vfs_inode.c 32 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * linux/fs/9p/vfs_inode.c
  4. *
  5. * This file contains vfs inode ops for the 9P2000 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. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  11. #include <linux/module.h>
  12. #include <linux/errno.h>
  13. #include <linux/fs.h>
  14. #include <linux/file.h>
  15. #include <linux/pagemap.h>
  16. #include <linux/stat.h>
  17. #include <linux/string.h>
  18. #include <linux/inet.h>
  19. #include <linux/namei.h>
  20. #include <linux/idr.h>
  21. #include <linux/sched.h>
  22. #include <linux/slab.h>
  23. #include <linux/xattr.h>
  24. #include <linux/posix_acl.h>
  25. #include <net/9p/9p.h>
  26. #include <net/9p/client.h>
  27. #include "v9fs.h"
  28. #include "v9fs_vfs.h"
  29. #include "fid.h"
  30. #include "cache.h"
  31. #include "xattr.h"
  32. #include "acl.h"
  33. static const struct inode_operations v9fs_dir_inode_operations;
  34. static const struct inode_operations v9fs_dir_inode_operations_dotu;
  35. static const struct inode_operations v9fs_file_inode_operations;
  36. static const struct inode_operations v9fs_symlink_inode_operations;
  37. /**
  38. * unixmode2p9mode - convert unix mode bits to plan 9
  39. * @v9ses: v9fs session information
  40. * @mode: mode to convert
  41. *
  42. */
  43. static u32 unixmode2p9mode(struct v9fs_session_info *v9ses, umode_t mode)
  44. {
  45. int res;
  46. res = mode & 0777;
  47. if (S_ISDIR(mode))
  48. res |= P9_DMDIR;
  49. if (v9fs_proto_dotu(v9ses)) {
  50. if (v9ses->nodev == 0) {
  51. if (S_ISSOCK(mode))
  52. res |= P9_DMSOCKET;
  53. if (S_ISFIFO(mode))
  54. res |= P9_DMNAMEDPIPE;
  55. if (S_ISBLK(mode))
  56. res |= P9_DMDEVICE;
  57. if (S_ISCHR(mode))
  58. res |= P9_DMDEVICE;
  59. }
  60. if ((mode & S_ISUID) == S_ISUID)
  61. res |= P9_DMSETUID;
  62. if ((mode & S_ISGID) == S_ISGID)
  63. res |= P9_DMSETGID;
  64. if ((mode & S_ISVTX) == S_ISVTX)
  65. res |= P9_DMSETVTX;
  66. }
  67. return res;
  68. }
  69. /**
  70. * p9mode2perm- convert plan9 mode bits to unix permission bits
  71. * @v9ses: v9fs session information
  72. * @stat: p9_wstat from which mode need to be derived
  73. *
  74. */
  75. static int p9mode2perm(struct v9fs_session_info *v9ses,
  76. struct p9_wstat *stat)
  77. {
  78. int res;
  79. int mode = stat->mode;
  80. res = mode & S_IALLUGO;
  81. if (v9fs_proto_dotu(v9ses)) {
  82. if ((mode & P9_DMSETUID) == P9_DMSETUID)
  83. res |= S_ISUID;
  84. if ((mode & P9_DMSETGID) == P9_DMSETGID)
  85. res |= S_ISGID;
  86. if ((mode & P9_DMSETVTX) == P9_DMSETVTX)
  87. res |= S_ISVTX;
  88. }
  89. return res;
  90. }
  91. /**
  92. * p9mode2unixmode- convert plan9 mode bits to unix mode bits
  93. * @v9ses: v9fs session information
  94. * @stat: p9_wstat from which mode need to be derived
  95. * @rdev: major number, minor number in case of device files.
  96. *
  97. */
  98. static umode_t p9mode2unixmode(struct v9fs_session_info *v9ses,
  99. struct p9_wstat *stat, dev_t *rdev)
  100. {
  101. int res;
  102. u32 mode = stat->mode;
  103. *rdev = 0;
  104. res = p9mode2perm(v9ses, stat);
  105. if ((mode & P9_DMDIR) == P9_DMDIR)
  106. res |= S_IFDIR;
  107. else if ((mode & P9_DMSYMLINK) && (v9fs_proto_dotu(v9ses)))
  108. res |= S_IFLNK;
  109. else if ((mode & P9_DMSOCKET) && (v9fs_proto_dotu(v9ses))
  110. && (v9ses->nodev == 0))
  111. res |= S_IFSOCK;
  112. else if ((mode & P9_DMNAMEDPIPE) && (v9fs_proto_dotu(v9ses))
  113. && (v9ses->nodev == 0))
  114. res |= S_IFIFO;
  115. else if ((mode & P9_DMDEVICE) && (v9fs_proto_dotu(v9ses))
  116. && (v9ses->nodev == 0)) {
  117. char type = 0, ext[32];
  118. int major = -1, minor = -1;
  119. strlcpy(ext, stat->extension, sizeof(ext));
  120. sscanf(ext, "%c %i %i", &type, &major, &minor);
  121. switch (type) {
  122. case 'c':
  123. res |= S_IFCHR;
  124. break;
  125. case 'b':
  126. res |= S_IFBLK;
  127. break;
  128. default:
  129. p9_debug(P9_DEBUG_ERROR, "Unknown special type %c %s\n",
  130. type, stat->extension);
  131. }
  132. *rdev = MKDEV(major, minor);
  133. } else
  134. res |= S_IFREG;
  135. return res;
  136. }
  137. /**
  138. * v9fs_uflags2omode- convert posix open flags to plan 9 mode bits
  139. * @uflags: flags to convert
  140. * @extended: if .u extensions are active
  141. */
  142. int v9fs_uflags2omode(int uflags, int extended)
  143. {
  144. int ret;
  145. ret = 0;
  146. switch (uflags&3) {
  147. default:
  148. case O_RDONLY:
  149. ret = P9_OREAD;
  150. break;
  151. case O_WRONLY:
  152. ret = P9_OWRITE;
  153. break;
  154. case O_RDWR:
  155. ret = P9_ORDWR;
  156. break;
  157. }
  158. if (extended) {
  159. if (uflags & O_EXCL)
  160. ret |= P9_OEXCL;
  161. if (uflags & O_APPEND)
  162. ret |= P9_OAPPEND;
  163. }
  164. return ret;
  165. }
  166. /**
  167. * v9fs_blank_wstat - helper function to setup a 9P stat structure
  168. * @wstat: structure to initialize
  169. *
  170. */
  171. void
  172. v9fs_blank_wstat(struct p9_wstat *wstat)
  173. {
  174. wstat->type = ~0;
  175. wstat->dev = ~0;
  176. wstat->qid.type = ~0;
  177. wstat->qid.version = ~0;
  178. *((long long *)&wstat->qid.path) = ~0;
  179. wstat->mode = ~0;
  180. wstat->atime = ~0;
  181. wstat->mtime = ~0;
  182. wstat->length = ~0;
  183. wstat->name = NULL;
  184. wstat->uid = NULL;
  185. wstat->gid = NULL;
  186. wstat->muid = NULL;
  187. wstat->n_uid = INVALID_UID;
  188. wstat->n_gid = INVALID_GID;
  189. wstat->n_muid = INVALID_UID;
  190. wstat->extension = NULL;
  191. }
  192. /**
  193. * v9fs_alloc_inode - helper function to allocate an inode
  194. *
  195. */
  196. struct inode *v9fs_alloc_inode(struct super_block *sb)
  197. {
  198. struct v9fs_inode *v9inode;
  199. v9inode = kmem_cache_alloc(v9fs_inode_cache, GFP_KERNEL);
  200. if (!v9inode)
  201. return NULL;
  202. #ifdef CONFIG_9P_FSCACHE
  203. v9inode->fscache = NULL;
  204. mutex_init(&v9inode->fscache_lock);
  205. #endif
  206. v9inode->writeback_fid = NULL;
  207. v9inode->cache_validity = 0;
  208. mutex_init(&v9inode->v_mutex);
  209. return &v9inode->vfs_inode;
  210. }
  211. /**
  212. * v9fs_free_inode - destroy an inode
  213. *
  214. */
  215. void v9fs_free_inode(struct inode *inode)
  216. {
  217. kmem_cache_free(v9fs_inode_cache, V9FS_I(inode));
  218. }
  219. int v9fs_init_inode(struct v9fs_session_info *v9ses,
  220. struct inode *inode, umode_t mode, dev_t rdev)
  221. {
  222. int err = 0;
  223. inode_init_owner(inode, NULL, mode);
  224. inode->i_blocks = 0;
  225. inode->i_rdev = rdev;
  226. inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
  227. inode->i_mapping->a_ops = &v9fs_addr_operations;
  228. switch (mode & S_IFMT) {
  229. case S_IFIFO:
  230. case S_IFBLK:
  231. case S_IFCHR:
  232. case S_IFSOCK:
  233. if (v9fs_proto_dotl(v9ses)) {
  234. inode->i_op = &v9fs_file_inode_operations_dotl;
  235. } else if (v9fs_proto_dotu(v9ses)) {
  236. inode->i_op = &v9fs_file_inode_operations;
  237. } else {
  238. p9_debug(P9_DEBUG_ERROR,
  239. "special files without extended mode\n");
  240. err = -EINVAL;
  241. goto error;
  242. }
  243. init_special_inode(inode, inode->i_mode, inode->i_rdev);
  244. break;
  245. case S_IFREG:
  246. if (v9fs_proto_dotl(v9ses)) {
  247. inode->i_op = &v9fs_file_inode_operations_dotl;
  248. if (v9ses->cache == CACHE_LOOSE ||
  249. v9ses->cache == CACHE_FSCACHE)
  250. inode->i_fop =
  251. &v9fs_cached_file_operations_dotl;
  252. else if (v9ses->cache == CACHE_MMAP)
  253. inode->i_fop = &v9fs_mmap_file_operations_dotl;
  254. else
  255. inode->i_fop = &v9fs_file_operations_dotl;
  256. } else {
  257. inode->i_op = &v9fs_file_inode_operations;
  258. if (v9ses->cache == CACHE_LOOSE ||
  259. v9ses->cache == CACHE_FSCACHE)
  260. inode->i_fop =
  261. &v9fs_cached_file_operations;
  262. else if (v9ses->cache == CACHE_MMAP)
  263. inode->i_fop = &v9fs_mmap_file_operations;
  264. else
  265. inode->i_fop = &v9fs_file_operations;
  266. }
  267. break;
  268. case S_IFLNK:
  269. if (!v9fs_proto_dotu(v9ses) && !v9fs_proto_dotl(v9ses)) {
  270. p9_debug(P9_DEBUG_ERROR,
  271. "extended modes used with legacy protocol\n");
  272. err = -EINVAL;
  273. goto error;
  274. }
  275. if (v9fs_proto_dotl(v9ses))
  276. inode->i_op = &v9fs_symlink_inode_operations_dotl;
  277. else
  278. inode->i_op = &v9fs_symlink_inode_operations;
  279. break;
  280. case S_IFDIR:
  281. inc_nlink(inode);
  282. if (v9fs_proto_dotl(v9ses))
  283. inode->i_op = &v9fs_dir_inode_operations_dotl;
  284. else if (v9fs_proto_dotu(v9ses))
  285. inode->i_op = &v9fs_dir_inode_operations_dotu;
  286. else
  287. inode->i_op = &v9fs_dir_inode_operations;
  288. if (v9fs_proto_dotl(v9ses))
  289. inode->i_fop = &v9fs_dir_operations_dotl;
  290. else
  291. inode->i_fop = &v9fs_dir_operations;
  292. break;
  293. default:
  294. p9_debug(P9_DEBUG_ERROR, "BAD mode 0x%hx S_IFMT 0x%x\n",
  295. mode, mode & S_IFMT);
  296. err = -EINVAL;
  297. goto error;
  298. }
  299. error:
  300. return err;
  301. }
  302. /**
  303. * v9fs_get_inode - helper function to setup an inode
  304. * @sb: superblock
  305. * @mode: mode to setup inode with
  306. *
  307. */
  308. struct inode *v9fs_get_inode(struct super_block *sb, umode_t mode, dev_t rdev)
  309. {
  310. int err;
  311. struct inode *inode;
  312. struct v9fs_session_info *v9ses = sb->s_fs_info;
  313. p9_debug(P9_DEBUG_VFS, "super block: %p mode: %ho\n", sb, mode);
  314. inode = new_inode(sb);
  315. if (!inode) {
  316. pr_warn("%s (%d): Problem allocating inode\n",
  317. __func__, task_pid_nr(current));
  318. return ERR_PTR(-ENOMEM);
  319. }
  320. err = v9fs_init_inode(v9ses, inode, mode, rdev);
  321. if (err) {
  322. iput(inode);
  323. return ERR_PTR(err);
  324. }
  325. return inode;
  326. }
  327. /**
  328. * v9fs_clear_inode - release an inode
  329. * @inode: inode to release
  330. *
  331. */
  332. void v9fs_evict_inode(struct inode *inode)
  333. {
  334. struct v9fs_inode *v9inode = V9FS_I(inode);
  335. truncate_inode_pages_final(&inode->i_data);
  336. clear_inode(inode);
  337. filemap_fdatawrite(&inode->i_data);
  338. v9fs_cache_inode_put_cookie(inode);
  339. /* clunk the fid stashed in writeback_fid */
  340. if (v9inode->writeback_fid) {
  341. p9_client_clunk(v9inode->writeback_fid);
  342. v9inode->writeback_fid = NULL;
  343. }
  344. }
  345. static int v9fs_test_inode(struct inode *inode, void *data)
  346. {
  347. int umode;
  348. dev_t rdev;
  349. struct v9fs_inode *v9inode = V9FS_I(inode);
  350. struct p9_wstat *st = (struct p9_wstat *)data;
  351. struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode);
  352. umode = p9mode2unixmode(v9ses, st, &rdev);
  353. /* don't match inode of different type */
  354. if (inode_wrong_type(inode, umode))
  355. return 0;
  356. /* compare qid details */
  357. if (memcmp(&v9inode->qid.version,
  358. &st->qid.version, sizeof(v9inode->qid.version)))
  359. return 0;
  360. if (v9inode->qid.type != st->qid.type)
  361. return 0;
  362. if (v9inode->qid.path != st->qid.path)
  363. return 0;
  364. return 1;
  365. }
  366. static int v9fs_test_new_inode(struct inode *inode, void *data)
  367. {
  368. return 0;
  369. }
  370. static int v9fs_set_inode(struct inode *inode, void *data)
  371. {
  372. struct v9fs_inode *v9inode = V9FS_I(inode);
  373. struct p9_wstat *st = (struct p9_wstat *)data;
  374. memcpy(&v9inode->qid, &st->qid, sizeof(st->qid));
  375. return 0;
  376. }
  377. static struct inode *v9fs_qid_iget(struct super_block *sb,
  378. struct p9_qid *qid,
  379. struct p9_wstat *st,
  380. int new)
  381. {
  382. dev_t rdev;
  383. int retval;
  384. umode_t umode;
  385. unsigned long i_ino;
  386. struct inode *inode;
  387. struct v9fs_session_info *v9ses = sb->s_fs_info;
  388. int (*test)(struct inode *, void *);
  389. if (new)
  390. test = v9fs_test_new_inode;
  391. else
  392. test = v9fs_test_inode;
  393. i_ino = v9fs_qid2ino(qid);
  394. inode = iget5_locked(sb, i_ino, test, v9fs_set_inode, st);
  395. if (!inode)
  396. return ERR_PTR(-ENOMEM);
  397. if (!(inode->i_state & I_NEW))
  398. return inode;
  399. /*
  400. * initialize the inode with the stat info
  401. * FIXME!! we may need support for stale inodes
  402. * later.
  403. */
  404. inode->i_ino = i_ino;
  405. umode = p9mode2unixmode(v9ses, st, &rdev);
  406. retval = v9fs_init_inode(v9ses, inode, umode, rdev);
  407. if (retval)
  408. goto error;
  409. v9fs_stat2inode(st, inode, sb, 0);
  410. v9fs_cache_inode_get_cookie(inode);
  411. unlock_new_inode(inode);
  412. return inode;
  413. error:
  414. iget_failed(inode);
  415. return ERR_PTR(retval);
  416. }
  417. struct inode *
  418. v9fs_inode_from_fid(struct v9fs_session_info *v9ses, struct p9_fid *fid,
  419. struct super_block *sb, int new)
  420. {
  421. struct p9_wstat *st;
  422. struct inode *inode = NULL;
  423. st = p9_client_stat(fid);
  424. if (IS_ERR(st))
  425. return ERR_CAST(st);
  426. inode = v9fs_qid_iget(sb, &st->qid, st, new);
  427. p9stat_free(st);
  428. kfree(st);
  429. return inode;
  430. }
  431. /**
  432. * v9fs_at_to_dotl_flags- convert Linux specific AT flags to
  433. * plan 9 AT flag.
  434. * @flags: flags to convert
  435. */
  436. static int v9fs_at_to_dotl_flags(int flags)
  437. {
  438. int rflags = 0;
  439. if (flags & AT_REMOVEDIR)
  440. rflags |= P9_DOTL_AT_REMOVEDIR;
  441. return rflags;
  442. }
  443. /**
  444. * v9fs_dec_count - helper functon to drop i_nlink.
  445. *
  446. * If a directory had nlink <= 2 (including . and ..), then we should not drop
  447. * the link count, which indicates the underlying exported fs doesn't maintain
  448. * nlink accurately. e.g.
  449. * - overlayfs sets nlink to 1 for merged dir
  450. * - ext4 (with dir_nlink feature enabled) sets nlink to 1 if a dir has more
  451. * than EXT4_LINK_MAX (65000) links.
  452. *
  453. * @inode: inode whose nlink is being dropped
  454. */
  455. static void v9fs_dec_count(struct inode *inode)
  456. {
  457. if (!S_ISDIR(inode->i_mode) || inode->i_nlink > 2)
  458. drop_nlink(inode);
  459. }
  460. /**
  461. * v9fs_remove - helper function to remove files and directories
  462. * @dir: directory inode that is being deleted
  463. * @dentry: dentry that is being deleted
  464. * @flags: removing a directory
  465. *
  466. */
  467. static int v9fs_remove(struct inode *dir, struct dentry *dentry, int flags)
  468. {
  469. struct inode *inode;
  470. int retval = -EOPNOTSUPP;
  471. struct p9_fid *v9fid, *dfid;
  472. struct v9fs_session_info *v9ses;
  473. p9_debug(P9_DEBUG_VFS, "inode: %p dentry: %p rmdir: %x\n",
  474. dir, dentry, flags);
  475. v9ses = v9fs_inode2v9ses(dir);
  476. inode = d_inode(dentry);
  477. dfid = v9fs_parent_fid(dentry);
  478. if (IS_ERR(dfid)) {
  479. retval = PTR_ERR(dfid);
  480. p9_debug(P9_DEBUG_VFS, "fid lookup failed %d\n", retval);
  481. return retval;
  482. }
  483. if (v9fs_proto_dotl(v9ses))
  484. retval = p9_client_unlinkat(dfid, dentry->d_name.name,
  485. v9fs_at_to_dotl_flags(flags));
  486. if (retval == -EOPNOTSUPP) {
  487. /* Try the one based on path */
  488. v9fid = v9fs_fid_clone(dentry);
  489. if (IS_ERR(v9fid))
  490. return PTR_ERR(v9fid);
  491. retval = p9_client_remove(v9fid);
  492. }
  493. if (!retval) {
  494. /*
  495. * directories on unlink should have zero
  496. * link count
  497. */
  498. if (flags & AT_REMOVEDIR) {
  499. clear_nlink(inode);
  500. v9fs_dec_count(dir);
  501. } else
  502. v9fs_dec_count(inode);
  503. v9fs_invalidate_inode_attr(inode);
  504. v9fs_invalidate_inode_attr(dir);
  505. }
  506. return retval;
  507. }
  508. /**
  509. * v9fs_create - Create a file
  510. * @v9ses: session information
  511. * @dir: directory that dentry is being created in
  512. * @dentry: dentry that is being created
  513. * @extension: 9p2000.u extension string to support devices, etc.
  514. * @perm: create permissions
  515. * @mode: open mode
  516. *
  517. */
  518. static struct p9_fid *
  519. v9fs_create(struct v9fs_session_info *v9ses, struct inode *dir,
  520. struct dentry *dentry, char *extension, u32 perm, u8 mode)
  521. {
  522. int err;
  523. const unsigned char *name;
  524. struct p9_fid *dfid, *ofid, *fid;
  525. struct inode *inode;
  526. p9_debug(P9_DEBUG_VFS, "name %pd\n", dentry);
  527. err = 0;
  528. ofid = NULL;
  529. fid = NULL;
  530. name = dentry->d_name.name;
  531. dfid = v9fs_parent_fid(dentry);
  532. if (IS_ERR(dfid)) {
  533. err = PTR_ERR(dfid);
  534. p9_debug(P9_DEBUG_VFS, "fid lookup failed %d\n", err);
  535. return ERR_PTR(err);
  536. }
  537. /* clone a fid to use for creation */
  538. ofid = clone_fid(dfid);
  539. if (IS_ERR(ofid)) {
  540. err = PTR_ERR(ofid);
  541. p9_debug(P9_DEBUG_VFS, "p9_client_walk failed %d\n", err);
  542. return ERR_PTR(err);
  543. }
  544. err = p9_client_fcreate(ofid, name, perm, mode, extension);
  545. if (err < 0) {
  546. p9_debug(P9_DEBUG_VFS, "p9_client_fcreate failed %d\n", err);
  547. goto error;
  548. }
  549. if (!(perm & P9_DMLINK)) {
  550. /* now walk from the parent so we can get unopened fid */
  551. fid = p9_client_walk(dfid, 1, &name, 1);
  552. if (IS_ERR(fid)) {
  553. err = PTR_ERR(fid);
  554. p9_debug(P9_DEBUG_VFS,
  555. "p9_client_walk failed %d\n", err);
  556. fid = NULL;
  557. goto error;
  558. }
  559. /*
  560. * instantiate inode and assign the unopened fid to the dentry
  561. */
  562. inode = v9fs_get_new_inode_from_fid(v9ses, fid, dir->i_sb);
  563. if (IS_ERR(inode)) {
  564. err = PTR_ERR(inode);
  565. p9_debug(P9_DEBUG_VFS,
  566. "inode creation failed %d\n", err);
  567. goto error;
  568. }
  569. v9fs_fid_add(dentry, fid);
  570. d_instantiate(dentry, inode);
  571. }
  572. return ofid;
  573. error:
  574. if (ofid)
  575. p9_client_clunk(ofid);
  576. if (fid)
  577. p9_client_clunk(fid);
  578. return ERR_PTR(err);
  579. }
  580. /**
  581. * v9fs_vfs_create - VFS hook to create a regular file
  582. *
  583. * open(.., O_CREAT) is handled in v9fs_vfs_atomic_open(). This is only called
  584. * for mknod(2).
  585. *
  586. * @dir: directory inode that is being created
  587. * @dentry: dentry that is being deleted
  588. * @mode: create permissions
  589. *
  590. */
  591. static int
  592. v9fs_vfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
  593. bool excl)
  594. {
  595. struct v9fs_session_info *v9ses = v9fs_inode2v9ses(dir);
  596. u32 perm = unixmode2p9mode(v9ses, mode);
  597. struct p9_fid *fid;
  598. /* P9_OEXCL? */
  599. fid = v9fs_create(v9ses, dir, dentry, NULL, perm, P9_ORDWR);
  600. if (IS_ERR(fid))
  601. return PTR_ERR(fid);
  602. v9fs_invalidate_inode_attr(dir);
  603. p9_client_clunk(fid);
  604. return 0;
  605. }
  606. /**
  607. * v9fs_vfs_mkdir - VFS mkdir hook to create a directory
  608. * @dir: inode that is being unlinked
  609. * @dentry: dentry that is being unlinked
  610. * @mode: mode for new directory
  611. *
  612. */
  613. static int v9fs_vfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
  614. {
  615. int err;
  616. u32 perm;
  617. struct p9_fid *fid;
  618. struct v9fs_session_info *v9ses;
  619. p9_debug(P9_DEBUG_VFS, "name %pd\n", dentry);
  620. err = 0;
  621. v9ses = v9fs_inode2v9ses(dir);
  622. perm = unixmode2p9mode(v9ses, mode | S_IFDIR);
  623. fid = v9fs_create(v9ses, dir, dentry, NULL, perm, P9_OREAD);
  624. if (IS_ERR(fid)) {
  625. err = PTR_ERR(fid);
  626. fid = NULL;
  627. } else {
  628. inc_nlink(dir);
  629. v9fs_invalidate_inode_attr(dir);
  630. }
  631. if (fid)
  632. p9_client_clunk(fid);
  633. return err;
  634. }
  635. /**
  636. * v9fs_vfs_lookup - VFS lookup hook to "walk" to a new inode
  637. * @dir: inode that is being walked from
  638. * @dentry: dentry that is being walked to?
  639. * @flags: lookup flags (unused)
  640. *
  641. */
  642. struct dentry *v9fs_vfs_lookup(struct inode *dir, struct dentry *dentry,
  643. unsigned int flags)
  644. {
  645. struct dentry *res;
  646. struct v9fs_session_info *v9ses;
  647. struct p9_fid *dfid, *fid;
  648. struct inode *inode;
  649. const unsigned char *name;
  650. p9_debug(P9_DEBUG_VFS, "dir: %p dentry: (%pd) %p flags: %x\n",
  651. dir, dentry, dentry, flags);
  652. if (dentry->d_name.len > NAME_MAX)
  653. return ERR_PTR(-ENAMETOOLONG);
  654. v9ses = v9fs_inode2v9ses(dir);
  655. /* We can walk d_parent because we hold the dir->i_mutex */
  656. dfid = v9fs_parent_fid(dentry);
  657. if (IS_ERR(dfid))
  658. return ERR_CAST(dfid);
  659. /*
  660. * Make sure we don't use a wrong inode due to parallel
  661. * unlink. For cached mode create calls request for new
  662. * inode. But with cache disabled, lookup should do this.
  663. */
  664. name = dentry->d_name.name;
  665. fid = p9_client_walk(dfid, 1, &name, 1);
  666. if (fid == ERR_PTR(-ENOENT))
  667. inode = NULL;
  668. else if (IS_ERR(fid))
  669. inode = ERR_CAST(fid);
  670. else if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE)
  671. inode = v9fs_get_inode_from_fid(v9ses, fid, dir->i_sb);
  672. else
  673. inode = v9fs_get_new_inode_from_fid(v9ses, fid, dir->i_sb);
  674. /*
  675. * If we had a rename on the server and a parallel lookup
  676. * for the new name, then make sure we instantiate with
  677. * the new name. ie look up for a/b, while on server somebody
  678. * moved b under k and client parallely did a lookup for
  679. * k/b.
  680. */
  681. res = d_splice_alias(inode, dentry);
  682. if (!IS_ERR(fid)) {
  683. if (!res)
  684. v9fs_fid_add(dentry, fid);
  685. else if (!IS_ERR(res))
  686. v9fs_fid_add(res, fid);
  687. else
  688. p9_client_clunk(fid);
  689. }
  690. return res;
  691. }
  692. static int
  693. v9fs_vfs_atomic_open(struct inode *dir, struct dentry *dentry,
  694. struct file *file, unsigned flags, umode_t mode)
  695. {
  696. int err;
  697. u32 perm;
  698. struct v9fs_inode *v9inode;
  699. struct v9fs_session_info *v9ses;
  700. struct p9_fid *fid, *inode_fid;
  701. struct dentry *res = NULL;
  702. if (d_in_lookup(dentry)) {
  703. res = v9fs_vfs_lookup(dir, dentry, 0);
  704. if (IS_ERR(res))
  705. return PTR_ERR(res);
  706. if (res)
  707. dentry = res;
  708. }
  709. /* Only creates */
  710. if (!(flags & O_CREAT) || d_really_is_positive(dentry))
  711. return finish_no_open(file, res);
  712. err = 0;
  713. v9ses = v9fs_inode2v9ses(dir);
  714. perm = unixmode2p9mode(v9ses, mode);
  715. fid = v9fs_create(v9ses, dir, dentry, NULL, perm,
  716. v9fs_uflags2omode(flags,
  717. v9fs_proto_dotu(v9ses)));
  718. if (IS_ERR(fid)) {
  719. err = PTR_ERR(fid);
  720. fid = NULL;
  721. goto error;
  722. }
  723. v9fs_invalidate_inode_attr(dir);
  724. v9inode = V9FS_I(d_inode(dentry));
  725. mutex_lock(&v9inode->v_mutex);
  726. if ((v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) &&
  727. !v9inode->writeback_fid &&
  728. ((flags & O_ACCMODE) != O_RDONLY)) {
  729. /*
  730. * clone a fid and add it to writeback_fid
  731. * we do it during open time instead of
  732. * page dirty time via write_begin/page_mkwrite
  733. * because we want write after unlink usecase
  734. * to work.
  735. */
  736. inode_fid = v9fs_writeback_fid(dentry);
  737. if (IS_ERR(inode_fid)) {
  738. err = PTR_ERR(inode_fid);
  739. mutex_unlock(&v9inode->v_mutex);
  740. goto error;
  741. }
  742. v9inode->writeback_fid = (void *) inode_fid;
  743. }
  744. mutex_unlock(&v9inode->v_mutex);
  745. err = finish_open(file, dentry, generic_file_open);
  746. if (err)
  747. goto error;
  748. file->private_data = fid;
  749. if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE)
  750. v9fs_cache_inode_set_cookie(d_inode(dentry), file);
  751. file->f_mode |= FMODE_CREATED;
  752. out:
  753. dput(res);
  754. return err;
  755. error:
  756. if (fid)
  757. p9_client_clunk(fid);
  758. goto out;
  759. }
  760. /**
  761. * v9fs_vfs_unlink - VFS unlink hook to delete an inode
  762. * @i: inode that is being unlinked
  763. * @d: dentry that is being unlinked
  764. *
  765. */
  766. int v9fs_vfs_unlink(struct inode *i, struct dentry *d)
  767. {
  768. return v9fs_remove(i, d, 0);
  769. }
  770. /**
  771. * v9fs_vfs_rmdir - VFS unlink hook to delete a directory
  772. * @i: inode that is being unlinked
  773. * @d: dentry that is being unlinked
  774. *
  775. */
  776. int v9fs_vfs_rmdir(struct inode *i, struct dentry *d)
  777. {
  778. return v9fs_remove(i, d, AT_REMOVEDIR);
  779. }
  780. /**
  781. * v9fs_vfs_rename - VFS hook to rename an inode
  782. * @old_dir: old dir inode
  783. * @old_dentry: old dentry
  784. * @new_dir: new dir inode
  785. * @new_dentry: new dentry
  786. *
  787. */
  788. int
  789. v9fs_vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
  790. struct inode *new_dir, struct dentry *new_dentry,
  791. unsigned int flags)
  792. {
  793. int retval;
  794. struct inode *old_inode;
  795. struct inode *new_inode;
  796. struct v9fs_session_info *v9ses;
  797. struct p9_fid *oldfid;
  798. struct p9_fid *olddirfid;
  799. struct p9_fid *newdirfid;
  800. struct p9_wstat wstat;
  801. if (flags)
  802. return -EINVAL;
  803. p9_debug(P9_DEBUG_VFS, "\n");
  804. retval = 0;
  805. old_inode = d_inode(old_dentry);
  806. new_inode = d_inode(new_dentry);
  807. v9ses = v9fs_inode2v9ses(old_inode);
  808. oldfid = v9fs_fid_lookup(old_dentry);
  809. if (IS_ERR(oldfid))
  810. return PTR_ERR(oldfid);
  811. olddirfid = clone_fid(v9fs_parent_fid(old_dentry));
  812. if (IS_ERR(olddirfid)) {
  813. retval = PTR_ERR(olddirfid);
  814. goto done;
  815. }
  816. newdirfid = clone_fid(v9fs_parent_fid(new_dentry));
  817. if (IS_ERR(newdirfid)) {
  818. retval = PTR_ERR(newdirfid);
  819. goto clunk_olddir;
  820. }
  821. down_write(&v9ses->rename_sem);
  822. if (v9fs_proto_dotl(v9ses)) {
  823. retval = p9_client_renameat(olddirfid, old_dentry->d_name.name,
  824. newdirfid, new_dentry->d_name.name);
  825. if (retval == -EOPNOTSUPP)
  826. retval = p9_client_rename(oldfid, newdirfid,
  827. new_dentry->d_name.name);
  828. if (retval != -EOPNOTSUPP)
  829. goto clunk_newdir;
  830. }
  831. if (old_dentry->d_parent != new_dentry->d_parent) {
  832. /*
  833. * 9P .u can only handle file rename in the same directory
  834. */
  835. p9_debug(P9_DEBUG_ERROR, "old dir and new dir are different\n");
  836. retval = -EXDEV;
  837. goto clunk_newdir;
  838. }
  839. v9fs_blank_wstat(&wstat);
  840. wstat.muid = v9ses->uname;
  841. wstat.name = new_dentry->d_name.name;
  842. retval = p9_client_wstat(oldfid, &wstat);
  843. clunk_newdir:
  844. if (!retval) {
  845. if (new_inode) {
  846. if (S_ISDIR(new_inode->i_mode))
  847. clear_nlink(new_inode);
  848. else
  849. v9fs_dec_count(new_inode);
  850. }
  851. if (S_ISDIR(old_inode->i_mode)) {
  852. if (!new_inode)
  853. inc_nlink(new_dir);
  854. v9fs_dec_count(old_dir);
  855. }
  856. v9fs_invalidate_inode_attr(old_inode);
  857. v9fs_invalidate_inode_attr(old_dir);
  858. v9fs_invalidate_inode_attr(new_dir);
  859. /* successful rename */
  860. d_move(old_dentry, new_dentry);
  861. }
  862. up_write(&v9ses->rename_sem);
  863. p9_client_clunk(newdirfid);
  864. clunk_olddir:
  865. p9_client_clunk(olddirfid);
  866. done:
  867. return retval;
  868. }
  869. /**
  870. * v9fs_vfs_getattr - retrieve file metadata
  871. * @path: Object to query
  872. * @stat: metadata structure to populate
  873. * @request_mask: Mask of STATX_xxx flags indicating the caller's interests
  874. * @flags: AT_STATX_xxx setting
  875. *
  876. */
  877. static int
  878. v9fs_vfs_getattr(const struct path *path, struct kstat *stat,
  879. u32 request_mask, unsigned int flags)
  880. {
  881. struct dentry *dentry = path->dentry;
  882. struct v9fs_session_info *v9ses;
  883. struct p9_fid *fid;
  884. struct p9_wstat *st;
  885. p9_debug(P9_DEBUG_VFS, "dentry: %p\n", dentry);
  886. v9ses = v9fs_dentry2v9ses(dentry);
  887. if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) {
  888. generic_fillattr(d_inode(dentry), stat);
  889. return 0;
  890. }
  891. fid = v9fs_fid_lookup(dentry);
  892. if (IS_ERR(fid))
  893. return PTR_ERR(fid);
  894. st = p9_client_stat(fid);
  895. if (IS_ERR(st))
  896. return PTR_ERR(st);
  897. v9fs_stat2inode(st, d_inode(dentry), dentry->d_sb, 0);
  898. generic_fillattr(d_inode(dentry), stat);
  899. p9stat_free(st);
  900. kfree(st);
  901. return 0;
  902. }
  903. /**
  904. * v9fs_vfs_setattr - set file metadata
  905. * @dentry: file whose metadata to set
  906. * @iattr: metadata assignment structure
  907. *
  908. */
  909. static int v9fs_vfs_setattr(struct dentry *dentry, struct iattr *iattr)
  910. {
  911. int retval;
  912. struct v9fs_session_info *v9ses;
  913. struct p9_fid *fid = NULL;
  914. struct p9_wstat wstat;
  915. p9_debug(P9_DEBUG_VFS, "\n");
  916. retval = setattr_prepare(dentry, iattr);
  917. if (retval)
  918. return retval;
  919. retval = -EPERM;
  920. v9ses = v9fs_dentry2v9ses(dentry);
  921. if (iattr->ia_valid & ATTR_FILE) {
  922. fid = iattr->ia_file->private_data;
  923. WARN_ON(!fid);
  924. }
  925. if (!fid)
  926. fid = v9fs_fid_lookup(dentry);
  927. if(IS_ERR(fid))
  928. return PTR_ERR(fid);
  929. v9fs_blank_wstat(&wstat);
  930. if (iattr->ia_valid & ATTR_MODE)
  931. wstat.mode = unixmode2p9mode(v9ses, iattr->ia_mode);
  932. if (iattr->ia_valid & ATTR_MTIME)
  933. wstat.mtime = iattr->ia_mtime.tv_sec;
  934. if (iattr->ia_valid & ATTR_ATIME)
  935. wstat.atime = iattr->ia_atime.tv_sec;
  936. if (iattr->ia_valid & ATTR_SIZE)
  937. wstat.length = iattr->ia_size;
  938. if (v9fs_proto_dotu(v9ses)) {
  939. if (iattr->ia_valid & ATTR_UID)
  940. wstat.n_uid = iattr->ia_uid;
  941. if (iattr->ia_valid & ATTR_GID)
  942. wstat.n_gid = iattr->ia_gid;
  943. }
  944. /* Write all dirty data */
  945. if (d_is_reg(dentry))
  946. filemap_write_and_wait(d_inode(dentry)->i_mapping);
  947. retval = p9_client_wstat(fid, &wstat);
  948. if (retval < 0)
  949. return retval;
  950. if ((iattr->ia_valid & ATTR_SIZE) &&
  951. iattr->ia_size != i_size_read(d_inode(dentry)))
  952. truncate_setsize(d_inode(dentry), iattr->ia_size);
  953. v9fs_invalidate_inode_attr(d_inode(dentry));
  954. setattr_copy(d_inode(dentry), iattr);
  955. mark_inode_dirty(d_inode(dentry));
  956. return 0;
  957. }
  958. /**
  959. * v9fs_stat2inode - populate an inode structure with mistat info
  960. * @stat: Plan 9 metadata (mistat) structure
  961. * @inode: inode to populate
  962. * @sb: superblock of filesystem
  963. * @flags: control flags (e.g. V9FS_STAT2INODE_KEEP_ISIZE)
  964. *
  965. */
  966. void
  967. v9fs_stat2inode(struct p9_wstat *stat, struct inode *inode,
  968. struct super_block *sb, unsigned int flags)
  969. {
  970. umode_t mode;
  971. char ext[32];
  972. char tag_name[14];
  973. unsigned int i_nlink;
  974. struct v9fs_session_info *v9ses = sb->s_fs_info;
  975. struct v9fs_inode *v9inode = V9FS_I(inode);
  976. set_nlink(inode, 1);
  977. inode->i_atime.tv_sec = stat->atime;
  978. inode->i_mtime.tv_sec = stat->mtime;
  979. inode->i_ctime.tv_sec = stat->mtime;
  980. inode->i_uid = v9ses->dfltuid;
  981. inode->i_gid = v9ses->dfltgid;
  982. if (v9fs_proto_dotu(v9ses)) {
  983. inode->i_uid = stat->n_uid;
  984. inode->i_gid = stat->n_gid;
  985. }
  986. if ((S_ISREG(inode->i_mode)) || (S_ISDIR(inode->i_mode))) {
  987. if (v9fs_proto_dotu(v9ses) && (stat->extension[0] != '\0')) {
  988. /*
  989. * Hadlink support got added later to
  990. * to the .u extension. So there can be
  991. * server out there that doesn't support
  992. * this even with .u extension. So check
  993. * for non NULL stat->extension
  994. */
  995. strlcpy(ext, stat->extension, sizeof(ext));
  996. /* HARDLINKCOUNT %u */
  997. sscanf(ext, "%13s %u", tag_name, &i_nlink);
  998. if (!strncmp(tag_name, "HARDLINKCOUNT", 13))
  999. set_nlink(inode, i_nlink);
  1000. }
  1001. }
  1002. mode = p9mode2perm(v9ses, stat);
  1003. mode |= inode->i_mode & ~S_IALLUGO;
  1004. inode->i_mode = mode;
  1005. if (!(flags & V9FS_STAT2INODE_KEEP_ISIZE))
  1006. v9fs_i_size_write(inode, stat->length);
  1007. /* not real number of blocks, but 512 byte ones ... */
  1008. inode->i_blocks = (stat->length + 512 - 1) >> 9;
  1009. v9inode->cache_validity &= ~V9FS_INO_INVALID_ATTR;
  1010. }
  1011. /**
  1012. * v9fs_qid2ino - convert qid into inode number
  1013. * @qid: qid to hash
  1014. *
  1015. * BUG: potential for inode number collisions?
  1016. */
  1017. ino_t v9fs_qid2ino(struct p9_qid *qid)
  1018. {
  1019. u64 path = qid->path + 2;
  1020. ino_t i = 0;
  1021. if (sizeof(ino_t) == sizeof(path))
  1022. memcpy(&i, &path, sizeof(ino_t));
  1023. else
  1024. i = (ino_t) (path ^ (path >> 32));
  1025. return i;
  1026. }
  1027. /**
  1028. * v9fs_vfs_get_link - follow a symlink path
  1029. * @dentry: dentry for symlink
  1030. * @inode: inode for symlink
  1031. * @done: delayed call for when we are done with the return value
  1032. */
  1033. static const char *v9fs_vfs_get_link(struct dentry *dentry,
  1034. struct inode *inode,
  1035. struct delayed_call *done)
  1036. {
  1037. struct v9fs_session_info *v9ses;
  1038. struct p9_fid *fid;
  1039. struct p9_wstat *st;
  1040. char *res;
  1041. if (!dentry)
  1042. return ERR_PTR(-ECHILD);
  1043. v9ses = v9fs_dentry2v9ses(dentry);
  1044. fid = v9fs_fid_lookup(dentry);
  1045. p9_debug(P9_DEBUG_VFS, "%pd\n", dentry);
  1046. if (IS_ERR(fid))
  1047. return ERR_CAST(fid);
  1048. if (!v9fs_proto_dotu(v9ses))
  1049. return ERR_PTR(-EBADF);
  1050. st = p9_client_stat(fid);
  1051. if (IS_ERR(st))
  1052. return ERR_CAST(st);
  1053. if (!(st->mode & P9_DMSYMLINK)) {
  1054. p9stat_free(st);
  1055. kfree(st);
  1056. return ERR_PTR(-EINVAL);
  1057. }
  1058. res = st->extension;
  1059. st->extension = NULL;
  1060. if (strlen(res) >= PATH_MAX)
  1061. res[PATH_MAX - 1] = '\0';
  1062. p9stat_free(st);
  1063. kfree(st);
  1064. set_delayed_call(done, kfree_link, res);
  1065. return res;
  1066. }
  1067. /**
  1068. * v9fs_vfs_mkspecial - create a special file
  1069. * @dir: inode to create special file in
  1070. * @dentry: dentry to create
  1071. * @perm: mode to create special file
  1072. * @extension: 9p2000.u format extension string representing special file
  1073. *
  1074. */
  1075. static int v9fs_vfs_mkspecial(struct inode *dir, struct dentry *dentry,
  1076. u32 perm, const char *extension)
  1077. {
  1078. struct p9_fid *fid;
  1079. struct v9fs_session_info *v9ses;
  1080. v9ses = v9fs_inode2v9ses(dir);
  1081. if (!v9fs_proto_dotu(v9ses)) {
  1082. p9_debug(P9_DEBUG_ERROR, "not extended\n");
  1083. return -EPERM;
  1084. }
  1085. fid = v9fs_create(v9ses, dir, dentry, (char *) extension, perm,
  1086. P9_OREAD);
  1087. if (IS_ERR(fid))
  1088. return PTR_ERR(fid);
  1089. v9fs_invalidate_inode_attr(dir);
  1090. p9_client_clunk(fid);
  1091. return 0;
  1092. }
  1093. /**
  1094. * v9fs_vfs_symlink - helper function to create symlinks
  1095. * @dir: directory inode containing symlink
  1096. * @dentry: dentry for symlink
  1097. * @symname: symlink data
  1098. *
  1099. * See Also: 9P2000.u RFC for more information
  1100. *
  1101. */
  1102. static int
  1103. v9fs_vfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
  1104. {
  1105. p9_debug(P9_DEBUG_VFS, " %lu,%pd,%s\n",
  1106. dir->i_ino, dentry, symname);
  1107. return v9fs_vfs_mkspecial(dir, dentry, P9_DMSYMLINK, symname);
  1108. }
  1109. #define U32_MAX_DIGITS 10
  1110. /**
  1111. * v9fs_vfs_link - create a hardlink
  1112. * @old_dentry: dentry for file to link to
  1113. * @dir: inode destination for new link
  1114. * @dentry: dentry for link
  1115. *
  1116. */
  1117. static int
  1118. v9fs_vfs_link(struct dentry *old_dentry, struct inode *dir,
  1119. struct dentry *dentry)
  1120. {
  1121. int retval;
  1122. char name[1 + U32_MAX_DIGITS + 2]; /* sign + number + \n + \0 */
  1123. struct p9_fid *oldfid;
  1124. p9_debug(P9_DEBUG_VFS, " %lu,%pd,%pd\n",
  1125. dir->i_ino, dentry, old_dentry);
  1126. oldfid = v9fs_fid_clone(old_dentry);
  1127. if (IS_ERR(oldfid))
  1128. return PTR_ERR(oldfid);
  1129. sprintf(name, "%d\n", oldfid->fid);
  1130. retval = v9fs_vfs_mkspecial(dir, dentry, P9_DMLINK, name);
  1131. if (!retval) {
  1132. v9fs_refresh_inode(oldfid, d_inode(old_dentry));
  1133. v9fs_invalidate_inode_attr(dir);
  1134. }
  1135. p9_client_clunk(oldfid);
  1136. return retval;
  1137. }
  1138. /**
  1139. * v9fs_vfs_mknod - create a special file
  1140. * @dir: inode destination for new link
  1141. * @dentry: dentry for file
  1142. * @mode: mode for creation
  1143. * @rdev: device associated with special file
  1144. *
  1145. */
  1146. static int
  1147. v9fs_vfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t rdev)
  1148. {
  1149. struct v9fs_session_info *v9ses = v9fs_inode2v9ses(dir);
  1150. int retval;
  1151. char name[2 + U32_MAX_DIGITS + 1 + U32_MAX_DIGITS + 1];
  1152. u32 perm;
  1153. p9_debug(P9_DEBUG_VFS, " %lu,%pd mode: %hx MAJOR: %u MINOR: %u\n",
  1154. dir->i_ino, dentry, mode,
  1155. MAJOR(rdev), MINOR(rdev));
  1156. /* build extension */
  1157. if (S_ISBLK(mode))
  1158. sprintf(name, "b %u %u", MAJOR(rdev), MINOR(rdev));
  1159. else if (S_ISCHR(mode))
  1160. sprintf(name, "c %u %u", MAJOR(rdev), MINOR(rdev));
  1161. else
  1162. *name = 0;
  1163. perm = unixmode2p9mode(v9ses, mode);
  1164. retval = v9fs_vfs_mkspecial(dir, dentry, perm, name);
  1165. return retval;
  1166. }
  1167. int v9fs_refresh_inode(struct p9_fid *fid, struct inode *inode)
  1168. {
  1169. int umode;
  1170. dev_t rdev;
  1171. struct p9_wstat *st;
  1172. struct v9fs_session_info *v9ses;
  1173. unsigned int flags;
  1174. v9ses = v9fs_inode2v9ses(inode);
  1175. st = p9_client_stat(fid);
  1176. if (IS_ERR(st))
  1177. return PTR_ERR(st);
  1178. /*
  1179. * Don't update inode if the file type is different
  1180. */
  1181. umode = p9mode2unixmode(v9ses, st, &rdev);
  1182. if (inode_wrong_type(inode, umode))
  1183. goto out;
  1184. /*
  1185. * We don't want to refresh inode->i_size,
  1186. * because we may have cached data
  1187. */
  1188. flags = (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) ?
  1189. V9FS_STAT2INODE_KEEP_ISIZE : 0;
  1190. v9fs_stat2inode(st, inode, inode->i_sb, flags);
  1191. out:
  1192. p9stat_free(st);
  1193. kfree(st);
  1194. return 0;
  1195. }
  1196. static const struct inode_operations v9fs_dir_inode_operations_dotu = {
  1197. .create = v9fs_vfs_create,
  1198. .lookup = v9fs_vfs_lookup,
  1199. .atomic_open = v9fs_vfs_atomic_open,
  1200. .symlink = v9fs_vfs_symlink,
  1201. .link = v9fs_vfs_link,
  1202. .unlink = v9fs_vfs_unlink,
  1203. .mkdir = v9fs_vfs_mkdir,
  1204. .rmdir = v9fs_vfs_rmdir,
  1205. .mknod = v9fs_vfs_mknod,
  1206. .rename = v9fs_vfs_rename,
  1207. .getattr = v9fs_vfs_getattr,
  1208. .setattr = v9fs_vfs_setattr,
  1209. };
  1210. static const struct inode_operations v9fs_dir_inode_operations = {
  1211. .create = v9fs_vfs_create,
  1212. .lookup = v9fs_vfs_lookup,
  1213. .atomic_open = v9fs_vfs_atomic_open,
  1214. .unlink = v9fs_vfs_unlink,
  1215. .mkdir = v9fs_vfs_mkdir,
  1216. .rmdir = v9fs_vfs_rmdir,
  1217. .mknod = v9fs_vfs_mknod,
  1218. .rename = v9fs_vfs_rename,
  1219. .getattr = v9fs_vfs_getattr,
  1220. .setattr = v9fs_vfs_setattr,
  1221. };
  1222. static const struct inode_operations v9fs_file_inode_operations = {
  1223. .getattr = v9fs_vfs_getattr,
  1224. .setattr = v9fs_vfs_setattr,
  1225. };
  1226. static const struct inode_operations v9fs_symlink_inode_operations = {
  1227. .get_link = v9fs_vfs_get_link,
  1228. .getattr = v9fs_vfs_getattr,
  1229. .setattr = v9fs_vfs_setattr,
  1230. };