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>
43 #include "delegation.h"
45 #define NFSDBG_FACILITY NFSDBG_VFS
46 #define NFS_PARANOIA 1
48 /* Maximum number of readahead requests
49 * FIXME: this should really be a sysctl so that users may tune it to suit
50 * their needs. People that do NFS over a slow network, might for
51 * instance want to reduce it to something closer to 1 for improved
52 * interactive response.
54 #define NFS_MAX_READAHEAD (RPC_DEF_SLOT_TABLE - 1)
56 static void nfs_invalidate_inode(struct inode
*);
57 static int nfs_update_inode(struct inode
*, struct nfs_fattr
*, unsigned long);
59 static struct inode
*nfs_alloc_inode(struct super_block
*sb
);
60 static void nfs_destroy_inode(struct inode
*);
61 static int nfs_write_inode(struct inode
*,int);
62 static void nfs_delete_inode(struct inode
*);
63 static void nfs_clear_inode(struct inode
*);
64 static void nfs_umount_begin(struct super_block
*);
65 static int nfs_statfs(struct super_block
*, struct kstatfs
*);
66 static int nfs_show_options(struct seq_file
*, struct vfsmount
*);
68 static struct rpc_program nfs_program
;
70 static struct super_operations nfs_sops
= {
71 .alloc_inode
= nfs_alloc_inode
,
72 .destroy_inode
= nfs_destroy_inode
,
73 .write_inode
= nfs_write_inode
,
74 .delete_inode
= nfs_delete_inode
,
76 .clear_inode
= nfs_clear_inode
,
77 .umount_begin
= nfs_umount_begin
,
78 .show_options
= nfs_show_options
,
84 static struct rpc_stat nfs_rpcstat
= {
85 .program
= &nfs_program
87 static struct rpc_version
* nfs_version
[] = {
91 #if defined(CONFIG_NFS_V3)
93 #elif defined(CONFIG_NFS_V4)
96 #if defined(CONFIG_NFS_V4)
101 static struct rpc_program nfs_program
= {
103 .number
= NFS_PROGRAM
,
104 .nrvers
= sizeof(nfs_version
) / sizeof(nfs_version
[0]),
105 .version
= nfs_version
,
106 .stats
= &nfs_rpcstat
,
107 .pipe_dir_name
= "/nfs",
110 static inline unsigned long
111 nfs_fattr_to_ino_t(struct nfs_fattr
*fattr
)
113 return nfs_fileid_to_ino_t(fattr
->fileid
);
117 nfs_write_inode(struct inode
*inode
, int sync
)
119 int flags
= sync
? FLUSH_WAIT
: 0;
122 ret
= nfs_commit_inode(inode
, 0, 0, flags
);
129 nfs_delete_inode(struct inode
* inode
)
131 dprintk("NFS: delete_inode(%s/%ld)\n", inode
->i_sb
->s_id
, inode
->i_ino
);
135 * The following should never happen...
137 if (nfs_have_writebacks(inode
)) {
138 printk(KERN_ERR
"nfs_delete_inode: inode %ld has pending RPC requests\n", inode
->i_ino
);
145 * For the moment, the only task for the NFS clear_inode method is to
146 * release the mmap credential
149 nfs_clear_inode(struct inode
*inode
)
151 struct nfs_inode
*nfsi
= NFS_I(inode
);
152 struct rpc_cred
*cred
;
155 BUG_ON (!list_empty(&nfsi
->open_files
));
156 cred
= nfsi
->cache_access
.cred
;
159 BUG_ON(atomic_read(&nfsi
->data_updates
) != 0);
163 nfs_umount_begin(struct super_block
*sb
)
165 struct nfs_server
*server
= NFS_SB(sb
);
166 struct rpc_clnt
*rpc
;
168 /* -EIO all pending I/O */
169 if ((rpc
= server
->client
) != NULL
)
170 rpc_killall_tasks(rpc
);
174 static inline unsigned long
175 nfs_block_bits(unsigned long bsize
, unsigned char *nrbitsp
)
177 /* make sure blocksize is a power of two */
178 if ((bsize
& (bsize
- 1)) || nrbitsp
) {
179 unsigned char nrbits
;
181 for (nrbits
= 31; nrbits
&& !(bsize
& (1 << nrbits
)); nrbits
--)
192 * Calculate the number of 512byte blocks used.
194 static inline unsigned long
195 nfs_calc_block_size(u64 tsize
)
197 loff_t used
= (tsize
+ 511) >> 9;
198 return (used
> ULONG_MAX
) ? ULONG_MAX
: used
;
202 * Compute and set NFS server blocksize
204 static inline unsigned long
205 nfs_block_size(unsigned long bsize
, unsigned char *nrbitsp
)
208 bsize
= NFS_DEF_FILE_IO_BUFFER_SIZE
;
209 else if (bsize
>= NFS_MAX_FILE_IO_BUFFER_SIZE
)
210 bsize
= NFS_MAX_FILE_IO_BUFFER_SIZE
;
212 return nfs_block_bits(bsize
, nrbitsp
);
216 * Obtain the root inode of the file system.
218 static struct inode
*
219 nfs_get_root(struct super_block
*sb
, struct nfs_fh
*rootfh
, struct nfs_fsinfo
*fsinfo
)
221 struct nfs_server
*server
= NFS_SB(sb
);
225 error
= server
->rpc_ops
->getroot(server
, rootfh
, fsinfo
);
227 dprintk("nfs_get_root: getattr error = %d\n", -error
);
228 return ERR_PTR(error
);
231 rooti
= nfs_fhget(sb
, rootfh
, fsinfo
->fattr
);
233 return ERR_PTR(-ENOMEM
);
238 * Do NFS version-independent mount processing, and sanity checking
241 nfs_sb_init(struct super_block
*sb
, rpc_authflavor_t authflavor
)
243 struct nfs_server
*server
;
244 struct inode
*root_inode
;
245 struct nfs_fattr fattr
;
246 struct nfs_fsinfo fsinfo
= {
249 struct nfs_pathconf pathinfo
= {
252 int no_root_error
= 0;
253 unsigned long max_rpc_payload
;
255 /* We probably want something more informative here */
256 snprintf(sb
->s_id
, sizeof(sb
->s_id
), "%x:%x", MAJOR(sb
->s_dev
), MINOR(sb
->s_dev
));
260 sb
->s_magic
= NFS_SUPER_MAGIC
;
262 root_inode
= nfs_get_root(sb
, &server
->fh
, &fsinfo
);
263 /* Did getting the root inode fail? */
264 if (IS_ERR(root_inode
)) {
265 no_root_error
= PTR_ERR(root_inode
);
268 sb
->s_root
= d_alloc_root(root_inode
);
270 no_root_error
= -ENOMEM
;
273 sb
->s_root
->d_op
= server
->rpc_ops
->dentry_ops
;
275 /* Get some general file system info */
276 if (server
->namelen
== 0 &&
277 server
->rpc_ops
->pathconf(server
, &server
->fh
, &pathinfo
) >= 0)
278 server
->namelen
= pathinfo
.max_namelen
;
279 /* Work out a lot of parameters */
280 if (server
->rsize
== 0)
281 server
->rsize
= nfs_block_size(fsinfo
.rtpref
, NULL
);
282 if (server
->wsize
== 0)
283 server
->wsize
= nfs_block_size(fsinfo
.wtpref
, NULL
);
285 if (fsinfo
.rtmax
>= 512 && server
->rsize
> fsinfo
.rtmax
)
286 server
->rsize
= nfs_block_size(fsinfo
.rtmax
, NULL
);
287 if (fsinfo
.wtmax
>= 512 && server
->wsize
> fsinfo
.wtmax
)
288 server
->wsize
= nfs_block_size(fsinfo
.wtmax
, NULL
);
290 max_rpc_payload
= nfs_block_size(rpc_max_payload(server
->client
), NULL
);
291 if (server
->rsize
> max_rpc_payload
)
292 server
->rsize
= max_rpc_payload
;
293 if (server
->wsize
> max_rpc_payload
)
294 server
->wsize
= max_rpc_payload
;
296 server
->rpages
= (server
->rsize
+ PAGE_CACHE_SIZE
- 1) >> PAGE_CACHE_SHIFT
;
297 if (server
->rpages
> NFS_READ_MAXIOV
) {
298 server
->rpages
= NFS_READ_MAXIOV
;
299 server
->rsize
= server
->rpages
<< PAGE_CACHE_SHIFT
;
302 server
->wpages
= (server
->wsize
+ PAGE_CACHE_SIZE
- 1) >> PAGE_CACHE_SHIFT
;
303 if (server
->wpages
> NFS_WRITE_MAXIOV
) {
304 server
->wpages
= NFS_WRITE_MAXIOV
;
305 server
->wsize
= server
->wpages
<< PAGE_CACHE_SHIFT
;
308 if (sb
->s_blocksize
== 0)
309 sb
->s_blocksize
= nfs_block_bits(server
->wsize
,
310 &sb
->s_blocksize_bits
);
311 server
->wtmult
= nfs_block_bits(fsinfo
.wtmult
, NULL
);
313 server
->dtsize
= nfs_block_size(fsinfo
.dtpref
, NULL
);
314 if (server
->dtsize
> PAGE_CACHE_SIZE
)
315 server
->dtsize
= PAGE_CACHE_SIZE
;
316 if (server
->dtsize
> server
->rsize
)
317 server
->dtsize
= server
->rsize
;
319 if (server
->flags
& NFS_MOUNT_NOAC
) {
320 server
->acregmin
= server
->acregmax
= 0;
321 server
->acdirmin
= server
->acdirmax
= 0;
322 sb
->s_flags
|= MS_SYNCHRONOUS
;
324 server
->backing_dev_info
.ra_pages
= server
->rpages
* NFS_MAX_READAHEAD
;
326 sb
->s_maxbytes
= fsinfo
.maxfilesize
;
327 if (sb
->s_maxbytes
> MAX_LFS_FILESIZE
)
328 sb
->s_maxbytes
= MAX_LFS_FILESIZE
;
330 server
->client
->cl_intr
= (server
->flags
& NFS_MOUNT_INTR
) ? 1 : 0;
331 server
->client
->cl_softrtry
= (server
->flags
& NFS_MOUNT_SOFT
) ? 1 : 0;
333 /* We're airborne Set socket buffersize */
334 rpc_setbufsize(server
->client
, server
->wsize
+ 100, server
->rsize
+ 100);
336 /* Yargs. It didn't work out. */
338 dprintk("nfs_sb_init: get root inode failed: errno %d\n", -no_root_error
);
339 if (!IS_ERR(root_inode
))
341 return no_root_error
;
345 * Create an RPC client handle.
347 static struct rpc_clnt
*
348 nfs_create_client(struct nfs_server
*server
, const struct nfs_mount_data
*data
)
350 struct rpc_timeout timeparms
;
351 struct rpc_xprt
*xprt
= NULL
;
352 struct rpc_clnt
*clnt
= NULL
;
353 int tcp
= (data
->flags
& NFS_MOUNT_TCP
);
355 /* Initialize timeout values */
356 timeparms
.to_initval
= data
->timeo
* HZ
/ 10;
357 timeparms
.to_retries
= data
->retrans
;
358 timeparms
.to_maxval
= tcp
? RPC_MAX_TCP_TIMEOUT
: RPC_MAX_UDP_TIMEOUT
;
359 timeparms
.to_exponential
= 1;
361 if (!timeparms
.to_initval
)
362 timeparms
.to_initval
= (tcp
? 600 : 11) * HZ
/ 10;
363 if (!timeparms
.to_retries
)
364 timeparms
.to_retries
= 5;
366 /* create transport and client */
367 xprt
= xprt_create_proto(tcp
? IPPROTO_TCP
: IPPROTO_UDP
,
368 &server
->addr
, &timeparms
);
370 dprintk("%s: cannot create RPC transport. Error = %ld\n",
371 __FUNCTION__
, PTR_ERR(xprt
));
372 return (struct rpc_clnt
*)xprt
;
374 clnt
= rpc_create_client(xprt
, server
->hostname
, &nfs_program
,
375 server
->rpc_ops
->version
, data
->pseudoflavor
);
377 dprintk("%s: cannot create RPC client. Error = %ld\n",
378 __FUNCTION__
, PTR_ERR(xprt
));
383 clnt
->cl_softrtry
= 1;
393 * The way this works is that the mount process passes a structure
394 * in the data argument which contains the server's IP address
395 * and the root file handle obtained from the server's mount
396 * daemon. We stash these away in the private superblock fields.
399 nfs_fill_super(struct super_block
*sb
, struct nfs_mount_data
*data
, int silent
)
401 struct nfs_server
*server
;
402 rpc_authflavor_t authflavor
;
405 sb
->s_blocksize_bits
= 0;
408 sb
->s_blocksize
= nfs_block_size(data
->bsize
, &sb
->s_blocksize_bits
);
410 server
->rsize
= nfs_block_size(data
->rsize
, NULL
);
412 server
->wsize
= nfs_block_size(data
->wsize
, NULL
);
413 server
->flags
= data
->flags
& NFS_MOUNT_FLAGMASK
;
415 server
->acregmin
= data
->acregmin
*HZ
;
416 server
->acregmax
= data
->acregmax
*HZ
;
417 server
->acdirmin
= data
->acdirmin
*HZ
;
418 server
->acdirmax
= data
->acdirmax
*HZ
;
420 /* Start lockd here, before we might error out */
421 if (!(server
->flags
& NFS_MOUNT_NONLM
))
424 server
->namelen
= data
->namlen
;
425 server
->hostname
= kmalloc(strlen(data
->hostname
) + 1, GFP_KERNEL
);
426 if (!server
->hostname
)
428 strcpy(server
->hostname
, data
->hostname
);
430 /* Check NFS protocol revision and initialize RPC op vector
431 * and file handle pool. */
433 if (server
->flags
& NFS_MOUNT_VER3
) {
434 server
->rpc_ops
= &nfs_v3_clientops
;
435 server
->caps
|= NFS_CAP_READDIRPLUS
;
437 server
->rpc_ops
= &nfs_v2_clientops
;
440 server
->rpc_ops
= &nfs_v2_clientops
;
443 /* Fill in pseudoflavor for mount version < 5 */
444 if (!(data
->flags
& NFS_MOUNT_SECFLAVOUR
))
445 data
->pseudoflavor
= RPC_AUTH_UNIX
;
446 authflavor
= data
->pseudoflavor
; /* save for sb_init() */
447 /* XXX maybe we want to add a server->pseudoflavor field */
449 /* Create RPC client handles */
450 server
->client
= nfs_create_client(server
, data
);
451 if (IS_ERR(server
->client
))
452 return PTR_ERR(server
->client
);
453 /* RFC 2623, sec 2.3.2 */
454 if (authflavor
!= RPC_AUTH_UNIX
) {
455 server
->client_sys
= rpc_clone_client(server
->client
);
456 if (IS_ERR(server
->client_sys
))
457 return PTR_ERR(server
->client_sys
);
458 if (!rpcauth_create(RPC_AUTH_UNIX
, server
->client_sys
))
461 atomic_inc(&server
->client
->cl_count
);
462 server
->client_sys
= server
->client
;
465 if (server
->flags
& NFS_MOUNT_VER3
) {
466 if (server
->namelen
== 0 || server
->namelen
> NFS3_MAXNAMLEN
)
467 server
->namelen
= NFS3_MAXNAMLEN
;
470 if (server
->namelen
== 0 || server
->namelen
> NFS2_MAXNAMLEN
)
471 server
->namelen
= NFS2_MAXNAMLEN
;
474 sb
->s_op
= &nfs_sops
;
475 return nfs_sb_init(sb
, authflavor
);
479 nfs_statfs(struct super_block
*sb
, struct kstatfs
*buf
)
481 struct nfs_server
*server
= NFS_SB(sb
);
482 unsigned char blockbits
;
483 unsigned long blockres
;
484 struct nfs_fh
*rootfh
= NFS_FH(sb
->s_root
->d_inode
);
485 struct nfs_fattr fattr
;
486 struct nfs_fsstat res
= {
493 error
= server
->rpc_ops
->statfs(server
, rootfh
, &res
);
494 buf
->f_type
= NFS_SUPER_MAGIC
;
499 * Current versions of glibc do not correctly handle the
500 * case where f_frsize != f_bsize. Eventually we want to
501 * report the value of wtmult in this field.
503 buf
->f_frsize
= sb
->s_blocksize
;
506 * On most *nix systems, f_blocks, f_bfree, and f_bavail
507 * are reported in units of f_frsize. Linux hasn't had
508 * an f_frsize field in its statfs struct until recently,
509 * thus historically Linux's sys_statfs reports these
510 * fields in units of f_bsize.
512 buf
->f_bsize
= sb
->s_blocksize
;
513 blockbits
= sb
->s_blocksize_bits
;
514 blockres
= (1 << blockbits
) - 1;
515 buf
->f_blocks
= (res
.tbytes
+ blockres
) >> blockbits
;
516 buf
->f_bfree
= (res
.fbytes
+ blockres
) >> blockbits
;
517 buf
->f_bavail
= (res
.abytes
+ blockres
) >> blockbits
;
519 buf
->f_files
= res
.tfiles
;
520 buf
->f_ffree
= res
.afiles
;
522 buf
->f_namelen
= server
->namelen
;
529 printk(KERN_WARNING
"nfs_statfs: statfs error = %d\n", -error
);
530 buf
->f_bsize
= buf
->f_blocks
= buf
->f_bfree
= buf
->f_bavail
= -1;
535 static int nfs_show_options(struct seq_file
*m
, struct vfsmount
*mnt
)
537 static struct proc_nfs_info
{
542 { NFS_MOUNT_SOFT
, ",soft", ",hard" },
543 { NFS_MOUNT_INTR
, ",intr", "" },
544 { NFS_MOUNT_POSIX
, ",posix", "" },
545 { NFS_MOUNT_TCP
, ",tcp", ",udp" },
546 { NFS_MOUNT_NOCTO
, ",nocto", "" },
547 { NFS_MOUNT_NOAC
, ",noac", "" },
548 { NFS_MOUNT_NONLM
, ",nolock", ",lock" },
551 struct proc_nfs_info
*nfs_infop
;
552 struct nfs_server
*nfss
= NFS_SB(mnt
->mnt_sb
);
554 seq_printf(m
, ",v%d", nfss
->rpc_ops
->version
);
555 seq_printf(m
, ",rsize=%d", nfss
->rsize
);
556 seq_printf(m
, ",wsize=%d", nfss
->wsize
);
557 if (nfss
->acregmin
!= 3*HZ
)
558 seq_printf(m
, ",acregmin=%d", nfss
->acregmin
/HZ
);
559 if (nfss
->acregmax
!= 60*HZ
)
560 seq_printf(m
, ",acregmax=%d", nfss
->acregmax
/HZ
);
561 if (nfss
->acdirmin
!= 30*HZ
)
562 seq_printf(m
, ",acdirmin=%d", nfss
->acdirmin
/HZ
);
563 if (nfss
->acdirmax
!= 60*HZ
)
564 seq_printf(m
, ",acdirmax=%d", nfss
->acdirmax
/HZ
);
565 for (nfs_infop
= nfs_info
; nfs_infop
->flag
; nfs_infop
++) {
566 if (nfss
->flags
& nfs_infop
->flag
)
567 seq_puts(m
, nfs_infop
->str
);
569 seq_puts(m
, nfs_infop
->nostr
);
571 seq_puts(m
, ",addr=");
572 seq_escape(m
, nfss
->hostname
, " \t\n\\");
577 * Invalidate the local caches
580 nfs_zap_caches(struct inode
*inode
)
582 struct nfs_inode
*nfsi
= NFS_I(inode
);
583 int mode
= inode
->i_mode
;
585 NFS_ATTRTIMEO(inode
) = NFS_MINATTRTIMEO(inode
);
586 NFS_ATTRTIMEO_UPDATE(inode
) = jiffies
;
588 memset(NFS_COOKIEVERF(inode
), 0, sizeof(NFS_COOKIEVERF(inode
)));
589 if (S_ISREG(mode
) || S_ISDIR(mode
) || S_ISLNK(mode
))
590 nfsi
->flags
|= NFS_INO_INVALID_ATTR
|NFS_INO_INVALID_DATA
|NFS_INO_INVALID_ACCESS
;
592 nfsi
->flags
|= NFS_INO_INVALID_ATTR
|NFS_INO_INVALID_ACCESS
;
596 * Invalidate, but do not unhash, the inode
599 nfs_invalidate_inode(struct inode
*inode
)
601 umode_t save_mode
= inode
->i_mode
;
603 make_bad_inode(inode
);
604 inode
->i_mode
= save_mode
;
605 nfs_zap_caches(inode
);
608 struct nfs_find_desc
{
610 struct nfs_fattr
*fattr
;
614 * In NFSv3 we can have 64bit inode numbers. In order to support
615 * this, and re-exported directories (also seen in NFSv2)
616 * we are forced to allow 2 different inodes to have the same
620 nfs_find_actor(struct inode
*inode
, void *opaque
)
622 struct nfs_find_desc
*desc
= (struct nfs_find_desc
*)opaque
;
623 struct nfs_fh
*fh
= desc
->fh
;
624 struct nfs_fattr
*fattr
= desc
->fattr
;
626 if (NFS_FILEID(inode
) != fattr
->fileid
)
628 if (nfs_compare_fh(NFS_FH(inode
), fh
))
630 if (is_bad_inode(inode
) || NFS_STALE(inode
))
636 nfs_init_locked(struct inode
*inode
, void *opaque
)
638 struct nfs_find_desc
*desc
= (struct nfs_find_desc
*)opaque
;
639 struct nfs_fattr
*fattr
= desc
->fattr
;
641 NFS_FILEID(inode
) = fattr
->fileid
;
642 nfs_copy_fh(NFS_FH(inode
), desc
->fh
);
646 /* Don't use READDIRPLUS on directories that we believe are too large */
647 #define NFS_LIMIT_READDIRPLUS (8*PAGE_SIZE)
650 * This is our front-end to iget that looks up inodes by file handle
651 * instead of inode number.
654 nfs_fhget(struct super_block
*sb
, struct nfs_fh
*fh
, struct nfs_fattr
*fattr
)
656 struct nfs_find_desc desc
= {
660 struct inode
*inode
= NULL
;
663 if ((fattr
->valid
& NFS_ATTR_FATTR
) == 0)
667 printk("NFS: Buggy server - nlink == 0!\n");
671 hash
= nfs_fattr_to_ino_t(fattr
);
673 if (!(inode
= iget5_locked(sb
, hash
, nfs_find_actor
, nfs_init_locked
, &desc
)))
676 if (inode
->i_state
& I_NEW
) {
677 struct nfs_inode
*nfsi
= NFS_I(inode
);
679 /* We set i_ino for the few things that still rely on it,
683 /* We can't support update_atime(), since the server will reset it */
684 inode
->i_flags
|= S_NOATIME
|S_NOCMTIME
;
685 inode
->i_mode
= fattr
->mode
;
686 /* Why so? Because we want revalidate for devices/FIFOs, and
687 * that's precisely what we have in nfs_file_inode_operations.
689 inode
->i_op
= &nfs_file_inode_operations
;
690 if (S_ISREG(inode
->i_mode
)) {
691 inode
->i_fop
= &nfs_file_operations
;
692 inode
->i_data
.a_ops
= &nfs_file_aops
;
693 inode
->i_data
.backing_dev_info
= &NFS_SB(sb
)->backing_dev_info
;
694 } else if (S_ISDIR(inode
->i_mode
)) {
695 inode
->i_op
= NFS_SB(sb
)->rpc_ops
->dir_inode_ops
;
696 inode
->i_fop
= &nfs_dir_operations
;
697 if (nfs_server_capable(inode
, NFS_CAP_READDIRPLUS
)
698 && fattr
->size
<= NFS_LIMIT_READDIRPLUS
)
699 NFS_FLAGS(inode
) |= NFS_INO_ADVISE_RDPLUS
;
700 } else if (S_ISLNK(inode
->i_mode
))
701 inode
->i_op
= &nfs_symlink_inode_operations
;
703 init_special_inode(inode
, inode
->i_mode
, fattr
->rdev
);
705 nfsi
->read_cache_jiffies
= fattr
->timestamp
;
706 inode
->i_atime
= fattr
->atime
;
707 inode
->i_mtime
= fattr
->mtime
;
708 inode
->i_ctime
= fattr
->ctime
;
709 if (fattr
->valid
& NFS_ATTR_FATTR_V4
)
710 nfsi
->change_attr
= fattr
->change_attr
;
711 inode
->i_size
= nfs_size_to_loff_t(fattr
->size
);
712 inode
->i_nlink
= fattr
->nlink
;
713 inode
->i_uid
= fattr
->uid
;
714 inode
->i_gid
= fattr
->gid
;
715 if (fattr
->valid
& (NFS_ATTR_FATTR_V3
| NFS_ATTR_FATTR_V4
)) {
717 * report the blocks in 512byte units
719 inode
->i_blocks
= nfs_calc_block_size(fattr
->du
.nfs3
.used
);
720 inode
->i_blksize
= inode
->i_sb
->s_blocksize
;
722 inode
->i_blocks
= fattr
->du
.nfs2
.blocks
;
723 inode
->i_blksize
= fattr
->du
.nfs2
.blocksize
;
725 nfsi
->attrtimeo
= NFS_MINATTRTIMEO(inode
);
726 nfsi
->attrtimeo_timestamp
= jiffies
;
727 memset(nfsi
->cookieverf
, 0, sizeof(nfsi
->cookieverf
));
728 nfsi
->cache_access
.cred
= NULL
;
730 unlock_new_inode(inode
);
732 nfs_refresh_inode(inode
, fattr
);
733 dprintk("NFS: nfs_fhget(%s/%Ld ct=%d)\n",
735 (long long)NFS_FILEID(inode
),
736 atomic_read(&inode
->i_count
));
742 printk("nfs_fhget: iget failed\n");
746 #define NFS_VALID_ATTRS (ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_SIZE|ATTR_ATIME|ATTR_ATIME_SET|ATTR_MTIME|ATTR_MTIME_SET)
749 nfs_setattr(struct dentry
*dentry
, struct iattr
*attr
)
751 struct inode
*inode
= dentry
->d_inode
;
752 struct nfs_fattr fattr
;
755 if (attr
->ia_valid
& ATTR_SIZE
) {
756 if (!S_ISREG(inode
->i_mode
) || attr
->ia_size
== i_size_read(inode
))
757 attr
->ia_valid
&= ~ATTR_SIZE
;
760 /* Optimization: if the end result is no change, don't RPC */
761 attr
->ia_valid
&= NFS_VALID_ATTRS
;
762 if (attr
->ia_valid
== 0)
766 nfs_begin_data_update(inode
);
767 /* Write all dirty data if we're changing file permissions or size */
768 if ((attr
->ia_valid
& (ATTR_MODE
|ATTR_UID
|ATTR_GID
|ATTR_SIZE
)) != 0) {
769 if (filemap_fdatawrite(inode
->i_mapping
) == 0)
770 filemap_fdatawait(inode
->i_mapping
);
773 error
= NFS_PROTO(inode
)->setattr(dentry
, &fattr
, attr
);
775 nfs_refresh_inode(inode
, &fattr
);
776 if ((attr
->ia_valid
& ATTR_MODE
) != 0) {
778 mode
= inode
->i_mode
& ~S_IALLUGO
;
779 mode
|= attr
->ia_mode
& S_IALLUGO
;
780 inode
->i_mode
= mode
;
782 if ((attr
->ia_valid
& ATTR_UID
) != 0)
783 inode
->i_uid
= attr
->ia_uid
;
784 if ((attr
->ia_valid
& ATTR_GID
) != 0)
785 inode
->i_gid
= attr
->ia_gid
;
786 if ((attr
->ia_valid
& ATTR_SIZE
) != 0) {
787 inode
->i_size
= attr
->ia_size
;
788 vmtruncate(inode
, attr
->ia_size
);
791 if ((attr
->ia_valid
& (ATTR_MODE
|ATTR_UID
|ATTR_GID
)) != 0)
792 NFS_FLAGS(inode
) |= NFS_INO_INVALID_ACCESS
;
793 nfs_end_data_update(inode
);
799 * Wait for the inode to get unlocked.
800 * (Used for NFS_INO_LOCKED and NFS_INO_REVALIDATING).
803 nfs_wait_on_inode(struct inode
*inode
, int flag
)
805 struct rpc_clnt
*clnt
= NFS_CLIENT(inode
);
806 struct nfs_inode
*nfsi
= NFS_I(inode
);
809 if (!(NFS_FLAGS(inode
) & flag
))
811 atomic_inc(&inode
->i_count
);
812 error
= nfs_wait_event(clnt
, nfsi
->nfs_i_wait
,
813 !(NFS_FLAGS(inode
) & flag
));
818 int nfs_getattr(struct vfsmount
*mnt
, struct dentry
*dentry
, struct kstat
*stat
)
820 struct inode
*inode
= dentry
->d_inode
;
821 struct nfs_inode
*nfsi
= NFS_I(inode
);
822 int need_atime
= nfsi
->flags
& NFS_INO_INVALID_ATIME
;
825 if (__IS_FLG(inode
, MS_NOATIME
))
827 else if (__IS_FLG(inode
, MS_NODIRATIME
) && S_ISDIR(inode
->i_mode
))
829 /* We may force a getattr if the user cares about atime */
831 err
= __nfs_revalidate_inode(NFS_SERVER(inode
), inode
);
833 err
= nfs_revalidate_inode(NFS_SERVER(inode
), inode
);
835 generic_fillattr(inode
, stat
);
839 struct nfs_open_context
*alloc_nfs_open_context(struct dentry
*dentry
, struct rpc_cred
*cred
)
841 struct nfs_open_context
*ctx
;
843 ctx
= (struct nfs_open_context
*)kmalloc(sizeof(*ctx
), GFP_KERNEL
);
845 atomic_set(&ctx
->count
, 1);
846 ctx
->dentry
= dget(dentry
);
847 ctx
->cred
= get_rpccred(cred
);
849 ctx
->lockowner
= current
->files
;
855 struct nfs_open_context
*get_nfs_open_context(struct nfs_open_context
*ctx
)
858 atomic_inc(&ctx
->count
);
862 void put_nfs_open_context(struct nfs_open_context
*ctx
)
864 if (atomic_dec_and_test(&ctx
->count
)) {
865 if (!list_empty(&ctx
->list
)) {
866 struct inode
*inode
= ctx
->dentry
->d_inode
;
867 spin_lock(&inode
->i_lock
);
868 list_del(&ctx
->list
);
869 spin_unlock(&inode
->i_lock
);
871 if (ctx
->state
!= NULL
)
872 nfs4_close_state(ctx
->state
, ctx
->mode
);
873 if (ctx
->cred
!= NULL
)
874 put_rpccred(ctx
->cred
);
881 * Ensure that mmap has a recent RPC credential for use when writing out
884 void nfs_file_set_open_context(struct file
*filp
, struct nfs_open_context
*ctx
)
886 struct inode
*inode
= filp
->f_dentry
->d_inode
;
887 struct nfs_inode
*nfsi
= NFS_I(inode
);
889 filp
->private_data
= get_nfs_open_context(ctx
);
890 spin_lock(&inode
->i_lock
);
891 list_add(&ctx
->list
, &nfsi
->open_files
);
892 spin_unlock(&inode
->i_lock
);
895 struct nfs_open_context
*nfs_find_open_context(struct inode
*inode
, int mode
)
897 struct nfs_inode
*nfsi
= NFS_I(inode
);
898 struct nfs_open_context
*pos
, *ctx
= NULL
;
900 spin_lock(&inode
->i_lock
);
901 list_for_each_entry(pos
, &nfsi
->open_files
, list
) {
902 if ((pos
->mode
& mode
) == mode
) {
903 ctx
= get_nfs_open_context(pos
);
907 spin_unlock(&inode
->i_lock
);
911 void nfs_file_clear_open_context(struct file
*filp
)
913 struct inode
*inode
= filp
->f_dentry
->d_inode
;
914 struct nfs_open_context
*ctx
= (struct nfs_open_context
*)filp
->private_data
;
917 filp
->private_data
= NULL
;
918 spin_lock(&inode
->i_lock
);
919 list_move_tail(&ctx
->list
, &NFS_I(inode
)->open_files
);
920 spin_unlock(&inode
->i_lock
);
921 put_nfs_open_context(ctx
);
926 * These allocate and release file read/write context information.
928 int nfs_open(struct inode
*inode
, struct file
*filp
)
930 struct nfs_open_context
*ctx
;
931 struct rpc_cred
*cred
;
933 cred
= rpcauth_lookupcred(NFS_CLIENT(inode
)->cl_auth
, 0);
935 return PTR_ERR(cred
);
936 ctx
= alloc_nfs_open_context(filp
->f_dentry
, cred
);
940 ctx
->mode
= filp
->f_mode
;
941 nfs_file_set_open_context(filp
, ctx
);
942 put_nfs_open_context(ctx
);
943 if ((filp
->f_mode
& FMODE_WRITE
) != 0)
944 nfs_begin_data_update(inode
);
948 int nfs_release(struct inode
*inode
, struct file
*filp
)
950 if ((filp
->f_mode
& FMODE_WRITE
) != 0)
951 nfs_end_data_update(inode
);
952 nfs_file_clear_open_context(filp
);
957 * This function is called whenever some part of NFS notices that
958 * the cached attributes have to be refreshed.
961 __nfs_revalidate_inode(struct nfs_server
*server
, struct inode
*inode
)
963 int status
= -ESTALE
;
964 struct nfs_fattr fattr
;
965 struct nfs_inode
*nfsi
= NFS_I(inode
);
966 unsigned long verifier
;
969 dfprintk(PAGECACHE
, "NFS: revalidating (%s/%Ld)\n",
970 inode
->i_sb
->s_id
, (long long)NFS_FILEID(inode
));
973 if (!inode
|| is_bad_inode(inode
))
975 if (NFS_STALE(inode
))
978 while (NFS_REVALIDATING(inode
)) {
979 status
= nfs_wait_on_inode(inode
, NFS_INO_REVALIDATING
);
982 if (NFS_ATTRTIMEO(inode
) == 0)
984 if (NFS_FLAGS(inode
) & (NFS_INO_INVALID_ATTR
|NFS_INO_INVALID_DATA
|NFS_INO_INVALID_ATIME
))
986 status
= NFS_STALE(inode
) ? -ESTALE
: 0;
989 NFS_FLAGS(inode
) |= NFS_INO_REVALIDATING
;
991 /* Protect against RPC races by saving the change attribute */
992 verifier
= nfs_save_change_attribute(inode
);
993 status
= NFS_PROTO(inode
)->getattr(server
, NFS_FH(inode
), &fattr
);
995 dfprintk(PAGECACHE
, "nfs_revalidate_inode: (%s/%Ld) getattr failed, error=%d\n",
997 (long long)NFS_FILEID(inode
), status
);
998 if (status
== -ESTALE
) {
999 nfs_zap_caches(inode
);
1000 if (!S_ISDIR(inode
->i_mode
))
1001 NFS_FLAGS(inode
) |= NFS_INO_STALE
;
1006 status
= nfs_update_inode(inode
, &fattr
, verifier
);
1008 dfprintk(PAGECACHE
, "nfs_revalidate_inode: (%s/%Ld) refresh failed, error=%d\n",
1010 (long long)NFS_FILEID(inode
), status
);
1013 flags
= nfsi
->flags
;
1015 * We may need to keep the attributes marked as invalid if
1016 * we raced with nfs_end_attr_update().
1018 if (verifier
== nfsi
->cache_change_attribute
)
1019 nfsi
->flags
&= ~(NFS_INO_INVALID_ATTR
|NFS_INO_INVALID_ATIME
);
1020 /* Do the page cache invalidation */
1021 if (flags
& NFS_INO_INVALID_DATA
) {
1022 if (S_ISREG(inode
->i_mode
)) {
1023 if (filemap_fdatawrite(inode
->i_mapping
) == 0)
1024 filemap_fdatawait(inode
->i_mapping
);
1027 nfsi
->flags
&= ~NFS_INO_INVALID_DATA
;
1028 invalidate_inode_pages2(inode
->i_mapping
);
1029 memset(NFS_COOKIEVERF(inode
), 0, sizeof(NFS_COOKIEVERF(inode
)));
1030 dfprintk(PAGECACHE
, "NFS: (%s/%Ld) data cache invalidated\n",
1032 (long long)NFS_FILEID(inode
));
1033 /* This ensures we revalidate dentries */
1034 nfsi
->cache_change_attribute
++;
1036 dfprintk(PAGECACHE
, "NFS: (%s/%Ld) revalidation complete\n",
1038 (long long)NFS_FILEID(inode
));
1041 NFS_FLAGS(inode
) &= ~NFS_INO_REVALIDATING
;
1042 wake_up(&nfsi
->nfs_i_wait
);
1048 int nfs_attribute_timeout(struct inode
*inode
)
1050 struct nfs_inode
*nfsi
= NFS_I(inode
);
1052 if (nfs_have_delegation(inode
, FMODE_READ
))
1054 return time_after(jiffies
, nfsi
->read_cache_jiffies
+nfsi
->attrtimeo
);
1058 * nfs_revalidate_inode - Revalidate the inode attributes
1059 * @server - pointer to nfs_server struct
1060 * @inode - pointer to inode struct
1062 * Updates inode attribute information by retrieving the data from the server.
1064 int nfs_revalidate_inode(struct nfs_server
*server
, struct inode
*inode
)
1066 if (!(NFS_FLAGS(inode
) & (NFS_INO_INVALID_ATTR
|NFS_INO_INVALID_DATA
))
1067 && !nfs_attribute_timeout(inode
))
1068 return NFS_STALE(inode
) ? -ESTALE
: 0;
1069 return __nfs_revalidate_inode(server
, inode
);
1073 * nfs_begin_data_update
1074 * @inode - pointer to inode
1075 * Declare that a set of operations will update file data on the server
1077 void nfs_begin_data_update(struct inode
*inode
)
1079 atomic_inc(&NFS_I(inode
)->data_updates
);
1083 * nfs_end_data_update
1084 * @inode - pointer to inode
1085 * Declare end of the operations that will update file data
1086 * This will mark the inode as immediately needing revalidation
1087 * of its attribute cache.
1089 void nfs_end_data_update(struct inode
*inode
)
1091 struct nfs_inode
*nfsi
= NFS_I(inode
);
1093 if (!nfs_have_delegation(inode
, FMODE_READ
)) {
1094 /* Mark the attribute cache for revalidation */
1095 nfsi
->flags
|= NFS_INO_INVALID_ATTR
;
1096 /* Directories and symlinks: invalidate page cache too */
1097 if (S_ISDIR(inode
->i_mode
) || S_ISLNK(inode
->i_mode
))
1098 nfsi
->flags
|= NFS_INO_INVALID_DATA
;
1100 nfsi
->cache_change_attribute
++;
1101 atomic_dec(&nfsi
->data_updates
);
1105 * nfs_end_data_update_defer
1106 * @inode - pointer to inode
1107 * Declare end of the operations that will update file data
1108 * This will defer marking the inode as needing revalidation
1109 * unless there are no other pending updates.
1111 void nfs_end_data_update_defer(struct inode
*inode
)
1113 struct nfs_inode
*nfsi
= NFS_I(inode
);
1115 if (atomic_dec_and_test(&nfsi
->data_updates
)) {
1116 /* Mark the attribute cache for revalidation */
1117 nfsi
->flags
|= NFS_INO_INVALID_ATTR
;
1118 /* Directories and symlinks: invalidate page cache too */
1119 if (S_ISDIR(inode
->i_mode
) || S_ISLNK(inode
->i_mode
))
1120 nfsi
->flags
|= NFS_INO_INVALID_DATA
;
1121 nfsi
->cache_change_attribute
++;
1126 * nfs_refresh_inode - verify consistency of the inode attribute cache
1127 * @inode - pointer to inode
1128 * @fattr - updated attributes
1130 * Verifies the attribute cache. If we have just changed the attributes,
1131 * so that fattr carries weak cache consistency data, then it may
1132 * also update the ctime/mtime/change_attribute.
1134 int nfs_refresh_inode(struct inode
*inode
, struct nfs_fattr
*fattr
)
1136 struct nfs_inode
*nfsi
= NFS_I(inode
);
1137 loff_t cur_size
, new_isize
;
1140 /* Do we hold a delegation? */
1141 if (nfs_have_delegation(inode
, FMODE_READ
))
1144 /* Are we in the process of updating data on the server? */
1145 data_unstable
= nfs_caches_unstable(inode
);
1147 if (fattr
->valid
& NFS_ATTR_FATTR_V4
) {
1148 if ((fattr
->valid
& NFS_ATTR_PRE_CHANGE
) != 0
1149 && nfsi
->change_attr
== fattr
->pre_change_attr
)
1150 nfsi
->change_attr
= fattr
->change_attr
;
1151 if (!data_unstable
&& nfsi
->change_attr
!= fattr
->change_attr
)
1152 nfsi
->flags
|= NFS_INO_INVALID_ATTR
;
1155 if ((fattr
->valid
& NFS_ATTR_FATTR
) == 0)
1158 /* Has the inode gone and changed behind our back? */
1159 if (nfsi
->fileid
!= fattr
->fileid
1160 || (inode
->i_mode
& S_IFMT
) != (fattr
->mode
& S_IFMT
))
1163 cur_size
= i_size_read(inode
);
1164 new_isize
= nfs_size_to_loff_t(fattr
->size
);
1166 /* If we have atomic WCC data, we may update some attributes */
1167 if ((fattr
->valid
& NFS_ATTR_WCC
) != 0) {
1168 if (timespec_equal(&inode
->i_ctime
, &fattr
->pre_ctime
))
1169 memcpy(&inode
->i_ctime
, &fattr
->ctime
, sizeof(inode
->i_ctime
));
1170 if (timespec_equal(&inode
->i_mtime
, &fattr
->pre_mtime
))
1171 memcpy(&inode
->i_mtime
, &fattr
->mtime
, sizeof(inode
->i_mtime
));
1174 /* Verify a few of the more important attributes */
1175 if (!data_unstable
) {
1176 if (!timespec_equal(&inode
->i_mtime
, &fattr
->mtime
)
1177 || cur_size
!= new_isize
)
1178 nfsi
->flags
|= NFS_INO_INVALID_ATTR
;
1179 } else if (S_ISREG(inode
->i_mode
) && new_isize
> cur_size
)
1180 nfsi
->flags
|= NFS_INO_INVALID_ATTR
;
1182 /* Have any file permissions changed? */
1183 if ((inode
->i_mode
& S_IALLUGO
) != (fattr
->mode
& S_IALLUGO
)
1184 || inode
->i_uid
!= fattr
->uid
1185 || inode
->i_gid
!= fattr
->gid
)
1186 nfsi
->flags
|= NFS_INO_INVALID_ATTR
| NFS_INO_INVALID_ACCESS
;
1188 /* Has the link count changed? */
1189 if (inode
->i_nlink
!= fattr
->nlink
)
1190 nfsi
->flags
|= NFS_INO_INVALID_ATTR
;
1192 if (!timespec_equal(&inode
->i_atime
, &fattr
->atime
))
1193 nfsi
->flags
|= NFS_INO_INVALID_ATIME
;
1195 nfsi
->read_cache_jiffies
= fattr
->timestamp
;
1200 * Many nfs protocol calls return the new file attributes after
1201 * an operation. Here we update the inode to reflect the state
1202 * of the server's inode.
1204 * This is a bit tricky because we have to make sure all dirty pages
1205 * have been sent off to the server before calling invalidate_inode_pages.
1206 * To make sure no other process adds more write requests while we try
1207 * our best to flush them, we make them sleep during the attribute refresh.
1209 * A very similar scenario holds for the dir cache.
1211 static int nfs_update_inode(struct inode
*inode
, struct nfs_fattr
*fattr
, unsigned long verifier
)
1213 struct nfs_inode
*nfsi
= NFS_I(inode
);
1216 unsigned int invalid
= 0;
1220 dfprintk(VFS
, "NFS: %s(%s/%ld ct=%d info=0x%x)\n",
1221 __FUNCTION__
, inode
->i_sb
->s_id
, inode
->i_ino
,
1222 atomic_read(&inode
->i_count
), fattr
->valid
);
1224 if ((fattr
->valid
& NFS_ATTR_FATTR
) == 0)
1227 if (nfsi
->fileid
!= fattr
->fileid
) {
1228 printk(KERN_ERR
"%s: inode number mismatch\n"
1229 "expected (%s/0x%Lx), got (%s/0x%Lx)\n",
1231 inode
->i_sb
->s_id
, (long long)nfsi
->fileid
,
1232 inode
->i_sb
->s_id
, (long long)fattr
->fileid
);
1237 * Make sure the inode's type hasn't changed.
1239 if ((inode
->i_mode
& S_IFMT
) != (fattr
->mode
& S_IFMT
))
1243 * Update the read time so we don't revalidate too often.
1245 nfsi
->read_cache_jiffies
= fattr
->timestamp
;
1247 /* Are we racing with known updates of the metadata on the server? */
1248 data_unstable
= ! nfs_verify_change_attribute(inode
, verifier
);
1250 /* Check if the file size agrees */
1251 new_size
= fattr
->size
;
1252 new_isize
= nfs_size_to_loff_t(fattr
->size
);
1253 cur_isize
= i_size_read(inode
);
1254 if (cur_isize
!= new_size
) {
1255 #ifdef NFS_DEBUG_VERBOSE
1256 printk(KERN_DEBUG
"NFS: isize change on %s/%ld\n", inode
->i_sb
->s_id
, inode
->i_ino
);
1259 * If we have pending writebacks, things can get
1262 if (S_ISREG(inode
->i_mode
) && data_unstable
) {
1263 if (new_isize
> cur_isize
) {
1264 inode
->i_size
= new_isize
;
1265 invalid
|= NFS_INO_INVALID_ATTR
|NFS_INO_INVALID_DATA
;
1268 inode
->i_size
= new_isize
;
1269 invalid
|= NFS_INO_INVALID_ATTR
|NFS_INO_INVALID_DATA
;
1274 * Note: we don't check inode->i_mtime since pipes etc.
1275 * can change this value in VFS without requiring a
1276 * cache revalidation.
1278 if (!timespec_equal(&inode
->i_mtime
, &fattr
->mtime
)) {
1279 memcpy(&inode
->i_mtime
, &fattr
->mtime
, sizeof(inode
->i_mtime
));
1280 #ifdef NFS_DEBUG_VERBOSE
1281 printk(KERN_DEBUG
"NFS: mtime change on %s/%ld\n", inode
->i_sb
->s_id
, inode
->i_ino
);
1284 invalid
|= NFS_INO_INVALID_ATTR
|NFS_INO_INVALID_DATA
;
1287 if ((fattr
->valid
& NFS_ATTR_FATTR_V4
)
1288 && nfsi
->change_attr
!= fattr
->change_attr
) {
1289 #ifdef NFS_DEBUG_VERBOSE
1290 printk(KERN_DEBUG
"NFS: change_attr change on %s/%ld\n",
1291 inode
->i_sb
->s_id
, inode
->i_ino
);
1293 nfsi
->change_attr
= fattr
->change_attr
;
1295 invalid
|= NFS_INO_INVALID_ATTR
|NFS_INO_INVALID_DATA
|NFS_INO_INVALID_ACCESS
;
1298 memcpy(&inode
->i_ctime
, &fattr
->ctime
, sizeof(inode
->i_ctime
));
1299 memcpy(&inode
->i_atime
, &fattr
->atime
, sizeof(inode
->i_atime
));
1301 if ((inode
->i_mode
& S_IALLUGO
) != (fattr
->mode
& S_IALLUGO
) ||
1302 inode
->i_uid
!= fattr
->uid
||
1303 inode
->i_gid
!= fattr
->gid
)
1304 invalid
|= NFS_INO_INVALID_ATTR
|NFS_INO_INVALID_ACCESS
;
1306 inode
->i_mode
= fattr
->mode
;
1307 inode
->i_nlink
= fattr
->nlink
;
1308 inode
->i_uid
= fattr
->uid
;
1309 inode
->i_gid
= fattr
->gid
;
1311 if (fattr
->valid
& (NFS_ATTR_FATTR_V3
| NFS_ATTR_FATTR_V4
)) {
1313 * report the blocks in 512byte units
1315 inode
->i_blocks
= nfs_calc_block_size(fattr
->du
.nfs3
.used
);
1316 inode
->i_blksize
= inode
->i_sb
->s_blocksize
;
1318 inode
->i_blocks
= fattr
->du
.nfs2
.blocks
;
1319 inode
->i_blksize
= fattr
->du
.nfs2
.blocksize
;
1322 /* Update attrtimeo value if we're out of the unstable period */
1323 if (invalid
& NFS_INO_INVALID_ATTR
) {
1324 nfsi
->attrtimeo
= NFS_MINATTRTIMEO(inode
);
1325 nfsi
->attrtimeo_timestamp
= jiffies
;
1326 } else if (time_after(jiffies
, nfsi
->attrtimeo_timestamp
+nfsi
->attrtimeo
)) {
1327 if ((nfsi
->attrtimeo
<<= 1) > NFS_MAXATTRTIMEO(inode
))
1328 nfsi
->attrtimeo
= NFS_MAXATTRTIMEO(inode
);
1329 nfsi
->attrtimeo_timestamp
= jiffies
;
1331 /* Don't invalidate the data if we were to blame */
1332 if (!(S_ISREG(inode
->i_mode
) || S_ISDIR(inode
->i_mode
)
1333 || S_ISLNK(inode
->i_mode
)))
1334 invalid
&= ~NFS_INO_INVALID_DATA
;
1335 if (!nfs_have_delegation(inode
, FMODE_READ
))
1336 nfsi
->flags
|= invalid
;
1341 * Big trouble! The inode has become a different object.
1344 printk(KERN_DEBUG
"%s: inode %ld mode changed, %07o to %07o\n",
1345 __FUNCTION__
, inode
->i_ino
, inode
->i_mode
, fattr
->mode
);
1348 * No need to worry about unhashing the dentry, as the
1349 * lookup validation will know that the inode is bad.
1350 * (But we fall through to invalidate the caches.)
1352 nfs_invalidate_inode(inode
);
1354 NFS_FLAGS(inode
) |= NFS_INO_STALE
;
1359 * File system information
1362 static int nfs_set_super(struct super_block
*s
, void *data
)
1364 s
->s_fs_info
= data
;
1365 return set_anon_super(s
, data
);
1368 static int nfs_compare_super(struct super_block
*sb
, void *data
)
1370 struct nfs_server
*server
= data
;
1371 struct nfs_server
*old
= NFS_SB(sb
);
1373 if (old
->addr
.sin_addr
.s_addr
!= server
->addr
.sin_addr
.s_addr
)
1375 if (old
->addr
.sin_port
!= server
->addr
.sin_port
)
1377 return !nfs_compare_fh(&old
->fh
, &server
->fh
);
1380 static struct super_block
*nfs_get_sb(struct file_system_type
*fs_type
,
1381 int flags
, const char *dev_name
, void *raw_data
)
1384 struct nfs_server
*server
= NULL
;
1385 struct super_block
*s
;
1386 struct nfs_fh
*root
;
1387 struct nfs_mount_data
*data
= raw_data
;
1389 s
= ERR_PTR(-EINVAL
);
1391 dprintk("%s: missing data argument\n", __FUNCTION__
);
1394 if (data
->version
<= 0 || data
->version
> NFS_MOUNT_VERSION
) {
1395 dprintk("%s: bad mount version\n", __FUNCTION__
);
1398 switch (data
->version
) {
1404 if (data
->flags
& NFS_MOUNT_VER3
) {
1405 dprintk("%s: mount structure version %d does not support NFSv3\n",
1410 data
->root
.size
= NFS2_FHSIZE
;
1411 memcpy(data
->root
.data
, data
->old_root
.data
, NFS2_FHSIZE
);
1413 if (data
->flags
& NFS_MOUNT_SECFLAVOUR
) {
1414 dprintk("%s: mount structure version %d does not support strong security\n",
1420 memset(data
->context
, 0, sizeof(data
->context
));
1422 #ifndef CONFIG_NFS_V3
1423 /* If NFSv3 is not compiled in, return -EPROTONOSUPPORT */
1424 s
= ERR_PTR(-EPROTONOSUPPORT
);
1425 if (data
->flags
& NFS_MOUNT_VER3
) {
1426 dprintk("%s: NFSv3 not compiled into kernel\n", __FUNCTION__
);
1429 #endif /* CONFIG_NFS_V3 */
1431 s
= ERR_PTR(-ENOMEM
);
1432 server
= kmalloc(sizeof(struct nfs_server
), GFP_KERNEL
);
1435 memset(server
, 0, sizeof(struct nfs_server
));
1436 /* Zero out the NFS state stuff */
1437 init_nfsv4_state(server
);
1440 if (data
->flags
& NFS_MOUNT_VER3
)
1441 root
->size
= data
->root
.size
;
1443 root
->size
= NFS2_FHSIZE
;
1444 s
= ERR_PTR(-EINVAL
);
1445 if (root
->size
> sizeof(root
->data
)) {
1446 dprintk("%s: invalid root filehandle\n", __FUNCTION__
);
1449 memcpy(root
->data
, data
->root
.data
, root
->size
);
1451 /* We now require that the mount process passes the remote address */
1452 memcpy(&server
->addr
, &data
->addr
, sizeof(server
->addr
));
1453 if (server
->addr
.sin_addr
.s_addr
== INADDR_ANY
) {
1454 dprintk("%s: mount program didn't pass remote address!\n",
1459 /* Fire up rpciod if not yet running */
1460 s
= ERR_PTR(rpciod_up());
1462 dprintk("%s: couldn't start rpciod! Error = %ld\n",
1463 __FUNCTION__
, PTR_ERR(s
));
1467 s
= sget(fs_type
, nfs_compare_super
, nfs_set_super
, server
);
1468 if (IS_ERR(s
) || s
->s_root
)
1469 goto out_rpciod_down
;
1473 error
= nfs_fill_super(s
, data
, flags
& MS_VERBOSE
? 1 : 0);
1475 up_write(&s
->s_umount
);
1476 deactivate_super(s
);
1477 return ERR_PTR(error
);
1479 s
->s_flags
|= MS_ACTIVE
;
1488 static void nfs_kill_super(struct super_block
*s
)
1490 struct nfs_server
*server
= NFS_SB(s
);
1494 if (server
->client
!= NULL
&& !IS_ERR(server
->client
))
1495 rpc_shutdown_client(server
->client
);
1496 if (server
->client_sys
!= NULL
&& !IS_ERR(server
->client_sys
))
1497 rpc_shutdown_client(server
->client_sys
);
1499 if (!(server
->flags
& NFS_MOUNT_NONLM
))
1500 lockd_down(); /* release rpc.lockd */
1502 rpciod_down(); /* release rpciod */
1504 if (server
->hostname
!= NULL
)
1505 kfree(server
->hostname
);
1509 static struct file_system_type nfs_fs_type
= {
1510 .owner
= THIS_MODULE
,
1512 .get_sb
= nfs_get_sb
,
1513 .kill_sb
= nfs_kill_super
,
1514 .fs_flags
= FS_ODD_RENAME
|FS_REVAL_DOT
|FS_BINARY_MOUNTDATA
,
1517 #ifdef CONFIG_NFS_V4
1519 static void nfs4_clear_inode(struct inode
*);
1522 static struct super_operations nfs4_sops
= {
1523 .alloc_inode
= nfs_alloc_inode
,
1524 .destroy_inode
= nfs_destroy_inode
,
1525 .write_inode
= nfs_write_inode
,
1526 .delete_inode
= nfs_delete_inode
,
1527 .statfs
= nfs_statfs
,
1528 .clear_inode
= nfs4_clear_inode
,
1529 .umount_begin
= nfs_umount_begin
,
1530 .show_options
= nfs_show_options
,
1534 * Clean out any remaining NFSv4 state that might be left over due
1535 * to open() calls that passed nfs_atomic_lookup, but failed to call
1538 static void nfs4_clear_inode(struct inode
*inode
)
1540 struct nfs_inode
*nfsi
= NFS_I(inode
);
1542 /* If we are holding a delegation, return it! */
1543 if (nfsi
->delegation
!= NULL
)
1544 nfs_inode_return_delegation(inode
);
1545 /* First call standard NFS clear_inode() code */
1546 nfs_clear_inode(inode
);
1547 /* Now clear out any remaining state */
1548 while (!list_empty(&nfsi
->open_states
)) {
1549 struct nfs4_state
*state
;
1551 state
= list_entry(nfsi
->open_states
.next
,
1554 dprintk("%s(%s/%Ld): found unclaimed NFSv4 state %p\n",
1557 (long long)NFS_FILEID(inode
),
1559 BUG_ON(atomic_read(&state
->count
) != 1);
1560 nfs4_close_state(state
, state
->state
);
1565 static int nfs4_fill_super(struct super_block
*sb
, struct nfs4_mount_data
*data
, int silent
)
1567 struct nfs_server
*server
;
1568 struct nfs4_client
*clp
= NULL
;
1569 struct rpc_xprt
*xprt
= NULL
;
1570 struct rpc_clnt
*clnt
= NULL
;
1571 struct rpc_timeout timeparms
;
1572 rpc_authflavor_t authflavour
;
1573 int proto
, err
= -EIO
;
1575 sb
->s_blocksize_bits
= 0;
1576 sb
->s_blocksize
= 0;
1577 server
= NFS_SB(sb
);
1578 if (data
->rsize
!= 0)
1579 server
->rsize
= nfs_block_size(data
->rsize
, NULL
);
1580 if (data
->wsize
!= 0)
1581 server
->wsize
= nfs_block_size(data
->wsize
, NULL
);
1582 server
->flags
= data
->flags
& NFS_MOUNT_FLAGMASK
;
1583 server
->caps
= NFS_CAP_ATOMIC_OPEN
;
1585 server
->acregmin
= data
->acregmin
*HZ
;
1586 server
->acregmax
= data
->acregmax
*HZ
;
1587 server
->acdirmin
= data
->acdirmin
*HZ
;
1588 server
->acdirmax
= data
->acdirmax
*HZ
;
1590 server
->rpc_ops
= &nfs_v4_clientops
;
1591 /* Initialize timeout values */
1593 timeparms
.to_initval
= data
->timeo
* HZ
/ 10;
1594 timeparms
.to_retries
= data
->retrans
;
1595 timeparms
.to_exponential
= 1;
1596 if (!timeparms
.to_retries
)
1597 timeparms
.to_retries
= 5;
1599 proto
= data
->proto
;
1600 /* Which IP protocol do we use? */
1603 timeparms
.to_maxval
= RPC_MAX_TCP_TIMEOUT
;
1604 if (!timeparms
.to_initval
)
1605 timeparms
.to_initval
= 600 * HZ
/ 10;
1608 timeparms
.to_maxval
= RPC_MAX_UDP_TIMEOUT
;
1609 if (!timeparms
.to_initval
)
1610 timeparms
.to_initval
= 11 * HZ
/ 10;
1616 clp
= nfs4_get_client(&server
->addr
.sin_addr
);
1618 dprintk("%s: failed to create NFS4 client.\n", __FUNCTION__
);
1622 /* Now create transport and client */
1623 authflavour
= RPC_AUTH_UNIX
;
1624 if (data
->auth_flavourlen
!= 0) {
1625 if (data
->auth_flavourlen
!= 1) {
1626 dprintk("%s: Invalid number of RPC auth flavours %d.\n",
1627 __FUNCTION__
, data
->auth_flavourlen
);
1631 if (copy_from_user(&authflavour
, data
->auth_flavours
, sizeof(authflavour
))) {
1637 down_write(&clp
->cl_sem
);
1638 if (clp
->cl_rpcclient
== NULL
) {
1639 xprt
= xprt_create_proto(proto
, &server
->addr
, &timeparms
);
1641 up_write(&clp
->cl_sem
);
1642 err
= PTR_ERR(xprt
);
1643 dprintk("%s: cannot create RPC transport. Error = %d\n",
1647 clnt
= rpc_create_client(xprt
, server
->hostname
, &nfs_program
,
1648 server
->rpc_ops
->version
, authflavour
);
1650 up_write(&clp
->cl_sem
);
1651 err
= PTR_ERR(clnt
);
1652 dprintk("%s: cannot create RPC client. Error = %d\n",
1657 clnt
->cl_softrtry
= 1;
1658 clnt
->cl_chatty
= 1;
1659 clp
->cl_rpcclient
= clnt
;
1660 clp
->cl_cred
= rpcauth_lookupcred(clnt
->cl_auth
, 0);
1661 if (IS_ERR(clp
->cl_cred
)) {
1662 up_write(&clp
->cl_sem
);
1663 err
= PTR_ERR(clp
->cl_cred
);
1664 clp
->cl_cred
= NULL
;
1667 memcpy(clp
->cl_ipaddr
, server
->ip_addr
, sizeof(clp
->cl_ipaddr
));
1670 if (list_empty(&clp
->cl_superblocks
)) {
1671 err
= nfs4_init_client(clp
);
1673 up_write(&clp
->cl_sem
);
1677 list_add_tail(&server
->nfs4_siblings
, &clp
->cl_superblocks
);
1678 clnt
= rpc_clone_client(clp
->cl_rpcclient
);
1680 server
->nfs4_state
= clp
;
1681 up_write(&clp
->cl_sem
);
1685 err
= PTR_ERR(clnt
);
1686 dprintk("%s: cannot create RPC client. Error = %d\n",
1691 server
->client
= clnt
;
1693 if (server
->nfs4_state
->cl_idmap
== NULL
) {
1694 dprintk("%s: failed to create idmapper.\n", __FUNCTION__
);
1698 if (clnt
->cl_auth
->au_flavor
!= authflavour
) {
1699 if (rpcauth_create(authflavour
, clnt
) == NULL
) {
1700 dprintk("%s: couldn't create credcache!\n", __FUNCTION__
);
1705 sb
->s_time_gran
= 1;
1707 sb
->s_op
= &nfs4_sops
;
1708 err
= nfs_sb_init(sb
, authflavour
);
1713 nfs4_put_client(clp
);
1717 static int nfs4_compare_super(struct super_block
*sb
, void *data
)
1719 struct nfs_server
*server
= data
;
1720 struct nfs_server
*old
= NFS_SB(sb
);
1722 if (strcmp(server
->hostname
, old
->hostname
) != 0)
1724 if (strcmp(server
->mnt_path
, old
->mnt_path
) != 0)
1730 nfs_copy_user_string(char *dst
, struct nfs_string
*src
, int maxlen
)
1735 return ERR_PTR(-EINVAL
);
1736 if (src
->len
< maxlen
)
1739 p
= dst
= kmalloc(maxlen
+ 1, GFP_KERNEL
);
1741 return ERR_PTR(-ENOMEM
);
1743 if (copy_from_user(dst
, src
->data
, maxlen
)) {
1746 return ERR_PTR(-EFAULT
);
1752 static struct super_block
*nfs4_get_sb(struct file_system_type
*fs_type
,
1753 int flags
, const char *dev_name
, void *raw_data
)
1756 struct nfs_server
*server
;
1757 struct super_block
*s
;
1758 struct nfs4_mount_data
*data
= raw_data
;
1762 dprintk("%s: missing data argument\n", __FUNCTION__
);
1763 return ERR_PTR(-EINVAL
);
1765 if (data
->version
<= 0 || data
->version
> NFS4_MOUNT_VERSION
) {
1766 dprintk("%s: bad mount version\n", __FUNCTION__
);
1767 return ERR_PTR(-EINVAL
);
1770 server
= kmalloc(sizeof(struct nfs_server
), GFP_KERNEL
);
1772 return ERR_PTR(-ENOMEM
);
1773 memset(server
, 0, sizeof(struct nfs_server
));
1774 /* Zero out the NFS state stuff */
1775 init_nfsv4_state(server
);
1777 p
= nfs_copy_user_string(NULL
, &data
->hostname
, 256);
1780 server
->hostname
= p
;
1782 p
= nfs_copy_user_string(NULL
, &data
->mnt_path
, 1024);
1785 server
->mnt_path
= p
;
1787 p
= nfs_copy_user_string(server
->ip_addr
, &data
->client_addr
,
1788 sizeof(server
->ip_addr
) - 1);
1792 /* We now require that the mount process passes the remote address */
1793 if (data
->host_addrlen
!= sizeof(server
->addr
)) {
1794 s
= ERR_PTR(-EINVAL
);
1797 if (copy_from_user(&server
->addr
, data
->host_addr
, sizeof(server
->addr
))) {
1798 s
= ERR_PTR(-EFAULT
);
1801 if (server
->addr
.sin_family
!= AF_INET
||
1802 server
->addr
.sin_addr
.s_addr
== INADDR_ANY
) {
1803 dprintk("%s: mount program didn't pass remote IP address!\n",
1805 s
= ERR_PTR(-EINVAL
);
1809 /* Fire up rpciod if not yet running */
1810 s
= ERR_PTR(rpciod_up());
1812 dprintk("%s: couldn't start rpciod! Error = %ld\n",
1813 __FUNCTION__
, PTR_ERR(s
));
1817 s
= sget(fs_type
, nfs4_compare_super
, nfs_set_super
, server
);
1819 if (IS_ERR(s
) || s
->s_root
)
1824 error
= nfs4_fill_super(s
, data
, flags
& MS_VERBOSE
? 1 : 0);
1826 up_write(&s
->s_umount
);
1827 deactivate_super(s
);
1828 return ERR_PTR(error
);
1830 s
->s_flags
|= MS_ACTIVE
;
1833 s
= (struct super_block
*)p
;
1835 if (server
->mnt_path
)
1836 kfree(server
->mnt_path
);
1837 if (server
->hostname
)
1838 kfree(server
->hostname
);
1843 static void nfs4_kill_super(struct super_block
*sb
)
1845 struct nfs_server
*server
= NFS_SB(sb
);
1847 nfs_return_all_delegations(sb
);
1848 kill_anon_super(sb
);
1850 nfs4_renewd_prepare_shutdown(server
);
1852 if (server
->client
!= NULL
&& !IS_ERR(server
->client
))
1853 rpc_shutdown_client(server
->client
);
1854 rpciod_down(); /* release rpciod */
1856 destroy_nfsv4_state(server
);
1858 if (server
->hostname
!= NULL
)
1859 kfree(server
->hostname
);
1863 static struct file_system_type nfs4_fs_type
= {
1864 .owner
= THIS_MODULE
,
1866 .get_sb
= nfs4_get_sb
,
1867 .kill_sb
= nfs4_kill_super
,
1868 .fs_flags
= FS_ODD_RENAME
|FS_REVAL_DOT
|FS_BINARY_MOUNTDATA
,
1871 #define nfs4_init_once(nfsi) \
1873 INIT_LIST_HEAD(&(nfsi)->open_states); \
1874 nfsi->delegation = NULL; \
1875 nfsi->delegation_state = 0; \
1876 init_rwsem(&nfsi->rwsem); \
1878 #define register_nfs4fs() register_filesystem(&nfs4_fs_type)
1879 #define unregister_nfs4fs() unregister_filesystem(&nfs4_fs_type)
1881 #define nfs4_init_once(nfsi) \
1883 #define register_nfs4fs() (0)
1884 #define unregister_nfs4fs()
1887 extern int nfs_init_nfspagecache(void);
1888 extern void nfs_destroy_nfspagecache(void);
1889 extern int nfs_init_readpagecache(void);
1890 extern void nfs_destroy_readpagecache(void);
1891 extern int nfs_init_writepagecache(void);
1892 extern void nfs_destroy_writepagecache(void);
1893 #ifdef CONFIG_NFS_DIRECTIO
1894 extern int nfs_init_directcache(void);
1895 extern void nfs_destroy_directcache(void);
1898 static kmem_cache_t
* nfs_inode_cachep
;
1900 static struct inode
*nfs_alloc_inode(struct super_block
*sb
)
1902 struct nfs_inode
*nfsi
;
1903 nfsi
= (struct nfs_inode
*)kmem_cache_alloc(nfs_inode_cachep
, SLAB_KERNEL
);
1907 return &nfsi
->vfs_inode
;
1910 static void nfs_destroy_inode(struct inode
*inode
)
1912 kmem_cache_free(nfs_inode_cachep
, NFS_I(inode
));
1915 static void init_once(void * foo
, kmem_cache_t
* cachep
, unsigned long flags
)
1917 struct nfs_inode
*nfsi
= (struct nfs_inode
*) foo
;
1919 if ((flags
& (SLAB_CTOR_VERIFY
|SLAB_CTOR_CONSTRUCTOR
)) ==
1920 SLAB_CTOR_CONSTRUCTOR
) {
1921 inode_init_once(&nfsi
->vfs_inode
);
1922 spin_lock_init(&nfsi
->req_lock
);
1923 INIT_LIST_HEAD(&nfsi
->dirty
);
1924 INIT_LIST_HEAD(&nfsi
->commit
);
1925 INIT_LIST_HEAD(&nfsi
->open_files
);
1926 INIT_RADIX_TREE(&nfsi
->nfs_page_tree
, GFP_ATOMIC
);
1927 atomic_set(&nfsi
->data_updates
, 0);
1931 init_waitqueue_head(&nfsi
->nfs_i_wait
);
1932 nfs4_init_once(nfsi
);
1936 static int nfs_init_inodecache(void)
1938 nfs_inode_cachep
= kmem_cache_create("nfs_inode_cache",
1939 sizeof(struct nfs_inode
),
1940 0, SLAB_RECLAIM_ACCOUNT
,
1942 if (nfs_inode_cachep
== NULL
)
1948 static void nfs_destroy_inodecache(void)
1950 if (kmem_cache_destroy(nfs_inode_cachep
))
1951 printk(KERN_INFO
"nfs_inode_cache: not all structures were freed\n");
1957 static int __init
init_nfs_fs(void)
1961 err
= nfs_init_nfspagecache();
1965 err
= nfs_init_inodecache();
1969 err
= nfs_init_readpagecache();
1973 err
= nfs_init_writepagecache();
1977 #ifdef CONFIG_NFS_DIRECTIO
1978 err
= nfs_init_directcache();
1983 #ifdef CONFIG_PROC_FS
1984 rpc_proc_register(&nfs_rpcstat
);
1986 err
= register_filesystem(&nfs_fs_type
);
1989 if ((err
= register_nfs4fs()) != 0)
1993 #ifdef CONFIG_PROC_FS
1994 rpc_proc_unregister("nfs");
1996 nfs_destroy_writepagecache();
1997 #ifdef CONFIG_NFS_DIRECTIO
1999 nfs_destroy_directcache();
2002 nfs_destroy_readpagecache();
2004 nfs_destroy_inodecache();
2006 nfs_destroy_nfspagecache();
2011 static void __exit
exit_nfs_fs(void)
2013 #ifdef CONFIG_NFS_DIRECTIO
2014 nfs_destroy_directcache();
2016 nfs_destroy_writepagecache();
2017 nfs_destroy_readpagecache();
2018 nfs_destroy_inodecache();
2019 nfs_destroy_nfspagecache();
2020 #ifdef CONFIG_PROC_FS
2021 rpc_proc_unregister("nfs");
2023 unregister_filesystem(&nfs_fs_type
);
2024 unregister_nfs4fs();
2027 /* Not quite true; I just maintain it */
2028 MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
2029 MODULE_LICENSE("GPL");
2031 module_init(init_nfs_fs
)
2032 module_exit(exit_nfs_fs
)