tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

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...

Linus Torvalds b42895d6 d3a36fb8

+77 -79
+1 -1
fs/lockd/clntlock.c
··· 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 }
+1 -1
fs/lockd/host.c
··· 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,
-4
fs/lockd/xdr.c
··· 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,
+4 -2
fs/lockd/xdr4.c
··· 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)) ··· 418 417 if (resp->status == nlm_lck_denied) { 419 418 struct file_lock *fl = &resp->lock.fl; 420 419 u32 excl; 421 - s64 start, end, len; 420 + __u64 start, len; 421 + __s64 end; 422 422 423 423 memset(&resp->lock, 0, sizeof(resp->lock)); 424 424 locks_init_lock(fl);
+2 -2
fs/nfs/callback.h
··· 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 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 };
+1 -1
fs/nfs/delegation.c
··· 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;
+2 -2
fs/nfs/dir.c
··· 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 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,
+2 -2
fs/nfs/nfs4proc.c
··· 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 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;
+1 -1
fs/nfs/nfs4state.c
··· 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
+48 -48
fs/nfs/nfs4xdr.c
··· 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 } ··· 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 ··· 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 ··· 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 ··· 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; ··· 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; ··· 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) ··· 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); ··· 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); ··· 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; ··· 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); ··· 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 } ··· 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 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 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 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 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 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 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 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 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 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 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 ··· 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
+5 -5
fs/nfs/read.c
··· 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; ··· 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 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 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 }
+3 -3
fs/nfs/write.c
··· 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 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 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);
+1
include/linux/lockd/xdr4.h
··· 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 */
+2 -1
include/linux/nfs4.h
··· 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 ··· 114 113 }; 115 114 116 115 typedef struct { char data[NFS4_VERIFIER_SIZE]; } nfs4_verifier; 117 - typedef struct { char data[16]; } nfs4_stateid; 116 + typedef struct { char data[NFS4_STATEID_SIZE]; } nfs4_stateid; 118 117 119 118 enum nfs_opnum4 { 120 119 OP_ACCESS = 3,
+2
include/linux/sunrpc/rpc_pipe_fs.h
··· 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
+2
include/linux/sunrpc/xprt.h
··· 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
-2
net/sunrpc/sched.c
··· 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;
-4
net/sunrpc/sunrpc_syms.c
··· 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)