Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit b42895d6fe66995ab101c15d9a59c78474dbf382

Authored by Linus Torvalds
2 parents d3a36fb82a dd504ea16f
Exists in master and in 7 other branches imx_3.0.35_4.1.0, imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga, smarc-l5.0.0_1.0.0-ga

Merge git://git.linux-nfs.org/pub/linux/nfs-2.6 

* git://git.linux-nfs.org/pub/linux/nfs-2.6:
  SUNRPC: Fix sparse warnings
  NLM: Fix sparse warnings
  NFS: Fix more sparse warnings
  NFS: Fix some 'sparse' warnings...
  SUNRPC: remove dead variable 'rpciod_running'
  NFS4: Fix incorrect use of sizeof() in fs/nfs/nfs4xdr.c
  NFS: use zero_user_page
  NLM: don't use CLONE_SIGHAND in nlmclnt_recovery
  NLM: Fix locking client timeouts...

Showing 18 changed files Side-by-side Diff

... ... @@ -153,7 +153,7 @@
153 153 if (!host->h_reclaiming++) {
154 154 nlm_get_host(host);
155 155 __module_get(THIS_MODULE);
156   - if (kernel_thread(reclaimer, host, CLONE_KERNEL) < 0)
  156 + if (kernel_thread(reclaimer, host, CLONE_FS | CLONE_FILES) < 0)
157 157 module_put(THIS_MODULE);
158 158 }
159 159 }
... ... @@ -221,7 +221,7 @@
221 221 host->h_nextrebind - jiffies);
222 222 }
223 223 } else {
224   - unsigned long increment = nlmsvc_timeout * HZ;
  224 + unsigned long increment = nlmsvc_timeout;
225 225 struct rpc_timeout timeparms = {
226 226 .to_initval = increment,
227 227 .to_increment = increment,
... ... @@ -586,10 +586,6 @@
586 586 .procs = nlm_procedures,
587 587 };
588 588  
589   -#ifdef CONFIG_LOCKD_V4
590   -extern struct rpc_version nlm_version4;
591   -#endif
592   -
593 589 static struct rpc_version * nlm_versions[] = {
594 590 [1] = &nlm_version1,
595 591 [3] = &nlm_version3,
... ... @@ -123,7 +123,8 @@
123 123 nlm4_decode_lock(__be32 *p, struct nlm_lock *lock)
124 124 {
125 125 struct file_lock *fl = &lock->fl;
126   - __s64 len, start, end;
  126 + __u64 len, start;
  127 + __s64 end;
127 128  
128 129 if (!(p = xdr_decode_string_inplace(p, &lock->caller,
129 130 &lock->len, NLM_MAXSTRLEN))
... ... @@ -417,7 +418,8 @@
417 418 if (resp->status == nlm_lck_denied) {
418 419 struct file_lock *fl = &resp->lock.fl;
419 420 u32 excl;
420   - s64 start, end, len;
  421 + __u64 start, len;
  422 + __s64 end;
421 423  
422 424 memset(&resp->lock, 0, sizeof(resp->lock));
423 425 locks_init_lock(fl);
... ... @@ -24,7 +24,7 @@
24 24 };
25 25  
26 26 struct cb_compound_hdr_arg {
27   - int taglen;
  27 + unsigned int taglen;
28 28 const char *tag;
29 29 unsigned int callback_ident;
30 30 unsigned nops;
... ... @@ -32,7 +32,7 @@
32 32  
33 33 struct cb_compound_hdr_res {
34 34 __be32 *status;
35   - int taglen;
  35 + unsigned int taglen;
36 36 const char *tag;
37 37 __be32 *nops;
38 38 };
... ... @@ -226,7 +226,7 @@
226 226 spin_unlock(&clp->cl_lock);
227 227 }
228 228  
229   -int nfs_do_expire_all_delegations(void *ptr)
  229 +static int nfs_do_expire_all_delegations(void *ptr)
230 230 {
231 231 struct nfs_client *clp = ptr;
232 232 struct nfs_delegation *delegation;
... ... @@ -607,7 +607,7 @@
607 607 return res;
608 608 }
609 609  
610   -loff_t nfs_llseek_dir(struct file *filp, loff_t offset, int origin)
  610 +static loff_t nfs_llseek_dir(struct file *filp, loff_t offset, int origin)
611 611 {
612 612 mutex_lock(&filp->f_path.dentry->d_inode->i_mutex);
613 613 switch (origin) {
... ... @@ -633,7 +633,7 @@
633 633 * All directory operations under NFS are synchronous, so fsync()
634 634 * is a dummy operation.
635 635 */
636   -int nfs_fsync_dir(struct file *filp, struct dentry *dentry, int datasync)
  636 +static int nfs_fsync_dir(struct file *filp, struct dentry *dentry, int datasync)
637 637 {
638 638 dfprintk(VFS, "NFS: fsync_dir(%s/%s) datasync %d\n",
639 639 dentry->d_parent->d_name.name, dentry->d_name.name,
... ... @@ -790,7 +790,7 @@
790 790 return -EACCES;
791 791 }
792 792  
793   -int nfs4_recover_expired_lease(struct nfs_server *server)
  793 +static int nfs4_recover_expired_lease(struct nfs_server *server)
794 794 {
795 795 struct nfs_client *clp = server->nfs_client;
796 796 int ret;
... ... @@ -2748,7 +2748,7 @@
2748 2748 /* This is the error handling routine for processes that are allowed
2749 2749 * to sleep.
2750 2750 */
2751   -int nfs4_handle_exception(const struct nfs_server *server, int errorcode, struct nfs4_exception *exception)
  2751 +static int nfs4_handle_exception(const struct nfs_server *server, int errorcode, struct nfs4_exception *exception)
2752 2752 {
2753 2753 struct nfs_client *clp = server->nfs_client;
2754 2754 int ret = errorcode;
... ... @@ -104,7 +104,7 @@
104 104 return cred;
105 105 }
106 106  
107   -struct rpc_cred *nfs4_get_setclientid_cred(struct nfs_client *clp)
  107 +static struct rpc_cred *nfs4_get_setclientid_cred(struct nfs_client *clp)
108 108 {
109 109 struct nfs4_state_owner *sp;
110 110  
... ... @@ -646,10 +646,10 @@
646 646 {
647 647 __be32 *p;
648 648  
649   - RESERVE_SPACE(8+sizeof(arg->stateid->data));
  649 + RESERVE_SPACE(8+NFS4_STATEID_SIZE);
650 650 WRITE32(OP_CLOSE);
651 651 WRITE32(arg->seqid->sequence->counter);
652   - WRITEMEM(arg->stateid->data, sizeof(arg->stateid->data));
  652 + WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE);
653 653  
654 654 return 0;
655 655 }
656 656  
657 657  
... ... @@ -793,17 +793,17 @@
793 793 WRITE64(nfs4_lock_length(args->fl));
794 794 WRITE32(args->new_lock_owner);
795 795 if (args->new_lock_owner){
796   - RESERVE_SPACE(40);
  796 + RESERVE_SPACE(4+NFS4_STATEID_SIZE+20);
797 797 WRITE32(args->open_seqid->sequence->counter);
798   - WRITEMEM(args->open_stateid->data, sizeof(args->open_stateid->data));
  798 + WRITEMEM(args->open_stateid->data, NFS4_STATEID_SIZE);
799 799 WRITE32(args->lock_seqid->sequence->counter);
800 800 WRITE64(args->lock_owner.clientid);
801 801 WRITE32(4);
802 802 WRITE32(args->lock_owner.id);
803 803 }
804 804 else {
805   - RESERVE_SPACE(20);
806   - WRITEMEM(args->lock_stateid->data, sizeof(args->lock_stateid->data));
  805 + RESERVE_SPACE(NFS4_STATEID_SIZE+4);
  806 + WRITEMEM(args->lock_stateid->data, NFS4_STATEID_SIZE);
807 807 WRITE32(args->lock_seqid->sequence->counter);
808 808 }
809 809  
810 810  
... ... @@ -830,11 +830,11 @@
830 830 {
831 831 __be32 *p;
832 832  
833   - RESERVE_SPACE(44);
  833 + RESERVE_SPACE(12+NFS4_STATEID_SIZE+16);
834 834 WRITE32(OP_LOCKU);
835 835 WRITE32(nfs4_lock_type(args->fl, 0));
836 836 WRITE32(args->seqid->sequence->counter);
837   - WRITEMEM(args->stateid->data, sizeof(args->stateid->data));
  837 + WRITEMEM(args->stateid->data, NFS4_STATEID_SIZE);
838 838 WRITE64(args->fl->fl_start);
839 839 WRITE64(nfs4_lock_length(args->fl));
840 840  
841 841  
... ... @@ -966,9 +966,9 @@
966 966 {
967 967 __be32 *p;
968 968  
969   - RESERVE_SPACE(4+sizeof(stateid->data));
  969 + RESERVE_SPACE(4+NFS4_STATEID_SIZE);
970 970 WRITE32(NFS4_OPEN_CLAIM_DELEGATE_CUR);
971   - WRITEMEM(stateid->data, sizeof(stateid->data));
  971 + WRITEMEM(stateid->data, NFS4_STATEID_SIZE);
972 972 encode_string(xdr, name->len, name->name);
973 973 }
974 974  
975 975  
... ... @@ -996,9 +996,9 @@
996 996 {
997 997 __be32 *p;
998 998  
999   - RESERVE_SPACE(8+sizeof(arg->stateid->data));
  999 + RESERVE_SPACE(4+NFS4_STATEID_SIZE+4);
1000 1000 WRITE32(OP_OPEN_CONFIRM);
1001   - WRITEMEM(arg->stateid->data, sizeof(arg->stateid->data));
  1001 + WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE);
1002 1002 WRITE32(arg->seqid->sequence->counter);
1003 1003  
1004 1004 return 0;
1005 1005  
... ... @@ -1008,9 +1008,9 @@
1008 1008 {
1009 1009 __be32 *p;
1010 1010  
1011   - RESERVE_SPACE(8+sizeof(arg->stateid->data));
  1011 + RESERVE_SPACE(4+NFS4_STATEID_SIZE+4);
1012 1012 WRITE32(OP_OPEN_DOWNGRADE);
1013   - WRITEMEM(arg->stateid->data, sizeof(arg->stateid->data));
  1013 + WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE);
1014 1014 WRITE32(arg->seqid->sequence->counter);
1015 1015 encode_share_access(xdr, arg->open_flags);
1016 1016 return 0;
1017 1017  
1018 1018  
... ... @@ -1045,12 +1045,12 @@
1045 1045 nfs4_stateid stateid;
1046 1046 __be32 *p;
1047 1047  
1048   - RESERVE_SPACE(16);
  1048 + RESERVE_SPACE(NFS4_STATEID_SIZE);
1049 1049 if (ctx->state != NULL) {
1050 1050 nfs4_copy_stateid(&stateid, ctx->state, ctx->lockowner);
1051   - WRITEMEM(stateid.data, sizeof(stateid.data));
  1051 + WRITEMEM(stateid.data, NFS4_STATEID_SIZE);
1052 1052 } else
1053   - WRITEMEM(zero_stateid.data, sizeof(zero_stateid.data));
  1053 + WRITEMEM(zero_stateid.data, NFS4_STATEID_SIZE);
1054 1054 }
1055 1055  
1056 1056 static int encode_read(struct xdr_stream *xdr, const struct nfs_readargs *args)
1057 1057  
... ... @@ -1079,10 +1079,10 @@
1079 1079 int replen;
1080 1080 __be32 *p;
1081 1081  
1082   - RESERVE_SPACE(32+sizeof(nfs4_verifier));
  1082 + RESERVE_SPACE(12+NFS4_VERIFIER_SIZE+20);
1083 1083 WRITE32(OP_READDIR);
1084 1084 WRITE64(readdir->cookie);
1085   - WRITEMEM(readdir->verifier.data, sizeof(readdir->verifier.data));
  1085 + WRITEMEM(readdir->verifier.data, NFS4_VERIFIER_SIZE);
1086 1086 WRITE32(readdir->count >> 1); /* We're not doing readdirplus */
1087 1087 WRITE32(readdir->count);
1088 1088 WRITE32(2);
1089 1089  
... ... @@ -1190,9 +1190,9 @@
1190 1190 {
1191 1191 __be32 *p;
1192 1192  
1193   - RESERVE_SPACE(4+sizeof(zero_stateid.data));
  1193 + RESERVE_SPACE(4+NFS4_STATEID_SIZE);
1194 1194 WRITE32(OP_SETATTR);
1195   - WRITEMEM(zero_stateid.data, sizeof(zero_stateid.data));
  1195 + WRITEMEM(zero_stateid.data, NFS4_STATEID_SIZE);
1196 1196 RESERVE_SPACE(2*4);
1197 1197 WRITE32(1);
1198 1198 WRITE32(FATTR4_WORD0_ACL);
1199 1199  
... ... @@ -1220,9 +1220,9 @@
1220 1220 int status;
1221 1221 __be32 *p;
1222 1222  
1223   - RESERVE_SPACE(4+sizeof(arg->stateid.data));
  1223 + RESERVE_SPACE(4+NFS4_STATEID_SIZE);
1224 1224 WRITE32(OP_SETATTR);
1225   - WRITEMEM(arg->stateid.data, sizeof(arg->stateid.data));
  1225 + WRITEMEM(arg->stateid.data, NFS4_STATEID_SIZE);
1226 1226  
1227 1227 if ((status = encode_attrs(xdr, arg->iap, server)))
1228 1228 return status;
1229 1229  
... ... @@ -1234,9 +1234,9 @@
1234 1234 {
1235 1235 __be32 *p;
1236 1236  
1237   - RESERVE_SPACE(4 + sizeof(setclientid->sc_verifier->data));
  1237 + RESERVE_SPACE(4 + NFS4_VERIFIER_SIZE);
1238 1238 WRITE32(OP_SETCLIENTID);
1239   - WRITEMEM(setclientid->sc_verifier->data, sizeof(setclientid->sc_verifier->data));
  1239 + WRITEMEM(setclientid->sc_verifier->data, NFS4_VERIFIER_SIZE);
1240 1240  
1241 1241 encode_string(xdr, setclientid->sc_name_len, setclientid->sc_name);
1242 1242 RESERVE_SPACE(4);
1243 1243  
... ... @@ -1253,10 +1253,10 @@
1253 1253 {
1254 1254 __be32 *p;
1255 1255  
1256   - RESERVE_SPACE(12 + sizeof(client_state->cl_confirm.data));
  1256 + RESERVE_SPACE(12 + NFS4_VERIFIER_SIZE);
1257 1257 WRITE32(OP_SETCLIENTID_CONFIRM);
1258 1258 WRITE64(client_state->cl_clientid);
1259   - WRITEMEM(client_state->cl_confirm.data, sizeof(client_state->cl_confirm.data));
  1259 + WRITEMEM(client_state->cl_confirm.data, NFS4_VERIFIER_SIZE);
1260 1260  
1261 1261 return 0;
1262 1262 }
1263 1263  
... ... @@ -1284,10 +1284,10 @@
1284 1284 {
1285 1285 __be32 *p;
1286 1286  
1287   - RESERVE_SPACE(20);
  1287 + RESERVE_SPACE(4+NFS4_STATEID_SIZE);
1288 1288  
1289 1289 WRITE32(OP_DELEGRETURN);
1290   - WRITEMEM(stateid->data, sizeof(stateid->data));
  1290 + WRITEMEM(stateid->data, NFS4_STATEID_SIZE);
1291 1291 return 0;
1292 1292  
1293 1293 }
... ... @@ -2494,7 +2494,7 @@
2494 2494 int i;
2495 2495 dprintk("%s: using first %d of %d servers returned for location %d\n", __FUNCTION__, NFS4_FS_LOCATION_MAXSERVERS, m, res->nlocations);
2496 2496 for (i = loc->nservers; i < m; i++) {
2497   - int len;
  2497 + unsigned int len;
2498 2498 char *data;
2499 2499 status = decode_opaque_inline(xdr, &len, &data);
2500 2500 if (unlikely(status != 0))
... ... @@ -2642,7 +2642,7 @@
2642 2642 return 0;
2643 2643 }
2644 2644  
2645   -static int decode_attr_owner(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs_client *clp, int32_t *uid)
  2645 +static int decode_attr_owner(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs_client *clp, uint32_t *uid)
2646 2646 {
2647 2647 uint32_t len;
2648 2648 __be32 *p;
... ... @@ -2667,7 +2667,7 @@
2667 2667 return 0;
2668 2668 }
2669 2669  
2670   -static int decode_attr_group(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs_client *clp, int32_t *gid)
  2670 +static int decode_attr_group(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs_client *clp, uint32_t *gid)
2671 2671 {
2672 2672 uint32_t len;
2673 2673 __be32 *p;
... ... @@ -2897,8 +2897,8 @@
2897 2897 status = decode_op_hdr(xdr, OP_CLOSE);
2898 2898 if (status)
2899 2899 return status;
2900   - READ_BUF(sizeof(res->stateid.data));
2901   - COPYMEM(res->stateid.data, sizeof(res->stateid.data));
  2900 + READ_BUF(NFS4_STATEID_SIZE);
  2901 + COPYMEM(res->stateid.data, NFS4_STATEID_SIZE);
2902 2902 return 0;
2903 2903 }
2904 2904  
... ... @@ -3186,8 +3186,8 @@
3186 3186  
3187 3187 status = decode_op_hdr(xdr, OP_LOCK);
3188 3188 if (status == 0) {
3189   - READ_BUF(sizeof(res->stateid.data));
3190   - COPYMEM(res->stateid.data, sizeof(res->stateid.data));
  3189 + READ_BUF(NFS4_STATEID_SIZE);
  3190 + COPYMEM(res->stateid.data, NFS4_STATEID_SIZE);
3191 3191 } else if (status == -NFS4ERR_DENIED)
3192 3192 return decode_lock_denied(xdr, NULL);
3193 3193 return status;
... ... @@ -3209,8 +3209,8 @@
3209 3209  
3210 3210 status = decode_op_hdr(xdr, OP_LOCKU);
3211 3211 if (status == 0) {
3212   - READ_BUF(sizeof(res->stateid.data));
3213   - COPYMEM(res->stateid.data, sizeof(res->stateid.data));
  3212 + READ_BUF(NFS4_STATEID_SIZE);
  3213 + COPYMEM(res->stateid.data, NFS4_STATEID_SIZE);
3214 3214 }
3215 3215 return status;
3216 3216 }
... ... @@ -3251,8 +3251,8 @@
3251 3251 res->delegation_type = 0;
3252 3252 return 0;
3253 3253 }
3254   - READ_BUF(20);
3255   - COPYMEM(res->delegation.data, sizeof(res->delegation.data));
  3254 + READ_BUF(NFS4_STATEID_SIZE+4);
  3255 + COPYMEM(res->delegation.data, NFS4_STATEID_SIZE);
3256 3256 READ32(res->do_recall);
3257 3257 switch (delegation_type) {
3258 3258 case NFS4_OPEN_DELEGATE_READ:
... ... @@ -3275,8 +3275,8 @@
3275 3275 status = decode_op_hdr(xdr, OP_OPEN);
3276 3276 if (status)
3277 3277 return status;
3278   - READ_BUF(sizeof(res->stateid.data));
3279   - COPYMEM(res->stateid.data, sizeof(res->stateid.data));
  3278 + READ_BUF(NFS4_STATEID_SIZE);
  3279 + COPYMEM(res->stateid.data, NFS4_STATEID_SIZE);
3280 3280  
3281 3281 decode_change_info(xdr, &res->cinfo);
3282 3282  
... ... @@ -3302,8 +3302,8 @@
3302 3302 status = decode_op_hdr(xdr, OP_OPEN_CONFIRM);
3303 3303 if (status)
3304 3304 return status;
3305   - READ_BUF(sizeof(res->stateid.data));
3306   - COPYMEM(res->stateid.data, sizeof(res->stateid.data));
  3305 + READ_BUF(NFS4_STATEID_SIZE);
  3306 + COPYMEM(res->stateid.data, NFS4_STATEID_SIZE);
3307 3307 return 0;
3308 3308 }
3309 3309  
... ... @@ -3315,8 +3315,8 @@
3315 3315 status = decode_op_hdr(xdr, OP_OPEN_DOWNGRADE);
3316 3316 if (status)
3317 3317 return status;
3318   - READ_BUF(sizeof(res->stateid.data));
3319   - COPYMEM(res->stateid.data, sizeof(res->stateid.data));
  3318 + READ_BUF(NFS4_STATEID_SIZE);
  3319 + COPYMEM(res->stateid.data, NFS4_STATEID_SIZE);
3320 3320 return 0;
3321 3321 }
3322 3322  
3323 3323  
... ... @@ -3590,9 +3590,9 @@
3590 3590 }
3591 3591 READ32(nfserr);
3592 3592 if (nfserr == NFS_OK) {
3593   - READ_BUF(8 + sizeof(clp->cl_confirm.data));
  3593 + READ_BUF(8 + NFS4_VERIFIER_SIZE);
3594 3594 READ64(clp->cl_clientid);
3595   - COPYMEM(clp->cl_confirm.data, sizeof(clp->cl_confirm.data));
  3595 + COPYMEM(clp->cl_confirm.data, NFS4_VERIFIER_SIZE);
3596 3596 } else if (nfserr == NFSERR_CLID_INUSE) {
3597 3597 uint32_t len;
3598 3598  
... ... @@ -79,7 +79,7 @@
79 79 static
80 80 int nfs_return_empty_page(struct page *page)
81 81 {
82   - memclear_highpage_flush(page, 0, PAGE_CACHE_SIZE);
  82 + zero_user_page(page, 0, PAGE_CACHE_SIZE, KM_USER0);
83 83 SetPageUptodate(page);
84 84 unlock_page(page);
85 85 return 0;
86 86  
... ... @@ -103,10 +103,10 @@
103 103 pglen = PAGE_CACHE_SIZE - base;
104 104 for (;;) {
105 105 if (remainder <= pglen) {
106   - memclear_highpage_flush(*pages, base, remainder);
  106 + zero_user_page(*pages, base, remainder, KM_USER0);
107 107 break;
108 108 }
109   - memclear_highpage_flush(*pages, base, pglen);
  109 + zero_user_page(*pages, base, pglen, KM_USER0);
110 110 pages++;
111 111 remainder -= pglen;
112 112 pglen = PAGE_CACHE_SIZE;
... ... @@ -130,7 +130,7 @@
130 130 return PTR_ERR(new);
131 131 }
132 132 if (len < PAGE_CACHE_SIZE)
133   - memclear_highpage_flush(page, len, PAGE_CACHE_SIZE - len);
  133 + zero_user_page(page, len, PAGE_CACHE_SIZE - len, KM_USER0);
134 134  
135 135 nfs_list_add_request(new, &one_request);
136 136 if (NFS_SERVER(inode)->rsize < PAGE_CACHE_SIZE)
... ... @@ -532,7 +532,7 @@
532 532 return PTR_ERR(new);
533 533 }
534 534 if (len < PAGE_CACHE_SIZE)
535   - memclear_highpage_flush(page, len, PAGE_CACHE_SIZE - len);
  535 + zero_user_page(page, len, PAGE_CACHE_SIZE - len, KM_USER0);
536 536 nfs_pageio_add_request(desc->pgio, new);
537 537 return 0;
538 538 }
... ... @@ -58,7 +58,7 @@
58 58 return p;
59 59 }
60 60  
61   -void nfs_commit_rcu_free(struct rcu_head *head)
  61 +static void nfs_commit_rcu_free(struct rcu_head *head)
62 62 {
63 63 struct nfs_write_data *p = container_of(head, struct nfs_write_data, task.u.tk_rcu);
64 64 if (p && (p->pagevec != &p->page_array[0]))
... ... @@ -168,7 +168,7 @@
168 168 if (count != nfs_page_length(page))
169 169 return;
170 170 if (count != PAGE_CACHE_SIZE)
171   - memclear_highpage_flush(page, count, PAGE_CACHE_SIZE - count);
  171 + zero_user_page(page, count, PAGE_CACHE_SIZE - count, KM_USER0);
172 172 SetPageUptodate(page);
173 173 }
174 174  
... ... @@ -922,7 +922,7 @@
922 922 return 0;
923 923 out_bad:
924 924 while (!list_empty(head)) {
925   - struct nfs_page *req = nfs_list_entry(head->next);
  925 + req = nfs_list_entry(head->next);
926 926 nfs_list_remove_request(req);
927 927 nfs_redirty_request(req);
928 928 nfs_end_page_writeback(req->wb_page);
include/linux/lockd/xdr4.h
Diff comments   View file @ b42895d
... ... @@ -42,6 +42,7 @@
42 42 int nlmclt_encode_cancargs(struct rpc_rqst *, u32 *, struct nlm_args *);
43 43 int nlmclt_encode_unlockargs(struct rpc_rqst *, u32 *, struct nlm_args *);
44 44 */
  45 +extern struct rpc_version nlm_version4;
45 46  
46 47 #endif /* LOCKD_XDR4_H */
include/linux/nfs4.h
Diff comments   View file @ b42895d
... ... @@ -16,6 +16,7 @@
16 16 #include <linux/types.h>
17 17  
18 18 #define NFS4_VERIFIER_SIZE 8
  19 +#define NFS4_STATEID_SIZE 16
19 20 #define NFS4_FHSIZE 128
20 21 #define NFS4_MAXPATHLEN PATH_MAX
21 22 #define NFS4_MAXNAMLEN NAME_MAX
... ... @@ -113,7 +114,7 @@
113 114 };
114 115  
115 116 typedef struct { char data[NFS4_VERIFIER_SIZE]; } nfs4_verifier;
116   -typedef struct { char data[16]; } nfs4_stateid;
  117 +typedef struct { char data[NFS4_STATEID_SIZE]; } nfs4_stateid;
117 118  
118 119 enum nfs_opnum4 {
119 120 OP_ACCESS = 3,
include/linux/sunrpc/rpc_pipe_fs.h
Diff comments   View file @ b42895d
... ... @@ -47,6 +47,8 @@
47 47 extern int rpc_unlink(struct dentry *);
48 48 extern struct vfsmount *rpc_get_mount(void);
49 49 extern void rpc_put_mount(void);
  50 +extern int register_rpc_pipefs(void);
  51 +extern void unregister_rpc_pipefs(void);
50 52  
51 53 #endif
52 54 #endif
include/linux/sunrpc/xprt.h
Diff comments   View file @ b42895d
... ... @@ -244,6 +244,8 @@
244 244 */
245 245 struct rpc_xprt * xs_setup_udp(struct sockaddr *addr, size_t addrlen, struct rpc_timeout *to);
246 246 struct rpc_xprt * xs_setup_tcp(struct sockaddr *addr, size_t addrlen, struct rpc_timeout *to);
  247 +int init_socket_xprt(void);
  248 +void cleanup_socket_xprt(void);
247 249  
248 250 /*
249 251 * Reserved bit positions in xprt->state
... ... @@ -989,8 +989,6 @@
989 989 spin_unlock(&rpc_sched_lock);
990 990 }
991 991  
992   -static DECLARE_MUTEX_LOCKED(rpciod_running);
993   -
994 992 static void rpciod_killall(void)
995 993 {
996 994 unsigned long flags;
net/sunrpc/sunrpc_syms.c
Diff comments   View file @ b42895d
... ... @@ -134,11 +134,7 @@
134 134 EXPORT_SYMBOL(nlm_debug);
135 135 #endif
136 136  
137   -extern int register_rpc_pipefs(void);
138   -extern void unregister_rpc_pipefs(void);
139 137 extern struct cache_detail ip_map_cache, unix_gid_cache;
140   -extern int init_socket_xprt(void);
141   -extern void cleanup_socket_xprt(void);
142 138  
143 139 static int __init
144 140 init_sunrpc(void)