1// SPDX-License-Identifier: GPL-2.0-only 2/* 3 * V9FS FID Management 4 * 5 * Copyright (C) 2007 by Latchesar Ionkov <lucho@ionkov.net> 6 * Copyright (C) 2005, 2006 by Eric Van Hensbergen <ericvh@gmail.com> 7 */ 8 9#include <linux/module.h> 10#include <linux/errno.h> 11#include <linux/fs.h> 12#include <linux/slab.h> 13#include <linux/sched.h> 14#include <linux/idr.h> 15#include <net/9p/9p.h> 16#include <net/9p/client.h> 17 18#include "v9fs.h" 19#include "v9fs_vfs.h" 20#include "fid.h" 21 22/** 23 * v9fs_fid_add - add a fid to a dentry 24 * @dentry: dentry that the fid is being added to 25 * @fid: fid to add 26 * 27 */ 28 29static inline void __add_fid(struct dentry *dentry, struct p9_fid *fid) 30{ 31 hlist_add_head(&fid->dlist, (struct hlist_head *)&dentry->d_fsdata); 32} 33 34void v9fs_fid_add(struct dentry *dentry, struct p9_fid *fid) 35{ 36 spin_lock(&dentry->d_lock); 37 __add_fid(dentry, fid); 38 spin_unlock(&dentry->d_lock); 39} 40 41/** 42 * v9fs_fid_find - retrieve a fid that belongs to the specified uid 43 * @dentry: dentry to look for fid in 44 * @uid: return fid that belongs to the specified user 45 * @any: if non-zero, return any fid associated with the dentry 46 * 47 */ 48 49static struct p9_fid *v9fs_fid_find(struct dentry *dentry, kuid_t uid, int any) 50{ 51 struct p9_fid *fid, *ret; 52 53 p9_debug(P9_DEBUG_VFS, " dentry: %pd (%p) uid %d any %d\n", 54 dentry, dentry, from_kuid(&init_user_ns, uid), 55 any); 56 ret = NULL; 57 /* we'll recheck under lock if there's anything to look in */ 58 if (dentry->d_fsdata) { 59 struct hlist_head *h = (struct hlist_head *)&dentry->d_fsdata; 60 spin_lock(&dentry->d_lock); 61 hlist_for_each_entry(fid, h, dlist) { 62 if (any || uid_eq(fid->uid, uid)) { 63 ret = fid; 64 break; 65 } 66 } 67 spin_unlock(&dentry->d_lock); 68 } 69 70 return ret; 71} 72 73/* 74 * We need to hold v9ses->rename_sem as long as we hold references 75 * to returned path array. Array element contain pointers to 76 * dentry names. 77 */ 78static int build_path_from_dentry(struct v9fs_session_info *v9ses, 79 struct dentry *dentry, const unsigned char ***names) 80{ 81 int n = 0, i; 82 const unsigned char **wnames; 83 struct dentry *ds; 84 85 for (ds = dentry; !IS_ROOT(ds); ds = ds->d_parent) 86 n++; 87 88 wnames = kmalloc_array(n, sizeof(char *), GFP_KERNEL); 89 if (!wnames) 90 goto err_out; 91 92 for (ds = dentry, i = (n-1); i >= 0; i--, ds = ds->d_parent) 93 wnames[i] = ds->d_name.name; 94 95 *names = wnames; 96 return n; 97err_out: 98 return -ENOMEM; 99} 100 101static struct p9_fid *v9fs_fid_lookup_with_uid(struct dentry *dentry, 102 kuid_t uid, int any) 103{ 104 struct dentry *ds; 105 const unsigned char **wnames, *uname; 106 int i, n, l, clone, access; 107 struct v9fs_session_info *v9ses; 108 struct p9_fid *fid, *old_fid = NULL; 109 110 v9ses = v9fs_dentry2v9ses(dentry); 111 access = v9ses->flags & V9FS_ACCESS_MASK; 112 fid = v9fs_fid_find(dentry, uid, any); 113 if (fid) 114 return fid; 115 /* 116 * we don't have a matching fid. To do a TWALK we need 117 * parent fid. We need to prevent rename when we want to 118 * look at the parent. 119 */ 120 down_read(&v9ses->rename_sem); 121 ds = dentry->d_parent; 122 fid = v9fs_fid_find(ds, uid, any); 123 if (fid) { 124 /* Found the parent fid do a lookup with that */ 125 fid = p9_client_walk(fid, 1, &dentry->d_name.name, 1); 126 goto fid_out; 127 } 128 up_read(&v9ses->rename_sem); 129 130 /* start from the root and try to do a lookup */ 131 fid = v9fs_fid_find(dentry->d_sb->s_root, uid, any); 132 if (!fid) { 133 /* the user is not attached to the fs yet */ 134 if (access == V9FS_ACCESS_SINGLE) 135 return ERR_PTR(-EPERM); 136 137 if (v9fs_proto_dotu(v9ses) || v9fs_proto_dotl(v9ses)) 138 uname = NULL; 139 else 140 uname = v9ses->uname; 141 142 fid = p9_client_attach(v9ses->clnt, NULL, uname, uid, 143 v9ses->aname); 144 if (IS_ERR(fid)) 145 return fid; 146 147 v9fs_fid_add(dentry->d_sb->s_root, fid); 148 } 149 /* If we are root ourself just return that */ 150 if (dentry->d_sb->s_root == dentry) 151 return fid; 152 /* 153 * Do a multipath walk with attached root. 154 * When walking parent we need to make sure we 155 * don't have a parallel rename happening 156 */ 157 down_read(&v9ses->rename_sem); 158 n = build_path_from_dentry(v9ses, dentry, &wnames); 159 if (n < 0) { 160 fid = ERR_PTR(n); 161 goto err_out; 162 } 163 clone = 1; 164 i = 0; 165 while (i < n) { 166 l = min(n - i, P9_MAXWELEM); 167 /* 168 * We need to hold rename lock when doing a multipath 169 * walk to ensure none of the patch component change 170 */ 171 fid = p9_client_walk(fid, l, &wnames[i], clone); 172 if (IS_ERR(fid)) { 173 if (old_fid) { 174 /* 175 * If we fail, clunk fid which are mapping 176 * to path component and not the last component 177 * of the path. 178 */ 179 p9_client_clunk(old_fid); 180 } 181 kfree(wnames); 182 goto err_out; 183 } 184 old_fid = fid; 185 i += l; 186 clone = 0; 187 } 188 kfree(wnames); 189fid_out: 190 if (!IS_ERR(fid)) { 191 spin_lock(&dentry->d_lock); 192 if (d_unhashed(dentry)) { 193 spin_unlock(&dentry->d_lock); 194 p9_client_clunk(fid); 195 fid = ERR_PTR(-ENOENT); 196 } else { 197 __add_fid(dentry, fid); 198 spin_unlock(&dentry->d_lock); 199 } 200 } 201err_out: 202 up_read(&v9ses->rename_sem); 203 return fid; 204} 205 206/** 207 * v9fs_fid_lookup - lookup for a fid, try to walk if not found 208 * @dentry: dentry to look for fid in 209 * 210 * Look for a fid in the specified dentry for the current user. 211 * If no fid is found, try to create one walking from a fid from the parent 212 * dentry (if it has one), or the root dentry. If the user haven't accessed 213 * the fs yet, attach now and walk from the root. 214 */ 215 216struct p9_fid *v9fs_fid_lookup(struct dentry *dentry) 217{ 218 kuid_t uid; 219 int any, access; 220 struct v9fs_session_info *v9ses; 221 222 v9ses = v9fs_dentry2v9ses(dentry); 223 access = v9ses->flags & V9FS_ACCESS_MASK; 224 switch (access) { 225 case V9FS_ACCESS_SINGLE: 226 case V9FS_ACCESS_USER: 227 case V9FS_ACCESS_CLIENT: 228 uid = current_fsuid(); 229 any = 0; 230 break; 231 232 case V9FS_ACCESS_ANY: 233 uid = v9ses->uid; 234 any = 1; 235 break; 236 237 default: 238 uid = INVALID_UID; 239 any = 0; 240 break; 241 } 242 return v9fs_fid_lookup_with_uid(dentry, uid, any); 243} 244 245struct p9_fid *v9fs_writeback_fid(struct dentry *dentry) 246{ 247 int err; 248 struct p9_fid *fid; 249 250 fid = clone_fid(v9fs_fid_lookup_with_uid(dentry, GLOBAL_ROOT_UID, 0)); 251 if (IS_ERR(fid)) 252 goto error_out; 253 /* 254 * writeback fid will only be used to write back the 255 * dirty pages. We always request for the open fid in read-write 256 * mode so that a partial page write which result in page 257 * read can work. 258 */ 259 err = p9_client_open(fid, O_RDWR); 260 if (err < 0) { 261 p9_client_clunk(fid); 262 fid = ERR_PTR(err); 263 goto error_out; 264 } 265error_out: 266 return fid; 267} 268