NFSD: simplify struct nfsfh

Most of the fields in 'struct knfsd_fh' are 2 levels deep (a union and a
struct) and are accessed using macros like:

 #define fh_FOO fh_base.fh_new.fb_FOO

This patch makes the union and struct anonymous, so that "fh_FOO" can be
a name directly within 'struct knfsd_fh' and the #defines aren't needed.

The file handle as a whole is sometimes accessed as "fh_base" or
"fh_base.fh_pad", neither of which are particularly helpful names.
As the struct holding the filehandle is now anonymous, we
cannot use the name of that, so we union it with 'fh_raw' and use that
where the raw filehandle is needed.  fh_raw also ensure the structure is
large enough for the largest possible filehandle.

fh_raw is a 'char' array, removing any need to cast it for memcpy etc.

SVCFH_fmt() is simplified using the "%ph" printk format.  This
changes the appearance of filehandles in dprintk() debugging, making
them a little more precise.

Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: NeilBrown <neilb@suse.de>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>

diff --git a/fs/nfsd/flexfilelayout.c b/fs/nfsd/flexfilelayout.c
index db7ef07ae50c9bfbf4396559cabff576a6eb56df..2e2f1d5e9f623cf25cad07e0dfba768f60d6e431 100644 (file)
--- a/fs/nfsd/flexfilelayout.c
+++ b/fs/nfsd/flexfilelayout.c
@@ -61,7 +61,7 @@ nfsd4_ff_proc_layoutget(struct inode *inode, const struct svc_fh *fhp,
                goto out_error;
 
        fl->fh.size = fhp->fh_handle.fh_size;
-       memcpy(fl->fh.data, &fhp->fh_handle.fh_base, fl->fh.size);
+       memcpy(fl->fh.data, &fhp->fh_handle.fh_raw, fl->fh.size);
 
        /* Give whole file layout segments */
        seg->offset = 0;

diff --git a/fs/nfsd/lockd.c b/fs/nfsd/lockd.c
index 606fa155c28adf524cd8e447b42a06dee89dd375..46a7f9b813e527707f305ab85ee8e97e8564edec 100644 (file)
--- a/fs/nfsd/lockd.c
+++ b/fs/nfsd/lockd.c
@@ -35,7 +35,7 @@ nlm_fopen(struct svc_rqst *rqstp, struct nfs_fh *f, struct file **filp,
        /* must initialize before using! but maxsize doesn't matter */
        fh_init(&fh,0);
        fh.fh_handle.fh_size = f->size;
-       memcpy((char*)&fh.fh_handle.fh_base, f->data, f->size);
+       memcpy(&fh.fh_handle.fh_raw, f->data, f->size);
        fh.fh_export = NULL;
 
        access = (mode == O_WRONLY) ? NFSD_MAY_WRITE : NFSD_MAY_READ;

diff --git a/fs/nfsd/nfs3xdr.c b/fs/nfsd/nfs3xdr.c
index 0a5ebc52e6a9ccdc5aaf0beffab7ced35cb3adac..3d37923afb06cb2a11d286662826279d33b9ec5c 100644 (file)
--- a/fs/nfsd/nfs3xdr.c
+++ b/fs/nfsd/nfs3xdr.c
@@ -92,7 +92,7 @@ svcxdr_decode_nfs_fh3(struct xdr_stream *xdr, struct svc_fh *fhp)
                return false;
        fh_init(fhp, NFS3_FHSIZE);
        fhp->fh_handle.fh_size = size;
-       memcpy(&fhp->fh_handle.fh_base, p, size);
+       memcpy(&fhp->fh_handle.fh_raw, p, size);
 
        return true;
 }
@@ -131,7 +131,7 @@ svcxdr_encode_nfs_fh3(struct xdr_stream *xdr, const struct svc_fh *fhp)
        *p++ = cpu_to_be32(size);
        if (size)
                p[XDR_QUADLEN(size) - 1] = 0;
-       memcpy(p, &fhp->fh_handle.fh_base, size);
+       memcpy(p, &fhp->fh_handle.fh_raw, size);
 
        return true;
 }

