Merge branch 'master' of /home/trondmy/repositories/git/linux-2.6/
authorTrond Myklebust <Trond.Myklebust@netapp.com>
Thu, 17 May 2007 12:23:04 +0000 (08:23 -0400)
committerTrond Myklebust <Trond.Myklebust@netapp.com>
Thu, 17 May 2007 12:23:04 +0000 (08:23 -0400)
18 files changed:
fs/lockd/clntlock.c
fs/lockd/host.c
fs/lockd/xdr.c
fs/lockd/xdr4.c
fs/nfs/callback.h
fs/nfs/delegation.c
fs/nfs/dir.c
fs/nfs/nfs4proc.c
fs/nfs/nfs4state.c
fs/nfs/nfs4xdr.c
fs/nfs/read.c
fs/nfs/write.c
include/linux/lockd/xdr4.h
include/linux/nfs4.h
include/linux/sunrpc/rpc_pipe_fs.h
include/linux/sunrpc/xprt.h
net/sunrpc/sched.c
net/sunrpc/sunrpc_syms.c

index f4d45d4d835b9ff77531d896ababeecf6b090f5d..d070b18e539dac18a8e452bff19524e74b1d793e 100644 (file)
@@ -153,7 +153,7 @@ nlmclnt_recovery(struct nlm_host *host)
        if (!host->h_reclaiming++) {
                nlm_get_host(host);
                __module_get(THIS_MODULE);
-               if (kernel_thread(reclaimer, host, CLONE_KERNEL) < 0)
+               if (kernel_thread(reclaimer, host, CLONE_FS | CLONE_FILES) < 0)
                        module_put(THIS_MODULE);
        }
 }
