vfs_inode_dotl.c 24 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * linux/fs/9p/vfs_inode_dotl.c
  4. *
  5. * This file contains vfs inode ops for the 9P2000.L protocol.
  6. *
  7. * Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
  8. * Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
  9. */
  10. #include <linux/module.h>
  11. #include <linux/errno.h>
  12. #include <linux/fs.h>
  13. #include <linux/file.h>
  14. #include <linux/pagemap.h>
  15. #include <linux/stat.h>
  16. #include <linux/string.h>
  17. #include <linux/inet.h>
  18. #include <linux/namei.h>
  19. #include <linux/idr.h>
  20. #include <linux/sched.h>
  21. #include <linux/slab.h>
  22. #include <linux/xattr.h>
  23. #include <linux/posix_acl.h>
  24. #include <net/9p/9p.h>
  25. #include <net/9p/client.h>
  26. #include "v9fs.h"
  27. #include "v9fs_vfs.h"
  28. #include "fid.h"
  29. #include "cache.h"
  30. #include "xattr.h"
  31. #include "acl.h"
  32. static int
  33. v9fs_vfs_mknod_dotl(struct inode *dir, struct dentry *dentry, umode_t omode,
  34. dev_t rdev);
  35. /**
  36. * v9fs_get_fsgid_for_create - Helper function to get the gid for creating a
  37. * new file system object. This checks the S_ISGID to determine the owning
  38. * group of the new file system object.
  39. */
  40. static kgid_t v9fs_get_fsgid_for_create(struct inode *dir_inode)
  41. {
  42. BUG_ON(dir_inode == NULL);
  43. if (dir_inode->i_mode & S_ISGID) {
  44. /* set_gid bit is set.*/
  45. return dir_inode->i_gid;
  46. }
  47. return current_fsgid();
  48. }
  49. static int v9fs_test_inode_dotl(struct inode *inode, void *data)
  50. {
  51. struct v9fs_inode *v9inode = V9FS_I(inode);
  52. struct p9_stat_dotl *st = (struct p9_stat_dotl *)data;
  53. /* don't match inode of different type */
  54. if (inode_wrong_type(inode, st->st_mode))
  55. return 0;
  56. if (inode->i_generation != st->st_gen)
  57. return 0;
  58. /* compare qid details */
  59. if (memcmp(&v9inode->qid.version,
  60. &st->qid.version, sizeof(v9inode->qid.version)))
  61. return 0;
  62. if (v9inode->qid.type != st->qid.type)
  63. return 0;
  64. if (v9inode->qid.path != st->qid.path)
  65. return 0;
  66. return 1;
  67. }
  68. /* Always get a new inode */
  69. static int v9fs_test_new_inode_dotl(struct inode *inode, void *data)
  70. {
  71. return 0;
  72. }
  73. static int v9fs_set_inode_dotl(struct inode *inode, void *data)
  74. {
  75. struct v9fs_inode *v9inode = V9FS_I(inode);
  76. struct p9_stat_dotl *st = (struct p9_stat_dotl *)data;
  77. memcpy(&v9inode->qid, &st->qid, sizeof(st->qid));
  78. inode->i_generation = st->st_gen;
  79. return 0;
  80. }
  81. static struct inode *v9fs_qid_iget_dotl(struct super_block *sb,
  82. struct p9_qid *qid,
  83. struct p9_fid *fid,
  84. struct p9_stat_dotl *st,
  85. int new)
  86. {
  87. int retval;
  88. unsigned long i_ino;
  89. struct inode *inode;
  90. struct v9fs_session_info *v9ses = sb->s_fs_info;
  91. int (*test)(struct inode *, void *);
  92. if (new)
  93. test = v9fs_test_new_inode_dotl;
  94. else
  95. test = v9fs_test_inode_dotl;
  96. i_ino = v9fs_qid2ino(qid);
  97. inode = iget5_locked(sb, i_ino, test, v9fs_set_inode_dotl, st);
  98. if (!inode)
  99. return ERR_PTR(-ENOMEM);
  100. if (!(inode->i_state & I_NEW))
  101. return inode;
  102. /*
  103. * initialize the inode with the stat info
  104. * FIXME!! we may need support for stale inodes
  105. * later.
  106. */
  107. inode->i_ino = i_ino;
  108. retval = v9fs_init_inode(v9ses, inode,
  109. st->st_mode, new_decode_dev(st->st_rdev));
  110. if (retval)
  111. goto error;
  112. v9fs_stat2inode_dotl(st, inode, 0);
  113. v9fs_cache_inode_get_cookie(inode);
  114. retval = v9fs_get_acl(inode, fid);
  115. if (retval)
  116. goto error;
  117. unlock_new_inode(inode);
  118. return inode;
  119. error:
  120. iget_failed(inode);
  121. return ERR_PTR(retval);
  122. }
  123. struct inode *
  124. v9fs_inode_from_fid_dotl(struct v9fs_session_info *v9ses, struct p9_fid *fid,
  125. struct super_block *sb, int new)
  126. {
  127. struct p9_stat_dotl *st;
  128. struct inode *inode = NULL;
  129. st = p9_client_getattr_dotl(fid, P9_STATS_BASIC | P9_STATS_GEN);
  130. if (IS_ERR(st))
  131. return ERR_CAST(st);
  132. inode = v9fs_qid_iget_dotl(sb, &st->qid, fid, st, new);
  133. kfree(st);
  134. return inode;
  135. }
  136. struct dotl_openflag_map {
  137. int open_flag;
  138. int dotl_flag;
  139. };
  140. static int v9fs_mapped_dotl_flags(int flags)
  141. {
  142. int i;
  143. int rflags = 0;
  144. struct dotl_openflag_map dotl_oflag_map[] = {
  145. { O_CREAT, P9_DOTL_CREATE },
  146. { O_EXCL, P9_DOTL_EXCL },
  147. { O_NOCTTY, P9_DOTL_NOCTTY },
  148. { O_APPEND, P9_DOTL_APPEND },
  149. { O_NONBLOCK, P9_DOTL_NONBLOCK },
  150. { O_DSYNC, P9_DOTL_DSYNC },
  151. { FASYNC, P9_DOTL_FASYNC },
  152. { O_DIRECT, P9_DOTL_DIRECT },
  153. { O_LARGEFILE, P9_DOTL_LARGEFILE },
  154. { O_DIRECTORY, P9_DOTL_DIRECTORY },
  155. { O_NOFOLLOW, P9_DOTL_NOFOLLOW },
  156. { O_NOATIME, P9_DOTL_NOATIME },
  157. { O_CLOEXEC, P9_DOTL_CLOEXEC },
  158. { O_SYNC, P9_DOTL_SYNC},
  159. };
  160. for (i = 0; i < ARRAY_SIZE(dotl_oflag_map); i++) {
  161. if (flags & dotl_oflag_map[i].open_flag)
  162. rflags |= dotl_oflag_map[i].dotl_flag;
  163. }
  164. return rflags;
  165. }
  166. /**
  167. * v9fs_open_to_dotl_flags- convert Linux specific open flags to
  168. * plan 9 open flag.
  169. * @flags: flags to convert
  170. */
  171. int v9fs_open_to_dotl_flags(int flags)
  172. {
  173. int rflags = 0;
  174. /*
  175. * We have same bits for P9_DOTL_READONLY, P9_DOTL_WRONLY
  176. * and P9_DOTL_NOACCESS
  177. */
  178. rflags |= flags & O_ACCMODE;
  179. rflags |= v9fs_mapped_dotl_flags(flags);
  180. return rflags;
  181. }
  182. /**
  183. * v9fs_vfs_create_dotl - VFS hook to create files for 9P2000.L protocol.
  184. * @dir: directory inode that is being created
  185. * @dentry: dentry that is being deleted
  186. * @omode: create permissions
  187. *
  188. */
  189. static int
  190. v9fs_vfs_create_dotl(struct inode *dir, struct dentry *dentry, umode_t omode,
  191. bool excl)
  192. {
  193. return v9fs_vfs_mknod_dotl(dir, dentry, omode, 0);
  194. }
  195. static int
  196. v9fs_vfs_atomic_open_dotl(struct inode *dir, struct dentry *dentry,
  197. struct file *file, unsigned flags, umode_t omode)
  198. {
  199. int err = 0;
  200. kgid_t gid;
  201. umode_t mode;
  202. const unsigned char *name = NULL;
  203. struct p9_qid qid;
  204. struct inode *inode;
  205. struct p9_fid *fid = NULL;
  206. struct v9fs_inode *v9inode;
  207. struct p9_fid *dfid, *ofid, *inode_fid;
  208. struct v9fs_session_info *v9ses;
  209. struct posix_acl *pacl = NULL, *dacl = NULL;
  210. struct dentry *res = NULL;
  211. if (d_in_lookup(dentry)) {
  212. res = v9fs_vfs_lookup(dir, dentry, 0);
  213. if (IS_ERR(res))
  214. return PTR_ERR(res);
  215. if (res)
  216. dentry = res;
  217. }
  218. /* Only creates */
  219. if (!(flags & O_CREAT) || d_really_is_positive(dentry))
  220. return finish_no_open(file, res);
  221. v9ses = v9fs_inode2v9ses(dir);
  222. name = dentry->d_name.name;
  223. p9_debug(P9_DEBUG_VFS, "name:%s flags:0x%x mode:0x%hx\n",
  224. name, flags, omode);
  225. dfid = v9fs_parent_fid(dentry);
  226. if (IS_ERR(dfid)) {
  227. err = PTR_ERR(dfid);
  228. p9_debug(P9_DEBUG_VFS, "fid lookup failed %d\n", err);
  229. goto out;
  230. }
  231. /* clone a fid to use for creation */
  232. ofid = clone_fid(dfid);
  233. if (IS_ERR(ofid)) {
  234. err = PTR_ERR(ofid);
  235. p9_debug(P9_DEBUG_VFS, "p9_client_walk failed %d\n", err);
  236. goto out;
  237. }
  238. gid = v9fs_get_fsgid_for_create(dir);
  239. mode = omode;
  240. /* Update mode based on ACL value */
  241. err = v9fs_acl_mode(dir, &mode, &dacl, &pacl);
  242. if (err) {
  243. p9_debug(P9_DEBUG_VFS, "Failed to get acl values in creat %d\n",
  244. err);
  245. goto error;
  246. }
  247. err = p9_client_create_dotl(ofid, name, v9fs_open_to_dotl_flags(flags),
  248. mode, gid, &qid);
  249. if (err < 0) {
  250. p9_debug(P9_DEBUG_VFS, "p9_client_open_dotl failed in creat %d\n",
  251. err);
  252. goto error;
  253. }
  254. v9fs_invalidate_inode_attr(dir);
  255. /* instantiate inode and assign the unopened fid to the dentry */
  256. fid = p9_client_walk(dfid, 1, &name, 1);
  257. if (IS_ERR(fid)) {
  258. err = PTR_ERR(fid);
  259. p9_debug(P9_DEBUG_VFS, "p9_client_walk failed %d\n", err);
  260. fid = NULL;
  261. goto error;
  262. }
  263. inode = v9fs_get_new_inode_from_fid(v9ses, fid, dir->i_sb);
  264. if (IS_ERR(inode)) {
  265. err = PTR_ERR(inode);
  266. p9_debug(P9_DEBUG_VFS, "inode creation failed %d\n", err);
  267. goto error;
  268. }
  269. /* Now set the ACL based on the default value */
  270. v9fs_set_create_acl(inode, fid, dacl, pacl);
  271. v9fs_fid_add(dentry, fid);
  272. d_instantiate(dentry, inode);
  273. v9inode = V9FS_I(inode);
  274. mutex_lock(&v9inode->v_mutex);
  275. if ((v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) &&
  276. !v9inode->writeback_fid &&
  277. ((flags & O_ACCMODE) != O_RDONLY)) {
  278. /*
  279. * clone a fid and add it to writeback_fid
  280. * we do it during open time instead of
  281. * page dirty time via write_begin/page_mkwrite
  282. * because we want write after unlink usecase
  283. * to work.
  284. */
  285. inode_fid = v9fs_writeback_fid(dentry);
  286. if (IS_ERR(inode_fid)) {
  287. err = PTR_ERR(inode_fid);
  288. mutex_unlock(&v9inode->v_mutex);
  289. goto err_clunk_old_fid;
  290. }
  291. v9inode->writeback_fid = (void *) inode_fid;
  292. }
  293. mutex_unlock(&v9inode->v_mutex);
  294. /* Since we are opening a file, assign the open fid to the file */
  295. err = finish_open(file, dentry, generic_file_open);
  296. if (err)
  297. goto err_clunk_old_fid;
  298. file->private_data = ofid;
  299. if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE)
  300. v9fs_cache_inode_set_cookie(inode, file);
  301. file->f_mode |= FMODE_CREATED;
  302. out:
  303. v9fs_put_acl(dacl, pacl);
  304. dput(res);
  305. return err;
  306. error:
  307. if (fid)
  308. p9_client_clunk(fid);
  309. err_clunk_old_fid:
  310. if (ofid)
  311. p9_client_clunk(ofid);
  312. goto out;
  313. }
  314. /**
  315. * v9fs_vfs_mkdir_dotl - VFS mkdir hook to create a directory
  316. * @dir: inode that is being unlinked
  317. * @dentry: dentry that is being unlinked
  318. * @omode: mode for new directory
  319. *
  320. */
  321. static int v9fs_vfs_mkdir_dotl(struct inode *dir,
  322. struct dentry *dentry, umode_t omode)
  323. {
  324. int err;
  325. struct v9fs_session_info *v9ses;
  326. struct p9_fid *fid = NULL, *dfid = NULL;
  327. kgid_t gid;
  328. const unsigned char *name;
  329. umode_t mode;
  330. struct inode *inode;
  331. struct p9_qid qid;
  332. struct posix_acl *dacl = NULL, *pacl = NULL;
  333. p9_debug(P9_DEBUG_VFS, "name %pd\n", dentry);
  334. err = 0;
  335. v9ses = v9fs_inode2v9ses(dir);
  336. omode |= S_IFDIR;
  337. if (dir->i_mode & S_ISGID)
  338. omode |= S_ISGID;
  339. dfid = v9fs_parent_fid(dentry);
  340. if (IS_ERR(dfid)) {
  341. err = PTR_ERR(dfid);
  342. p9_debug(P9_DEBUG_VFS, "fid lookup failed %d\n", err);
  343. dfid = NULL;
  344. goto error;
  345. }
  346. gid = v9fs_get_fsgid_for_create(dir);
  347. mode = omode;
  348. /* Update mode based on ACL value */
  349. err = v9fs_acl_mode(dir, &mode, &dacl, &pacl);
  350. if (err) {
  351. p9_debug(P9_DEBUG_VFS, "Failed to get acl values in mkdir %d\n",
  352. err);
  353. goto error;
  354. }
  355. name = dentry->d_name.name;
  356. err = p9_client_mkdir_dotl(dfid, name, mode, gid, &qid);
  357. if (err < 0)
  358. goto error;
  359. fid = p9_client_walk(dfid, 1, &name, 1);
  360. if (IS_ERR(fid)) {
  361. err = PTR_ERR(fid);
  362. p9_debug(P9_DEBUG_VFS, "p9_client_walk failed %d\n",
  363. err);
  364. fid = NULL;
  365. goto error;
  366. }
  367. /* instantiate inode and assign the unopened fid to the dentry */
  368. if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) {
  369. inode = v9fs_get_new_inode_from_fid(v9ses, fid, dir->i_sb);
  370. if (IS_ERR(inode)) {
  371. err = PTR_ERR(inode);
  372. p9_debug(P9_DEBUG_VFS, "inode creation failed %d\n",
  373. err);
  374. goto error;
  375. }
  376. v9fs_fid_add(dentry, fid);
  377. v9fs_set_create_acl(inode, fid, dacl, pacl);
  378. d_instantiate(dentry, inode);
  379. fid = NULL;
  380. err = 0;
  381. } else {
  382. /*
  383. * Not in cached mode. No need to populate
  384. * inode with stat. We need to get an inode
  385. * so that we can set the acl with dentry
  386. */
  387. inode = v9fs_get_inode(dir->i_sb, mode, 0);
  388. if (IS_ERR(inode)) {
  389. err = PTR_ERR(inode);
  390. goto error;
  391. }
  392. v9fs_set_create_acl(inode, fid, dacl, pacl);
  393. d_instantiate(dentry, inode);
  394. }
  395. inc_nlink(dir);
  396. v9fs_invalidate_inode_attr(dir);
  397. error:
  398. if (fid)
  399. p9_client_clunk(fid);
  400. v9fs_put_acl(dacl, pacl);
  401. return err;
  402. }
  403. static int
  404. v9fs_vfs_getattr_dotl(const struct path *path, struct kstat *stat,
  405. u32 request_mask, unsigned int flags)
  406. {
  407. struct dentry *dentry = path->dentry;
  408. struct v9fs_session_info *v9ses;
  409. struct p9_fid *fid;
  410. struct p9_stat_dotl *st;
  411. p9_debug(P9_DEBUG_VFS, "dentry: %p\n", dentry);
  412. v9ses = v9fs_dentry2v9ses(dentry);
  413. if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) {
  414. generic_fillattr(d_inode(dentry), stat);
  415. return 0;
  416. }
  417. fid = v9fs_fid_lookup(dentry);
  418. if (IS_ERR(fid))
  419. return PTR_ERR(fid);
  420. /* Ask for all the fields in stat structure. Server will return
  421. * whatever it supports
  422. */
  423. st = p9_client_getattr_dotl(fid, P9_STATS_ALL);
  424. if (IS_ERR(st))
  425. return PTR_ERR(st);
  426. v9fs_stat2inode_dotl(st, d_inode(dentry), 0);
  427. generic_fillattr(d_inode(dentry), stat);
  428. /* Change block size to what the server returned */
  429. stat->blksize = st->st_blksize;
  430. kfree(st);
  431. return 0;
  432. }
  433. /*
  434. * Attribute flags.
  435. */
  436. #define P9_ATTR_MODE (1 << 0)
  437. #define P9_ATTR_UID (1 << 1)
  438. #define P9_ATTR_GID (1 << 2)
  439. #define P9_ATTR_SIZE (1 << 3)
  440. #define P9_ATTR_ATIME (1 << 4)
  441. #define P9_ATTR_MTIME (1 << 5)
  442. #define P9_ATTR_CTIME (1 << 6)
  443. #define P9_ATTR_ATIME_SET (1 << 7)
  444. #define P9_ATTR_MTIME_SET (1 << 8)
  445. struct dotl_iattr_map {
  446. int iattr_valid;
  447. int p9_iattr_valid;
  448. };
  449. static int v9fs_mapped_iattr_valid(int iattr_valid)
  450. {
  451. int i;
  452. int p9_iattr_valid = 0;
  453. struct dotl_iattr_map dotl_iattr_map[] = {
  454. { ATTR_MODE, P9_ATTR_MODE },
  455. { ATTR_UID, P9_ATTR_UID },
  456. { ATTR_GID, P9_ATTR_GID },
  457. { ATTR_SIZE, P9_ATTR_SIZE },
  458. { ATTR_ATIME, P9_ATTR_ATIME },
  459. { ATTR_MTIME, P9_ATTR_MTIME },
  460. { ATTR_CTIME, P9_ATTR_CTIME },
  461. { ATTR_ATIME_SET, P9_ATTR_ATIME_SET },
  462. { ATTR_MTIME_SET, P9_ATTR_MTIME_SET },
  463. };
  464. for (i = 0; i < ARRAY_SIZE(dotl_iattr_map); i++) {
  465. if (iattr_valid & dotl_iattr_map[i].iattr_valid)
  466. p9_iattr_valid |= dotl_iattr_map[i].p9_iattr_valid;
  467. }
  468. return p9_iattr_valid;
  469. }
  470. /**
  471. * v9fs_vfs_setattr_dotl - set file metadata
  472. * @dentry: file whose metadata to set
  473. * @iattr: metadata assignment structure
  474. *
  475. */
  476. int v9fs_vfs_setattr_dotl(struct dentry *dentry, struct iattr *iattr)
  477. {
  478. int retval;
  479. struct p9_fid *fid = NULL;
  480. struct p9_iattr_dotl p9attr = {
  481. .uid = INVALID_UID,
  482. .gid = INVALID_GID,
  483. };
  484. struct inode *inode = d_inode(dentry);
  485. p9_debug(P9_DEBUG_VFS, "\n");
  486. retval = setattr_prepare(dentry, iattr);
  487. if (retval)
  488. return retval;
  489. p9attr.valid = v9fs_mapped_iattr_valid(iattr->ia_valid);
  490. if (iattr->ia_valid & ATTR_MODE)
  491. p9attr.mode = iattr->ia_mode;
  492. if (iattr->ia_valid & ATTR_UID)
  493. p9attr.uid = iattr->ia_uid;
  494. if (iattr->ia_valid & ATTR_GID)
  495. p9attr.gid = iattr->ia_gid;
  496. if (iattr->ia_valid & ATTR_SIZE)
  497. p9attr.size = iattr->ia_size;
  498. if (iattr->ia_valid & ATTR_ATIME_SET) {
  499. p9attr.atime_sec = iattr->ia_atime.tv_sec;
  500. p9attr.atime_nsec = iattr->ia_atime.tv_nsec;
  501. }
  502. if (iattr->ia_valid & ATTR_MTIME_SET) {
  503. p9attr.mtime_sec = iattr->ia_mtime.tv_sec;
  504. p9attr.mtime_nsec = iattr->ia_mtime.tv_nsec;
  505. }
  506. if (iattr->ia_valid & ATTR_FILE) {
  507. fid = iattr->ia_file->private_data;
  508. WARN_ON(!fid);
  509. }
  510. if (!fid)
  511. fid = v9fs_fid_lookup(dentry);
  512. if (IS_ERR(fid))
  513. return PTR_ERR(fid);
  514. /* Write all dirty data */
  515. if (S_ISREG(inode->i_mode))
  516. filemap_write_and_wait(inode->i_mapping);
  517. retval = p9_client_setattr(fid, &p9attr);
  518. if (retval < 0)
  519. return retval;
  520. if ((iattr->ia_valid & ATTR_SIZE) &&
  521. iattr->ia_size != i_size_read(inode))
  522. truncate_setsize(inode, iattr->ia_size);
  523. v9fs_invalidate_inode_attr(inode);
  524. setattr_copy(inode, iattr);
  525. mark_inode_dirty(inode);
  526. if (iattr->ia_valid & ATTR_MODE) {
  527. /* We also want to update ACL when we update mode bits */
  528. retval = v9fs_acl_chmod(inode, fid);
  529. if (retval < 0)
  530. return retval;
  531. }
  532. return 0;
  533. }
  534. /**
  535. * v9fs_stat2inode_dotl - populate an inode structure with stat info
  536. * @stat: stat structure
  537. * @inode: inode to populate
  538. * @flags: ctrl flags (e.g. V9FS_STAT2INODE_KEEP_ISIZE)
  539. *
  540. */
  541. void
  542. v9fs_stat2inode_dotl(struct p9_stat_dotl *stat, struct inode *inode,
  543. unsigned int flags)
  544. {
  545. umode_t mode;
  546. struct v9fs_inode *v9inode = V9FS_I(inode);
  547. if ((stat->st_result_mask & P9_STATS_BASIC) == P9_STATS_BASIC) {
  548. inode->i_atime.tv_sec = stat->st_atime_sec;
  549. inode->i_atime.tv_nsec = stat->st_atime_nsec;
  550. inode->i_mtime.tv_sec = stat->st_mtime_sec;
  551. inode->i_mtime.tv_nsec = stat->st_mtime_nsec;
  552. inode->i_ctime.tv_sec = stat->st_ctime_sec;
  553. inode->i_ctime.tv_nsec = stat->st_ctime_nsec;
  554. inode->i_uid = stat->st_uid;
  555. inode->i_gid = stat->st_gid;
  556. set_nlink(inode, stat->st_nlink);
  557. mode = stat->st_mode & S_IALLUGO;
  558. mode |= inode->i_mode & ~S_IALLUGO;
  559. inode->i_mode = mode;
  560. if (!(flags & V9FS_STAT2INODE_KEEP_ISIZE))
  561. v9fs_i_size_write(inode, stat->st_size);
  562. inode->i_blocks = stat->st_blocks;
  563. } else {
  564. if (stat->st_result_mask & P9_STATS_ATIME) {
  565. inode->i_atime.tv_sec = stat->st_atime_sec;
  566. inode->i_atime.tv_nsec = stat->st_atime_nsec;
  567. }
  568. if (stat->st_result_mask & P9_STATS_MTIME) {
  569. inode->i_mtime.tv_sec = stat->st_mtime_sec;
  570. inode->i_mtime.tv_nsec = stat->st_mtime_nsec;
  571. }
  572. if (stat->st_result_mask & P9_STATS_CTIME) {
  573. inode->i_ctime.tv_sec = stat->st_ctime_sec;
  574. inode->i_ctime.tv_nsec = stat->st_ctime_nsec;
  575. }
  576. if (stat->st_result_mask & P9_STATS_UID)
  577. inode->i_uid = stat->st_uid;
  578. if (stat->st_result_mask & P9_STATS_GID)
  579. inode->i_gid = stat->st_gid;
  580. if (stat->st_result_mask & P9_STATS_NLINK)
  581. set_nlink(inode, stat->st_nlink);
  582. if (stat->st_result_mask & P9_STATS_MODE) {
  583. inode->i_mode = stat->st_mode;
  584. if ((S_ISBLK(inode->i_mode)) ||
  585. (S_ISCHR(inode->i_mode)))
  586. init_special_inode(inode, inode->i_mode,
  587. inode->i_rdev);
  588. }
  589. if (stat->st_result_mask & P9_STATS_RDEV)
  590. inode->i_rdev = new_decode_dev(stat->st_rdev);
  591. if (!(flags & V9FS_STAT2INODE_KEEP_ISIZE) &&
  592. stat->st_result_mask & P9_STATS_SIZE)
  593. v9fs_i_size_write(inode, stat->st_size);
  594. if (stat->st_result_mask & P9_STATS_BLOCKS)
  595. inode->i_blocks = stat->st_blocks;
  596. }
  597. if (stat->st_result_mask & P9_STATS_GEN)
  598. inode->i_generation = stat->st_gen;
  599. /* Currently we don't support P9_STATS_BTIME and P9_STATS_DATA_VERSION
  600. * because the inode structure does not have fields for them.
  601. */
  602. v9inode->cache_validity &= ~V9FS_INO_INVALID_ATTR;
  603. }
  604. static int
  605. v9fs_vfs_symlink_dotl(struct inode *dir, struct dentry *dentry,
  606. const char *symname)
  607. {
  608. int err;
  609. kgid_t gid;
  610. const unsigned char *name;
  611. struct p9_qid qid;
  612. struct inode *inode;
  613. struct p9_fid *dfid;
  614. struct p9_fid *fid = NULL;
  615. struct v9fs_session_info *v9ses;
  616. name = dentry->d_name.name;
  617. p9_debug(P9_DEBUG_VFS, "%lu,%s,%s\n", dir->i_ino, name, symname);
  618. v9ses = v9fs_inode2v9ses(dir);
  619. dfid = v9fs_parent_fid(dentry);
  620. if (IS_ERR(dfid)) {
  621. err = PTR_ERR(dfid);
  622. p9_debug(P9_DEBUG_VFS, "fid lookup failed %d\n", err);
  623. return err;
  624. }
  625. gid = v9fs_get_fsgid_for_create(dir);
  626. /* Server doesn't alter fid on TSYMLINK. Hence no need to clone it. */
  627. err = p9_client_symlink(dfid, name, symname, gid, &qid);
  628. if (err < 0) {
  629. p9_debug(P9_DEBUG_VFS, "p9_client_symlink failed %d\n", err);
  630. goto error;
  631. }
  632. v9fs_invalidate_inode_attr(dir);
  633. if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) {
  634. /* Now walk from the parent so we can get an unopened fid. */
  635. fid = p9_client_walk(dfid, 1, &name, 1);
  636. if (IS_ERR(fid)) {
  637. err = PTR_ERR(fid);
  638. p9_debug(P9_DEBUG_VFS, "p9_client_walk failed %d\n",
  639. err);
  640. fid = NULL;
  641. goto error;
  642. }
  643. /* instantiate inode and assign the unopened fid to dentry */
  644. inode = v9fs_get_new_inode_from_fid(v9ses, fid, dir->i_sb);
  645. if (IS_ERR(inode)) {
  646. err = PTR_ERR(inode);
  647. p9_debug(P9_DEBUG_VFS, "inode creation failed %d\n",
  648. err);
  649. goto error;
  650. }
  651. v9fs_fid_add(dentry, fid);
  652. d_instantiate(dentry, inode);
  653. fid = NULL;
  654. err = 0;
  655. } else {
  656. /* Not in cached mode. No need to populate inode with stat */
  657. inode = v9fs_get_inode(dir->i_sb, S_IFLNK, 0);
  658. if (IS_ERR(inode)) {
  659. err = PTR_ERR(inode);
  660. goto error;
  661. }
  662. d_instantiate(dentry, inode);
  663. }
  664. error:
  665. if (fid)
  666. p9_client_clunk(fid);
  667. return err;
  668. }
  669. /**
  670. * v9fs_vfs_link_dotl - create a hardlink for dotl
  671. * @old_dentry: dentry for file to link to
  672. * @dir: inode destination for new link
  673. * @dentry: dentry for link
  674. *
  675. */
  676. static int
  677. v9fs_vfs_link_dotl(struct dentry *old_dentry, struct inode *dir,
  678. struct dentry *dentry)
  679. {
  680. int err;
  681. struct p9_fid *dfid, *oldfid;
  682. struct v9fs_session_info *v9ses;
  683. p9_debug(P9_DEBUG_VFS, "dir ino: %lu, old_name: %pd, new_name: %pd\n",
  684. dir->i_ino, old_dentry, dentry);
  685. v9ses = v9fs_inode2v9ses(dir);
  686. dfid = v9fs_parent_fid(dentry);
  687. if (IS_ERR(dfid))
  688. return PTR_ERR(dfid);
  689. oldfid = v9fs_fid_lookup(old_dentry);
  690. if (IS_ERR(oldfid))
  691. return PTR_ERR(oldfid);
  692. err = p9_client_link(dfid, oldfid, dentry->d_name.name);
  693. if (err < 0) {
  694. p9_debug(P9_DEBUG_VFS, "p9_client_link failed %d\n", err);
  695. return err;
  696. }
  697. v9fs_invalidate_inode_attr(dir);
  698. if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) {
  699. /* Get the latest stat info from server. */
  700. struct p9_fid *fid;
  701. fid = v9fs_fid_lookup(old_dentry);
  702. if (IS_ERR(fid))
  703. return PTR_ERR(fid);
  704. v9fs_refresh_inode_dotl(fid, d_inode(old_dentry));
  705. }
  706. ihold(d_inode(old_dentry));
  707. d_instantiate(dentry, d_inode(old_dentry));
  708. return err;
  709. }
  710. /**
  711. * v9fs_vfs_mknod_dotl - create a special file
  712. * @dir: inode destination for new link
  713. * @dentry: dentry for file
  714. * @omode: mode for creation
  715. * @rdev: device associated with special file
  716. *
  717. */
  718. static int
  719. v9fs_vfs_mknod_dotl(struct inode *dir, struct dentry *dentry, umode_t omode,
  720. dev_t rdev)
  721. {
  722. int err;
  723. kgid_t gid;
  724. const unsigned char *name;
  725. umode_t mode;
  726. struct v9fs_session_info *v9ses;
  727. struct p9_fid *fid = NULL, *dfid = NULL;
  728. struct inode *inode;
  729. struct p9_qid qid;
  730. struct posix_acl *dacl = NULL, *pacl = NULL;
  731. p9_debug(P9_DEBUG_VFS, " %lu,%pd mode: %hx MAJOR: %u MINOR: %u\n",
  732. dir->i_ino, dentry, omode,
  733. MAJOR(rdev), MINOR(rdev));
  734. v9ses = v9fs_inode2v9ses(dir);
  735. dfid = v9fs_parent_fid(dentry);
  736. if (IS_ERR(dfid)) {
  737. err = PTR_ERR(dfid);
  738. p9_debug(P9_DEBUG_VFS, "fid lookup failed %d\n", err);
  739. dfid = NULL;
  740. goto error;
  741. }
  742. gid = v9fs_get_fsgid_for_create(dir);
  743. mode = omode;
  744. /* Update mode based on ACL value */
  745. err = v9fs_acl_mode(dir, &mode, &dacl, &pacl);
  746. if (err) {
  747. p9_debug(P9_DEBUG_VFS, "Failed to get acl values in mknod %d\n",
  748. err);
  749. goto error;
  750. }
  751. name = dentry->d_name.name;
  752. err = p9_client_mknod_dotl(dfid, name, mode, rdev, gid, &qid);
  753. if (err < 0)
  754. goto error;
  755. v9fs_invalidate_inode_attr(dir);
  756. fid = p9_client_walk(dfid, 1, &name, 1);
  757. if (IS_ERR(fid)) {
  758. err = PTR_ERR(fid);
  759. p9_debug(P9_DEBUG_VFS, "p9_client_walk failed %d\n",
  760. err);
  761. fid = NULL;
  762. goto error;
  763. }
  764. /* instantiate inode and assign the unopened fid to the dentry */
  765. if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) {
  766. inode = v9fs_get_new_inode_from_fid(v9ses, fid, dir->i_sb);
  767. if (IS_ERR(inode)) {
  768. err = PTR_ERR(inode);
  769. p9_debug(P9_DEBUG_VFS, "inode creation failed %d\n",
  770. err);
  771. goto error;
  772. }
  773. v9fs_set_create_acl(inode, fid, dacl, pacl);
  774. v9fs_fid_add(dentry, fid);
  775. d_instantiate(dentry, inode);
  776. fid = NULL;
  777. err = 0;
  778. } else {
  779. /*
  780. * Not in cached mode. No need to populate inode with stat.
  781. * socket syscall returns a fd, so we need instantiate
  782. */
  783. inode = v9fs_get_inode(dir->i_sb, mode, rdev);
  784. if (IS_ERR(inode)) {
  785. err = PTR_ERR(inode);
  786. goto error;
  787. }
  788. v9fs_set_create_acl(inode, fid, dacl, pacl);
  789. d_instantiate(dentry, inode);
  790. }
  791. error:
  792. if (fid)
  793. p9_client_clunk(fid);
  794. v9fs_put_acl(dacl, pacl);
  795. return err;
  796. }
  797. /**
  798. * v9fs_vfs_get_link_dotl - follow a symlink path
  799. * @dentry: dentry for symlink
  800. * @inode: inode for symlink
  801. * @done: destructor for return value
  802. */
  803. static const char *
  804. v9fs_vfs_get_link_dotl(struct dentry *dentry,
  805. struct inode *inode,
  806. struct delayed_call *done)
  807. {
  808. struct p9_fid *fid;
  809. char *target;
  810. int retval;
  811. if (!dentry)
  812. return ERR_PTR(-ECHILD);
  813. p9_debug(P9_DEBUG_VFS, "%pd\n", dentry);
  814. fid = v9fs_fid_lookup(dentry);
  815. if (IS_ERR(fid))
  816. return ERR_CAST(fid);
  817. retval = p9_client_readlink(fid, &target);
  818. if (retval)
  819. return ERR_PTR(retval);
  820. set_delayed_call(done, kfree_link, target);
  821. return target;
  822. }
  823. int v9fs_refresh_inode_dotl(struct p9_fid *fid, struct inode *inode)
  824. {
  825. struct p9_stat_dotl *st;
  826. struct v9fs_session_info *v9ses;
  827. unsigned int flags;
  828. v9ses = v9fs_inode2v9ses(inode);
  829. st = p9_client_getattr_dotl(fid, P9_STATS_ALL);
  830. if (IS_ERR(st))
  831. return PTR_ERR(st);
  832. /*
  833. * Don't update inode if the file type is different
  834. */
  835. if (inode_wrong_type(inode, st->st_mode))
  836. goto out;
  837. /*
  838. * We don't want to refresh inode->i_size,
  839. * because we may have cached data
  840. */
  841. flags = (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) ?
  842. V9FS_STAT2INODE_KEEP_ISIZE : 0;
  843. v9fs_stat2inode_dotl(st, inode, flags);
  844. out:
  845. kfree(st);
  846. return 0;
  847. }
  848. const struct inode_operations v9fs_dir_inode_operations_dotl = {
  849. .create = v9fs_vfs_create_dotl,
  850. .atomic_open = v9fs_vfs_atomic_open_dotl,
  851. .lookup = v9fs_vfs_lookup,
  852. .link = v9fs_vfs_link_dotl,
  853. .symlink = v9fs_vfs_symlink_dotl,
  854. .unlink = v9fs_vfs_unlink,
  855. .mkdir = v9fs_vfs_mkdir_dotl,
  856. .rmdir = v9fs_vfs_rmdir,
  857. .mknod = v9fs_vfs_mknod_dotl,
  858. .rename = v9fs_vfs_rename,
  859. .getattr = v9fs_vfs_getattr_dotl,
  860. .setattr = v9fs_vfs_setattr_dotl,
  861. .listxattr = v9fs_listxattr,
  862. .get_acl = v9fs_iop_get_acl,
  863. };
  864. const struct inode_operations v9fs_file_inode_operations_dotl = {
  865. .getattr = v9fs_vfs_getattr_dotl,
  866. .setattr = v9fs_vfs_setattr_dotl,
  867. .listxattr = v9fs_listxattr,
  868. .get_acl = v9fs_iop_get_acl,
  869. };
  870. const struct inode_operations v9fs_symlink_inode_operations_dotl = {
  871. .get_link = v9fs_vfs_get_link_dotl,
  872. .getattr = v9fs_vfs_getattr_dotl,
  873. .setattr = v9fs_vfs_setattr_dotl,
  874. .listxattr = v9fs_listxattr,
  875. };