/*      $NetBSD: hfs_vfsops.c,v 1.38 2022/03/19 13:53:32 hannken Exp $  */

/*-
* Copyright (c) 2005, 2007 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Yevgeny Binder and Dieter Baron.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/

/*
* Copyright (c) 1991, 1993, 1994
*      The Regents of the University of California.  All rights reserved.
* (c) UNIX System Laboratories, Inc.
* All or some portions of this file are derived from material licensed
* to the University of California by American Telephone and Telegraph
* Co. or Unix System Laboratories, Inc. and are reproduced herein with
* the permission of UNIX System Laboratories, Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
*    may be used to endorse or promote products derived from this software
*    without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/

/*
* Copyright (c) 1989, 1991, 1993, 1994
*      The Regents of the University of California.  All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
*    may be used to endorse or promote products derived from this software
*    without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/



/*
* Apple HFS+ filesystem
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: hfs_vfsops.c,v 1.38 2022/03/19 13:53:32 hannken Exp $");

#ifdef _KERNEL_OPT
#include "opt_compat_netbsd.h"
#endif

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/namei.h>
#include <sys/proc.h>
#include <sys/kernel.h>
#include <sys/vnode.h>
#include <sys/socket.h>
#include <sys/mount.h>
#include <sys/buf.h>
#include <sys/device.h>
#include <sys/file.h>
#include <sys/disklabel.h>
#include <sys/ioctl.h>
#include <sys/errno.h>
#include <sys/malloc.h>
#include <sys/pool.h>
#include <sys/lock.h>
#include <sys/sysctl.h>
#include <sys/conf.h>
#include <sys/kauth.h>
#include <sys/stat.h>
#include <sys/module.h>

#include <miscfs/genfs/genfs.h>
#include <miscfs/specfs/specdev.h>

#include <fs/hfs/hfs.h>
#include <fs/hfs/libhfs.h>

MODULE(MODULE_CLASS_VFS, hfs, NULL);

MALLOC_JUSTDEFINE(M_HFSMNT, "hfs mount", "hfs mount structures");

struct pool hfs_node_pool;

const struct vnodeopv_desc * const hfs_vnodeopv_descs[] = {
       &hfs_vnodeop_opv_desc,
       &hfs_specop_opv_desc,
       &hfs_fifoop_opv_desc,
       NULL,
};

struct vfsops hfs_vfsops = {
       .vfs_name = MOUNT_HFS,
       .vfs_min_mount_data = sizeof (struct hfs_args),
       .vfs_mount = hfs_mount,
       .vfs_start = hfs_start,
       .vfs_unmount = hfs_unmount,
       .vfs_root = hfs_root,
       .vfs_quotactl = (void *)eopnotsupp,
       .vfs_statvfs = hfs_statvfs,
       .vfs_sync = hfs_sync,
       .vfs_vget = hfs_vget,
       .vfs_loadvnode = hfs_loadvnode,
       .vfs_fhtovp = hfs_fhtovp,
       .vfs_vptofh = hfs_vptofh,
       .vfs_init = hfs_init,
       .vfs_reinit = hfs_reinit,
       .vfs_done = hfs_done,
       .vfs_extattrctl = vfs_stdextattrctl,
       .vfs_suspendctl = genfs_suspendctl,
       .vfs_renamelock_enter = genfs_renamelock_enter,
       .vfs_renamelock_exit = genfs_renamelock_exit,
       .vfs_fsync = (void *)eopnotsupp,
       .vfs_opv_descs = hfs_vnodeopv_descs
};

static const struct genfs_ops hfs_genfsops = {
       .gop_size = genfs_size,
};

static int
hfs_modcmd(modcmd_t cmd, void *arg)
{
       switch (cmd) {
       case MODULE_CMD_INIT:
               return vfs_attach(&hfs_vfsops);
       case MODULE_CMD_FINI:
               return vfs_detach(&hfs_vfsops);
       default:
               return ENOTTY;
       }
}

int
hfs_mount(struct mount *mp, const char *path, void *data, size_t *data_len)
{
       struct lwp *l = curlwp;
       struct hfs_args *args = data;
       struct vnode *devvp;
       struct hfsmount *hmp;
       int error = 0;
       int update;
       mode_t accessmode;

       if (args == NULL)
               return EINVAL;
       if (*data_len < sizeof *args)
               return EINVAL;

#ifdef HFS_DEBUG
       printf("vfsop = hfs_mount()\n");
#endif /* HFS_DEBUG */

       if (mp->mnt_flag & MNT_GETARGS) {
               hmp = VFSTOHFS(mp);
               if (hmp == NULL)
                       return EIO;
               args->fspec = NULL;
               *data_len = sizeof *args;
               return 0;
       }

