]> nv-tegra.nvidia Code Review - linux-2.6.git/commitdiff
Merge branch 'for-linus' of git://oss.sgi.com:8090/xfs/xfs-2.6
authorLinus Torvalds <torvalds@woody.linux-foundation.org>
Fri, 19 Oct 2007 18:55:50 +0000 (11:55 -0700)
committerLinus Torvalds <torvalds@woody.linux-foundation.org>
Fri, 19 Oct 2007 18:55:50 +0000 (11:55 -0700)
* 'for-linus' of git://oss.sgi.com:8090/xfs/xfs-2.6:
  [XFS] cleanup fid types mess
  [XFS] fixups after behavior removal merge into mainline git

fs/xfs/linux-2.6/xfs_export.c
fs/xfs/linux-2.6/xfs_export.h
fs/xfs/linux-2.6/xfs_ioctl.c
fs/xfs/xfs_dmops.c
fs/xfs/xfs_fs.h
fs/xfs/xfs_qmops.c
fs/xfs/xfs_vfsops.c
fs/xfs/xfs_vfsops.h
fs/xfs/xfs_vnodeops.c
fs/xfs/xfs_vnodeops.h

index 726449d4fd223fc80817968e50c77d1e92f3977f..3586c7a28d2cb1cce5d631b2dd385a8144e3ea6e 100644 (file)
@@ -54,8 +54,8 @@ xfs_fs_decode_fh(
                struct dentry   *de),
        void                    *context)
 {
-       xfs_fid2_t              ifid;
-       xfs_fid2_t              pfid;
+       xfs_fid_t               ifid;
+       xfs_fid_t               pfid;
        void                    *parent = NULL;
        int                     is64 = 0;
        __u32                   *p = fh;
@@ -144,7 +144,7 @@ xfs_fs_get_dentry(
        struct dentry           *result;
        int                     error;
 
-       error = xfs_vget(XFS_M(sb), &vp, (fid_t *)data);
+       error = xfs_vget(XFS_M(sb), &vp, data);
        if (error || vp == NULL)
                return ERR_PTR(-ESTALE) ;
 
index e794ca4efc761b28edd3813f6c9dea16ca03d957..2f36071a86f76b289c4e5976405058bb26ac80b0 100644 (file)
@@ -71,13 +71,13 @@ xfs_fileid_length(int hasparent, int is64)
 
 /*
  * Decode encoded inode information (either for the inode itself
- * or the parent) into an xfs_fid2_t structure.  Advances and
+ * or the parent) into an xfs_fid_t structure.  Advances and
  * returns the new data pointer
  */
 static inline __u32 *
-xfs_fileid_decode_fid2(__u32 *p, xfs_fid2_t *fid, int is64)
+xfs_fileid_decode_fid2(__u32 *p, xfs_fid_t *fid, int is64)
 {
-       fid->fid_len = sizeof(xfs_fid2_t) - sizeof(fid->fid_len);
+       fid->fid_len = sizeof(xfs_fid_t) - sizeof(fid->fid_len);
        fid->fid_pad = 0;
        fid->fid_ino = *p++;
 #if XFS_BIG_INUMS
index ffec630e7db71743ecc2b63089992be081b8e830..2b34bad48b079c73da80bc47c696d92a51198bd4 100644 (file)
@@ -152,11 +152,11 @@ xfs_find_handle(
                lock_mode = xfs_ilock_map_shared(ip);
 
                /* fill in fid section of handle from inode */
-               handle.ha_fid.xfs_fid_len = sizeof(xfs_fid_t) -
-                                           sizeof(handle.ha_fid.xfs_fid_len);
-               handle.ha_fid.xfs_fid_pad = 0;
-               handle.ha_fid.xfs_fid_gen = ip->i_d.di_gen;
-               handle.ha_fid.xfs_fid_ino = ip->i_ino;
+               handle.ha_fid.fid_len = sizeof(xfs_fid_t) -
+                                       sizeof(handle.ha_fid.fid_len);
+               handle.ha_fid.fid_pad = 0;
+               handle.ha_fid.fid_gen = ip->i_d.di_gen;
+               handle.ha_fid.fid_ino = ip->i_ino;
 
                xfs_iunlock_map_shared(ip, lock_mode);
 
@@ -222,10 +222,10 @@ xfs_vget_fsop_handlereq(
        if (hlen < sizeof(*handlep))
                memset(((char *)handlep) + hlen, 0, sizeof(*handlep) - hlen);
        if (hlen > sizeof(handlep->ha_fsid)) {
-               if (handlep->ha_fid.xfs_fid_len !=
-                               (hlen - sizeof(handlep->ha_fsid)
-                                       - sizeof(handlep->ha_fid.xfs_fid_len))
-                   || handlep->ha_fid.xfs_fid_pad)
+               if (handlep->ha_fid.fid_len !=
+                   (hlen - sizeof(handlep->ha_fsid) -
+                           sizeof(handlep->ha_fid.fid_len)) ||
+                   handlep->ha_fid.fid_pad)
                        return XFS_ERROR(EINVAL);
        }
 
@@ -233,9 +233,9 @@ xfs_vget_fsop_handlereq(
         * Crack the handle, obtain the inode # & generation #
         */
        xfid = (struct xfs_fid *)&handlep->ha_fid;
-       if (xfid->xfs_fid_len == sizeof(*xfid) - sizeof(xfid->xfs_fid_len)) {
-               ino  = xfid->xfs_fid_ino;
-               igen = xfid->xfs_fid_gen;
+       if (xfid->fid_len == sizeof(*xfid) - sizeof(xfid->fid_len)) {
+               ino  = xfid->fid_ino;
+               igen = xfid->fid_gen;
        } else {
                return XFS_ERROR(EINVAL);
        }
index 6cd5704258a29f1584ec63faa9a7a000e71eb05e..a1e55fb9d5dde43c95565c1aece67d4345232391 100644 (file)
@@ -41,29 +41,16 @@ int
 xfs_dmops_get(struct xfs_mount *mp, struct xfs_mount_args *args)
 {
        if (args->flags & XFSMNT_DMAPI) {
-               struct xfs_dmops *ops;
-
-               ops = symbol_get(xfs_dmcore_xfs);
-               if (!ops) {
-                       request_module("xfs_dmapi");
-                       ops = symbol_get(xfs_dmcore_xfs);
-               }
-
-               if (!ops) {
-                       cmn_err(CE_WARN, "XFS: no dmapi support available.");
-                       return EINVAL;
-               }
-               mp->m_dm_ops = ops;
-       } else {
-               mp->m_dm_ops = &xfs_dmcore_stub;
+               cmn_err(CE_WARN,
+                       "XFS: dmapi support not available in this kernel.");
+               return EINVAL;
        }
 
+       mp->m_dm_ops = &xfs_dmcore_stub;
        return 0;
 }
 
 void
 xfs_dmops_put(struct xfs_mount *mp)
 {
-       if (mp->m_dm_ops != &xfs_dmcore_stub)
-               symbol_put(xfs_dmcore_xfs);
 }
index ec3c9c27e0de699fe66e6fc1aaf48428549b072b..aab9662765170b556bdf82cd623c2642dce8aa45 100644 (file)
@@ -389,30 +389,13 @@ typedef struct xfs_fsop_attrmulti_handlereq {
  */
 typedef struct { __u32 val[2]; } xfs_fsid_t; /* file system id type */
 
-
-#ifndef HAVE_FID
-#define MAXFIDSZ       46
-
-typedef struct fid {
-       __u16           fid_len;                /* length of data in bytes */
-       unsigned char   fid_data[MAXFIDSZ];     /* data (fid_len worth)  */
-} fid_t;
-#endif
-
 typedef struct xfs_fid {
-       __u16   xfs_fid_len;            /* length of remainder  */
-       __u16   xfs_fid_pad;
-       __u32   xfs_fid_gen;            /* generation number    */
-       __u64   xfs_fid_ino;            /* 64 bits inode number */
+       __u16   fid_len;                /* length of remainder  */
+       __u16   fid_pad;
+       __u32   fid_gen;                /* generation number    */
+       __u64   fid_ino;                /* 64 bits inode number */
 } xfs_fid_t;
 
-typedef struct xfs_fid2 {
-       __u16   fid_len;        /* length of remainder */
-       __u16   fid_pad;        /* padding, must be zero */
-       __u32   fid_gen;        /* generation number */
-       __u64   fid_ino;        /* inode number */
-} xfs_fid2_t;
-
 typedef struct xfs_handle {
        union {
                __s64       align;      /* force alignment of ha_fid     */
@@ -422,9 +405,9 @@ typedef struct xfs_handle {
 } xfs_handle_t;
 #define ha_fsid ha_u._ha_fsid
 
-#define XFS_HSIZE(handle)      (((char *) &(handle).ha_fid.xfs_fid_pad  \
+#define XFS_HSIZE(handle)      (((char *) &(handle).ha_fid.fid_pad      \
                                 - (char *) &(handle))                    \
-                                + (handle).ha_fid.xfs_fid_len)
+                                + (handle).ha_fid.fid_len)
 
 /*
  * Flags for going down operation
index c266a0184b42e2e38eac37059a1b8ee0997dd1ab..2ec1d8a27352e6a8595af8cbaecbfc9390e16cdd 100644 (file)
@@ -135,19 +135,13 @@ int
 xfs_qmops_get(struct xfs_mount *mp, struct xfs_mount_args *args)
 {
        if (args->flags & (XFSMNT_UQUOTA | XFSMNT_PQUOTA | XFSMNT_GQUOTA)) {
-               struct xfs_qmops *ops;
-
-               ops = symbol_get(xfs_qmcore_xfs);
-               if (!ops) {
-                       request_module("xfs_quota");
-                       ops = symbol_get(xfs_qmcore_xfs);
-               }
-
-               if (!ops) {
-                       cmn_err(CE_WARN, "XFS: no quota support available.");
-                       return EINVAL;
-               }
-               mp->m_qm_ops = ops;
+#ifdef CONFIG_XFS_QUOTA
+               mp->m_qm_ops = &xfs_qmcore_xfs;
+#else
+               cmn_err(CE_WARN,
+                       "XFS: qouta support not available in this kernel.");
+               return EINVAL;
+#endif
        } else {
                mp->m_qm_ops = &xfs_qmcore_stub;
        }
@@ -158,6 +152,4 @@ xfs_qmops_get(struct xfs_mount *mp, struct xfs_mount_args *args)
 void
 xfs_qmops_put(struct xfs_mount *mp)
 {
-       if (mp->m_qm_ops != &xfs_qmcore_stub)
-               symbol_put(xfs_qmcore_xfs);
 }
index a5a8454f2a631684de389d911a54055c5e64701a..a1544597bcd318c7f35a80551321c1f103b55f13 100644 (file)
@@ -1635,9 +1635,8 @@ int
 xfs_vget(
        xfs_mount_t     *mp,
        bhv_vnode_t     **vpp,
-       fid_t           *fidp)
+       xfs_fid_t       *xfid)
 {
-       xfs_fid_t       *xfid = (struct xfs_fid *)fidp;
        xfs_inode_t     *ip;
        int             error;
        xfs_ino_t       ino;
@@ -1647,11 +1646,11 @@ xfs_vget(
         * Invalid.  Since handles can be created in user space and passed in
         * via gethandle(), this is not cause for a panic.
         */
-       if (xfid->xfs_fid_len != sizeof(*xfid) - sizeof(xfid->xfs_fid_len))
+       if (xfid->fid_len != sizeof(*xfid) - sizeof(xfid->fid_len))
                return XFS_ERROR(EINVAL);
 
-       ino  = xfid->xfs_fid_ino;
-       igen = xfid->xfs_fid_gen;
+       ino  = xfid->fid_ino;
+       igen = xfid->fid_gen;
 
        /*
         * NFS can sometimes send requests for ino 0.  Fail them gracefully.
index bc99e3eb7dbba0291d139c4e0a6340e18f64b87b..a592fe02a3393367150447d4dae6af4ce36870dc 100644 (file)
@@ -2,7 +2,7 @@
 #define _XFS_VFSOPS_H 1
 
 struct cred;
-struct fid;
+struct xfs_fid;
 struct inode;
 struct kstatfs;
 struct xfs_mount;
@@ -17,7 +17,7 @@ int xfs_root(struct xfs_mount *mp, bhv_vnode_t **vpp);
 int xfs_statvfs(struct xfs_mount *mp, struct kstatfs *statp,
                bhv_vnode_t *vp);
 int xfs_sync(struct xfs_mount *mp, int flags);
-int xfs_vget(struct xfs_mount *mp, bhv_vnode_t **vpp, struct fid *fidp);
+int xfs_vget(struct xfs_mount *mp, bhv_vnode_t **vpp, struct xfs_fid *xfid);
 int xfs_parseargs(struct xfs_mount *mp, char *options,
                struct xfs_mount_args *args, int update);
 int xfs_showargs(struct xfs_mount *mp, struct seq_file *m);
index 5e3c57ca9981e6573b4a968e91f3a18e8ee68b42..efd5aff9eaf6aa1d149fa6431ca6355e944c5b1a 100644 (file)
@@ -3466,23 +3466,14 @@ std_return:
 }
 
 
-/*
- * xfs_fid2
- *
- * A fid routine that takes a pointer to a previously allocated
- * fid structure (like xfs_fast_fid) but uses a 64 bit inode number.
- */
 int
 xfs_fid2(
        xfs_inode_t     *ip,
-       fid_t           *fidp)
+       xfs_fid_t       *xfid)
 {
-       xfs_fid2_t      *xfid = (xfs_fid2_t *)fidp;
-
        vn_trace_entry(ip, __FUNCTION__, (inst_t *)__return_address);
-       ASSERT(sizeof(fid_t) >= sizeof(xfs_fid2_t));
 
-       xfid->fid_len = sizeof(xfs_fid2_t) - sizeof(xfid->fid_len);
+       xfid->fid_len = sizeof(xfs_fid_t) - sizeof(xfid->fid_len);
        xfid->fid_pad = 0;
        /*
         * use memcpy because the inode is a long long and there's no
index f36e74f2f0c2a18719fcaca6b585fefe97ce940a..b7e461c40cfbace8e0289ab1d131a67f8b813a86 100644 (file)
@@ -39,7 +39,7 @@ int xfs_readdir(struct xfs_inode      *dp, void *dirent, size_t bufsize,
 int xfs_symlink(struct xfs_inode *dp, bhv_vname_t *dentry,
                char *target_path, mode_t mode, bhv_vnode_t **vpp,
                struct cred *credp);
-int xfs_fid2(struct xfs_inode *ip, fid_t       *fidp);
+int xfs_fid2(struct xfs_inode *ip, struct xfs_fid *xfid);
 int xfs_rwlock(struct xfs_inode *ip, bhv_vrwlock_t locktype);
 void xfs_rwunlock(struct xfs_inode *ip, bhv_vrwlock_t locktype);
 int xfs_inode_flush(struct xfs_inode *ip, int flags);