afs: Implement @cell substitution handling

Implement @cell substitution handling such that if @cell is seen as a name
in a dynamic root mount, then the name of the root cell for that network
namespace will be substituted for @cell during lookup.

The substitution of @cell for the current net namespace is set by writing
the cell name to /proc/fs/afs/rootcell.  The value can be obtained by
reading the file.

For example:

	# mount -t afs none /kafs -o dyn
	# echo grand.central.org >/proc/fs/afs/rootcell
	# ls /kafs/@cell
	archive/  cvs/  doc/  local/  project/  service/  software/  user/  www/
	# cat /proc/fs/afs/rootcell
	grand.central.org

Signed-off-by: David Howells <dhowells@redhat.com>

diff --git a/fs/afs/cell.c b/fs/afs/cell.c
index 721425b98b31e8350b91d4b1d81d658bb6b57a45..fdf4c36cff79ead65acf11a36b99614db924fe9b 100644 (file)
--- a/fs/afs/cell.c
+++ b/fs/afs/cell.c
@@ -130,6 +130,8 @@ static struct afs_cell *afs_alloc_cell(struct afs_net *net,
                _leave(" = -ENAMETOOLONG");
                return ERR_PTR(-ENAMETOOLONG);
        }
+       if (namelen == 5 && memcmp(name, "@cell", 5) == 0)
+               return ERR_PTR(-EINVAL);
 
        _enter("%*.*s,%s", namelen, namelen, name, vllist);
 

diff --git a/fs/afs/dir.c b/fs/afs/dir.c
index 3ebd741b74d04c31e44f0196a059b7c65e3557bf..b073976db8d2dab97dd1a5c6a4ece6475f43752d 100644 (file)
--- a/fs/afs/dir.c
+++ b/fs/afs/dir.c
@@ -908,6 +908,55 @@ success:
        return NULL;
 }
 
+/*
+ * Look up @cell in a dynroot directory.  This is a substitution for the
+ * local cell name for the net namespace.
+ */
+static struct dentry *afs_lookup_atcell(struct dentry *dentry)
+{
+       struct afs_cell *cell;
+       struct afs_net *net = afs_d2net(dentry);
+       struct dentry *ret;
+       unsigned int seq = 0;
+       char *name;
+       int len;
+
+       if (!net->ws_cell)
+               return ERR_PTR(-ENOENT);
+
+       ret = ERR_PTR(-ENOMEM);
+       name = kmalloc(AFS_MAXCELLNAME + 1, GFP_KERNEL);
+       if (!name)
+               goto out_p;
+
+       rcu_read_lock();
+       do {
+               read_seqbegin_or_lock(&net->cells_lock, &seq);
+               cell = rcu_dereference_raw(net->ws_cell);
+               if (cell) {
+                       len = cell->name_len;
+                       memcpy(name, cell->name, len + 1);
+               }
+       } while (need_seqretry(&net->cells_lock, seq));
+       done_seqretry(&net->cells_lock, seq);
+       rcu_read_unlock();
+
+       ret = ERR_PTR(-ENOENT);
+       if (!cell)
+               goto out_n;
+
+       ret = lookup_one_len(name, dentry->d_parent, len);
+
+       /* We don't want to d_add() the @cell dentry here as we don't want to
+        * the cached dentry to hide changes to the local cell name.
+        */
+
+out_n:
+       kfree(name);
+out_p:
+       return ret;
+}
+
 /*
  * Look up an entry in a dynroot directory.
  */
@@ -929,6 +978,10 @@ static struct dentry *afs_dynroot_lookup(struct inode *dir, struct dentry *dentr
                return ERR_PTR(-ENAMETOOLONG);
        }
 
+       if (dentry->d_name.len == 5 &&
+           memcmp(dentry->d_name.name, "@cell", 5) == 0)
+               return afs_lookup_atcell(dentry);
+
        inode = afs_try_auto_mntpt(dentry, dir);
        if (IS_ERR(inode)) {
                ret = PTR_ERR(inode);

diff --git a/fs/afs/proc.c b/fs/afs/proc.c
index 15650cd5940426bdab161fe32c20c000650b9d20..76f6df32cde048ae6befba94fbe4fc502c8d71b6 100644 (file)
--- a/fs/afs/proc.c
+++ b/fs/afs/proc.c
@@ -334,7 +334,40 @@ inval:
 static ssize_t afs_proc_rootcell_read(struct file *file, char __user *buf,
                                      size_t size, loff_t *_pos)
 {
-       return 0;
+       struct afs_cell *cell;
+       struct afs_net *net = afs_proc2net(file);
+       unsigned int seq = 0;
+       char name[AFS_MAXCELLNAME + 1];
+       int len;
+
+       if (*_pos > 0)
+               return 0;
+       if (!net->ws_cell)
+               return 0;
+
+       rcu_read_lock();
+       do {
+               read_seqbegin_or_lock(&net->cells_lock, &seq);
+               len = 0;
+               cell = rcu_dereference_raw(net->ws_cell);
+               if (cell) {
+                       len = cell->name_len;
+                       memcpy(name, cell->name, len);
+               }
+       } while (need_seqretry(&net->cells_lock, seq));
+       done_seqretry(&net->cells_lock, seq);
+       rcu_read_unlock();
+
+       if (!len)
+               return 0;
+
+       name[len++] = '\n';
+       if (len > size)
+               len = size;
+       if (copy_to_user(buf, name, len) != 0)
+               return -EFAULT;
+       *_pos = 1;
+       return len;
 }
 
 /*