Change the kernel dev_t, representing a pointer to a specinfo structure,
[dragonfly.git] / sys / vfs / udf / udf_vfsops.c
index 3ba8222..c02ab3a 100644 (file)
@@ -24,7 +24,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/fs/udf/udf_vfsops.c,v 1.16 2003/11/05 06:56:08 scottl Exp $
- * $DragonFly: src/sys/vfs/udf/udf_vfsops.c,v 1.10 2004/11/12 00:09:51 dillon Exp $
+ * $DragonFly: src/sys/vfs/udf/udf_vfsops.c,v 1.23 2006/09/10 01:26:41 dillon Exp $
  */
 
 /* udf_vfsops.c */
@@ -78,7 +78,6 @@
 #include <sys/uio.h>
 #include <sys/buf.h>
 #include <sys/conf.h>
-#include <sys/dirent.h>
 #include <sys/fcntl.h>
 #include <sys/module.h>
 #include <sys/kernel.h>
 #include <vfs/udf/udf.h>
 #include <vfs/udf/udf_mount.h>
 
-extern struct vnodeopv_entry_desc udf_vnodeop_entries[];
+extern struct vop_ops udf_vnode_vops;
 
 MALLOC_DEFINE(M_UDFNODE, "UDF node", "UDF node structure");
 MALLOC_DEFINE(M_UDFMOUNT, "UDF mount", "UDF mount structure");
 MALLOC_DEFINE(M_UDFFENTRY, "UDF fentry", "UDF file entry structure");
 
-static int udf_mount(struct mount *, char *, caddr_t, struct thread *);
-static int udf_unmount(struct mount *, int, struct thread *);
+static int udf_mount(struct mount *, char *, caddr_t, struct ucred *);
+static int udf_unmount(struct mount *, int);
 static int udf_root(struct mount *, struct vnode **);
-static int udf_statfs(struct mount *, struct statfs *, struct thread *);
+static int udf_statfs(struct mount *, struct statfs *, struct ucred *);
 static int udf_fhtovp(struct mount *, struct fid *, struct vnode **);
 static int udf_vptofh(struct vnode *, struct fid *);
 
 static int udf_find_partmaps(struct udf_mnt *, struct logvol_desc *);
 
 static struct vfsops udf_vfsops = {
-       udf_mount,
-       vfs_stdstart,
-       udf_unmount,
-       udf_root,
-       vfs_stdquotactl,
-       udf_statfs,
-       vfs_stdsync,
-       udf_vget,
-       udf_fhtovp,
-       vfs_stdcheckexp,
-       udf_vptofh,
-       vfs_stdinit,
-       vfs_stduninit,
-       vfs_stdextattrctl,
+       .vfs_mount =            udf_mount,
+       .vfs_unmount =          udf_unmount,
+       .vfs_root =             udf_root,
+       .vfs_statfs =           udf_statfs,
+       .vfs_sync =             vfs_stdsync,
+       .vfs_vget =             udf_vget,
+       .vfs_fhtovp =           udf_fhtovp,
+       .vfs_vptofh =           udf_vptofh
 };
 VFS_SET(udf_vfsops, udf, VFCF_READONLY);
 
 MODULE_VERSION(udf, 1);
 
-static int udf_mountfs(struct vnode *, struct mount *, struct thread *);
+static int udf_mountfs(struct vnode *, struct mount *);
 
 static int
-udf_mount(struct mount *mp, char *path, caddr_t data, struct thread *td)
+udf_mount(struct mount *mp, char *path, caddr_t data, struct ucred *cred)
 {
        struct vnode *devvp;    /* vnode of the mount device */
        struct udf_args args;
@@ -177,17 +170,17 @@ udf_mount(struct mount *mp, char *path, caddr_t data, struct thread *td)
        }
 
        /* Check the access rights on the mount device */
-       vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td);
-       error = VOP_ACCESS(devvp, VREAD, td->td_proc->p_ucred, td);
+       vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
+       error = VOP_ACCESS(devvp, VREAD, cred);
        if (error)
-               error = suser(td);
+               error = suser_cred(cred, 0);
        if (error) {
                vput(devvp);
                return(error);
        }
-       VOP_UNLOCK(devvp, 0, td);
+       vn_unlock(devvp);
 