/* FIXME: For development ONLY - disallow remounting for now */
#if 0
       update = mp->mnt_flag & MNT_UPDATE;
#else
       update = 0;
#endif

       /* Check arguments */
       if (args->fspec != NULL) {
               /*
                * Look up the name and verify that it's sane.
                */
               error = namei_simple_user(args->fspec,
                                       NSM_FOLLOW_NOEMULROOT, &devvp);
               if (error != 0)
                       return error;

               if (!update) {
                       /*
                        * Be sure this is a valid block device
                        */
                       if (devvp->v_type != VBLK)
                               error = ENOTBLK;
                       else if (bdevsw_lookup(devvp->v_rdev) == NULL)
                               error = ENXIO;
               } else {
                       /*
                        * Be sure we're still naming the same device
                        * used for our initial mount
                        */
                       hmp = VFSTOHFS(mp);
                       if (devvp != hmp->hm_devvp)
                               error = EINVAL;
               }
       } else {
               if (update) {
                       /* Use the extant mount */
                       hmp = VFSTOHFS(mp);
                       devvp = hmp->hm_devvp;
                       vref(devvp);
               } else {
                       /* New mounts must have a filename for the device */
                       return EINVAL;
               }
       }

       /*
        * If mount by non-root, then verify that user has necessary
        * permissions on the device.
        *
        * Permission to update a mount is checked higher, so here we presume
        * updating the mount is okay (for example, as far as securelevel goes)
        * which leaves us with the normal check.
        */
       if (error == 0) {
               accessmode = VREAD;
               if (update ?
                       (mp->mnt_iflag & IMNT_WANTRDWR) != 0 :
                       (mp->mnt_flag & MNT_RDONLY) == 0)
                       accessmode |= VWRITE;
               vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
               error = kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_MOUNT,
                   KAUTH_REQ_SYSTEM_MOUNT_DEVICE, mp, devvp,
                   KAUTH_ARG(accessmode));
               VOP_UNLOCK(devvp);
       }

       if (error != 0)
               goto error;

       if (update) {
               printf("HFS: live remounting not yet supported!\n");
               error = EINVAL;
               goto error;
       }

       if ((error = hfs_mountfs(devvp, mp, l, args->fspec)) != 0)
               goto error;

       error = set_statvfs_info(path, UIO_USERSPACE, args->fspec, UIO_USERSPACE,
               mp->mnt_op->vfs_name, mp, l);

#ifdef HFS_DEBUG
       if(!update) {
               char* volname;

               hmp = VFSTOHFS(mp);
               volname = malloc(hmp->hm_vol.name.length + 1, M_TEMP, M_WAITOK);
               if (volname == NULL)
                       printf("could not allocate volname; ignored\n");
               else {
                       if (hfs_unicode_to_ascii(hmp->hm_vol.name.unicode,
                               hmp->hm_vol.name.length, volname) == NULL)
                               printf("could not convert volume name to ascii; ignored\n");
                       else
                               printf("mounted volume \"%s\"\n", volname);
                       free(volname, M_TEMP);
               }
       }
#endif /* HFS_DEBUG */

       return error;

error:
       vrele(devvp);
       return error;
}

int
hfs_start(struct mount *mp, int flags)
{
#ifdef HFS_DEBUG
       printf("vfsop = hfs_start()\n");
#endif /* HFS_DEBUG */

       return 0;
}

int
hfs_mountfs(struct vnode *devvp, struct mount *mp, struct lwp *l,
   const char *devpath)
{
       hfs_callback_args cbargs;
       hfs_libcb_argsopen argsopen;
       hfs_libcb_argsread argsread;
       struct hfsmount *hmp;
       kauth_cred_t cred;
       int error;

       cred = l ? l->l_cred : NOCRED;
       error = 0;
       hmp = NULL;

       /* Create mounted volume structure. */
       hmp = malloc(sizeof(struct hfsmount), M_HFSMNT, M_WAITOK|M_ZERO);
       if (hmp == NULL) {
               error = ENOMEM;
               goto error;
       }

       mp->mnt_data = hmp;
       mp->mnt_flag |= MNT_LOCAL;
       vfs_getnewfsid(mp);

       hmp->hm_mountp = mp;
       hmp->hm_dev = devvp->v_rdev;
       hmp->hm_devvp = devvp;

       /*
        * Use libhfs to open the volume and read the volume header and other
        * useful information.
        */

       hfslib_init_cbargs(&cbargs);
       argsopen.cred = argsread.cred = cred;
       argsopen.l = argsread.l = l;
       argsopen.devvp = devvp;
       cbargs.read = (void*)&argsread;
       cbargs.openvol = (void*)&argsopen;

       if ((error = hfslib_open_volume(devpath, mp->mnt_flag & MNT_RDONLY,
               &hmp->hm_vol, &cbargs)) != 0)
               goto error;

       /* Make sure this is not a journaled volume whose journal is dirty. */
       if (!hfslib_is_journal_clean(&hmp->hm_vol)) {
               printf("volume journal is dirty; not mounting\n");
               error = EIO;
               goto error;
       }

       mp->mnt_fs_bshift = 0;
       while ((1 << mp->mnt_fs_bshift) < hmp->hm_vol.vh.block_size)
               mp->mnt_fs_bshift++;
       mp->mnt_dev_bshift = DEV_BSHIFT;

       return 0;

error:
       if (hmp != NULL)
               free(hmp, M_HFSMNT);
       return error;
}

