aboutsummaryrefslogtreecommitdiffstats
path: root/fs/nfs/inode.c
diff options
context:
space:
mode:
Diffstat (limited to 'fs/nfs/inode.c')
-rw-r--r--fs/nfs/inode.c1365
1 files changed, 93 insertions, 1272 deletions
diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index 937fbfc381bb..bc9376ca86cd 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -13,7 +13,6 @@
13 * 13 *
14 */ 14 */
15 15
16#include <linux/config.h>
17#include <linux/module.h> 16#include <linux/module.h>
18#include <linux/init.h> 17#include <linux/init.h>
19 18
@@ -36,6 +35,8 @@
36#include <linux/mount.h> 35#include <linux/mount.h>
37#include <linux/nfs_idmap.h> 36#include <linux/nfs_idmap.h>
38#include <linux/vfs.h> 37#include <linux/vfs.h>
38#include <linux/inet.h>
39#include <linux/nfs_xdr.h>
39 40
40#include <asm/system.h> 41#include <asm/system.h>
41#include <asm/uaccess.h> 42#include <asm/uaccess.h>
@@ -44,89 +45,17 @@
44#include "callback.h" 45#include "callback.h"
45#include "delegation.h" 46#include "delegation.h"
46#include "iostat.h" 47#include "iostat.h"
48#include "internal.h"
47 49
48#define NFSDBG_FACILITY NFSDBG_VFS 50#define NFSDBG_FACILITY NFSDBG_VFS
49#define NFS_PARANOIA 1 51#define NFS_PARANOIA 1
50 52
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
59static void nfs_invalidate_inode(struct inode *); 53static void nfs_invalidate_inode(struct inode *);
60static int nfs_update_inode(struct inode *, struct nfs_fattr *); 54static int nfs_update_inode(struct inode *, struct nfs_fattr *);
61 55
62static struct inode *nfs_alloc_inode(struct super_block *sb);
63static void nfs_destroy_inode(struct inode *);
64static int nfs_write_inode(struct inode *,int);
65static void nfs_delete_inode(struct inode *);
66static void nfs_clear_inode(struct inode *);
67static void nfs_umount_begin(struct super_block *);
68static int nfs_statfs(struct dentry *, struct kstatfs *);
69static int nfs_show_options(struct seq_file *, struct vfsmount *);
70static int nfs_show_stats(struct seq_file *, struct vfsmount *);
71static void nfs_zap_acl_cache(struct inode *); 56static void nfs_zap_acl_cache(struct inode *);
72 57
73static struct rpc_program nfs_program; 58static kmem_cache_t * nfs_inode_cachep;
74
75static 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 */
90static struct rpc_stat nfs_rpcstat = {
91 .program = &nfs_program
92};
93static 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
107static 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
117static struct rpc_stat nfsacl_rpcstat = { &nfsacl_program };
118static struct rpc_version * nfsacl_version[] = {
119 [3] = &nfsacl_version3,
120};
121
122struct 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 59
131static inline unsigned long 60static inline unsigned long
132nfs_fattr_to_ino_t(struct nfs_fattr *fattr) 61nfs_fattr_to_ino_t(struct nfs_fattr *fattr)
@@ -134,8 +63,7 @@ nfs_fattr_to_ino_t(struct nfs_fattr *fattr)
134 return nfs_fileid_to_ino_t(fattr->fileid); 63 return nfs_fileid_to_ino_t(fattr->fileid);
135} 64}
136 65
137static int 66int nfs_write_inode(struct inode *inode, int sync)
138nfs_write_inode(struct inode *inode, int sync)
139{ 67{
140 int flags = sync ? FLUSH_SYNC : 0; 68 int flags = sync ? FLUSH_SYNC : 0;
141 int ret; 69 int ret;
@@ -146,586 +74,16 @@ nfs_write_inode(struct inode *inode, int sync)
146 return 0; 74 return 0;
147} 75}
148 76
149static void 77void nfs_clear_inode(struct inode *inode)
150nfs_delete_inode(struct inode * inode)
151{ 78{
152 dprintk("NFS: delete_inode(%s/%ld)\n", inode->i_sb->s_id, inode->i_ino);
153
154 truncate_inode_pages(&inode->i_data, 0);
155
156 nfs_wb_all(inode);
157 /* 79 /*
158 * The following should never happen... 80 * The following should never happen...
159 */ 81 */
160 if (nfs_have_writebacks(inode)) { 82 BUG_ON(nfs_have_writebacks(inode));
161 printk(KERN_ERR "nfs_delete_inode: inode %ld has pending RPC requests\n", inode->i_ino); 83 BUG_ON(!list_empty(&NFS_I(inode)->open_files));
162 } 84 BUG_ON(atomic_read(&NFS_I(inode)->data_updates) != 0);
163
164 clear_inode(inode);
165}
166
167static void
168nfs_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));
175 nfs_zap_acl_cache(inode); 85 nfs_zap_acl_cache(inode);
176 cred = nfsi->cache_access.cred; 86 nfs_access_zap_cache(inode);
177 if (cred)
178 put_rpccred(cred);
179 BUG_ON(atomic_read(&nfsi->data_updates) != 0);
180}
181
182void
183nfs_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
196static inline unsigned long
197nfs_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 */
216static inline unsigned long
217nfs_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 */
226static inline unsigned long
227nfs_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 */
240static struct inode *
241nfs_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 */
258static int
259nfs_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. */
357out_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
364static 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 */
396static struct rpc_clnt *
397nfs_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
429out_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 */
439static int
440nfs_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
536static int
537nfs_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
593static 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
645static 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
657static 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} 87}
730 88
731/** 89/**
@@ -879,17 +237,25 @@ nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr)
879 /* Why so? Because we want revalidate for devices/FIFOs, and 237 /* Why so? Because we want revalidate for devices/FIFOs, and
880 * that's precisely what we have in nfs_file_inode_operations. 238 * that's precisely what we have in nfs_file_inode_operations.
881 */ 239 */
882 inode->i_op = NFS_SB(sb)->rpc_ops->file_inode_ops; 240 inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->file_inode_ops;
883 if (S_ISREG(inode->i_mode)) { 241 if (S_ISREG(inode->i_mode)) {
884 inode->i_fop = &nfs_file_operations; 242 inode->i_fop = &nfs_file_operations;
885 inode->i_data.a_ops = &nfs_file_aops; 243 inode->i_data.a_ops = &nfs_file_aops;
886 inode->i_data.backing_dev_info = &NFS_SB(sb)->backing_dev_info; 244 inode->i_data.backing_dev_info = &NFS_SB(sb)->backing_dev_info;
887 } else if (S_ISDIR(inode->i_mode)) { 245 } else if (S_ISDIR(inode->i_mode)) {
888 inode->i_op = NFS_SB(sb)->rpc_ops->dir_inode_ops; 246 inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->dir_inode_ops;
889 inode->i_fop = &nfs_dir_operations; 247 inode->i_fop = &nfs_dir_operations;
890 if (nfs_server_capable(inode, NFS_CAP_READDIRPLUS) 248 if (nfs_server_capable(inode, NFS_CAP_READDIRPLUS)
891 && fattr->size <= NFS_LIMIT_READDIRPLUS) 249 && fattr->size <= NFS_LIMIT_READDIRPLUS)
892 set_bit(NFS_INO_ADVISE_RDPLUS, &NFS_FLAGS(inode)); 250 set_bit(NFS_INO_ADVISE_RDPLUS, &NFS_FLAGS(inode));
251 /* Deal with crossing mountpoints */
252 if (!nfs_fsid_equal(&NFS_SB(sb)->fsid, &fattr->fsid)) {
253 if (fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL)
254 inode->i_op = &nfs_referral_inode_operations;
255 else
256 inode->i_op = &nfs_mountpoint_inode_operations;
257 inode->i_fop = NULL;
258 }
893 } else if (S_ISLNK(inode->i_mode)) 259 } else if (S_ISLNK(inode->i_mode))
894 inode->i_op = &nfs_symlink_inode_operations; 260 inode->i_op = &nfs_symlink_inode_operations;
895 else 261 else
@@ -911,15 +277,13 @@ nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr)
911 * report the blocks in 512byte units 277 * report the blocks in 512byte units
912 */ 278 */
913 inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used); 279 inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
914 inode->i_blksize = inode->i_sb->s_blocksize;
915 } else { 280 } else {
916 inode->i_blocks = fattr->du.nfs2.blocks; 281 inode->i_blocks = fattr->du.nfs2.blocks;
917 inode->i_blksize = fattr->du.nfs2.blocksize;
918 } 282 }
919 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode); 283 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
920 nfsi->attrtimeo_timestamp = jiffies; 284 nfsi->attrtimeo_timestamp = jiffies;
921 memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf)); 285 memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf));
922 nfsi->cache_access.cred = NULL; 286 nfsi->access_cache = RB_ROOT;
923 287
924 unlock_new_inode(inode); 288 unlock_new_inode(inode);
925 } else 289 } else
@@ -1077,7 +441,7 @@ static struct nfs_open_context *alloc_nfs_open_context(struct vfsmount *mnt, str
1077{ 441{
1078 struct nfs_open_context *ctx; 442 struct nfs_open_context *ctx;
1079 443
1080 ctx = (struct nfs_open_context *)kmalloc(sizeof(*ctx), GFP_KERNEL); 444 ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
1081 if (ctx != NULL) { 445 if (ctx != NULL) {
1082 atomic_set(&ctx->count, 1); 446 atomic_set(&ctx->count, 1);
1083 ctx->dentry = dget(dentry); 447 ctx->dentry = dget(dentry);
@@ -1208,6 +572,7 @@ __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
1208 dfprintk(PAGECACHE, "NFS: revalidating (%s/%Ld)\n", 572 dfprintk(PAGECACHE, "NFS: revalidating (%s/%Ld)\n",
1209 inode->i_sb->s_id, (long long)NFS_FILEID(inode)); 573 inode->i_sb->s_id, (long long)NFS_FILEID(inode));
1210 574
575 nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE);
1211 lock_kernel(); 576 lock_kernel();
1212 if (!inode || is_bad_inode(inode)) 577 if (!inode || is_bad_inode(inode))
1213 goto out_nowait; 578 goto out_nowait;
@@ -1221,7 +586,7 @@ __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
1221 status = -ESTALE; 586 status = -ESTALE;
1222 /* Do we trust the cached ESTALE? */ 587 /* Do we trust the cached ESTALE? */
1223 if (NFS_ATTRTIMEO(inode) != 0) { 588 if (NFS_ATTRTIMEO(inode) != 0) {
1224 if (nfsi->cache_validity & (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA|NFS_INO_INVALID_ATIME)) { 589 if (nfsi->cache_validity & (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ATIME)) {
1225 /* no */ 590 /* no */
1226 } else 591 } else
1227 goto out; 592 goto out;
@@ -1252,8 +617,6 @@ __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
1252 } 617 }
1253 spin_unlock(&inode->i_lock); 618 spin_unlock(&inode->i_lock);
1254 619
1255 nfs_revalidate_mapping(inode, inode->i_mapping);
1256
1257 if (nfsi->cache_validity & NFS_INO_INVALID_ACL) 620 if (nfsi->cache_validity & NFS_INO_INVALID_ACL)
1258 nfs_zap_acl_cache(inode); 621 nfs_zap_acl_cache(inode);
1259 622
@@ -1287,8 +650,7 @@ int nfs_attribute_timeout(struct inode *inode)
1287 */ 650 */
1288int nfs_revalidate_inode(struct nfs_server *server, struct inode *inode) 651int nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
1289{ 652{
1290 nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE); 653 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)) 654 && !nfs_attribute_timeout(inode))
1293 return NFS_STALE(inode) ? -ESTALE : 0; 655 return NFS_STALE(inode) ? -ESTALE : 0;
1294 return __nfs_revalidate_inode(server, inode); 656 return __nfs_revalidate_inode(server, inode);
@@ -1299,9 +661,16 @@ int nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
1299 * @inode - pointer to host inode 661 * @inode - pointer to host inode
1300 * @mapping - pointer to mapping 662 * @mapping - pointer to mapping
1301 */ 663 */
1302void nfs_revalidate_mapping(struct inode *inode, struct address_space *mapping) 664int nfs_revalidate_mapping(struct inode *inode, struct address_space *mapping)
1303{ 665{
1304 struct nfs_inode *nfsi = NFS_I(inode); 666 struct nfs_inode *nfsi = NFS_I(inode);
667 int ret = 0;
668
669 if (NFS_STALE(inode))
670 ret = -ESTALE;
671 if ((nfsi->cache_validity & NFS_INO_REVAL_PAGECACHE)
672 || nfs_attribute_timeout(inode))
673 ret = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
1305 674
1306 if (nfsi->cache_validity & NFS_INO_INVALID_DATA) { 675 if (nfsi->cache_validity & NFS_INO_INVALID_DATA) {
1307 nfs_inc_stats(inode, NFSIOS_DATAINVALIDATE); 676 nfs_inc_stats(inode, NFSIOS_DATAINVALIDATE);
@@ -1322,6 +691,7 @@ void nfs_revalidate_mapping(struct inode *inode, struct address_space *mapping)
1322 inode->i_sb->s_id, 691 inode->i_sb->s_id,
1323 (long long)NFS_FILEID(inode)); 692 (long long)NFS_FILEID(inode));
1324 } 693 }
694 return ret;
1325} 695}
1326 696
1327/** 697/**
@@ -1345,13 +715,11 @@ void nfs_end_data_update(struct inode *inode)
1345{ 715{
1346 struct nfs_inode *nfsi = NFS_I(inode); 716 struct nfs_inode *nfsi = NFS_I(inode);
1347 717
1348 if (!nfs_have_delegation(inode, FMODE_READ)) { 718 /* Directories: invalidate page cache */
1349 /* Directories and symlinks: invalidate page cache */ 719 if (S_ISDIR(inode->i_mode)) {
1350 if (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode)) { 720 spin_lock(&inode->i_lock);
1351 spin_lock(&inode->i_lock); 721 nfsi->cache_validity |= NFS_INO_INVALID_DATA;
1352 nfsi->cache_validity |= NFS_INO_INVALID_DATA; 722 spin_unlock(&inode->i_lock);
1353 spin_unlock(&inode->i_lock);
1354 }
1355 } 723 }
1356 nfsi->cache_change_attribute = jiffies; 724 nfsi->cache_change_attribute = jiffies;
1357 atomic_dec(&nfsi->data_updates); 725 atomic_dec(&nfsi->data_updates);
@@ -1361,12 +729,6 @@ static void nfs_wcc_update_inode(struct inode *inode, struct nfs_fattr *fattr)
1361{ 729{
1362 struct nfs_inode *nfsi = NFS_I(inode); 730 struct nfs_inode *nfsi = NFS_I(inode);
1363 731
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 */ 732 /* If we have atomic WCC data, we may update some attributes */
1371 if ((fattr->valid & NFS_ATTR_WCC) != 0) { 733 if ((fattr->valid & NFS_ATTR_WCC) != 0) {
1372 if (timespec_equal(&inode->i_ctime, &fattr->pre_ctime)) { 734 if (timespec_equal(&inode->i_ctime, &fattr->pre_ctime)) {
@@ -1400,9 +762,6 @@ static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fat
1400 int data_unstable; 762 int data_unstable;
1401 763
1402 764
1403 if ((fattr->valid & NFS_ATTR_FATTR) == 0)
1404 return 0;
1405
1406 /* Has the inode gone and changed behind our back? */ 765 /* Has the inode gone and changed behind our back? */
1407 if (nfsi->fileid != fattr->fileid 766 if (nfsi->fileid != fattr->fileid
1408 || (inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT)) { 767 || (inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT)) {
@@ -1415,20 +774,13 @@ static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fat
1415 /* Do atomic weak cache consistency updates */ 774 /* Do atomic weak cache consistency updates */
1416 nfs_wcc_update_inode(inode, fattr); 775 nfs_wcc_update_inode(inode, fattr);
1417 776
1418 if ((fattr->valid & NFS_ATTR_FATTR_V4) != 0) { 777 if ((fattr->valid & NFS_ATTR_FATTR_V4) != 0 &&
1419 if (nfsi->change_attr == fattr->change_attr) 778 nfsi->change_attr != fattr->change_attr)
1420 goto out; 779 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 780
1426 /* Verify a few of the more important attributes */ 781 /* Verify a few of the more important attributes */
1427 if (!timespec_equal(&inode->i_mtime, &fattr->mtime)) { 782 if (!timespec_equal(&inode->i_mtime, &fattr->mtime))
1428 nfsi->cache_validity |= NFS_INO_INVALID_ATTR; 783 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 784
1433 cur_size = i_size_read(inode); 785 cur_size = i_size_read(inode);
1434 new_isize = nfs_size_to_loff_t(fattr->size); 786 new_isize = nfs_size_to_loff_t(fattr->size);
@@ -1445,7 +797,6 @@ static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fat
1445 if (inode->i_nlink != fattr->nlink) 797 if (inode->i_nlink != fattr->nlink)
1446 nfsi->cache_validity |= NFS_INO_INVALID_ATTR; 798 nfsi->cache_validity |= NFS_INO_INVALID_ATTR;
1447 799
1448out:
1449 if (!timespec_equal(&inode->i_atime, &fattr->atime)) 800 if (!timespec_equal(&inode->i_atime, &fattr->atime))
1450 nfsi->cache_validity |= NFS_INO_INVALID_ATIME; 801 nfsi->cache_validity |= NFS_INO_INVALID_ATIME;
1451 802
@@ -1471,7 +822,6 @@ int nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr)
1471 if ((fattr->valid & NFS_ATTR_FATTR) == 0) 822 if ((fattr->valid & NFS_ATTR_FATTR) == 0)
1472 return 0; 823 return 0;
1473 spin_lock(&inode->i_lock); 824 spin_lock(&inode->i_lock);
1474 nfsi->cache_validity &= ~NFS_INO_REVAL_PAGECACHE;
1475 if (time_after(fattr->time_start, nfsi->last_updated)) 825 if (time_after(fattr->time_start, nfsi->last_updated))
1476 status = nfs_update_inode(inode, fattr); 826 status = nfs_update_inode(inode, fattr);
1477 else 827 else
@@ -1488,6 +838,12 @@ int nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr)
1488 * 838 *
1489 * After an operation that has changed the inode metadata, mark the 839 * After an operation that has changed the inode metadata, mark the
1490 * attribute cache as being invalid, then try to update it. 840 * attribute cache as being invalid, then try to update it.
841 *
842 * NB: if the server didn't return any post op attributes, this
843 * function will force the retrieval of attributes before the next
844 * NFS request. Thus it should be used only for operations that
845 * are expected to change one or more attributes, to avoid
846 * unnecessary NFS requests and trips through nfs_update_inode().
1491 */ 847 */
1492int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr) 848int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr)
1493{ 849{
@@ -1496,7 +852,7 @@ int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr)
1496 852
1497 spin_lock(&inode->i_lock); 853 spin_lock(&inode->i_lock);
1498 if (unlikely((fattr->valid & NFS_ATTR_FATTR) == 0)) { 854 if (unlikely((fattr->valid & NFS_ATTR_FATTR) == 0)) {
1499 nfsi->cache_validity |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS; 855 nfsi->cache_validity |= NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
1500 goto out; 856 goto out;
1501 } 857 }
1502 status = nfs_update_inode(inode, fattr); 858 status = nfs_update_inode(inode, fattr);
@@ -1519,6 +875,7 @@ out:
1519 */ 875 */
1520static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr) 876static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
1521{ 877{
878 struct nfs_server *server;
1522 struct nfs_inode *nfsi = NFS_I(inode); 879 struct nfs_inode *nfsi = NFS_I(inode);
1523 loff_t cur_isize, new_isize; 880 loff_t cur_isize, new_isize;
1524 unsigned int invalid = 0; 881 unsigned int invalid = 0;
@@ -1528,9 +885,6 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
1528 __FUNCTION__, inode->i_sb->s_id, inode->i_ino, 885 __FUNCTION__, inode->i_sb->s_id, inode->i_ino,
1529 atomic_read(&inode->i_count), fattr->valid); 886 atomic_read(&inode->i_count), fattr->valid);
1530 887
1531 if ((fattr->valid & NFS_ATTR_FATTR) == 0)
1532 return 0;
1533
1534 if (nfsi->fileid != fattr->fileid) 888 if (nfsi->fileid != fattr->fileid)
1535 goto out_fileid; 889 goto out_fileid;
1536 890
@@ -1540,6 +894,12 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
1540 if ((inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT)) 894 if ((inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT))
1541 goto out_changed; 895 goto out_changed;
1542 896
897 server = NFS_SERVER(inode);
898 /* Update the fsid if and only if this is the root directory */
899 if (inode == inode->i_sb->s_root->d_inode
900 && !nfs_fsid_equal(&server->fsid, &fattr->fsid))
901 server->fsid = fattr->fsid;
902
1543 /* 903 /*
1544 * Update the read time so we don't revalidate too often. 904 * Update the read time so we don't revalidate too often.
1545 */ 905 */
@@ -1549,7 +909,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? */ 909 /* Are we racing with known updates of the metadata on the server? */
1550 data_stable = nfs_verify_change_attribute(inode, fattr->time_start); 910 data_stable = nfs_verify_change_attribute(inode, fattr->time_start);
1551 if (data_stable) 911 if (data_stable)
1552 nfsi->cache_validity &= ~(NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ATIME); 912 nfsi->cache_validity &= ~(NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE|NFS_INO_INVALID_ATIME);
1553 913
1554 /* Do atomic weak cache consistency updates */ 914 /* Do atomic weak cache consistency updates */
1555 nfs_wcc_update_inode(inode, fattr); 915 nfs_wcc_update_inode(inode, fattr);
@@ -1607,21 +967,17 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
1607 * report the blocks in 512byte units 967 * report the blocks in 512byte units
1608 */ 968 */
1609 inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used); 969 inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
1610 inode->i_blksize = inode->i_sb->s_blocksize;
1611 } else { 970 } else {
1612 inode->i_blocks = fattr->du.nfs2.blocks; 971 inode->i_blocks = fattr->du.nfs2.blocks;
1613 inode->i_blksize = fattr->du.nfs2.blocksize;
1614 } 972 }
1615 973
1616 if ((fattr->valid & NFS_ATTR_FATTR_V4)) { 974 if ((fattr->valid & NFS_ATTR_FATTR_V4) != 0 &&
1617 if (nfsi->change_attr != fattr->change_attr) { 975 nfsi->change_attr != fattr->change_attr) {
1618 dprintk("NFS: change_attr change on server for file %s/%ld\n", 976 dprintk("NFS: change_attr change on server for file %s/%ld\n",
1619 inode->i_sb->s_id, inode->i_ino); 977 inode->i_sb->s_id, inode->i_ino);
1620 nfsi->change_attr = fattr->change_attr; 978 nfsi->change_attr = fattr->change_attr;
1621 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL; 979 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
1622 nfsi->cache_change_attribute = jiffies; 980 nfsi->cache_change_attribute = jiffies;
1623 } else
1624 invalid &= ~(NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA);
1625 } 981 }
1626 982
1627 /* Update attrtimeo value if we're out of the unstable period */ 983 /* Update attrtimeo value if we're out of the unstable period */
@@ -1664,207 +1020,20 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
1664 out_fileid: 1020 out_fileid:
1665 printk(KERN_ERR "NFS: server %s error: fileid changed\n" 1021 printk(KERN_ERR "NFS: server %s error: fileid changed\n"
1666 "fsid %s: expected fileid 0x%Lx, got 0x%Lx\n", 1022 "fsid %s: expected fileid 0x%Lx, got 0x%Lx\n",
1667 NFS_SERVER(inode)->hostname, inode->i_sb->s_id, 1023 NFS_SERVER(inode)->nfs_client->cl_hostname, inode->i_sb->s_id,
1668 (long long)nfsi->fileid, (long long)fattr->fileid); 1024 (long long)nfsi->fileid, (long long)fattr->fileid);
1669 goto out_err; 1025 goto out_err;
1670} 1026}
1671 1027
1672/*
1673 * File system information
1674 */
1675
1676static 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
1682static 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
1694static 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
1801out_rpciod_down:
1802 rpciod_down();
1803 kfree(server);
1804 return simple_set_mnt(mnt, s);
1805
1806out_err_rpciod:
1807 rpciod_down();
1808out_err:
1809 kfree(server);
1810out_err_noserver:
1811 return error;
1812}
1813
1814static 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
1837static 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 1028
1845#ifdef CONFIG_NFS_V4 1029#ifdef CONFIG_NFS_V4
1846 1030
1847static void nfs4_clear_inode(struct inode *);
1848
1849
1850static 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/* 1031/*
1863 * Clean out any remaining NFSv4 state that might be left over due 1032 * 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 1033 * to open() calls that passed nfs_atomic_lookup, but failed to call
1865 * nfs_open(). 1034 * nfs_open().
1866 */ 1035 */
1867static void nfs4_clear_inode(struct inode *inode) 1036void nfs4_clear_inode(struct inode *inode)
1868{ 1037{
1869 struct nfs_inode *nfsi = NFS_I(inode); 1038 struct nfs_inode *nfsi = NFS_I(inode);
1870 1039
@@ -1888,365 +1057,9 @@ static void nfs4_clear_inode(struct inode *inode)
1888 nfs4_close_state(state, state->state); 1057 nfs4_close_state(state, state->state);
1889 } 1058 }
1890} 1059}
1891
1892
1893static 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;
2008out_fail:
2009 if (clp)
2010 nfs4_put_client(clp);
2011 return err;
2012}
2013
2014static 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
2026static void *
2027nfs_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
2048static 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);
2136out_err:
2137 error = PTR_ERR(p);
2138out_free:
2139 kfree(server->mnt_path);
2140 kfree(server->hostname);
2141 kfree(server);
2142 return error;
2143}
2144
2145static 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
2166static 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
2174static const int nfs_set_port_min = 0;
2175static const int nfs_set_port_max = 65535;
2176static 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
2186module_param_call(callback_tcpport, param_set_port, param_get_int,
2187 &nfs_callback_set_tcpport, 0644);
2188
2189static 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
2200module_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
2211static 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
2224static 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
2235
2236extern int nfs_init_nfspagecache(void);
2237extern void nfs_destroy_nfspagecache(void);
2238extern int nfs_init_readpagecache(void);
2239extern void nfs_destroy_readpagecache(void);
2240extern int nfs_init_writepagecache(void);
2241extern void nfs_destroy_writepagecache(void);
2242#ifdef CONFIG_NFS_DIRECTIO
2243extern int nfs_init_directcache(void);
2244extern void nfs_destroy_directcache(void);
2245#endif 1060#endif
2246 1061
2247static kmem_cache_t * nfs_inode_cachep; 1062struct inode *nfs_alloc_inode(struct super_block *sb)
2248
2249static struct inode *nfs_alloc_inode(struct super_block *sb)
2250{ 1063{
2251 struct nfs_inode *nfsi; 1064 struct nfs_inode *nfsi;
2252 nfsi = (struct nfs_inode *)kmem_cache_alloc(nfs_inode_cachep, SLAB_KERNEL); 1065 nfsi = (struct nfs_inode *)kmem_cache_alloc(nfs_inode_cachep, SLAB_KERNEL);
@@ -2265,11 +1078,21 @@ static struct inode *nfs_alloc_inode(struct super_block *sb)
2265 return &nfsi->vfs_inode; 1078 return &nfsi->vfs_inode;
2266} 1079}
2267 1080
2268static void nfs_destroy_inode(struct inode *inode) 1081void nfs_destroy_inode(struct inode *inode)
2269{ 1082{
2270 kmem_cache_free(nfs_inode_cachep, NFS_I(inode)); 1083 kmem_cache_free(nfs_inode_cachep, NFS_I(inode));
2271} 1084}
2272 1085
1086static inline void nfs4_init_once(struct nfs_inode *nfsi)
1087{
1088#ifdef CONFIG_NFS_V4
1089 INIT_LIST_HEAD(&nfsi->open_states);
1090 nfsi->delegation = NULL;
1091 nfsi->delegation_state = 0;
1092 init_rwsem(&nfsi->rwsem);
1093#endif
1094}
1095
2273static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags) 1096static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
2274{ 1097{
2275 struct nfs_inode *nfsi = (struct nfs_inode *) foo; 1098 struct nfs_inode *nfsi = (struct nfs_inode *) foo;
@@ -2281,6 +1104,8 @@ static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
2281 INIT_LIST_HEAD(&nfsi->dirty); 1104 INIT_LIST_HEAD(&nfsi->dirty);
2282 INIT_LIST_HEAD(&nfsi->commit); 1105 INIT_LIST_HEAD(&nfsi->commit);
2283 INIT_LIST_HEAD(&nfsi->open_files); 1106 INIT_LIST_HEAD(&nfsi->open_files);
1107 INIT_LIST_HEAD(&nfsi->access_cache_entry_lru);
1108 INIT_LIST_HEAD(&nfsi->access_cache_inode_lru);
2284 INIT_RADIX_TREE(&nfsi->nfs_page_tree, GFP_ATOMIC); 1109 INIT_RADIX_TREE(&nfsi->nfs_page_tree, GFP_ATOMIC);
2285 atomic_set(&nfsi->data_updates, 0); 1110 atomic_set(&nfsi->data_updates, 0);
2286 nfsi->ndirty = 0; 1111 nfsi->ndirty = 0;
@@ -2290,7 +1115,7 @@ static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
2290 } 1115 }
2291} 1116}
2292 1117
2293static int nfs_init_inodecache(void) 1118static int __init nfs_init_inodecache(void)
2294{ 1119{
2295 nfs_inode_cachep = kmem_cache_create("nfs_inode_cache", 1120 nfs_inode_cachep = kmem_cache_create("nfs_inode_cache",
2296 sizeof(struct nfs_inode), 1121 sizeof(struct nfs_inode),
@@ -2305,8 +1130,7 @@ static int nfs_init_inodecache(void)
2305 1130
2306static void nfs_destroy_inodecache(void) 1131static void nfs_destroy_inodecache(void)
2307{ 1132{
2308 if (kmem_cache_destroy(nfs_inode_cachep)) 1133 kmem_cache_destroy(nfs_inode_cachep);
2309 printk(KERN_INFO "nfs_inode_cache: not all structures were freed\n");
2310} 1134}
2311 1135
2312/* 1136/*
@@ -2316,6 +1140,10 @@ static int __init init_nfs_fs(void)
2316{ 1140{
2317 int err; 1141 int err;
2318 1142
1143 err = nfs_fs_proc_init();
1144 if (err)
1145 goto out5;
1146
2319 err = nfs_init_nfspagecache(); 1147 err = nfs_init_nfspagecache();
2320 if (err) 1148 if (err)
2321 goto out4; 1149 goto out4;
@@ -2332,29 +1160,22 @@ static int __init init_nfs_fs(void)
2332 if (err) 1160 if (err)
2333 goto out1; 1161 goto out1;
2334 1162
2335#ifdef CONFIG_NFS_DIRECTIO
2336 err = nfs_init_directcache(); 1163 err = nfs_init_directcache();
2337 if (err) 1164 if (err)
2338 goto out0; 1165 goto out0;
2339#endif
2340 1166
2341#ifdef CONFIG_PROC_FS 1167#ifdef CONFIG_PROC_FS
2342 rpc_proc_register(&nfs_rpcstat); 1168 rpc_proc_register(&nfs_rpcstat);
2343#endif 1169#endif
2344 err = register_filesystem(&nfs_fs_type); 1170 if ((err = register_nfs_fs()) != 0)
2345 if (err)
2346 goto out;
2347 if ((err = register_nfs4fs()) != 0)
2348 goto out; 1171 goto out;
2349 return 0; 1172 return 0;
2350out: 1173out:
2351#ifdef CONFIG_PROC_FS 1174#ifdef CONFIG_PROC_FS
2352 rpc_proc_unregister("nfs"); 1175 rpc_proc_unregister("nfs");
2353#endif 1176#endif
2354#ifdef CONFIG_NFS_DIRECTIO
2355 nfs_destroy_directcache(); 1177 nfs_destroy_directcache();
2356out0: 1178out0:
2357#endif
2358 nfs_destroy_writepagecache(); 1179 nfs_destroy_writepagecache();
2359out1: 1180out1:
2360 nfs_destroy_readpagecache(); 1181 nfs_destroy_readpagecache();
@@ -2363,14 +1184,14 @@ out2:
2363out3: 1184out3:
2364 nfs_destroy_nfspagecache(); 1185 nfs_destroy_nfspagecache();
2365out4: 1186out4:
1187 nfs_fs_proc_exit();
1188out5:
2366 return err; 1189 return err;
2367} 1190}
2368 1191
2369static void __exit exit_nfs_fs(void) 1192static void __exit exit_nfs_fs(void)
2370{ 1193{
2371#ifdef CONFIG_NFS_DIRECTIO
2372 nfs_destroy_directcache(); 1194 nfs_destroy_directcache();
2373#endif
2374 nfs_destroy_writepagecache(); 1195 nfs_destroy_writepagecache();
2375 nfs_destroy_readpagecache(); 1196 nfs_destroy_readpagecache();
2376 nfs_destroy_inodecache(); 1197 nfs_destroy_inodecache();
@@ -2378,8 +1199,8 @@ static void __exit exit_nfs_fs(void)
2378#ifdef CONFIG_PROC_FS 1199#ifdef CONFIG_PROC_FS
2379 rpc_proc_unregister("nfs"); 1200 rpc_proc_unregister("nfs");
2380#endif 1201#endif
2381 unregister_filesystem(&nfs_fs_type); 1202 unregister_nfs_fs();
2382 unregister_nfs4fs(); 1203 nfs_fs_proc_exit();
2383} 1204}
2384 1205
2385/* Not quite true; I just maintain it */ 1206/* Not quite true; I just maintain it */
generated by cgit v1.2.2 (git 2.25.0) at 2025-11-06 13:11:57 -0500