diff --git a/fs/nfsd/nfs4callback.c b/fs/nfsd/nfs4callback.c
index 0f8b10f363e7f3dba63d514f07def9621e8fc796..11f8715d92d63ab0250dee5d6b55d9999c41857b 100644 (file)
--- a/fs/nfsd/nfs4callback.c
+++ b/fs/nfsd/nfs4callback.c
@@ -121,7 +121,7 @@ static void encode_nfs_fh4(struct xdr_stream *xdr, const struct knfsd_fh *fh)
 
        BUG_ON(length > NFS4_FHSIZE);
        p = xdr_reserve_space(xdr, 4 + length);
-       xdr_encode_opaque(p, &fh->fh_base, length);
+       xdr_encode_opaque(p, &fh->fh_raw, length);
 }
 
 /*

diff --git a/fs/nfsd/nfs4proc.c b/fs/nfsd/nfs4proc.c
index 486c5dba4b6502ea1f9078a46f290b7528992a74..3f7e59ec4e32b6ea5fb2ada12a9c8b4f143bf09a 100644 (file)
--- a/fs/nfsd/nfs4proc.c
+++ b/fs/nfsd/nfs4proc.c
@@ -519,7 +519,7 @@ nfsd4_putfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 
        fh_put(&cstate->current_fh);
        cstate->current_fh.fh_handle.fh_size = putfh->pf_fhlen;
-       memcpy(&cstate->current_fh.fh_handle.fh_base, putfh->pf_fhval,
+       memcpy(&cstate->current_fh.fh_handle.fh_raw, putfh->pf_fhval,
               putfh->pf_fhlen);
        ret = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_BYPASS_GSS);
 #ifdef CONFIG_NFSD_V4_2_INTER_SSC
@@ -1383,7 +1383,7 @@ nfsd4_setup_inter_ssc(struct svc_rqst *rqstp,
        s_fh = &cstate->save_fh;
 
        copy->c_fh.size = s_fh->fh_handle.fh_size;
-       memcpy(copy->c_fh.data, &s_fh->fh_handle.fh_base, copy->c_fh.size);
+       memcpy(copy->c_fh.data, &s_fh->fh_handle.fh_raw, copy->c_fh.size);
        copy->stateid.seqid = cpu_to_be32(s_stid->si_generation);
        memcpy(copy->stateid.other, (void *)&s_stid->si_opaque,
               sizeof(stateid_opaque_t));

diff --git a/fs/nfsd/nfs4state.c b/fs/nfsd/nfs4state.c
index 42356416f0a0e895456c73939b11e9aef7e7c034..88c0a5cd7b75515075c738af9a700e8ae926078e 100644 (file)
--- a/fs/nfsd/nfs4state.c
+++ b/fs/nfsd/nfs4state.c
@@ -1010,7 +1010,7 @@ static int delegation_blocked(struct knfsd_fh *fh)
                }
                spin_unlock(&blocked_delegations_lock);
        }
-       hash = jhash(&fh->fh_base, fh->fh_size, 0);
+       hash = jhash(&fh->fh_raw, fh->fh_size, 0);
        if (test_bit(hash&255, bd->set[0]) &&
            test_bit((hash>>8)&255, bd->set[0]) &&
            test_bit((hash>>16)&255, bd->set[0]))
@@ -1029,7 +1029,7 @@ static void block_delegations(struct knfsd_fh *fh)
        u32 hash;
        struct bloom_pair *bd = &blocked_delegations;
 
-       hash = jhash(&fh->fh_base, fh->fh_size, 0);
+       hash = jhash(&fh->fh_raw, fh->fh_size, 0);
 
        spin_lock(&blocked_delegations_lock);
        __set_bit(hash&255, bd->set[bd->new]);

diff --git a/fs/nfsd/nfs4xdr.c b/fs/nfsd/nfs4xdr.c
index 7abeccb975b22703cb40ab36b310da1657d8bc34..a54b2845473b39fab930cecbb04b2557b56aeb49 100644 (file)
--- a/fs/nfsd/nfs4xdr.c
+++ b/fs/nfsd/nfs4xdr.c
@@ -3110,7 +3110,7 @@ out_acl:
                p = xdr_reserve_space(xdr, fhp->fh_handle.fh_size + 4);
                if (!p)
                        goto out_resource;
-               p = xdr_encode_opaque(p, &fhp->fh_handle.fh_base,
+               p = xdr_encode_opaque(p, &fhp->fh_handle.fh_raw,
                                        fhp->fh_handle.fh_size);
        }
        if (bmval0 & FATTR4_WORD0_FILEID) {
@@ -3667,7 +3667,7 @@ nfsd4_encode_getfh(struct nfsd4_compoundres *resp, __be32 nfserr, struct svc_fh
        p = xdr_reserve_space(xdr, len + 4);
        if (!p)
                return nfserr_resource;
-       p = xdr_encode_opaque(p, &fhp->fh_handle.fh_base, len);
+       p = xdr_encode_opaque(p, &fhp->fh_handle.fh_raw, len);
        return 0;
 }
 

diff --git a/fs/nfsd/nfsctl.c b/fs/nfsd/nfsctl.c
index c2c3d9077dc5813fbd63ee1df4bd154d7a376813..5e48bc48942e6da5c60b9b356542343e77c14b00 100644 (file)
--- a/fs/nfsd/nfsctl.c
+++ b/fs/nfsd/nfsctl.c
@@ -395,12 +395,12 @@ static ssize_t write_filehandle(struct file *file, char *buf, size_t size)
        auth_domain_put(dom);
        if (len)
                return len;
-       
+
        mesg = buf;
        len = SIMPLE_TRANSACTION_LIMIT;
-       qword_addhex(&mesg, &len, (char*)&fh.fh_base, fh.fh_size);
+       qword_addhex(&mesg, &len, fh.fh_raw, fh.fh_size);
        mesg[-1] = '\n';
-       return mesg - buf;      
+       return mesg - buf;
 }
 
 /*

diff --git a/fs/nfsd/nfsfh.c b/fs/nfsd/nfsfh.c
index 149f9bbc48a4e4232bfe0a4ee1775f4656cb4443..f3779fa72c896250a5abf6bfbbb900d5a6c245d3 100644 (file)
--- a/fs/nfsd/nfsfh.c
+++ b/fs/nfsd/nfsfh.c
@@ -640,16 +640,11 @@ fh_put(struct svc_fh *fhp)
 char * SVCFH_fmt(struct svc_fh *fhp)
 {
        struct knfsd_fh *fh = &fhp->fh_handle;
+       static char buf[2+1+1+64*3+1];
 
-       static char buf[80];
-       sprintf(buf, "%d: %08x %08x %08x %08x %08x %08x",
-               fh->fh_size,
-               fh->fh_base.fh_pad[0],
-               fh->fh_base.fh_pad[1],
-               fh->fh_base.fh_pad[2],
-               fh->fh_base.fh_pad[3],
-               fh->fh_base.fh_pad[4],
-               fh->fh_base.fh_pad[5]);
+       if (fh->fh_size < 0 || fh->fh_size> 64)
+               return "bad-fh";
+       sprintf(buf, "%d: %*ph", fh->fh_size, fh->fh_size, fh->fh_raw);
        return buf;
 }
 

diff --git a/fs/nfsd/nfsfh.h b/fs/nfsd/nfsfh.h
index 8b5587f274a7d6b6ef4794dc4849f00996dfe70c..d11e4b6870d6810167659116d16fdd329406b889 100644 (file)
--- a/fs/nfsd/nfsfh.h
+++ b/fs/nfsd/nfsfh.h
@@ -43,44 +43,24 @@
  *   filesystems must not use the values '0' or '0xff'. 'See enum fid_type'
  *   in include/linux/exportfs.h for currently registered values.
  */
