fs/9p/fid.c

   1 /*
   2  * V9FS FID Management
   3  *
   4  *  Copyright (C) 2007 by Latchesar Ionkov <lucho@ionkov.net>
   5  *  Copyright (C) 2005, 2006 by Eric Van Hensbergen <ericvh@gmail.com>
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License version 2
   9  *  as published by the Free Software Foundation.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to:
  18  *  Free Software Foundation
  19  *  51 Franklin Street, Fifth Floor
  20  *  Boston, MA  02111-1301  USA
  21  *
  22  */
  23
  24 #include <linux/module.h>
  25 #include <linux/errno.h>
  26 #include <linux/fs.h>
  27 #include <linux/sched.h>
  28 #include <linux/idr.h>
  29 #include <net/9p/9p.h>
  30 #include <net/9p/client.h>
  31
  32 #include "v9fs.h"
  33 #include "v9fs_vfs.h"
  34 #include "fid.h"
  35
  36 /**
  37  * v9fs_fid_add - add a fid to a dentry
  38  * @dentry: dentry that the fid is being added to
  39  * @fid: fid to add
  40  *
  41  */
  42
  43 int v9fs_fid_add(struct dentry *dentry, struct p9_fid *fid)
  44 {
  45         struct v9fs_dentry *dent;
  46
  47         P9_DPRINTK(P9_DEBUG_VFS, "fid %d dentry %s\n",
  48                                         fid->fid, dentry->d_iname);
  49
  50         dent = dentry->d_fsdata;
  51         if (!dent) {
  52                 dent = kmalloc(sizeof(struct v9fs_dentry), GFP_KERNEL);
  53                 if (!dent)
  54                         return -ENOMEM;
  55
  56                 spin_lock_init(&dent->lock);
  57                 INIT_LIST_HEAD(&dent->fidlist);
  58                 dentry->d_fsdata = dent;
  59         }
  60
  61         spin_lock(&dent->lock);
  62         list_add(&fid->dlist, &dent->fidlist);
  63         spin_unlock(&dent->lock);
  64
  65         return 0;
  66 }
  67
  68 /**
  69  * v9fs_fid_find - retrieve a fid that belongs to the specified uid
  70  * @dentry: dentry to look for fid in
  71  * @uid: return fid that belongs to the specified user
  72  * @any: if non-zero, return any fid associated with the dentry
  73  *
  74  */
  75
  76 static struct p9_fid *v9fs_fid_find(struct dentry *dentry, u32 uid, int any)
  77 {
  78         struct v9fs_dentry *dent;
  79         struct p9_fid *fid, *ret;
  80
  81         P9_DPRINTK(P9_DEBUG_VFS, " dentry: %s (%p) uid %d any %d\n",
  82                 dentry->d_iname, dentry, uid, any);
  83         dent = (struct v9fs_dentry *) dentry->d_fsdata;
  84         ret = NULL;
  85         if (dent) {
  86                 spin_lock(&dent->lock);
  87                 list_for_each_entry(fid, &dent->fidlist, dlist) {
  88                         if (any || fid->uid == uid) {
  89                                 ret = fid;
  90                                 break;
  91                         }
  92                 }
  93                 spin_unlock(&dent->lock);
  94         }
  95
  96         return ret;
  97 }
  98
  99 /**
 100  * v9fs_fid_lookup - lookup for a fid, try to walk if not found
 101  * @dentry: dentry to look for fid in
 102  *
 103  * Look for a fid in the specified dentry for the current user.
 104  * If no fid is found, try to create one walking from a fid from the parent
 105  * dentry (if it has one), or the root dentry. If the user haven't accessed
 106  * the fs yet, attach now and walk from the root.
 107  */
 108
 109 struct p9_fid *v9fs_fid_lookup(struct dentry *dentry)
 110 {
 111         int i, n, l, clone, any, access;
 112         u32 uid;
 113         struct p9_fid *fid;
 114         struct dentry *d, *ds;
 115         struct v9fs_session_info *v9ses;
 116         char **wnames, *uname;
 117
 118         v9ses = v9fs_inode2v9ses(dentry->d_inode);
 119         access = v9ses->flags & V9FS_ACCESS_MASK;
 120         switch (access) {
 121         case V9FS_ACCESS_SINGLE:
 122         case V9FS_ACCESS_USER:
 123                 uid = current->fsuid;
 124                 any = 0;
 125                 break;
 126
 127         case V9FS_ACCESS_ANY:
 128                 uid = v9ses->uid;
 129                 any = 1;
 130                 break;
 131
 132         default:
 133                 uid = ~0;
 134                 any = 0;
 135                 break;
 136         }
 137
 138         fid = v9fs_fid_find(dentry, uid, any);
 139         if (fid)
 140                 return fid;
 141
 142         ds = dentry->d_parent;
 143         fid = v9fs_fid_find(ds, uid, any);
 144         if (!fid) { /* walk from the root */
 145                 n = 0;
 146                 for (ds = dentry; !IS_ROOT(ds); ds = ds->d_parent)
 147                         n++;
 148
 149                 fid = v9fs_fid_find(ds, uid, any);
 150                 if (!fid) { /* the user is not attached to the fs yet */
 151                         if (access == V9FS_ACCESS_SINGLE)
 152                                 return ERR_PTR(-EPERM);
 153
 154                         if (v9fs_extended(v9ses))
 155                                 uname = NULL;
 156                         else
 157                                 uname = v9ses->uname;
 158
 159                         fid = p9_client_attach(v9ses->clnt, NULL, uname, uid,
 160                                 v9ses->aname);
 161
 162                         if (IS_ERR(fid))
 163                                 return fid;
 164
 165                         v9fs_fid_add(ds, fid);
 166                 }
 167         } else /* walk from the parent */
 168                 n = 1;
 169
 170         if (ds == dentry)
 171                 return fid;
 172
 173         wnames = kmalloc(sizeof(char *) * n, GFP_KERNEL);
 174         if (!wnames)
 175                 return ERR_PTR(-ENOMEM);
 176
 177         for (d = dentry, i = (n-1); i >= 0; i--, d = d->d_parent)
 178                 wnames[i] = (char *) d->d_name.name;
 179
 180         clone = 1;
 181         i = 0;
 182         while (i < n) {
 183                 l = min(n - i, P9_MAXWELEM);
 184                 fid = p9_client_walk(fid, l, &wnames[i], clone);
 185                 if (IS_ERR(fid)) {
 186                         kfree(wnames);
 187                         return fid;
 188                 }
 189
 190                 i += l;
 191                 clone = 0;
 192         }
 193
 194         kfree(wnames);
 195         v9fs_fid_add(dentry, fid);
 196         return fid;
 197 }
 198
 199 struct p9_fid *v9fs_fid_clone(struct dentry *dentry)
 200 {
 201         struct p9_fid *fid, *ret;
 202
 203         fid = v9fs_fid_lookup(dentry);
 204         if (IS_ERR(fid))
 205                 return fid;
 206
 207         ret = p9_client_walk(fid, 0, NULL, 1);
 208         return ret;
 209 }