diff options
Diffstat (limited to 'fs/nfs/inode.c')
-rw-r--r-- | fs/nfs/inode.c | 1315 |
1 files changed, 67 insertions, 1248 deletions
diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c index 937fbfc381bb..51bc88b662fe 100644 --- a/fs/nfs/inode.c +++ b/fs/nfs/inode.c | |||
@@ -36,6 +36,8 @@ | |||
36 | #include <linux/mount.h> | 36 | #include <linux/mount.h> |
37 | #include <linux/nfs_idmap.h> | 37 | #include <linux/nfs_idmap.h> |
38 | #include <linux/vfs.h> | 38 | #include <linux/vfs.h> |
39 | #include <linux/inet.h> | ||
40 | #include <linux/nfs_xdr.h> | ||
39 | 41 | ||
40 | #include <asm/system.h> | 42 | #include <asm/system.h> |
41 | #include <asm/uaccess.h> | 43 | #include <asm/uaccess.h> |
@@ -44,89 +46,17 @@ | |||
44 | #include "callback.h" | 46 | #include "callback.h" |
45 | #include "delegation.h" | 47 | #include "delegation.h" |
46 | #include "iostat.h" | 48 | #include "iostat.h" |
49 | #include "internal.h" | ||
47 | 50 | ||
48 | #define NFSDBG_FACILITY NFSDBG_VFS | 51 | #define NFSDBG_FACILITY NFSDBG_VFS |
49 | #define NFS_PARANOIA 1 | 52 | #define NFS_PARANOIA 1 |
50 | 53 | ||
51 | /* Maximum number of readahead requests | ||
52 | * FIXME: this should really be a sysctl so that users may tune it to suit | ||
53 | * their needs. People that do NFS over a slow network, might for | ||
54 | * instance want to reduce it to something closer to 1 for improved | ||
55 | * interactive response. | ||
56 | */ | ||
57 | #define NFS_MAX_READAHEAD (RPC_DEF_SLOT_TABLE - 1) | ||
58 | |||
59 | static void nfs_invalidate_inode(struct inode *); | 54 | static void nfs_invalidate_inode(struct inode *); |
60 | static int nfs_update_inode(struct inode *, struct nfs_fattr *); | 55 | static int nfs_update_inode(struct inode *, struct nfs_fattr *); |
61 | 56 | ||
62 | static struct inode *nfs_alloc_inode(struct super_block *sb); | ||
63 | static void nfs_destroy_inode(struct inode *); | ||
64 | static int nfs_write_inode(struct inode *,int); | ||
65 | static void nfs_delete_inode(struct inode *); | ||
66 | static void nfs_clear_inode(struct inode *); | ||
67 | static void nfs_umount_begin(struct super_block *); | ||
68 | static int nfs_statfs(struct dentry *, struct kstatfs *); | ||
69 | static int nfs_show_options(struct seq_file *, struct vfsmount *); | ||
70 | static int nfs_show_stats(struct seq_file *, struct vfsmount *); | ||
71 | static void nfs_zap_acl_cache(struct inode *); | 57 | static void nfs_zap_acl_cache(struct inode *); |
72 | 58 | ||
73 | static struct rpc_program nfs_program; | 59 | static kmem_cache_t * nfs_inode_cachep; |
74 | |||
75 | static struct super_operations nfs_sops = { | ||
76 | .alloc_inode = nfs_alloc_inode, | ||
77 | .destroy_inode = nfs_destroy_inode, | ||
78 | .write_inode = nfs_write_inode, | ||
79 | .delete_inode = nfs_delete_inode, | ||
80 | .statfs = nfs_statfs, | ||
81 | .clear_inode = nfs_clear_inode, | ||
82 | .umount_begin = nfs_umount_begin, | ||
83 | .show_options = nfs_show_options, | ||
84 | .show_stats = nfs_show_stats, | ||
85 | }; | ||
86 | |||
87 | /* | ||
88 | * RPC cruft for NFS | ||
89 | */ | ||
90 | static struct rpc_stat nfs_rpcstat = { | ||
91 | .program = &nfs_program | ||
92 | }; | ||
93 | static struct rpc_version * nfs_version[] = { | ||
94 | NULL, | ||
95 | NULL, | ||
96 | &nfs_version2, | ||
97 | #if defined(CONFIG_NFS_V3) | ||
98 | &nfs_version3, | ||
99 | #elif defined(CONFIG_NFS_V4) | ||
100 | NULL, | ||
101 | #endif | ||
102 | #if defined(CONFIG_NFS_V4) | ||
103 | &nfs_version4, | ||
104 | #endif | ||
105 | }; | ||
106 | |||
107 | static struct rpc_program nfs_program = { | ||
108 | .name = "nfs", | ||
109 | .number = NFS_PROGRAM, | ||
110 | .nrvers = ARRAY_SIZE(nfs_version), | ||
111 | .version = nfs_version, | ||
112 | .stats = &nfs_rpcstat, | ||
113 | .pipe_dir_name = "/nfs", | ||
114 | }; | ||
115 | |||
116 | #ifdef CONFIG_NFS_V3_ACL | ||
117 | static struct rpc_stat nfsacl_rpcstat = { &nfsacl_program }; | ||
118 | static struct rpc_version * nfsacl_version[] = { | ||
119 | [3] = &nfsacl_version3, | ||
120 | }; | ||
121 | |||
122 | struct rpc_program nfsacl_program = { | ||
123 | .name = "nfsacl", | ||
124 | .number = NFS_ACL_PROGRAM, | ||
125 | .nrvers = ARRAY_SIZE(nfsacl_version), | ||
126 | .version = nfsacl_version, | ||
127 | .stats = &nfsacl_rpcstat, | ||
128 | }; | ||
129 | #endif /* CONFIG_NFS_V3_ACL */ | ||
130 | 60 | ||
131 | static inline unsigned long | 61 | static inline unsigned long |
132 | nfs_fattr_to_ino_t(struct nfs_fattr *fattr) | 62 | nfs_fattr_to_ino_t(struct nfs_fattr *fattr) |
@@ -134,8 +64,7 @@ nfs_fattr_to_ino_t(struct nfs_fattr *fattr) | |||
134 | return nfs_fileid_to_ino_t(fattr->fileid); | 64 | return nfs_fileid_to_ino_t(fattr->fileid); |
135 | } | 65 | } |
136 | 66 | ||
137 | static int | 67 | int nfs_write_inode(struct inode *inode, int sync) |
138 | nfs_write_inode(struct inode *inode, int sync) | ||
139 | { | 68 | { |
140 | int flags = sync ? FLUSH_SYNC : 0; | 69 | int flags = sync ? FLUSH_SYNC : 0; |
141 | int ret; | 70 | int ret; |
@@ -146,31 +75,15 @@ nfs_write_inode(struct inode *inode, int sync) | |||
146 | return 0; | 75 | return 0; |
147 | } | 76 | } |
148 | 77 | ||
149 | static void | 78 | void nfs_clear_inode(struct inode *inode) |
150 | nfs_delete_inode(struct inode * inode) | ||
151 | { | 79 | { |
152 | dprintk("NFS: delete_inode(%s/%ld)\n", inode->i_sb->s_id, inode->i_ino); | 80 | struct nfs_inode *nfsi = NFS_I(inode); |
153 | 81 | struct rpc_cred *cred; | |
154 | truncate_inode_pages(&inode->i_data, 0); | ||
155 | 82 | ||
156 | nfs_wb_all(inode); | ||
157 | /* | 83 | /* |
158 | * The following should never happen... | 84 | * The following should never happen... |
159 | */ | 85 | */ |
160 | if (nfs_have_writebacks(inode)) { | 86 | BUG_ON(nfs_have_writebacks(inode)); |
161 | printk(KERN_ERR "nfs_delete_inode: inode %ld has pending RPC requests\n", inode->i_ino); | ||
162 | } | ||
163 | |||
164 | clear_inode(inode); | ||
165 | } | ||
166 | |||
167 | static void | ||
168 | nfs_clear_inode(struct inode *inode) | ||
169 | { | ||
170 | struct nfs_inode *nfsi = NFS_I(inode); | ||
171 | struct rpc_cred *cred; | ||
172 | |||
173 | nfs_wb_all(inode); | ||
174 | BUG_ON (!list_empty(&nfsi->open_files)); | 87 | BUG_ON (!list_empty(&nfsi->open_files)); |
175 | nfs_zap_acl_cache(inode); | 88 | nfs_zap_acl_cache(inode); |
176 | cred = nfsi->cache_access.cred; | 89 | cred = nfsi->cache_access.cred; |
@@ -179,555 +92,6 @@ nfs_clear_inode(struct inode *inode) | |||
179 | BUG_ON(atomic_read(&nfsi->data_updates) != 0); | 92 | BUG_ON(atomic_read(&nfsi->data_updates) != 0); |
180 | } | 93 | } |
181 | 94 | ||
182 | void | ||
183 | nfs_umount_begin(struct super_block *sb) | ||
184 | { | ||
185 | struct rpc_clnt *rpc = NFS_SB(sb)->client; | ||
186 | |||
187 | /* -EIO all pending I/O */ | ||
188 | if (!IS_ERR(rpc)) | ||
189 | rpc_killall_tasks(rpc); | ||
190 | rpc = NFS_SB(sb)->client_acl; | ||
191 | if (!IS_ERR(rpc)) | ||
192 | rpc_killall_tasks(rpc); | ||
193 | } | ||
194 | |||
195 | |||
196 | static inline unsigned long | ||
197 | nfs_block_bits(unsigned long bsize, unsigned char *nrbitsp) | ||
198 | { | ||
199 | /* make sure blocksize is a power of two */ | ||
200 | if ((bsize & (bsize - 1)) || nrbitsp) { | ||
201 | unsigned char nrbits; | ||
202 | |||
203 | for (nrbits = 31; nrbits && !(bsize & (1 << nrbits)); nrbits--) | ||
204 | ; | ||
205 | bsize = 1 << nrbits; | ||
206 | if (nrbitsp) | ||
207 | *nrbitsp = nrbits; | ||
208 | } | ||
209 | |||
210 | return bsize; | ||
211 | } | ||
212 | |||
213 | /* | ||
214 | * Calculate the number of 512byte blocks used. | ||
215 | */ | ||
216 | static inline unsigned long | ||
217 | nfs_calc_block_size(u64 tsize) | ||
218 | { | ||
219 | loff_t used = (tsize + 511) >> 9; | ||
220 | return (used > ULONG_MAX) ? ULONG_MAX : used; | ||
221 | } | ||
222 | |||
223 | /* | ||
224 | * Compute and set NFS server blocksize | ||
225 | */ | ||
226 | static inline unsigned long | ||
227 | nfs_block_size(unsigned long bsize, unsigned char *nrbitsp) | ||
228 | { | ||
229 | if (bsize < NFS_MIN_FILE_IO_SIZE) | ||
230 | bsize = NFS_DEF_FILE_IO_SIZE; | ||
231 | else if (bsize >= NFS_MAX_FILE_IO_SIZE) | ||
232 | bsize = NFS_MAX_FILE_IO_SIZE; | ||
233 | |||
234 | return nfs_block_bits(bsize, nrbitsp); | ||
235 | } | ||
236 | |||
237 | /* | ||
238 | * Obtain the root inode of the file system. | ||
239 | */ | ||
240 | static struct inode * | ||
241 | nfs_get_root(struct super_block *sb, struct nfs_fh *rootfh, struct nfs_fsinfo *fsinfo) | ||
242 | { | ||
243 | struct nfs_server *server = NFS_SB(sb); | ||
244 | int error; | ||
245 | |||
246 | error = server->rpc_ops->getroot(server, rootfh, fsinfo); | ||
247 | if (error < 0) { | ||
248 | dprintk("nfs_get_root: getattr error = %d\n", -error); | ||
249 | return ERR_PTR(error); | ||
250 | } | ||
251 | |||
252 | return nfs_fhget(sb, rootfh, fsinfo->fattr); | ||
253 | } | ||
254 | |||
255 | /* | ||
256 | * Do NFS version-independent mount processing, and sanity checking | ||
257 | */ | ||
258 | static int | ||
259 | nfs_sb_init(struct super_block *sb, rpc_authflavor_t authflavor) | ||
260 | { | ||
261 | struct nfs_server *server; | ||
262 | struct inode *root_inode; | ||
263 | struct nfs_fattr fattr; | ||
264 | struct nfs_fsinfo fsinfo = { | ||
265 | .fattr = &fattr, | ||
266 | }; | ||
267 | struct nfs_pathconf pathinfo = { | ||
268 | .fattr = &fattr, | ||
269 | }; | ||
270 | int no_root_error = 0; | ||
271 | unsigned long max_rpc_payload; | ||
272 | |||
273 | /* We probably want something more informative here */ | ||
274 | snprintf(sb->s_id, sizeof(sb->s_id), "%x:%x", MAJOR(sb->s_dev), MINOR(sb->s_dev)); | ||
275 | |||
276 | server = NFS_SB(sb); | ||
277 | |||
278 | sb->s_magic = NFS_SUPER_MAGIC; | ||
279 | |||
280 | server->io_stats = nfs_alloc_iostats(); | ||
281 | if (server->io_stats == NULL) | ||
282 | return -ENOMEM; | ||
283 | |||
284 | root_inode = nfs_get_root(sb, &server->fh, &fsinfo); | ||
285 | /* Did getting the root inode fail? */ | ||
286 | if (IS_ERR(root_inode)) { | ||
287 | no_root_error = PTR_ERR(root_inode); | ||
288 | goto out_no_root; | ||
289 | } | ||
290 | sb->s_root = d_alloc_root(root_inode); | ||
291 | if (!sb->s_root) { | ||
292 | no_root_error = -ENOMEM; | ||
293 | goto out_no_root; | ||
294 | } | ||
295 | sb->s_root->d_op = server->rpc_ops->dentry_ops; | ||
296 | |||
297 | /* mount time stamp, in seconds */ | ||
298 | server->mount_time = jiffies; | ||
299 | |||
300 | /* Get some general file system info */ | ||
301 | if (server->namelen == 0 && | ||
302 | server->rpc_ops->pathconf(server, &server->fh, &pathinfo) >= 0) | ||
303 | server->namelen = pathinfo.max_namelen; | ||
304 | /* Work out a lot of parameters */ | ||
305 | if (server->rsize == 0) | ||
306 | server->rsize = nfs_block_size(fsinfo.rtpref, NULL); | ||
307 | if (server->wsize == 0) | ||
308 | server->wsize = nfs_block_size(fsinfo.wtpref, NULL); | ||
309 | |||
310 | if (fsinfo.rtmax >= 512 && server->rsize > fsinfo.rtmax) | ||
311 | server->rsize = nfs_block_size(fsinfo.rtmax, NULL); | ||
312 | if (fsinfo.wtmax >= 512 && server->wsize > fsinfo.wtmax) | ||
313 | server->wsize = nfs_block_size(fsinfo.wtmax, NULL); | ||
314 | |||
315 | max_rpc_payload = nfs_block_size(rpc_max_payload(server->client), NULL); | ||
316 | if (server->rsize > max_rpc_payload) | ||
317 | server->rsize = max_rpc_payload; | ||
318 | if (server->rsize > NFS_MAX_FILE_IO_SIZE) | ||
319 | server->rsize = NFS_MAX_FILE_IO_SIZE; | ||
320 | server->rpages = (server->rsize + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT; | ||
321 | |||
322 | if (server->wsize > max_rpc_payload) | ||
323 | server->wsize = max_rpc_payload; | ||
324 | if (server->wsize > NFS_MAX_FILE_IO_SIZE) | ||
325 | server->wsize = NFS_MAX_FILE_IO_SIZE; | ||
326 | server->wpages = (server->wsize + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT; | ||
327 | |||
328 | if (sb->s_blocksize == 0) | ||
329 | sb->s_blocksize = nfs_block_bits(server->wsize, | ||
330 | &sb->s_blocksize_bits); | ||
331 | server->wtmult = nfs_block_bits(fsinfo.wtmult, NULL); | ||
332 | |||
333 | server->dtsize = nfs_block_size(fsinfo.dtpref, NULL); | ||
334 | if (server->dtsize > PAGE_CACHE_SIZE) | ||
335 | server->dtsize = PAGE_CACHE_SIZE; | ||
336 | if (server->dtsize > server->rsize) | ||
337 | server->dtsize = server->rsize; | ||
338 | |||
339 | if (server->flags & NFS_MOUNT_NOAC) { | ||
340 | server->acregmin = server->acregmax = 0; | ||
341 | server->acdirmin = server->acdirmax = 0; | ||
342 | sb->s_flags |= MS_SYNCHRONOUS; | ||
343 | } | ||
344 | server->backing_dev_info.ra_pages = server->rpages * NFS_MAX_READAHEAD; | ||
345 | |||
346 | sb->s_maxbytes = fsinfo.maxfilesize; | ||
347 | if (sb->s_maxbytes > MAX_LFS_FILESIZE) | ||
348 | sb->s_maxbytes = MAX_LFS_FILESIZE; | ||
349 | |||
350 | server->client->cl_intr = (server->flags & NFS_MOUNT_INTR) ? 1 : 0; | ||
351 | server->client->cl_softrtry = (server->flags & NFS_MOUNT_SOFT) ? 1 : 0; | ||
352 | |||
353 | /* We're airborne Set socket buffersize */ | ||
354 | rpc_setbufsize(server->client, server->wsize + 100, server->rsize + 100); | ||
355 | return 0; | ||
356 | /* Yargs. It didn't work out. */ | ||
357 | out_no_root: | ||
358 | dprintk("nfs_sb_init: get root inode failed: errno %d\n", -no_root_error); | ||
359 | if (!IS_ERR(root_inode)) | ||
360 | iput(root_inode); | ||
361 | return no_root_error; | ||
362 | } | ||
363 | |||
364 | static void nfs_init_timeout_values(struct rpc_timeout *to, int proto, unsigned int timeo, unsigned int retrans) | ||
365 | { | ||
366 | to->to_initval = timeo * HZ / 10; | ||
367 | to->to_retries = retrans; | ||
368 | if (!to->to_retries) | ||
369 | to->to_retries = 2; | ||
370 | |||
371 | switch (proto) { | ||
372 | case IPPROTO_TCP: | ||
373 | if (!to->to_initval) | ||
374 | to->to_initval = 60 * HZ; | ||
375 | if (to->to_initval > NFS_MAX_TCP_TIMEOUT) | ||
376 | to->to_initval = NFS_MAX_TCP_TIMEOUT; | ||
377 | to->to_increment = to->to_initval; | ||
378 | to->to_maxval = to->to_initval + (to->to_increment * to->to_retries); | ||
379 | to->to_exponential = 0; | ||
380 | break; | ||
381 | case IPPROTO_UDP: | ||
382 | default: | ||
383 | if (!to->to_initval) | ||
384 | to->to_initval = 11 * HZ / 10; | ||
385 | if (to->to_initval > NFS_MAX_UDP_TIMEOUT) | ||
386 | to->to_initval = NFS_MAX_UDP_TIMEOUT; | ||
387 | to->to_maxval = NFS_MAX_UDP_TIMEOUT; | ||
388 | to->to_exponential = 1; | ||
389 | break; | ||
390 | } | ||
391 | } | ||
392 | |||
393 | /* | ||
394 | * Create an RPC client handle. | ||
395 | */ | ||
396 | static struct rpc_clnt * | ||
397 | nfs_create_client(struct nfs_server *server, const struct nfs_mount_data *data) | ||
398 | { | ||
399 | struct rpc_timeout timeparms; | ||
400 | struct rpc_xprt *xprt = NULL; | ||
401 | struct rpc_clnt *clnt = NULL; | ||
402 | int proto = (data->flags & NFS_MOUNT_TCP) ? IPPROTO_TCP : IPPROTO_UDP; | ||
403 | |||
404 | nfs_init_timeout_values(&timeparms, proto, data->timeo, data->retrans); | ||
405 | |||
406 | server->retrans_timeo = timeparms.to_initval; | ||
407 | server->retrans_count = timeparms.to_retries; | ||
408 | |||
409 | /* create transport and client */ | ||
410 | xprt = xprt_create_proto(proto, &server->addr, &timeparms); | ||
411 | if (IS_ERR(xprt)) { | ||
412 | dprintk("%s: cannot create RPC transport. Error = %ld\n", | ||
413 | __FUNCTION__, PTR_ERR(xprt)); | ||
414 | return (struct rpc_clnt *)xprt; | ||
415 | } | ||
416 | clnt = rpc_create_client(xprt, server->hostname, &nfs_program, | ||
417 | server->rpc_ops->version, data->pseudoflavor); | ||
418 | if (IS_ERR(clnt)) { | ||
419 | dprintk("%s: cannot create RPC client. Error = %ld\n", | ||
420 | __FUNCTION__, PTR_ERR(xprt)); | ||
421 | goto out_fail; | ||
422 | } | ||
423 | |||
424 | clnt->cl_intr = 1; | ||
425 | clnt->cl_softrtry = 1; | ||
426 | |||
427 | return clnt; | ||
428 | |||
429 | out_fail: | ||
430 | return clnt; | ||
431 | } | ||
432 | |||
433 | /* | ||
434 | * The way this works is that the mount process passes a structure | ||
435 | * in the data argument which contains the server's IP address | ||
436 | * and the root file handle obtained from the server's mount | ||
437 | * daemon. We stash these away in the private superblock fields. | ||
438 | */ | ||
439 | static int | ||
440 | nfs_fill_super(struct super_block *sb, struct nfs_mount_data *data, int silent) | ||
441 | { | ||
442 | struct nfs_server *server; | ||
443 | rpc_authflavor_t authflavor; | ||
444 | |||
445 | server = NFS_SB(sb); | ||
446 | sb->s_blocksize_bits = 0; | ||
447 | sb->s_blocksize = 0; | ||
448 | if (data->bsize) | ||
449 | sb->s_blocksize = nfs_block_size(data->bsize, &sb->s_blocksize_bits); | ||
450 | if (data->rsize) | ||
451 | server->rsize = nfs_block_size(data->rsize, NULL); | ||
452 | if (data->wsize) | ||
453 | server->wsize = nfs_block_size(data->wsize, NULL); | ||
454 | server->flags = data->flags & NFS_MOUNT_FLAGMASK; | ||
455 | |||
456 | server->acregmin = data->acregmin*HZ; | ||
457 | server->acregmax = data->acregmax*HZ; | ||
458 | server->acdirmin = data->acdirmin*HZ; | ||
459 | server->acdirmax = data->acdirmax*HZ; | ||
460 | |||
461 | /* Start lockd here, before we might error out */ | ||
462 | if (!(server->flags & NFS_MOUNT_NONLM)) | ||
463 | lockd_up(); | ||
464 | |||
465 | server->namelen = data->namlen; | ||
466 | server->hostname = kmalloc(strlen(data->hostname) + 1, GFP_KERNEL); | ||
467 | if (!server->hostname) | ||
468 | return -ENOMEM; | ||
469 | strcpy(server->hostname, data->hostname); | ||
470 | |||
471 | /* Check NFS protocol revision and initialize RPC op vector | ||
472 | * and file handle pool. */ | ||
473 | #ifdef CONFIG_NFS_V3 | ||
474 | if (server->flags & NFS_MOUNT_VER3) { | ||
475 | server->rpc_ops = &nfs_v3_clientops; | ||
476 | server->caps |= NFS_CAP_READDIRPLUS; | ||
477 | } else { | ||
478 | server->rpc_ops = &nfs_v2_clientops; | ||
479 | } | ||
480 | #else | ||
481 | server->rpc_ops = &nfs_v2_clientops; | ||
482 | #endif | ||
483 | |||
484 | /* Fill in pseudoflavor for mount version < 5 */ | ||
485 | if (!(data->flags & NFS_MOUNT_SECFLAVOUR)) | ||
486 | data->pseudoflavor = RPC_AUTH_UNIX; | ||
487 | authflavor = data->pseudoflavor; /* save for sb_init() */ | ||
488 | /* XXX maybe we want to add a server->pseudoflavor field */ | ||
489 | |||
490 | /* Create RPC client handles */ | ||
491 | server->client = nfs_create_client(server, data); | ||
492 | if (IS_ERR(server->client)) | ||
493 | return PTR_ERR(server->client); | ||
494 | /* RFC 2623, sec 2.3.2 */ | ||
495 | if (authflavor != RPC_AUTH_UNIX) { | ||
496 | struct rpc_auth *auth; | ||
497 | |||
498 | server->client_sys = rpc_clone_client(server->client); | ||
499 | if (IS_ERR(server->client_sys)) | ||
500 | return PTR_ERR(server->client_sys); | ||
501 | auth = rpcauth_create(RPC_AUTH_UNIX, server->client_sys); | ||
502 | if (IS_ERR(auth)) | ||
503 | return PTR_ERR(auth); | ||
504 | } else { | ||
505 | atomic_inc(&server->client->cl_count); | ||
506 | server->client_sys = server->client; | ||
507 | } | ||
508 | if (server->flags & NFS_MOUNT_VER3) { | ||
509 | #ifdef CONFIG_NFS_V3_ACL | ||
510 | if (!(server->flags & NFS_MOUNT_NOACL)) { | ||
511 | server->client_acl = rpc_bind_new_program(server->client, &nfsacl_program, 3); | ||
512 | /* No errors! Assume that Sun nfsacls are supported */ | ||
513 | if (!IS_ERR(server->client_acl)) | ||
514 | server->caps |= NFS_CAP_ACLS; | ||
515 | } | ||
516 | #else | ||
517 | server->flags &= ~NFS_MOUNT_NOACL; | ||
518 | #endif /* CONFIG_NFS_V3_ACL */ | ||
519 | /* | ||
520 | * The VFS shouldn't apply the umask to mode bits. We will | ||
521 | * do so ourselves when necessary. | ||
522 | */ | ||
523 | sb->s_flags |= MS_POSIXACL; | ||
524 | if (server->namelen == 0 || server->namelen > NFS3_MAXNAMLEN) | ||
525 | server->namelen = NFS3_MAXNAMLEN; | ||
526 | sb->s_time_gran = 1; | ||
527 | } else { | ||
528 | if (server->namelen == 0 || server->namelen > NFS2_MAXNAMLEN) | ||
529 | server->namelen = NFS2_MAXNAMLEN; | ||
530 | } | ||
531 | |||
532 | sb->s_op = &nfs_sops; | ||
533 | return nfs_sb_init(sb, authflavor); | ||
534 | } | ||
535 | |||
536 | static int | ||
537 | nfs_statfs(struct dentry *dentry, struct kstatfs *buf) | ||
538 | { | ||
539 | struct super_block *sb = dentry->d_sb; | ||
540 | struct nfs_server *server = NFS_SB(sb); | ||
541 | unsigned char blockbits; | ||
542 | unsigned long blockres; | ||
543 | struct nfs_fh *rootfh = NFS_FH(sb->s_root->d_inode); | ||
544 | struct nfs_fattr fattr; | ||
545 | struct nfs_fsstat res = { | ||
546 | .fattr = &fattr, | ||
547 | }; | ||
548 | int error; | ||
549 | |||
550 | lock_kernel(); | ||
551 | |||
552 | error = server->rpc_ops->statfs(server, rootfh, &res); | ||
553 | buf->f_type = NFS_SUPER_MAGIC; | ||
554 | if (error < 0) | ||
555 | goto out_err; | ||
556 | |||
557 | /* | ||
558 | * Current versions of glibc do not correctly handle the | ||
559 | * case where f_frsize != f_bsize. Eventually we want to | ||
560 | * report the value of wtmult in this field. | ||
561 | */ | ||
562 | buf->f_frsize = sb->s_blocksize; | ||
563 | |||
564 | /* | ||
565 | * On most *nix systems, f_blocks, f_bfree, and f_bavail | ||
566 | * are reported in units of f_frsize. Linux hasn't had | ||
567 | * an f_frsize field in its statfs struct until recently, | ||
568 | * thus historically Linux's sys_statfs reports these | ||
569 | * fields in units of f_bsize. | ||
570 | */ | ||
571 | buf->f_bsize = sb->s_blocksize; | ||
572 | blockbits = sb->s_blocksize_bits; | ||
573 | blockres = (1 << blockbits) - 1; | ||
574 | buf->f_blocks = (res.tbytes + blockres) >> blockbits; | ||
575 | buf->f_bfree = (res.fbytes + blockres) >> blockbits; | ||
576 | buf->f_bavail = (res.abytes + blockres) >> blockbits; | ||
577 | |||
578 | buf->f_files = res.tfiles; | ||
579 | buf->f_ffree = res.afiles; | ||
580 | |||
581 | buf->f_namelen = server->namelen; | ||
582 | out: | ||
583 | unlock_kernel(); | ||
584 | return 0; | ||
585 | |||
586 | out_err: | ||
587 | dprintk("%s: statfs error = %d\n", __FUNCTION__, -error); | ||
588 | buf->f_bsize = buf->f_blocks = buf->f_bfree = buf->f_bavail = -1; | ||
589 | goto out; | ||
590 | |||
591 | } | ||
592 | |||
593 | static void nfs_show_mount_options(struct seq_file *m, struct nfs_server *nfss, int showdefaults) | ||
594 | { | ||
595 | static struct proc_nfs_info { | ||
596 | int flag; | ||
597 | char *str; | ||
598 | char *nostr; | ||
599 | } nfs_info[] = { | ||
600 | { NFS_MOUNT_SOFT, ",soft", ",hard" }, | ||
601 | { NFS_MOUNT_INTR, ",intr", "" }, | ||
602 | { NFS_MOUNT_NOCTO, ",nocto", "" }, | ||
603 | { NFS_MOUNT_NOAC, ",noac", "" }, | ||
604 | { NFS_MOUNT_NONLM, ",nolock", "" }, | ||
605 | { NFS_MOUNT_NOACL, ",noacl", "" }, | ||
606 | { 0, NULL, NULL } | ||
607 | }; | ||
608 | struct proc_nfs_info *nfs_infop; | ||
609 | char buf[12]; | ||
610 | char *proto; | ||
611 | |||
612 | seq_printf(m, ",vers=%d", nfss->rpc_ops->version); | ||
613 | seq_printf(m, ",rsize=%d", nfss->rsize); | ||
614 | seq_printf(m, ",wsize=%d", nfss->wsize); | ||
615 | if (nfss->acregmin != 3*HZ || showdefaults) | ||
616 | seq_printf(m, ",acregmin=%d", nfss->acregmin/HZ); | ||
617 | if (nfss->acregmax != 60*HZ || showdefaults) | ||
618 | seq_printf(m, ",acregmax=%d", nfss->acregmax/HZ); | ||
619 | if (nfss->acdirmin != 30*HZ || showdefaults) | ||
620 | seq_printf(m, ",acdirmin=%d", nfss->acdirmin/HZ); | ||
621 | if (nfss->acdirmax != 60*HZ || showdefaults) | ||
622 | seq_printf(m, ",acdirmax=%d", nfss->acdirmax/HZ); | ||
623 | for (nfs_infop = nfs_info; nfs_infop->flag; nfs_infop++) { | ||
624 | if (nfss->flags & nfs_infop->flag) | ||
625 | seq_puts(m, nfs_infop->str); | ||
626 | else | ||
627 | seq_puts(m, nfs_infop->nostr); | ||
628 | } | ||
629 | switch (nfss->client->cl_xprt->prot) { | ||
630 | case IPPROTO_TCP: | ||
631 | proto = "tcp"; | ||
632 | break; | ||
633 | case IPPROTO_UDP: | ||
634 | proto = "udp"; | ||
635 | break; | ||
636 | default: | ||
637 | snprintf(buf, sizeof(buf), "%u", nfss->client->cl_xprt->prot); | ||
638 | proto = buf; | ||
639 | } | ||
640 | seq_printf(m, ",proto=%s", proto); | ||
641 | seq_printf(m, ",timeo=%lu", 10U * nfss->retrans_timeo / HZ); | ||
642 | seq_printf(m, ",retrans=%u", nfss->retrans_count); | ||
643 | } | ||
644 | |||
645 | static int nfs_show_options(struct seq_file *m, struct vfsmount *mnt) | ||
646 | { | ||
647 | struct nfs_server *nfss = NFS_SB(mnt->mnt_sb); | ||
648 | |||
649 | nfs_show_mount_options(m, nfss, 0); | ||
650 | |||
651 | seq_puts(m, ",addr="); | ||
652 | seq_escape(m, nfss->hostname, " \t\n\\"); | ||
653 | |||
654 | return 0; | ||
655 | } | ||
656 | |||
657 | static int nfs_show_stats(struct seq_file *m, struct vfsmount *mnt) | ||
658 | { | ||
659 | int i, cpu; | ||
660 | struct nfs_server *nfss = NFS_SB(mnt->mnt_sb); | ||
661 | struct rpc_auth *auth = nfss->client->cl_auth; | ||
662 | struct nfs_iostats totals = { }; | ||
663 | |||
664 | seq_printf(m, "statvers=%s", NFS_IOSTAT_VERS); | ||
665 | |||
666 | /* | ||
667 | * Display all mount option settings | ||
668 | */ | ||
669 | seq_printf(m, "\n\topts:\t"); | ||
670 | seq_puts(m, mnt->mnt_sb->s_flags & MS_RDONLY ? "ro" : "rw"); | ||
671 | seq_puts(m, mnt->mnt_sb->s_flags & MS_SYNCHRONOUS ? ",sync" : ""); | ||
672 | seq_puts(m, mnt->mnt_sb->s_flags & MS_NOATIME ? ",noatime" : ""); | ||
673 | seq_puts(m, mnt->mnt_sb->s_flags & MS_NODIRATIME ? ",nodiratime" : ""); | ||
674 | nfs_show_mount_options(m, nfss, 1); | ||
675 | |||
676 | seq_printf(m, "\n\tage:\t%lu", (jiffies - nfss->mount_time) / HZ); | ||
677 | |||
678 | seq_printf(m, "\n\tcaps:\t"); | ||
679 | seq_printf(m, "caps=0x%x", nfss->caps); | ||
680 | seq_printf(m, ",wtmult=%d", nfss->wtmult); | ||
681 | seq_printf(m, ",dtsize=%d", nfss->dtsize); | ||
682 | seq_printf(m, ",bsize=%d", nfss->bsize); | ||
683 | seq_printf(m, ",namelen=%d", nfss->namelen); | ||
684 | |||
685 | #ifdef CONFIG_NFS_V4 | ||
686 | if (nfss->rpc_ops->version == 4) { | ||
687 | seq_printf(m, "\n\tnfsv4:\t"); | ||
688 | seq_printf(m, "bm0=0x%x", nfss->attr_bitmask[0]); | ||
689 | seq_printf(m, ",bm1=0x%x", nfss->attr_bitmask[1]); | ||
690 | seq_printf(m, ",acl=0x%x", nfss->acl_bitmask); | ||
691 | } | ||
692 | #endif | ||
693 | |||
694 | /* | ||
695 | * Display security flavor in effect for this mount | ||
696 | */ | ||
697 | seq_printf(m, "\n\tsec:\tflavor=%d", auth->au_ops->au_flavor); | ||
698 | if (auth->au_flavor) | ||
699 | seq_printf(m, ",pseudoflavor=%d", auth->au_flavor); | ||
700 | |||
701 | /* | ||
702 | * Display superblock I/O counters | ||
703 | */ | ||
704 | for_each_possible_cpu(cpu) { | ||
705 | struct nfs_iostats *stats; | ||
706 | |||
707 | preempt_disable(); | ||
708 | stats = per_cpu_ptr(nfss->io_stats, cpu); | ||
709 | |||
710 | for (i = 0; i < __NFSIOS_COUNTSMAX; i++) | ||
711 | totals.events[i] += stats->events[i]; | ||
712 | for (i = 0; i < __NFSIOS_BYTESMAX; i++) | ||
713 | totals.bytes[i] += stats->bytes[i]; | ||
714 | |||
715 | preempt_enable(); | ||
716 | } | ||
717 | |||
718 | seq_printf(m, "\n\tevents:\t"); | ||
719 | for (i = 0; i < __NFSIOS_COUNTSMAX; i++) | ||
720 | seq_printf(m, "%lu ", totals.events[i]); | ||
721 | seq_printf(m, "\n\tbytes:\t"); | ||
722 | for (i = 0; i < __NFSIOS_BYTESMAX; i++) | ||
723 | seq_printf(m, "%Lu ", totals.bytes[i]); | ||
724 | seq_printf(m, "\n"); | ||
725 | |||
726 | rpc_print_iostats(m, nfss->client); | ||
727 | |||
728 | return 0; | ||
729 | } | ||
730 | |||
731 | /** | 95 | /** |
732 | * nfs_sync_mapping - helper to flush all mmapped dirty data to disk | 96 | * nfs_sync_mapping - helper to flush all mmapped dirty data to disk |
733 | */ | 97 | */ |
@@ -890,6 +254,14 @@ nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr) | |||
890 | if (nfs_server_capable(inode, NFS_CAP_READDIRPLUS) | 254 | if (nfs_server_capable(inode, NFS_CAP_READDIRPLUS) |
891 | && fattr->size <= NFS_LIMIT_READDIRPLUS) | 255 | && fattr->size <= NFS_LIMIT_READDIRPLUS) |
892 | set_bit(NFS_INO_ADVISE_RDPLUS, &NFS_FLAGS(inode)); | 256 | set_bit(NFS_INO_ADVISE_RDPLUS, &NFS_FLAGS(inode)); |
257 | /* Deal with crossing mountpoints */ | ||
258 | if (!nfs_fsid_equal(&NFS_SB(sb)->fsid, &fattr->fsid)) { | ||
259 | if (fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL) | ||
260 | inode->i_op = &nfs_referral_inode_operations; | ||
261 | else | ||
262 | inode->i_op = &nfs_mountpoint_inode_operations; | ||
263 | inode->i_fop = NULL; | ||
264 | } | ||
893 | } else if (S_ISLNK(inode->i_mode)) | 265 | } else if (S_ISLNK(inode->i_mode)) |
894 | inode->i_op = &nfs_symlink_inode_operations; | 266 | inode->i_op = &nfs_symlink_inode_operations; |
895 | else | 267 | else |
@@ -1208,6 +580,7 @@ __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode) | |||
1208 | dfprintk(PAGECACHE, "NFS: revalidating (%s/%Ld)\n", | 580 | dfprintk(PAGECACHE, "NFS: revalidating (%s/%Ld)\n", |
1209 | inode->i_sb->s_id, (long long)NFS_FILEID(inode)); | 581 | inode->i_sb->s_id, (long long)NFS_FILEID(inode)); |
1210 | 582 | ||
583 | nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE); | ||
1211 | lock_kernel(); | 584 | lock_kernel(); |
1212 | if (!inode || is_bad_inode(inode)) | 585 | if (!inode || is_bad_inode(inode)) |
1213 | goto out_nowait; | 586 | goto out_nowait; |
@@ -1221,7 +594,7 @@ __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode) | |||
1221 | status = -ESTALE; | 594 | status = -ESTALE; |
1222 | /* Do we trust the cached ESTALE? */ | 595 | /* Do we trust the cached ESTALE? */ |
1223 | if (NFS_ATTRTIMEO(inode) != 0) { | 596 | if (NFS_ATTRTIMEO(inode) != 0) { |
1224 | if (nfsi->cache_validity & (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA|NFS_INO_INVALID_ATIME)) { | 597 | if (nfsi->cache_validity & (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ATIME)) { |
1225 | /* no */ | 598 | /* no */ |
1226 | } else | 599 | } else |
1227 | goto out; | 600 | goto out; |
@@ -1252,8 +625,6 @@ __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode) | |||
1252 | } | 625 | } |
1253 | spin_unlock(&inode->i_lock); | 626 | spin_unlock(&inode->i_lock); |
1254 | 627 | ||
1255 | nfs_revalidate_mapping(inode, inode->i_mapping); | ||
1256 | |||
1257 | if (nfsi->cache_validity & NFS_INO_INVALID_ACL) | 628 | if (nfsi->cache_validity & NFS_INO_INVALID_ACL) |
1258 | nfs_zap_acl_cache(inode); | 629 | nfs_zap_acl_cache(inode); |
1259 | 630 | ||
@@ -1287,8 +658,7 @@ int nfs_attribute_timeout(struct inode *inode) | |||
1287 | */ | 658 | */ |
1288 | int nfs_revalidate_inode(struct nfs_server *server, struct inode *inode) | 659 | int nfs_revalidate_inode(struct nfs_server *server, struct inode *inode) |
1289 | { | 660 | { |
1290 | nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE); | 661 | if (!(NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATTR) |
1291 | if (!(NFS_I(inode)->cache_validity & (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA)) | ||
1292 | && !nfs_attribute_timeout(inode)) | 662 | && !nfs_attribute_timeout(inode)) |
1293 | return NFS_STALE(inode) ? -ESTALE : 0; | 663 | return NFS_STALE(inode) ? -ESTALE : 0; |
1294 | return __nfs_revalidate_inode(server, inode); | 664 | return __nfs_revalidate_inode(server, inode); |
@@ -1299,9 +669,16 @@ int nfs_revalidate_inode(struct nfs_server *server, struct inode *inode) | |||
1299 | * @inode - pointer to host inode | 669 | * @inode - pointer to host inode |
1300 | * @mapping - pointer to mapping | 670 | * @mapping - pointer to mapping |
1301 | */ | 671 | */ |
1302 | void nfs_revalidate_mapping(struct inode *inode, struct address_space *mapping) | 672 | int nfs_revalidate_mapping(struct inode *inode, struct address_space *mapping) |
1303 | { | 673 | { |
1304 | struct nfs_inode *nfsi = NFS_I(inode); | 674 | struct nfs_inode *nfsi = NFS_I(inode); |
675 | int ret = 0; | ||
676 | |||
677 | if (NFS_STALE(inode)) | ||
678 | ret = -ESTALE; | ||
679 | if ((nfsi->cache_validity & NFS_INO_REVAL_PAGECACHE) | ||
680 | || nfs_attribute_timeout(inode)) | ||
681 | ret = __nfs_revalidate_inode(NFS_SERVER(inode), inode); | ||
1305 | 682 | ||
1306 | if (nfsi->cache_validity & NFS_INO_INVALID_DATA) { | 683 | if (nfsi->cache_validity & NFS_INO_INVALID_DATA) { |
1307 | nfs_inc_stats(inode, NFSIOS_DATAINVALIDATE); | 684 | nfs_inc_stats(inode, NFSIOS_DATAINVALIDATE); |
@@ -1322,6 +699,7 @@ void nfs_revalidate_mapping(struct inode *inode, struct address_space *mapping) | |||
1322 | inode->i_sb->s_id, | 699 | inode->i_sb->s_id, |
1323 | (long long)NFS_FILEID(inode)); | 700 | (long long)NFS_FILEID(inode)); |
1324 | } | 701 | } |
702 | return ret; | ||
1325 | } | 703 | } |
1326 | 704 | ||
1327 | /** | 705 | /** |
@@ -1361,12 +739,6 @@ static void nfs_wcc_update_inode(struct inode *inode, struct nfs_fattr *fattr) | |||
1361 | { | 739 | { |
1362 | struct nfs_inode *nfsi = NFS_I(inode); | 740 | struct nfs_inode *nfsi = NFS_I(inode); |
1363 | 741 | ||
1364 | if ((fattr->valid & NFS_ATTR_PRE_CHANGE) != 0 | ||
1365 | && nfsi->change_attr == fattr->pre_change_attr) { | ||
1366 | nfsi->change_attr = fattr->change_attr; | ||
1367 | nfsi->cache_change_attribute = jiffies; | ||
1368 | } | ||
1369 | |||
1370 | /* If we have atomic WCC data, we may update some attributes */ | 742 | /* If we have atomic WCC data, we may update some attributes */ |
1371 | if ((fattr->valid & NFS_ATTR_WCC) != 0) { | 743 | if ((fattr->valid & NFS_ATTR_WCC) != 0) { |
1372 | if (timespec_equal(&inode->i_ctime, &fattr->pre_ctime)) { | 744 | if (timespec_equal(&inode->i_ctime, &fattr->pre_ctime)) { |
@@ -1400,9 +772,6 @@ static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fat | |||
1400 | int data_unstable; | 772 | int data_unstable; |
1401 | 773 | ||
1402 | 774 | ||
1403 | if ((fattr->valid & NFS_ATTR_FATTR) == 0) | ||
1404 | return 0; | ||
1405 | |||
1406 | /* Has the inode gone and changed behind our back? */ | 775 | /* Has the inode gone and changed behind our back? */ |
1407 | if (nfsi->fileid != fattr->fileid | 776 | if (nfsi->fileid != fattr->fileid |
1408 | || (inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT)) { | 777 | || (inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT)) { |
@@ -1415,20 +784,13 @@ static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fat | |||
1415 | /* Do atomic weak cache consistency updates */ | 784 | /* Do atomic weak cache consistency updates */ |
1416 | nfs_wcc_update_inode(inode, fattr); | 785 | nfs_wcc_update_inode(inode, fattr); |
1417 | 786 | ||
1418 | if ((fattr->valid & NFS_ATTR_FATTR_V4) != 0) { | 787 | if ((fattr->valid & NFS_ATTR_FATTR_V4) != 0 && |
1419 | if (nfsi->change_attr == fattr->change_attr) | 788 | nfsi->change_attr != fattr->change_attr) |
1420 | goto out; | 789 | nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE; |
1421 | nfsi->cache_validity |= NFS_INO_INVALID_ATTR; | ||
1422 | if (!data_unstable) | ||
1423 | nfsi->cache_validity |= NFS_INO_REVAL_PAGECACHE; | ||
1424 | } | ||
1425 | 790 | ||
1426 | /* Verify a few of the more important attributes */ | 791 | /* Verify a few of the more important attributes */ |
1427 | if (!timespec_equal(&inode->i_mtime, &fattr->mtime)) { | 792 | if (!timespec_equal(&inode->i_mtime, &fattr->mtime)) |
1428 | nfsi->cache_validity |= NFS_INO_INVALID_ATTR; | 793 | nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE; |
1429 | if (!data_unstable) | ||
1430 | nfsi->cache_validity |= NFS_INO_REVAL_PAGECACHE; | ||
1431 | } | ||
1432 | 794 | ||
1433 | cur_size = i_size_read(inode); | 795 | cur_size = i_size_read(inode); |
1434 | new_isize = nfs_size_to_loff_t(fattr->size); | 796 | new_isize = nfs_size_to_loff_t(fattr->size); |
@@ -1445,7 +807,6 @@ static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fat | |||
1445 | if (inode->i_nlink != fattr->nlink) | 807 | if (inode->i_nlink != fattr->nlink) |
1446 | nfsi->cache_validity |= NFS_INO_INVALID_ATTR; | 808 | nfsi->cache_validity |= NFS_INO_INVALID_ATTR; |
1447 | 809 | ||
1448 | out: | ||
1449 | if (!timespec_equal(&inode->i_atime, &fattr->atime)) | 810 | if (!timespec_equal(&inode->i_atime, &fattr->atime)) |
1450 | nfsi->cache_validity |= NFS_INO_INVALID_ATIME; | 811 | nfsi->cache_validity |= NFS_INO_INVALID_ATIME; |
1451 | 812 | ||
@@ -1471,7 +832,6 @@ int nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr) | |||
1471 | if ((fattr->valid & NFS_ATTR_FATTR) == 0) | 832 | if ((fattr->valid & NFS_ATTR_FATTR) == 0) |
1472 | return 0; | 833 | return 0; |
1473 | spin_lock(&inode->i_lock); | 834 | spin_lock(&inode->i_lock); |
1474 | nfsi->cache_validity &= ~NFS_INO_REVAL_PAGECACHE; | ||
1475 | if (time_after(fattr->time_start, nfsi->last_updated)) | 835 | if (time_after(fattr->time_start, nfsi->last_updated)) |
1476 | status = nfs_update_inode(inode, fattr); | 836 | status = nfs_update_inode(inode, fattr); |
1477 | else | 837 | else |
@@ -1496,7 +856,7 @@ int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr) | |||
1496 | 856 | ||
1497 | spin_lock(&inode->i_lock); | 857 | spin_lock(&inode->i_lock); |
1498 | if (unlikely((fattr->valid & NFS_ATTR_FATTR) == 0)) { | 858 | if (unlikely((fattr->valid & NFS_ATTR_FATTR) == 0)) { |
1499 | nfsi->cache_validity |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS; | 859 | nfsi->cache_validity |= NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE; |
1500 | goto out; | 860 | goto out; |
1501 | } | 861 | } |
1502 | status = nfs_update_inode(inode, fattr); | 862 | status = nfs_update_inode(inode, fattr); |
@@ -1519,6 +879,7 @@ out: | |||
1519 | */ | 879 | */ |
1520 | static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr) | 880 | static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr) |
1521 | { | 881 | { |
882 | struct nfs_server *server; | ||
1522 | struct nfs_inode *nfsi = NFS_I(inode); | 883 | struct nfs_inode *nfsi = NFS_I(inode); |
1523 | loff_t cur_isize, new_isize; | 884 | loff_t cur_isize, new_isize; |
1524 | unsigned int invalid = 0; | 885 | unsigned int invalid = 0; |
@@ -1528,9 +889,6 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr) | |||
1528 | __FUNCTION__, inode->i_sb->s_id, inode->i_ino, | 889 | __FUNCTION__, inode->i_sb->s_id, inode->i_ino, |
1529 | atomic_read(&inode->i_count), fattr->valid); | 890 | atomic_read(&inode->i_count), fattr->valid); |
1530 | 891 | ||
1531 | if ((fattr->valid & NFS_ATTR_FATTR) == 0) | ||
1532 | return 0; | ||
1533 | |||
1534 | if (nfsi->fileid != fattr->fileid) | 892 | if (nfsi->fileid != fattr->fileid) |
1535 | goto out_fileid; | 893 | goto out_fileid; |
1536 | 894 | ||
@@ -1540,6 +898,12 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr) | |||
1540 | if ((inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT)) | 898 | if ((inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT)) |
1541 | goto out_changed; | 899 | goto out_changed; |
1542 | 900 | ||
901 | server = NFS_SERVER(inode); | ||
902 | /* Update the fsid if and only if this is the root directory */ | ||
903 | if (inode == inode->i_sb->s_root->d_inode | ||
904 | && !nfs_fsid_equal(&server->fsid, &fattr->fsid)) | ||
905 | server->fsid = fattr->fsid; | ||
906 | |||
1543 | /* | 907 | /* |
1544 | * Update the read time so we don't revalidate too often. | 908 | * Update the read time so we don't revalidate too often. |
1545 | */ | 909 | */ |
@@ -1549,7 +913,7 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr) | |||
1549 | /* Are we racing with known updates of the metadata on the server? */ | 913 | /* Are we racing with known updates of the metadata on the server? */ |
1550 | data_stable = nfs_verify_change_attribute(inode, fattr->time_start); | 914 | data_stable = nfs_verify_change_attribute(inode, fattr->time_start); |
1551 | if (data_stable) | 915 | if (data_stable) |
1552 | nfsi->cache_validity &= ~(NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ATIME); | 916 | nfsi->cache_validity &= ~(NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE|NFS_INO_INVALID_ATIME); |
1553 | 917 | ||
1554 | /* Do atomic weak cache consistency updates */ | 918 | /* Do atomic weak cache consistency updates */ |
1555 | nfs_wcc_update_inode(inode, fattr); | 919 | nfs_wcc_update_inode(inode, fattr); |
@@ -1613,15 +977,13 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr) | |||
1613 | inode->i_blksize = fattr->du.nfs2.blocksize; | 977 | inode->i_blksize = fattr->du.nfs2.blocksize; |
1614 | } | 978 | } |
1615 | 979 | ||
1616 | if ((fattr->valid & NFS_ATTR_FATTR_V4)) { | 980 | if ((fattr->valid & NFS_ATTR_FATTR_V4) != 0 && |
1617 | if (nfsi->change_attr != fattr->change_attr) { | 981 | nfsi->change_attr != fattr->change_attr) { |
1618 | dprintk("NFS: change_attr change on server for file %s/%ld\n", | 982 | dprintk("NFS: change_attr change on server for file %s/%ld\n", |
1619 | inode->i_sb->s_id, inode->i_ino); | 983 | inode->i_sb->s_id, inode->i_ino); |
1620 | nfsi->change_attr = fattr->change_attr; | 984 | nfsi->change_attr = fattr->change_attr; |
1621 | invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL; | 985 | invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL; |
1622 | nfsi->cache_change_attribute = jiffies; | 986 | nfsi->cache_change_attribute = jiffies; |
1623 | } else | ||
1624 | invalid &= ~(NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA); | ||
1625 | } | 987 | } |
1626 | 988 | ||
1627 | /* Update attrtimeo value if we're out of the unstable period */ | 989 | /* Update attrtimeo value if we're out of the unstable period */ |
@@ -1669,202 +1031,15 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr) | |||
1669 | goto out_err; | 1031 | goto out_err; |
1670 | } | 1032 | } |
1671 | 1033 | ||
1672 | /* | ||
1673 | * File system information | ||
1674 | */ | ||
1675 | |||
1676 | static int nfs_set_super(struct super_block *s, void *data) | ||
1677 | { | ||
1678 | s->s_fs_info = data; | ||
1679 | return set_anon_super(s, data); | ||
1680 | } | ||
1681 | |||
1682 | static int nfs_compare_super(struct super_block *sb, void *data) | ||
1683 | { | ||
1684 | struct nfs_server *server = data; | ||
1685 | struct nfs_server *old = NFS_SB(sb); | ||
1686 | |||
1687 | if (old->addr.sin_addr.s_addr != server->addr.sin_addr.s_addr) | ||
1688 | return 0; | ||
1689 | if (old->addr.sin_port != server->addr.sin_port) | ||
1690 | return 0; | ||
1691 | return !nfs_compare_fh(&old->fh, &server->fh); | ||
1692 | } | ||
1693 | |||
1694 | static int nfs_get_sb(struct file_system_type *fs_type, | ||
1695 | int flags, const char *dev_name, void *raw_data, struct vfsmount *mnt) | ||
1696 | { | ||
1697 | int error; | ||
1698 | struct nfs_server *server = NULL; | ||
1699 | struct super_block *s; | ||
1700 | struct nfs_fh *root; | ||
1701 | struct nfs_mount_data *data = raw_data; | ||
1702 | |||
1703 | error = -EINVAL; | ||
1704 | if (data == NULL) { | ||
1705 | dprintk("%s: missing data argument\n", __FUNCTION__); | ||
1706 | goto out_err_noserver; | ||
1707 | } | ||
1708 | if (data->version <= 0 || data->version > NFS_MOUNT_VERSION) { | ||
1709 | dprintk("%s: bad mount version\n", __FUNCTION__); | ||
1710 | goto out_err_noserver; | ||
1711 | } | ||
1712 | switch (data->version) { | ||
1713 | case 1: | ||
1714 | data->namlen = 0; | ||
1715 | case 2: | ||
1716 | data->bsize = 0; | ||
1717 | case 3: | ||
1718 | if (data->flags & NFS_MOUNT_VER3) { | ||
1719 | dprintk("%s: mount structure version %d does not support NFSv3\n", | ||
1720 | __FUNCTION__, | ||
1721 | data->version); | ||
1722 | goto out_err_noserver; | ||
1723 | } | ||
1724 | data->root.size = NFS2_FHSIZE; | ||
1725 | memcpy(data->root.data, data->old_root.data, NFS2_FHSIZE); | ||
1726 | case 4: | ||
1727 | if (data->flags & NFS_MOUNT_SECFLAVOUR) { | ||
1728 | dprintk("%s: mount structure version %d does not support strong security\n", | ||
1729 | __FUNCTION__, | ||
1730 | data->version); | ||
1731 | goto out_err_noserver; | ||
1732 | } | ||
1733 | case 5: | ||
1734 | memset(data->context, 0, sizeof(data->context)); | ||
1735 | } | ||
1736 | #ifndef CONFIG_NFS_V3 | ||
1737 | /* If NFSv3 is not compiled in, return -EPROTONOSUPPORT */ | ||
1738 | error = -EPROTONOSUPPORT; | ||
1739 | if (data->flags & NFS_MOUNT_VER3) { | ||
1740 | dprintk("%s: NFSv3 not compiled into kernel\n", __FUNCTION__); | ||
1741 | goto out_err_noserver; | ||
1742 | } | ||
1743 | #endif /* CONFIG_NFS_V3 */ | ||
1744 | |||
1745 | error = -ENOMEM; | ||
1746 | server = kzalloc(sizeof(struct nfs_server), GFP_KERNEL); | ||
1747 | if (!server) | ||
1748 | goto out_err_noserver; | ||
1749 | /* Zero out the NFS state stuff */ | ||
1750 | init_nfsv4_state(server); | ||
1751 | server->client = server->client_sys = server->client_acl = ERR_PTR(-EINVAL); | ||
1752 | |||
1753 | root = &server->fh; | ||
1754 | if (data->flags & NFS_MOUNT_VER3) | ||
1755 | root->size = data->root.size; | ||
1756 | else | ||
1757 | root->size = NFS2_FHSIZE; | ||
1758 | error = -EINVAL; | ||
1759 | if (root->size > sizeof(root->data)) { | ||
1760 | dprintk("%s: invalid root filehandle\n", __FUNCTION__); | ||
1761 | goto out_err; | ||
1762 | } | ||
1763 | memcpy(root->data, data->root.data, root->size); | ||
1764 | |||
1765 | /* We now require that the mount process passes the remote address */ | ||
1766 | memcpy(&server->addr, &data->addr, sizeof(server->addr)); | ||
1767 | if (server->addr.sin_addr.s_addr == INADDR_ANY) { | ||
1768 | dprintk("%s: mount program didn't pass remote address!\n", | ||
1769 | __FUNCTION__); | ||
1770 | goto out_err; | ||
1771 | } | ||
1772 | |||
1773 | /* Fire up rpciod if not yet running */ | ||
1774 | error = rpciod_up(); | ||
1775 | if (error < 0) { | ||
1776 | dprintk("%s: couldn't start rpciod! Error = %d\n", | ||
1777 | __FUNCTION__, error); | ||
1778 | goto out_err; | ||
1779 | } | ||
1780 | |||
1781 | s = sget(fs_type, nfs_compare_super, nfs_set_super, server); | ||
1782 | if (IS_ERR(s)) { | ||
1783 | error = PTR_ERR(s); | ||
1784 | goto out_err_rpciod; | ||
1785 | } | ||
1786 | |||
1787 | if (s->s_root) | ||
1788 | goto out_rpciod_down; | ||
1789 | |||
1790 | s->s_flags = flags; | ||
1791 | |||
1792 | error = nfs_fill_super(s, data, flags & MS_SILENT ? 1 : 0); | ||
1793 | if (error) { | ||
1794 | up_write(&s->s_umount); | ||
1795 | deactivate_super(s); | ||
1796 | return error; | ||
1797 | } | ||
1798 | s->s_flags |= MS_ACTIVE; | ||
1799 | return simple_set_mnt(mnt, s); | ||
1800 | |||
1801 | out_rpciod_down: | ||
1802 | rpciod_down(); | ||
1803 | kfree(server); | ||
1804 | return simple_set_mnt(mnt, s); | ||
1805 | |||
1806 | out_err_rpciod: | ||
1807 | rpciod_down(); | ||
1808 | out_err: | ||
1809 | kfree(server); | ||
1810 | out_err_noserver: | ||
1811 | return error; | ||
1812 | } | ||
1813 | |||
1814 | static void nfs_kill_super(struct super_block *s) | ||
1815 | { | ||
1816 | struct nfs_server *server = NFS_SB(s); | ||
1817 | |||
1818 | kill_anon_super(s); | ||
1819 | |||
1820 | if (!IS_ERR(server->client)) | ||
1821 | rpc_shutdown_client(server->client); | ||
1822 | if (!IS_ERR(server->client_sys)) | ||
1823 | rpc_shutdown_client(server->client_sys); | ||
1824 | if (!IS_ERR(server->client_acl)) | ||
1825 | rpc_shutdown_client(server->client_acl); | ||
1826 | |||
1827 | if (!(server->flags & NFS_MOUNT_NONLM)) | ||
1828 | lockd_down(); /* release rpc.lockd */ | ||
1829 | |||
1830 | rpciod_down(); /* release rpciod */ | ||
1831 | |||
1832 | nfs_free_iostats(server->io_stats); | ||
1833 | kfree(server->hostname); | ||
1834 | kfree(server); | ||
1835 | } | ||
1836 | |||
1837 | static struct file_system_type nfs_fs_type = { | ||
1838 | .owner = THIS_MODULE, | ||
1839 | .name = "nfs", | ||
1840 | .get_sb = nfs_get_sb, | ||
1841 | .kill_sb = nfs_kill_super, | ||
1842 | .fs_flags = FS_ODD_RENAME|FS_REVAL_DOT|FS_BINARY_MOUNTDATA, | ||
1843 | }; | ||
1844 | 1034 | ||
1845 | #ifdef CONFIG_NFS_V4 | 1035 | #ifdef CONFIG_NFS_V4 |
1846 | 1036 | ||
1847 | static void nfs4_clear_inode(struct inode *); | ||
1848 | |||
1849 | |||
1850 | static struct super_operations nfs4_sops = { | ||
1851 | .alloc_inode = nfs_alloc_inode, | ||
1852 | .destroy_inode = nfs_destroy_inode, | ||
1853 | .write_inode = nfs_write_inode, | ||
1854 | .delete_inode = nfs_delete_inode, | ||
1855 | .statfs = nfs_statfs, | ||
1856 | .clear_inode = nfs4_clear_inode, | ||
1857 | .umount_begin = nfs_umount_begin, | ||
1858 | .show_options = nfs_show_options, | ||
1859 | .show_stats = nfs_show_stats, | ||
1860 | }; | ||
1861 | |||
1862 | /* | 1037 | /* |
1863 | * Clean out any remaining NFSv4 state that might be left over due | 1038 | * Clean out any remaining NFSv4 state that might be left over due |
1864 | * to open() calls that passed nfs_atomic_lookup, but failed to call | 1039 | * to open() calls that passed nfs_atomic_lookup, but failed to call |
1865 | * nfs_open(). | 1040 | * nfs_open(). |
1866 | */ | 1041 | */ |
1867 | static void nfs4_clear_inode(struct inode *inode) | 1042 | void nfs4_clear_inode(struct inode *inode) |
1868 | { | 1043 | { |
1869 | struct nfs_inode *nfsi = NFS_I(inode); | 1044 | struct nfs_inode *nfsi = NFS_I(inode); |
1870 | 1045 | ||
@@ -1888,365 +1063,9 @@ static void nfs4_clear_inode(struct inode *inode) | |||
1888 | nfs4_close_state(state, state->state); | 1063 | nfs4_close_state(state, state->state); |
1889 | } | 1064 | } |
1890 | } | 1065 | } |
1891 | |||
1892 | |||
1893 | static int nfs4_fill_super(struct super_block *sb, struct nfs4_mount_data *data, int silent) | ||
1894 | { | ||
1895 | struct nfs_server *server; | ||
1896 | struct nfs4_client *clp = NULL; | ||
1897 | struct rpc_xprt *xprt = NULL; | ||
1898 | struct rpc_clnt *clnt = NULL; | ||
1899 | struct rpc_timeout timeparms; | ||
1900 | rpc_authflavor_t authflavour; | ||
1901 | int err = -EIO; | ||
1902 | |||
1903 | sb->s_blocksize_bits = 0; | ||
1904 | sb->s_blocksize = 0; | ||
1905 | server = NFS_SB(sb); | ||
1906 | if (data->rsize != 0) | ||
1907 | server->rsize = nfs_block_size(data->rsize, NULL); | ||
1908 | if (data->wsize != 0) | ||
1909 | server->wsize = nfs_block_size(data->wsize, NULL); | ||
1910 | server->flags = data->flags & NFS_MOUNT_FLAGMASK; | ||
1911 | server->caps = NFS_CAP_ATOMIC_OPEN; | ||
1912 | |||
1913 | server->acregmin = data->acregmin*HZ; | ||
1914 | server->acregmax = data->acregmax*HZ; | ||
1915 | server->acdirmin = data->acdirmin*HZ; | ||
1916 | server->acdirmax = data->acdirmax*HZ; | ||
1917 | |||
1918 | server->rpc_ops = &nfs_v4_clientops; | ||
1919 | |||
1920 | nfs_init_timeout_values(&timeparms, data->proto, data->timeo, data->retrans); | ||
1921 | |||
1922 | server->retrans_timeo = timeparms.to_initval; | ||
1923 | server->retrans_count = timeparms.to_retries; | ||
1924 | |||
1925 | clp = nfs4_get_client(&server->addr.sin_addr); | ||
1926 | if (!clp) { | ||
1927 | dprintk("%s: failed to create NFS4 client.\n", __FUNCTION__); | ||
1928 | return -EIO; | ||
1929 | } | ||
1930 | |||
1931 | /* Now create transport and client */ | ||
1932 | authflavour = RPC_AUTH_UNIX; | ||
1933 | if (data->auth_flavourlen != 0) { | ||
1934 | if (data->auth_flavourlen != 1) { | ||
1935 | dprintk("%s: Invalid number of RPC auth flavours %d.\n", | ||
1936 | __FUNCTION__, data->auth_flavourlen); | ||
1937 | err = -EINVAL; | ||
1938 | goto out_fail; | ||
1939 | } | ||
1940 | if (copy_from_user(&authflavour, data->auth_flavours, sizeof(authflavour))) { | ||
1941 | err = -EFAULT; | ||
1942 | goto out_fail; | ||
1943 | } | ||
1944 | } | ||
1945 | |||
1946 | down_write(&clp->cl_sem); | ||
1947 | if (IS_ERR(clp->cl_rpcclient)) { | ||
1948 | xprt = xprt_create_proto(data->proto, &server->addr, &timeparms); | ||
1949 | if (IS_ERR(xprt)) { | ||
1950 | up_write(&clp->cl_sem); | ||
1951 | err = PTR_ERR(xprt); | ||
1952 | dprintk("%s: cannot create RPC transport. Error = %d\n", | ||
1953 | __FUNCTION__, err); | ||
1954 | goto out_fail; | ||
1955 | } | ||
1956 | clnt = rpc_create_client(xprt, server->hostname, &nfs_program, | ||
1957 | server->rpc_ops->version, authflavour); | ||
1958 | if (IS_ERR(clnt)) { | ||
1959 | up_write(&clp->cl_sem); | ||
1960 | err = PTR_ERR(clnt); | ||
1961 | dprintk("%s: cannot create RPC client. Error = %d\n", | ||
1962 | __FUNCTION__, err); | ||
1963 | goto out_fail; | ||
1964 | } | ||
1965 | clnt->cl_intr = 1; | ||
1966 | clnt->cl_softrtry = 1; | ||
1967 | clp->cl_rpcclient = clnt; | ||
1968 | memcpy(clp->cl_ipaddr, server->ip_addr, sizeof(clp->cl_ipaddr)); | ||
1969 | nfs_idmap_new(clp); | ||
1970 | } | ||
1971 | list_add_tail(&server->nfs4_siblings, &clp->cl_superblocks); | ||
1972 | clnt = rpc_clone_client(clp->cl_rpcclient); | ||
1973 | if (!IS_ERR(clnt)) | ||
1974 | server->nfs4_state = clp; | ||
1975 | up_write(&clp->cl_sem); | ||
1976 | clp = NULL; | ||
1977 | |||
1978 | if (IS_ERR(clnt)) { | ||
1979 | err = PTR_ERR(clnt); | ||
1980 | dprintk("%s: cannot create RPC client. Error = %d\n", | ||
1981 | __FUNCTION__, err); | ||
1982 | return err; | ||
1983 | } | ||
1984 | |||
1985 | server->client = clnt; | ||
1986 | |||
1987 | if (server->nfs4_state->cl_idmap == NULL) { | ||
1988 | dprintk("%s: failed to create idmapper.\n", __FUNCTION__); | ||
1989 | return -ENOMEM; | ||
1990 | } | ||
1991 | |||
1992 | if (clnt->cl_auth->au_flavor != authflavour) { | ||
1993 | struct rpc_auth *auth; | ||
1994 | |||
1995 | auth = rpcauth_create(authflavour, clnt); | ||
1996 | if (IS_ERR(auth)) { | ||
1997 | dprintk("%s: couldn't create credcache!\n", __FUNCTION__); | ||
1998 | return PTR_ERR(auth); | ||
1999 | } | ||
2000 | } | ||
2001 | |||
2002 | sb->s_time_gran = 1; | ||
2003 | |||
2004 | sb->s_op = &nfs4_sops; | ||
2005 | err = nfs_sb_init(sb, authflavour); | ||
2006 | if (err == 0) | ||
2007 | return 0; | ||
2008 | out_fail: | ||
2009 | if (clp) | ||
2010 | nfs4_put_client(clp); | ||
2011 | return err; | ||
2012 | } | ||
2013 | |||
2014 | static int nfs4_compare_super(struct super_block *sb, void *data) | ||
2015 | { | ||
2016 | struct nfs_server *server = data; | ||
2017 | struct nfs_server *old = NFS_SB(sb); | ||
2018 | |||
2019 | if (strcmp(server->hostname, old->hostname) != 0) | ||
2020 | return 0; | ||
2021 | if (strcmp(server->mnt_path, old->mnt_path) != 0) | ||
2022 | return 0; | ||
2023 | return 1; | ||
2024 | } | ||
2025 | |||
2026 | static void * | ||
2027 | nfs_copy_user_string(char *dst, struct nfs_string *src, int maxlen) | ||
2028 | { | ||
2029 | void *p = NULL; | ||
2030 | |||
2031 | if (!src->len) | ||
2032 | return ERR_PTR(-EINVAL); | ||
2033 | if (src->len < maxlen) | ||
2034 | maxlen = src->len; | ||
2035 | if (dst == NULL) { | ||
2036 | p = dst = kmalloc(maxlen + 1, GFP_KERNEL); | ||
2037 | if (p == NULL) | ||
2038 | return ERR_PTR(-ENOMEM); | ||
2039 | } | ||
2040 | if (copy_from_user(dst, src->data, maxlen)) { | ||
2041 | kfree(p); | ||
2042 | return ERR_PTR(-EFAULT); | ||
2043 | } | ||
2044 | dst[maxlen] = '\0'; | ||
2045 | return dst; | ||
2046 | } | ||
2047 | |||
2048 | static int nfs4_get_sb(struct file_system_type *fs_type, | ||
2049 | int flags, const char *dev_name, void *raw_data, struct vfsmount *mnt) | ||
2050 | { | ||
2051 | int error; | ||
2052 | struct nfs_server *server; | ||
2053 | struct super_block *s; | ||
2054 | struct nfs4_mount_data *data = raw_data; | ||
2055 | void *p; | ||
2056 | |||
2057 | if (data == NULL) { | ||
2058 | dprintk("%s: missing data argument\n", __FUNCTION__); | ||
2059 | return -EINVAL; | ||
2060 | } | ||
2061 | if (data->version <= 0 || data->version > NFS4_MOUNT_VERSION) { | ||
2062 | dprintk("%s: bad mount version\n", __FUNCTION__); | ||
2063 | return -EINVAL; | ||
2064 | } | ||
2065 | |||
2066 | server = kzalloc(sizeof(struct nfs_server), GFP_KERNEL); | ||
2067 | if (!server) | ||
2068 | return -ENOMEM; | ||
2069 | /* Zero out the NFS state stuff */ | ||
2070 | init_nfsv4_state(server); | ||
2071 | server->client = server->client_sys = server->client_acl = ERR_PTR(-EINVAL); | ||
2072 | |||
2073 | p = nfs_copy_user_string(NULL, &data->hostname, 256); | ||
2074 | if (IS_ERR(p)) | ||
2075 | goto out_err; | ||
2076 | server->hostname = p; | ||
2077 | |||
2078 | p = nfs_copy_user_string(NULL, &data->mnt_path, 1024); | ||
2079 | if (IS_ERR(p)) | ||
2080 | goto out_err; | ||
2081 | server->mnt_path = p; | ||
2082 | |||
2083 | p = nfs_copy_user_string(server->ip_addr, &data->client_addr, | ||
2084 | sizeof(server->ip_addr) - 1); | ||
2085 | if (IS_ERR(p)) | ||
2086 | goto out_err; | ||
2087 | |||
2088 | /* We now require that the mount process passes the remote address */ | ||
2089 | if (data->host_addrlen != sizeof(server->addr)) { | ||
2090 | error = -EINVAL; | ||
2091 | goto out_free; | ||
2092 | } | ||
2093 | if (copy_from_user(&server->addr, data->host_addr, sizeof(server->addr))) { | ||
2094 | error = -EFAULT; | ||
2095 | goto out_free; | ||
2096 | } | ||
2097 | if (server->addr.sin_family != AF_INET || | ||
2098 | server->addr.sin_addr.s_addr == INADDR_ANY) { | ||
2099 | dprintk("%s: mount program didn't pass remote IP address!\n", | ||
2100 | __FUNCTION__); | ||
2101 | error = -EINVAL; | ||
2102 | goto out_free; | ||
2103 | } | ||
2104 | |||
2105 | /* Fire up rpciod if not yet running */ | ||
2106 | error = rpciod_up(); | ||
2107 | if (error < 0) { | ||
2108 | dprintk("%s: couldn't start rpciod! Error = %d\n", | ||
2109 | __FUNCTION__, error); | ||
2110 | goto out_free; | ||
2111 | } | ||
2112 | |||
2113 | s = sget(fs_type, nfs4_compare_super, nfs_set_super, server); | ||
2114 | if (IS_ERR(s)) { | ||
2115 | error = PTR_ERR(s); | ||
2116 | goto out_free; | ||
2117 | } | ||
2118 | |||
2119 | if (s->s_root) { | ||
2120 | kfree(server->mnt_path); | ||
2121 | kfree(server->hostname); | ||
2122 | kfree(server); | ||
2123 | return simple_set_mnt(mnt, s); | ||
2124 | } | ||
2125 | |||
2126 | s->s_flags = flags; | ||
2127 | |||
2128 | error = nfs4_fill_super(s, data, flags & MS_SILENT ? 1 : 0); | ||
2129 | if (error) { | ||
2130 | up_write(&s->s_umount); | ||
2131 | deactivate_super(s); | ||
2132 | return error; | ||
2133 | } | ||
2134 | s->s_flags |= MS_ACTIVE; | ||
2135 | return simple_set_mnt(mnt, s); | ||
2136 | out_err: | ||
2137 | error = PTR_ERR(p); | ||
2138 | out_free: | ||
2139 | kfree(server->mnt_path); | ||
2140 | kfree(server->hostname); | ||
2141 | kfree(server); | ||
2142 | return error; | ||
2143 | } | ||
2144 | |||
2145 | static void nfs4_kill_super(struct super_block *sb) | ||
2146 | { | ||
2147 | struct nfs_server *server = NFS_SB(sb); | ||
2148 | |||
2149 | nfs_return_all_delegations(sb); | ||
2150 | kill_anon_super(sb); | ||
2151 | |||
2152 | nfs4_renewd_prepare_shutdown(server); | ||
2153 | |||
2154 | if (server->client != NULL && !IS_ERR(server->client)) | ||
2155 | rpc_shutdown_client(server->client); | ||
2156 | |||
2157 | destroy_nfsv4_state(server); | ||
2158 | |||
2159 | rpciod_down(); | ||
2160 | |||
2161 | nfs_free_iostats(server->io_stats); | ||
2162 | kfree(server->hostname); | ||
2163 | kfree(server); | ||
2164 | } | ||
2165 | |||
2166 | static struct file_system_type nfs4_fs_type = { | ||
2167 | .owner = THIS_MODULE, | ||
2168 | .name = "nfs4", | ||
2169 | .get_sb = nfs4_get_sb, | ||
2170 | .kill_sb = nfs4_kill_super, | ||
2171 | .fs_flags = FS_ODD_RENAME|FS_REVAL_DOT|FS_BINARY_MOUNTDATA, | ||
2172 | }; | ||
2173 | |||
2174 | static const int nfs_set_port_min = 0; | ||
2175 | static const int nfs_set_port_max = 65535; | ||
2176 | static int param_set_port(const char *val, struct kernel_param *kp) | ||
2177 | { | ||
2178 | char *endp; | ||
2179 | int num = simple_strtol(val, &endp, 0); | ||
2180 | if (endp == val || *endp || num < nfs_set_port_min || num > nfs_set_port_max) | ||
2181 | return -EINVAL; | ||
2182 | *((int *)kp->arg) = num; | ||
2183 | return 0; | ||
2184 | } | ||
2185 | |||
2186 | module_param_call(callback_tcpport, param_set_port, param_get_int, | ||
2187 | &nfs_callback_set_tcpport, 0644); | ||
2188 | |||
2189 | static int param_set_idmap_timeout(const char *val, struct kernel_param *kp) | ||
2190 | { | ||
2191 | char *endp; | ||
2192 | int num = simple_strtol(val, &endp, 0); | ||
2193 | int jif = num * HZ; | ||
2194 | if (endp == val || *endp || num < 0 || jif < num) | ||
2195 | return -EINVAL; | ||
2196 | *((int *)kp->arg) = jif; | ||
2197 | return 0; | ||
2198 | } | ||
2199 | |||
2200 | module_param_call(idmap_cache_timeout, param_set_idmap_timeout, param_get_int, | ||
2201 | &nfs_idmap_cache_timeout, 0644); | ||
2202 | |||
2203 | #define nfs4_init_once(nfsi) \ | ||
2204 | do { \ | ||
2205 | INIT_LIST_HEAD(&(nfsi)->open_states); \ | ||
2206 | nfsi->delegation = NULL; \ | ||
2207 | nfsi->delegation_state = 0; \ | ||
2208 | init_rwsem(&nfsi->rwsem); \ | ||
2209 | } while(0) | ||
2210 | |||
2211 | static inline int register_nfs4fs(void) | ||
2212 | { | ||
2213 | int ret; | ||
2214 | |||
2215 | ret = nfs_register_sysctl(); | ||
2216 | if (ret != 0) | ||
2217 | return ret; | ||
2218 | ret = register_filesystem(&nfs4_fs_type); | ||
2219 | if (ret != 0) | ||
2220 | nfs_unregister_sysctl(); | ||
2221 | return ret; | ||
2222 | } | ||
2223 | |||
2224 | static inline void unregister_nfs4fs(void) | ||
2225 | { | ||
2226 | unregister_filesystem(&nfs4_fs_type); | ||
2227 | nfs_unregister_sysctl(); | ||
2228 | } | ||
2229 | #else | ||
2230 | #define nfs4_init_once(nfsi) \ | ||
2231 | do { } while (0) | ||
2232 | #define register_nfs4fs() (0) | ||
2233 | #define unregister_nfs4fs() | ||
2234 | #endif | 1066 | #endif |
2235 | 1067 | ||
2236 | extern int nfs_init_nfspagecache(void); | 1068 | struct inode *nfs_alloc_inode(struct super_block *sb) |
2237 | extern void nfs_destroy_nfspagecache(void); | ||
2238 | extern int nfs_init_readpagecache(void); | ||
2239 | extern void nfs_destroy_readpagecache(void); | ||
2240 | extern int nfs_init_writepagecache(void); | ||
2241 | extern void nfs_destroy_writepagecache(void); | ||
2242 | #ifdef CONFIG_NFS_DIRECTIO | ||
2243 | extern int nfs_init_directcache(void); | ||
2244 | extern void nfs_destroy_directcache(void); | ||
2245 | #endif | ||
2246 | |||
2247 | static kmem_cache_t * nfs_inode_cachep; | ||
2248 | |||
2249 | static struct inode *nfs_alloc_inode(struct super_block *sb) | ||
2250 | { | 1069 | { |
2251 | struct nfs_inode *nfsi; | 1070 | struct nfs_inode *nfsi; |
2252 | nfsi = (struct nfs_inode *)kmem_cache_alloc(nfs_inode_cachep, SLAB_KERNEL); | 1071 | nfsi = (struct nfs_inode *)kmem_cache_alloc(nfs_inode_cachep, SLAB_KERNEL); |
@@ -2265,11 +1084,21 @@ static struct inode *nfs_alloc_inode(struct super_block *sb) | |||
2265 | return &nfsi->vfs_inode; | 1084 | return &nfsi->vfs_inode; |
2266 | } | 1085 | } |
2267 | 1086 | ||
2268 | static void nfs_destroy_inode(struct inode *inode) | 1087 | void nfs_destroy_inode(struct inode *inode) |
2269 | { | 1088 | { |
2270 | kmem_cache_free(nfs_inode_cachep, NFS_I(inode)); | 1089 | kmem_cache_free(nfs_inode_cachep, NFS_I(inode)); |
2271 | } | 1090 | } |
2272 | 1091 | ||
1092 | static inline void nfs4_init_once(struct nfs_inode *nfsi) | ||
1093 | { | ||
1094 | #ifdef CONFIG_NFS_V4 | ||
1095 | INIT_LIST_HEAD(&nfsi->open_states); | ||
1096 | nfsi->delegation = NULL; | ||
1097 | nfsi->delegation_state = 0; | ||
1098 | init_rwsem(&nfsi->rwsem); | ||
1099 | #endif | ||
1100 | } | ||
1101 | |||
2273 | static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags) | 1102 | static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags) |
2274 | { | 1103 | { |
2275 | struct nfs_inode *nfsi = (struct nfs_inode *) foo; | 1104 | struct nfs_inode *nfsi = (struct nfs_inode *) foo; |
@@ -2290,7 +1119,7 @@ static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags) | |||
2290 | } | 1119 | } |
2291 | } | 1120 | } |
2292 | 1121 | ||
2293 | static int nfs_init_inodecache(void) | 1122 | static int __init nfs_init_inodecache(void) |
2294 | { | 1123 | { |
2295 | nfs_inode_cachep = kmem_cache_create("nfs_inode_cache", | 1124 | nfs_inode_cachep = kmem_cache_create("nfs_inode_cache", |
2296 | sizeof(struct nfs_inode), | 1125 | sizeof(struct nfs_inode), |
@@ -2303,7 +1132,7 @@ static int nfs_init_inodecache(void) | |||
2303 | return 0; | 1132 | return 0; |
2304 | } | 1133 | } |
2305 | 1134 | ||
2306 | static void nfs_destroy_inodecache(void) | 1135 | static void __exit nfs_destroy_inodecache(void) |
2307 | { | 1136 | { |
2308 | if (kmem_cache_destroy(nfs_inode_cachep)) | 1137 | if (kmem_cache_destroy(nfs_inode_cachep)) |
2309 | printk(KERN_INFO "nfs_inode_cache: not all structures were freed\n"); | 1138 | printk(KERN_INFO "nfs_inode_cache: not all structures were freed\n"); |
@@ -2332,29 +1161,22 @@ static int __init init_nfs_fs(void) | |||
2332 | if (err) | 1161 | if (err) |
2333 | goto out1; | 1162 | goto out1; |
2334 | 1163 | ||
2335 | #ifdef CONFIG_NFS_DIRECTIO | ||
2336 | err = nfs_init_directcache(); | 1164 | err = nfs_init_directcache(); |
2337 | if (err) | 1165 | if (err) |
2338 | goto out0; | 1166 | goto out0; |
2339 | #endif | ||
2340 | 1167 | ||
2341 | #ifdef CONFIG_PROC_FS | 1168 | #ifdef CONFIG_PROC_FS |
2342 | rpc_proc_register(&nfs_rpcstat); | 1169 | rpc_proc_register(&nfs_rpcstat); |
2343 | #endif | 1170 | #endif |
2344 | err = register_filesystem(&nfs_fs_type); | 1171 | if ((err = register_nfs_fs()) != 0) |
2345 | if (err) | ||
2346 | goto out; | ||
2347 | if ((err = register_nfs4fs()) != 0) | ||
2348 | goto out; | 1172 | goto out; |
2349 | return 0; | 1173 | return 0; |
2350 | out: | 1174 | out: |
2351 | #ifdef CONFIG_PROC_FS | 1175 | #ifdef CONFIG_PROC_FS |
2352 | rpc_proc_unregister("nfs"); | 1176 | rpc_proc_unregister("nfs"); |
2353 | #endif | 1177 | #endif |
2354 | #ifdef CONFIG_NFS_DIRECTIO | ||
2355 | nfs_destroy_directcache(); | 1178 | nfs_destroy_directcache(); |
2356 | out0: | 1179 | out0: |
2357 | #endif | ||
2358 | nfs_destroy_writepagecache(); | 1180 | nfs_destroy_writepagecache(); |
2359 | out1: | 1181 | out1: |
2360 | nfs_destroy_readpagecache(); | 1182 | nfs_destroy_readpagecache(); |
@@ -2368,9 +1190,7 @@ out4: | |||
2368 | 1190 | ||
2369 | static void __exit exit_nfs_fs(void) | 1191 | static void __exit exit_nfs_fs(void) |
2370 | { | 1192 | { |
2371 | #ifdef CONFIG_NFS_DIRECTIO | ||
2372 | nfs_destroy_directcache(); | 1193 | nfs_destroy_directcache(); |
2373 | #endif | ||
2374 | nfs_destroy_writepagecache(); | 1194 | nfs_destroy_writepagecache(); |
2375 | nfs_destroy_readpagecache(); | 1195 | nfs_destroy_readpagecache(); |
2376 | nfs_destroy_inodecache(); | 1196 | nfs_destroy_inodecache(); |
@@ -2378,8 +1198,7 @@ static void __exit exit_nfs_fs(void) | |||
2378 | #ifdef CONFIG_PROC_FS | 1198 | #ifdef CONFIG_PROC_FS |
2379 | rpc_proc_unregister("nfs"); | 1199 | rpc_proc_unregister("nfs"); |
2380 | #endif | 1200 | #endif |
2381 | unregister_filesystem(&nfs_fs_type); | 1201 | unregister_nfs_fs(); |
2382 | unregister_nfs4fs(); | ||
2383 | } | 1202 | } |
2384 | 1203 | ||
2385 | /* Not quite true; I just maintain it */ | 1204 | /* Not quite true; I just maintain it */ |