-struct nfs_fhbase_new {
-       union {
-               struct {
-                       u8              fb_version_aux; /* == 1 */
-                       u8              fb_auth_type_aux;
-                       u8              fb_fsid_type_aux;
-                       u8              fb_fileid_type_aux;
-                       u32             fb_auth[1];
-               /*      u32             fb_fsid[0]; floating */
-               /*      u32             fb_fileid[0]; floating */
-               };
-               struct {
-                       u8              fb_version;     /* == 1 */
-                       u8              fb_auth_type;
-                       u8              fb_fsid_type;
-                       u8              fb_fileid_type;
-                       u32             fb_auth_flex[]; /* flexible-array member */
-               };
-       };
-};
 
 struct knfsd_fh {
-       unsigned int    fh_size;        /* significant for NFSv3.
-                                        * Points to the current size while building
-                                        * a new file handle
+       unsigned int    fh_size;        /*
+                                        * Points to the current size while
+                                        * building a new file handle.
                                         */
        union {
-               u32                     fh_pad[NFS4_FHSIZE/4];
-               struct nfs_fhbase_new   fh_new;
-       } fh_base;
+               char                    fh_raw[NFS4_FHSIZE];
+               struct {
+                       u8              fh_version;     /* == 1 */
+                       u8              fh_auth_type;   /* deprecated */
+                       u8              fh_fsid_type;
+                       u8              fh_fileid_type;
+                       u32             fh_fsid[]; /* flexible-array member */
+               };
+       };
 };
 
