Branch data     Line data    Source code

       1                 :            : // SPDX-License-Identifier: GPL-2.0-only
       2                 :            : /*
       3                 :            :  * linux/fs/nfs/namespace.c
       4                 :            :  *
       5                 :            :  * Copyright (C) 2005 Trond Myklebust <Trond.Myklebust@netapp.com>
       6                 :            :  * - Modified by David Howells <dhowells@redhat.com>
       7                 :            :  *
       8                 :            :  * NFS namespace
       9                 :            :  */
      10                 :            : 
      11                 :            : #include <linux/module.h>
      12                 :            : #include <linux/dcache.h>
      13                 :            : #include <linux/gfp.h>
      14                 :            : #include <linux/mount.h>
      15                 :            : #include <linux/namei.h>
      16                 :            : #include <linux/nfs_fs.h>
      17                 :            : #include <linux/string.h>
      18                 :            : #include <linux/sunrpc/clnt.h>
      19                 :            : #include <linux/vfs.h>
      20                 :            : #include <linux/sunrpc/gss_api.h>
      21                 :            : #include "internal.h"
      22                 :            : 
      23                 :            : #define NFSDBG_FACILITY         NFSDBG_VFS
      24                 :            : 
      25                 :            : static void nfs_expire_automounts(struct work_struct *work);
      26                 :            : 
      27                 :            : static LIST_HEAD(nfs_automount_list);
      28                 :            : static DECLARE_DELAYED_WORK(nfs_automount_task, nfs_expire_automounts);
      29                 :            : int nfs_mountpoint_expiry_timeout = 500 * HZ;
      30                 :            : 
      31                 :            : /*
      32                 :            :  * nfs_path - reconstruct the path given an arbitrary dentry
      33                 :            :  * @base - used to return pointer to the end of devname part of path
      34                 :            :  * @dentry - pointer to dentry
      35                 :            :  * @buffer - result buffer
      36                 :            :  * @buflen - length of buffer
      37                 :            :  * @flags - options (see below)
      38                 :            :  *
      39                 :            :  * Helper function for constructing the server pathname
      40                 :            :  * by arbitrary hashed dentry.
      41                 :            :  *
      42                 :            :  * This is mainly for use in figuring out the path on the
      43                 :            :  * server side when automounting on top of an existing partition
      44                 :            :  * and in generating /proc/mounts and friends.
      45                 :            :  *
      46                 :            :  * Supported flags:
      47                 :            :  * NFS_PATH_CANONICAL: ensure there is exactly one slash after
      48                 :            :  *                     the original device (export) name
      49                 :            :  *                     (if unset, the original name is returned verbatim)
      50                 :            :  */
      51                 :          0 : char *nfs_path(char **p, struct dentry *dentry, char *buffer, ssize_t buflen,
      52                 :            :                unsigned flags)
      53                 :            : {
      54                 :            :         char *end;
      55                 :            :         int namelen;
      56                 :            :         unsigned seq;
      57                 :            :         const char *base;
      58                 :            : 
      59                 :            : rename_retry:
      60                 :          0 :         end = buffer+buflen;
      61                 :          0 :         *--end = '\0';
      62                 :          0 :         buflen--;
      63                 :            : 
      64                 :            :         seq = read_seqbegin(&rename_lock);
      65                 :            :         rcu_read_lock();
      66                 :            :         while (1) {
      67                 :            :                 spin_lock(&dentry->d_lock);
      68                 :          0 :                 if (IS_ROOT(dentry))
      69                 :            :                         break;
      70                 :          0 :                 namelen = dentry->d_name.len;
      71                 :          0 :                 buflen -= namelen + 1;
      72                 :          0 :                 if (buflen < 0)
      73                 :            :                         goto Elong_unlock;
      74                 :          0 :                 end -= namelen;
      75                 :          0 :                 memcpy(end, dentry->d_name.name, namelen);
      76                 :          0 :                 *--end = '/';
      77                 :            :                 spin_unlock(&dentry->d_lock);
      78                 :          0 :                 dentry = dentry->d_parent;
      79                 :          0 :         }
      80                 :          0 :         if (read_seqretry(&rename_lock, seq)) {
      81                 :            :                 spin_unlock(&dentry->d_lock);
      82                 :            :                 rcu_read_unlock();
      83                 :            :                 goto rename_retry;
      84                 :            :         }
      85                 :          0 :         if ((flags & NFS_PATH_CANONICAL) && *end != '/') {
      86                 :          0 :                 if (--buflen < 0) {
      87                 :            :                         spin_unlock(&dentry->d_lock);
      88                 :            :                         rcu_read_unlock();
      89                 :            :                         goto Elong;
      90                 :            :                 }
      91                 :          0 :                 *--end = '/';
      92                 :            :         }
      93                 :          0 :         *p = end;
      94                 :          0 :         base = dentry->d_fsdata;
      95                 :          0 :         if (!base) {
      96                 :            :                 spin_unlock(&dentry->d_lock);
      97                 :            :                 rcu_read_unlock();
      98                 :          0 :                 WARN_ON(1);
      99                 :          0 :                 return end;
     100                 :            :         }
     101                 :          0 :         namelen = strlen(base);
     102                 :          0 :         if (*end == '/') {
     103                 :            :                 /* Strip off excess slashes in base string */
     104                 :          0 :                 while (namelen > 0 && base[namelen - 1] == '/')
     105                 :          0 :                         namelen--;
     106                 :            :         }
     107                 :          0 :         buflen -= namelen;
     108                 :          0 :         if (buflen < 0) {
     109                 :            :                 spin_unlock(&dentry->d_lock);
     110                 :            :                 rcu_read_unlock();
     111                 :            :                 goto Elong;
     112                 :            :         }
     113                 :          0 :         end -= namelen;
     114                 :          0 :         memcpy(end, base, namelen);
     115                 :            :         spin_unlock(&dentry->d_lock);
     116                 :            :         rcu_read_unlock();
     117                 :          0 :         return end;
     118                 :            : Elong_unlock:
     119                 :            :         spin_unlock(&dentry->d_lock);
     120                 :            :         rcu_read_unlock();
     121                 :          0 :         if (read_seqretry(&rename_lock, seq))
     122                 :            :                 goto rename_retry;
     123                 :            : Elong:
     124                 :            :         return ERR_PTR(-ENAMETOOLONG);
     125                 :            : }
     126                 :            : EXPORT_SYMBOL_GPL(nfs_path);
     127                 :            : 
     128                 :            : /*
     129                 :            :  * nfs_d_automount - Handle crossing a mountpoint on the server
     130                 :            :  * @path - The mountpoint
     131                 :            :  *
     132                 :            :  * When we encounter a mountpoint on the server, we want to set up
     133                 :            :  * a mountpoint on the client too, to prevent inode numbers from
     134                 :            :  * colliding, and to allow "df" to work properly.
     135                 :            :  * On NFSv4, we also want to allow for the fact that different
     136                 :            :  * filesystems may be migrated to different servers in a failover
     137                 :            :  * situation, and that different filesystems may want to use
     138                 :            :  * different security flavours.
     139                 :            :  */
     140                 :          0 : struct vfsmount *nfs_d_automount(struct path *path)
     141                 :            : {
     142                 :            :         struct vfsmount *mnt;
     143                 :          0 :         struct nfs_server *server = NFS_SERVER(d_inode(path->dentry));
     144                 :            :         struct nfs_fh *fh = NULL;
     145                 :            :         struct nfs_fattr *fattr = NULL;
     146                 :            : 
     147                 :          0 :         if (IS_ROOT(path->dentry))
     148                 :            :                 return ERR_PTR(-ESTALE);
     149                 :            : 
     150                 :            :         mnt = ERR_PTR(-ENOMEM);
     151                 :          0 :         fh = nfs_alloc_fhandle();
     152                 :          0 :         fattr = nfs_alloc_fattr();
     153                 :          0 :         if (fh == NULL || fattr == NULL)
     154                 :            :                 goto out;
     155                 :            : 
     156                 :          0 :         mnt = server->nfs_client->rpc_ops->submount(server, path->dentry, fh, fattr);
     157                 :          0 :         if (IS_ERR(mnt))
     158                 :            :                 goto out;
     159                 :            : 
     160                 :          0 :         mntget(mnt); /* prevent immediate expiration */
     161                 :          0 :         mnt_set_expiry(mnt, &nfs_automount_list);
     162                 :          0 :         schedule_delayed_work(&nfs_automount_task, nfs_mountpoint_expiry_timeout);
     163                 :            : 
     164                 :            : out:
     165                 :            :         nfs_free_fattr(fattr);
     166                 :            :         nfs_free_fhandle(fh);
     167                 :          0 :         return mnt;
     168                 :            : }
     169                 :            : 
     170                 :            : static int
     171                 :          0 : nfs_namespace_getattr(const struct path *path, struct kstat *stat,
     172                 :            :                         u32 request_mask, unsigned int query_flags)
     173                 :            : {
     174                 :          0 :         if (NFS_FH(d_inode(path->dentry))->size != 0)
     175                 :          0 :                 return nfs_getattr(path, stat, request_mask, query_flags);
     176                 :          0 :         generic_fillattr(d_inode(path->dentry), stat);
     177                 :          0 :         return 0;
     178                 :            : }
     179                 :            : 
     180                 :            : static int
     181                 :          0 : nfs_namespace_setattr(struct dentry *dentry, struct iattr *attr)
     182                 :            : {
     183                 :          0 :         if (NFS_FH(d_inode(dentry))->size != 0)
     184                 :          0 :                 return nfs_setattr(dentry, attr);
     185                 :            :         return -EACCES;
     186                 :            : }
     187                 :            : 
     188                 :            : const struct inode_operations nfs_mountpoint_inode_operations = {
     189                 :            :         .getattr        = nfs_getattr,
     190                 :            :         .setattr        = nfs_setattr,
     191                 :            : };
     192                 :            : 
     193                 :            : const struct inode_operations nfs_referral_inode_operations = {
     194                 :            :         .getattr        = nfs_namespace_getattr,
     195                 :            :         .setattr        = nfs_namespace_setattr,
     196                 :            : };
     197                 :            : 
     198                 :          0 : static void nfs_expire_automounts(struct work_struct *work)
     199                 :            : {
     200                 :            :         struct list_head *list = &nfs_automount_list;
     201                 :            : 
     202                 :          0 :         mark_mounts_for_expiry(list);
     203                 :          0 :         if (!list_empty(list))
     204                 :          0 :                 schedule_delayed_work(&nfs_automount_task, nfs_mountpoint_expiry_timeout);
     205                 :          0 : }
     206                 :            : 
     207                 :          0 : void nfs_release_automount_timer(void)
     208                 :            : {
     209                 :          0 :         if (list_empty(&nfs_automount_list))
     210                 :          0 :                 cancel_delayed_work(&nfs_automount_task);
     211                 :          0 : }
     212                 :            : 
     213                 :            : /*
     214                 :            :  * Clone a mountpoint of the appropriate type
     215                 :            :  */
     216                 :            : static struct vfsmount *nfs_do_clone_mount(struct nfs_server *server,
     217                 :            :                                            const char *devname,
     218                 :            :                                            struct nfs_clone_mount *mountdata)
     219                 :            : {
     220                 :          0 :         return vfs_submount(mountdata->dentry, &nfs_xdev_fs_type, devname, mountdata);
     221                 :            : }
     222                 :            : 
     223                 :            : /**
     224                 :            :  * nfs_do_submount - set up mountpoint when crossing a filesystem boundary
     225                 :            :  * @dentry: parent directory
     226                 :            :  * @fh: filehandle for new root dentry
     227                 :            :  * @fattr: attributes for new root inode
     228                 :            :  * @authflavor: security flavor to use when performing the mount
     229                 :            :  *
     230                 :            :  */
     231                 :          0 : struct vfsmount *nfs_do_submount(struct dentry *dentry, struct nfs_fh *fh,
     232                 :            :                                  struct nfs_fattr *fattr, rpc_authflavor_t authflavor)
     233                 :            : {
     234                 :          0 :         struct nfs_clone_mount mountdata = {
     235                 :          0 :                 .sb = dentry->d_sb,
     236                 :            :                 .dentry = dentry,
     237                 :            :                 .fh = fh,
     238                 :            :                 .fattr = fattr,
     239                 :            :                 .authflavor = authflavor,
     240                 :            :         };
     241                 :            :         struct vfsmount *mnt;
     242                 :          0 :         char *page = (char *) __get_free_page(GFP_USER);
     243                 :            :         char *devname;
     244                 :            : 
     245                 :          0 :         if (page == NULL)
     246                 :            :                 return ERR_PTR(-ENOMEM);
     247                 :            : 
     248                 :            :         devname = nfs_devname(dentry, page, PAGE_SIZE);
     249                 :          0 :         if (IS_ERR(devname))
     250                 :            :                 mnt = ERR_CAST(devname);
     251                 :            :         else
     252                 :            :                 mnt = nfs_do_clone_mount(NFS_SB(dentry->d_sb), devname, &mountdata);
     253                 :            : 
     254                 :          0 :         free_page((unsigned long)page);
     255                 :          0 :         return mnt;
     256                 :            : }
     257                 :            : EXPORT_SYMBOL_GPL(nfs_do_submount);
     258                 :            : 
     259                 :          0 : struct vfsmount *nfs_submount(struct nfs_server *server, struct dentry *dentry,
     260                 :            :                               struct nfs_fh *fh, struct nfs_fattr *fattr)
     261                 :            : {
     262                 :            :         int err;
     263                 :          0 :         struct dentry *parent = dget_parent(dentry);
     264                 :            : 
     265                 :            :         /* Look it up again to get its attributes */
     266                 :          0 :         err = server->nfs_client->rpc_ops->lookup(d_inode(parent), &dentry->d_name, fh, fattr, NULL);
     267                 :          0 :         dput(parent);
     268                 :          0 :         if (err != 0)
     269                 :          0 :                 return ERR_PTR(err);
     270                 :            : 
     271                 :          0 :         return nfs_do_submount(dentry, fh, fattr, server->client->cl_auth->au_flavor);
     272                 :            : }
     273                 :            : EXPORT_SYMBOL_GPL(nfs_submount);