int
hfs_unmount(struct mount *mp, int mntflags)
{
       hfs_callback_args cbargs;
       hfs_libcb_argsread argsclose;
       struct hfsmount* hmp;
       int error;
       int flags;

#ifdef HFS_DEBUG
       printf("vfsop = hfs_unmount()\n");
#endif /* HFS_DEBUG */

       hmp = VFSTOHFS(mp);

       flags = 0;
       if (mntflags & MNT_FORCE)
               flags |= FORCECLOSE;

       if ((error = vflush(mp, NULLVP, flags)) != 0)
               return error;

       hfslib_init_cbargs(&cbargs);
       argsclose.l = curlwp;
       cbargs.closevol = (void*)&argsclose;
       hfslib_close_volume(&hmp->hm_vol, &cbargs);

       vrele(hmp->hm_devvp);

       free(hmp, M_HFSMNT);
       mp->mnt_data = NULL;
       mp->mnt_flag &= ~MNT_LOCAL;

       return error;
}

int
hfs_root(struct mount *mp, int lktype, struct vnode **vpp)
{
       struct vnode *nvp;
       int error;

#ifdef HFS_DEBUG
       printf("vfsop = hfs_root()\n");
#endif /* HFS_DEBUG */

       if ((error = VFS_VGET(mp, HFS_CNID_ROOT_FOLDER, lktype, &nvp)) != 0)
               return error;
       *vpp = nvp;

       return 0;
}

int
hfs_statvfs(struct mount *mp, struct statvfs *sbp)
{
       hfs_volume_header_t *vh;

#ifdef HFS_DEBUG
       printf("vfsop = hfs_statvfs()\n");
#endif /* HFS_DEBUG */

       vh = &VFSTOHFS(mp)->hm_vol.vh;

       sbp->f_bsize = vh->block_size;
       sbp->f_frsize = sbp->f_bsize;
       sbp->f_iosize = 4096;/* mac os x uses a 4 kb io size, so do the same */
       sbp->f_blocks = vh->total_blocks;
       sbp->f_bfree = vh->free_blocks; /* total free blocks */
       sbp->f_bavail = vh->free_blocks; /* blocks free for non superuser */
       sbp->f_bresvd = 0;
       sbp->f_files =  vh->file_count; /* total files */
       sbp->f_ffree = (1U<<31) - vh->file_count; /* free file nodes */
       copy_statvfs_info(sbp, mp);

       return 0;
}

int
hfs_sync(struct mount *mp, int waitfor, kauth_cred_t cred)
{
#ifdef HFS_DEBUG
       printf("vfsop = hfs_sync()\n");
#endif /* HFS_DEBUG */

       return 0;
}

/*
* an ino_t corresponds directly to a CNID in our particular case,
* since both are conveniently 32-bit numbers
*/
int
hfs_vget(struct mount *mp, ino_t ino, int lktype, struct vnode **vpp)
{
       int error;

       error = hfs_vget_internal(mp, ino, HFS_DATAFORK, vpp);
       if (error)
               return error;
       error = vn_lock(*vpp, lktype);
       if (error) {
               vrele(*vpp);
               *vpp = NULL;
               return error;
       }
       return 0;
}

/*
* internal version with extra arguments to allow accessing resource fork
*/
int
hfs_vget_internal(struct mount *mp, ino_t ino, uint8_t fork,
   struct vnode **vpp)
{
       struct hfsnode_key key;

       memset(&key, 0, sizeof(key));
       key.hnk_cnid = (hfs_cnid_t)ino;
       key.hnk_fork = (fork != HFS_RSRCFORK ? HFS_DATAFORK : HFS_RSRCFORK);

       return vcache_get(mp, &key, sizeof(key), vpp);
}

