Merge branch 'fixes-jgarzik' of git://git.kernel.org/pub/scm/linux/kernel/git/linvill...
[linux-2.6] / 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 <asm/semaphore.h>
30 #include <net/9p/9p.h>
31 #include <net/9p/client.h>
32
33 #include "v9fs.h"
34 #include "v9fs_vfs.h"
35 #include "fid.h"
36
37 /**
38  * v9fs_fid_add - add a fid to a dentry
39  * @dentry: dentry that the fid is being added to
40  * @fid: fid to add
41  *
42  */
43
44 int v9fs_fid_add(struct dentry *dentry, struct p9_fid *fid)
45 {
46         struct v9fs_dentry *dent;
47
48         P9_DPRINTK(P9_DEBUG_VFS, "fid %d dentry %s\n",
49                                         fid->fid, dentry->d_iname);
50
51         dent = dentry->d_fsdata;
52         if (!dent) {
53                 dent = kmalloc(sizeof(struct v9fs_dentry), GFP_KERNEL);
54                 if (!dent)
55                         return -ENOMEM;
56
57                 spin_lock_init(&dent->lock);
58                 INIT_LIST_HEAD(&dent->fidlist);
59                 dentry->d_fsdata = dent;
60         }
61
62         spin_lock(&dent->lock);
63         list_add(&fid->dlist, &dent->fidlist);
64         spin_unlock(&dent->lock);
65
66         return 0;
67 }
68
69 /**
70  * v9fs_fid_find - retrieve a fid that belongs to the specified uid
71  * @dentry: dentry to look for fid in
72  * @uid: return fid that belongs to the specified user
73  * @any: if non-zero, return any fid associated with the dentry
74  *
75  */
76
77 static struct p9_fid *v9fs_fid_find(struct dentry *dentry, u32 uid, int any)
78 {
79         struct v9fs_dentry *dent;
80         struct p9_fid *fid, *ret;
81
82         P9_DPRINTK(P9_DEBUG_VFS, " dentry: %s (%p) uid %d any %d\n",
83                 dentry->d_iname, dentry, uid, any);
84         dent = (struct v9fs_dentry *) dentry->d_fsdata;
85         ret = NULL;
86         if (dent) {
87                 spin_lock(&dent->lock);
88                 list_for_each_entry(fid, &dent->fidlist, dlist) {
89                         if (any || fid->uid == uid) {
90                                 ret = fid;
91                                 break;
92                         }
93                 }
94                 spin_unlock(&dent->lock);
95         }
96
97         return ret;
98 }
99
100 /**
101  * v9fs_fid_lookup - lookup for a fid, try to walk if not found
102  * @dentry: dentry to look for fid in
103  *
104  * Look for a fid in the specified dentry for the current user.
105  * If no fid is found, try to create one walking from a fid from the parent
106  * dentry (if it has one), or the root dentry. If the user haven't accessed
107  * the fs yet, attach now and walk from the root.
108  */
109
110 struct p9_fid *v9fs_fid_lookup(struct dentry *dentry)
111 {
112         int i, n, l, clone, any, access;
113         u32 uid;
114         struct p9_fid *fid;
115         struct dentry *d, *ds;
116         struct v9fs_session_info *v9ses;
117         char **wnames, *uname;
118
119         v9ses = v9fs_inode2v9ses(dentry->d_inode);
120         access = v9ses->flags & V9FS_ACCESS_MASK;
121         switch (access) {
122         case V9FS_ACCESS_SINGLE:
123         case V9FS_ACCESS_USER:
124                 uid = current->fsuid;
125                 any = 0;
126                 break;
127
128         case V9FS_ACCESS_ANY:
129                 uid = v9ses->uid;
130                 any = 1;
131                 break;
132
133         default:
134                 uid = ~0;
135                 any = 0;
136                 break;
137         }
138
139         fid = v9fs_fid_find(dentry, uid, any);
140         if (fid)
141                 return fid;
142
143         ds = dentry->d_parent;
144         fid = v9fs_fid_find(ds, uid, any);
145         if (!fid) { /* walk from the root */
146                 n = 0;
147                 for (ds = dentry; !IS_ROOT(ds); ds = ds->d_parent)
148                         n++;
149
150                 fid = v9fs_fid_find(ds, uid, any);
151                 if (!fid) { /* the user is not attached to the fs yet */
152                         if (access == V9FS_ACCESS_SINGLE)
153                                 return ERR_PTR(-EPERM);
154
155                         if (v9fs_extended(v9ses))
156                                 uname = NULL;
157                         else
158                                 uname = v9ses->uname;
159
160                         fid = p9_client_attach(v9ses->clnt, NULL, uname, uid,
161                                 v9ses->aname);
162
163                         if (IS_ERR(fid))
164                                 return fid;
165
166                         v9fs_fid_add(ds, fid);
167                 }
168         } else /* walk from the parent */
169                 n = 1;
170
171         if (ds == dentry)
172                 return fid;
173
174         wnames = kmalloc(sizeof(char *) * n, GFP_KERNEL);
175         if (!wnames)
176                 return ERR_PTR(-ENOMEM);
177
178         for (d = dentry, i = n; i >= 0; i--, d = d->d_parent)
179                 wnames[i] = (char *) d->d_name.name;
180
181         clone = 1;
182         i = 0;
183         while (i < n) {
184                 l = min(n - i, P9_MAXWELEM);
185                 fid = p9_client_walk(fid, l, &wnames[i], clone);
186                 if (!fid) {
187                         kfree(wnames);
188                         return fid;
189                 }
190
191                 i += l;
192                 clone = 0;
193         }
194
195         kfree(wnames);
196         v9fs_fid_add(dentry, fid);
197         return fid;
198 }
199
200 struct p9_fid *v9fs_fid_clone(struct dentry *dentry)
201 {
202         struct p9_fid *fid, *ret;
203
204         fid = v9fs_fid_lookup(dentry);
205         if (IS_ERR(fid))
206                 return fid;
207
208         ret = p9_client_walk(fid, 0, NULL, 1);
209         return ret;
210 }