Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  *  linux/fs/nfs/super.c
0004  *
0005  *  Copyright (C) 1992  Rick Sladkey
0006  *
0007  *  nfs superblock handling functions
0008  *
0009  *  Modularised by Alan Cox <alan@lxorguk.ukuu.org.uk>, while hacking some
0010  *  experimental NFS changes. Modularisation taken straight from SYS5 fs.
0011  *
0012  *  Change to nfs_read_super() to permit NFS mounts to multi-homed hosts.
0013  *  J.S.Peatfield@damtp.cam.ac.uk
0014  *
0015  *  Split from inode.c by David Howells <dhowells@redhat.com>
0016  *
0017  * - superblocks are indexed on server only - all inodes, dentries, etc. associated with a
0018  *   particular server are held in the same superblock
0019  * - NFS superblocks can have several effective roots to the dentry tree
0020  * - directory type roots are spliced into the tree when a path from one root reaches the root
0021  *   of another (see nfs_lookup())
0022  */
0023 
0024 #include <linux/module.h>
0025 #include <linux/init.h>
0026 
0027 #include <linux/time.h>
0028 #include <linux/kernel.h>
0029 #include <linux/mm.h>
0030 #include <linux/string.h>
0031 #include <linux/stat.h>
0032 #include <linux/errno.h>
0033 #include <linux/unistd.h>
0034 #include <linux/sunrpc/clnt.h>
0035 #include <linux/sunrpc/addr.h>
0036 #include <linux/sunrpc/stats.h>
0037 #include <linux/sunrpc/metrics.h>
0038 #include <linux/sunrpc/xprtsock.h>
0039 #include <linux/sunrpc/xprtrdma.h>
0040 #include <linux/nfs_fs.h>
0041 #include <linux/nfs_mount.h>
0042 #include <linux/nfs4_mount.h>
0043 #include <linux/lockd/bind.h>
0044 #include <linux/seq_file.h>
0045 #include <linux/mount.h>
0046 #include <linux/namei.h>
0047 #include <linux/vfs.h>
0048 #include <linux/inet.h>
0049 #include <linux/in6.h>
0050 #include <linux/slab.h>
0051 #include <net/ipv6.h>
0052 #include <linux/netdevice.h>
0053 #include <linux/nfs_xdr.h>
0054 #include <linux/magic.h>
0055 #include <linux/parser.h>
0056 #include <linux/nsproxy.h>
0057 #include <linux/rcupdate.h>
0058 
0059 #include <linux/uaccess.h>
0060 #include <linux/nfs_ssc.h>
0061 
0062 #include "nfs4_fs.h"
0063 #include "callback.h"
0064 #include "delegation.h"
0065 #include "iostat.h"
0066 #include "internal.h"
0067 #include "fscache.h"
0068 #include "nfs4session.h"
0069 #include "pnfs.h"
0070 #include "nfs.h"
0071 
0072 #define NFSDBG_FACILITY     NFSDBG_VFS
0073 
0074 const struct super_operations nfs_sops = {
0075     .alloc_inode    = nfs_alloc_inode,
0076     .free_inode = nfs_free_inode,
0077     .write_inode    = nfs_write_inode,
0078     .drop_inode = nfs_drop_inode,
0079     .statfs     = nfs_statfs,
0080     .evict_inode    = nfs_evict_inode,
0081     .umount_begin   = nfs_umount_begin,
0082     .show_options   = nfs_show_options,
0083     .show_devname   = nfs_show_devname,
0084     .show_path  = nfs_show_path,
0085     .show_stats = nfs_show_stats,
0086 };
0087 EXPORT_SYMBOL_GPL(nfs_sops);
0088 
0089 #ifdef CONFIG_NFS_V4_2
0090 static const struct nfs_ssc_client_ops nfs_ssc_clnt_ops_tbl = {
0091     .sco_sb_deactive = nfs_sb_deactive,
0092 };
0093 #endif
0094 
0095 #if IS_ENABLED(CONFIG_NFS_V4)
0096 static int __init register_nfs4_fs(void)
0097 {
0098     return register_filesystem(&nfs4_fs_type);
0099 }
0100 
0101 static void unregister_nfs4_fs(void)
0102 {
0103     unregister_filesystem(&nfs4_fs_type);
0104 }
0105 #else
0106 static int __init register_nfs4_fs(void)
0107 {
0108     return 0;
0109 }
0110 
0111 static void unregister_nfs4_fs(void)
0112 {
0113 }
0114 #endif
0115 
0116 #ifdef CONFIG_NFS_V4_2
0117 static void nfs_ssc_register_ops(void)
0118 {
0119     nfs_ssc_register(&nfs_ssc_clnt_ops_tbl);
0120 }
0121 
0122 static void nfs_ssc_unregister_ops(void)
0123 {
0124     nfs_ssc_unregister(&nfs_ssc_clnt_ops_tbl);
0125 }
0126 #endif /* CONFIG_NFS_V4_2 */
0127 
0128 static struct shrinker acl_shrinker = {
0129     .count_objects  = nfs_access_cache_count,
0130     .scan_objects   = nfs_access_cache_scan,
0131     .seeks      = DEFAULT_SEEKS,
0132 };
0133 
0134 /*
0135  * Register the NFS filesystems
0136  */
0137 int __init register_nfs_fs(void)
0138 {
0139     int ret;
0140 
0141         ret = register_filesystem(&nfs_fs_type);
0142     if (ret < 0)
0143         goto error_0;
0144 
0145     ret = register_nfs4_fs();
0146     if (ret < 0)
0147         goto error_1;
0148 
0149     ret = nfs_register_sysctl();
0150     if (ret < 0)
0151         goto error_2;
0152     ret = register_shrinker(&acl_shrinker, "nfs-acl");
0153     if (ret < 0)
0154         goto error_3;
0155 #ifdef CONFIG_NFS_V4_2
0156     nfs_ssc_register_ops();
0157 #endif
0158     return 0;
0159 error_3:
0160     nfs_unregister_sysctl();
0161 error_2:
0162     unregister_nfs4_fs();
0163 error_1:
0164     unregister_filesystem(&nfs_fs_type);
0165 error_0:
0166     return ret;
0167 }
0168 
0169 /*
0170  * Unregister the NFS filesystems
0171  */
0172 void __exit unregister_nfs_fs(void)
0173 {
0174     unregister_shrinker(&acl_shrinker);
0175     nfs_unregister_sysctl();
0176     unregister_nfs4_fs();
0177 #ifdef CONFIG_NFS_V4_2
0178     nfs_ssc_unregister_ops();
0179 #endif
0180     unregister_filesystem(&nfs_fs_type);
0181 }
0182 
0183 bool nfs_sb_active(struct super_block *sb)
0184 {
0185     struct nfs_server *server = NFS_SB(sb);
0186 
0187     if (!atomic_inc_not_zero(&sb->s_active))
0188         return false;
0189     if (atomic_inc_return(&server->active) != 1)
0190         atomic_dec(&sb->s_active);
0191     return true;
0192 }
0193 EXPORT_SYMBOL_GPL(nfs_sb_active);
0194 
0195 void nfs_sb_deactive(struct super_block *sb)
0196 {
0197     struct nfs_server *server = NFS_SB(sb);
0198 
0199     if (atomic_dec_and_test(&server->active))
0200         deactivate_super(sb);
0201 }
0202 EXPORT_SYMBOL_GPL(nfs_sb_deactive);
0203 
0204 static int __nfs_list_for_each_server(struct list_head *head,
0205         int (*fn)(struct nfs_server *, void *),
0206         void *data)
0207 {
0208     struct nfs_server *server, *last = NULL;
0209     int ret = 0;
0210 
0211     rcu_read_lock();
0212     list_for_each_entry_rcu(server, head, client_link) {
0213         if (!(server->super && nfs_sb_active(server->super)))
0214             continue;
0215         rcu_read_unlock();
0216         if (last)
0217             nfs_sb_deactive(last->super);
0218         last = server;
0219         ret = fn(server, data);
0220         if (ret)
0221             goto out;
0222         rcu_read_lock();
0223     }
0224     rcu_read_unlock();
0225 out:
0226     if (last)
0227         nfs_sb_deactive(last->super);
0228     return ret;
0229 }
0230 
0231 int nfs_client_for_each_server(struct nfs_client *clp,
0232         int (*fn)(struct nfs_server *, void *),
0233         void *data)
0234 {
0235     return __nfs_list_for_each_server(&clp->cl_superblocks, fn, data);
0236 }
0237 EXPORT_SYMBOL_GPL(nfs_client_for_each_server);
0238 
0239 /*
0240  * Deliver file system statistics to userspace
0241  */
0242 int nfs_statfs(struct dentry *dentry, struct kstatfs *buf)
0243 {
0244     struct nfs_server *server = NFS_SB(dentry->d_sb);
0245     unsigned char blockbits;
0246     unsigned long blockres;
0247     struct nfs_fh *fh = NFS_FH(d_inode(dentry));
0248     struct nfs_fsstat res;
0249     int error = -ENOMEM;
0250 
0251     res.fattr = nfs_alloc_fattr();
0252     if (res.fattr == NULL)
0253         goto out_err;
0254 
0255     error = server->nfs_client->rpc_ops->statfs(server, fh, &res);
0256     if (unlikely(error == -ESTALE)) {
0257         struct dentry *pd_dentry;
0258 
0259         pd_dentry = dget_parent(dentry);
0260         nfs_zap_caches(d_inode(pd_dentry));
0261         dput(pd_dentry);
0262     }
0263     nfs_free_fattr(res.fattr);
0264     if (error < 0)
0265         goto out_err;
0266 
0267     buf->f_type = NFS_SUPER_MAGIC;
0268 
0269     /*
0270      * Current versions of glibc do not correctly handle the
0271      * case where f_frsize != f_bsize.  Eventually we want to
0272      * report the value of wtmult in this field.
0273      */
0274     buf->f_frsize = dentry->d_sb->s_blocksize;
0275 
0276     /*
0277      * On most *nix systems, f_blocks, f_bfree, and f_bavail
0278      * are reported in units of f_frsize.  Linux hasn't had
0279      * an f_frsize field in its statfs struct until recently,
0280      * thus historically Linux's sys_statfs reports these
0281      * fields in units of f_bsize.
0282      */
0283     buf->f_bsize = dentry->d_sb->s_blocksize;
0284     blockbits = dentry->d_sb->s_blocksize_bits;
0285     blockres = (1 << blockbits) - 1;
0286     buf->f_blocks = (res.tbytes + blockres) >> blockbits;
0287     buf->f_bfree = (res.fbytes + blockres) >> blockbits;
0288     buf->f_bavail = (res.abytes + blockres) >> blockbits;
0289 
0290     buf->f_files = res.tfiles;
0291     buf->f_ffree = res.afiles;
0292 
0293     buf->f_namelen = server->namelen;
0294 
0295     return 0;
0296 
0297  out_err:
0298     dprintk("%s: statfs error = %d\n", __func__, -error);
0299     return error;
0300 }
0301 EXPORT_SYMBOL_GPL(nfs_statfs);
0302 
0303 /*
0304  * Map the security flavour number to a name
0305  */
0306 static const char *nfs_pseudoflavour_to_name(rpc_authflavor_t flavour)
0307 {
0308     static const struct {
0309         rpc_authflavor_t flavour;
0310         const char *str;
0311     } sec_flavours[NFS_AUTH_INFO_MAX_FLAVORS] = {
0312         /* update NFS_AUTH_INFO_MAX_FLAVORS when this list changes! */
0313         { RPC_AUTH_NULL, "null" },
0314         { RPC_AUTH_UNIX, "sys" },
0315         { RPC_AUTH_GSS_KRB5, "krb5" },
0316         { RPC_AUTH_GSS_KRB5I, "krb5i" },
0317         { RPC_AUTH_GSS_KRB5P, "krb5p" },
0318         { RPC_AUTH_GSS_LKEY, "lkey" },
0319         { RPC_AUTH_GSS_LKEYI, "lkeyi" },
0320         { RPC_AUTH_GSS_LKEYP, "lkeyp" },
0321         { RPC_AUTH_GSS_SPKM, "spkm" },
0322         { RPC_AUTH_GSS_SPKMI, "spkmi" },
0323         { RPC_AUTH_GSS_SPKMP, "spkmp" },
0324         { UINT_MAX, "unknown" }
0325     };
0326     int i;
0327 
0328     for (i = 0; sec_flavours[i].flavour != UINT_MAX; i++) {
0329         if (sec_flavours[i].flavour == flavour)
0330             break;
0331     }
0332     return sec_flavours[i].str;
0333 }
0334 
0335 static void nfs_show_mountd_netid(struct seq_file *m, struct nfs_server *nfss,
0336                   int showdefaults)
0337 {
0338     struct sockaddr *sap = (struct sockaddr *) &nfss->mountd_address;
0339     char *proto = NULL;
0340 
0341     switch (sap->sa_family) {
0342     case AF_INET:
0343         switch (nfss->mountd_protocol) {
0344         case IPPROTO_UDP:
0345             proto = RPCBIND_NETID_UDP;
0346             break;
0347         case IPPROTO_TCP:
0348             proto = RPCBIND_NETID_TCP;
0349             break;
0350         }
0351         break;
0352     case AF_INET6:
0353         switch (nfss->mountd_protocol) {
0354         case IPPROTO_UDP:
0355             proto = RPCBIND_NETID_UDP6;
0356             break;
0357         case IPPROTO_TCP:
0358             proto = RPCBIND_NETID_TCP6;
0359             break;
0360         }
0361         break;
0362     }
0363     if (proto || showdefaults)
0364         seq_printf(m, ",mountproto=%s", proto ?: "auto");
0365 }
0366 
0367 static void nfs_show_mountd_options(struct seq_file *m, struct nfs_server *nfss,
0368                     int showdefaults)
0369 {
0370     struct sockaddr *sap = (struct sockaddr *)&nfss->mountd_address;
0371 
0372     if (nfss->flags & NFS_MOUNT_LEGACY_INTERFACE)
0373         return;
0374 
0375     switch (sap->sa_family) {
0376     case AF_INET: {
0377         struct sockaddr_in *sin = (struct sockaddr_in *)sap;
0378         seq_printf(m, ",mountaddr=%pI4", &sin->sin_addr.s_addr);
0379         break;
0380     }
0381     case AF_INET6: {
0382         struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sap;
0383         seq_printf(m, ",mountaddr=%pI6c", &sin6->sin6_addr);
0384         break;
0385     }
0386     default:
0387         if (showdefaults)
0388             seq_puts(m, ",mountaddr=unspecified");
0389     }
0390 
0391     if (nfss->mountd_version || showdefaults)
0392         seq_printf(m, ",mountvers=%u", nfss->mountd_version);
0393     if ((nfss->mountd_port &&
0394         nfss->mountd_port != (unsigned short)NFS_UNSPEC_PORT) ||
0395         showdefaults)
0396         seq_printf(m, ",mountport=%u", nfss->mountd_port);
0397 
0398     nfs_show_mountd_netid(m, nfss, showdefaults);
0399 }
0400 
0401 #if IS_ENABLED(CONFIG_NFS_V4)
0402 static void nfs_show_nfsv4_options(struct seq_file *m, struct nfs_server *nfss,
0403                     int showdefaults)
0404 {
0405     struct nfs_client *clp = nfss->nfs_client;
0406 
0407     seq_printf(m, ",clientaddr=%s", clp->cl_ipaddr);
0408 }
0409 #else
0410 static void nfs_show_nfsv4_options(struct seq_file *m, struct nfs_server *nfss,
0411                     int showdefaults)
0412 {
0413 }
0414 #endif
0415 
0416 static void nfs_show_nfs_version(struct seq_file *m,
0417         unsigned int version,
0418         unsigned int minorversion)
0419 {
0420     seq_printf(m, ",vers=%u", version);
0421     if (version == 4)
0422         seq_printf(m, ".%u", minorversion);
0423 }
0424 
0425 /*
0426  * Describe the mount options in force on this server representation
0427  */
0428 static void nfs_show_mount_options(struct seq_file *m, struct nfs_server *nfss,
0429                    int showdefaults)
0430 {
0431     static const struct proc_nfs_info {
0432         int flag;
0433         const char *str;
0434         const char *nostr;
0435     } nfs_info[] = {
0436         { NFS_MOUNT_SOFT, ",soft", "" },
0437         { NFS_MOUNT_SOFTERR, ",softerr", "" },
0438         { NFS_MOUNT_SOFTREVAL, ",softreval", "" },
0439         { NFS_MOUNT_POSIX, ",posix", "" },
0440         { NFS_MOUNT_NOCTO, ",nocto", "" },
0441         { NFS_MOUNT_NOAC, ",noac", "" },
0442         { NFS_MOUNT_NONLM, ",nolock", "" },
0443         { NFS_MOUNT_NOACL, ",noacl", "" },
0444         { NFS_MOUNT_NORDIRPLUS, ",nordirplus", "" },
0445         { NFS_MOUNT_UNSHARED, ",nosharecache", "" },
0446         { NFS_MOUNT_NORESVPORT, ",noresvport", "" },
0447         { 0, NULL, NULL }
0448     };
0449     const struct proc_nfs_info *nfs_infop;
0450     struct nfs_client *clp = nfss->nfs_client;
0451     u32 version = clp->rpc_ops->version;
0452     int local_flock, local_fcntl;
0453 
0454     nfs_show_nfs_version(m, version, clp->cl_minorversion);
0455     seq_printf(m, ",rsize=%u", nfss->rsize);
0456     seq_printf(m, ",wsize=%u", nfss->wsize);
0457     if (nfss->bsize != 0)
0458         seq_printf(m, ",bsize=%u", nfss->bsize);
0459     seq_printf(m, ",namlen=%u", nfss->namelen);
0460     if (nfss->acregmin != NFS_DEF_ACREGMIN*HZ || showdefaults)
0461         seq_printf(m, ",acregmin=%u", nfss->acregmin/HZ);
0462     if (nfss->acregmax != NFS_DEF_ACREGMAX*HZ || showdefaults)
0463         seq_printf(m, ",acregmax=%u", nfss->acregmax/HZ);
0464     if (nfss->acdirmin != NFS_DEF_ACDIRMIN*HZ || showdefaults)
0465         seq_printf(m, ",acdirmin=%u", nfss->acdirmin/HZ);
0466     if (nfss->acdirmax != NFS_DEF_ACDIRMAX*HZ || showdefaults)
0467         seq_printf(m, ",acdirmax=%u", nfss->acdirmax/HZ);
0468     if (!(nfss->flags & (NFS_MOUNT_SOFT|NFS_MOUNT_SOFTERR)))
0469             seq_puts(m, ",hard");
0470     for (nfs_infop = nfs_info; nfs_infop->flag; nfs_infop++) {
0471         if (nfss->flags & nfs_infop->flag)
0472             seq_puts(m, nfs_infop->str);
0473         else
0474             seq_puts(m, nfs_infop->nostr);
0475     }
0476     rcu_read_lock();
0477     seq_printf(m, ",proto=%s",
0478            rpc_peeraddr2str(nfss->client, RPC_DISPLAY_NETID));
0479     rcu_read_unlock();
0480     if (clp->cl_nconnect > 0)
0481         seq_printf(m, ",nconnect=%u", clp->cl_nconnect);
0482     if (version == 4) {
0483         if (clp->cl_max_connect > 1)
0484             seq_printf(m, ",max_connect=%u", clp->cl_max_connect);
0485         if (nfss->port != NFS_PORT)
0486             seq_printf(m, ",port=%u", nfss->port);
0487     } else
0488         if (nfss->port)
0489             seq_printf(m, ",port=%u", nfss->port);
0490 
0491     seq_printf(m, ",timeo=%lu", 10U * nfss->client->cl_timeout->to_initval / HZ);
0492     seq_printf(m, ",retrans=%u", nfss->client->cl_timeout->to_retries);
0493     seq_printf(m, ",sec=%s", nfs_pseudoflavour_to_name(nfss->client->cl_auth->au_flavor));
0494 
0495     if (version != 4)
0496         nfs_show_mountd_options(m, nfss, showdefaults);
0497     else
0498         nfs_show_nfsv4_options(m, nfss, showdefaults);
0499 
0500     if (nfss->options & NFS_OPTION_FSCACHE)
0501         seq_puts(m, ",fsc");
0502 
0503     if (nfss->options & NFS_OPTION_MIGRATION)
0504         seq_puts(m, ",migration");
0505 
0506     if (nfss->flags & NFS_MOUNT_LOOKUP_CACHE_NONEG) {
0507         if (nfss->flags & NFS_MOUNT_LOOKUP_CACHE_NONE)
0508             seq_puts(m, ",lookupcache=none");
0509         else
0510             seq_puts(m, ",lookupcache=pos");
0511     }
0512 
0513     local_flock = nfss->flags & NFS_MOUNT_LOCAL_FLOCK;
0514     local_fcntl = nfss->flags & NFS_MOUNT_LOCAL_FCNTL;
0515 
0516     if (!local_flock && !local_fcntl)
0517         seq_puts(m, ",local_lock=none");
0518     else if (local_flock && local_fcntl)
0519         seq_puts(m, ",local_lock=all");
0520     else if (local_flock)
0521         seq_puts(m, ",local_lock=flock");
0522     else
0523         seq_puts(m, ",local_lock=posix");
0524 
0525     if (nfss->flags & NFS_MOUNT_WRITE_EAGER) {
0526         if (nfss->flags & NFS_MOUNT_WRITE_WAIT)
0527             seq_puts(m, ",write=wait");
0528         else
0529             seq_puts(m, ",write=eager");
0530     }
0531 }
0532 
0533 /*
0534  * Describe the mount options on this VFS mountpoint
0535  */
0536 int nfs_show_options(struct seq_file *m, struct dentry *root)
0537 {
0538     struct nfs_server *nfss = NFS_SB(root->d_sb);
0539 
0540     nfs_show_mount_options(m, nfss, 0);
0541 
0542     rcu_read_lock();
0543     seq_printf(m, ",addr=%s",
0544             rpc_peeraddr2str(nfss->nfs_client->cl_rpcclient,
0545                             RPC_DISPLAY_ADDR));
0546     rcu_read_unlock();
0547 
0548     return 0;
0549 }
0550 EXPORT_SYMBOL_GPL(nfs_show_options);
0551 
0552 #if IS_ENABLED(CONFIG_NFS_V4)
0553 static void show_lease(struct seq_file *m, struct nfs_server *server)
0554 {
0555     struct nfs_client *clp = server->nfs_client;
0556     unsigned long expire;
0557 
0558     seq_printf(m, ",lease_time=%ld", clp->cl_lease_time / HZ);
0559     expire = clp->cl_last_renewal + clp->cl_lease_time;
0560     seq_printf(m, ",lease_expired=%ld",
0561            time_after(expire, jiffies) ?  0 : (jiffies - expire) / HZ);
0562 }
0563 #ifdef CONFIG_NFS_V4_1
0564 static void show_sessions(struct seq_file *m, struct nfs_server *server)
0565 {
0566     if (nfs4_has_session(server->nfs_client))
0567         seq_puts(m, ",sessions");
0568 }
0569 #else
0570 static void show_sessions(struct seq_file *m, struct nfs_server *server) {}
0571 #endif
0572 #endif
0573 
0574 #ifdef CONFIG_NFS_V4_1
0575 static void show_pnfs(struct seq_file *m, struct nfs_server *server)
0576 {
0577     seq_printf(m, ",pnfs=");
0578     if (server->pnfs_curr_ld)
0579         seq_printf(m, "%s", server->pnfs_curr_ld->name);
0580     else
0581         seq_printf(m, "not configured");
0582 }
0583 
0584 static void show_implementation_id(struct seq_file *m, struct nfs_server *nfss)
0585 {
0586     if (nfss->nfs_client && nfss->nfs_client->cl_implid) {
0587         struct nfs41_impl_id *impl_id = nfss->nfs_client->cl_implid;
0588         seq_printf(m, "\n\timpl_id:\tname='%s',domain='%s',"
0589                "date='%llu,%u'",
0590                impl_id->name, impl_id->domain,
0591                impl_id->date.seconds, impl_id->date.nseconds);
0592     }
0593 }
0594 #else
0595 #if IS_ENABLED(CONFIG_NFS_V4)
0596 static void show_pnfs(struct seq_file *m, struct nfs_server *server)
0597 {
0598 }
0599 #endif
0600 static void show_implementation_id(struct seq_file *m, struct nfs_server *nfss)
0601 {
0602 }
0603 #endif
0604 
0605 int nfs_show_devname(struct seq_file *m, struct dentry *root)
0606 {
0607     char *page = (char *) __get_free_page(GFP_KERNEL);
0608     char *devname, *dummy;
0609     int err = 0;
0610     if (!page)
0611         return -ENOMEM;
0612     devname = nfs_path(&dummy, root, page, PAGE_SIZE, 0);
0613     if (IS_ERR(devname))
0614         err = PTR_ERR(devname);
0615     else
0616         seq_escape(m, devname, " \t\n\\");
0617     free_page((unsigned long)page);
0618     return err;
0619 }
0620 EXPORT_SYMBOL_GPL(nfs_show_devname);
0621 
0622 int nfs_show_path(struct seq_file *m, struct dentry *dentry)
0623 {
0624     seq_puts(m, "/");
0625     return 0;
0626 }
0627 EXPORT_SYMBOL_GPL(nfs_show_path);
0628 
0629 /*
0630  * Present statistical information for this VFS mountpoint
0631  */
0632 int nfs_show_stats(struct seq_file *m, struct dentry *root)
0633 {
0634     int i, cpu;
0635     struct nfs_server *nfss = NFS_SB(root->d_sb);
0636     struct rpc_auth *auth = nfss->client->cl_auth;
0637     struct nfs_iostats totals = { };
0638 
0639     seq_printf(m, "statvers=%s", NFS_IOSTAT_VERS);
0640 
0641     /*
0642      * Display all mount option settings
0643      */
0644     seq_puts(m, "\n\topts:\t");
0645     seq_puts(m, sb_rdonly(root->d_sb) ? "ro" : "rw");
0646     seq_puts(m, root->d_sb->s_flags & SB_SYNCHRONOUS ? ",sync" : "");
0647     seq_puts(m, root->d_sb->s_flags & SB_NOATIME ? ",noatime" : "");
0648     seq_puts(m, root->d_sb->s_flags & SB_NODIRATIME ? ",nodiratime" : "");
0649     nfs_show_mount_options(m, nfss, 1);
0650 
0651     seq_printf(m, "\n\tage:\t%lu", (jiffies - nfss->mount_time) / HZ);
0652 
0653     show_implementation_id(m, nfss);
0654 
0655     seq_puts(m, "\n\tcaps:\t");
0656     seq_printf(m, "caps=0x%x", nfss->caps);
0657     seq_printf(m, ",wtmult=%u", nfss->wtmult);
0658     seq_printf(m, ",dtsize=%u", nfss->dtsize);
0659     seq_printf(m, ",bsize=%u", nfss->bsize);
0660     seq_printf(m, ",namlen=%u", nfss->namelen);
0661 
0662 #if IS_ENABLED(CONFIG_NFS_V4)
0663     if (nfss->nfs_client->rpc_ops->version == 4) {
0664         seq_puts(m, "\n\tnfsv4:\t");
0665         seq_printf(m, "bm0=0x%x", nfss->attr_bitmask[0]);
0666         seq_printf(m, ",bm1=0x%x", nfss->attr_bitmask[1]);
0667         seq_printf(m, ",bm2=0x%x", nfss->attr_bitmask[2]);
0668         seq_printf(m, ",acl=0x%x", nfss->acl_bitmask);
0669         show_sessions(m, nfss);
0670         show_pnfs(m, nfss);
0671         show_lease(m, nfss);
0672     }
0673 #endif
0674 
0675     /*
0676      * Display security flavor in effect for this mount
0677      */
0678     seq_printf(m, "\n\tsec:\tflavor=%u", auth->au_ops->au_flavor);
0679     if (auth->au_flavor)
0680         seq_printf(m, ",pseudoflavor=%u", auth->au_flavor);
0681 
0682     /*
0683      * Display superblock I/O counters
0684      */
0685     for_each_possible_cpu(cpu) {
0686         struct nfs_iostats *stats;
0687 
0688         preempt_disable();
0689         stats = per_cpu_ptr(nfss->io_stats, cpu);
0690 
0691         for (i = 0; i < __NFSIOS_COUNTSMAX; i++)
0692             totals.events[i] += stats->events[i];
0693         for (i = 0; i < __NFSIOS_BYTESMAX; i++)
0694             totals.bytes[i] += stats->bytes[i];
0695 #ifdef CONFIG_NFS_FSCACHE
0696         for (i = 0; i < __NFSIOS_FSCACHEMAX; i++)
0697             totals.fscache[i] += stats->fscache[i];
0698 #endif
0699 
0700         preempt_enable();
0701     }
0702 
0703     seq_puts(m, "\n\tevents:\t");
0704     for (i = 0; i < __NFSIOS_COUNTSMAX; i++)
0705         seq_printf(m, "%lu ", totals.events[i]);
0706     seq_puts(m, "\n\tbytes:\t");
0707     for (i = 0; i < __NFSIOS_BYTESMAX; i++)
0708         seq_printf(m, "%Lu ", totals.bytes[i]);
0709 #ifdef CONFIG_NFS_FSCACHE
0710     if (nfss->options & NFS_OPTION_FSCACHE) {
0711         seq_puts(m, "\n\tfsc:\t");
0712         for (i = 0; i < __NFSIOS_FSCACHEMAX; i++)
0713             seq_printf(m, "%Lu ", totals.fscache[i]);
0714     }
0715 #endif
0716     seq_putc(m, '\n');
0717 
0718     rpc_clnt_show_stats(m, nfss->client);
0719 
0720     return 0;
0721 }
0722 EXPORT_SYMBOL_GPL(nfs_show_stats);
0723 
0724 /*
0725  * Begin unmount by attempting to remove all automounted mountpoints we added
0726  * in response to xdev traversals and referrals
0727  */
0728 void nfs_umount_begin(struct super_block *sb)
0729 {
0730     struct nfs_server *server;
0731     struct rpc_clnt *rpc;
0732 
0733     server = NFS_SB(sb);
0734     /* -EIO all pending I/O */
0735     rpc = server->client_acl;
0736     if (!IS_ERR(rpc))
0737         rpc_killall_tasks(rpc);
0738     rpc = server->client;
0739     if (!IS_ERR(rpc))
0740         rpc_killall_tasks(rpc);
0741 }
0742 EXPORT_SYMBOL_GPL(nfs_umount_begin);
0743 
0744 /*
0745  * Return true if 'match' is in auth_info or auth_info is empty.
0746  * Return false otherwise.
0747  */
0748 bool nfs_auth_info_match(const struct nfs_auth_info *auth_info,
0749              rpc_authflavor_t match)
0750 {
0751     int i;
0752 
0753     if (!auth_info->flavor_len)
0754         return true;
0755 
0756     for (i = 0; i < auth_info->flavor_len; i++) {
0757         if (auth_info->flavors[i] == match)
0758             return true;
0759     }
0760     return false;
0761 }
0762 EXPORT_SYMBOL_GPL(nfs_auth_info_match);
0763 
0764 /*
0765  * Ensure that a specified authtype in ctx->auth_info is supported by
0766  * the server. Returns 0 and sets ctx->selected_flavor if it's ok, and
0767  * -EACCES if not.
0768  */
0769 static int nfs_verify_authflavors(struct nfs_fs_context *ctx,
0770                   rpc_authflavor_t *server_authlist,
0771                   unsigned int count)
0772 {
0773     rpc_authflavor_t flavor = RPC_AUTH_MAXFLAVOR;
0774     bool found_auth_null = false;
0775     unsigned int i;
0776 
0777     /*
0778      * If the sec= mount option is used, the specified flavor or AUTH_NULL
0779      * must be in the list returned by the server.
0780      *
0781      * AUTH_NULL has a special meaning when it's in the server list - it
0782      * means that the server will ignore the rpc creds, so any flavor
0783      * can be used but still use the sec= that was specified.
0784      *
0785      * Note also that the MNT procedure in MNTv1 does not return a list
0786      * of supported security flavors. In this case, nfs_mount() fabricates
0787      * a security flavor list containing just AUTH_NULL.
0788      */
0789     for (i = 0; i < count; i++) {
0790         flavor = server_authlist[i];
0791 
0792         if (nfs_auth_info_match(&ctx->auth_info, flavor))
0793             goto out;
0794 
0795         if (flavor == RPC_AUTH_NULL)
0796             found_auth_null = true;
0797     }
0798 
0799     if (found_auth_null) {
0800         flavor = ctx->auth_info.flavors[0];
0801         goto out;
0802     }
0803 
0804     dfprintk(MOUNT,
0805          "NFS: specified auth flavors not supported by server\n");
0806     return -EACCES;
0807 
0808 out:
0809     ctx->selected_flavor = flavor;
0810     dfprintk(MOUNT, "NFS: using auth flavor %u\n", ctx->selected_flavor);
0811     return 0;
0812 }
0813 
0814 /*
0815  * Use the remote server's MOUNT service to request the NFS file handle
0816  * corresponding to the provided path.
0817  */
0818 static int nfs_request_mount(struct fs_context *fc,
0819                  struct nfs_fh *root_fh,
0820                  rpc_authflavor_t *server_authlist,
0821                  unsigned int *server_authlist_len)
0822 {
0823     struct nfs_fs_context *ctx = nfs_fc2context(fc);
0824     struct nfs_mount_request request = {
0825         .sap        = (struct sockaddr *)
0826                         &ctx->mount_server.address,
0827         .dirpath    = ctx->nfs_server.export_path,
0828         .protocol   = ctx->mount_server.protocol,
0829         .fh     = root_fh,
0830         .noresvport = ctx->flags & NFS_MOUNT_NORESVPORT,
0831         .auth_flav_len  = server_authlist_len,
0832         .auth_flavs = server_authlist,
0833         .net        = fc->net_ns,
0834     };
0835     int status;
0836 
0837     if (ctx->mount_server.version == 0) {
0838         switch (ctx->version) {
0839             default:
0840                 ctx->mount_server.version = NFS_MNT3_VERSION;
0841                 break;
0842             case 2:
0843                 ctx->mount_server.version = NFS_MNT_VERSION;
0844         }
0845     }
0846     request.version = ctx->mount_server.version;
0847 
0848     if (ctx->mount_server.hostname)
0849         request.hostname = ctx->mount_server.hostname;
0850     else
0851         request.hostname = ctx->nfs_server.hostname;
0852 
0853     /*
0854      * Construct the mount server's address.
0855      */
0856     if (ctx->mount_server.address.sa_family == AF_UNSPEC) {
0857         memcpy(request.sap, &ctx->nfs_server.address,
0858                ctx->nfs_server.addrlen);
0859         ctx->mount_server.addrlen = ctx->nfs_server.addrlen;
0860     }
0861     request.salen = ctx->mount_server.addrlen;
0862     nfs_set_port(request.sap, &ctx->mount_server.port, 0);
0863 
0864     /*
0865      * Now ask the mount server to map our export path
0866      * to a file handle.
0867      */
0868     status = nfs_mount(&request, ctx->timeo, ctx->retrans);
0869     if (status != 0) {
0870         dfprintk(MOUNT, "NFS: unable to mount server %s, error %d\n",
0871                 request.hostname, status);
0872         return status;
0873     }
0874 
0875     return 0;
0876 }
0877 
0878 static struct nfs_server *nfs_try_mount_request(struct fs_context *fc)
0879 {
0880     struct nfs_fs_context *ctx = nfs_fc2context(fc);
0881     int status;
0882     unsigned int i;
0883     bool tried_auth_unix = false;
0884     bool auth_null_in_list = false;
0885     struct nfs_server *server = ERR_PTR(-EACCES);
0886     rpc_authflavor_t authlist[NFS_MAX_SECFLAVORS];
0887     unsigned int authlist_len = ARRAY_SIZE(authlist);
0888 
0889     status = nfs_request_mount(fc, ctx->mntfh, authlist, &authlist_len);
0890     if (status)
0891         return ERR_PTR(status);
0892 
0893     /*
0894      * Was a sec= authflavor specified in the options? First, verify
0895      * whether the server supports it, and then just try to use it if so.
0896      */
0897     if (ctx->auth_info.flavor_len > 0) {
0898         status = nfs_verify_authflavors(ctx, authlist, authlist_len);
0899         dfprintk(MOUNT, "NFS: using auth flavor %u\n",
0900              ctx->selected_flavor);
0901         if (status)
0902             return ERR_PTR(status);
0903         return ctx->nfs_mod->rpc_ops->create_server(fc);
0904     }
0905 
0906     /*
0907      * No sec= option was provided. RFC 2623, section 2.7 suggests we
0908      * SHOULD prefer the flavor listed first. However, some servers list
0909      * AUTH_NULL first. Avoid ever choosing AUTH_NULL.
0910      */
0911     for (i = 0; i < authlist_len; ++i) {
0912         rpc_authflavor_t flavor;
0913         struct rpcsec_gss_info info;
0914 
0915         flavor = authlist[i];
0916         switch (flavor) {
0917         case RPC_AUTH_UNIX:
0918             tried_auth_unix = true;
0919             break;
0920         case RPC_AUTH_NULL:
0921             auth_null_in_list = true;
0922             continue;
0923         default:
0924             if (rpcauth_get_gssinfo(flavor, &info) != 0)
0925                 continue;
0926             break;
0927         }
0928         dfprintk(MOUNT, "NFS: attempting to use auth flavor %u\n", flavor);
0929         ctx->selected_flavor = flavor;
0930         server = ctx->nfs_mod->rpc_ops->create_server(fc);
0931         if (!IS_ERR(server))
0932             return server;
0933     }
0934 
0935     /*
0936      * Nothing we tried so far worked. At this point, give up if we've
0937      * already tried AUTH_UNIX or if the server's list doesn't contain
0938      * AUTH_NULL
0939      */
0940     if (tried_auth_unix || !auth_null_in_list)
0941         return server;
0942 
0943     /* Last chance! Try AUTH_UNIX */
0944     dfprintk(MOUNT, "NFS: attempting to use auth flavor %u\n", RPC_AUTH_UNIX);
0945     ctx->selected_flavor = RPC_AUTH_UNIX;
0946     return ctx->nfs_mod->rpc_ops->create_server(fc);
0947 }
0948 
0949 int nfs_try_get_tree(struct fs_context *fc)
0950 {
0951     struct nfs_fs_context *ctx = nfs_fc2context(fc);
0952 
0953     if (ctx->need_mount)
0954         ctx->server = nfs_try_mount_request(fc);
0955     else
0956         ctx->server = ctx->nfs_mod->rpc_ops->create_server(fc);
0957 
0958     return nfs_get_tree_common(fc);
0959 }
0960 EXPORT_SYMBOL_GPL(nfs_try_get_tree);
0961 
0962 
0963 #define NFS_REMOUNT_CMP_FLAGMASK ~(NFS_MOUNT_INTR \
0964         | NFS_MOUNT_SECURE \
0965         | NFS_MOUNT_TCP \
0966         | NFS_MOUNT_VER3 \
0967         | NFS_MOUNT_KERBEROS \
0968         | NFS_MOUNT_NONLM \
0969         | NFS_MOUNT_BROKEN_SUID \
0970         | NFS_MOUNT_STRICTLOCK \
0971         | NFS_MOUNT_LEGACY_INTERFACE)
0972 
0973 #define NFS_MOUNT_CMP_FLAGMASK (NFS_REMOUNT_CMP_FLAGMASK & \
0974         ~(NFS_MOUNT_UNSHARED | NFS_MOUNT_NORESVPORT))
0975 
0976 static int
0977 nfs_compare_remount_data(struct nfs_server *nfss,
0978              struct nfs_fs_context *ctx)
0979 {
0980     if ((ctx->flags ^ nfss->flags) & NFS_REMOUNT_CMP_FLAGMASK ||
0981         ctx->rsize != nfss->rsize ||
0982         ctx->wsize != nfss->wsize ||
0983         ctx->version != nfss->nfs_client->rpc_ops->version ||
0984         ctx->minorversion != nfss->nfs_client->cl_minorversion ||
0985         ctx->retrans != nfss->client->cl_timeout->to_retries ||
0986         !nfs_auth_info_match(&ctx->auth_info, nfss->client->cl_auth->au_flavor) ||
0987         ctx->acregmin != nfss->acregmin / HZ ||
0988         ctx->acregmax != nfss->acregmax / HZ ||
0989         ctx->acdirmin != nfss->acdirmin / HZ ||
0990         ctx->acdirmax != nfss->acdirmax / HZ ||
0991         ctx->timeo != (10U * nfss->client->cl_timeout->to_initval / HZ) ||
0992         (ctx->options & NFS_OPTION_FSCACHE) != (nfss->options & NFS_OPTION_FSCACHE) ||
0993         ctx->nfs_server.port != nfss->port ||
0994         ctx->nfs_server.addrlen != nfss->nfs_client->cl_addrlen ||
0995         !rpc_cmp_addr((struct sockaddr *)&ctx->nfs_server.address,
0996               (struct sockaddr *)&nfss->nfs_client->cl_addr))
0997         return -EINVAL;
0998 
0999     return 0;
1000 }
1001 
1002 int nfs_reconfigure(struct fs_context *fc)
1003 {
1004     struct nfs_fs_context *ctx = nfs_fc2context(fc);
1005     struct super_block *sb = fc->root->d_sb;
1006     struct nfs_server *nfss = sb->s_fs_info;
1007     int ret;
1008 
1009     sync_filesystem(sb);
1010 
1011     /*
1012      * Userspace mount programs that send binary options generally send
1013      * them populated with default values. We have no way to know which
1014      * ones were explicitly specified. Fall back to legacy behavior and
1015      * just return success.
1016      */
1017     if (ctx->skip_reconfig_option_check)
1018         return 0;
1019 
1020     /*
1021      * noac is a special case. It implies -o sync, but that's not
1022      * necessarily reflected in the mtab options. reconfigure_super
1023      * will clear SB_SYNCHRONOUS if -o sync wasn't specified in the
1024      * remount options, so we have to explicitly reset it.
1025      */
1026     if (ctx->flags & NFS_MOUNT_NOAC) {
1027         fc->sb_flags |= SB_SYNCHRONOUS;
1028         fc->sb_flags_mask |= SB_SYNCHRONOUS;
1029     }
1030 
1031     /* compare new mount options with old ones */
1032     ret = nfs_compare_remount_data(nfss, ctx);
1033     if (ret)
1034         return ret;
1035 
1036     return nfs_probe_server(nfss, NFS_FH(d_inode(fc->root)));
1037 }
1038 EXPORT_SYMBOL_GPL(nfs_reconfigure);
1039 
1040 /*
1041  * Finish setting up an NFS superblock
1042  */
1043 static void nfs_fill_super(struct super_block *sb, struct nfs_fs_context *ctx)
1044 {
1045     struct nfs_server *server = NFS_SB(sb);
1046 
1047     sb->s_blocksize_bits = 0;
1048     sb->s_blocksize = 0;
1049     sb->s_xattr = server->nfs_client->cl_nfs_mod->xattr;
1050     sb->s_op = server->nfs_client->cl_nfs_mod->sops;
1051     if (ctx->bsize)
1052         sb->s_blocksize = nfs_block_size(ctx->bsize, &sb->s_blocksize_bits);
1053 
1054     switch (server->nfs_client->rpc_ops->version) {
1055     case 2:
1056         sb->s_time_gran = 1000;
1057         sb->s_time_min = 0;
1058         sb->s_time_max = U32_MAX;
1059         break;
1060     case 3:
1061         /*
1062          * The VFS shouldn't apply the umask to mode bits.
1063          * We will do so ourselves when necessary.
1064          */
1065         sb->s_flags |= SB_POSIXACL;
1066         sb->s_time_gran = 1;
1067         sb->s_time_min = 0;
1068         sb->s_time_max = U32_MAX;
1069         sb->s_export_op = &nfs_export_ops;
1070         break;
1071     case 4:
1072         sb->s_flags |= SB_POSIXACL;
1073         sb->s_time_gran = 1;
1074         sb->s_time_min = S64_MIN;
1075         sb->s_time_max = S64_MAX;
1076         if (server->caps & NFS_CAP_ATOMIC_OPEN_V1)
1077             sb->s_export_op = &nfs_export_ops;
1078         break;
1079     }
1080 
1081     sb->s_magic = NFS_SUPER_MAGIC;
1082 
1083     /* We probably want something more informative here */
1084     snprintf(sb->s_id, sizeof(sb->s_id),
1085          "%u:%u", MAJOR(sb->s_dev), MINOR(sb->s_dev));
1086 
1087     if (sb->s_blocksize == 0)
1088         sb->s_blocksize = nfs_block_bits(server->wsize,
1089                          &sb->s_blocksize_bits);
1090 
1091     nfs_super_set_maxbytes(sb, server->maxfilesize);
1092     server->has_sec_mnt_opts = ctx->has_sec_mnt_opts;
1093 }
1094 
1095 static int nfs_compare_mount_options(const struct super_block *s, const struct nfs_server *b,
1096                      const struct fs_context *fc)
1097 {
1098     const struct nfs_server *a = s->s_fs_info;
1099     const struct rpc_clnt *clnt_a = a->client;
1100     const struct rpc_clnt *clnt_b = b->client;
1101 
1102     if ((s->s_flags & NFS_SB_MASK) != (fc->sb_flags & NFS_SB_MASK))
1103         goto Ebusy;
1104     if (a->nfs_client != b->nfs_client)
1105         goto Ebusy;
1106     if ((a->flags ^ b->flags) & NFS_MOUNT_CMP_FLAGMASK)
1107         goto Ebusy;
1108     if (a->wsize != b->wsize)
1109         goto Ebusy;
1110     if (a->rsize != b->rsize)
1111         goto Ebusy;
1112     if (a->acregmin != b->acregmin)
1113         goto Ebusy;
1114     if (a->acregmax != b->acregmax)
1115         goto Ebusy;
1116     if (a->acdirmin != b->acdirmin)
1117         goto Ebusy;
1118     if (a->acdirmax != b->acdirmax)
1119         goto Ebusy;
1120     if (clnt_a->cl_auth->au_flavor != clnt_b->cl_auth->au_flavor)
1121         goto Ebusy;
1122     return 1;
1123 Ebusy:
1124     return 0;
1125 }
1126 
1127 static int nfs_set_super(struct super_block *s, struct fs_context *fc)
1128 {
1129     struct nfs_server *server = fc->s_fs_info;
1130     int ret;
1131 
1132     s->s_d_op = server->nfs_client->rpc_ops->dentry_ops;
1133     ret = set_anon_super(s, server);
1134     if (ret == 0)
1135         server->s_dev = s->s_dev;
1136     return ret;
1137 }
1138 
1139 static int nfs_compare_super_address(struct nfs_server *server1,
1140                      struct nfs_server *server2)
1141 {
1142     struct sockaddr *sap1, *sap2;
1143     struct rpc_xprt *xprt1 = server1->client->cl_xprt;
1144     struct rpc_xprt *xprt2 = server2->client->cl_xprt;
1145 
1146     if (!net_eq(xprt1->xprt_net, xprt2->xprt_net))
1147         return 0;
1148 
1149     sap1 = (struct sockaddr *)&server1->nfs_client->cl_addr;
1150     sap2 = (struct sockaddr *)&server2->nfs_client->cl_addr;
1151 
1152     if (sap1->sa_family != sap2->sa_family)
1153         return 0;
1154 
1155     switch (sap1->sa_family) {
1156     case AF_INET: {
1157         struct sockaddr_in *sin1 = (struct sockaddr_in *)sap1;
1158         struct sockaddr_in *sin2 = (struct sockaddr_in *)sap2;
1159         if (sin1->sin_addr.s_addr != sin2->sin_addr.s_addr)
1160             return 0;
1161         if (sin1->sin_port != sin2->sin_port)
1162             return 0;
1163         break;
1164     }
1165     case AF_INET6: {
1166         struct sockaddr_in6 *sin1 = (struct sockaddr_in6 *)sap1;
1167         struct sockaddr_in6 *sin2 = (struct sockaddr_in6 *)sap2;
1168         if (!ipv6_addr_equal(&sin1->sin6_addr, &sin2->sin6_addr))
1169             return 0;
1170         if (sin1->sin6_port != sin2->sin6_port)
1171             return 0;
1172         break;
1173     }
1174     default:
1175         return 0;
1176     }
1177 
1178     return 1;
1179 }
1180 
1181 static int nfs_compare_userns(const struct nfs_server *old,
1182         const struct nfs_server *new)
1183 {
1184     const struct user_namespace *oldns = &init_user_ns;
1185     const struct user_namespace *newns = &init_user_ns;
1186 
1187     if (old->client && old->client->cl_cred)
1188         oldns = old->client->cl_cred->user_ns;
1189     if (new->client && new->client->cl_cred)
1190         newns = new->client->cl_cred->user_ns;
1191     if (oldns != newns)
1192         return 0;
1193     return 1;
1194 }
1195 
1196 static int nfs_compare_super(struct super_block *sb, struct fs_context *fc)
1197 {
1198     struct nfs_server *server = fc->s_fs_info, *old = NFS_SB(sb);
1199 
1200     if (!nfs_compare_super_address(old, server))
1201         return 0;
1202     /* Note: NFS_MOUNT_UNSHARED == NFS4_MOUNT_UNSHARED */
1203     if (old->flags & NFS_MOUNT_UNSHARED)
1204         return 0;
1205     if (memcmp(&old->fsid, &server->fsid, sizeof(old->fsid)) != 0)
1206         return 0;
1207     if (!nfs_compare_userns(old, server))
1208         return 0;
1209     if ((old->has_sec_mnt_opts || fc->security) &&
1210             security_sb_mnt_opts_compat(sb, fc->security))
1211         return 0;
1212     return nfs_compare_mount_options(sb, server, fc);
1213 }
1214 
1215 #ifdef CONFIG_NFS_FSCACHE
1216 static int nfs_get_cache_cookie(struct super_block *sb,
1217                 struct nfs_fs_context *ctx)
1218 {
1219     struct nfs_server *nfss = NFS_SB(sb);
1220     char *uniq = NULL;
1221     int ulen = 0;
1222 
1223     nfss->fscache = NULL;
1224 
1225     if (!ctx)
1226         return 0;
1227 
1228     if (ctx->clone_data.sb) {
1229         struct nfs_server *mnt_s = NFS_SB(ctx->clone_data.sb);
1230         if (!(mnt_s->options & NFS_OPTION_FSCACHE))
1231             return 0;
1232         if (mnt_s->fscache_uniq) {
1233             uniq = mnt_s->fscache_uniq;
1234             ulen = strlen(uniq);
1235         }
1236     } else {
1237         if (!(ctx->options & NFS_OPTION_FSCACHE))
1238             return 0;
1239         if (ctx->fscache_uniq) {
1240             uniq = ctx->fscache_uniq;
1241             ulen = strlen(ctx->fscache_uniq);
1242         }
1243     }
1244 
1245     return nfs_fscache_get_super_cookie(sb, uniq, ulen);
1246 }
1247 #else
1248 static int nfs_get_cache_cookie(struct super_block *sb,
1249                 struct nfs_fs_context *ctx)
1250 {
1251     return 0;
1252 }
1253 #endif
1254 
1255 int nfs_get_tree_common(struct fs_context *fc)
1256 {
1257     struct nfs_fs_context *ctx = nfs_fc2context(fc);
1258     struct super_block *s;
1259     int (*compare_super)(struct super_block *, struct fs_context *) = nfs_compare_super;
1260     struct nfs_server *server = ctx->server;
1261     int error;
1262 
1263     ctx->server = NULL;
1264     if (IS_ERR(server))
1265         return PTR_ERR(server);
1266 
1267     if (server->flags & NFS_MOUNT_UNSHARED)
1268         compare_super = NULL;
1269 
1270     /* -o noac implies -o sync */
1271     if (server->flags & NFS_MOUNT_NOAC)
1272         fc->sb_flags |= SB_SYNCHRONOUS;
1273 
1274     if (ctx->clone_data.sb)
1275         if (ctx->clone_data.sb->s_flags & SB_SYNCHRONOUS)
1276             fc->sb_flags |= SB_SYNCHRONOUS;
1277 
1278     if (server->caps & NFS_CAP_SECURITY_LABEL)
1279         fc->lsm_flags |= SECURITY_LSM_NATIVE_LABELS;
1280 
1281     /* Get a superblock - note that we may end up sharing one that already exists */
1282     fc->s_fs_info = server;
1283     s = sget_fc(fc, compare_super, nfs_set_super);
1284     fc->s_fs_info = NULL;
1285     if (IS_ERR(s)) {
1286         error = PTR_ERR(s);
1287         nfs_errorf(fc, "NFS: Couldn't get superblock");
1288         goto out_err_nosb;
1289     }
1290 
1291     if (s->s_fs_info != server) {
1292         nfs_free_server(server);
1293         server = NULL;
1294     } else {
1295         error = super_setup_bdi_name(s, "%u:%u", MAJOR(server->s_dev),
1296                          MINOR(server->s_dev));
1297         if (error)
1298             goto error_splat_super;
1299         s->s_bdi->io_pages = server->rpages;
1300         server->super = s;
1301     }
1302 
1303     if (!s->s_root) {
1304         unsigned bsize = ctx->clone_data.inherited_bsize;
1305         /* initial superblock/root creation */
1306         nfs_fill_super(s, ctx);
1307         if (bsize) {
1308             s->s_blocksize_bits = bsize;
1309             s->s_blocksize = 1U << bsize;
1310         }
1311         error = nfs_get_cache_cookie(s, ctx);
1312         if (error < 0)
1313             goto error_splat_super;
1314     }
1315 
1316     error = nfs_get_root(s, fc);
1317     if (error < 0) {
1318         nfs_errorf(fc, "NFS: Couldn't get root dentry");
1319         goto error_splat_super;
1320     }
1321 
1322     s->s_flags |= SB_ACTIVE;
1323     error = 0;
1324 
1325 out:
1326     return error;
1327 
1328 out_err_nosb:
1329     nfs_free_server(server);
1330     goto out;
1331 error_splat_super:
1332     deactivate_locked_super(s);
1333     goto out;
1334 }
1335 
1336 /*
1337  * Destroy an NFS2/3 superblock
1338  */
1339 void nfs_kill_super(struct super_block *s)
1340 {
1341     struct nfs_server *server = NFS_SB(s);
1342     dev_t dev = s->s_dev;
1343 
1344     generic_shutdown_super(s);
1345 
1346     nfs_fscache_release_super_cookie(s);
1347 
1348     nfs_free_server(server);
1349     free_anon_bdev(dev);
1350 }
1351 EXPORT_SYMBOL_GPL(nfs_kill_super);
1352 
1353 #if IS_ENABLED(CONFIG_NFS_V4)
1354 
1355 /*
1356  * NFS v4 module parameters need to stay in the
1357  * NFS client for backwards compatibility
1358  */
1359 unsigned int nfs_callback_set_tcpport;
1360 unsigned short nfs_callback_nr_threads;
1361 /* Default cache timeout is 10 minutes */
1362 unsigned int nfs_idmap_cache_timeout = 600;
1363 /* Turn off NFSv4 uid/gid mapping when using AUTH_SYS */
1364 bool nfs4_disable_idmapping = true;
1365 unsigned short max_session_slots = NFS4_DEF_SLOT_TABLE_SIZE;
1366 unsigned short max_session_cb_slots = NFS4_DEF_CB_SLOT_TABLE_SIZE;
1367 unsigned short send_implementation_id = 1;
1368 char nfs4_client_id_uniquifier[NFS4_CLIENT_ID_UNIQ_LEN] = "";
1369 bool recover_lost_locks = false;
1370 
1371 EXPORT_SYMBOL_GPL(nfs_callback_nr_threads);
1372 EXPORT_SYMBOL_GPL(nfs_callback_set_tcpport);
1373 EXPORT_SYMBOL_GPL(nfs_idmap_cache_timeout);
1374 EXPORT_SYMBOL_GPL(nfs4_disable_idmapping);
1375 EXPORT_SYMBOL_GPL(max_session_slots);
1376 EXPORT_SYMBOL_GPL(max_session_cb_slots);
1377 EXPORT_SYMBOL_GPL(send_implementation_id);
1378 EXPORT_SYMBOL_GPL(nfs4_client_id_uniquifier);
1379 EXPORT_SYMBOL_GPL(recover_lost_locks);
1380 
1381 #define NFS_CALLBACK_MAXPORTNR (65535U)
1382 
1383 static int param_set_portnr(const char *val, const struct kernel_param *kp)
1384 {
1385     unsigned long num;
1386     int ret;
1387 
1388     if (!val)
1389         return -EINVAL;
1390     ret = kstrtoul(val, 0, &num);
1391     if (ret || num > NFS_CALLBACK_MAXPORTNR)
1392         return -EINVAL;
1393     *((unsigned int *)kp->arg) = num;
1394     return 0;
1395 }
1396 static const struct kernel_param_ops param_ops_portnr = {
1397     .set = param_set_portnr,
1398     .get = param_get_uint,
1399 };
1400 #define param_check_portnr(name, p) __param_check(name, p, unsigned int)
1401 
1402 module_param_named(callback_tcpport, nfs_callback_set_tcpport, portnr, 0644);
1403 module_param_named(callback_nr_threads, nfs_callback_nr_threads, ushort, 0644);
1404 MODULE_PARM_DESC(callback_nr_threads, "Number of threads that will be "
1405         "assigned to the NFSv4 callback channels.");
1406 module_param(nfs_idmap_cache_timeout, int, 0644);
1407 module_param(nfs4_disable_idmapping, bool, 0644);
1408 module_param_string(nfs4_unique_id, nfs4_client_id_uniquifier,
1409             NFS4_CLIENT_ID_UNIQ_LEN, 0600);
1410 MODULE_PARM_DESC(nfs4_disable_idmapping,
1411         "Turn off NFSv4 idmapping when using 'sec=sys'");
1412 module_param(max_session_slots, ushort, 0644);
1413 MODULE_PARM_DESC(max_session_slots, "Maximum number of outstanding NFSv4.1 "
1414         "requests the client will negotiate");
1415 module_param(max_session_cb_slots, ushort, 0644);
1416 MODULE_PARM_DESC(max_session_cb_slots, "Maximum number of parallel NFSv4.1 "
1417         "callbacks the client will process for a given server");
1418 module_param(send_implementation_id, ushort, 0644);
1419 MODULE_PARM_DESC(send_implementation_id,
1420         "Send implementation ID with NFSv4.1 exchange_id");
1421 MODULE_PARM_DESC(nfs4_unique_id, "nfs_client_id4 uniquifier string");
1422 
1423 module_param(recover_lost_locks, bool, 0644);
1424 MODULE_PARM_DESC(recover_lost_locks,
1425          "If the server reports that a lock might be lost, "
1426          "try to recover it risking data corruption.");
1427 
1428 
1429 #endif /* CONFIG_NFS_V4 */
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!