Clean up the nfs4_stateid and nfs4_verifier typedefs.

Convert them into structures

diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index 8b742557c1e0f7cd0e9443993c1656fb7c0e978c..2ef48c737a005118118b18371f347341240b5ec3 100644 (file)
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -54,8 +54,7 @@
 extern u32 *nfs4_decode_dirent(u32 *p, struct nfs_entry *entry, int plus);
 extern struct rpc_procinfo nfs4_procedures[];
 
-static nfs4_stateid zero_stateid =
-       { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+extern nfs4_stateid zero_stateid;
 
 static spinlock_t renew_lock = SPIN_LOCK_UNLOCKED;
 
@@ -336,7 +335,7 @@ nfs4_setup_readdir(struct nfs4_compound *cp, u64 cookie, u32 *verifier,
 
        BUG_ON(bufsize < 80);
        readdir->rd_cookie = (cookie > 2) ? cookie : 0;
-       memcpy(readdir->rd_req_verifier, verifier, sizeof(nfs4_verifier));
+       memcpy(&readdir->rd_req_verifier, verifier, sizeof(readdir->rd_req_verifier));
        readdir->rd_count = bufsize;
        readdir->rd_bmval[0] = FATTR4_WORD0_FILEID;
        readdir->rd_bmval[1] = 0;
@@ -464,7 +463,7 @@ nfs4_setup_setclientid(struct nfs4_compound *cp, u32 program, unsigned short por
        u32 *p;
 
        tv = CURRENT_TIME;
-       p = (u32 *)setclientid->sc_verifier;
+       p = (u32 *)setclientid->sc_verifier.data;
        *p++ = tv.tv_sec;
        *p++ = tv.tv_nsec;
        setclientid->sc_name = server->ip_addr;
@@ -606,7 +605,7 @@ nfs4_do_open(struct inode *dir, struct qstr *name, int flags, struct iattr *satt
                goto out;
        }
        if (o_arg.createmode & NFS4_CREATE_EXCLUSIVE){
-               u32 *p = (u32 *) o_arg.u.verifier;
+               u32 *p = (u32 *) o_arg.u.verifier.data;
                p[0] = jiffies;
                p[1] = current->pid;
        } else if (o_arg.createmode == NFS4_CREATE_UNCHECKED) {
@@ -648,14 +647,14 @@ nfs4_do_open(struct inode *dir, struct qstr *name, int flags, struct iattr *satt
                        .rpc_cred       = cred,
                };
 
-               memcpy(oc_arg.stateid, o_res.stateid, sizeof(nfs4_stateid));
+               memcpy(&oc_arg.stateid, &o_res.stateid, sizeof(oc_arg.stateid));
                status = rpc_call_sync(server->client, &msg, 0);
                if (status)
                        goto out_up;
                nfs4_increment_seqid(status, sp);
-               memcpy(state->stateid, oc_res.stateid, sizeof(state->stateid));
+               memcpy(&state->stateid, &oc_res.stateid, sizeof(state->stateid));
        } else
-               memcpy(state->stateid, o_res.stateid, sizeof(state->stateid));
+               memcpy(&state->stateid, &o_res.stateid, sizeof(state->stateid));
        state->state |= flags & (FMODE_READ|FMODE_WRITE);
        state->pid = current->pid;
 
@@ -703,9 +702,9 @@ nfs4_do_setattr(struct nfs_server *server, struct nfs_fattr *fattr,
         fattr->valid = 0;
 
        if (state)
-               memcpy(arg.stateid, state->stateid, sizeof(arg.stateid));
+               memcpy(&arg.stateid, &state->stateid, sizeof(arg.stateid));
         else
-               memcpy(arg.stateid, zero_stateid, sizeof(arg.stateid));
+               memcpy(&arg.stateid, &zero_stateid, sizeof(arg.stateid));
 
         return(rpc_call_sync(server->client, &msg, 0));
 }
@@ -738,7 +737,7 @@ nfs4_do_close(struct inode *inode, struct nfs4_state *state)
                .rpc_resp       = &res,
        };
 
-       memcpy(arg.stateid, state->stateid, sizeof(arg.stateid));
+       memcpy(&arg.stateid, &state->stateid, sizeof(arg.stateid));
        /* Serialization for the sequence id */
        arg.seqid = sp->so_seqid,
        status = rpc_call_sync(NFS_SERVER(inode)->client, &msg, 0);
@@ -1034,7 +1033,6 @@ nfs4_proc_read(struct nfs_read_data *rdata, struct file *filp)
        int flags = rdata->flags;
        struct inode *inode = rdata->inode;
        struct nfs_fattr *fattr = rdata->res.fattr;
-       nfs4_stateid *stateid = &rdata->args.stateid;
        struct nfs_server *server = NFS_SERVER(inode);
        struct rpc_message msg = {
                .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_READ],
@@ -1054,9 +1052,9 @@ nfs4_proc_read(struct nfs_read_data *rdata, struct file *filp)
        if (filp) {
                struct nfs4_state *state;
                state = (struct nfs4_state *)filp->private_data;
-               memcpy(stateid, state->stateid, sizeof(stateid));
+               memcpy(&rdata->args.stateid, &state->stateid, sizeof(rdata->args.stateid));
        } else
-               memcpy(stateid, zero_stateid, sizeof(stateid));
+               memcpy(&rdata->args.stateid, &zero_stateid, sizeof(rdata->args.stateid));
 
        fattr->valid = 0;
        status = rpc_call_sync(server->client, &msg, flags);
@@ -1076,7 +1074,6 @@ nfs4_proc_write(struct nfs_write_data *wdata, struct file *filp)
        int rpcflags = wdata->flags;
        struct inode *inode = wdata->inode;
        struct nfs_fattr *fattr = wdata->res.fattr;
-       nfs4_stateid *stateid = &wdata->args.stateid;
        struct nfs_server *server = NFS_SERVER(inode);
        struct rpc_message msg = {
                .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_WRITE],
@@ -1095,9 +1092,9 @@ nfs4_proc_write(struct nfs_write_data *wdata, struct file *filp)
        if (filp) {
                struct nfs4_state *state;
                state = (struct nfs4_state *)filp->private_data;
-               memcpy(stateid, state->stateid, sizeof(stateid));
+               memcpy(&wdata->args.stateid, &state->stateid, sizeof(wdata->args.stateid));
        } else
-               memcpy(stateid, zero_stateid, sizeof(stateid));
+               memcpy(&wdata->args.stateid, &zero_stateid, sizeof(wdata->args.stateid));
 
        fattr->valid = 0;
        status = rpc_call_sync(server->client, &msg, rpcflags);
@@ -1476,9 +1473,9 @@ nfs4_proc_read_setup(struct nfs_read_data *data, unsigned int count)
        data->timestamp   = jiffies;
 
        if (req->wb_state)
-               memcpy(data->args.stateid, req->wb_state->stateid, sizeof(data->args.stateid));
+               memcpy(&data->args.stateid, &req->wb_state->stateid, sizeof(data->args.stateid));
        else
-               memcpy(data->args.stateid, zero_stateid, sizeof(data->args.stateid));
+               memcpy(&data->args.stateid, &zero_stateid, sizeof(data->args.stateid));
 
        /* N.B. Do we need to test? Never called for swapfile inode */
        flags = RPC_TASK_ASYNC | (IS_SWAPFILE(inode)? NFS_RPC_SWAPFLAGS : 0);
@@ -1555,9 +1552,9 @@ nfs4_proc_write_setup(struct nfs_write_data *data, unsigned int count, int how)
        data->timestamp   = jiffies;
 
        if (req->wb_state)
-               memcpy(data->args.stateid, req->wb_state->stateid, sizeof(data->args.stateid));
+               memcpy(&data->args.stateid, &req->wb_state->stateid, sizeof(data->args.stateid));
        else
-               memcpy(data->args.stateid, zero_stateid, sizeof(data->args.stateid));
+               memcpy(&data->args.stateid, &zero_stateid, sizeof(data->args.stateid));
 
        /* Set the initial flags for the task.  */
        flags = (how & FLUSH_SYNC) ? 0 : RPC_TASK_ASYNC;

diff --git a/fs/nfs/nfs4state.c b/fs/nfs/nfs4state.c
index fd5a93d948e58fde2bbc744d4e941e730825342f..42a2344a28935e102e144da2850bb3c273932f49 100644 (file)
--- a/fs/nfs/nfs4state.c
+++ b/fs/nfs/nfs4state.c
@@ -46,11 +46,12 @@
 
 static spinlock_t              state_spinlock = SPIN_LOCK_UNLOCKED;
 
-nfs4_stateid zero_stateid =
-       { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+nfs4_stateid zero_stateid;
 
+#if 0
 nfs4_stateid one_stateid =
        { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
+#endif
 
 static LIST_HEAD(nfs4_clientid_list);
 
@@ -228,7 +229,7 @@ nfs4_alloc_open_state(void)
                return NULL;
        state->pid = current->pid;
        state->state = 0;
-       memset(state->stateid, 0, sizeof(state->stateid));
+       memset(state->stateid.data, 0, sizeof(state->stateid.data));
        atomic_set(&state->count, 1);
        return state;
 }

diff --git a/fs/nfs/nfs4xdr.c b/fs/nfs/nfs4xdr.c
index ac89bf9ac33627548c475673b593c9d66bd4c2fc..9d944780865d0ca23cd1fd42177cebeaeec1d98c 100644 (file)
--- a/fs/nfs/nfs4xdr.c
+++ b/fs/nfs/nfs4xdr.c
@@ -205,6 +205,7 @@ struct compound_hdr {
 
 #define RESERVE_SPACE(nbytes)  do {                            \
        p = xdr_reserve_space(xdr, nbytes);                     \
+       if (!p) printk("RESERVE_SPACE(%d) failed in function %s\n", nbytes, __FUNCTION__); \
        BUG_ON(!p);                                             \
 } while (0)
 
@@ -382,10 +383,10 @@ encode_close(struct xdr_stream *xdr, struct nfs_closeargs *arg)
 {
        uint32_t *p;
 
-       RESERVE_SPACE(8+sizeof(nfs4_stateid));
+       RESERVE_SPACE(8+sizeof(arg->stateid.data));
        WRITE32(OP_CLOSE);
        WRITE32(arg->seqid);
-       WRITEMEM(arg->stateid, sizeof(nfs4_stateid));
+       WRITEMEM(arg->stateid.data, sizeof(arg->stateid.data));
        
        return 0;
 }
@@ -575,7 +576,7 @@ encode_open(struct xdr_stream *xdr, struct nfs_openargs *arg)
                if (arg->createmode == NFS4_CREATE_EXCLUSIVE) {
                        RESERVE_SPACE(12);
                        WRITE32(arg->createmode);
-                       WRITEMEM(arg->u.verifier, sizeof(nfs4_verifier));
+                       WRITEMEM(arg->u.verifier.data, sizeof(arg->u.verifier.data));
                }
                else if (arg->u.attrs) {
                        RESERVE_SPACE(4);
@@ -604,9 +605,9 @@ encode_open_confirm(struct xdr_stream *xdr, struct nfs_open_confirmargs *arg)
 {
        uint32_t *p;
 
-       RESERVE_SPACE(8+sizeof(nfs4_stateid));
+       RESERVE_SPACE(8+sizeof(arg->stateid.data));
        WRITE32(OP_OPEN_CONFIRM);
-       WRITEMEM(arg->stateid, sizeof(nfs4_stateid));
+       WRITEMEM(arg->stateid.data, sizeof(arg->stateid.data));
        WRITE32(arg->seqid);
 
        return 0;
@@ -645,7 +646,7 @@ encode_read(struct xdr_stream *xdr, struct nfs_readargs *args)
 
        RESERVE_SPACE(32);
        WRITE32(OP_READ);
-       WRITEMEM(args->stateid, sizeof(nfs4_stateid));
+       WRITEMEM(args->stateid.data, sizeof(args->stateid.data));
        WRITE64(args->offset);
        WRITE32(args->count);
 
@@ -662,7 +663,7 @@ encode_readdir(struct xdr_stream *xdr, struct nfs4_readdir *readdir, struct rpc_
        RESERVE_SPACE(32+sizeof(nfs4_verifier));
        WRITE32(OP_READDIR);
        WRITE64(readdir->rd_cookie);
-       WRITEMEM(readdir->rd_req_verifier, sizeof(nfs4_verifier));
+       WRITEMEM(readdir->rd_req_verifier.data, sizeof(readdir->rd_req_verifier.data));
        WRITE32(readdir->rd_count >> 5);  /* meaningless "dircount" field */
        WRITE32(readdir->rd_count);
        WRITE32(2);
@@ -771,9 +772,9 @@ encode_setattr(struct xdr_stream *xdr, struct nfs_setattrargs *arg,
        int status;
        uint32_t *p;
        
-        RESERVE_SPACE(4+sizeof(nfs4_stateid));
+        RESERVE_SPACE(4+sizeof(arg->stateid.data));
         WRITE32(OP_SETATTR);
-       WRITEMEM(arg->stateid, sizeof(nfs4_stateid));
+       WRITEMEM(arg->stateid.data, sizeof(arg->stateid.data));
 
         if ((status = encode_attrs(xdr, arg->iap, server)))
                return status;
@@ -792,11 +793,11 @@ encode_setclientid(struct xdr_stream *xdr, struct nfs4_setclientid *setclientid)
        len2 = strlen(setclientid->sc_netid);
        len3 = strlen(setclientid->sc_uaddr);
        total_len = XDR_QUADLEN(len1) + XDR_QUADLEN(len2) + XDR_QUADLEN(len3);
-       total_len = (total_len << 2) + 24 + sizeof(nfs4_verifier);
+       total_len = (total_len << 2) + 24 + sizeof(setclientid->sc_verifier.data);
 
        RESERVE_SPACE(total_len);
        WRITE32(OP_SETCLIENTID);
-       WRITEMEM(setclientid->sc_verifier, sizeof(nfs4_verifier));
+       WRITEMEM(setclientid->sc_verifier.data, sizeof(setclientid->sc_verifier.data));
        WRITE32(len1);
        WRITEMEM(setclientid->sc_name, len1);
        WRITE32(setclientid->sc_prog);
@@ -814,10 +815,10 @@ encode_setclientid_confirm(struct xdr_stream *xdr, struct nfs4_client *client_st
 {
         uint32_t *p;
 
-        RESERVE_SPACE(12 + sizeof(nfs4_verifier));
+        RESERVE_SPACE(12 + sizeof(client_state->cl_confirm.data));
         WRITE32(OP_SETCLIENTID_CONFIRM);
         WRITE64(client_state->cl_clientid);
-        WRITEMEM(client_state->cl_confirm,sizeof(nfs4_verifier));
+        WRITEMEM(client_state->cl_confirm.data, sizeof(client_state->cl_confirm.data));
 
         return 0;
 }
@@ -829,7 +830,7 @@ encode_write(struct xdr_stream *xdr, struct nfs_writeargs *args)
 
        RESERVE_SPACE(36);
        WRITE32(OP_WRITE);
-       WRITEMEM(args->stateid, sizeof(nfs4_stateid));
+       WRITEMEM(args->stateid.data, sizeof(args->stateid.data));
        WRITE64(args->offset);
        WRITE32(args->stable);
        WRITE32(args->count);
@@ -1256,8 +1257,8 @@ decode_close(struct xdr_stream *xdr, struct nfs_closeres *res)
        status = decode_op_hdr(xdr, OP_CLOSE);
        if (status)
                return status;
-       READ_BUF(sizeof(nfs4_stateid));
-       COPYMEM(res->stateid, sizeof(nfs4_stateid));
+       READ_BUF(sizeof(res->stateid.data));
+       COPYMEM(res->stateid.data, sizeof(res->stateid.data));
        return 0;
 }
 
@@ -1744,8 +1745,8 @@ decode_open(struct xdr_stream *xdr, struct nfs_openres *res)
         status = decode_op_hdr(xdr, OP_OPEN);
         if (status)
                 return status;
-        READ_BUF(sizeof(nfs4_stateid));
-        COPYMEM(res->stateid, sizeof(nfs4_stateid));
+        READ_BUF(sizeof(res->stateid.data));
+        COPYMEM(res->stateid.data, sizeof(res->stateid.data));
 
         decode_change_info(xdr, res->cinfo);
 
@@ -1772,8 +1773,8 @@ decode_open_confirm(struct xdr_stream *xdr, struct nfs_open_confirmres *res)
         res->status = decode_op_hdr(xdr, OP_OPEN_CONFIRM);
         if (res->status)
                 return res->status;
-        READ_BUF(sizeof(nfs4_stateid));
-        COPYMEM(res->stateid, sizeof(nfs4_stateid));
+        READ_BUF(sizeof(res->stateid.data));
+        COPYMEM(res->stateid.data, sizeof(res->stateid.data));
         return 0;
 }
 
@@ -1833,7 +1834,7 @@ decode_readdir(struct xdr_stream *xdr, struct rpc_rqst *req, struct nfs4_readdir
        if (status)
                return status;
        READ_BUF(8);
-       COPYMEM(readdir->rd_resp_verifier, 8);
+       COPYMEM(readdir->rd_resp_verifier.data, 8);
 
        hdrlen = (char *) p - (char *) iov->iov_base;
        recvd = req->rq_received - hdrlen;
@@ -2026,9 +2027,9 @@ decode_setclientid(struct xdr_stream *xdr, struct nfs4_setclientid *setclientid)
        }
        READ32(nfserr);
        if (nfserr == NFS_OK) {
-               READ_BUF(8 + sizeof(nfs4_verifier));
+               READ_BUF(8 + sizeof(setclientid->sc_state->cl_confirm.data));
                READ64(setclientid->sc_state->cl_clientid);
-               COPYMEM(setclientid->sc_state->cl_confirm, sizeof(nfs4_verifier));
+               COPYMEM(setclientid->sc_state->cl_confirm.data, sizeof(setclientid->sc_state->cl_confirm.data));
        } else if (nfserr == NFSERR_CLID_INUSE) {
                uint32_t len;
 

diff --git a/fs/nfsd/nfs4proc.c b/fs/nfsd/nfs4proc.c
index ba0a43a995485fc42d0821c478ea68839fbad5da..dc3f183524ebb488f8fb9cd27a6d8d27840f2830 100644 (file)
--- a/fs/nfsd/nfs4proc.c
+++ b/fs/nfsd/nfs4proc.c
@@ -78,7 +78,7 @@ do_open_lookup(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_o
                status = nfsd_create_v3(rqstp, current_fh, open->op_fname.data,
                                        open->op_fname.len, &open->op_iattr,
                                        &resfh, open->op_createmode,
-                                       (u32 *)open->op_verf, &open->op_truncate);
+                                       (u32 *)open->op_verf.data, &open->op_truncate);
        }
        else {
                status = nfsd_lookup(rqstp, current_fh,
@@ -204,7 +204,7 @@ nfsd4_access(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_acc
 static inline int
 nfsd4_commit(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_commit *commit)
 {
-       u32 *p = (u32 *)commit->co_verf;
+       u32 *p = (u32 *)commit->co_verf.data;
        *p++ = nfssvc_boot.tv_sec;
        *p++ = nfssvc_boot.tv_usec;
 
@@ -522,7 +522,7 @@ zero_stateid:
        nfs4_unlock_state();
        write->wr_bytes_written = write->wr_buflen;
        write->wr_how_written = write->wr_stable_how;
-       p = (u32 *)write->wr_verifier;
+       p = (u32 *)write->wr_verifier.data;
        *p++ = nfssvc_boot.tv_sec;
        *p++ = nfssvc_boot.tv_usec;
 

diff --git a/fs/nfsd/nfs4state.c b/fs/nfsd/nfs4state.c
index 1858b523268538fb3b34fdc1d7f2e31d163198aa..0d485189c92d79eaf686ce10e2dd1066833aa228 100644 (file)
--- a/fs/nfsd/nfs4state.c
+++ b/fs/nfsd/nfs4state.c
@@ -228,8 +228,8 @@ out:
 }
 
 static void
-copy_verf(struct nfs4_client *target, nfs4_verifier source) {
-       memcpy(&target->cl_verifier, source, sizeof(nfs4_verifier));
+copy_verf(struct nfs4_client *target, nfs4_verifier *source) {
+       memcpy(target->cl_verifier.data, source->data, sizeof(target->cl_verifier.data));
 }
 
 static void
@@ -256,8 +256,8 @@ cmp_name(struct xdr_netobj *n1, struct xdr_netobj *n2) {
 }
 
 static int
-cmp_verf(nfs4_verifier v1, nfs4_verifier v2) {
-       return(!memcmp(v1,v2,sizeof(nfs4_verifier)));
+cmp_verf(nfs4_verifier *v1, nfs4_verifier *v2) {
+       return(!memcmp(v1->data,v2->data,sizeof(v1->data)));
 }
 
 static int
@@ -286,7 +286,7 @@ gen_confirm(struct nfs4_client *clp) {
        u32 *                   p;
 
        tv = CURRENT_TIME;
-       p = (u32 *)clp->cl_confirm;
+       p = (u32 *)clp->cl_confirm.data;
        *p++ = tv.tv_sec;
        *p++ = tv.tv_nsec;
 }
@@ -371,7 +371,7 @@ nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_setclientid *setclid)
                .len = setclid->se_namelen,
                .data = setclid->se_name,
        };
-       char *                  clverifier = setclid->se_verf;
+       nfs4_verifier           clverifier = setclid->se_verf;
        unsigned int            strhashval;
        struct nfs4_client *    conf, * unconf, * new, * clp;
        int                     status;
@@ -439,13 +439,13 @@ nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_setclientid *setclid)
                        expire_client(unconf);
                if (!(new = create_client(clname)))
                        goto out;
-               copy_verf(new,clverifier);
+               copy_verf(new, &clverifier);
                new->cl_addr = ip_addr;
                copy_cred(&new->cl_cred,&rqstp->rq_cred);
                gen_clid(new);
                gen_confirm(new);
                add_to_unconfirmed(new, strhashval);
-       } else if (cmp_verf(conf->cl_verifier, clverifier)) {
+       } else if (cmp_verf(&conf->cl_verifier, &clverifier)) {
                /*
                 * CASE 1:
                 * cl_name match, confirmed, principal match
@@ -460,13 +460,13 @@ nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_setclientid *setclid)
                 * new cl_confirm
                 */
                if ((unconf) && 
-                   cmp_verf(unconf->cl_verifier, conf->cl_verifier) &&
+                   cmp_verf(&unconf->cl_verifier, &conf->cl_verifier) &&
                     cmp_clid(&unconf->cl_clientid, &conf->cl_clientid)) {
                                expire_client(unconf);
                }
                if (!(new = create_client(clname)))
                        goto out;
-               copy_verf(new,conf->cl_verifier);
+               copy_verf(new,&conf->cl_verifier);
                new->cl_addr = ip_addr;
                copy_cred(&new->cl_cred,&rqstp->rq_cred);
                copy_clid(new, conf);
@@ -483,14 +483,14 @@ nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_setclientid *setclid)
                 */
                if (!(new = create_client(clname)))
                        goto out;
-               copy_verf(new,clverifier);
+               copy_verf(new,&clverifier);
                new->cl_addr = ip_addr;
                copy_cred(&new->cl_cred,&rqstp->rq_cred);
                gen_clid(new);
                gen_confirm(new);
                add_to_unconfirmed(new, strhashval);
        } else if (!cmp_clid(&conf->cl_clientid, &unconf->cl_clientid) &&
-             !cmp_verf(conf->cl_confirm, unconf->cl_confirm)) {
+             !cmp_verf(&conf->cl_confirm, &unconf->cl_confirm)) {
                /*      
                 * CASE3:
                 * confirmed found (name, principal match)
@@ -510,7 +510,7 @@ nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_setclientid *setclid)
                expire_client(unconf);
                if (!(new = create_client(clname)))
                        goto out;
-               copy_verf(new,clverifier);
+               copy_verf(new,&clverifier);
                new->cl_addr = ip_addr;
                copy_cred(&new->cl_cred,&rqstp->rq_cred);
                gen_clid(new);
@@ -524,7 +524,7 @@ nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_setclientid *setclid)
        }
        setclid->se_clientid.cl_boot = new->cl_clientid.cl_boot;
        setclid->se_clientid.cl_id = new->cl_clientid.cl_id;
-       memcpy(&setclid->se_confirm, new->cl_confirm, sizeof(nfs4_verifier));
+       memcpy(setclid->se_confirm.data, new->cl_confirm.data, sizeof(setclid->se_confirm.data));
        printk(KERN_INFO "NFSD: this client will not receive delegations\n");
        status = nfs_ok;
 out:
@@ -546,7 +546,7 @@ nfsd4_setclientid_confirm(struct svc_rqst *rqstp, struct nfsd4_setclientid_confi
        u32 ip_addr = rqstp->rq_addr.sin_addr.s_addr;
        unsigned int idhashval;
        struct nfs4_client *clp, *conf = NULL, *unconf = NULL;
-       char * confirm = setclientid_confirm->sc_confirm; 
+       nfs4_verifier confirm = setclientid_confirm->sc_confirm; 
        clientid_t * clid = &setclientid_confirm->sc_clientid;
        struct list_head *pos, *next;
        int status;
@@ -601,10 +601,10 @@ nfsd4_setclientid_confirm(struct svc_rqst *rqstp, struct nfsd4_setclientid_confi
        * conf  and unconf records match names, verifiers 
        */
        if ((conf && unconf) && 
-           (cmp_verf(unconf->cl_confirm, confirm)) &&
-           (cmp_verf(conf->cl_verifier, unconf->cl_verifier)) &&
+           (cmp_verf(&unconf->cl_confirm, &confirm)) &&
+           (cmp_verf(&conf->cl_verifier, &unconf->cl_verifier)) &&
            (cmp_name(&conf->cl_name,&unconf->cl_name))  &&
-           (!cmp_verf(conf->cl_confirm, unconf->cl_confirm))) {
+           (!cmp_verf(&conf->cl_confirm, &unconf->cl_confirm))) {
                if (!cmp_creds(&conf->cl_cred, &unconf->cl_cred)) 
                        status = nfserr_clid_inuse;
                else {
@@ -621,7 +621,7 @@ nfsd4_setclientid_confirm(struct svc_rqst *rqstp, struct nfsd4_setclientid_confi
         */
        if ((conf && !unconf) || 
            ((conf && unconf) && 
-            (!cmp_verf(conf->cl_verifier, unconf->cl_verifier) ||
+            (!cmp_verf(&conf->cl_verifier, &unconf->cl_verifier) ||
              !cmp_name(&conf->cl_name, &unconf->cl_name)))) {
                if (!cmp_creds(&conf->cl_cred,&rqstp->rq_cred)) {
                        status = nfserr_clid_inuse;
@@ -635,7 +635,7 @@ nfsd4_setclientid_confirm(struct svc_rqst *rqstp, struct nfsd4_setclientid_confi
         * unconf record found. 
         * unconf->cl_confirm matches input confirm
         */ 
-       if (!conf && unconf && cmp_verf(unconf->cl_confirm, confirm)) {
+       if (!conf && unconf && cmp_verf(&unconf->cl_confirm, &confirm)) {
                if (!cmp_creds(&unconf->cl_cred, &rqstp->rq_cred)) {
                        status = nfserr_clid_inuse;
                } else {
@@ -650,8 +650,8 @@ nfsd4_setclientid_confirm(struct svc_rqst *rqstp, struct nfsd4_setclientid_confi
         * unconf record not found, or if unconf, then unconf->cl_confirm 
         * does not match input confirm.
         */
-       if ((!conf || (conf && !cmp_verf(conf->cl_confirm, confirm))) &&
-           (!unconf || (unconf && !cmp_verf(unconf->cl_confirm, confirm)))) {
+       if ((!conf || (conf && !cmp_verf(&conf->cl_confirm, &confirm))) &&
+           (!unconf || (unconf && !cmp_verf(&unconf->cl_confirm, &confirm)))) {
                status = nfserr_stale_clientid;
                goto out;
        }

diff --git a/fs/nfsd/nfs4xdr.c b/fs/nfsd/nfs4xdr.c
index 476c969412f9beb24f689a54a11b5de3954fc135..e931a435eebd054e483c37381fe7ff648cce4411 100644 (file)
--- a/fs/nfsd/nfs4xdr.c
+++ b/fs/nfsd/nfs4xdr.c
@@ -691,7 +691,7 @@ nfsd4_decode_open(struct nfsd4_compoundargs *argp, struct nfsd4_open *open)
                        break;
                case NFS4_CREATE_EXCLUSIVE:
                        READ_BUF(8);
-                       COPYMEM(open->op_verf, 8);
+                       COPYMEM(open->op_verf.data, 8);
                        break;
                default:
                        goto xdr_error;
@@ -798,7 +798,7 @@ nfsd4_decode_readdir(struct nfsd4_compoundargs *argp, struct nfsd4_readdir *read
 
        READ_BUF(24);
        READ64(readdir->rd_cookie);
-       COPYMEM(readdir->rd_verf, sizeof(nfs4_verifier));
+       COPYMEM(readdir->rd_verf.data, sizeof(readdir->rd_verf.data));
        READ32(readdir->rd_dircount);    /* just in case you needed a useless field... */
        READ32(readdir->rd_maxcount);
        if ((status = nfsd4_decode_bitmap(argp, readdir->rd_bmval)))
@@ -873,7 +873,7 @@ nfsd4_decode_setclientid(struct nfsd4_compoundargs *argp, struct nfsd4_setclient
        DECODE_HEAD;
 
        READ_BUF(12);
-       COPYMEM(setclientid->se_verf, 8);
+       COPYMEM(setclientid->se_verf.data, 8);
        READ32(setclientid->se_namelen);
 
        READ_BUF(setclientid->se_namelen + 8);
@@ -1740,7 +1740,7 @@ nfsd4_encode_commit(struct nfsd4_compoundres *resp, int nfserr, struct nfsd4_com
 
        if (!nfserr) {
                RESERVE_SPACE(8);
-               WRITEMEM(commit->co_verf, 8);
+               WRITEMEM(commit->co_verf.data, 8);
                ADJUST_ARGS();
        }
 }
@@ -2224,7 +2224,7 @@ nfsd4_encode_write(struct nfsd4_compoundres *resp, int nfserr, struct nfsd4_writ
                RESERVE_SPACE(16);
                WRITE32(write->wr_bytes_written);
                WRITE32(write->wr_how_written);
-               WRITEMEM(write->wr_verifier, 8);
+               WRITEMEM(write->wr_verifier.data, 8);
                ADJUST_ARGS();
        }
 }

diff --git a/include/linux/nfs4.h b/include/linux/nfs4.h
index a65be432b9f54aa88a4f5f877dd5daae1c10493b..8bb512eb2b43c22a00808ac55620d8b7e61ef5a3 100644 (file)
--- a/include/linux/nfs4.h
+++ b/include/linux/nfs4.h
@@ -46,8 +46,8 @@
 #define NFS4_ACE_SYSTEM_AUDIT_ACE_TYPE   2
 #define NFS4_ACE_SYSTEM_ALARM_ACE_TYPE   3
 
-typedef char nfs4_verifier[NFS4_VERIFIER_SIZE];
-typedef char nfs4_stateid[16];
+typedef struct { char data[NFS4_VERIFIER_SIZE]; } nfs4_verifier;
+typedef struct { char data[16]; } nfs4_stateid;
 
 enum nfs_opnum4 {
        OP_ACCESS = 3,