4 * Copyright (C) 1992 Rick Sladkey
6 * nfs inode and superblock handling functions
8 * Modularised by Alan Cox <Alan.Cox@linux.org>, while hacking some
9 * experimental NFS changes. Modularisation taken straight from SYS5 fs.
11 * Change to nfs_read_super() to permit NFS mounts to multi-homed hosts.
12 * J.S.Peatfield@damtp.cam.ac.uk
16 #include <linux/config.h>
17 #include <linux/module.h>
18 #include <linux/init.h>
20 #include <linux/time.h>
21 #include <linux/kernel.h>
23 #include <linux/string.h>
24 #include <linux/stat.h>
25 #include <linux/errno.h>
26 #include <linux/unistd.h>
27 #include <linux/sunrpc/clnt.h>
28 #include <linux/sunrpc/stats.h>
29 #include <linux/nfs_fs.h>
30 #include <linux/nfs_mount.h>
31 #include <linux/nfs4_mount.h>
32 #include <linux/lockd/bind.h>
33 #include <linux/smp_lock.h>
34 #include <linux/seq_file.h>
35 #include <linux/mount.h>
36 #include <linux/nfs_idmap.h>
37 #include <linux/vfs.h>
39 #include <asm/system.h>
40 #include <asm/uaccess.h>
44 #include "delegation.h"
46 #define NFSDBG_FACILITY NFSDBG_VFS
47 #define NFS_PARANOIA 1
49 /* Maximum number of readahead requests
50 * FIXME: this should really be a sysctl so that users may tune it to suit
51 * their needs. People that do NFS over a slow network, might for
52 * instance want to reduce it to something closer to 1 for improved
53 * interactive response.
55 #define NFS_MAX_READAHEAD (RPC_DEF_SLOT_TABLE - 1)
57 static void nfs_invalidate_inode(struct inode
*);
58 static int nfs_update_inode(struct inode
*, struct nfs_fattr
*);
60 static struct inode
*nfs_alloc_inode(struct super_block
*sb
);
61 static void nfs_destroy_inode(struct inode
*);
62 static int nfs_write_inode(struct inode
*,int);
63 static void nfs_delete_inode(struct inode
*);
64 static void nfs_clear_inode(struct inode
*);
65 static void nfs_umount_begin(struct super_block
*);
66 static int nfs_statfs(struct super_block
*, struct kstatfs
*);
67 static int nfs_show_options(struct seq_file
*, struct vfsmount
*);
68 static void nfs_zap_acl_cache(struct inode
*);
70 static struct rpc_program nfs_program
;
72 static struct super_operations nfs_sops
= {
73 .alloc_inode
= nfs_alloc_inode
,
74 .destroy_inode
= nfs_destroy_inode
,
75 .write_inode
= nfs_write_inode
,
76 .delete_inode
= nfs_delete_inode
,
78 .clear_inode
= nfs_clear_inode
,
79 .umount_begin
= nfs_umount_begin
,
80 .show_options
= nfs_show_options
,
86 static struct rpc_stat nfs_rpcstat
= {
87 .program
= &nfs_program
89 static struct rpc_version
* nfs_version
[] = {
93 #if defined(CONFIG_NFS_V3)
95 #elif defined(CONFIG_NFS_V4)
98 #if defined(CONFIG_NFS_V4)
103 static struct rpc_program nfs_program
= {
105 .number
= NFS_PROGRAM
,
106 .nrvers
= sizeof(nfs_version
) / sizeof(nfs_version
[0]),
107 .version
= nfs_version
,
108 .stats
= &nfs_rpcstat
,
109 .pipe_dir_name
= "/nfs",
112 #ifdef CONFIG_NFS_V3_ACL
113 static struct rpc_stat nfsacl_rpcstat
= { &nfsacl_program
};
114 static struct rpc_version
* nfsacl_version
[] = {
115 [3] = &nfsacl_version3
,
118 struct rpc_program nfsacl_program
= {
120 .number
= NFS_ACL_PROGRAM
,
121 .nrvers
= sizeof(nfsacl_version
) / sizeof(nfsacl_version
[0]),
122 .version
= nfsacl_version
,
123 .stats
= &nfsacl_rpcstat
,
125 #endif /* CONFIG_NFS_V3_ACL */
127 static inline unsigned long
128 nfs_fattr_to_ino_t(struct nfs_fattr
*fattr
)
130 return nfs_fileid_to_ino_t(fattr
->fileid
);
134 nfs_write_inode(struct inode
*inode
, int sync
)
136 int flags
= sync
? FLUSH_WAIT
: 0;
139 ret
= nfs_commit_inode(inode
, flags
);
146 nfs_delete_inode(struct inode
* inode
)
148 dprintk("NFS: delete_inode(%s/%ld)\n", inode
->i_sb
->s_id
, inode
->i_ino
);
150 truncate_inode_pages(&inode
->i_data
, 0);
154 * The following should never happen...
156 if (nfs_have_writebacks(inode
)) {
157 printk(KERN_ERR
"nfs_delete_inode: inode %ld has pending RPC requests\n", inode
->i_ino
);
164 nfs_clear_inode(struct inode
*inode
)
166 struct nfs_inode
*nfsi
= NFS_I(inode
);
167 struct rpc_cred
*cred
;
170 BUG_ON (!list_empty(&nfsi
->open_files
));
171 nfs_zap_acl_cache(inode
);
172 cred
= nfsi
->cache_access
.cred
;
175 BUG_ON(atomic_read(&nfsi
->data_updates
) != 0);
179 nfs_umount_begin(struct super_block
*sb
)
181 struct rpc_clnt
*rpc
= NFS_SB(sb
)->client
;
183 /* -EIO all pending I/O */
185 rpc_killall_tasks(rpc
);
186 rpc
= NFS_SB(sb
)->client_acl
;
188 rpc_killall_tasks(rpc
);
192 static inline unsigned long
193 nfs_block_bits(unsigned long bsize
, unsigned char *nrbitsp
)
195 /* make sure blocksize is a power of two */
196 if ((bsize
& (bsize
- 1)) || nrbitsp
) {
197 unsigned char nrbits
;
199 for (nrbits
= 31; nrbits
&& !(bsize
& (1 << nrbits
)); nrbits
--)
210 * Calculate the number of 512byte blocks used.
212 static inline unsigned long
213 nfs_calc_block_size(u64 tsize
)
215 loff_t used
= (tsize
+ 511) >> 9;
216 return (used
> ULONG_MAX
) ? ULONG_MAX
: used
;
220 * Compute and set NFS server blocksize
222 static inline unsigned long
223 nfs_block_size(unsigned long bsize
, unsigned char *nrbitsp
)
225 if (bsize
< NFS_MIN_FILE_IO_SIZE
)
226 bsize
= NFS_DEF_FILE_IO_SIZE
;
227 else if (bsize
>= NFS_MAX_FILE_IO_SIZE
)
228 bsize
= NFS_MAX_FILE_IO_SIZE
;
230 return nfs_block_bits(bsize
, nrbitsp
);
234 * Obtain the root inode of the file system.
236 static struct inode
*
237 nfs_get_root(struct super_block
*sb
, struct nfs_fh
*rootfh
, struct nfs_fsinfo
*fsinfo
)
239 struct nfs_server
*server
= NFS_SB(sb
);
243 error
= server
->rpc_ops
->getroot(server
, rootfh
, fsinfo
);
245 dprintk("nfs_get_root: getattr error = %d\n", -error
);
246 return ERR_PTR(error
);
249 rooti
= nfs_fhget(sb
, rootfh
, fsinfo
->fattr
);
251 return ERR_PTR(-ENOMEM
);
256 * Do NFS version-independent mount processing, and sanity checking
259 nfs_sb_init(struct super_block
*sb
, rpc_authflavor_t authflavor
)
261 struct nfs_server
*server
;
262 struct inode
*root_inode
;
263 struct nfs_fattr fattr
;
264 struct nfs_fsinfo fsinfo
= {
267 struct nfs_pathconf pathinfo
= {
270 int no_root_error
= 0;
271 unsigned long max_rpc_payload
;
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
));
278 sb
->s_magic
= NFS_SUPER_MAGIC
;
280 root_inode
= nfs_get_root(sb
, &server
->fh
, &fsinfo
);
281 /* Did getting the root inode fail? */
282 if (IS_ERR(root_inode
)) {
283 no_root_error
= PTR_ERR(root_inode
);
286 sb
->s_root
= d_alloc_root(root_inode
);
288 no_root_error
= -ENOMEM
;
291 sb
->s_root
->d_op
= server
->rpc_ops
->dentry_ops
;
293 /* Get some general file system info */
294 if (server
->namelen
== 0 &&
295 server
->rpc_ops
->pathconf(server
, &server
->fh
, &pathinfo
) >= 0)
296 server
->namelen
= pathinfo
.max_namelen
;
297 /* Work out a lot of parameters */
298 if (server
->rsize
== 0)
299 server
->rsize
= nfs_block_size(fsinfo
.rtpref
, NULL
);
300 if (server
->wsize
== 0)
301 server
->wsize
= nfs_block_size(fsinfo
.wtpref
, NULL
);
303 if (fsinfo
.rtmax
>= 512 && server
->rsize
> fsinfo
.rtmax
)
304 server
->rsize
= nfs_block_size(fsinfo
.rtmax
, NULL
);
305 if (fsinfo
.wtmax
>= 512 && server
->wsize
> fsinfo
.wtmax
)
306 server
->wsize
= nfs_block_size(fsinfo
.wtmax
, NULL
);
308 max_rpc_payload
= nfs_block_size(rpc_max_payload(server
->client
), NULL
);
309 if (server
->rsize
> max_rpc_payload
)
310 server
->rsize
= max_rpc_payload
;
311 if (server
->rsize
> NFS_MAX_FILE_IO_SIZE
)
312 server
->rsize
= NFS_MAX_FILE_IO_SIZE
;
313 server
->rpages
= (server
->rsize
+ PAGE_CACHE_SIZE
- 1) >> PAGE_CACHE_SHIFT
;
315 if (server
->wsize
> max_rpc_payload
)
316 server
->wsize
= max_rpc_payload
;
317 if (server
->wsize
> NFS_MAX_FILE_IO_SIZE
)
318 server
->wsize
= NFS_MAX_FILE_IO_SIZE
;
319 server
->wpages
= (server
->wsize
+ PAGE_CACHE_SIZE
- 1) >> PAGE_CACHE_SHIFT
;
321 if (sb
->s_blocksize
== 0)
322 sb
->s_blocksize
= nfs_block_bits(server
->wsize
,
323 &sb
->s_blocksize_bits
);
324 server
->wtmult
= nfs_block_bits(fsinfo
.wtmult
, NULL
);
326 server
->dtsize
= nfs_block_size(fsinfo
.dtpref
, NULL
);
327 if (server
->dtsize
> PAGE_CACHE_SIZE
)
328 server
->dtsize
= PAGE_CACHE_SIZE
;
329 if (server
->dtsize
> server
->rsize
)
330 server
->dtsize
= server
->rsize
;
332 if (server
->flags
& NFS_MOUNT_NOAC
) {
333 server
->acregmin
= server
->acregmax
= 0;
334 server
->acdirmin
= server
->acdirmax
= 0;
335 sb
->s_flags
|= MS_SYNCHRONOUS
;
337 server
->backing_dev_info
.ra_pages
= server
->rpages
* NFS_MAX_READAHEAD
;
339 sb
->s_maxbytes
= fsinfo
.maxfilesize
;
340 if (sb
->s_maxbytes
> MAX_LFS_FILESIZE
)
341 sb
->s_maxbytes
= MAX_LFS_FILESIZE
;
343 server
->client
->cl_intr
= (server
->flags
& NFS_MOUNT_INTR
) ? 1 : 0;
344 server
->client
->cl_softrtry
= (server
->flags
& NFS_MOUNT_SOFT
) ? 1 : 0;
346 /* We're airborne Set socket buffersize */
347 rpc_setbufsize(server
->client
, server
->wsize
+ 100, server
->rsize
+ 100);
349 /* Yargs. It didn't work out. */
351 dprintk("nfs_sb_init: get root inode failed: errno %d\n", -no_root_error
);
352 if (!IS_ERR(root_inode
))
354 return no_root_error
;
357 static void nfs_init_timeout_values(struct rpc_timeout
*to
, int proto
, unsigned int timeo
, unsigned int retrans
)
359 to
->to_initval
= timeo
* HZ
/ 10;
360 to
->to_retries
= retrans
;
367 to
->to_initval
= 60 * HZ
;
368 if (to
->to_initval
> NFS_MAX_TCP_TIMEOUT
)
369 to
->to_initval
= NFS_MAX_TCP_TIMEOUT
;
370 to
->to_increment
= to
->to_initval
;
371 to
->to_maxval
= to
->to_initval
+ (to
->to_increment
* to
->to_retries
);
372 to
->to_exponential
= 0;
377 to
->to_initval
= 11 * HZ
/ 10;
378 if (to
->to_initval
> NFS_MAX_UDP_TIMEOUT
)
379 to
->to_initval
= NFS_MAX_UDP_TIMEOUT
;
380 to
->to_maxval
= NFS_MAX_UDP_TIMEOUT
;
381 to
->to_exponential
= 1;
387 * Create an RPC client handle.
389 static struct rpc_clnt
*
390 nfs_create_client(struct nfs_server
*server
, const struct nfs_mount_data
*data
)
392 struct rpc_timeout timeparms
;
393 struct rpc_xprt
*xprt
= NULL
;
394 struct rpc_clnt
*clnt
= NULL
;
395 int proto
= (data
->flags
& NFS_MOUNT_TCP
) ? IPPROTO_TCP
: IPPROTO_UDP
;
397 nfs_init_timeout_values(&timeparms
, proto
, data
->timeo
, data
->retrans
);
399 /* create transport and client */
400 xprt
= xprt_create_proto(proto
, &server
->addr
, &timeparms
);
402 dprintk("%s: cannot create RPC transport. Error = %ld\n",
403 __FUNCTION__
, PTR_ERR(xprt
));
404 return (struct rpc_clnt
*)xprt
;
406 clnt
= rpc_create_client(xprt
, server
->hostname
, &nfs_program
,
407 server
->rpc_ops
->version
, data
->pseudoflavor
);
409 dprintk("%s: cannot create RPC client. Error = %ld\n",
410 __FUNCTION__
, PTR_ERR(xprt
));
415 clnt
->cl_softrtry
= 1;
424 * The way this works is that the mount process passes a structure
425 * in the data argument which contains the server's IP address
426 * and the root file handle obtained from the server's mount
427 * daemon. We stash these away in the private superblock fields.
430 nfs_fill_super(struct super_block
*sb
, struct nfs_mount_data
*data
, int silent
)
432 struct nfs_server
*server
;
433 rpc_authflavor_t authflavor
;
436 sb
->s_blocksize_bits
= 0;
439 sb
->s_blocksize
= nfs_block_size(data
->bsize
, &sb
->s_blocksize_bits
);
441 server
->rsize
= nfs_block_size(data
->rsize
, NULL
);
443 server
->wsize
= nfs_block_size(data
->wsize
, NULL
);
444 server
->flags
= data
->flags
& NFS_MOUNT_FLAGMASK
;
446 server
->acregmin
= data
->acregmin
*HZ
;
447 server
->acregmax
= data
->acregmax
*HZ
;
448 server
->acdirmin
= data
->acdirmin
*HZ
;
449 server
->acdirmax
= data
->acdirmax
*HZ
;
451 /* Start lockd here, before we might error out */
452 if (!(server
->flags
& NFS_MOUNT_NONLM
))
455 server
->namelen
= data
->namlen
;
456 server
->hostname
= kmalloc(strlen(data
->hostname
) + 1, GFP_KERNEL
);
457 if (!server
->hostname
)
459 strcpy(server
->hostname
, data
->hostname
);
461 /* Check NFS protocol revision and initialize RPC op vector
462 * and file handle pool. */
464 if (server
->flags
& NFS_MOUNT_VER3
) {
465 server
->rpc_ops
= &nfs_v3_clientops
;
466 server
->caps
|= NFS_CAP_READDIRPLUS
;
468 server
->rpc_ops
= &nfs_v2_clientops
;
471 server
->rpc_ops
= &nfs_v2_clientops
;
474 /* Fill in pseudoflavor for mount version < 5 */
475 if (!(data
->flags
& NFS_MOUNT_SECFLAVOUR
))
476 data
->pseudoflavor
= RPC_AUTH_UNIX
;
477 authflavor
= data
->pseudoflavor
; /* save for sb_init() */
478 /* XXX maybe we want to add a server->pseudoflavor field */
480 /* Create RPC client handles */
481 server
->client
= nfs_create_client(server
, data
);
482 if (IS_ERR(server
->client
))
483 return PTR_ERR(server
->client
);
484 /* RFC 2623, sec 2.3.2 */
485 if (authflavor
!= RPC_AUTH_UNIX
) {
486 struct rpc_auth
*auth
;
488 server
->client_sys
= rpc_clone_client(server
->client
);
489 if (IS_ERR(server
->client_sys
))
490 return PTR_ERR(server
->client_sys
);
491 auth
= rpcauth_create(RPC_AUTH_UNIX
, server
->client_sys
);
493 return PTR_ERR(auth
);
495 atomic_inc(&server
->client
->cl_count
);
496 server
->client_sys
= server
->client
;
498 if (server
->flags
& NFS_MOUNT_VER3
) {
499 #ifdef CONFIG_NFS_V3_ACL
500 if (!(server
->flags
& NFS_MOUNT_NOACL
)) {
501 server
->client_acl
= rpc_bind_new_program(server
->client
, &nfsacl_program
, 3);
502 /* No errors! Assume that Sun nfsacls are supported */
503 if (!IS_ERR(server
->client_acl
))
504 server
->caps
|= NFS_CAP_ACLS
;
507 server
->flags
&= ~NFS_MOUNT_NOACL
;
508 #endif /* CONFIG_NFS_V3_ACL */
510 * The VFS shouldn't apply the umask to mode bits. We will
511 * do so ourselves when necessary.
513 sb
->s_flags
|= MS_POSIXACL
;
514 if (server
->namelen
== 0 || server
->namelen
> NFS3_MAXNAMLEN
)
515 server
->namelen
= NFS3_MAXNAMLEN
;
518 if (server
->namelen
== 0 || server
->namelen
> NFS2_MAXNAMLEN
)
519 server
->namelen
= NFS2_MAXNAMLEN
;
522 sb
->s_op
= &nfs_sops
;
523 return nfs_sb_init(sb
, authflavor
);
527 nfs_statfs(struct super_block
*sb
, struct kstatfs
*buf
)
529 struct nfs_server
*server
= NFS_SB(sb
);
530 unsigned char blockbits
;
531 unsigned long blockres
;
532 struct nfs_fh
*rootfh
= NFS_FH(sb
->s_root
->d_inode
);
533 struct nfs_fattr fattr
;
534 struct nfs_fsstat res
= {
541 error
= server
->rpc_ops
->statfs(server
, rootfh
, &res
);
542 buf
->f_type
= NFS_SUPER_MAGIC
;
547 * Current versions of glibc do not correctly handle the
548 * case where f_frsize != f_bsize. Eventually we want to
549 * report the value of wtmult in this field.
551 buf
->f_frsize
= sb
->s_blocksize
;
554 * On most *nix systems, f_blocks, f_bfree, and f_bavail
555 * are reported in units of f_frsize. Linux hasn't had
556 * an f_frsize field in its statfs struct until recently,
557 * thus historically Linux's sys_statfs reports these
558 * fields in units of f_bsize.
560 buf
->f_bsize
= sb
->s_blocksize
;
561 blockbits
= sb
->s_blocksize_bits
;
562 blockres
= (1 << blockbits
) - 1;
563 buf
->f_blocks
= (res
.tbytes
+ blockres
) >> blockbits
;
564 buf
->f_bfree
= (res
.fbytes
+ blockres
) >> blockbits
;
565 buf
->f_bavail
= (res
.abytes
+ blockres
) >> blockbits
;
567 buf
->f_files
= res
.tfiles
;
568 buf
->f_ffree
= res
.afiles
;
570 buf
->f_namelen
= server
->namelen
;
576 dprintk("%s: statfs error = %d\n", __FUNCTION__
, -error
);
577 buf
->f_bsize
= buf
->f_blocks
= buf
->f_bfree
= buf
->f_bavail
= -1;
582 static int nfs_show_options(struct seq_file
*m
, struct vfsmount
*mnt
)
584 static struct proc_nfs_info
{
589 { NFS_MOUNT_SOFT
, ",soft", ",hard" },
590 { NFS_MOUNT_INTR
, ",intr", "" },
591 { NFS_MOUNT_POSIX
, ",posix", "" },
592 { NFS_MOUNT_NOCTO
, ",nocto", "" },
593 { NFS_MOUNT_NOAC
, ",noac", "" },
594 { NFS_MOUNT_NONLM
, ",nolock", ",lock" },
595 { NFS_MOUNT_NOACL
, ",noacl", "" },
598 struct proc_nfs_info
*nfs_infop
;
599 struct nfs_server
*nfss
= NFS_SB(mnt
->mnt_sb
);
603 seq_printf(m
, ",v%d", nfss
->rpc_ops
->version
);
604 seq_printf(m
, ",rsize=%d", nfss
->rsize
);
605 seq_printf(m
, ",wsize=%d", nfss
->wsize
);
606 if (nfss
->acregmin
!= 3*HZ
)
607 seq_printf(m
, ",acregmin=%d", nfss
->acregmin
/HZ
);
608 if (nfss
->acregmax
!= 60*HZ
)
609 seq_printf(m
, ",acregmax=%d", nfss
->acregmax
/HZ
);
610 if (nfss
->acdirmin
!= 30*HZ
)
611 seq_printf(m
, ",acdirmin=%d", nfss
->acdirmin
/HZ
);
612 if (nfss
->acdirmax
!= 60*HZ
)
613 seq_printf(m
, ",acdirmax=%d", nfss
->acdirmax
/HZ
);
614 for (nfs_infop
= nfs_info
; nfs_infop
->flag
; nfs_infop
++) {
615 if (nfss
->flags
& nfs_infop
->flag
)
616 seq_puts(m
, nfs_infop
->str
);
618 seq_puts(m
, nfs_infop
->nostr
);
620 switch (nfss
->client
->cl_xprt
->prot
) {
628 snprintf(buf
, sizeof(buf
), "%u", nfss
->client
->cl_xprt
->prot
);
631 seq_printf(m
, ",proto=%s", proto
);
632 seq_puts(m
, ",addr=");
633 seq_escape(m
, nfss
->hostname
, " \t\n\\");
638 * nfs_sync_mapping - helper to flush all mmapped dirty data to disk
640 int nfs_sync_mapping(struct address_space
*mapping
)
644 if (mapping
->nrpages
== 0)
646 unmap_mapping_range(mapping
, 0, 0, 0);
647 ret
= filemap_fdatawrite(mapping
);
650 ret
= filemap_fdatawait(mapping
);
653 ret
= nfs_wb_all(mapping
->host
);
659 * Invalidate the local caches
661 static void nfs_zap_caches_locked(struct inode
*inode
)
663 struct nfs_inode
*nfsi
= NFS_I(inode
);
664 int mode
= inode
->i_mode
;
666 NFS_ATTRTIMEO(inode
) = NFS_MINATTRTIMEO(inode
);
667 NFS_ATTRTIMEO_UPDATE(inode
) = jiffies
;
669 memset(NFS_COOKIEVERF(inode
), 0, sizeof(NFS_COOKIEVERF(inode
)));
670 if (S_ISREG(mode
) || S_ISDIR(mode
) || S_ISLNK(mode
))
671 nfsi
->cache_validity
|= NFS_INO_INVALID_ATTR
|NFS_INO_INVALID_DATA
|NFS_INO_INVALID_ACCESS
|NFS_INO_INVALID_ACL
|NFS_INO_REVAL_PAGECACHE
;
673 nfsi
->cache_validity
|= NFS_INO_INVALID_ATTR
|NFS_INO_INVALID_ACCESS
|NFS_INO_INVALID_ACL
|NFS_INO_REVAL_PAGECACHE
;
676 void nfs_zap_caches(struct inode
*inode
)
678 spin_lock(&inode
->i_lock
);
679 nfs_zap_caches_locked(inode
);
680 spin_unlock(&inode
->i_lock
);
683 static void nfs_zap_acl_cache(struct inode
*inode
)
685 void (*clear_acl_cache
)(struct inode
*);
687 clear_acl_cache
= NFS_PROTO(inode
)->clear_acl_cache
;
688 if (clear_acl_cache
!= NULL
)
689 clear_acl_cache(inode
);
690 spin_lock(&inode
->i_lock
);
691 NFS_I(inode
)->cache_validity
&= ~NFS_INO_INVALID_ACL
;
692 spin_unlock(&inode
->i_lock
);
696 * Invalidate, but do not unhash, the inode.
697 * NB: must be called with inode->i_lock held!
699 static void nfs_invalidate_inode(struct inode
*inode
)
701 set_bit(NFS_INO_STALE
, &NFS_FLAGS(inode
));
702 nfs_zap_caches_locked(inode
);
705 struct nfs_find_desc
{
707 struct nfs_fattr
*fattr
;
711 * In NFSv3 we can have 64bit inode numbers. In order to support
712 * this, and re-exported directories (also seen in NFSv2)
713 * we are forced to allow 2 different inodes to have the same
717 nfs_find_actor(struct inode
*inode
, void *opaque
)
719 struct nfs_find_desc
*desc
= (struct nfs_find_desc
*)opaque
;
720 struct nfs_fh
*fh
= desc
->fh
;
721 struct nfs_fattr
*fattr
= desc
->fattr
;
723 if (NFS_FILEID(inode
) != fattr
->fileid
)
725 if (nfs_compare_fh(NFS_FH(inode
), fh
))
727 if (is_bad_inode(inode
) || NFS_STALE(inode
))
733 nfs_init_locked(struct inode
*inode
, void *opaque
)
735 struct nfs_find_desc
*desc
= (struct nfs_find_desc
*)opaque
;
736 struct nfs_fattr
*fattr
= desc
->fattr
;
738 NFS_FILEID(inode
) = fattr
->fileid
;
739 nfs_copy_fh(NFS_FH(inode
), desc
->fh
);
743 /* Don't use READDIRPLUS on directories that we believe are too large */
744 #define NFS_LIMIT_READDIRPLUS (8*PAGE_SIZE)
747 * This is our front-end to iget that looks up inodes by file handle
748 * instead of inode number.
751 nfs_fhget(struct super_block
*sb
, struct nfs_fh
*fh
, struct nfs_fattr
*fattr
)
753 struct nfs_find_desc desc
= {
757 struct inode
*inode
= NULL
;
760 if ((fattr
->valid
& NFS_ATTR_FATTR
) == 0)
764 printk("NFS: Buggy server - nlink == 0!\n");
768 hash
= nfs_fattr_to_ino_t(fattr
);
770 if (!(inode
= iget5_locked(sb
, hash
, nfs_find_actor
, nfs_init_locked
, &desc
)))
773 if (inode
->i_state
& I_NEW
) {
774 struct nfs_inode
*nfsi
= NFS_I(inode
);
776 /* We set i_ino for the few things that still rely on it,
780 /* We can't support update_atime(), since the server will reset it */
781 inode
->i_flags
|= S_NOATIME
|S_NOCMTIME
;
782 inode
->i_mode
= fattr
->mode
;
783 /* Why so? Because we want revalidate for devices/FIFOs, and
784 * that's precisely what we have in nfs_file_inode_operations.
786 inode
->i_op
= NFS_SB(sb
)->rpc_ops
->file_inode_ops
;
787 if (S_ISREG(inode
->i_mode
)) {
788 inode
->i_fop
= &nfs_file_operations
;
789 inode
->i_data
.a_ops
= &nfs_file_aops
;
790 inode
->i_data
.backing_dev_info
= &NFS_SB(sb
)->backing_dev_info
;
791 } else if (S_ISDIR(inode
->i_mode
)) {
792 inode
->i_op
= NFS_SB(sb
)->rpc_ops
->dir_inode_ops
;
793 inode
->i_fop
= &nfs_dir_operations
;
794 if (nfs_server_capable(inode
, NFS_CAP_READDIRPLUS
)
795 && fattr
->size
<= NFS_LIMIT_READDIRPLUS
)
796 set_bit(NFS_INO_ADVISE_RDPLUS
, &NFS_FLAGS(inode
));
797 } else if (S_ISLNK(inode
->i_mode
))
798 inode
->i_op
= &nfs_symlink_inode_operations
;
800 init_special_inode(inode
, inode
->i_mode
, fattr
->rdev
);
802 nfsi
->read_cache_jiffies
= fattr
->time_start
;
803 nfsi
->last_updated
= jiffies
;
804 inode
->i_atime
= fattr
->atime
;
805 inode
->i_mtime
= fattr
->mtime
;
806 inode
->i_ctime
= fattr
->ctime
;
807 if (fattr
->valid
& NFS_ATTR_FATTR_V4
)
808 nfsi
->change_attr
= fattr
->change_attr
;
809 inode
->i_size
= nfs_size_to_loff_t(fattr
->size
);
810 inode
->i_nlink
= fattr
->nlink
;
811 inode
->i_uid
= fattr
->uid
;
812 inode
->i_gid
= fattr
->gid
;
813 if (fattr
->valid
& (NFS_ATTR_FATTR_V3
| NFS_ATTR_FATTR_V4
)) {
815 * report the blocks in 512byte units
817 inode
->i_blocks
= nfs_calc_block_size(fattr
->du
.nfs3
.used
);
818 inode
->i_blksize
= inode
->i_sb
->s_blocksize
;
820 inode
->i_blocks
= fattr
->du
.nfs2
.blocks
;
821 inode
->i_blksize
= fattr
->du
.nfs2
.blocksize
;
823 nfsi
->attrtimeo
= NFS_MINATTRTIMEO(inode
);
824 nfsi
->attrtimeo_timestamp
= jiffies
;
825 memset(nfsi
->cookieverf
, 0, sizeof(nfsi
->cookieverf
));
826 nfsi
->cache_access
.cred
= NULL
;
828 unlock_new_inode(inode
);
830 nfs_refresh_inode(inode
, fattr
);
831 dprintk("NFS: nfs_fhget(%s/%Ld ct=%d)\n",
833 (long long)NFS_FILEID(inode
),
834 atomic_read(&inode
->i_count
));
840 printk("nfs_fhget: iget failed\n");
844 #define NFS_VALID_ATTRS (ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_SIZE|ATTR_ATIME|ATTR_ATIME_SET|ATTR_MTIME|ATTR_MTIME_SET)
847 nfs_setattr(struct dentry
*dentry
, struct iattr
*attr
)
849 struct inode
*inode
= dentry
->d_inode
;
850 struct nfs_fattr fattr
;
853 if (attr
->ia_valid
& ATTR_SIZE
) {
854 if (!S_ISREG(inode
->i_mode
) || attr
->ia_size
== i_size_read(inode
))
855 attr
->ia_valid
&= ~ATTR_SIZE
;
858 /* Optimization: if the end result is no change, don't RPC */
859 attr
->ia_valid
&= NFS_VALID_ATTRS
;
860 if (attr
->ia_valid
== 0)
864 nfs_begin_data_update(inode
);
865 /* Write all dirty data if we're changing file permissions or size */
866 if ((attr
->ia_valid
& (ATTR_MODE
|ATTR_UID
|ATTR_GID
|ATTR_SIZE
)) != 0) {
867 if (filemap_fdatawrite(inode
->i_mapping
) == 0)
868 filemap_fdatawait(inode
->i_mapping
);
872 * Return any delegations if we're going to change ACLs
874 if ((attr
->ia_valid
& (ATTR_MODE
|ATTR_UID
|ATTR_GID
)) != 0)
875 nfs_inode_return_delegation(inode
);
876 error
= NFS_PROTO(inode
)->setattr(dentry
, &fattr
, attr
);
878 nfs_refresh_inode(inode
, &fattr
);
879 nfs_end_data_update(inode
);
885 * nfs_setattr_update_inode - Update inode metadata after a setattr call.
886 * @inode: pointer to struct inode
887 * @attr: pointer to struct iattr
889 * Note: we do this in the *proc.c in order to ensure that
890 * it works for things like exclusive creates too.
892 void nfs_setattr_update_inode(struct inode
*inode
, struct iattr
*attr
)
894 if ((attr
->ia_valid
& (ATTR_MODE
|ATTR_UID
|ATTR_GID
)) != 0) {
895 if ((attr
->ia_valid
& ATTR_MODE
) != 0) {
896 int mode
= attr
->ia_mode
& S_IALLUGO
;
897 mode
|= inode
->i_mode
& ~S_IALLUGO
;
898 inode
->i_mode
= mode
;
900 if ((attr
->ia_valid
& ATTR_UID
) != 0)
901 inode
->i_uid
= attr
->ia_uid
;
902 if ((attr
->ia_valid
& ATTR_GID
) != 0)
903 inode
->i_gid
= attr
->ia_gid
;
904 spin_lock(&inode
->i_lock
);
905 NFS_I(inode
)->cache_validity
|= NFS_INO_INVALID_ACCESS
|NFS_INO_INVALID_ACL
;
906 spin_unlock(&inode
->i_lock
);
908 if ((attr
->ia_valid
& ATTR_SIZE
) != 0) {
909 inode
->i_size
= attr
->ia_size
;
910 vmtruncate(inode
, attr
->ia_size
);
914 static int nfs_wait_schedule(void *word
)
916 if (signal_pending(current
))
923 * Wait for the inode to get unlocked.
925 static int nfs_wait_on_inode(struct inode
*inode
)
927 struct rpc_clnt
*clnt
= NFS_CLIENT(inode
);
928 struct nfs_inode
*nfsi
= NFS_I(inode
);
932 rpc_clnt_sigmask(clnt
, &oldmask
);
933 error
= wait_on_bit_lock(&nfsi
->flags
, NFS_INO_REVALIDATING
,
934 nfs_wait_schedule
, TASK_INTERRUPTIBLE
);
935 rpc_clnt_sigunmask(clnt
, &oldmask
);
940 static void nfs_wake_up_inode(struct inode
*inode
)
942 struct nfs_inode
*nfsi
= NFS_I(inode
);
944 clear_bit(NFS_INO_REVALIDATING
, &nfsi
->flags
);
945 smp_mb__after_clear_bit();
946 wake_up_bit(&nfsi
->flags
, NFS_INO_REVALIDATING
);
949 int nfs_getattr(struct vfsmount
*mnt
, struct dentry
*dentry
, struct kstat
*stat
)
951 struct inode
*inode
= dentry
->d_inode
;
952 int need_atime
= NFS_I(inode
)->cache_validity
& NFS_INO_INVALID_ATIME
;
955 /* Flush out writes to the server in order to update c/mtime */
956 nfs_sync_inode(inode
, 0, 0, FLUSH_WAIT
|FLUSH_NOCOMMIT
);
957 if (__IS_FLG(inode
, MS_NOATIME
))
959 else if (__IS_FLG(inode
, MS_NODIRATIME
) && S_ISDIR(inode
->i_mode
))
961 /* We may force a getattr if the user cares about atime */
963 err
= __nfs_revalidate_inode(NFS_SERVER(inode
), inode
);
965 err
= nfs_revalidate_inode(NFS_SERVER(inode
), inode
);
967 generic_fillattr(inode
, stat
);
971 struct nfs_open_context
*alloc_nfs_open_context(struct dentry
*dentry
, struct rpc_cred
*cred
)
973 struct nfs_open_context
*ctx
;
975 ctx
= (struct nfs_open_context
*)kmalloc(sizeof(*ctx
), GFP_KERNEL
);
977 atomic_set(&ctx
->count
, 1);
978 ctx
->dentry
= dget(dentry
);
979 ctx
->cred
= get_rpccred(cred
);
981 ctx
->lockowner
= current
->files
;
988 struct nfs_open_context
*get_nfs_open_context(struct nfs_open_context
*ctx
)
991 atomic_inc(&ctx
->count
);
995 void put_nfs_open_context(struct nfs_open_context
*ctx
)
997 if (atomic_dec_and_test(&ctx
->count
)) {
998 if (!list_empty(&ctx
->list
)) {
999 struct inode
*inode
= ctx
->dentry
->d_inode
;
1000 spin_lock(&inode
->i_lock
);
1001 list_del(&ctx
->list
);
1002 spin_unlock(&inode
->i_lock
);
1004 if (ctx
->state
!= NULL
)
1005 nfs4_close_state(ctx
->state
, ctx
->mode
);
1006 if (ctx
->cred
!= NULL
)
1007 put_rpccred(ctx
->cred
);
1014 * Ensure that mmap has a recent RPC credential for use when writing out
1017 void nfs_file_set_open_context(struct file
*filp
, struct nfs_open_context
*ctx
)
1019 struct inode
*inode
= filp
->f_dentry
->d_inode
;
1020 struct nfs_inode
*nfsi
= NFS_I(inode
);
1022 filp
->private_data
= get_nfs_open_context(ctx
);
1023 spin_lock(&inode
->i_lock
);
1024 list_add(&ctx
->list
, &nfsi
->open_files
);
1025 spin_unlock(&inode
->i_lock
);
1029 * Given an inode, search for an open context with the desired characteristics
1031 struct nfs_open_context
*nfs_find_open_context(struct inode
*inode
, struct rpc_cred
*cred
, int mode
)
1033 struct nfs_inode
*nfsi
= NFS_I(inode
);
1034 struct nfs_open_context
*pos
, *ctx
= NULL
;
1036 spin_lock(&inode
->i_lock
);
1037 list_for_each_entry(pos
, &nfsi
->open_files
, list
) {
1038 if (cred
!= NULL
&& pos
->cred
!= cred
)
1040 if ((pos
->mode
& mode
) == mode
) {
1041 ctx
= get_nfs_open_context(pos
);
1045 spin_unlock(&inode
->i_lock
);
1049 void nfs_file_clear_open_context(struct file
*filp
)
1051 struct inode
*inode
= filp
->f_dentry
->d_inode
;
1052 struct nfs_open_context
*ctx
= (struct nfs_open_context
*)filp
->private_data
;
1055 filp
->private_data
= NULL
;
1056 spin_lock(&inode
->i_lock
);
1057 list_move_tail(&ctx
->list
, &NFS_I(inode
)->open_files
);
1058 spin_unlock(&inode
->i_lock
);
1059 put_nfs_open_context(ctx
);
1064 * These allocate and release file read/write context information.
1066 int nfs_open(struct inode
*inode
, struct file
*filp
)
1068 struct nfs_open_context
*ctx
;
1069 struct rpc_cred
*cred
;
1071 cred
= rpcauth_lookupcred(NFS_CLIENT(inode
)->cl_auth
, 0);
1073 return PTR_ERR(cred
);
1074 ctx
= alloc_nfs_open_context(filp
->f_dentry
, cred
);
1078 ctx
->mode
= filp
->f_mode
;
1079 nfs_file_set_open_context(filp
, ctx
);
1080 put_nfs_open_context(ctx
);
1084 int nfs_release(struct inode
*inode
, struct file
*filp
)
1086 nfs_file_clear_open_context(filp
);
1091 * This function is called whenever some part of NFS notices that
1092 * the cached attributes have to be refreshed.
1095 __nfs_revalidate_inode(struct nfs_server
*server
, struct inode
*inode
)
1097 int status
= -ESTALE
;
1098 struct nfs_fattr fattr
;
1099 struct nfs_inode
*nfsi
= NFS_I(inode
);
1101 dfprintk(PAGECACHE
, "NFS: revalidating (%s/%Ld)\n",
1102 inode
->i_sb
->s_id
, (long long)NFS_FILEID(inode
));
1105 if (!inode
|| is_bad_inode(inode
))
1107 if (NFS_STALE(inode
))
1110 status
= nfs_wait_on_inode(inode
);
1113 if (NFS_STALE(inode
)) {
1115 /* Do we trust the cached ESTALE? */
1116 if (NFS_ATTRTIMEO(inode
) != 0) {
1117 if (nfsi
->cache_validity
& (NFS_INO_INVALID_ATTR
|NFS_INO_INVALID_DATA
|NFS_INO_INVALID_ATIME
)) {
1124 status
= NFS_PROTO(inode
)->getattr(server
, NFS_FH(inode
), &fattr
);
1126 dfprintk(PAGECACHE
, "nfs_revalidate_inode: (%s/%Ld) getattr failed, error=%d\n",
1128 (long long)NFS_FILEID(inode
), status
);
1129 if (status
== -ESTALE
) {
1130 nfs_zap_caches(inode
);
1131 if (!S_ISDIR(inode
->i_mode
))
1132 set_bit(NFS_INO_STALE
, &NFS_FLAGS(inode
));
1137 spin_lock(&inode
->i_lock
);
1138 status
= nfs_update_inode(inode
, &fattr
);
1140 spin_unlock(&inode
->i_lock
);
1141 dfprintk(PAGECACHE
, "nfs_revalidate_inode: (%s/%Ld) refresh failed, error=%d\n",
1143 (long long)NFS_FILEID(inode
), status
);
1146 spin_unlock(&inode
->i_lock
);
1148 nfs_revalidate_mapping(inode
, inode
->i_mapping
);
1150 if (nfsi
->cache_validity
& NFS_INO_INVALID_ACL
)
1151 nfs_zap_acl_cache(inode
);
1153 dfprintk(PAGECACHE
, "NFS: (%s/%Ld) revalidation complete\n",
1155 (long long)NFS_FILEID(inode
));
1158 nfs_wake_up_inode(inode
);
1165 int nfs_attribute_timeout(struct inode
*inode
)
1167 struct nfs_inode
*nfsi
= NFS_I(inode
);
1169 if (nfs_have_delegation(inode
, FMODE_READ
))
1171 return time_after(jiffies
, nfsi
->read_cache_jiffies
+nfsi
->attrtimeo
);
1175 * nfs_revalidate_inode - Revalidate the inode attributes
1176 * @server - pointer to nfs_server struct
1177 * @inode - pointer to inode struct
1179 * Updates inode attribute information by retrieving the data from the server.
1181 int nfs_revalidate_inode(struct nfs_server
*server
, struct inode
*inode
)
1183 if (!(NFS_I(inode
)->cache_validity
& (NFS_INO_INVALID_ATTR
|NFS_INO_INVALID_DATA
))
1184 && !nfs_attribute_timeout(inode
))
1185 return NFS_STALE(inode
) ? -ESTALE
: 0;
1186 return __nfs_revalidate_inode(server
, inode
);
1190 * nfs_revalidate_mapping - Revalidate the pagecache
1191 * @inode - pointer to host inode
1192 * @mapping - pointer to mapping
1194 void nfs_revalidate_mapping(struct inode
*inode
, struct address_space
*mapping
)
1196 struct nfs_inode
*nfsi
= NFS_I(inode
);
1198 if (nfsi
->cache_validity
& NFS_INO_INVALID_DATA
) {
1199 if (S_ISREG(inode
->i_mode
))
1200 nfs_sync_mapping(mapping
);
1201 invalidate_inode_pages2(mapping
);
1203 spin_lock(&inode
->i_lock
);
1204 nfsi
->cache_validity
&= ~NFS_INO_INVALID_DATA
;
1205 if (S_ISDIR(inode
->i_mode
)) {
1206 memset(nfsi
->cookieverf
, 0, sizeof(nfsi
->cookieverf
));
1207 /* This ensures we revalidate child dentries */
1208 nfsi
->cache_change_attribute
= jiffies
;
1210 spin_unlock(&inode
->i_lock
);
1212 dfprintk(PAGECACHE
, "NFS: (%s/%Ld) data cache invalidated\n",
1214 (long long)NFS_FILEID(inode
));
1219 * nfs_begin_data_update
1220 * @inode - pointer to inode
1221 * Declare that a set of operations will update file data on the server
1223 void nfs_begin_data_update(struct inode
*inode
)
1225 atomic_inc(&NFS_I(inode
)->data_updates
);
1229 * nfs_end_data_update
1230 * @inode - pointer to inode
1231 * Declare end of the operations that will update file data
1232 * This will mark the inode as immediately needing revalidation
1233 * of its attribute cache.
1235 void nfs_end_data_update(struct inode
*inode
)
1237 struct nfs_inode
*nfsi
= NFS_I(inode
);
1239 if (!nfs_have_delegation(inode
, FMODE_READ
)) {
1240 /* Directories and symlinks: invalidate page cache */
1241 if (S_ISDIR(inode
->i_mode
) || S_ISLNK(inode
->i_mode
)) {
1242 spin_lock(&inode
->i_lock
);
1243 nfsi
->cache_validity
|= NFS_INO_INVALID_DATA
;
1244 spin_unlock(&inode
->i_lock
);
1247 nfsi
->cache_change_attribute
= jiffies
;
1248 atomic_dec(&nfsi
->data_updates
);
1251 static void nfs_wcc_update_inode(struct inode
*inode
, struct nfs_fattr
*fattr
)
1253 struct nfs_inode
*nfsi
= NFS_I(inode
);
1255 if ((fattr
->valid
& NFS_ATTR_PRE_CHANGE
) != 0
1256 && nfsi
->change_attr
== fattr
->pre_change_attr
) {
1257 nfsi
->change_attr
= fattr
->change_attr
;
1258 nfsi
->cache_change_attribute
= jiffies
;
1261 /* If we have atomic WCC data, we may update some attributes */
1262 if ((fattr
->valid
& NFS_ATTR_WCC
) != 0) {
1263 if (timespec_equal(&inode
->i_ctime
, &fattr
->pre_ctime
)) {
1264 memcpy(&inode
->i_ctime
, &fattr
->ctime
, sizeof(inode
->i_ctime
));
1265 nfsi
->cache_change_attribute
= jiffies
;
1267 if (timespec_equal(&inode
->i_mtime
, &fattr
->pre_mtime
)) {
1268 memcpy(&inode
->i_mtime
, &fattr
->mtime
, sizeof(inode
->i_mtime
));
1269 nfsi
->cache_change_attribute
= jiffies
;
1271 if (inode
->i_size
== fattr
->pre_size
&& nfsi
->npages
== 0) {
1272 inode
->i_size
= fattr
->size
;
1273 nfsi
->cache_change_attribute
= jiffies
;
1279 * nfs_check_inode_attributes - verify consistency of the inode attribute cache
1280 * @inode - pointer to inode
1281 * @fattr - updated attributes
1283 * Verifies the attribute cache. If we have just changed the attributes,
1284 * so that fattr carries weak cache consistency data, then it may
1285 * also update the ctime/mtime/change_attribute.
1287 static int nfs_check_inode_attributes(struct inode
*inode
, struct nfs_fattr
*fattr
)
1289 struct nfs_inode
*nfsi
= NFS_I(inode
);
1290 loff_t cur_size
, new_isize
;
1294 if ((fattr
->valid
& NFS_ATTR_FATTR
) == 0)
1297 /* Are we in the process of updating data on the server? */
1298 data_unstable
= nfs_caches_unstable(inode
);
1300 /* Do atomic weak cache consistency updates */
1301 nfs_wcc_update_inode(inode
, fattr
);
1303 if ((fattr
->valid
& NFS_ATTR_FATTR_V4
) != 0 &&
1304 nfsi
->change_attr
!= fattr
->change_attr
) {
1305 nfsi
->cache_validity
|= NFS_INO_INVALID_ATTR
;
1307 nfsi
->cache_validity
|= NFS_INO_REVAL_PAGECACHE
;
1310 /* Has the inode gone and changed behind our back? */
1311 if (nfsi
->fileid
!= fattr
->fileid
1312 || (inode
->i_mode
& S_IFMT
) != (fattr
->mode
& S_IFMT
)) {
1316 cur_size
= i_size_read(inode
);
1317 new_isize
= nfs_size_to_loff_t(fattr
->size
);
1319 /* Verify a few of the more important attributes */
1320 if (!timespec_equal(&inode
->i_mtime
, &fattr
->mtime
)) {
1321 nfsi
->cache_validity
|= NFS_INO_INVALID_ATTR
;
1323 nfsi
->cache_validity
|= NFS_INO_REVAL_PAGECACHE
;
1325 if (cur_size
!= new_isize
) {
1326 nfsi
->cache_validity
|= NFS_INO_INVALID_ATTR
;
1327 if (nfsi
->npages
== 0)
1328 nfsi
->cache_validity
|= NFS_INO_REVAL_PAGECACHE
;
1331 /* Have any file permissions changed? */
1332 if ((inode
->i_mode
& S_IALLUGO
) != (fattr
->mode
& S_IALLUGO
)
1333 || inode
->i_uid
!= fattr
->uid
1334 || inode
->i_gid
!= fattr
->gid
)
1335 nfsi
->cache_validity
|= NFS_INO_INVALID_ATTR
| NFS_INO_INVALID_ACCESS
| NFS_INO_INVALID_ACL
;
1337 /* Has the link count changed? */
1338 if (inode
->i_nlink
!= fattr
->nlink
)
1339 nfsi
->cache_validity
|= NFS_INO_INVALID_ATTR
;
1341 if (!timespec_equal(&inode
->i_atime
, &fattr
->atime
))
1342 nfsi
->cache_validity
|= NFS_INO_INVALID_ATIME
;
1344 nfsi
->read_cache_jiffies
= fattr
->time_start
;
1349 * nfs_refresh_inode - try to update the inode attribute cache
1350 * @inode - pointer to inode
1351 * @fattr - updated attributes
1353 * Check that an RPC call that returned attributes has not overlapped with
1354 * other recent updates of the inode metadata, then decide whether it is
1355 * safe to do a full update of the inode attributes, or whether just to
1356 * call nfs_check_inode_attributes.
1358 int nfs_refresh_inode(struct inode
*inode
, struct nfs_fattr
*fattr
)
1360 struct nfs_inode
*nfsi
= NFS_I(inode
);
1363 if ((fattr
->valid
& NFS_ATTR_FATTR
) == 0)
1365 spin_lock(&inode
->i_lock
);
1366 nfsi
->cache_validity
&= ~NFS_INO_REVAL_PAGECACHE
;
1367 if (time_after(fattr
->time_start
, nfsi
->last_updated
))
1368 status
= nfs_update_inode(inode
, fattr
);
1370 status
= nfs_check_inode_attributes(inode
, fattr
);
1372 spin_unlock(&inode
->i_lock
);
1377 * nfs_post_op_update_inode - try to update the inode attribute cache
1378 * @inode - pointer to inode
1379 * @fattr - updated attributes
1381 * After an operation that has changed the inode metadata, mark the
1382 * attribute cache as being invalid, then try to update it.
1384 int nfs_post_op_update_inode(struct inode
*inode
, struct nfs_fattr
*fattr
)
1386 struct nfs_inode
*nfsi
= NFS_I(inode
);
1389 spin_lock(&inode
->i_lock
);
1390 if (unlikely((fattr
->valid
& NFS_ATTR_FATTR
) == 0)) {
1391 nfsi
->cache_validity
|= NFS_INO_INVALID_ATTR
| NFS_INO_INVALID_ACCESS
;
1394 status
= nfs_update_inode(inode
, fattr
);
1396 spin_unlock(&inode
->i_lock
);
1401 * Many nfs protocol calls return the new file attributes after
1402 * an operation. Here we update the inode to reflect the state
1403 * of the server's inode.
1405 * This is a bit tricky because we have to make sure all dirty pages
1406 * have been sent off to the server before calling invalidate_inode_pages.
1407 * To make sure no other process adds more write requests while we try
1408 * our best to flush them, we make them sleep during the attribute refresh.
1410 * A very similar scenario holds for the dir cache.
1412 static int nfs_update_inode(struct inode
*inode
, struct nfs_fattr
*fattr
)
1414 struct nfs_inode
*nfsi
= NFS_I(inode
);
1415 loff_t cur_isize
, new_isize
;
1416 unsigned int invalid
= 0;
1419 dfprintk(VFS
, "NFS: %s(%s/%ld ct=%d info=0x%x)\n",
1420 __FUNCTION__
, inode
->i_sb
->s_id
, inode
->i_ino
,
1421 atomic_read(&inode
->i_count
), fattr
->valid
);
1423 if ((fattr
->valid
& NFS_ATTR_FATTR
) == 0)
1426 if (nfsi
->fileid
!= fattr
->fileid
)
1430 * Make sure the inode's type hasn't changed.
1432 if ((inode
->i_mode
& S_IFMT
) != (fattr
->mode
& S_IFMT
))
1436 * Update the read time so we don't revalidate too often.
1438 nfsi
->read_cache_jiffies
= fattr
->time_start
;
1439 nfsi
->last_updated
= jiffies
;
1441 /* Are we racing with known updates of the metadata on the server? */
1442 data_stable
= nfs_verify_change_attribute(inode
, fattr
->time_start
);
1444 nfsi
->cache_validity
&= ~(NFS_INO_INVALID_ATTR
|NFS_INO_INVALID_ATIME
);
1446 /* Do atomic weak cache consistency updates */
1447 nfs_wcc_update_inode(inode
, fattr
);
1449 /* Check if our cached file size is stale */
1450 new_isize
= nfs_size_to_loff_t(fattr
->size
);
1451 cur_isize
= i_size_read(inode
);
1452 if (new_isize
!= cur_isize
) {
1453 /* Do we perhaps have any outstanding writes? */
1454 if (nfsi
->npages
== 0) {
1455 /* No, but did we race with nfs_end_data_update()? */
1457 inode
->i_size
= new_isize
;
1458 invalid
|= NFS_INO_INVALID_DATA
;
1460 invalid
|= NFS_INO_INVALID_ATTR
;
1461 } else if (new_isize
> cur_isize
) {
1462 inode
->i_size
= new_isize
;
1463 invalid
|= NFS_INO_INVALID_ATTR
|NFS_INO_INVALID_DATA
;
1465 nfsi
->cache_change_attribute
= jiffies
;
1466 dprintk("NFS: isize change on server for file %s/%ld\n",
1467 inode
->i_sb
->s_id
, inode
->i_ino
);
1470 /* Check if the mtime agrees */
1471 if (!timespec_equal(&inode
->i_mtime
, &fattr
->mtime
)) {
1472 memcpy(&inode
->i_mtime
, &fattr
->mtime
, sizeof(inode
->i_mtime
));
1473 dprintk("NFS: mtime change on server for file %s/%ld\n",
1474 inode
->i_sb
->s_id
, inode
->i_ino
);
1475 invalid
|= NFS_INO_INVALID_ATTR
|NFS_INO_INVALID_DATA
;
1476 nfsi
->cache_change_attribute
= jiffies
;
1479 if ((fattr
->valid
& NFS_ATTR_FATTR_V4
)
1480 && nfsi
->change_attr
!= fattr
->change_attr
) {
1481 dprintk("NFS: change_attr change on server for file %s/%ld\n",
1482 inode
->i_sb
->s_id
, inode
->i_ino
);
1483 nfsi
->change_attr
= fattr
->change_attr
;
1484 invalid
|= NFS_INO_INVALID_ATTR
|NFS_INO_INVALID_DATA
|NFS_INO_INVALID_ACCESS
|NFS_INO_INVALID_ACL
;
1485 nfsi
->cache_change_attribute
= jiffies
;
1488 /* If ctime has changed we should definitely clear access+acl caches */
1489 if (!timespec_equal(&inode
->i_ctime
, &fattr
->ctime
)) {
1490 invalid
|= NFS_INO_INVALID_ACCESS
|NFS_INO_INVALID_ACL
;
1491 memcpy(&inode
->i_ctime
, &fattr
->ctime
, sizeof(inode
->i_ctime
));
1492 nfsi
->cache_change_attribute
= jiffies
;
1494 memcpy(&inode
->i_atime
, &fattr
->atime
, sizeof(inode
->i_atime
));
1496 if ((inode
->i_mode
& S_IALLUGO
) != (fattr
->mode
& S_IALLUGO
) ||
1497 inode
->i_uid
!= fattr
->uid
||
1498 inode
->i_gid
!= fattr
->gid
)
1499 invalid
|= NFS_INO_INVALID_ATTR
|NFS_INO_INVALID_ACCESS
|NFS_INO_INVALID_ACL
;
1501 inode
->i_mode
= fattr
->mode
;
1502 inode
->i_nlink
= fattr
->nlink
;
1503 inode
->i_uid
= fattr
->uid
;
1504 inode
->i_gid
= fattr
->gid
;
1506 if (fattr
->valid
& (NFS_ATTR_FATTR_V3
| NFS_ATTR_FATTR_V4
)) {
1508 * report the blocks in 512byte units
1510 inode
->i_blocks
= nfs_calc_block_size(fattr
->du
.nfs3
.used
);
1511 inode
->i_blksize
= inode
->i_sb
->s_blocksize
;
1513 inode
->i_blocks
= fattr
->du
.nfs2
.blocks
;
1514 inode
->i_blksize
= fattr
->du
.nfs2
.blocksize
;
1517 /* Update attrtimeo value if we're out of the unstable period */
1518 if (invalid
& NFS_INO_INVALID_ATTR
) {
1519 nfsi
->attrtimeo
= NFS_MINATTRTIMEO(inode
);
1520 nfsi
->attrtimeo_timestamp
= jiffies
;
1521 } else if (time_after(jiffies
, nfsi
->attrtimeo_timestamp
+nfsi
->attrtimeo
)) {
1522 if ((nfsi
->attrtimeo
<<= 1) > NFS_MAXATTRTIMEO(inode
))
1523 nfsi
->attrtimeo
= NFS_MAXATTRTIMEO(inode
);
1524 nfsi
->attrtimeo_timestamp
= jiffies
;
1526 /* Don't invalidate the data if we were to blame */
1527 if (!(S_ISREG(inode
->i_mode
) || S_ISDIR(inode
->i_mode
)
1528 || S_ISLNK(inode
->i_mode
)))
1529 invalid
&= ~NFS_INO_INVALID_DATA
;
1531 invalid
&= ~(NFS_INO_INVALID_ATTR
|NFS_INO_INVALID_ATIME
|NFS_INO_REVAL_PAGECACHE
);
1532 if (!nfs_have_delegation(inode
, FMODE_READ
))
1533 nfsi
->cache_validity
|= invalid
;
1538 * Big trouble! The inode has become a different object.
1541 printk(KERN_DEBUG
"%s: inode %ld mode changed, %07o to %07o\n",
1542 __FUNCTION__
, inode
->i_ino
, inode
->i_mode
, fattr
->mode
);
1546 * No need to worry about unhashing the dentry, as the
1547 * lookup validation will know that the inode is bad.
1548 * (But we fall through to invalidate the caches.)
1550 nfs_invalidate_inode(inode
);
1554 printk(KERN_ERR
"NFS: server %s error: fileid changed\n"
1555 "fsid %s: expected fileid 0x%Lx, got 0x%Lx\n",
1556 NFS_SERVER(inode
)->hostname
, inode
->i_sb
->s_id
,
1557 (long long)nfsi
->fileid
, (long long)fattr
->fileid
);
1562 * File system information
1565 static int nfs_set_super(struct super_block
*s
, void *data
)
1567 s
->s_fs_info
= data
;
1568 return set_anon_super(s
, data
);
1571 static int nfs_compare_super(struct super_block
*sb
, void *data
)
1573 struct nfs_server
*server
= data
;
1574 struct nfs_server
*old
= NFS_SB(sb
);
1576 if (old
->addr
.sin_addr
.s_addr
!= server
->addr
.sin_addr
.s_addr
)
1578 if (old
->addr
.sin_port
!= server
->addr
.sin_port
)
1580 return !nfs_compare_fh(&old
->fh
, &server
->fh
);
1583 static struct super_block
*nfs_get_sb(struct file_system_type
*fs_type
,
1584 int flags
, const char *dev_name
, void *raw_data
)
1587 struct nfs_server
*server
= NULL
;
1588 struct super_block
*s
;
1589 struct nfs_fh
*root
;
1590 struct nfs_mount_data
*data
= raw_data
;
1592 s
= ERR_PTR(-EINVAL
);
1594 dprintk("%s: missing data argument\n", __FUNCTION__
);
1597 if (data
->version
<= 0 || data
->version
> NFS_MOUNT_VERSION
) {
1598 dprintk("%s: bad mount version\n", __FUNCTION__
);
1601 switch (data
->version
) {
1607 if (data
->flags
& NFS_MOUNT_VER3
) {
1608 dprintk("%s: mount structure version %d does not support NFSv3\n",
1613 data
->root
.size
= NFS2_FHSIZE
;
1614 memcpy(data
->root
.data
, data
->old_root
.data
, NFS2_FHSIZE
);
1616 if (data
->flags
& NFS_MOUNT_SECFLAVOUR
) {
1617 dprintk("%s: mount structure version %d does not support strong security\n",
1623 memset(data
->context
, 0, sizeof(data
->context
));
1625 #ifndef CONFIG_NFS_V3
1626 /* If NFSv3 is not compiled in, return -EPROTONOSUPPORT */
1627 s
= ERR_PTR(-EPROTONOSUPPORT
);
1628 if (data
->flags
& NFS_MOUNT_VER3
) {
1629 dprintk("%s: NFSv3 not compiled into kernel\n", __FUNCTION__
);
1632 #endif /* CONFIG_NFS_V3 */
1634 s
= ERR_PTR(-ENOMEM
);
1635 server
= kmalloc(sizeof(struct nfs_server
), GFP_KERNEL
);
1638 memset(server
, 0, sizeof(struct nfs_server
));
1639 /* Zero out the NFS state stuff */
1640 init_nfsv4_state(server
);
1641 server
->client
= server
->client_sys
= server
->client_acl
= ERR_PTR(-EINVAL
);
1644 if (data
->flags
& NFS_MOUNT_VER3
)
1645 root
->size
= data
->root
.size
;
1647 root
->size
= NFS2_FHSIZE
;
1648 s
= ERR_PTR(-EINVAL
);
1649 if (root
->size
> sizeof(root
->data
)) {
1650 dprintk("%s: invalid root filehandle\n", __FUNCTION__
);
1653 memcpy(root
->data
, data
->root
.data
, root
->size
);
1655 /* We now require that the mount process passes the remote address */
1656 memcpy(&server
->addr
, &data
->addr
, sizeof(server
->addr
));
1657 if (server
->addr
.sin_addr
.s_addr
== INADDR_ANY
) {
1658 dprintk("%s: mount program didn't pass remote address!\n",
1663 /* Fire up rpciod if not yet running */
1664 s
= ERR_PTR(rpciod_up());
1666 dprintk("%s: couldn't start rpciod! Error = %ld\n",
1667 __FUNCTION__
, PTR_ERR(s
));
1671 s
= sget(fs_type
, nfs_compare_super
, nfs_set_super
, server
);
1672 if (IS_ERR(s
) || s
->s_root
)
1673 goto out_rpciod_down
;
1677 error
= nfs_fill_super(s
, data
, flags
& MS_VERBOSE
? 1 : 0);
1679 up_write(&s
->s_umount
);
1680 deactivate_super(s
);
1681 return ERR_PTR(error
);
1683 s
->s_flags
|= MS_ACTIVE
;
1692 static void nfs_kill_super(struct super_block
*s
)
1694 struct nfs_server
*server
= NFS_SB(s
);
1698 if (!IS_ERR(server
->client
))
1699 rpc_shutdown_client(server
->client
);
1700 if (!IS_ERR(server
->client_sys
))
1701 rpc_shutdown_client(server
->client_sys
);
1702 if (!IS_ERR(server
->client_acl
))
1703 rpc_shutdown_client(server
->client_acl
);
1705 if (!(server
->flags
& NFS_MOUNT_NONLM
))
1706 lockd_down(); /* release rpc.lockd */
1708 rpciod_down(); /* release rpciod */
1710 kfree(server
->hostname
);
1714 static struct file_system_type nfs_fs_type
= {
1715 .owner
= THIS_MODULE
,
1717 .get_sb
= nfs_get_sb
,
1718 .kill_sb
= nfs_kill_super
,
1719 .fs_flags
= FS_ODD_RENAME
|FS_REVAL_DOT
|FS_BINARY_MOUNTDATA
,
1722 #ifdef CONFIG_NFS_V4
1724 static void nfs4_clear_inode(struct inode
*);
1727 static struct super_operations nfs4_sops
= {
1728 .alloc_inode
= nfs_alloc_inode
,
1729 .destroy_inode
= nfs_destroy_inode
,
1730 .write_inode
= nfs_write_inode
,
1731 .delete_inode
= nfs_delete_inode
,
1732 .statfs
= nfs_statfs
,
1733 .clear_inode
= nfs4_clear_inode
,
1734 .umount_begin
= nfs_umount_begin
,
1735 .show_options
= nfs_show_options
,
1739 * Clean out any remaining NFSv4 state that might be left over due
1740 * to open() calls that passed nfs_atomic_lookup, but failed to call
1743 static void nfs4_clear_inode(struct inode
*inode
)
1745 struct nfs_inode
*nfsi
= NFS_I(inode
);
1747 /* If we are holding a delegation, return it! */
1748 nfs_inode_return_delegation(inode
);
1749 /* First call standard NFS clear_inode() code */
1750 nfs_clear_inode(inode
);
1751 /* Now clear out any remaining state */
1752 while (!list_empty(&nfsi
->open_states
)) {
1753 struct nfs4_state
*state
;
1755 state
= list_entry(nfsi
->open_states
.next
,
1758 dprintk("%s(%s/%Ld): found unclaimed NFSv4 state %p\n",
1761 (long long)NFS_FILEID(inode
),
1763 BUG_ON(atomic_read(&state
->count
) != 1);
1764 nfs4_close_state(state
, state
->state
);
1769 static int nfs4_fill_super(struct super_block
*sb
, struct nfs4_mount_data
*data
, int silent
)
1771 struct nfs_server
*server
;
1772 struct nfs4_client
*clp
= NULL
;
1773 struct rpc_xprt
*xprt
= NULL
;
1774 struct rpc_clnt
*clnt
= NULL
;
1775 struct rpc_timeout timeparms
;
1776 rpc_authflavor_t authflavour
;
1779 sb
->s_blocksize_bits
= 0;
1780 sb
->s_blocksize
= 0;
1781 server
= NFS_SB(sb
);
1782 if (data
->rsize
!= 0)
1783 server
->rsize
= nfs_block_size(data
->rsize
, NULL
);
1784 if (data
->wsize
!= 0)
1785 server
->wsize
= nfs_block_size(data
->wsize
, NULL
);
1786 server
->flags
= data
->flags
& NFS_MOUNT_FLAGMASK
;
1787 server
->caps
= NFS_CAP_ATOMIC_OPEN
;
1789 server
->acregmin
= data
->acregmin
*HZ
;
1790 server
->acregmax
= data
->acregmax
*HZ
;
1791 server
->acdirmin
= data
->acdirmin
*HZ
;
1792 server
->acdirmax
= data
->acdirmax
*HZ
;
1794 server
->rpc_ops
= &nfs_v4_clientops
;
1796 nfs_init_timeout_values(&timeparms
, data
->proto
, data
->timeo
, data
->retrans
);
1798 clp
= nfs4_get_client(&server
->addr
.sin_addr
);
1800 dprintk("%s: failed to create NFS4 client.\n", __FUNCTION__
);
1804 /* Now create transport and client */
1805 authflavour
= RPC_AUTH_UNIX
;
1806 if (data
->auth_flavourlen
!= 0) {
1807 if (data
->auth_flavourlen
!= 1) {
1808 dprintk("%s: Invalid number of RPC auth flavours %d.\n",
1809 __FUNCTION__
, data
->auth_flavourlen
);
1813 if (copy_from_user(&authflavour
, data
->auth_flavours
, sizeof(authflavour
))) {
1819 down_write(&clp
->cl_sem
);
1820 if (IS_ERR(clp
->cl_rpcclient
)) {
1821 xprt
= xprt_create_proto(data
->proto
, &server
->addr
, &timeparms
);
1823 up_write(&clp
->cl_sem
);
1824 err
= PTR_ERR(xprt
);
1825 dprintk("%s: cannot create RPC transport. Error = %d\n",
1829 clnt
= rpc_create_client(xprt
, server
->hostname
, &nfs_program
,
1830 server
->rpc_ops
->version
, authflavour
);
1832 up_write(&clp
->cl_sem
);
1833 err
= PTR_ERR(clnt
);
1834 dprintk("%s: cannot create RPC client. Error = %d\n",
1839 clnt
->cl_softrtry
= 1;
1840 clp
->cl_rpcclient
= clnt
;
1841 memcpy(clp
->cl_ipaddr
, server
->ip_addr
, sizeof(clp
->cl_ipaddr
));
1844 list_add_tail(&server
->nfs4_siblings
, &clp
->cl_superblocks
);
1845 clnt
= rpc_clone_client(clp
->cl_rpcclient
);
1847 server
->nfs4_state
= clp
;
1848 up_write(&clp
->cl_sem
);
1852 err
= PTR_ERR(clnt
);
1853 dprintk("%s: cannot create RPC client. Error = %d\n",
1858 server
->client
= clnt
;
1860 if (server
->nfs4_state
->cl_idmap
== NULL
) {
1861 dprintk("%s: failed to create idmapper.\n", __FUNCTION__
);
1865 if (clnt
->cl_auth
->au_flavor
!= authflavour
) {
1866 struct rpc_auth
*auth
;
1868 auth
= rpcauth_create(authflavour
, clnt
);
1870 dprintk("%s: couldn't create credcache!\n", __FUNCTION__
);
1871 return PTR_ERR(auth
);
1875 sb
->s_time_gran
= 1;
1877 sb
->s_op
= &nfs4_sops
;
1878 err
= nfs_sb_init(sb
, authflavour
);
1883 nfs4_put_client(clp
);
1887 static int nfs4_compare_super(struct super_block
*sb
, void *data
)
1889 struct nfs_server
*server
= data
;
1890 struct nfs_server
*old
= NFS_SB(sb
);
1892 if (strcmp(server
->hostname
, old
->hostname
) != 0)
1894 if (strcmp(server
->mnt_path
, old
->mnt_path
) != 0)
1900 nfs_copy_user_string(char *dst
, struct nfs_string
*src
, int maxlen
)
1905 return ERR_PTR(-EINVAL
);
1906 if (src
->len
< maxlen
)
1909 p
= dst
= kmalloc(maxlen
+ 1, GFP_KERNEL
);
1911 return ERR_PTR(-ENOMEM
);
1913 if (copy_from_user(dst
, src
->data
, maxlen
)) {
1915 return ERR_PTR(-EFAULT
);
1921 static struct super_block
*nfs4_get_sb(struct file_system_type
*fs_type
,
1922 int flags
, const char *dev_name
, void *raw_data
)
1925 struct nfs_server
*server
;
1926 struct super_block
*s
;
1927 struct nfs4_mount_data
*data
= raw_data
;
1931 dprintk("%s: missing data argument\n", __FUNCTION__
);
1932 return ERR_PTR(-EINVAL
);
1934 if (data
->version
<= 0 || data
->version
> NFS4_MOUNT_VERSION
) {
1935 dprintk("%s: bad mount version\n", __FUNCTION__
);
1936 return ERR_PTR(-EINVAL
);
1939 server
= kmalloc(sizeof(struct nfs_server
), GFP_KERNEL
);
1941 return ERR_PTR(-ENOMEM
);
1942 memset(server
, 0, sizeof(struct nfs_server
));
1943 /* Zero out the NFS state stuff */
1944 init_nfsv4_state(server
);
1945 server
->client
= server
->client_sys
= server
->client_acl
= ERR_PTR(-EINVAL
);
1947 p
= nfs_copy_user_string(NULL
, &data
->hostname
, 256);
1950 server
->hostname
= p
;
1952 p
= nfs_copy_user_string(NULL
, &data
->mnt_path
, 1024);
1955 server
->mnt_path
= p
;
1957 p
= nfs_copy_user_string(server
->ip_addr
, &data
->client_addr
,
1958 sizeof(server
->ip_addr
) - 1);
1962 /* We now require that the mount process passes the remote address */
1963 if (data
->host_addrlen
!= sizeof(server
->addr
)) {
1964 s
= ERR_PTR(-EINVAL
);
1967 if (copy_from_user(&server
->addr
, data
->host_addr
, sizeof(server
->addr
))) {
1968 s
= ERR_PTR(-EFAULT
);
1971 if (server
->addr
.sin_family
!= AF_INET
||
1972 server
->addr
.sin_addr
.s_addr
== INADDR_ANY
) {
1973 dprintk("%s: mount program didn't pass remote IP address!\n",
1975 s
= ERR_PTR(-EINVAL
);
1979 /* Fire up rpciod if not yet running */
1980 s
= ERR_PTR(rpciod_up());
1982 dprintk("%s: couldn't start rpciod! Error = %ld\n",
1983 __FUNCTION__
, PTR_ERR(s
));
1987 s
= sget(fs_type
, nfs4_compare_super
, nfs_set_super
, server
);
1989 if (IS_ERR(s
) || s
->s_root
)
1994 error
= nfs4_fill_super(s
, data
, flags
& MS_VERBOSE
? 1 : 0);
1996 up_write(&s
->s_umount
);
1997 deactivate_super(s
);
1998 return ERR_PTR(error
);
2000 s
->s_flags
|= MS_ACTIVE
;
2003 s
= (struct super_block
*)p
;
2005 kfree(server
->mnt_path
);
2006 kfree(server
->hostname
);
2011 static void nfs4_kill_super(struct super_block
*sb
)
2013 struct nfs_server
*server
= NFS_SB(sb
);
2015 nfs_return_all_delegations(sb
);
2016 kill_anon_super(sb
);
2018 nfs4_renewd_prepare_shutdown(server
);
2020 if (server
->client
!= NULL
&& !IS_ERR(server
->client
))
2021 rpc_shutdown_client(server
->client
);
2022 rpciod_down(); /* release rpciod */
2024 destroy_nfsv4_state(server
);
2026 kfree(server
->hostname
);
2030 static struct file_system_type nfs4_fs_type
= {
2031 .owner
= THIS_MODULE
,
2033 .get_sb
= nfs4_get_sb
,
2034 .kill_sb
= nfs4_kill_super
,
2035 .fs_flags
= FS_ODD_RENAME
|FS_REVAL_DOT
|FS_BINARY_MOUNTDATA
,
2038 static const int nfs_set_port_min
= 0;
2039 static const int nfs_set_port_max
= 65535;
2040 static int param_set_port(const char *val
, struct kernel_param
*kp
)
2043 int num
= simple_strtol(val
, &endp
, 0);
2044 if (endp
== val
|| *endp
|| num
< nfs_set_port_min
|| num
> nfs_set_port_max
)
2046 *((int *)kp
->arg
) = num
;
2050 module_param_call(callback_tcpport
, param_set_port
, param_get_int
,
2051 &nfs_callback_set_tcpport
, 0644);
2053 static int param_set_idmap_timeout(const char *val
, struct kernel_param
*kp
)
2056 int num
= simple_strtol(val
, &endp
, 0);
2058 if (endp
== val
|| *endp
|| num
< 0 || jif
< num
)
2060 *((int *)kp
->arg
) = jif
;
2064 module_param_call(idmap_cache_timeout
, param_set_idmap_timeout
, param_get_int
,
2065 &nfs_idmap_cache_timeout
, 0644);
2067 #define nfs4_init_once(nfsi) \
2069 INIT_LIST_HEAD(&(nfsi)->open_states); \
2070 nfsi->delegation = NULL; \
2071 nfsi->delegation_state = 0; \
2072 init_rwsem(&nfsi->rwsem); \
2075 static inline int register_nfs4fs(void)
2079 ret
= nfs_register_sysctl();
2082 ret
= register_filesystem(&nfs4_fs_type
);
2084 nfs_unregister_sysctl();
2088 static inline void unregister_nfs4fs(void)
2090 unregister_filesystem(&nfs4_fs_type
);
2091 nfs_unregister_sysctl();
2094 #define nfs4_init_once(nfsi) \
2096 #define register_nfs4fs() (0)
2097 #define unregister_nfs4fs()
2100 extern int nfs_init_nfspagecache(void);
2101 extern void nfs_destroy_nfspagecache(void);
2102 extern int nfs_init_readpagecache(void);
2103 extern void nfs_destroy_readpagecache(void);
2104 extern int nfs_init_writepagecache(void);
2105 extern void nfs_destroy_writepagecache(void);
2106 #ifdef CONFIG_NFS_DIRECTIO
2107 extern int nfs_init_directcache(void);
2108 extern void nfs_destroy_directcache(void);
2111 static kmem_cache_t
* nfs_inode_cachep
;
2113 static struct inode
*nfs_alloc_inode(struct super_block
*sb
)
2115 struct nfs_inode
*nfsi
;
2116 nfsi
= (struct nfs_inode
*)kmem_cache_alloc(nfs_inode_cachep
, SLAB_KERNEL
);
2120 nfsi
->cache_validity
= 0UL;
2121 nfsi
->cache_change_attribute
= jiffies
;
2122 #ifdef CONFIG_NFS_V3_ACL
2123 nfsi
->acl_access
= ERR_PTR(-EAGAIN
);
2124 nfsi
->acl_default
= ERR_PTR(-EAGAIN
);
2126 #ifdef CONFIG_NFS_V4
2127 nfsi
->nfs4_acl
= NULL
;
2128 #endif /* CONFIG_NFS_V4 */
2129 return &nfsi
->vfs_inode
;
2132 static void nfs_destroy_inode(struct inode
*inode
)
2134 kmem_cache_free(nfs_inode_cachep
, NFS_I(inode
));
2137 static void init_once(void * foo
, kmem_cache_t
* cachep
, unsigned long flags
)
2139 struct nfs_inode
*nfsi
= (struct nfs_inode
*) foo
;
2141 if ((flags
& (SLAB_CTOR_VERIFY
|SLAB_CTOR_CONSTRUCTOR
)) ==
2142 SLAB_CTOR_CONSTRUCTOR
) {
2143 inode_init_once(&nfsi
->vfs_inode
);
2144 spin_lock_init(&nfsi
->req_lock
);
2145 INIT_LIST_HEAD(&nfsi
->dirty
);
2146 INIT_LIST_HEAD(&nfsi
->commit
);
2147 INIT_LIST_HEAD(&nfsi
->open_files
);
2148 INIT_RADIX_TREE(&nfsi
->nfs_page_tree
, GFP_ATOMIC
);
2149 atomic_set(&nfsi
->data_updates
, 0);
2153 nfs4_init_once(nfsi
);
2157 static int nfs_init_inodecache(void)
2159 nfs_inode_cachep
= kmem_cache_create("nfs_inode_cache",
2160 sizeof(struct nfs_inode
),
2161 0, SLAB_RECLAIM_ACCOUNT
,
2163 if (nfs_inode_cachep
== NULL
)
2169 static void nfs_destroy_inodecache(void)
2171 if (kmem_cache_destroy(nfs_inode_cachep
))
2172 printk(KERN_INFO
"nfs_inode_cache: not all structures were freed\n");
2178 static int __init
init_nfs_fs(void)
2182 err
= nfs_init_nfspagecache();
2186 err
= nfs_init_inodecache();
2190 err
= nfs_init_readpagecache();
2194 err
= nfs_init_writepagecache();
2198 #ifdef CONFIG_NFS_DIRECTIO
2199 err
= nfs_init_directcache();
2204 #ifdef CONFIG_PROC_FS
2205 rpc_proc_register(&nfs_rpcstat
);
2207 err
= register_filesystem(&nfs_fs_type
);
2210 if ((err
= register_nfs4fs()) != 0)
2214 #ifdef CONFIG_PROC_FS
2215 rpc_proc_unregister("nfs");
2217 #ifdef CONFIG_NFS_DIRECTIO
2218 nfs_destroy_directcache();
2221 nfs_destroy_writepagecache();
2223 nfs_destroy_readpagecache();
2225 nfs_destroy_inodecache();
2227 nfs_destroy_nfspagecache();
2232 static void __exit
exit_nfs_fs(void)
2234 #ifdef CONFIG_NFS_DIRECTIO
2235 nfs_destroy_directcache();
2237 nfs_destroy_writepagecache();
2238 nfs_destroy_readpagecache();
2239 nfs_destroy_inodecache();
2240 nfs_destroy_nfspagecache();
2241 #ifdef CONFIG_PROC_FS
2242 rpc_proc_unregister("nfs");
2244 unregister_filesystem(&nfs_fs_type
);
2245 unregister_nfs4fs();
2248 /* Not quite true; I just maintain it */
2249 MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
2250 MODULE_LICENSE("GPL");
2252 module_init(init_nfs_fs
)
2253 module_exit(exit_nfs_fs
)