int
hfs_loadvnode(struct mount *mp, struct vnode *vp,
   const void *key, size_t key_len, const void **new_key)
{
       struct hfsmount *hmp;
       struct hfsnode *hnode;
       struct hfsnode_key hfskey;
       hfs_callback_args cbargs;
       hfs_catalog_keyed_record_t rec;
       hfs_catalog_key_t cat_key; /* the search key used to find this file on disk */
       dev_t dev;

#ifdef HFS_DEBUG
       printf("vfsop = hfs_loadvnode()\n");
#endif /* HFS_DEBUG */

       KASSERT(key_len == sizeof(hfskey));
       memcpy(&hfskey, key, key_len);

       hmp = VFSTOHFS(mp);
       dev = hmp->hm_dev;

       hnode = pool_get(&hfs_node_pool, PR_WAITOK);
       memset(hnode, 0, sizeof(*hnode));
       hnode->h_vnode = vp;
       hnode->h_hmp = hmp;
       hnode->dummy = 0x1337BABE;
       hnode->h_dev = dev;
       hnode->h_rec.u.cnid = hfskey.hnk_cnid;
       hnode->h_fork = hfskey.hnk_fork;
       hnode->h_key = hfskey;

       /*
        * Read catalog record from disk.
        */
       hfslib_init_cbargs(&cbargs);

       if (hfslib_find_catalog_record_with_cnid(&hmp->hm_vol, hfskey.hnk_cnid,
               &rec, &cat_key, &cbargs) != 0) {
               pool_put(&hfs_node_pool, hnode);
               return EBADF;
       }

       memcpy(&hnode->h_rec, &rec, sizeof(hnode->h_rec));
       hnode->h_parent = cat_key.parent_cnid;

       /* XXX Eventually need to add an "ignore permissions" mount option */

       /*
        * Now convert some of the catalog record's fields into values that make
        * sense on this system.
        */
       /* DATE AND TIME */

       vp->v_tag = VT_HFS;
       vp->v_op = hfs_vnodeop_p;
       vp->v_data = hnode;
       genfs_node_init(vp, &hfs_genfsops);

       /*
        * Initialize the vnode from the hfsnode, check for aliases.
        */
       hfs_vinit(mp, hfs_specop_p, hfs_fifoop_p, &vp);

       hnode->h_devvp = hmp->hm_devvp;
       vref(hnode->h_devvp);  /* Increment the ref count to the volume's device. */

       /* Make sure UVM has allocated enough memory. (?) */
       if (hnode->h_rec.u.rec_type == HFS_REC_FILE) {
               if (hnode->h_fork == HFS_DATAFORK)
                       uvm_vnp_setsize(vp,
                           hnode->h_rec.file.data_fork.logical_size);
               else
                       uvm_vnp_setsize(vp,
                           hnode->h_rec.file.rsrc_fork.logical_size);
       }
       else
               uvm_vnp_setsize(vp, 0); /* no directly reading directories */

       *new_key = &hnode->h_key;
       return 0;
}

int
hfs_fhtovp(struct mount *mp, struct fid *fhp, int lktype, struct vnode **vpp)
{

#ifdef HFS_DEBUG
       printf("vfsop = hfs_fhtovp()\n");
#endif /* HFS_DEBUG */

       return EOPNOTSUPP;
}

int
hfs_vptofh(struct vnode *vp, struct fid *fhp, size_t *fh_size)
{
#ifdef HFS_DEBUG
       printf("vfsop = hfs_vptofh()\n");
#endif /* HFS_DEBUG */

       return EOPNOTSUPP;
}

void
hfs_init(void)
{
       hfs_callbacks   callbacks;

#ifdef HFS_DEBUG
       printf("vfsop = hfs_init()\n");
#endif /* HFS_DEBUG */

       malloc_type_attach(M_HFSMNT);
       pool_init(&hfs_node_pool, sizeof(struct hfsnode), 0, 0, 0, "hfsndpl",
           &pool_allocator_nointr, IPL_NONE);

       callbacks.error = hfs_libcb_error;
       callbacks.allocmem = hfs_libcb_malloc;
       callbacks.reallocmem = hfs_libcb_realloc;
       callbacks.freemem = hfs_libcb_free;
       callbacks.openvol = hfs_libcb_opendev;
       callbacks.closevol = hfs_libcb_closedev;
       callbacks.read = hfs_libcb_read;

       hfslib_init(&callbacks);
}

void
hfs_reinit(void)
{
#ifdef HFS_DEBUG
       printf("vfsop = hfs_reinit()\n");
#endif /* HFS_DEBUG */

       return;
}

void
hfs_done(void)
{
#ifdef HFS_DEBUG
       printf("vfsop = hfs_done()\n");
#endif /* HFS_DEBUG */

       malloc_type_detach(M_HFSMNT);
       pool_destroy(&hfs_node_pool);
       hfslib_done();
}

int
hfs_mountroot(void)
{
#ifdef HFS_DEBUG
       printf("vfsop = hfs_mountroot()\n");
#endif /* HFS_DEBUG */

       return EOPNOTSUPP;
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.