fid.c 7.2 KB

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