1 // SPDX-License-Identifier: GPL-2.0-only
5 * Copyright (C) 1992 Rick Sladkey
7 * nfs superblock handling functions
9 * Modularised by Alan Cox <alan@lxorguk.ukuu.org.uk>, while hacking some
10 * experimental NFS changes. Modularisation taken straight from SYS5 fs.
12 * Change to nfs_read_super() to permit NFS mounts to multi-homed hosts.
13 * J.S.Peatfield@damtp.cam.ac.uk
15 * Split from inode.c by David Howells <dhowells@redhat.com>
17 * - superblocks are indexed on server only - all inodes, dentries, etc. associated with a
18 * particular server are held in the same superblock
19 * - NFS superblocks can have several effective roots to the dentry tree
20 * - directory type roots are spliced into the tree when a path from one root reaches the root
21 * of another (see nfs_lookup())
24 #include <linux/module.h>
25 #include <linux/init.h>
27 #include <linux/time.h>
28 #include <linux/kernel.h>
30 #include <linux/string.h>
31 #include <linux/stat.h>
32 #include <linux/errno.h>
33 #include <linux/unistd.h>
34 #include <linux/sunrpc/clnt.h>
35 #include <linux/sunrpc/addr.h>
36 #include <linux/sunrpc/stats.h>
37 #include <linux/sunrpc/metrics.h>
38 #include <linux/sunrpc/xprtsock.h>
39 #include <linux/sunrpc/xprtrdma.h>
40 #include <linux/nfs_fs.h>
41 #include <linux/nfs_mount.h>
42 #include <linux/nfs4_mount.h>
43 #include <linux/lockd/bind.h>
44 #include <linux/seq_file.h>
45 #include <linux/mount.h>
46 #include <linux/namei.h>
47 #include <linux/vfs.h>
48 #include <linux/inet.h>
49 #include <linux/in6.h>
50 #include <linux/slab.h>
52 #include <linux/netdevice.h>
53 #include <linux/nfs_xdr.h>
54 #include <linux/magic.h>
55 #include <linux/parser.h>
56 #include <linux/nsproxy.h>
57 #include <linux/rcupdate.h>
59 #include <linux/uaccess.h>
60 #include <linux/nfs_ssc.h>
64 #include "delegation.h"
68 #include "nfs4session.h"
72 #define NFSDBG_FACILITY NFSDBG_VFS
74 const struct super_operations nfs_sops
= {
75 .alloc_inode
= nfs_alloc_inode
,
76 .free_inode
= nfs_free_inode
,
77 .write_inode
= nfs_write_inode
,
78 .drop_inode
= nfs_drop_inode
,
80 .evict_inode
= nfs_evict_inode
,
81 .umount_begin
= nfs_umount_begin
,
82 .show_options
= nfs_show_options
,
83 .show_devname
= nfs_show_devname
,
84 .show_path
= nfs_show_path
,
85 .show_stats
= nfs_show_stats
,
87 EXPORT_SYMBOL_GPL(nfs_sops
);
89 #ifdef CONFIG_NFS_V4_2
90 static const struct nfs_ssc_client_ops nfs_ssc_clnt_ops_tbl
= {
91 .sco_sb_deactive
= nfs_sb_deactive
,
95 #if IS_ENABLED(CONFIG_NFS_V4)
96 static int __init
register_nfs4_fs(void)
98 return register_filesystem(&nfs4_fs_type
);
101 static void unregister_nfs4_fs(void)
103 unregister_filesystem(&nfs4_fs_type
);
106 static int __init
register_nfs4_fs(void)
111 static void unregister_nfs4_fs(void)
116 #ifdef CONFIG_NFS_V4_2
117 static void nfs_ssc_register_ops(void)
119 nfs_ssc_register(&nfs_ssc_clnt_ops_tbl
);
122 static void nfs_ssc_unregister_ops(void)
124 nfs_ssc_unregister(&nfs_ssc_clnt_ops_tbl
);
126 #endif /* CONFIG_NFS_V4_2 */
128 static struct shrinker acl_shrinker
= {
129 .count_objects
= nfs_access_cache_count
,
130 .scan_objects
= nfs_access_cache_scan
,
131 .seeks
= DEFAULT_SEEKS
,
135 * Register the NFS filesystems
137 int __init
register_nfs_fs(void)
141 ret
= register_filesystem(&nfs_fs_type
);
145 ret
= register_nfs4_fs();
149 ret
= nfs_register_sysctl();
152 ret
= register_shrinker(&acl_shrinker
);
155 #ifdef CONFIG_NFS_V4_2
156 nfs_ssc_register_ops();
160 nfs_unregister_sysctl();
162 unregister_nfs4_fs();
164 unregister_filesystem(&nfs_fs_type
);
170 * Unregister the NFS filesystems
172 void __exit
unregister_nfs_fs(void)
174 unregister_shrinker(&acl_shrinker
);
175 nfs_unregister_sysctl();
176 unregister_nfs4_fs();
177 #ifdef CONFIG_NFS_V4_2
178 nfs_ssc_unregister_ops();
180 unregister_filesystem(&nfs_fs_type
);
183 bool nfs_sb_active(struct super_block
*sb
)
185 struct nfs_server
*server
= NFS_SB(sb
);
187 if (!atomic_inc_not_zero(&sb
->s_active
))
189 if (atomic_inc_return(&server
->active
) != 1)
190 atomic_dec(&sb
->s_active
);
193 EXPORT_SYMBOL_GPL(nfs_sb_active
);
195 void nfs_sb_deactive(struct super_block
*sb
)
197 struct nfs_server
*server
= NFS_SB(sb
);
199 if (atomic_dec_and_test(&server
->active
))
200 deactivate_super(sb
);
202 EXPORT_SYMBOL_GPL(nfs_sb_deactive
);
204 static int __nfs_list_for_each_server(struct list_head
*head
,
205 int (*fn
)(struct nfs_server
*, void *),
208 struct nfs_server
*server
, *last
= NULL
;
212 list_for_each_entry_rcu(server
, head
, client_link
) {
213 if (!(server
->super
&& nfs_sb_active(server
->super
)))
217 nfs_sb_deactive(last
->super
);
219 ret
= fn(server
, data
);
227 nfs_sb_deactive(last
->super
);
231 int nfs_client_for_each_server(struct nfs_client
*clp
,
232 int (*fn
)(struct nfs_server
*, void *),
235 return __nfs_list_for_each_server(&clp
->cl_superblocks
, fn
, data
);
237 EXPORT_SYMBOL_GPL(nfs_client_for_each_server
);
240 * Deliver file system statistics to userspace
242 int nfs_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
244 struct nfs_server
*server
= NFS_SB(dentry
->d_sb
);
245 unsigned char blockbits
;
246 unsigned long blockres
;
247 struct nfs_fh
*fh
= NFS_FH(d_inode(dentry
));
248 struct nfs_fsstat res
;
251 res
.fattr
= nfs_alloc_fattr();
252 if (res
.fattr
== NULL
)
255 error
= server
->nfs_client
->rpc_ops
->statfs(server
, fh
, &res
);
256 if (unlikely(error
== -ESTALE
)) {
257 struct dentry
*pd_dentry
;
259 pd_dentry
= dget_parent(dentry
);
260 nfs_zap_caches(d_inode(pd_dentry
));
263 nfs_free_fattr(res
.fattr
);
267 buf
->f_type
= NFS_SUPER_MAGIC
;
270 * Current versions of glibc do not correctly handle the
271 * case where f_frsize != f_bsize. Eventually we want to
272 * report the value of wtmult in this field.
274 buf
->f_frsize
= dentry
->d_sb
->s_blocksize
;
277 * On most *nix systems, f_blocks, f_bfree, and f_bavail
278 * are reported in units of f_frsize. Linux hasn't had
279 * an f_frsize field in its statfs struct until recently,
280 * thus historically Linux's sys_statfs reports these
281 * fields in units of f_bsize.
283 buf
->f_bsize
= dentry
->d_sb
->s_blocksize
;
284 blockbits
= dentry
->d_sb
->s_blocksize_bits
;
285 blockres
= (1 << blockbits
) - 1;
286 buf
->f_blocks
= (res
.tbytes
+ blockres
) >> blockbits
;
287 buf
->f_bfree
= (res
.fbytes
+ blockres
) >> blockbits
;
288 buf
->f_bavail
= (res
.abytes
+ blockres
) >> blockbits
;
290 buf
->f_files
= res
.tfiles
;
291 buf
->f_ffree
= res
.afiles
;
293 buf
->f_namelen
= server
->namelen
;
298 dprintk("%s: statfs error = %d\n", __func__
, -error
);
301 EXPORT_SYMBOL_GPL(nfs_statfs
);
304 * Map the security flavour number to a name
306 static const char *nfs_pseudoflavour_to_name(rpc_authflavor_t flavour
)
308 static const struct {
309 rpc_authflavor_t flavour
;
311 } sec_flavours
[NFS_AUTH_INFO_MAX_FLAVORS
] = {
312 /* update NFS_AUTH_INFO_MAX_FLAVORS when this list changes! */
313 { RPC_AUTH_NULL
, "null" },
314 { RPC_AUTH_UNIX
, "sys" },
315 { RPC_AUTH_GSS_KRB5
, "krb5" },
316 { RPC_AUTH_GSS_KRB5I
, "krb5i" },
317 { RPC_AUTH_GSS_KRB5P
, "krb5p" },
318 { RPC_AUTH_GSS_LKEY
, "lkey" },
319 { RPC_AUTH_GSS_LKEYI
, "lkeyi" },
320 { RPC_AUTH_GSS_LKEYP
, "lkeyp" },
321 { RPC_AUTH_GSS_SPKM
, "spkm" },
322 { RPC_AUTH_GSS_SPKMI
, "spkmi" },
323 { RPC_AUTH_GSS_SPKMP
, "spkmp" },
324 { UINT_MAX
, "unknown" }
328 for (i
= 0; sec_flavours
[i
].flavour
!= UINT_MAX
; i
++) {
329 if (sec_flavours
[i
].flavour
== flavour
)
332 return sec_flavours
[i
].str
;
335 static void nfs_show_mountd_netid(struct seq_file
*m
, struct nfs_server
*nfss
,
338 struct sockaddr
*sap
= (struct sockaddr
*) &nfss
->mountd_address
;
341 switch (sap
->sa_family
) {
343 switch (nfss
->mountd_protocol
) {
345 proto
= RPCBIND_NETID_UDP
;
348 proto
= RPCBIND_NETID_TCP
;
353 switch (nfss
->mountd_protocol
) {
355 proto
= RPCBIND_NETID_UDP6
;
358 proto
= RPCBIND_NETID_TCP6
;
363 if (proto
|| showdefaults
)
364 seq_printf(m
, ",mountproto=%s", proto
?: "auto");
367 static void nfs_show_mountd_options(struct seq_file
*m
, struct nfs_server
*nfss
,
370 struct sockaddr
*sap
= (struct sockaddr
*)&nfss
->mountd_address
;
372 if (nfss
->flags
& NFS_MOUNT_LEGACY_INTERFACE
)
375 switch (sap
->sa_family
) {
377 struct sockaddr_in
*sin
= (struct sockaddr_in
*)sap
;
378 seq_printf(m
, ",mountaddr=%pI4", &sin
->sin_addr
.s_addr
);
382 struct sockaddr_in6
*sin6
= (struct sockaddr_in6
*)sap
;
383 seq_printf(m
, ",mountaddr=%pI6c", &sin6
->sin6_addr
);
388 seq_puts(m
, ",mountaddr=unspecified");
391 if (nfss
->mountd_version
|| showdefaults
)
392 seq_printf(m
, ",mountvers=%u", nfss
->mountd_version
);
393 if ((nfss
->mountd_port
&&
394 nfss
->mountd_port
!= (unsigned short)NFS_UNSPEC_PORT
) ||
396 seq_printf(m
, ",mountport=%u", nfss
->mountd_port
);
398 nfs_show_mountd_netid(m
, nfss
, showdefaults
);
401 #if IS_ENABLED(CONFIG_NFS_V4)
402 static void nfs_show_nfsv4_options(struct seq_file
*m
, struct nfs_server
*nfss
,
405 struct nfs_client
*clp
= nfss
->nfs_client
;
407 seq_printf(m
, ",clientaddr=%s", clp
->cl_ipaddr
);
410 static void nfs_show_nfsv4_options(struct seq_file
*m
, struct nfs_server
*nfss
,
416 static void nfs_show_nfs_version(struct seq_file
*m
,
417 unsigned int version
,
418 unsigned int minorversion
)
420 seq_printf(m
, ",vers=%u", version
);
422 seq_printf(m
, ".%u", minorversion
);
426 * Describe the mount options in force on this server representation
428 static void nfs_show_mount_options(struct seq_file
*m
, struct nfs_server
*nfss
,
431 static const struct proc_nfs_info
{
436 { NFS_MOUNT_SOFT
, ",soft", "" },
437 { NFS_MOUNT_SOFTERR
, ",softerr", "" },
438 { NFS_MOUNT_SOFTREVAL
, ",softreval", "" },
439 { NFS_MOUNT_POSIX
, ",posix", "" },
440 { NFS_MOUNT_NOCTO
, ",nocto", "" },
441 { NFS_MOUNT_NOAC
, ",noac", "" },
442 { NFS_MOUNT_NONLM
, ",nolock", "" },
443 { NFS_MOUNT_NOACL
, ",noacl", "" },
444 { NFS_MOUNT_NORDIRPLUS
, ",nordirplus", "" },
445 { NFS_MOUNT_UNSHARED
, ",nosharecache", "" },
446 { NFS_MOUNT_NORESVPORT
, ",noresvport", "" },
449 const struct proc_nfs_info
*nfs_infop
;
450 struct nfs_client
*clp
= nfss
->nfs_client
;
451 u32 version
= clp
->rpc_ops
->version
;
452 int local_flock
, local_fcntl
;
454 nfs_show_nfs_version(m
, version
, clp
->cl_minorversion
);
455 seq_printf(m
, ",rsize=%u", nfss
->rsize
);
456 seq_printf(m
, ",wsize=%u", nfss
->wsize
);
457 if (nfss
->bsize
!= 0)
458 seq_printf(m
, ",bsize=%u", nfss
->bsize
);
459 seq_printf(m
, ",namlen=%u", nfss
->namelen
);
460 if (nfss
->acregmin
!= NFS_DEF_ACREGMIN
*HZ
|| showdefaults
)
461 seq_printf(m
, ",acregmin=%u", nfss
->acregmin
/HZ
);
462 if (nfss
->acregmax
!= NFS_DEF_ACREGMAX
*HZ
|| showdefaults
)
463 seq_printf(m
, ",acregmax=%u", nfss
->acregmax
/HZ
);
464 if (nfss
->acdirmin
!= NFS_DEF_ACDIRMIN
*HZ
|| showdefaults
)
465 seq_printf(m
, ",acdirmin=%u", nfss
->acdirmin
/HZ
);
466 if (nfss
->acdirmax
!= NFS_DEF_ACDIRMAX
*HZ
|| showdefaults
)
467 seq_printf(m
, ",acdirmax=%u", nfss
->acdirmax
/HZ
);
468 if (!(nfss
->flags
& (NFS_MOUNT_SOFT
|NFS_MOUNT_SOFTERR
)))
469 seq_puts(m
, ",hard");
470 for (nfs_infop
= nfs_info
; nfs_infop
->flag
; nfs_infop
++) {
471 if (nfss
->flags
& nfs_infop
->flag
)
472 seq_puts(m
, nfs_infop
->str
);
474 seq_puts(m
, nfs_infop
->nostr
);
477 seq_printf(m
, ",proto=%s",
478 rpc_peeraddr2str(nfss
->client
, RPC_DISPLAY_NETID
));
480 if (clp
->cl_nconnect
> 0)
481 seq_printf(m
, ",nconnect=%u", clp
->cl_nconnect
);
483 if (nfss
->port
!= NFS_PORT
)
484 seq_printf(m
, ",port=%u", nfss
->port
);
487 seq_printf(m
, ",port=%u", nfss
->port
);
489 seq_printf(m
, ",timeo=%lu", 10U * nfss
->client
->cl_timeout
->to_initval
/ HZ
);
490 seq_printf(m
, ",retrans=%u", nfss
->client
->cl_timeout
->to_retries
);
491 seq_printf(m
, ",sec=%s", nfs_pseudoflavour_to_name(nfss
->client
->cl_auth
->au_flavor
));
494 nfs_show_mountd_options(m
, nfss
, showdefaults
);
496 nfs_show_nfsv4_options(m
, nfss
, showdefaults
);
498 if (nfss
->options
& NFS_OPTION_FSCACHE
)
501 if (nfss
->options
& NFS_OPTION_MIGRATION
)
502 seq_puts(m
, ",migration");
504 if (nfss
->flags
& NFS_MOUNT_LOOKUP_CACHE_NONEG
) {
505 if (nfss
->flags
& NFS_MOUNT_LOOKUP_CACHE_NONE
)
506 seq_puts(m
, ",lookupcache=none");
508 seq_puts(m
, ",lookupcache=pos");
511 local_flock
= nfss
->flags
& NFS_MOUNT_LOCAL_FLOCK
;
512 local_fcntl
= nfss
->flags
& NFS_MOUNT_LOCAL_FCNTL
;
514 if (!local_flock
&& !local_fcntl
)
515 seq_puts(m
, ",local_lock=none");
516 else if (local_flock
&& local_fcntl
)
517 seq_puts(m
, ",local_lock=all");
518 else if (local_flock
)
519 seq_puts(m
, ",local_lock=flock");
521 seq_puts(m
, ",local_lock=posix");
523 if (nfss
->flags
& NFS_MOUNT_WRITE_EAGER
) {
524 if (nfss
->flags
& NFS_MOUNT_WRITE_WAIT
)
525 seq_puts(m
, ",write=wait");
527 seq_puts(m
, ",write=eager");
532 * Describe the mount options on this VFS mountpoint
534 int nfs_show_options(struct seq_file
*m
, struct dentry
*root
)
536 struct nfs_server
*nfss
= NFS_SB(root
->d_sb
);
538 nfs_show_mount_options(m
, nfss
, 0);
541 seq_printf(m
, ",addr=%s",
542 rpc_peeraddr2str(nfss
->nfs_client
->cl_rpcclient
,
548 EXPORT_SYMBOL_GPL(nfs_show_options
);
550 #if IS_ENABLED(CONFIG_NFS_V4)
551 static void show_lease(struct seq_file
*m
, struct nfs_server
*server
)
553 struct nfs_client
*clp
= server
->nfs_client
;
554 unsigned long expire
;
556 seq_printf(m
, ",lease_time=%ld", clp
->cl_lease_time
/ HZ
);
557 expire
= clp
->cl_last_renewal
+ clp
->cl_lease_time
;
558 seq_printf(m
, ",lease_expired=%ld",
559 time_after(expire
, jiffies
) ? 0 : (jiffies
- expire
) / HZ
);
561 #ifdef CONFIG_NFS_V4_1
562 static void show_sessions(struct seq_file
*m
, struct nfs_server
*server
)
564 if (nfs4_has_session(server
->nfs_client
))
565 seq_puts(m
, ",sessions");
568 static void show_sessions(struct seq_file
*m
, struct nfs_server
*server
) {}
572 #ifdef CONFIG_NFS_V4_1
573 static void show_pnfs(struct seq_file
*m
, struct nfs_server
*server
)
575 seq_printf(m
, ",pnfs=");
576 if (server
->pnfs_curr_ld
)
577 seq_printf(m
, "%s", server
->pnfs_curr_ld
->name
);
579 seq_printf(m
, "not configured");
582 static void show_implementation_id(struct seq_file
*m
, struct nfs_server
*nfss
)
584 if (nfss
->nfs_client
&& nfss
->nfs_client
->cl_implid
) {
585 struct nfs41_impl_id
*impl_id
= nfss
->nfs_client
->cl_implid
;
586 seq_printf(m
, "\n\timpl_id:\tname='%s',domain='%s',"
588 impl_id
->name
, impl_id
->domain
,
589 impl_id
->date
.seconds
, impl_id
->date
.nseconds
);
593 #if IS_ENABLED(CONFIG_NFS_V4)
594 static void show_pnfs(struct seq_file
*m
, struct nfs_server
*server
)
598 static void show_implementation_id(struct seq_file
*m
, struct nfs_server
*nfss
)
603 int nfs_show_devname(struct seq_file
*m
, struct dentry
*root
)
605 char *page
= (char *) __get_free_page(GFP_KERNEL
);
606 char *devname
, *dummy
;
610 devname
= nfs_path(&dummy
, root
, page
, PAGE_SIZE
, 0);
612 err
= PTR_ERR(devname
);
614 seq_escape(m
, devname
, " \t\n\\");
615 free_page((unsigned long)page
);
618 EXPORT_SYMBOL_GPL(nfs_show_devname
);
620 int nfs_show_path(struct seq_file
*m
, struct dentry
*dentry
)
625 EXPORT_SYMBOL_GPL(nfs_show_path
);
628 * Present statistical information for this VFS mountpoint
630 int nfs_show_stats(struct seq_file
*m
, struct dentry
*root
)
633 struct nfs_server
*nfss
= NFS_SB(root
->d_sb
);
634 struct rpc_auth
*auth
= nfss
->client
->cl_auth
;
635 struct nfs_iostats totals
= { };
637 seq_printf(m
, "statvers=%s", NFS_IOSTAT_VERS
);
640 * Display all mount option settings
642 seq_puts(m
, "\n\topts:\t");
643 seq_puts(m
, sb_rdonly(root
->d_sb
) ? "ro" : "rw");
644 seq_puts(m
, root
->d_sb
->s_flags
& SB_SYNCHRONOUS
? ",sync" : "");
645 seq_puts(m
, root
->d_sb
->s_flags
& SB_NOATIME
? ",noatime" : "");
646 seq_puts(m
, root
->d_sb
->s_flags
& SB_NODIRATIME
? ",nodiratime" : "");
647 nfs_show_mount_options(m
, nfss
, 1);
649 seq_printf(m
, "\n\tage:\t%lu", (jiffies
- nfss
->mount_time
) / HZ
);
651 show_implementation_id(m
, nfss
);
653 seq_puts(m
, "\n\tcaps:\t");
654 seq_printf(m
, "caps=0x%x", nfss
->caps
);
655 seq_printf(m
, ",wtmult=%u", nfss
->wtmult
);
656 seq_printf(m
, ",dtsize=%u", nfss
->dtsize
);
657 seq_printf(m
, ",bsize=%u", nfss
->bsize
);
658 seq_printf(m
, ",namlen=%u", nfss
->namelen
);
660 #if IS_ENABLED(CONFIG_NFS_V4)
661 if (nfss
->nfs_client
->rpc_ops
->version
== 4) {
662 seq_puts(m
, "\n\tnfsv4:\t");
663 seq_printf(m
, "bm0=0x%x", nfss
->attr_bitmask
[0]);
664 seq_printf(m
, ",bm1=0x%x", nfss
->attr_bitmask
[1]);
665 seq_printf(m
, ",bm2=0x%x", nfss
->attr_bitmask
[2]);
666 seq_printf(m
, ",acl=0x%x", nfss
->acl_bitmask
);
667 show_sessions(m
, nfss
);
674 * Display security flavor in effect for this mount
676 seq_printf(m
, "\n\tsec:\tflavor=%u", auth
->au_ops
->au_flavor
);
678 seq_printf(m
, ",pseudoflavor=%u", auth
->au_flavor
);
681 * Display superblock I/O counters
683 for_each_possible_cpu(cpu
) {
684 struct nfs_iostats
*stats
;
687 stats
= per_cpu_ptr(nfss
->io_stats
, cpu
);
689 for (i
= 0; i
< __NFSIOS_COUNTSMAX
; i
++)
690 totals
.events
[i
] += stats
->events
[i
];
691 for (i
= 0; i
< __NFSIOS_BYTESMAX
; i
++)
692 totals
.bytes
[i
] += stats
->bytes
[i
];
693 #ifdef CONFIG_NFS_FSCACHE
694 for (i
= 0; i
< __NFSIOS_FSCACHEMAX
; i
++)
695 totals
.fscache
[i
] += stats
->fscache
[i
];
701 seq_puts(m
, "\n\tevents:\t");
702 for (i
= 0; i
< __NFSIOS_COUNTSMAX
; i
++)
703 seq_printf(m
, "%lu ", totals
.events
[i
]);
704 seq_puts(m
, "\n\tbytes:\t");
705 for (i
= 0; i
< __NFSIOS_BYTESMAX
; i
++)
706 seq_printf(m
, "%Lu ", totals
.bytes
[i
]);
707 #ifdef CONFIG_NFS_FSCACHE
708 if (nfss
->options
& NFS_OPTION_FSCACHE
) {
709 seq_puts(m
, "\n\tfsc:\t");
710 for (i
= 0; i
< __NFSIOS_FSCACHEMAX
; i
++)
711 seq_printf(m
, "%Lu ", totals
.fscache
[i
]);
716 rpc_clnt_show_stats(m
, nfss
->client
);
720 EXPORT_SYMBOL_GPL(nfs_show_stats
);
723 * Begin unmount by attempting to remove all automounted mountpoints we added
724 * in response to xdev traversals and referrals
726 void nfs_umount_begin(struct super_block
*sb
)
728 struct nfs_server
*server
;
729 struct rpc_clnt
*rpc
;
732 /* -EIO all pending I/O */
733 rpc
= server
->client_acl
;
735 rpc_killall_tasks(rpc
);
736 rpc
= server
->client
;
738 rpc_killall_tasks(rpc
);
740 EXPORT_SYMBOL_GPL(nfs_umount_begin
);
743 * Return true if 'match' is in auth_info or auth_info is empty.
744 * Return false otherwise.
746 bool nfs_auth_info_match(const struct nfs_auth_info
*auth_info
,
747 rpc_authflavor_t match
)
751 if (!auth_info
->flavor_len
)
754 for (i
= 0; i
< auth_info
->flavor_len
; i
++) {
755 if (auth_info
->flavors
[i
] == match
)
760 EXPORT_SYMBOL_GPL(nfs_auth_info_match
);
763 * Ensure that a specified authtype in ctx->auth_info is supported by
764 * the server. Returns 0 and sets ctx->selected_flavor if it's ok, and
767 static int nfs_verify_authflavors(struct nfs_fs_context
*ctx
,
768 rpc_authflavor_t
*server_authlist
,
771 rpc_authflavor_t flavor
= RPC_AUTH_MAXFLAVOR
;
772 bool found_auth_null
= false;
776 * If the sec= mount option is used, the specified flavor or AUTH_NULL
777 * must be in the list returned by the server.
779 * AUTH_NULL has a special meaning when it's in the server list - it
780 * means that the server will ignore the rpc creds, so any flavor
781 * can be used but still use the sec= that was specified.
783 * Note also that the MNT procedure in MNTv1 does not return a list
784 * of supported security flavors. In this case, nfs_mount() fabricates
785 * a security flavor list containing just AUTH_NULL.
787 for (i
= 0; i
< count
; i
++) {
788 flavor
= server_authlist
[i
];
790 if (nfs_auth_info_match(&ctx
->auth_info
, flavor
))
793 if (flavor
== RPC_AUTH_NULL
)
794 found_auth_null
= true;
797 if (found_auth_null
) {
798 flavor
= ctx
->auth_info
.flavors
[0];
803 "NFS: specified auth flavors not supported by server\n");
807 ctx
->selected_flavor
= flavor
;
808 dfprintk(MOUNT
, "NFS: using auth flavor %u\n", ctx
->selected_flavor
);
813 * Use the remote server's MOUNT service to request the NFS file handle
814 * corresponding to the provided path.
816 static int nfs_request_mount(struct fs_context
*fc
,
817 struct nfs_fh
*root_fh
,
818 rpc_authflavor_t
*server_authlist
,
819 unsigned int *server_authlist_len
)
821 struct nfs_fs_context
*ctx
= nfs_fc2context(fc
);
822 struct nfs_mount_request request
= {
823 .sap
= (struct sockaddr
*)
824 &ctx
->mount_server
.address
,
825 .dirpath
= ctx
->nfs_server
.export_path
,
826 .protocol
= ctx
->mount_server
.protocol
,
828 .noresvport
= ctx
->flags
& NFS_MOUNT_NORESVPORT
,
829 .auth_flav_len
= server_authlist_len
,
830 .auth_flavs
= server_authlist
,
835 if (ctx
->mount_server
.version
== 0) {
836 switch (ctx
->version
) {
838 ctx
->mount_server
.version
= NFS_MNT3_VERSION
;
841 ctx
->mount_server
.version
= NFS_MNT_VERSION
;
844 request
.version
= ctx
->mount_server
.version
;
846 if (ctx
->mount_server
.hostname
)
847 request
.hostname
= ctx
->mount_server
.hostname
;
849 request
.hostname
= ctx
->nfs_server
.hostname
;
852 * Construct the mount server's address.
854 if (ctx
->mount_server
.address
.sa_family
== AF_UNSPEC
) {
855 memcpy(request
.sap
, &ctx
->nfs_server
.address
,
856 ctx
->nfs_server
.addrlen
);
857 ctx
->mount_server
.addrlen
= ctx
->nfs_server
.addrlen
;
859 request
.salen
= ctx
->mount_server
.addrlen
;
860 nfs_set_port(request
.sap
, &ctx
->mount_server
.port
, 0);
863 * Now ask the mount server to map our export path
866 status
= nfs_mount(&request
, ctx
->timeo
, ctx
->retrans
);
868 dfprintk(MOUNT
, "NFS: unable to mount server %s, error %d\n",
869 request
.hostname
, status
);
876 static struct nfs_server
*nfs_try_mount_request(struct fs_context
*fc
)
878 struct nfs_fs_context
*ctx
= nfs_fc2context(fc
);
881 bool tried_auth_unix
= false;
882 bool auth_null_in_list
= false;
883 struct nfs_server
*server
= ERR_PTR(-EACCES
);
884 rpc_authflavor_t authlist
[NFS_MAX_SECFLAVORS
];
885 unsigned int authlist_len
= ARRAY_SIZE(authlist
);
887 status
= nfs_request_mount(fc
, ctx
->mntfh
, authlist
, &authlist_len
);
889 return ERR_PTR(status
);
892 * Was a sec= authflavor specified in the options? First, verify
893 * whether the server supports it, and then just try to use it if so.
895 if (ctx
->auth_info
.flavor_len
> 0) {
896 status
= nfs_verify_authflavors(ctx
, authlist
, authlist_len
);
897 dfprintk(MOUNT
, "NFS: using auth flavor %u\n",
898 ctx
->selected_flavor
);
900 return ERR_PTR(status
);
901 return ctx
->nfs_mod
->rpc_ops
->create_server(fc
);
905 * No sec= option was provided. RFC 2623, section 2.7 suggests we
906 * SHOULD prefer the flavor listed first. However, some servers list
907 * AUTH_NULL first. Avoid ever choosing AUTH_NULL.
909 for (i
= 0; i
< authlist_len
; ++i
) {
910 rpc_authflavor_t flavor
;
911 struct rpcsec_gss_info info
;
913 flavor
= authlist
[i
];
916 tried_auth_unix
= true;
919 auth_null_in_list
= true;
922 if (rpcauth_get_gssinfo(flavor
, &info
) != 0)
926 dfprintk(MOUNT
, "NFS: attempting to use auth flavor %u\n", flavor
);
927 ctx
->selected_flavor
= flavor
;
928 server
= ctx
->nfs_mod
->rpc_ops
->create_server(fc
);
934 * Nothing we tried so far worked. At this point, give up if we've
935 * already tried AUTH_UNIX or if the server's list doesn't contain
938 if (tried_auth_unix
|| !auth_null_in_list
)
941 /* Last chance! Try AUTH_UNIX */
942 dfprintk(MOUNT
, "NFS: attempting to use auth flavor %u\n", RPC_AUTH_UNIX
);
943 ctx
->selected_flavor
= RPC_AUTH_UNIX
;
944 return ctx
->nfs_mod
->rpc_ops
->create_server(fc
);
947 int nfs_try_get_tree(struct fs_context
*fc
)
949 struct nfs_fs_context
*ctx
= nfs_fc2context(fc
);
952 ctx
->server
= nfs_try_mount_request(fc
);
954 ctx
->server
= ctx
->nfs_mod
->rpc_ops
->create_server(fc
);
956 return nfs_get_tree_common(fc
);
958 EXPORT_SYMBOL_GPL(nfs_try_get_tree
);
961 #define NFS_REMOUNT_CMP_FLAGMASK ~(NFS_MOUNT_INTR \
965 | NFS_MOUNT_KERBEROS \
967 | NFS_MOUNT_BROKEN_SUID \
968 | NFS_MOUNT_STRICTLOCK \
969 | NFS_MOUNT_LEGACY_INTERFACE)
971 #define NFS_MOUNT_CMP_FLAGMASK (NFS_REMOUNT_CMP_FLAGMASK & \
972 ~(NFS_MOUNT_UNSHARED | NFS_MOUNT_NORESVPORT))
975 nfs_compare_remount_data(struct nfs_server
*nfss
,
976 struct nfs_fs_context
*ctx
)
978 if ((ctx
->flags
^ nfss
->flags
) & NFS_REMOUNT_CMP_FLAGMASK
||
979 ctx
->rsize
!= nfss
->rsize
||
980 ctx
->wsize
!= nfss
->wsize
||
981 ctx
->version
!= nfss
->nfs_client
->rpc_ops
->version
||
982 ctx
->minorversion
!= nfss
->nfs_client
->cl_minorversion
||
983 ctx
->retrans
!= nfss
->client
->cl_timeout
->to_retries
||
984 !nfs_auth_info_match(&ctx
->auth_info
, nfss
->client
->cl_auth
->au_flavor
) ||
985 ctx
->acregmin
!= nfss
->acregmin
/ HZ
||
986 ctx
->acregmax
!= nfss
->acregmax
/ HZ
||
987 ctx
->acdirmin
!= nfss
->acdirmin
/ HZ
||
988 ctx
->acdirmax
!= nfss
->acdirmax
/ HZ
||
989 ctx
->timeo
!= (10U * nfss
->client
->cl_timeout
->to_initval
/ HZ
) ||
990 (ctx
->options
& NFS_OPTION_FSCACHE
) != (nfss
->options
& NFS_OPTION_FSCACHE
) ||
991 ctx
->nfs_server
.port
!= nfss
->port
||
992 ctx
->nfs_server
.addrlen
!= nfss
->nfs_client
->cl_addrlen
||
993 !rpc_cmp_addr((struct sockaddr
*)&ctx
->nfs_server
.address
,
994 (struct sockaddr
*)&nfss
->nfs_client
->cl_addr
))
1000 int nfs_reconfigure(struct fs_context
*fc
)
1002 struct nfs_fs_context
*ctx
= nfs_fc2context(fc
);
1003 struct super_block
*sb
= fc
->root
->d_sb
;
1004 struct nfs_server
*nfss
= sb
->s_fs_info
;
1006 sync_filesystem(sb
);
1009 * Userspace mount programs that send binary options generally send
1010 * them populated with default values. We have no way to know which
1011 * ones were explicitly specified. Fall back to legacy behavior and
1012 * just return success.
1014 if (ctx
->skip_reconfig_option_check
)
1018 * noac is a special case. It implies -o sync, but that's not
1019 * necessarily reflected in the mtab options. reconfigure_super
1020 * will clear SB_SYNCHRONOUS if -o sync wasn't specified in the
1021 * remount options, so we have to explicitly reset it.
1023 if (ctx
->flags
& NFS_MOUNT_NOAC
) {
1024 fc
->sb_flags
|= SB_SYNCHRONOUS
;
1025 fc
->sb_flags_mask
|= SB_SYNCHRONOUS
;
1028 /* compare new mount options with old ones */
1029 return nfs_compare_remount_data(nfss
, ctx
);
1031 EXPORT_SYMBOL_GPL(nfs_reconfigure
);
1034 * Finish setting up an NFS superblock
1036 static void nfs_fill_super(struct super_block
*sb
, struct nfs_fs_context
*ctx
)
1038 struct nfs_server
*server
= NFS_SB(sb
);
1040 sb
->s_blocksize_bits
= 0;
1041 sb
->s_blocksize
= 0;
1042 sb
->s_xattr
= server
->nfs_client
->cl_nfs_mod
->xattr
;
1043 sb
->s_op
= server
->nfs_client
->cl_nfs_mod
->sops
;
1045 sb
->s_blocksize
= nfs_block_size(ctx
->bsize
, &sb
->s_blocksize_bits
);
1047 if (server
->nfs_client
->rpc_ops
->version
!= 2) {
1048 /* The VFS shouldn't apply the umask to mode bits. We will do
1049 * so ourselves when necessary.
1051 sb
->s_flags
|= SB_POSIXACL
;
1052 sb
->s_time_gran
= 1;
1053 sb
->s_export_op
= &nfs_export_ops
;
1055 sb
->s_time_gran
= 1000;
1057 if (server
->nfs_client
->rpc_ops
->version
!= 4) {
1059 sb
->s_time_max
= U32_MAX
;
1061 sb
->s_time_min
= S64_MIN
;
1062 sb
->s_time_max
= S64_MAX
;
1065 sb
->s_magic
= NFS_SUPER_MAGIC
;
1067 /* We probably want something more informative here */
1068 snprintf(sb
->s_id
, sizeof(sb
->s_id
),
1069 "%u:%u", MAJOR(sb
->s_dev
), MINOR(sb
->s_dev
));
1071 if (sb
->s_blocksize
== 0)
1072 sb
->s_blocksize
= nfs_block_bits(server
->wsize
,
1073 &sb
->s_blocksize_bits
);
1075 nfs_super_set_maxbytes(sb
, server
->maxfilesize
);
1076 server
->has_sec_mnt_opts
= ctx
->has_sec_mnt_opts
;
1079 static int nfs_compare_mount_options(const struct super_block
*s
, const struct nfs_server
*b
,
1080 const struct fs_context
*fc
)
1082 const struct nfs_server
*a
= s
->s_fs_info
;
1083 const struct rpc_clnt
*clnt_a
= a
->client
;
1084 const struct rpc_clnt
*clnt_b
= b
->client
;
1086 if ((s
->s_flags
& NFS_SB_MASK
) != (fc
->sb_flags
& NFS_SB_MASK
))
1088 if (a
->nfs_client
!= b
->nfs_client
)
1090 if ((a
->flags
^ b
->flags
) & NFS_MOUNT_CMP_FLAGMASK
)
1092 if (a
->wsize
!= b
->wsize
)
1094 if (a
->rsize
!= b
->rsize
)
1096 if (a
->acregmin
!= b
->acregmin
)
1098 if (a
->acregmax
!= b
->acregmax
)
1100 if (a
->acdirmin
!= b
->acdirmin
)
1102 if (a
->acdirmax
!= b
->acdirmax
)
1104 if (clnt_a
->cl_auth
->au_flavor
!= clnt_b
->cl_auth
->au_flavor
)
1111 static int nfs_set_super(struct super_block
*s
, struct fs_context
*fc
)
1113 struct nfs_server
*server
= fc
->s_fs_info
;
1116 s
->s_d_op
= server
->nfs_client
->rpc_ops
->dentry_ops
;
1117 ret
= set_anon_super(s
, server
);
1119 server
->s_dev
= s
->s_dev
;
1123 static int nfs_compare_super_address(struct nfs_server
*server1
,
1124 struct nfs_server
*server2
)
1126 struct sockaddr
*sap1
, *sap2
;
1127 struct rpc_xprt
*xprt1
= server1
->client
->cl_xprt
;
1128 struct rpc_xprt
*xprt2
= server2
->client
->cl_xprt
;
1130 if (!net_eq(xprt1
->xprt_net
, xprt2
->xprt_net
))
1133 sap1
= (struct sockaddr
*)&server1
->nfs_client
->cl_addr
;
1134 sap2
= (struct sockaddr
*)&server2
->nfs_client
->cl_addr
;
1136 if (sap1
->sa_family
!= sap2
->sa_family
)
1139 switch (sap1
->sa_family
) {
1141 struct sockaddr_in
*sin1
= (struct sockaddr_in
*)sap1
;
1142 struct sockaddr_in
*sin2
= (struct sockaddr_in
*)sap2
;
1143 if (sin1
->sin_addr
.s_addr
!= sin2
->sin_addr
.s_addr
)
1145 if (sin1
->sin_port
!= sin2
->sin_port
)
1150 struct sockaddr_in6
*sin1
= (struct sockaddr_in6
*)sap1
;
1151 struct sockaddr_in6
*sin2
= (struct sockaddr_in6
*)sap2
;
1152 if (!ipv6_addr_equal(&sin1
->sin6_addr
, &sin2
->sin6_addr
))
1154 if (sin1
->sin6_port
!= sin2
->sin6_port
)
1165 static int nfs_compare_userns(const struct nfs_server
*old
,
1166 const struct nfs_server
*new)
1168 const struct user_namespace
*oldns
= &init_user_ns
;
1169 const struct user_namespace
*newns
= &init_user_ns
;
1171 if (old
->client
&& old
->client
->cl_cred
)
1172 oldns
= old
->client
->cl_cred
->user_ns
;
1173 if (new->client
&& new->client
->cl_cred
)
1174 newns
= new->client
->cl_cred
->user_ns
;
1180 static int nfs_compare_super(struct super_block
*sb
, struct fs_context
*fc
)
1182 struct nfs_server
*server
= fc
->s_fs_info
, *old
= NFS_SB(sb
);
1184 if (!nfs_compare_super_address(old
, server
))
1186 /* Note: NFS_MOUNT_UNSHARED == NFS4_MOUNT_UNSHARED */
1187 if (old
->flags
& NFS_MOUNT_UNSHARED
)
1189 if (memcmp(&old
->fsid
, &server
->fsid
, sizeof(old
->fsid
)) != 0)
1191 if (!nfs_compare_userns(old
, server
))
1193 if ((old
->has_sec_mnt_opts
|| fc
->security
) &&
1194 security_sb_mnt_opts_compat(sb
, fc
->security
))
1196 return nfs_compare_mount_options(sb
, server
, fc
);
1199 #ifdef CONFIG_NFS_FSCACHE
1200 static void nfs_get_cache_cookie(struct super_block
*sb
,
1201 struct nfs_fs_context
*ctx
)
1203 struct nfs_server
*nfss
= NFS_SB(sb
);
1207 nfss
->fscache_key
= NULL
;
1208 nfss
->fscache
= NULL
;
1213 if (ctx
->clone_data
.sb
) {
1214 struct nfs_server
*mnt_s
= NFS_SB(ctx
->clone_data
.sb
);
1215 if (!(mnt_s
->options
& NFS_OPTION_FSCACHE
))
1217 if (mnt_s
->fscache_key
) {
1218 uniq
= mnt_s
->fscache_key
->key
.uniquifier
;
1219 ulen
= mnt_s
->fscache_key
->key
.uniq_len
;
1222 if (!(ctx
->options
& NFS_OPTION_FSCACHE
))
1224 if (ctx
->fscache_uniq
) {
1225 uniq
= ctx
->fscache_uniq
;
1226 ulen
= strlen(ctx
->fscache_uniq
);
1230 nfs_fscache_get_super_cookie(sb
, uniq
, ulen
);
1233 static void nfs_get_cache_cookie(struct super_block
*sb
,
1234 struct nfs_fs_context
*ctx
)
1239 int nfs_get_tree_common(struct fs_context
*fc
)
1241 struct nfs_fs_context
*ctx
= nfs_fc2context(fc
);
1242 struct super_block
*s
;
1243 int (*compare_super
)(struct super_block
*, struct fs_context
*) = nfs_compare_super
;
1244 struct nfs_server
*server
= ctx
->server
;
1249 return PTR_ERR(server
);
1251 if (server
->flags
& NFS_MOUNT_UNSHARED
)
1252 compare_super
= NULL
;
1254 /* -o noac implies -o sync */
1255 if (server
->flags
& NFS_MOUNT_NOAC
)
1256 fc
->sb_flags
|= SB_SYNCHRONOUS
;
1258 if (ctx
->clone_data
.sb
)
1259 if (ctx
->clone_data
.sb
->s_flags
& SB_SYNCHRONOUS
)
1260 fc
->sb_flags
|= SB_SYNCHRONOUS
;
1262 if (server
->caps
& NFS_CAP_SECURITY_LABEL
)
1263 fc
->lsm_flags
|= SECURITY_LSM_NATIVE_LABELS
;
1265 /* Get a superblock - note that we may end up sharing one that already exists */
1266 fc
->s_fs_info
= server
;
1267 s
= sget_fc(fc
, compare_super
, nfs_set_super
);
1268 fc
->s_fs_info
= NULL
;
1271 nfs_errorf(fc
, "NFS: Couldn't get superblock");
1275 if (s
->s_fs_info
!= server
) {
1276 nfs_free_server(server
);
1279 error
= super_setup_bdi_name(s
, "%u:%u", MAJOR(server
->s_dev
),
1280 MINOR(server
->s_dev
));
1282 goto error_splat_super
;
1283 s
->s_bdi
->io_pages
= server
->rpages
;
1288 unsigned bsize
= ctx
->clone_data
.inherited_bsize
;
1289 /* initial superblock/root creation */
1290 nfs_fill_super(s
, ctx
);
1292 s
->s_blocksize_bits
= bsize
;
1293 s
->s_blocksize
= 1U << bsize
;
1295 nfs_get_cache_cookie(s
, ctx
);
1298 error
= nfs_get_root(s
, fc
);
1300 nfs_errorf(fc
, "NFS: Couldn't get root dentry");
1301 goto error_splat_super
;
1304 s
->s_flags
|= SB_ACTIVE
;
1311 nfs_free_server(server
);
1314 deactivate_locked_super(s
);
1319 * Destroy an NFS2/3 superblock
1321 void nfs_kill_super(struct super_block
*s
)
1323 struct nfs_server
*server
= NFS_SB(s
);
1324 dev_t dev
= s
->s_dev
;
1326 generic_shutdown_super(s
);
1328 nfs_fscache_release_super_cookie(s
);
1330 nfs_free_server(server
);
1331 free_anon_bdev(dev
);
1333 EXPORT_SYMBOL_GPL(nfs_kill_super
);
1335 #if IS_ENABLED(CONFIG_NFS_V4)
1338 * NFS v4 module parameters need to stay in the
1339 * NFS client for backwards compatibility
1341 unsigned int nfs_callback_set_tcpport
;
1342 unsigned short nfs_callback_nr_threads
;
1343 /* Default cache timeout is 10 minutes */
1344 unsigned int nfs_idmap_cache_timeout
= 600;
1345 /* Turn off NFSv4 uid/gid mapping when using AUTH_SYS */
1346 bool nfs4_disable_idmapping
= true;
1347 unsigned short max_session_slots
= NFS4_DEF_SLOT_TABLE_SIZE
;
1348 unsigned short max_session_cb_slots
= NFS4_DEF_CB_SLOT_TABLE_SIZE
;
1349 unsigned short send_implementation_id
= 1;
1350 char nfs4_client_id_uniquifier
[NFS4_CLIENT_ID_UNIQ_LEN
] = "";
1351 bool recover_lost_locks
= false;
1353 EXPORT_SYMBOL_GPL(nfs_callback_nr_threads
);
1354 EXPORT_SYMBOL_GPL(nfs_callback_set_tcpport
);
1355 EXPORT_SYMBOL_GPL(nfs_idmap_cache_timeout
);
1356 EXPORT_SYMBOL_GPL(nfs4_disable_idmapping
);
1357 EXPORT_SYMBOL_GPL(max_session_slots
);
1358 EXPORT_SYMBOL_GPL(max_session_cb_slots
);
1359 EXPORT_SYMBOL_GPL(send_implementation_id
);
1360 EXPORT_SYMBOL_GPL(nfs4_client_id_uniquifier
);
1361 EXPORT_SYMBOL_GPL(recover_lost_locks
);
1363 #define NFS_CALLBACK_MAXPORTNR (65535U)
1365 static int param_set_portnr(const char *val
, const struct kernel_param
*kp
)
1372 ret
= kstrtoul(val
, 0, &num
);
1373 if (ret
|| num
> NFS_CALLBACK_MAXPORTNR
)
1375 *((unsigned int *)kp
->arg
) = num
;
1378 static const struct kernel_param_ops param_ops_portnr
= {
1379 .set
= param_set_portnr
,
1380 .get
= param_get_uint
,
1382 #define param_check_portnr(name, p) __param_check(name, p, unsigned int);
1384 module_param_named(callback_tcpport
, nfs_callback_set_tcpport
, portnr
, 0644);
1385 module_param_named(callback_nr_threads
, nfs_callback_nr_threads
, ushort
, 0644);
1386 MODULE_PARM_DESC(callback_nr_threads
, "Number of threads that will be "
1387 "assigned to the NFSv4 callback channels.");
1388 module_param(nfs_idmap_cache_timeout
, int, 0644);
1389 module_param(nfs4_disable_idmapping
, bool, 0644);
1390 module_param_string(nfs4_unique_id
, nfs4_client_id_uniquifier
,
1391 NFS4_CLIENT_ID_UNIQ_LEN
, 0600);
1392 MODULE_PARM_DESC(nfs4_disable_idmapping
,
1393 "Turn off NFSv4 idmapping when using 'sec=sys'");
1394 module_param(max_session_slots
, ushort
, 0644);
1395 MODULE_PARM_DESC(max_session_slots
, "Maximum number of outstanding NFSv4.1 "
1396 "requests the client will negotiate");
1397 module_param(max_session_cb_slots
, ushort
, 0644);
1398 MODULE_PARM_DESC(max_session_cb_slots
, "Maximum number of parallel NFSv4.1 "
1399 "callbacks the client will process for a given server");
1400 module_param(send_implementation_id
, ushort
, 0644);
1401 MODULE_PARM_DESC(send_implementation_id
,
1402 "Send implementation ID with NFSv4.1 exchange_id");
1403 MODULE_PARM_DESC(nfs4_unique_id
, "nfs_client_id4 uniquifier string");
1405 module_param(recover_lost_locks
, bool, 0644);
1406 MODULE_PARM_DESC(recover_lost_locks
,
1407 "If the server reports that a lock might be lost, "
1408 "try to recover it risking data corruption.");
1411 #endif /* CONFIG_NFS_V4 */