]>
git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - fs/9p/fid.c
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_debug(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
, kuid_t uid
, int any
)
79 struct v9fs_dentry
*dent
;
80 struct p9_fid
*fid
, *ret
;
82 p9_debug(P9_DEBUG_VFS
, " dentry: %s (%p) uid %d any %d\n",
83 dentry
->d_name
.name
, dentry
, from_kuid(&init_user_ns
, uid
),
85 dent
= (struct v9fs_dentry
*) dentry
->d_fsdata
;
88 spin_lock(&dent
->lock
);
89 list_for_each_entry(fid
, &dent
->fidlist
, dlist
) {
90 if (any
|| uid_eq(fid
->uid
, uid
)) {
95 spin_unlock(&dent
->lock
);
102 * We need to hold v9ses->rename_sem as long as we hold references
103 * to returned path array. Array element contain pointers to
106 static int build_path_from_dentry(struct v9fs_session_info
*v9ses
,
107 struct dentry
*dentry
, char ***names
)
113 for (ds
= dentry
; !IS_ROOT(ds
); ds
= ds
->d_parent
)
116 wnames
= kmalloc(sizeof(char *) * n
, GFP_KERNEL
);
120 for (ds
= dentry
, i
= (n
-1); i
>= 0; i
--, ds
= ds
->d_parent
)
121 wnames
[i
] = (char *)ds
->d_name
.name
;
129 static struct p9_fid
*v9fs_fid_lookup_with_uid(struct dentry
*dentry
,
133 char **wnames
, *uname
;
134 int i
, n
, l
, clone
, access
;
135 struct v9fs_session_info
*v9ses
;
136 struct p9_fid
*fid
, *old_fid
= NULL
;
138 v9ses
= v9fs_dentry2v9ses(dentry
);
139 access
= v9ses
->flags
& V9FS_ACCESS_MASK
;
140 fid
= v9fs_fid_find(dentry
, uid
, any
);
144 * we don't have a matching fid. To do a TWALK we need
145 * parent fid. We need to prevent rename when we want to
146 * look at the parent.
148 down_read(&v9ses
->rename_sem
);
149 ds
= dentry
->d_parent
;
150 fid
= v9fs_fid_find(ds
, uid
, any
);
152 /* Found the parent fid do a lookup with that */
153 fid
= p9_client_walk(fid
, 1, (char **)&dentry
->d_name
.name
, 1);
156 up_read(&v9ses
->rename_sem
);
158 /* start from the root and try to do a lookup */
159 fid
= v9fs_fid_find(dentry
->d_sb
->s_root
, uid
, any
);
161 /* the user is not attached to the fs yet */
162 if (access
== V9FS_ACCESS_SINGLE
)
163 return ERR_PTR(-EPERM
);
165 if (v9fs_proto_dotu(v9ses
) || v9fs_proto_dotl(v9ses
))
168 uname
= v9ses
->uname
;
170 fid
= p9_client_attach(v9ses
->clnt
, NULL
, uname
, uid
,
175 v9fs_fid_add(dentry
->d_sb
->s_root
, fid
);
177 /* If we are root ourself just return that */
178 if (dentry
->d_sb
->s_root
== dentry
)
181 * Do a multipath walk with attached root.
182 * When walking parent we need to make sure we
183 * don't have a parallel rename happening
185 down_read(&v9ses
->rename_sem
);
186 n
= build_path_from_dentry(v9ses
, dentry
, &wnames
);
194 l
= min(n
- i
, P9_MAXWELEM
);
196 * We need to hold rename lock when doing a multipath
197 * walk to ensure none of the patch component change
199 fid
= p9_client_walk(fid
, l
, &wnames
[i
], clone
);
203 * If we fail, clunk fid which are mapping
204 * to path component and not the last component
207 p9_client_clunk(old_fid
);
219 v9fs_fid_add(dentry
, fid
);
221 up_read(&v9ses
->rename_sem
);
226 * v9fs_fid_lookup - lookup for a fid, try to walk if not found
227 * @dentry: dentry to look for fid in
229 * Look for a fid in the specified dentry for the current user.
230 * If no fid is found, try to create one walking from a fid from the parent
231 * dentry (if it has one), or the root dentry. If the user haven't accessed
232 * the fs yet, attach now and walk from the root.
235 struct p9_fid
*v9fs_fid_lookup(struct dentry
*dentry
)
239 struct v9fs_session_info
*v9ses
;
241 v9ses
= v9fs_dentry2v9ses(dentry
);
242 access
= v9ses
->flags
& V9FS_ACCESS_MASK
;
244 case V9FS_ACCESS_SINGLE
:
245 case V9FS_ACCESS_USER
:
246 case V9FS_ACCESS_CLIENT
:
247 uid
= current_fsuid();
251 case V9FS_ACCESS_ANY
:
261 return v9fs_fid_lookup_with_uid(dentry
, uid
, any
);
264 struct p9_fid
*v9fs_fid_clone(struct dentry
*dentry
)
266 struct p9_fid
*fid
, *ret
;
268 fid
= v9fs_fid_lookup(dentry
);
272 ret
= p9_client_walk(fid
, 0, NULL
, 1);
276 static struct p9_fid
*v9fs_fid_clone_with_uid(struct dentry
*dentry
, kuid_t uid
)
278 struct p9_fid
*fid
, *ret
;
280 fid
= v9fs_fid_lookup_with_uid(dentry
, uid
, 0);
284 ret
= p9_client_walk(fid
, 0, NULL
, 1);
288 struct p9_fid
*v9fs_writeback_fid(struct dentry
*dentry
)
293 fid
= v9fs_fid_clone_with_uid(dentry
, GLOBAL_ROOT_UID
);
297 * writeback fid will only be used to write back the
298 * dirty pages. We always request for the open fid in read-write
299 * mode so that a partial page write which result in page
302 err
= p9_client_open(fid
, O_RDWR
);
304 p9_client_clunk(fid
);