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 #ifdef CONFIG_NFSD_V4
120 nfs_ssc_register(&nfs_ssc_clnt_ops_tbl
);
124 static void nfs_ssc_unregister_ops(void)
126 #ifdef CONFIG_NFSD_V4
127 nfs_ssc_unregister(&nfs_ssc_clnt_ops_tbl
);
130 #endif /* CONFIG_NFS_V4_2 */
132 static struct shrinker acl_shrinker
= {
133 .count_objects
= nfs_access_cache_count
,
134 .scan_objects
= nfs_access_cache_scan
,
135 .seeks
= DEFAULT_SEEKS
,
139 * Register the NFS filesystems
141 int __init
register_nfs_fs(void)
145 ret
= register_filesystem(&nfs_fs_type
);
149 ret
= register_nfs4_fs();
153 ret
= nfs_register_sysctl();
156 ret
= register_shrinker(&acl_shrinker
);
159 #ifdef CONFIG_NFS_V4_2
160 nfs_ssc_register_ops();
164 nfs_unregister_sysctl();
166 unregister_nfs4_fs();
168 unregister_filesystem(&nfs_fs_type
);
174 * Unregister the NFS filesystems
176 void __exit
unregister_nfs_fs(void)
178 unregister_shrinker(&acl_shrinker
);
179 nfs_unregister_sysctl();
180 unregister_nfs4_fs();
181 #ifdef CONFIG_NFS_V4_2
182 nfs_ssc_unregister_ops();
184 unregister_filesystem(&nfs_fs_type
);
187 bool nfs_sb_active(struct super_block
*sb
)
189 struct nfs_server
*server
= NFS_SB(sb
);
191 if (!atomic_inc_not_zero(&sb
->s_active
))
193 if (atomic_inc_return(&server
->active
) != 1)
194 atomic_dec(&sb
->s_active
);
197 EXPORT_SYMBOL_GPL(nfs_sb_active
);
199 void nfs_sb_deactive(struct super_block
*sb
)
201 struct nfs_server
*server
= NFS_SB(sb
);
203 if (atomic_dec_and_test(&server
->active
))
204 deactivate_super(sb
);
206 EXPORT_SYMBOL_GPL(nfs_sb_deactive
);
208 static int __nfs_list_for_each_server(struct list_head
*head
,
209 int (*fn
)(struct nfs_server
*, void *),
212 struct nfs_server
*server
, *last
= NULL
;
216 list_for_each_entry_rcu(server
, head
, client_link
) {
217 if (!(server
->super
&& nfs_sb_active(server
->super
)))
221 nfs_sb_deactive(last
->super
);
223 ret
= fn(server
, data
);
231 nfs_sb_deactive(last
->super
);
235 int nfs_client_for_each_server(struct nfs_client
*clp
,
236 int (*fn
)(struct nfs_server
*, void *),
239 return __nfs_list_for_each_server(&clp
->cl_superblocks
, fn
, data
);
241 EXPORT_SYMBOL_GPL(nfs_client_for_each_server
);
244 * Deliver file system statistics to userspace
246 int nfs_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
248 struct nfs_server
*server
= NFS_SB(dentry
->d_sb
);
249 unsigned char blockbits
;
250 unsigned long blockres
;
251 struct nfs_fh
*fh
= NFS_FH(d_inode(dentry
));
252 struct nfs_fsstat res
;
255 res
.fattr
= nfs_alloc_fattr();
256 if (res
.fattr
== NULL
)
259 error
= server
->nfs_client
->rpc_ops
->statfs(server
, fh
, &res
);
260 if (unlikely(error
== -ESTALE
)) {
261 struct dentry
*pd_dentry
;
263 pd_dentry
= dget_parent(dentry
);
264 nfs_zap_caches(d_inode(pd_dentry
));
267 nfs_free_fattr(res
.fattr
);
271 buf
->f_type
= NFS_SUPER_MAGIC
;
274 * Current versions of glibc do not correctly handle the
275 * case where f_frsize != f_bsize. Eventually we want to
276 * report the value of wtmult in this field.
278 buf
->f_frsize
= dentry
->d_sb
->s_blocksize
;
281 * On most *nix systems, f_blocks, f_bfree, and f_bavail
282 * are reported in units of f_frsize. Linux hasn't had
283 * an f_frsize field in its statfs struct until recently,
284 * thus historically Linux's sys_statfs reports these
285 * fields in units of f_bsize.
287 buf
->f_bsize
= dentry
->d_sb
->s_blocksize
;
288 blockbits
= dentry
->d_sb
->s_blocksize_bits
;
289 blockres
= (1 << blockbits
) - 1;
290 buf
->f_blocks
= (res
.tbytes
+ blockres
) >> blockbits
;
291 buf
->f_bfree
= (res
.fbytes
+ blockres
) >> blockbits
;
292 buf
->f_bavail
= (res
.abytes
+ blockres
) >> blockbits
;
294 buf
->f_files
= res
.tfiles
;
295 buf
->f_ffree
= res
.afiles
;
297 buf
->f_namelen
= server
->namelen
;
302 dprintk("%s: statfs error = %d\n", __func__
, -error
);
305 EXPORT_SYMBOL_GPL(nfs_statfs
);
308 * Map the security flavour number to a name
310 static const char *nfs_pseudoflavour_to_name(rpc_authflavor_t flavour
)
312 static const struct {
313 rpc_authflavor_t flavour
;
315 } sec_flavours
[NFS_AUTH_INFO_MAX_FLAVORS
] = {
316 /* update NFS_AUTH_INFO_MAX_FLAVORS when this list changes! */
317 { RPC_AUTH_NULL
, "null" },
318 { RPC_AUTH_UNIX
, "sys" },
319 { RPC_AUTH_GSS_KRB5
, "krb5" },
320 { RPC_AUTH_GSS_KRB5I
, "krb5i" },
321 { RPC_AUTH_GSS_KRB5P
, "krb5p" },
322 { RPC_AUTH_GSS_LKEY
, "lkey" },
323 { RPC_AUTH_GSS_LKEYI
, "lkeyi" },
324 { RPC_AUTH_GSS_LKEYP
, "lkeyp" },
325 { RPC_AUTH_GSS_SPKM
, "spkm" },
326 { RPC_AUTH_GSS_SPKMI
, "spkmi" },
327 { RPC_AUTH_GSS_SPKMP
, "spkmp" },
328 { UINT_MAX
, "unknown" }
332 for (i
= 0; sec_flavours
[i
].flavour
!= UINT_MAX
; i
++) {
333 if (sec_flavours
[i
].flavour
== flavour
)
336 return sec_flavours
[i
].str
;
339 static void nfs_show_mountd_netid(struct seq_file
*m
, struct nfs_server
*nfss
,
342 struct sockaddr
*sap
= (struct sockaddr
*) &nfss
->mountd_address
;
345 switch (sap
->sa_family
) {
347 switch (nfss
->mountd_protocol
) {
349 proto
= RPCBIND_NETID_UDP
;
352 proto
= RPCBIND_NETID_TCP
;
357 switch (nfss
->mountd_protocol
) {
359 proto
= RPCBIND_NETID_UDP6
;
362 proto
= RPCBIND_NETID_TCP6
;
367 if (proto
|| showdefaults
)
368 seq_printf(m
, ",mountproto=%s", proto
?: "auto");
371 static void nfs_show_mountd_options(struct seq_file
*m
, struct nfs_server
*nfss
,
374 struct sockaddr
*sap
= (struct sockaddr
*)&nfss
->mountd_address
;
376 if (nfss
->flags
& NFS_MOUNT_LEGACY_INTERFACE
)
379 switch (sap
->sa_family
) {
381 struct sockaddr_in
*sin
= (struct sockaddr_in
*)sap
;
382 seq_printf(m
, ",mountaddr=%pI4", &sin
->sin_addr
.s_addr
);
386 struct sockaddr_in6
*sin6
= (struct sockaddr_in6
*)sap
;
387 seq_printf(m
, ",mountaddr=%pI6c", &sin6
->sin6_addr
);
392 seq_puts(m
, ",mountaddr=unspecified");
395 if (nfss
->mountd_version
|| showdefaults
)
396 seq_printf(m
, ",mountvers=%u", nfss
->mountd_version
);
397 if ((nfss
->mountd_port
&&
398 nfss
->mountd_port
!= (unsigned short)NFS_UNSPEC_PORT
) ||
400 seq_printf(m
, ",mountport=%u", nfss
->mountd_port
);
402 nfs_show_mountd_netid(m
, nfss
, showdefaults
);
405 #if IS_ENABLED(CONFIG_NFS_V4)
406 static void nfs_show_nfsv4_options(struct seq_file
*m
, struct nfs_server
*nfss
,
409 struct nfs_client
*clp
= nfss
->nfs_client
;
411 seq_printf(m
, ",clientaddr=%s", clp
->cl_ipaddr
);
414 static void nfs_show_nfsv4_options(struct seq_file
*m
, struct nfs_server
*nfss
,
420 static void nfs_show_nfs_version(struct seq_file
*m
,
421 unsigned int version
,
422 unsigned int minorversion
)
424 seq_printf(m
, ",vers=%u", version
);
426 seq_printf(m
, ".%u", minorversion
);
430 * Describe the mount options in force on this server representation
432 static void nfs_show_mount_options(struct seq_file
*m
, struct nfs_server
*nfss
,
435 static const struct proc_nfs_info
{
440 { NFS_MOUNT_SOFT
, ",soft", "" },
441 { NFS_MOUNT_SOFTERR
, ",softerr", "" },
442 { NFS_MOUNT_SOFTREVAL
, ",softreval", "" },
443 { NFS_MOUNT_POSIX
, ",posix", "" },
444 { NFS_MOUNT_NOCTO
, ",nocto", "" },
445 { NFS_MOUNT_NOAC
, ",noac", "" },
446 { NFS_MOUNT_NONLM
, ",nolock", "" },
447 { NFS_MOUNT_NOACL
, ",noacl", "" },
448 { NFS_MOUNT_NORDIRPLUS
, ",nordirplus", "" },
449 { NFS_MOUNT_UNSHARED
, ",nosharecache", "" },
450 { NFS_MOUNT_NORESVPORT
, ",noresvport", "" },
453 const struct proc_nfs_info
*nfs_infop
;
454 struct nfs_client
*clp
= nfss
->nfs_client
;
455 u32 version
= clp
->rpc_ops
->version
;
456 int local_flock
, local_fcntl
;
458 nfs_show_nfs_version(m
, version
, clp
->cl_minorversion
);
459 seq_printf(m
, ",rsize=%u", nfss
->rsize
);
460 seq_printf(m
, ",wsize=%u", nfss
->wsize
);
461 if (nfss
->bsize
!= 0)
462 seq_printf(m
, ",bsize=%u", nfss
->bsize
);
463 seq_printf(m
, ",namlen=%u", nfss
->namelen
);
464 if (nfss
->acregmin
!= NFS_DEF_ACREGMIN
*HZ
|| showdefaults
)
465 seq_printf(m
, ",acregmin=%u", nfss
->acregmin
/HZ
);
466 if (nfss
->acregmax
!= NFS_DEF_ACREGMAX
*HZ
|| showdefaults
)
467 seq_printf(m
, ",acregmax=%u", nfss
->acregmax
/HZ
);
468 if (nfss
->acdirmin
!= NFS_DEF_ACDIRMIN
*HZ
|| showdefaults
)
469 seq_printf(m
, ",acdirmin=%u", nfss
->acdirmin
/HZ
);
470 if (nfss
->acdirmax
!= NFS_DEF_ACDIRMAX
*HZ
|| showdefaults
)
471 seq_printf(m
, ",acdirmax=%u", nfss
->acdirmax
/HZ
);
472 if (!(nfss
->flags
& (NFS_MOUNT_SOFT
|NFS_MOUNT_SOFTERR
)))
473 seq_puts(m
, ",hard");
474 for (nfs_infop
= nfs_info
; nfs_infop
->flag
; nfs_infop
++) {
475 if (nfss
->flags
& nfs_infop
->flag
)
476 seq_puts(m
, nfs_infop
->str
);
478 seq_puts(m
, nfs_infop
->nostr
);
481 seq_printf(m
, ",proto=%s",
482 rpc_peeraddr2str(nfss
->client
, RPC_DISPLAY_NETID
));
484 if (clp
->cl_nconnect
> 0)
485 seq_printf(m
, ",nconnect=%u", clp
->cl_nconnect
);
487 if (nfss
->port
!= NFS_PORT
)
488 seq_printf(m
, ",port=%u", nfss
->port
);
491 seq_printf(m
, ",port=%u", nfss
->port
);
493 seq_printf(m
, ",timeo=%lu", 10U * nfss
->client
->cl_timeout
->to_initval
/ HZ
);
494 seq_printf(m
, ",retrans=%u", nfss
->client
->cl_timeout
->to_retries
);
495 seq_printf(m
, ",sec=%s", nfs_pseudoflavour_to_name(nfss
->client
->cl_auth
->au_flavor
));
498 nfs_show_mountd_options(m
, nfss
, showdefaults
);
500 nfs_show_nfsv4_options(m
, nfss
, showdefaults
);
502 if (nfss
->options
& NFS_OPTION_FSCACHE
)
505 if (nfss
->options
& NFS_OPTION_MIGRATION
)
506 seq_puts(m
, ",migration");
508 if (nfss
->flags
& NFS_MOUNT_LOOKUP_CACHE_NONEG
) {
509 if (nfss
->flags
& NFS_MOUNT_LOOKUP_CACHE_NONE
)
510 seq_puts(m
, ",lookupcache=none");
512 seq_puts(m
, ",lookupcache=pos");
515 local_flock
= nfss
->flags
& NFS_MOUNT_LOCAL_FLOCK
;
516 local_fcntl
= nfss
->flags
& NFS_MOUNT_LOCAL_FCNTL
;
518 if (!local_flock
&& !local_fcntl
)
519 seq_puts(m
, ",local_lock=none");
520 else if (local_flock
&& local_fcntl
)
521 seq_puts(m
, ",local_lock=all");
522 else if (local_flock
)
523 seq_puts(m
, ",local_lock=flock");
525 seq_puts(m
, ",local_lock=posix");
527 if (nfss
->flags
& NFS_MOUNT_WRITE_EAGER
) {
528 if (nfss
->flags
& NFS_MOUNT_WRITE_WAIT
)
529 seq_puts(m
, ",write=wait");
531 seq_puts(m
, ",write=eager");
536 * Describe the mount options on this VFS mountpoint
538 int nfs_show_options(struct seq_file
*m
, struct dentry
*root
)
540 struct nfs_server
*nfss
= NFS_SB(root
->d_sb
);
542 nfs_show_mount_options(m
, nfss
, 0);
545 seq_printf(m
, ",addr=%s",
546 rpc_peeraddr2str(nfss
->nfs_client
->cl_rpcclient
,
552 EXPORT_SYMBOL_GPL(nfs_show_options
);
554 #if IS_ENABLED(CONFIG_NFS_V4)
555 static void show_lease(struct seq_file
*m
, struct nfs_server
*server
)
557 struct nfs_client
*clp
= server
->nfs_client
;
558 unsigned long expire
;
560 seq_printf(m
, ",lease_time=%ld", clp
->cl_lease_time
/ HZ
);
561 expire
= clp
->cl_last_renewal
+ clp
->cl_lease_time
;
562 seq_printf(m
, ",lease_expired=%ld",
563 time_after(expire
, jiffies
) ? 0 : (jiffies
- expire
) / HZ
);
565 #ifdef CONFIG_NFS_V4_1
566 static void show_sessions(struct seq_file
*m
, struct nfs_server
*server
)
568 if (nfs4_has_session(server
->nfs_client
))
569 seq_puts(m
, ",sessions");
572 static void show_sessions(struct seq_file
*m
, struct nfs_server
*server
) {}
576 #ifdef CONFIG_NFS_V4_1
577 static void show_pnfs(struct seq_file
*m
, struct nfs_server
*server
)
579 seq_printf(m
, ",pnfs=");
580 if (server
->pnfs_curr_ld
)
581 seq_printf(m
, "%s", server
->pnfs_curr_ld
->name
);
583 seq_printf(m
, "not configured");
586 static void show_implementation_id(struct seq_file
*m
, struct nfs_server
*nfss
)
588 if (nfss
->nfs_client
&& nfss
->nfs_client
->cl_implid
) {
589 struct nfs41_impl_id
*impl_id
= nfss
->nfs_client
->cl_implid
;
590 seq_printf(m
, "\n\timpl_id:\tname='%s',domain='%s',"
592 impl_id
->name
, impl_id
->domain
,
593 impl_id
->date
.seconds
, impl_id
->date
.nseconds
);
597 #if IS_ENABLED(CONFIG_NFS_V4)
598 static void show_pnfs(struct seq_file
*m
, struct nfs_server
*server
)
602 static void show_implementation_id(struct seq_file
*m
, struct nfs_server
*nfss
)
607 int nfs_show_devname(struct seq_file
*m
, struct dentry
*root
)
609 char *page
= (char *) __get_free_page(GFP_KERNEL
);
610 char *devname
, *dummy
;
614 devname
= nfs_path(&dummy
, root
, page
, PAGE_SIZE
, 0);
616 err
= PTR_ERR(devname
);
618 seq_escape(m
, devname
, " \t\n\\");
619 free_page((unsigned long)page
);
622 EXPORT_SYMBOL_GPL(nfs_show_devname
);
624 int nfs_show_path(struct seq_file
*m
, struct dentry
*dentry
)
629 EXPORT_SYMBOL_GPL(nfs_show_path
);
632 * Present statistical information for this VFS mountpoint
634 int nfs_show_stats(struct seq_file
*m
, struct dentry
*root
)
637 struct nfs_server
*nfss
= NFS_SB(root
->d_sb
);
638 struct rpc_auth
*auth
= nfss
->client
->cl_auth
;
639 struct nfs_iostats totals
= { };
641 seq_printf(m
, "statvers=%s", NFS_IOSTAT_VERS
);
644 * Display all mount option settings
646 seq_puts(m
, "\n\topts:\t");
647 seq_puts(m
, sb_rdonly(root
->d_sb
) ? "ro" : "rw");
648 seq_puts(m
, root
->d_sb
->s_flags
& SB_SYNCHRONOUS
? ",sync" : "");
649 seq_puts(m
, root
->d_sb
->s_flags
& SB_NOATIME
? ",noatime" : "");
650 seq_puts(m
, root
->d_sb
->s_flags
& SB_NODIRATIME
? ",nodiratime" : "");
651 nfs_show_mount_options(m
, nfss
, 1);
653 seq_printf(m
, "\n\tage:\t%lu", (jiffies
- nfss
->mount_time
) / HZ
);
655 show_implementation_id(m
, nfss
);
657 seq_puts(m
, "\n\tcaps:\t");
658 seq_printf(m
, "caps=0x%x", nfss
->caps
);
659 seq_printf(m
, ",wtmult=%u", nfss
->wtmult
);
660 seq_printf(m
, ",dtsize=%u", nfss
->dtsize
);
661 seq_printf(m
, ",bsize=%u", nfss
->bsize
);
662 seq_printf(m
, ",namlen=%u", nfss
->namelen
);
664 #if IS_ENABLED(CONFIG_NFS_V4)
665 if (nfss
->nfs_client
->rpc_ops
->version
== 4) {
666 seq_puts(m
, "\n\tnfsv4:\t");
667 seq_printf(m
, "bm0=0x%x", nfss
->attr_bitmask
[0]);
668 seq_printf(m
, ",bm1=0x%x", nfss
->attr_bitmask
[1]);
669 seq_printf(m
, ",bm2=0x%x", nfss
->attr_bitmask
[2]);
670 seq_printf(m
, ",acl=0x%x", nfss
->acl_bitmask
);
671 show_sessions(m
, nfss
);
678 * Display security flavor in effect for this mount
680 seq_printf(m
, "\n\tsec:\tflavor=%u", auth
->au_ops
->au_flavor
);
682 seq_printf(m
, ",pseudoflavor=%u", auth
->au_flavor
);
685 * Display superblock I/O counters
687 for_each_possible_cpu(cpu
) {
688 struct nfs_iostats
*stats
;
691 stats
= per_cpu_ptr(nfss
->io_stats
, cpu
);
693 for (i
= 0; i
< __NFSIOS_COUNTSMAX
; i
++)
694 totals
.events
[i
] += stats
->events
[i
];
695 for (i
= 0; i
< __NFSIOS_BYTESMAX
; i
++)
696 totals
.bytes
[i
] += stats
->bytes
[i
];
697 #ifdef CONFIG_NFS_FSCACHE
698 for (i
= 0; i
< __NFSIOS_FSCACHEMAX
; i
++)
699 totals
.fscache
[i
] += stats
->fscache
[i
];
705 seq_puts(m
, "\n\tevents:\t");
706 for (i
= 0; i
< __NFSIOS_COUNTSMAX
; i
++)
707 seq_printf(m
, "%lu ", totals
.events
[i
]);
708 seq_puts(m
, "\n\tbytes:\t");
709 for (i
= 0; i
< __NFSIOS_BYTESMAX
; i
++)
710 seq_printf(m
, "%Lu ", totals
.bytes
[i
]);
711 #ifdef CONFIG_NFS_FSCACHE
712 if (nfss
->options
& NFS_OPTION_FSCACHE
) {
713 seq_puts(m
, "\n\tfsc:\t");
714 for (i
= 0; i
< __NFSIOS_FSCACHEMAX
; i
++)
715 seq_printf(m
, "%Lu ", totals
.fscache
[i
]);
720 rpc_clnt_show_stats(m
, nfss
->client
);
724 EXPORT_SYMBOL_GPL(nfs_show_stats
);
727 * Begin unmount by attempting to remove all automounted mountpoints we added
728 * in response to xdev traversals and referrals
730 void nfs_umount_begin(struct super_block
*sb
)
732 struct nfs_server
*server
;
733 struct rpc_clnt
*rpc
;
736 /* -EIO all pending I/O */
737 rpc
= server
->client_acl
;
739 rpc_killall_tasks(rpc
);
740 rpc
= server
->client
;
742 rpc_killall_tasks(rpc
);
744 EXPORT_SYMBOL_GPL(nfs_umount_begin
);
747 * Return true if 'match' is in auth_info or auth_info is empty.
748 * Return false otherwise.
750 bool nfs_auth_info_match(const struct nfs_auth_info
*auth_info
,
751 rpc_authflavor_t match
)
755 if (!auth_info
->flavor_len
)
758 for (i
= 0; i
< auth_info
->flavor_len
; i
++) {
759 if (auth_info
->flavors
[i
] == match
)
764 EXPORT_SYMBOL_GPL(nfs_auth_info_match
);
767 * Ensure that a specified authtype in ctx->auth_info is supported by
768 * the server. Returns 0 and sets ctx->selected_flavor if it's ok, and
771 static int nfs_verify_authflavors(struct nfs_fs_context
*ctx
,
772 rpc_authflavor_t
*server_authlist
,
775 rpc_authflavor_t flavor
= RPC_AUTH_MAXFLAVOR
;
776 bool found_auth_null
= false;
780 * If the sec= mount option is used, the specified flavor or AUTH_NULL
781 * must be in the list returned by the server.
783 * AUTH_NULL has a special meaning when it's in the server list - it
784 * means that the server will ignore the rpc creds, so any flavor
785 * can be used but still use the sec= that was specified.
787 * Note also that the MNT procedure in MNTv1 does not return a list
788 * of supported security flavors. In this case, nfs_mount() fabricates
789 * a security flavor list containing just AUTH_NULL.
791 for (i
= 0; i
< count
; i
++) {
792 flavor
= server_authlist
[i
];
794 if (nfs_auth_info_match(&ctx
->auth_info
, flavor
))
797 if (flavor
== RPC_AUTH_NULL
)
798 found_auth_null
= true;
801 if (found_auth_null
) {
802 flavor
= ctx
->auth_info
.flavors
[0];
807 "NFS: specified auth flavors not supported by server\n");
811 ctx
->selected_flavor
= flavor
;
812 dfprintk(MOUNT
, "NFS: using auth flavor %u\n", ctx
->selected_flavor
);
817 * Use the remote server's MOUNT service to request the NFS file handle
818 * corresponding to the provided path.
820 static int nfs_request_mount(struct fs_context
*fc
,
821 struct nfs_fh
*root_fh
,
822 rpc_authflavor_t
*server_authlist
,
823 unsigned int *server_authlist_len
)
825 struct nfs_fs_context
*ctx
= nfs_fc2context(fc
);
826 struct nfs_mount_request request
= {
827 .sap
= (struct sockaddr
*)
828 &ctx
->mount_server
.address
,
829 .dirpath
= ctx
->nfs_server
.export_path
,
830 .protocol
= ctx
->mount_server
.protocol
,
832 .noresvport
= ctx
->flags
& NFS_MOUNT_NORESVPORT
,
833 .auth_flav_len
= server_authlist_len
,
834 .auth_flavs
= server_authlist
,
839 if (ctx
->mount_server
.version
== 0) {
840 switch (ctx
->version
) {
842 ctx
->mount_server
.version
= NFS_MNT3_VERSION
;
845 ctx
->mount_server
.version
= NFS_MNT_VERSION
;
848 request
.version
= ctx
->mount_server
.version
;
850 if (ctx
->mount_server
.hostname
)
851 request
.hostname
= ctx
->mount_server
.hostname
;
853 request
.hostname
= ctx
->nfs_server
.hostname
;
856 * Construct the mount server's address.
858 if (ctx
->mount_server
.address
.sa_family
== AF_UNSPEC
) {
859 memcpy(request
.sap
, &ctx
->nfs_server
.address
,
860 ctx
->nfs_server
.addrlen
);
861 ctx
->mount_server
.addrlen
= ctx
->nfs_server
.addrlen
;
863 request
.salen
= ctx
->mount_server
.addrlen
;
864 nfs_set_port(request
.sap
, &ctx
->mount_server
.port
, 0);
867 * Now ask the mount server to map our export path
870 status
= nfs_mount(&request
);
872 dfprintk(MOUNT
, "NFS: unable to mount server %s, error %d\n",
873 request
.hostname
, status
);
880 static struct nfs_server
*nfs_try_mount_request(struct fs_context
*fc
)
882 struct nfs_fs_context
*ctx
= nfs_fc2context(fc
);
885 bool tried_auth_unix
= false;
886 bool auth_null_in_list
= false;
887 struct nfs_server
*server
= ERR_PTR(-EACCES
);
888 rpc_authflavor_t authlist
[NFS_MAX_SECFLAVORS
];
889 unsigned int authlist_len
= ARRAY_SIZE(authlist
);
891 status
= nfs_request_mount(fc
, ctx
->mntfh
, authlist
, &authlist_len
);
893 return ERR_PTR(status
);
896 * Was a sec= authflavor specified in the options? First, verify
897 * whether the server supports it, and then just try to use it if so.
899 if (ctx
->auth_info
.flavor_len
> 0) {
900 status
= nfs_verify_authflavors(ctx
, authlist
, authlist_len
);
901 dfprintk(MOUNT
, "NFS: using auth flavor %u\n",
902 ctx
->selected_flavor
);
904 return ERR_PTR(status
);
905 return ctx
->nfs_mod
->rpc_ops
->create_server(fc
);
909 * No sec= option was provided. RFC 2623, section 2.7 suggests we
910 * SHOULD prefer the flavor listed first. However, some servers list
911 * AUTH_NULL first. Avoid ever choosing AUTH_NULL.
913 for (i
= 0; i
< authlist_len
; ++i
) {
914 rpc_authflavor_t flavor
;
915 struct rpcsec_gss_info info
;
917 flavor
= authlist
[i
];
920 tried_auth_unix
= true;
923 auth_null_in_list
= true;
926 if (rpcauth_get_gssinfo(flavor
, &info
) != 0)
930 dfprintk(MOUNT
, "NFS: attempting to use auth flavor %u\n", flavor
);
931 ctx
->selected_flavor
= flavor
;
932 server
= ctx
->nfs_mod
->rpc_ops
->create_server(fc
);
938 * Nothing we tried so far worked. At this point, give up if we've
939 * already tried AUTH_UNIX or if the server's list doesn't contain
942 if (tried_auth_unix
|| !auth_null_in_list
)
945 /* Last chance! Try AUTH_UNIX */
946 dfprintk(MOUNT
, "NFS: attempting to use auth flavor %u\n", RPC_AUTH_UNIX
);
947 ctx
->selected_flavor
= RPC_AUTH_UNIX
;
948 return ctx
->nfs_mod
->rpc_ops
->create_server(fc
);
951 int nfs_try_get_tree(struct fs_context
*fc
)
953 struct nfs_fs_context
*ctx
= nfs_fc2context(fc
);
956 ctx
->server
= nfs_try_mount_request(fc
);
958 ctx
->server
= ctx
->nfs_mod
->rpc_ops
->create_server(fc
);
960 return nfs_get_tree_common(fc
);
962 EXPORT_SYMBOL_GPL(nfs_try_get_tree
);
965 #define NFS_REMOUNT_CMP_FLAGMASK ~(NFS_MOUNT_INTR \
969 | NFS_MOUNT_KERBEROS \
971 | NFS_MOUNT_BROKEN_SUID \
972 | NFS_MOUNT_STRICTLOCK \
973 | NFS_MOUNT_LEGACY_INTERFACE)
975 #define NFS_MOUNT_CMP_FLAGMASK (NFS_REMOUNT_CMP_FLAGMASK & \
976 ~(NFS_MOUNT_UNSHARED | NFS_MOUNT_NORESVPORT))
979 nfs_compare_remount_data(struct nfs_server
*nfss
,
980 struct nfs_fs_context
*ctx
)
982 if ((ctx
->flags
^ nfss
->flags
) & NFS_REMOUNT_CMP_FLAGMASK
||
983 ctx
->rsize
!= nfss
->rsize
||
984 ctx
->wsize
!= nfss
->wsize
||
985 ctx
->version
!= nfss
->nfs_client
->rpc_ops
->version
||
986 ctx
->minorversion
!= nfss
->nfs_client
->cl_minorversion
||
987 ctx
->retrans
!= nfss
->client
->cl_timeout
->to_retries
||
988 !nfs_auth_info_match(&ctx
->auth_info
, nfss
->client
->cl_auth
->au_flavor
) ||
989 ctx
->acregmin
!= nfss
->acregmin
/ HZ
||
990 ctx
->acregmax
!= nfss
->acregmax
/ HZ
||
991 ctx
->acdirmin
!= nfss
->acdirmin
/ HZ
||
992 ctx
->acdirmax
!= nfss
->acdirmax
/ HZ
||
993 ctx
->timeo
!= (10U * nfss
->client
->cl_timeout
->to_initval
/ HZ
) ||
994 (ctx
->options
& NFS_OPTION_FSCACHE
) != (nfss
->options
& NFS_OPTION_FSCACHE
) ||
995 ctx
->nfs_server
.port
!= nfss
->port
||
996 ctx
->nfs_server
.addrlen
!= nfss
->nfs_client
->cl_addrlen
||
997 !rpc_cmp_addr((struct sockaddr
*)&ctx
->nfs_server
.address
,
998 (struct sockaddr
*)&nfss
->nfs_client
->cl_addr
))
1004 int nfs_reconfigure(struct fs_context
*fc
)
1006 struct nfs_fs_context
*ctx
= nfs_fc2context(fc
);
1007 struct super_block
*sb
= fc
->root
->d_sb
;
1008 struct nfs_server
*nfss
= sb
->s_fs_info
;
1010 sync_filesystem(sb
);
1013 * Userspace mount programs that send binary options generally send
1014 * them populated with default values. We have no way to know which
1015 * ones were explicitly specified. Fall back to legacy behavior and
1016 * just return success.
1018 if (ctx
->skip_reconfig_option_check
)
1022 * noac is a special case. It implies -o sync, but that's not
1023 * necessarily reflected in the mtab options. reconfigure_super
1024 * will clear SB_SYNCHRONOUS if -o sync wasn't specified in the
1025 * remount options, so we have to explicitly reset it.
1027 if (ctx
->flags
& NFS_MOUNT_NOAC
) {
1028 fc
->sb_flags
|= SB_SYNCHRONOUS
;
1029 fc
->sb_flags_mask
|= SB_SYNCHRONOUS
;
1032 /* compare new mount options with old ones */
1033 return nfs_compare_remount_data(nfss
, ctx
);
1035 EXPORT_SYMBOL_GPL(nfs_reconfigure
);
1038 * Finish setting up an NFS superblock
1040 static void nfs_fill_super(struct super_block
*sb
, struct nfs_fs_context
*ctx
)
1042 struct nfs_server
*server
= NFS_SB(sb
);
1044 sb
->s_blocksize_bits
= 0;
1045 sb
->s_blocksize
= 0;
1046 sb
->s_xattr
= server
->nfs_client
->cl_nfs_mod
->xattr
;
1047 sb
->s_op
= server
->nfs_client
->cl_nfs_mod
->sops
;
1049 sb
->s_blocksize
= nfs_block_size(ctx
->bsize
, &sb
->s_blocksize_bits
);
1051 if (server
->nfs_client
->rpc_ops
->version
!= 2) {
1052 /* The VFS shouldn't apply the umask to mode bits. We will do
1053 * so ourselves when necessary.
1055 sb
->s_flags
|= SB_POSIXACL
;
1056 sb
->s_time_gran
= 1;
1057 sb
->s_export_op
= &nfs_export_ops
;
1059 sb
->s_time_gran
= 1000;
1061 if (server
->nfs_client
->rpc_ops
->version
!= 4) {
1063 sb
->s_time_max
= U32_MAX
;
1065 sb
->s_time_min
= S64_MIN
;
1066 sb
->s_time_max
= S64_MAX
;
1069 sb
->s_magic
= NFS_SUPER_MAGIC
;
1071 /* We probably want something more informative here */
1072 snprintf(sb
->s_id
, sizeof(sb
->s_id
),
1073 "%u:%u", MAJOR(sb
->s_dev
), MINOR(sb
->s_dev
));
1075 if (sb
->s_blocksize
== 0)
1076 sb
->s_blocksize
= nfs_block_bits(server
->wsize
,
1077 &sb
->s_blocksize_bits
);
1079 nfs_super_set_maxbytes(sb
, server
->maxfilesize
);
1080 server
->has_sec_mnt_opts
= ctx
->has_sec_mnt_opts
;
1083 static int nfs_compare_mount_options(const struct super_block
*s
, const struct nfs_server
*b
,
1084 const struct fs_context
*fc
)
1086 const struct nfs_server
*a
= s
->s_fs_info
;
1087 const struct rpc_clnt
*clnt_a
= a
->client
;
1088 const struct rpc_clnt
*clnt_b
= b
->client
;
1090 if ((s
->s_flags
& NFS_SB_MASK
) != (fc
->sb_flags
& NFS_SB_MASK
))
1092 if (a
->nfs_client
!= b
->nfs_client
)
1094 if ((a
->flags
^ b
->flags
) & NFS_MOUNT_CMP_FLAGMASK
)
1096 if (a
->wsize
!= b
->wsize
)
1098 if (a
->rsize
!= b
->rsize
)
1100 if (a
->acregmin
!= b
->acregmin
)
1102 if (a
->acregmax
!= b
->acregmax
)
1104 if (a
->acdirmin
!= b
->acdirmin
)
1106 if (a
->acdirmax
!= b
->acdirmax
)
1108 if (clnt_a
->cl_auth
->au_flavor
!= clnt_b
->cl_auth
->au_flavor
)
1115 static int nfs_set_super(struct super_block
*s
, struct fs_context
*fc
)
1117 struct nfs_server
*server
= fc
->s_fs_info
;
1120 s
->s_d_op
= server
->nfs_client
->rpc_ops
->dentry_ops
;
1121 ret
= set_anon_super(s
, server
);
1123 server
->s_dev
= s
->s_dev
;
1127 static int nfs_compare_super_address(struct nfs_server
*server1
,
1128 struct nfs_server
*server2
)
1130 struct sockaddr
*sap1
, *sap2
;
1131 struct rpc_xprt
*xprt1
= server1
->client
->cl_xprt
;
1132 struct rpc_xprt
*xprt2
= server2
->client
->cl_xprt
;
1134 if (!net_eq(xprt1
->xprt_net
, xprt2
->xprt_net
))
1137 sap1
= (struct sockaddr
*)&server1
->nfs_client
->cl_addr
;
1138 sap2
= (struct sockaddr
*)&server2
->nfs_client
->cl_addr
;
1140 if (sap1
->sa_family
!= sap2
->sa_family
)
1143 switch (sap1
->sa_family
) {
1145 struct sockaddr_in
*sin1
= (struct sockaddr_in
*)sap1
;
1146 struct sockaddr_in
*sin2
= (struct sockaddr_in
*)sap2
;
1147 if (sin1
->sin_addr
.s_addr
!= sin2
->sin_addr
.s_addr
)
1149 if (sin1
->sin_port
!= sin2
->sin_port
)
1154 struct sockaddr_in6
*sin1
= (struct sockaddr_in6
*)sap1
;
1155 struct sockaddr_in6
*sin2
= (struct sockaddr_in6
*)sap2
;
1156 if (!ipv6_addr_equal(&sin1
->sin6_addr
, &sin2
->sin6_addr
))
1158 if (sin1
->sin6_port
!= sin2
->sin6_port
)
1169 static int nfs_compare_userns(const struct nfs_server
*old
,
1170 const struct nfs_server
*new)
1172 const struct user_namespace
*oldns
= &init_user_ns
;
1173 const struct user_namespace
*newns
= &init_user_ns
;
1175 if (old
->client
&& old
->client
->cl_cred
)
1176 oldns
= old
->client
->cl_cred
->user_ns
;
1177 if (new->client
&& new->client
->cl_cred
)
1178 newns
= new->client
->cl_cred
->user_ns
;
1184 static int nfs_compare_super(struct super_block
*sb
, struct fs_context
*fc
)
1186 struct nfs_server
*server
= fc
->s_fs_info
, *old
= NFS_SB(sb
);
1188 if (!nfs_compare_super_address(old
, server
))
1190 /* Note: NFS_MOUNT_UNSHARED == NFS4_MOUNT_UNSHARED */
1191 if (old
->flags
& NFS_MOUNT_UNSHARED
)
1193 if (memcmp(&old
->fsid
, &server
->fsid
, sizeof(old
->fsid
)) != 0)
1195 if (!nfs_compare_userns(old
, server
))
1197 if ((old
->has_sec_mnt_opts
|| fc
->security
) &&
1198 security_sb_mnt_opts_compat(sb
, fc
->security
))
1200 return nfs_compare_mount_options(sb
, server
, fc
);
1203 #ifdef CONFIG_NFS_FSCACHE
1204 static void nfs_get_cache_cookie(struct super_block
*sb
,
1205 struct nfs_fs_context
*ctx
)
1207 struct nfs_server
*nfss
= NFS_SB(sb
);
1211 nfss
->fscache_key
= NULL
;
1212 nfss
->fscache
= NULL
;
1217 if (ctx
->clone_data
.sb
) {
1218 struct nfs_server
*mnt_s
= NFS_SB(ctx
->clone_data
.sb
);
1219 if (!(mnt_s
->options
& NFS_OPTION_FSCACHE
))
1221 if (mnt_s
->fscache_key
) {
1222 uniq
= mnt_s
->fscache_key
->key
.uniquifier
;
1223 ulen
= mnt_s
->fscache_key
->key
.uniq_len
;
1226 if (!(ctx
->options
& NFS_OPTION_FSCACHE
))
1228 if (ctx
->fscache_uniq
) {
1229 uniq
= ctx
->fscache_uniq
;
1230 ulen
= strlen(ctx
->fscache_uniq
);
1234 nfs_fscache_get_super_cookie(sb
, uniq
, ulen
);
1237 static void nfs_get_cache_cookie(struct super_block
*sb
,
1238 struct nfs_fs_context
*ctx
)
1243 int nfs_get_tree_common(struct fs_context
*fc
)
1245 struct nfs_fs_context
*ctx
= nfs_fc2context(fc
);
1246 struct super_block
*s
;
1247 int (*compare_super
)(struct super_block
*, struct fs_context
*) = nfs_compare_super
;
1248 struct nfs_server
*server
= ctx
->server
;
1253 return PTR_ERR(server
);
1255 if (server
->flags
& NFS_MOUNT_UNSHARED
)
1256 compare_super
= NULL
;
1258 /* -o noac implies -o sync */
1259 if (server
->flags
& NFS_MOUNT_NOAC
)
1260 fc
->sb_flags
|= SB_SYNCHRONOUS
;
1262 if (ctx
->clone_data
.sb
)
1263 if (ctx
->clone_data
.sb
->s_flags
& SB_SYNCHRONOUS
)
1264 fc
->sb_flags
|= SB_SYNCHRONOUS
;
1266 if (server
->caps
& NFS_CAP_SECURITY_LABEL
)
1267 fc
->lsm_flags
|= SECURITY_LSM_NATIVE_LABELS
;
1269 /* Get a superblock - note that we may end up sharing one that already exists */
1270 fc
->s_fs_info
= server
;
1271 s
= sget_fc(fc
, compare_super
, nfs_set_super
);
1272 fc
->s_fs_info
= NULL
;
1275 nfs_errorf(fc
, "NFS: Couldn't get superblock");
1279 if (s
->s_fs_info
!= server
) {
1280 nfs_free_server(server
);
1283 error
= super_setup_bdi_name(s
, "%u:%u", MAJOR(server
->s_dev
),
1284 MINOR(server
->s_dev
));
1286 goto error_splat_super
;
1287 s
->s_bdi
->io_pages
= server
->rpages
;
1292 unsigned bsize
= ctx
->clone_data
.inherited_bsize
;
1293 /* initial superblock/root creation */
1294 nfs_fill_super(s
, ctx
);
1296 s
->s_blocksize_bits
= bsize
;
1297 s
->s_blocksize
= 1U << bsize
;
1299 nfs_get_cache_cookie(s
, ctx
);
1302 error
= nfs_get_root(s
, fc
);
1304 nfs_errorf(fc
, "NFS: Couldn't get root dentry");
1305 goto error_splat_super
;
1308 s
->s_flags
|= SB_ACTIVE
;
1315 nfs_free_server(server
);
1318 deactivate_locked_super(s
);
1323 * Destroy an NFS2/3 superblock
1325 void nfs_kill_super(struct super_block
*s
)
1327 struct nfs_server
*server
= NFS_SB(s
);
1328 dev_t dev
= s
->s_dev
;
1330 generic_shutdown_super(s
);
1332 nfs_fscache_release_super_cookie(s
);
1334 nfs_free_server(server
);
1335 free_anon_bdev(dev
);
1337 EXPORT_SYMBOL_GPL(nfs_kill_super
);
1339 #if IS_ENABLED(CONFIG_NFS_V4)
1342 * NFS v4 module parameters need to stay in the
1343 * NFS client for backwards compatibility
1345 unsigned int nfs_callback_set_tcpport
;
1346 unsigned short nfs_callback_nr_threads
;
1347 /* Default cache timeout is 10 minutes */
1348 unsigned int nfs_idmap_cache_timeout
= 600;
1349 /* Turn off NFSv4 uid/gid mapping when using AUTH_SYS */
1350 bool nfs4_disable_idmapping
= true;
1351 unsigned short max_session_slots
= NFS4_DEF_SLOT_TABLE_SIZE
;
1352 unsigned short max_session_cb_slots
= NFS4_DEF_CB_SLOT_TABLE_SIZE
;
1353 unsigned short send_implementation_id
= 1;
1354 char nfs4_client_id_uniquifier
[NFS4_CLIENT_ID_UNIQ_LEN
] = "";
1355 bool recover_lost_locks
= false;
1357 EXPORT_SYMBOL_GPL(nfs_callback_nr_threads
);
1358 EXPORT_SYMBOL_GPL(nfs_callback_set_tcpport
);
1359 EXPORT_SYMBOL_GPL(nfs_idmap_cache_timeout
);
1360 EXPORT_SYMBOL_GPL(nfs4_disable_idmapping
);
1361 EXPORT_SYMBOL_GPL(max_session_slots
);
1362 EXPORT_SYMBOL_GPL(max_session_cb_slots
);
1363 EXPORT_SYMBOL_GPL(send_implementation_id
);
1364 EXPORT_SYMBOL_GPL(nfs4_client_id_uniquifier
);
1365 EXPORT_SYMBOL_GPL(recover_lost_locks
);
1367 #define NFS_CALLBACK_MAXPORTNR (65535U)
1369 static int param_set_portnr(const char *val
, const struct kernel_param
*kp
)
1376 ret
= kstrtoul(val
, 0, &num
);
1377 if (ret
|| num
> NFS_CALLBACK_MAXPORTNR
)
1379 *((unsigned int *)kp
->arg
) = num
;
1382 static const struct kernel_param_ops param_ops_portnr
= {
1383 .set
= param_set_portnr
,
1384 .get
= param_get_uint
,
1386 #define param_check_portnr(name, p) __param_check(name, p, unsigned int);
1388 module_param_named(callback_tcpport
, nfs_callback_set_tcpport
, portnr
, 0644);
1389 module_param_named(callback_nr_threads
, nfs_callback_nr_threads
, ushort
, 0644);
1390 MODULE_PARM_DESC(callback_nr_threads
, "Number of threads that will be "
1391 "assigned to the NFSv4 callback channels.");
1392 module_param(nfs_idmap_cache_timeout
, int, 0644);
1393 module_param(nfs4_disable_idmapping
, bool, 0644);
1394 module_param_string(nfs4_unique_id
, nfs4_client_id_uniquifier
,
1395 NFS4_CLIENT_ID_UNIQ_LEN
, 0600);
1396 MODULE_PARM_DESC(nfs4_disable_idmapping
,
1397 "Turn off NFSv4 idmapping when using 'sec=sys'");
1398 module_param(max_session_slots
, ushort
, 0644);
1399 MODULE_PARM_DESC(max_session_slots
, "Maximum number of outstanding NFSv4.1 "
1400 "requests the client will negotiate");
1401 module_param(max_session_cb_slots
, ushort
, 0644);
1402 MODULE_PARM_DESC(max_session_cb_slots
, "Maximum number of parallel NFSv4.1 "
1403 "callbacks the client will process for a given server");
1404 module_param(send_implementation_id
, ushort
, 0644);
1405 MODULE_PARM_DESC(send_implementation_id
,
1406 "Send implementation ID with NFSv4.1 exchange_id");
1407 MODULE_PARM_DESC(nfs4_unique_id
, "nfs_client_id4 uniquifier string");
1409 module_param(recover_lost_locks
, bool, 0644);
1410 MODULE_PARM_DESC(recover_lost_locks
,
1411 "If the server reports that a lock might be lost, "
1412 "try to recover it risking data corruption.");
1415 #endif /* CONFIG_NFS_V4 */