-       if ((error = udf_mountfs(devvp, mp, td))) {
+       if ((error = udf_mountfs(devvp, mp))) {
                vrele(devvp);
                return(error);
        }
@@ -196,11 +189,9 @@ udf_mount(struct mount *mp, char *path, caddr_t data, struct thread *td)
 
        imp->im_flags = args.flags;
 
-       copyinstr(path, mp->mnt_stat.f_mntonname, MNAMELEN - 1, &size);
-       bzero(mp->mnt_stat.f_mntonname + size, MNAMELEN - size);
        copyinstr(args.fspec, mp->mnt_stat.f_mntfromname, MNAMELEN - 1, &size);
        bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
-       udf_statfs(mp, &mp->mnt_stat, td);
+       udf_statfs(mp, &mp->mnt_stat, cred);
        return(0);
 }
 
@@ -230,7 +221,7 @@ udf_checktag(struct desc_tag *tag, uint16_t id)
 }
 
 static int
-udf_mountfs(struct vnode *devvp, struct mount *mp, struct thread *td) 
+udf_mountfs(struct vnode *devvp, struct mount *mp)
 {
        struct buf *bp = NULL;
        struct anchor_vdp avdp;
@@ -239,7 +230,7 @@ udf_mountfs(struct vnode *devvp, struct mount *mp, struct thread *td)
        struct logvol_desc *lvd;
        struct fileset_desc *fsd;
        struct file_entry *root_fentry;
-       dev_t dev;
+       cdev_t dev;
        uint32_t sector, size, mvds_start, mvds_end;
        uint32_t fsd_offset = 0;
        uint16_t part_num = 0, fsd_part = 0;
@@ -255,18 +246,18 @@ udf_mountfs(struct vnode *devvp, struct mount *mp, struct thread *td)
                return(error);
        if (count_udev(devvp->v_udev) > 0)
                return(EBUSY);
-       if ((error = vinvalbuf(devvp, V_SAVE, td, 0, 0)))
+       if ((error = vinvalbuf(devvp, V_SAVE, 0, 0)))
                return(error);
 
-       vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td);
-       error = VOP_OPEN(devvp, FREAD, FSCRED, NULL, td);
-       VOP_UNLOCK(devvp, 0, td);
+       vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
+       error = VOP_OPEN(devvp, FREAD, FSCRED, NULL);
+       vn_unlock(devvp);
        if (error)
                return(error);
        needclose = 1;
        dev = devvp->v_rdev;
 
-       udfmp = malloc(sizeof(*udfmp), M_UDFMOUNT, M_WAITOK | M_ZERO);
+       udfmp = kmalloc(sizeof(*udfmp), M_UDFMOUNT, M_WAITOK | M_ZERO);
 
        mp->mnt_data = (qaddr_t)udfmp;
        mp->mnt_stat.f_fsid.val[0] = dev2udev(dev);
@@ -284,7 +275,7 @@ udf_mountfs(struct vnode *devvp, struct mount *mp, struct thread *td)
         * XXX Should also check sector n - 256, n, and 512.
         */
        sector = 256;
-       if ((error = bread(devvp, sector * btodb(bsize), bsize, &bp)) != 0)
+       if ((error = bread(devvp, (off_t)sector * bsize, bsize, &bp)) != 0)
                goto bail;
        if ((error = udf_checktag((struct desc_tag *)bp->b_data, TAGID_ANCHOR)))
                goto bail;