-#define        fh_version              fh_base.fh_new.fb_version
-#define        fh_fsid_type            fh_base.fh_new.fb_fsid_type
-#define        fh_auth_type            fh_base.fh_new.fb_auth_type
-#define        fh_fileid_type          fh_base.fh_new.fb_fileid_type
-#define        fh_fsid                 fh_base.fh_new.fb_auth_flex
-
 static inline __u32 ino_t_to_u32(ino_t ino)
 {
        return (__u32) ino;
@@ -255,7 +235,7 @@ static inline void
 fh_copy_shallow(struct knfsd_fh *dst, struct knfsd_fh *src)
 {
        dst->fh_size = src->fh_size;
-       memcpy(&dst->fh_base, &src->fh_base, src->fh_size);
+       memcpy(&dst->fh_raw, &src->fh_raw, src->fh_size);
 }
 
 static __inline__ struct svc_fh *
@@ -270,7 +250,7 @@ static inline bool fh_match(struct knfsd_fh *fh1, struct knfsd_fh *fh2)
 {
        if (fh1->fh_size != fh2->fh_size)
                return false;
-       if (memcmp(fh1->fh_base.fh_pad, fh2->fh_base.fh_pad, fh1->fh_size) != 0)
+       if (memcmp(fh1->fh_raw, fh2->fh_raw, fh1->fh_size) != 0)
                return false;
        return true;
 }
@@ -294,7 +274,7 @@ static inline bool fh_fsid_match(struct knfsd_fh *fh1, struct knfsd_fh *fh2)
  */
 static inline u32 knfsd_fh_hash(const struct knfsd_fh *fh)
 {
-       return ~crc32_le(0xFFFFFFFF, (unsigned char *)&fh->fh_base, fh->fh_size);
+       return ~crc32_le(0xFFFFFFFF, fh->fh_raw, fh->fh_size);
 }
 #else
 static inline u32 knfsd_fh_hash(const struct knfsd_fh *fh)

diff --git a/fs/nfsd/nfsxdr.c b/fs/nfsd/nfsxdr.c
index a06c05fe3b421895a13d2ed1c7ac11794c1ba67d..082449c7d0dbfa622235a8d02191a259096d908f 100644 (file)
--- a/fs/nfsd/nfsxdr.c
+++ b/fs/nfsd/nfsxdr.c
@@ -64,7 +64,7 @@ svcxdr_decode_fhandle(struct xdr_stream *xdr, struct svc_fh *fhp)
        if (!p)
                return false;
        fh_init(fhp, NFS_FHSIZE);
-       memcpy(&fhp->fh_handle.fh_base, p, NFS_FHSIZE);
+       memcpy(&fhp->fh_handle.fh_raw, p, NFS_FHSIZE);
        fhp->fh_handle.fh_size = NFS_FHSIZE;
 
        return true;
@@ -78,7 +78,7 @@ svcxdr_encode_fhandle(struct xdr_stream *xdr, const struct svc_fh *fhp)
        p = xdr_reserve_space(xdr, NFS_FHSIZE);
        if (!p)
                return false;
-       memcpy(p, &fhp->fh_handle.fh_base, NFS_FHSIZE);
+       memcpy(p, &fhp->fh_handle.fh_raw, NFS_FHSIZE);
 
        return true;
 }