index ad21c0713efa705ad7aeb5a18f165a46a934453f..96070bff93fc5c9f0ec91cef0c6abadfbf26e1e5 100644 (file)
@@ -221,7 +221,7 @@ nlm_bind_host(struct nlm_host *host)
                                        host->h_nextrebind - jiffies);
                }
        } else {
-               unsigned long increment = nlmsvc_timeout * HZ;
+               unsigned long increment = nlmsvc_timeout;
                struct rpc_timeout timeparms = {
                        .to_initval     = increment,
                        .to_increment   = increment,
index 9702956d206cf69ce9c4d5c6b3d419f0144359e8..5316e307a49d3a17156cbced0828558c37eb9cb7 100644 (file)
@@ -586,10 +586,6 @@ static struct rpc_version  nlm_version3 = {
                .procs          = nlm_procedures,
 };
 
-#ifdef         CONFIG_LOCKD_V4
-extern struct rpc_version nlm_version4;
-#endif
-
 static struct rpc_version *    nlm_versions[] = {
        [1] = &nlm_version1,
        [3] = &nlm_version3,
index ce1efdbe1b3a49616a8698c49efc75b6c2deba2c..846fc1d639ddf94b72e7f793f49d835140c9c43e 100644 (file)
@@ -123,7 +123,8 @@ static __be32 *
 nlm4_decode_lock(__be32 *p, struct nlm_lock *lock)
 {
        struct file_lock        *fl = &lock->fl;
-       __s64                   len, start, end;
+       __u64                   len, start;
+       __s64                   end;
 
        if (!(p = xdr_decode_string_inplace(p, &lock->caller,
                                            &lock->len, NLM_MAXSTRLEN))
@@ -417,7 +418,8 @@ nlm4clt_decode_testres(struct rpc_rqst *req, __be32 *p, struct nlm_res *resp)
        if (resp->status == nlm_lck_denied) {
                struct file_lock        *fl = &resp->lock.fl;
                u32                     excl;
-               s64                     start, end, len;
+               __u64                   start, len;
+               __s64                   end;
 
                memset(&resp->lock, 0, sizeof(resp->lock));
                locks_init_lock(fl);
index db3d7919c60131886f4272a77fd9d330d547de98..c2bb14e053e1cb445494e402b9f8c93d7df4b7c7 100644 (file)
@@ -24,7 +24,7 @@ enum nfs4_callback_opnum {
 };
 
 struct cb_compound_hdr_arg {
-       int taglen;
+       unsigned int taglen;
        const char *tag;
        unsigned int callback_ident;
        unsigned nops;
@@ -32,7 +32,7 @@ struct cb_compound_hdr_arg {
 
 struct cb_compound_hdr_res {
        __be32 *status;
-       int taglen;
+       unsigned int taglen;
        const char *tag;
        __be32 *nops;
 };
index 841c99a9b11c84203cb5afbcb9d69f38f3682319..7f37d1bea83fc3f8c4bdadb968c4f295e1b32cd7 100644 (file)
@@ -226,7 +226,7 @@ restart:
        spin_unlock(&clp->cl_lock);
 }
 
-int nfs_do_expire_all_delegations(void *ptr)
+static int nfs_do_expire_all_delegations(void *ptr)
 {
        struct nfs_client *clp = ptr;
        struct nfs_delegation *delegation;
index 3df4288165591e40d67f647cf13fb353d543cc0a..ac92e45432a340fd82213d960660b06273fff4a2 100644 (file)
@@ -607,7 +607,7 @@ static int nfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
        return res;
 }
 
-loff_t nfs_llseek_dir(struct file *filp, loff_t offset, int origin)
+static loff_t nfs_llseek_dir(struct file *filp, loff_t offset, int origin)
 {
        mutex_lock(&filp->f_path.dentry->d_inode->i_mutex);
        switch (origin) {
@@ -633,7 +633,7 @@ out:
  * All directory operations under NFS are synchronous, so fsync()
  * is a dummy operation.
  */
-int nfs_fsync_dir(struct file *filp, struct dentry *dentry, int datasync)
+static int nfs_fsync_dir(struct file *filp, struct dentry *dentry, int datasync)
 {
        dfprintk(VFS, "NFS: fsync_dir(%s/%s) datasync %d\n",
                        dentry->d_parent->d_name.name, dentry->d_name.name,
index d6a30e965787c375c6e33d1ab956060bdd92cf3d..648e0ac0f90ea07aa74e8f1da5610c30392490ce 100644 (file)
@@ -790,7 +790,7 @@ out:
        return -EACCES;
 }
 
-int nfs4_recover_expired_lease(struct nfs_server *server)
+static int nfs4_recover_expired_lease(struct nfs_server *server)
 {
        struct nfs_client *clp = server->nfs_client;
        int ret;
@@ -2748,7 +2748,7 @@ static int nfs4_delay(struct rpc_clnt *clnt, long *timeout)
 /* This is the error handling routine for processes that are allowed
  * to sleep.
  */
-int nfs4_handle_exception(const struct nfs_server *server, int errorcode, struct nfs4_exception *exception)
+static int nfs4_handle_exception(const struct nfs_server *server, int errorcode, struct nfs4_exception *exception)
 {
        struct nfs_client *clp = server->nfs_client;
        int ret = errorcode;
index 5fffbdfa971f4a070b2e5494e64398bbe4940cb0..8ed79d5c54f9449a4122bb77f4dffcd796a6ec09 100644 (file)
@@ -104,7 +104,7 @@ struct rpc_cred *nfs4_get_renew_cred(struct nfs_client *clp)
        return cred;
 }
 
-struct rpc_cred *nfs4_get_setclientid_cred(struct nfs_client *clp)
+static struct rpc_cred *nfs4_get_setclientid_cred(struct nfs_client *clp)
 {
        struct nfs4_state_owner *sp;
 
index 938f37166788d97643c14b6112318d091b412398..8003c91ccb9a0a5ca374f58dee3594b00615c5f0 100644 (file)
@@ -646,10 +646,10 @@ static int encode_close(struct xdr_stream *xdr, const struct nfs_closeargs *arg)
 {
        __be32 *p;
 
-       RESERVE_SPACE(8+sizeof(arg->stateid->data));
+       RESERVE_SPACE(8+NFS4_STATEID_SIZE);
        WRITE32(OP_CLOSE);
        WRITE32(arg->seqid->sequence->counter);
-       WRITEMEM(arg->stateid->data, sizeof(arg->stateid->data));
+       WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE);
        
        return 0;
 }
@@ -793,17 +793,17 @@ static int encode_lock(struct xdr_stream *xdr, const struct nfs_lock_args *args)
        WRITE64(nfs4_lock_length(args->fl));
        WRITE32(args->new_lock_owner);
        if (args->new_lock_owner){
-               RESERVE_SPACE(40);
+               RESERVE_SPACE(4+NFS4_STATEID_SIZE+20);
                WRITE32(args->open_seqid->sequence->counter);
-               WRITEMEM(args->open_stateid->data, sizeof(args->open_stateid->data));
+               WRITEMEM(args->open_stateid->data, NFS4_STATEID_SIZE);
                WRITE32(args->lock_seqid->sequence->counter);
                WRITE64(args->lock_owner.clientid);
                WRITE32(4);
                WRITE32(args->lock_owner.id);
        }
        else {
-               RESERVE_SPACE(20);
-               WRITEMEM(args->lock_stateid->data, sizeof(args->lock_stateid->data));
+               RESERVE_SPACE(NFS4_STATEID_SIZE+4);
+               WRITEMEM(args->lock_stateid->data, NFS4_STATEID_SIZE);
                WRITE32(args->lock_seqid->sequence->counter);
        }
 
@@ -830,11 +830,11 @@ static int encode_locku(struct xdr_stream *xdr, const struct nfs_locku_args *arg
 {
        __be32 *p;
 
-       RESERVE_SPACE(44);
+       RESERVE_SPACE(12+NFS4_STATEID_SIZE+16);
        WRITE32(OP_LOCKU);
        WRITE32(nfs4_lock_type(args->fl, 0));
        WRITE32(args->seqid->sequence->counter);
-       WRITEMEM(args->stateid->data, sizeof(args->stateid->data));
+       WRITEMEM(args->stateid->data, NFS4_STATEID_SIZE);
        WRITE64(args->fl->fl_start);
        WRITE64(nfs4_lock_length(args->fl));
 
@@ -966,9 +966,9 @@ static inline void encode_claim_delegate_cur(struct xdr_stream *xdr, const struc
 {
        __be32 *p;
 
-       RESERVE_SPACE(4+sizeof(stateid->data));
+       RESERVE_SPACE(4+NFS4_STATEID_SIZE);
        WRITE32(NFS4_OPEN_CLAIM_DELEGATE_CUR);
-       WRITEMEM(stateid->data, sizeof(stateid->data));
+       WRITEMEM(stateid->data, NFS4_STATEID_SIZE);
        encode_string(xdr, name->len, name->name);
 }
 
@@ -996,9 +996,9 @@ static int encode_open_confirm(struct xdr_stream *xdr, const struct nfs_open_con
 {
        __be32 *p;
 
-       RESERVE_SPACE(8+sizeof(arg->stateid->data));
+       RESERVE_SPACE(4+NFS4_STATEID_SIZE+4);
        WRITE32(OP_OPEN_CONFIRM);
-       WRITEMEM(arg->stateid->data, sizeof(arg->stateid->data));
+       WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE);
        WRITE32(arg->seqid->sequence->counter);
 
        return 0;
@@ -1008,9 +1008,9 @@ static int encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closea
 {
        __be32 *p;
 
-       RESERVE_SPACE(8+sizeof(arg->stateid->data));
+       RESERVE_SPACE(4+NFS4_STATEID_SIZE+4);
        WRITE32(OP_OPEN_DOWNGRADE);
-       WRITEMEM(arg->stateid->data, sizeof(arg->stateid->data));
+       WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE);
        WRITE32(arg->seqid->sequence->counter);
        encode_share_access(xdr, arg->open_flags);
        return 0;
@@ -1045,12 +1045,12 @@ static void encode_stateid(struct xdr_stream *xdr, const struct nfs_open_context
        nfs4_stateid stateid;
        __be32 *p;
 
-       RESERVE_SPACE(16);
+       RESERVE_SPACE(NFS4_STATEID_SIZE);
        if (ctx->state != NULL) {
                nfs4_copy_stateid(&stateid, ctx->state, ctx->lockowner);
-               WRITEMEM(stateid.data, sizeof(stateid.data));
+               WRITEMEM(stateid.data, NFS4_STATEID_SIZE);
        } else
-               WRITEMEM(zero_stateid.data, sizeof(zero_stateid.data));
+               WRITEMEM(zero_stateid.data, NFS4_STATEID_SIZE);
 }
 
 static int encode_read(struct xdr_stream *xdr, const struct nfs_readargs *args)
@@ -1079,10 +1079,10 @@ static int encode_readdir(struct xdr_stream *xdr, const struct nfs4_readdir_arg
        int replen;
        __be32 *p;
 
-       RESERVE_SPACE(32+sizeof(nfs4_verifier));
+       RESERVE_SPACE(12+NFS4_VERIFIER_SIZE+20);
        WRITE32(OP_READDIR);
        WRITE64(readdir->cookie);
-       WRITEMEM(readdir->verifier.data, sizeof(readdir->verifier.data));
+       WRITEMEM(readdir->verifier.data, NFS4_VERIFIER_SIZE);
        WRITE32(readdir->count >> 1);  /* We're not doing readdirplus */
        WRITE32(readdir->count);
        WRITE32(2);
@@ -1190,9 +1190,9 @@ encode_setacl(struct xdr_stream *xdr, struct nfs_setaclargs *arg)
 {
        __be32 *p;
 
-       RESERVE_SPACE(4+sizeof(zero_stateid.data));
+       RESERVE_SPACE(4+NFS4_STATEID_SIZE);
        WRITE32(OP_SETATTR);
-       WRITEMEM(zero_stateid.data, sizeof(zero_stateid.data));
+       WRITEMEM(zero_stateid.data, NFS4_STATEID_SIZE);
        RESERVE_SPACE(2*4);
        WRITE32(1);
        WRITE32(FATTR4_WORD0_ACL);
@@ -1220,9 +1220,9 @@ static int encode_setattr(struct xdr_stream *xdr, const struct nfs_setattrargs *
        int status;
        __be32 *p;
        
-        RESERVE_SPACE(4+sizeof(arg->stateid.data));
+        RESERVE_SPACE(4+NFS4_STATEID_SIZE);
         WRITE32(OP_SETATTR);
-       WRITEMEM(arg->stateid.data, sizeof(arg->stateid.data));
+       WRITEMEM(arg->stateid.data, NFS4_STATEID_SIZE);
 
         if ((status = encode_attrs(xdr, arg->iap, server)))
                return status;
@@ -1234,9 +1234,9 @@ static int encode_setclientid(struct xdr_stream *xdr, const struct nfs4_setclien
 {
        __be32 *p;
 
-       RESERVE_SPACE(4 + sizeof(setclientid->sc_verifier->data));
+       RESERVE_SPACE(4 + NFS4_VERIFIER_SIZE);
        WRITE32(OP_SETCLIENTID);
-       WRITEMEM(setclientid->sc_verifier->data, sizeof(setclientid->sc_verifier->data));
+       WRITEMEM(setclientid->sc_verifier->data, NFS4_VERIFIER_SIZE);
 
        encode_string(xdr, setclientid->sc_name_len, setclientid->sc_name);
        RESERVE_SPACE(4);
@@ -1253,10 +1253,10 @@ static int encode_setclientid_confirm(struct xdr_stream *xdr, const struct nfs_c
 {
         __be32 *p;
 
-        RESERVE_SPACE(12 + sizeof(client_state->cl_confirm.data));
+        RESERVE_SPACE(12 + NFS4_VERIFIER_SIZE);
         WRITE32(OP_SETCLIENTID_CONFIRM);
         WRITE64(client_state->cl_clientid);
-        WRITEMEM(client_state->cl_confirm.data, sizeof(client_state->cl_confirm.data));
+        WRITEMEM(client_state->cl_confirm.data, NFS4_VERIFIER_SIZE);
 
         return 0;
 }
@@ -1284,10 +1284,10 @@ static int encode_delegreturn(struct xdr_stream *xdr, const nfs4_stateid *statei
 {
        __be32 *p;
 
-       RESERVE_SPACE(20);
+       RESERVE_SPACE(4+NFS4_STATEID_SIZE);
 
        WRITE32(OP_DELEGRETURN);
-       WRITEMEM(stateid->data, sizeof(stateid->data));
+       WRITEMEM(stateid->data, NFS4_STATEID_SIZE);
        return 0;
 
 }
@@ -2494,7 +2494,7 @@ static int decode_attr_fs_locations(struct xdr_stream *xdr, uint32_t *bitmap, st
                                int i;
                                dprintk("%s: using first %d of %d servers returned for location %d\n", __FUNCTION__, NFS4_FS_LOCATION_MAXSERVERS, m, res->nlocations);
                                for (i = loc->nservers; i < m; i++) {
-                                       int len;
+                                       unsigned int len;
                                        char *data;
                                        status = decode_opaque_inline(xdr, &len, &data);
                                        if (unlikely(status != 0))
@@ -2642,7 +2642,7 @@ static int decode_attr_nlink(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t
        return 0;
 }
 
-static int decode_attr_owner(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs_client *clp, int32_t *uid)
+static int decode_attr_owner(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs_client *clp, uint32_t *uid)
 {
        uint32_t len;
        __be32 *p;
@@ -2667,7 +2667,7 @@ static int decode_attr_owner(struct xdr_stream *xdr, uint32_t *bitmap, struct nf
        return 0;
 }
 
-static int decode_attr_group(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs_client *clp, int32_t *gid)
+static int decode_attr_group(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs_client *clp, uint32_t *gid)
 {
        uint32_t len;
        __be32 *p;
@@ -2897,8 +2897,8 @@ static int decode_close(struct xdr_stream *xdr, struct nfs_closeres *res)
        status = decode_op_hdr(xdr, OP_CLOSE);
        if (status)
                return status;
-       READ_BUF(sizeof(res->stateid.data));
-       COPYMEM(res->stateid.data, sizeof(res->stateid.data));
+       READ_BUF(NFS4_STATEID_SIZE);
+       COPYMEM(res->stateid.data, NFS4_STATEID_SIZE);
        return 0;
 }
 
@@ -3186,8 +3186,8 @@ static int decode_lock(struct xdr_stream *xdr, struct nfs_lock_res *res)
 
        status = decode_op_hdr(xdr, OP_LOCK);
        if (status == 0) {
-               READ_BUF(sizeof(res->stateid.data));
-               COPYMEM(res->stateid.data, sizeof(res->stateid.data));
+               READ_BUF(NFS4_STATEID_SIZE);
+               COPYMEM(res->stateid.data, NFS4_STATEID_SIZE);
        } else if (status == -NFS4ERR_DENIED)
                return decode_lock_denied(xdr, NULL);
        return status;
@@ -3209,8 +3209,8 @@ static int decode_locku(struct xdr_stream *xdr, struct nfs_locku_res *res)
 
        status = decode_op_hdr(xdr, OP_LOCKU);
        if (status == 0) {
-               READ_BUF(sizeof(res->stateid.data));
-               COPYMEM(res->stateid.data, sizeof(res->stateid.data));
+               READ_BUF(NFS4_STATEID_SIZE);
+               COPYMEM(res->stateid.data, NFS4_STATEID_SIZE);
        }
        return status;
 }
@@ -3251,8 +3251,8 @@ static int decode_delegation(struct xdr_stream *xdr, struct nfs_openres *res)
                res->delegation_type = 0;
                return 0;
        }
-       READ_BUF(20);
-       COPYMEM(res->delegation.data, sizeof(res->delegation.data));
+       READ_BUF(NFS4_STATEID_SIZE+4);
+       COPYMEM(res->delegation.data, NFS4_STATEID_SIZE);
        READ32(res->do_recall);
        switch (delegation_type) {
                case NFS4_OPEN_DELEGATE_READ:
@@ -3275,8 +3275,8 @@ static int decode_open(struct xdr_stream *xdr, struct nfs_openres *res)
         status = decode_op_hdr(xdr, OP_OPEN);
         if (status)
                 return status;
-        READ_BUF(sizeof(res->stateid.data));
-        COPYMEM(res->stateid.data, sizeof(res->stateid.data));
+        READ_BUF(NFS4_STATEID_SIZE);
+        COPYMEM(res->stateid.data, NFS4_STATEID_SIZE);
 
         decode_change_info(xdr, &res->cinfo);
 
@@ -3302,8 +3302,8 @@ static int decode_open_confirm(struct xdr_stream *xdr, struct nfs_open_confirmre
         status = decode_op_hdr(xdr, OP_OPEN_CONFIRM);
         if (status)
                 return status;
-        READ_BUF(sizeof(res->stateid.data));
-        COPYMEM(res->stateid.data, sizeof(res->stateid.data));
+        READ_BUF(NFS4_STATEID_SIZE);
+        COPYMEM(res->stateid.data, NFS4_STATEID_SIZE);
         return 0;
 }
 
@@ -3315,8 +3315,8 @@ static int decode_open_downgrade(struct xdr_stream *xdr, struct nfs_closeres *re
        status = decode_op_hdr(xdr, OP_OPEN_DOWNGRADE);
        if (status)
                return status;
-       READ_BUF(sizeof(res->stateid.data));
-       COPYMEM(res->stateid.data, sizeof(res->stateid.data));
+       READ_BUF(NFS4_STATEID_SIZE);
+       COPYMEM(res->stateid.data, NFS4_STATEID_SIZE);
        return 0;
 }
 
@@ -3590,9 +3590,9 @@ static int decode_setclientid(struct xdr_stream *xdr, struct nfs_client *clp)
        }
        READ32(nfserr);
        if (nfserr == NFS_OK) {
-               READ_BUF(8 + sizeof(clp->cl_confirm.data));
+               READ_BUF(8 + NFS4_VERIFIER_SIZE);
                READ64(clp->cl_clientid);
-               COPYMEM(clp->cl_confirm.data, sizeof(clp->cl_confirm.data));
+               COPYMEM(clp->cl_confirm.data, NFS4_VERIFIER_SIZE);
        } else if (nfserr == NFSERR_CLID_INUSE) {
                uint32_t len;
 
index 9a55807b2a701f6b33cee3bf195140e8b724f314..7bd7cb95c034d8bbcdbcdb05fbba5f46a291e68c 100644 (file)
@@ -79,7 +79,7 @@ void nfs_readdata_release(void *data)
 static
 int nfs_return_empty_page(struct page *page)
 {
-       memclear_highpage_flush(page, 0, PAGE_CACHE_SIZE);
+       zero_user_page(page, 0, PAGE_CACHE_SIZE, KM_USER0);
        SetPageUptodate(page);
        unlock_page(page);
        return 0;
@@ -103,10 +103,10 @@ static void nfs_readpage_truncate_uninitialised_page(struct nfs_read_data *data)
        pglen = PAGE_CACHE_SIZE - base;
        for (;;) {
                if (remainder <= pglen) {
-                       memclear_highpage_flush(*pages, base, remainder);
+                       zero_user_page(*pages, base, remainder, KM_USER0);
                        break;
                }
-               memclear_highpage_flush(*pages, base, pglen);
+               zero_user_page(*pages, base, pglen, KM_USER0);
                pages++;
                remainder -= pglen;
                pglen = PAGE_CACHE_SIZE;
@@ -130,7 +130,7 @@ static int nfs_readpage_async(struct nfs_open_context *ctx, struct inode *inode,
                return PTR_ERR(new);
        }
        if (len < PAGE_CACHE_SIZE)
-               memclear_highpage_flush(page, len, PAGE_CACHE_SIZE - len);
+               zero_user_page(page, len, PAGE_CACHE_SIZE - len, KM_USER0);
 
        nfs_list_add_request(new, &one_request);
        if (NFS_SERVER(inode)->rsize < PAGE_CACHE_SIZE)
@@ -532,7 +532,7 @@ readpage_async_filler(void *data, struct page *page)
                        return PTR_ERR(new);
        }
        if (len < PAGE_CACHE_SIZE)
-               memclear_highpage_flush(page, len, PAGE_CACHE_SIZE - len);
+               zero_user_page(page, len, PAGE_CACHE_SIZE - len, KM_USER0);
        nfs_pageio_add_request(desc->pgio, new);
        return 0;
 }
index de92b9509d948f7bbcaf07a802a5d85b69cf6104..b084c03ce493f09de40612a0ed22abc1ad84ea22 100644 (file)
@@ -58,7 +58,7 @@ struct nfs_write_data *nfs_commit_alloc(void)
        return p;
 }
 
-void nfs_commit_rcu_free(struct rcu_head *head)
+static void nfs_commit_rcu_free(struct rcu_head *head)
 {
        struct nfs_write_data *p = container_of(head, struct nfs_write_data, task.u.tk_rcu);
        if (p && (p->pagevec != &p->page_array[0]))
@@ -168,7 +168,7 @@ static void nfs_mark_uptodate(struct page *page, unsigned int base, unsigned int
        if (count != nfs_page_length(page))
                return;
        if (count != PAGE_CACHE_SIZE)
-               memclear_highpage_flush(page, count, PAGE_CACHE_SIZE - count);
+               zero_user_page(page, count, PAGE_CACHE_SIZE - count, KM_USER0);
        SetPageUptodate(page);
 }
 
@@ -922,7 +922,7 @@ static int nfs_flush_one(struct inode *inode, struct list_head *head, unsigned i
        return 0;
  out_bad:
        while (!list_empty(head)) {
-               struct nfs_page *req = nfs_list_entry(head->next);
+               req = nfs_list_entry(head->next);
                nfs_list_remove_request(req);
                nfs_redirty_request(req);
                nfs_end_page_writeback(req->wb_page);
index dd12b4c9e613eab54d82c6eb2b7deb139b774cbe..12bfe09de2b11629993f80f29d9c947f045d494b 100644 (file)
@@ -42,5 +42,6 @@ int   nlmclt_encode_lockargs(struct rpc_rqst *, u32 *, struct nlm_args *);
 int    nlmclt_encode_cancargs(struct rpc_rqst *, u32 *, struct nlm_args *);
 int    nlmclt_encode_unlockargs(struct rpc_rqst *, u32 *, struct nlm_args *);
  */
+extern struct rpc_version nlm_version4;
 
 #endif /* LOCKD_XDR4_H */
index 1be5be88debe77c5e51aed74ef77fb8697974b5f..7e7f33a38fc06ba6b06929a9f1e94f77e6b09cae 100644 (file)
@@ -16,6 +16,7 @@
 #include <linux/types.h>
 
 #define NFS4_VERIFIER_SIZE     8
+#define NFS4_STATEID_SIZE      16
 #define NFS4_FHSIZE            128
 #define NFS4_MAXPATHLEN                PATH_MAX
 #define NFS4_MAXNAMLEN         NAME_MAX
@@ -113,7 +114,7 @@ struct nfs4_acl {
 };
 
 typedef struct { char data[NFS4_VERIFIER_SIZE]; } nfs4_verifier;
-typedef struct { char data[16]; } nfs4_stateid;
+typedef struct { char data[NFS4_STATEID_SIZE]; } nfs4_stateid;
 
 enum nfs_opnum4 {
        OP_ACCESS = 3,
index 4a68125b6de6308a37b6133973088da421e08fd4..ad293760f6ebaa23b6d1c85666eb78e57ffc873e 100644 (file)
@@ -47,6 +47,8 @@ extern struct dentry *rpc_mkpipe(struct dentry *, const char *, void *, struct r
 extern int rpc_unlink(struct dentry *);
 extern struct vfsmount *rpc_get_mount(void);
 extern void rpc_put_mount(void);
+extern int register_rpc_pipefs(void);
+extern void unregister_rpc_pipefs(void);
 
 #endif
 #endif
index fa89ce6ce076cb61ac98ebb80d85af3e33f524be..34f7590506fac8239add141704e2c59b83878c9d 100644 (file)
@@ -244,6 +244,8 @@ void                        xprt_disconnect(struct rpc_xprt *xprt);
  */
 struct rpc_xprt *      xs_setup_udp(struct sockaddr *addr, size_t addrlen, struct rpc_timeout *to);
 struct rpc_xprt *      xs_setup_tcp(struct sockaddr *addr, size_t addrlen, struct rpc_timeout *to);
+int                    init_socket_xprt(void);
+void                   cleanup_socket_xprt(void);
 
 /*
  * Reserved bit positions in xprt->state
index b011eb625e49ca1ce89a1970148170772d257a4c..944d75396fb3a39448b20c4036932917c631dd46 100644 (file)
@@ -989,8 +989,6 @@ void rpc_killall_tasks(struct rpc_clnt *clnt)
        spin_unlock(&rpc_sched_lock);
 }
 
-static DECLARE_MUTEX_LOCKED(rpciod_running);
-
 static void rpciod_killall(void)
 {
        unsigned long flags;
index 0d35bc796d0034bba98284c4d7fd75bf93e7153f..73075dec83c07e4d73503156ca22668519cdfcf5 100644 (file)
@@ -134,11 +134,7 @@ EXPORT_SYMBOL(nfsd_debug);
 EXPORT_SYMBOL(nlm_debug);
 #endif
 
-extern int register_rpc_pipefs(void);
-extern void unregister_rpc_pipefs(void);
 extern struct cache_detail ip_map_cache, unix_gid_cache;
-extern int init_socket_xprt(void);
-extern void cleanup_socket_xprt(void);
 
 static int __init
 init_sunrpc(void)