@@ -302,7 +293,7 @@ udf_mountfs(struct vnode *devvp, struct mount *mp, struct thread *td)
        mvds_start = avdp.main_vds_ex.loc;
        mvds_end = mvds_start + (avdp.main_vds_ex.len - 1) / bsize;
        for (sector = mvds_start; sector < mvds_end; sector++) {
-               if ((error = bread(devvp, sector * btodb(bsize), bsize,
+               if ((error = bread(devvp, (off_t)sector * bsize, bsize,
                                   &bp)) != 0) {
                        printf("Can't read sector %d of VDS\n", sector);
                        goto bail;
@@ -370,7 +361,7 @@ udf_mountfs(struct vnode *devvp, struct mount *mp, struct thread *td)
                goto bail;
        } 
 
-       vfs_add_vnodeops(&mp->mnt_vn_ops, udf_vnodeop_entries);
+       vfs_add_vnodeops(mp, &udf_vnode_vops, &mp->mnt_vn_norm_ops);
 
        /*
         * Find the file entry for the root directory.
@@ -398,16 +389,16 @@ udf_mountfs(struct vnode *devvp, struct mount *mp, struct thread *td)
 
 bail:
        if (udfmp != NULL)
-               free(udfmp, M_UDFMOUNT);
+               kfree(udfmp, M_UDFMOUNT);
        if (bp != NULL)
                brelse(bp);
        if (needclose)
-               VOP_CLOSE(devvp, FREAD, td);
+               VOP_CLOSE(devvp, FREAD);
        return(error);
 }
 
 static int
-udf_unmount(struct mount *mp, int mntflags, struct thread *td)
+udf_unmount(struct mount *mp, int mntflags)
 {
        struct udf_mnt *udfmp;
        int error, flags = 0;
@@ -421,14 +412,14 @@ udf_unmount(struct mount *mp, int mntflags, struct thread *td)
                return (error);
 
        udfmp->im_devvp->v_rdev->si_mountpoint = NULL;
-       error = VOP_CLOSE(udfmp->im_devvp, FREAD, td);
+       error = VOP_CLOSE(udfmp->im_devvp, FREAD);
        vrele(udfmp->im_devvp);
 
        if (udfmp->s_table)
-               free(udfmp->s_table, M_UDFMOUNT);
+               kfree(udfmp->s_table, M_UDFMOUNT);
        if (udfmp->hashtbl)
-               free(udfmp->hashtbl, M_UDFMOUNT);
-       free(udfmp, M_UDFMOUNT);
+               kfree(udfmp->hashtbl, M_UDFMOUNT);
+       kfree(udfmp, M_UDFMOUNT);
 
        mp->mnt_data = (qaddr_t)0;
        mp->mnt_flag &= ~MNT_LOCAL;
@@ -460,7 +451,7 @@ udf_root(struct mount *mp, struct vnode **vpp)
 }
 
 static int
-udf_statfs(struct mount *mp, struct statfs *sbp, struct thread *td)
+udf_statfs(struct mount *mp, struct statfs *sbp, struct ucred *cred)
 {
        struct udf_mnt *udfmp;
 
@@ -475,7 +466,6 @@ udf_statfs(struct mount *mp, struct statfs *sbp, struct thread *td)
        sbp->f_ffree = 0;
        if (sbp != &mp->mnt_stat) {
                sbp->f_type = mp->mnt_vfc->vfc_typenum;
-               bcopy(mp->mnt_stat.f_mntonname, sbp->f_mntonname, MNAMELEN);
                bcopy(mp->mnt_stat.f_mntfromname, sbp->f_mntfromname, MNAMELEN);
        }
 
@@ -508,7 +498,7 @@ udf_vget(struct mount *mp, ino_t ino, struct vnode **vpp)
         * Allocate memory and check the tag id's before grabbing a new
         * vnode, since it's hard to roll back if there is a problem.
         */
-       unode = malloc(sizeof(*unode), M_UDFNODE, M_WAITOK | M_ZERO);
+       unode = kmalloc(sizeof(*unode), M_UDFNODE, M_WAITOK | M_ZERO);
 
        /*
         * Copy in the file entry.  Per the spec, the size can only be 1 block.
@@ -517,19 +507,19 @@ udf_vget(struct mount *mp, ino_t ino, struct vnode **vpp)
        devvp = udfmp->im_devvp;
        if ((error = RDSECTOR(devvp, sector, udfmp->bsize, &bp)) != 0) {
                printf("Cannot read sector %d\n", sector);
-               free(unode, M_UDFNODE);
+               kfree(unode, M_UDFNODE);
                return(error);
        }
 
        fe = (struct file_entry *)bp->b_data;
        if (udf_checktag(&fe->tag, TAGID_FENTRY)) {
                printf("Invalid file entry!\n");
-               free(unode, M_UDFNODE);
+               kfree(unode, M_UDFNODE);
                brelse(bp);
                return(ENOMEM);
        }
        size = UDF_FENTRY_SIZE + fe->l_ea + fe->l_ad;
-       unode->fentry = malloc(size, M_UDFFENTRY, M_WAITOK | M_ZERO);
+       unode->fentry = kmalloc(size, M_UDFFENTRY, M_WAITOK | M_ZERO);
 
        bcopy(bp->b_data, unode->fentry, size);
        
@@ -538,7 +528,7 @@ udf_vget(struct mount *mp, ino_t ino, struct vnode **vpp)
 
        if ((error = udf_allocv(mp, &vp))) {
                printf("Error from udf_allocv\n");
-               free(unode, M_UDFNODE);
+               kfree(unode, M_UDFNODE);
                return(error);
        }
 
@@ -662,7 +652,7 @@ udf_find_partmaps(struct udf_mnt *udfmp, struct logvol_desc *lvd)
                }
 
                pms = &pmap->pms;
-               udfmp->s_table = malloc(pms->st_size, M_UDFMOUNT,
+               udfmp->s_table = kmalloc(pms->st_size, M_UDFMOUNT,
                                        M_WAITOK | M_ZERO);
                if (udfmp->s_table == NULL)
                        return(ENOMEM);