4 * Copyright (C) 2007 by Latchesar Ionkov <lucho@ionkov.net>
5 * Copyright (C) 2005, 2006 by Eric Van Hensbergen <ericvh@gmail.com>
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.
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.
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
24 #include <linux/module.h>
25 #include <linux/errno.h>
27 #include <linux/slab.h>
28 #include <linux/sched.h>
29 #include <linux/idr.h>
30 #include <net/9p/9p.h>
31 #include <net/9p/client.h>
38 * v9fs_fid_add - add a fid to a dentry
39 * @dentry: dentry that the fid is being added to
44 int v9fs_fid_add(struct dentry
*dentry
, struct p9_fid
*fid
)
46 struct v9fs_dentry
*dent
;
48 P9_DPRINTK(P9_DEBUG_VFS
, "fid %d dentry %s\n",
49 fid
->fid
, dentry
->d_name
.name
);
51 dent
= dentry
->d_fsdata
;
53 dent
= kmalloc(sizeof(struct v9fs_dentry
), GFP_KERNEL
);
57 spin_lock_init(&dent
->lock
);
58 INIT_LIST_HEAD(&dent
->fidlist
);
59 dentry
->d_fsdata
= dent
;
62 spin_lock(&dent
->lock
);
63 list_add(&fid
->dlist
, &dent
->fidlist
);
64 spin_unlock(&dent
->lock
);
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
77 static struct p9_fid
*v9fs_fid_find(struct dentry
*dentry
, u32 uid
, int any
)
79 struct v9fs_dentry
*dent
;
80 struct p9_fid
*fid
, *ret
;
82 P9_DPRINTK(P9_DEBUG_VFS
, " dentry: %s (%p) uid %d any %d\n",
83 dentry
->d_name
.name
, dentry
, uid
, any
);
84 dent
= (struct v9fs_dentry
*) dentry
->d_fsdata
;
87 spin_lock(&dent
->lock
);
88 list_for_each_entry(fid
, &dent
->fidlist
, dlist
) {
89 if (any
|| fid
->uid
== uid
) {
94 spin_unlock(&dent
->lock
);
101 * We need to hold v9ses->rename_sem as long as we hold references
102 * to returned path array. Array element contain pointers to
105 static int build_path_from_dentry(struct v9fs_session_info
*v9ses
,
106 struct dentry
*dentry
, char ***names
)
112 for (ds
= dentry
; !IS_ROOT(ds
); ds
= ds
->d_parent
)
115 wnames
= kmalloc(sizeof(char *) * n
, GFP_KERNEL
);
119 for (ds
= dentry
, i
= (n
-1); i
>= 0; i
--, ds
= ds
->d_parent
)
120 wnames
[i
] = (char *)ds
->d_name
.name
;
128 static struct p9_fid
*v9fs_fid_lookup_with_uid(struct dentry
*dentry
,
132 char **wnames
, *uname
;
133 int i
, n
, l
, clone
, access
;
134 struct v9fs_session_info
*v9ses
;
135 struct p9_fid
*fid
, *old_fid
= NULL
;
137 v9ses
= v9fs_dentry2v9ses(dentry
);
138 access
= v9ses
->flags
& V9FS_ACCESS_MASK
;
139 fid
= v9fs_fid_find(dentry
, uid
, any
);
143 * we don't have a matching fid. To do a TWALK we need
144 * parent fid. We need to prevent rename when we want to
145 * look at the parent.
147 down_read(&v9ses
->rename_sem
);
148 ds
= dentry
->d_parent
;
149 fid
= v9fs_fid_find(ds
, uid
, any
);
151 /* Found the parent fid do a lookup with that */
152 fid
= p9_client_walk(fid
, 1, (char **)&dentry
->d_name
.name
, 1);
155 up_read(&v9ses
->rename_sem
);
157 /* start from the root and try to do a lookup */
158 fid
= v9fs_fid_find(dentry
->d_sb
->s_root
, uid
, any
);
160 /* the user is not attached to the fs yet */
161 if (access
== V9FS_ACCESS_SINGLE
)
162 return ERR_PTR(-EPERM
);
164 if (v9fs_proto_dotu(v9ses
) || v9fs_proto_dotl(v9ses
))
167 uname
= v9ses
->uname
;
169 fid
= p9_client_attach(v9ses
->clnt
, NULL
, uname
, uid
,
174 v9fs_fid_add(dentry
->d_sb
->s_root
, fid
);
176 /* If we are root ourself just return that */
177 if (dentry
->d_sb
->s_root
== dentry
)
180 * Do a multipath walk with attached root.
181 * When walking parent we need to make sure we
182 * don't have a parallel rename happening
184 down_read(&v9ses
->rename_sem
);
185 n
= build_path_from_dentry(v9ses
, dentry
, &wnames
);
193 l
= min(n
- i
, P9_MAXWELEM
);
195 * We need to hold rename lock when doing a multipath
196 * walk to ensure none of the patch component change
198 fid
= p9_client_walk(fid
, l
, &wnames
[i
], clone
);
202 * If we fail, clunk fid which are mapping
203 * to path component and not the last component
206 p9_client_clunk(old_fid
);
218 v9fs_fid_add(dentry
, fid
);
220 up_read(&v9ses
->rename_sem
);
225 * v9fs_fid_lookup - lookup for a fid, try to walk if not found
226 * @dentry: dentry to look for fid in
228 * Look for a fid in the specified dentry for the current user.
229 * If no fid is found, try to create one walking from a fid from the parent
230 * dentry (if it has one), or the root dentry. If the user haven't accessed
231 * the fs yet, attach now and walk from the root.
234 struct p9_fid
*v9fs_fid_lookup(struct dentry
*dentry
)
238 struct v9fs_session_info
*v9ses
;
240 v9ses
= v9fs_dentry2v9ses(dentry
);
241 access
= v9ses
->flags
& V9FS_ACCESS_MASK
;
243 case V9FS_ACCESS_SINGLE
:
244 case V9FS_ACCESS_USER
:
245 case V9FS_ACCESS_CLIENT
:
246 uid
= current_fsuid();
250 case V9FS_ACCESS_ANY
:
260 return v9fs_fid_lookup_with_uid(dentry
, uid
, any
);
263 struct p9_fid
*v9fs_fid_clone(struct dentry
*dentry
)
265 struct p9_fid
*fid
, *ret
;
267 fid
= v9fs_fid_lookup(dentry
);
271 ret
= p9_client_walk(fid
, 0, NULL
, 1);
275 static struct p9_fid
*v9fs_fid_clone_with_uid(struct dentry
*dentry
, uid_t uid
)
277 struct p9_fid
*fid
, *ret
;
279 fid
= v9fs_fid_lookup_with_uid(dentry
, uid
, 0);
283 ret
= p9_client_walk(fid
, 0, NULL
, 1);
287 struct p9_fid
*v9fs_writeback_fid(struct dentry
*dentry
)
291 struct v9fs_session_info
*v9ses
;
293 v9ses
= v9fs_dentry2v9ses(dentry
);
294 fid
= v9fs_fid_clone_with_uid(dentry
, 0);
298 * writeback fid will only be used to write back the
299 * dirty pages. We always request for the open fid in read-write
300 * mode so that a partial page write which result in page
303 * we don't have a tsyncfs operation for older version
304 * of protocol. So make sure the write back fid is
305 * opened in O_SYNC mode.
307 if (!v9fs_proto_dotl(v9ses
))
308 flags
= O_RDWR
| O_SYNC
;
312 err
= p9_client_open(fid
, flags
);
314 p9_client_clunk(fid
);