vfs_inode.c 46 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019
  1. /*
  2. * linux/fs/9p/vfs_inode.c
  3. *
  4. * This file contains vfs inode ops for the 9P2000 protocol.
  5. *
  6. * Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
  7. * Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
  8. *
  9. * This program is free software; you can redistribute it and/or modify
  10. * it under the terms of the GNU General Public License version 2
  11. * as published by the Free Software Foundation.
  12. *
  13. * This program is distributed in the hope that it will be useful,
  14. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16. * GNU General Public License for more details.
  17. *
  18. * You should have received a copy of the GNU General Public License
  19. * along with this program; if not, write to:
  20. * Free Software Foundation
  21. * 51 Franklin Street, Fifth Floor
  22. * Boston, MA 02111-1301 USA
  23. *
  24. */
  25. #include <linux/module.h>
  26. #include <linux/errno.h>
  27. #include <linux/fs.h>
  28. #include <linux/file.h>
  29. #include <linux/pagemap.h>
  30. #include <linux/stat.h>
  31. #include <linux/string.h>
  32. #include <linux/inet.h>
  33. #include <linux/namei.h>
  34. #include <linux/idr.h>
  35. #include <linux/sched.h>
  36. #include <linux/slab.h>
  37. #include <linux/xattr.h>
  38. #include <net/9p/9p.h>
  39. #include <net/9p/client.h>
  40. #include "v9fs.h"
  41. #include "v9fs_vfs.h"
  42. #include "fid.h"
  43. #include "cache.h"
  44. #include "xattr.h"
  45. static const struct inode_operations v9fs_dir_inode_operations;
  46. static const struct inode_operations v9fs_dir_inode_operations_dotu;
  47. static const struct inode_operations v9fs_dir_inode_operations_dotl;
  48. static const struct inode_operations v9fs_file_inode_operations;
  49. static const struct inode_operations v9fs_file_inode_operations_dotl;
  50. static const struct inode_operations v9fs_symlink_inode_operations;
  51. static const struct inode_operations v9fs_symlink_inode_operations_dotl;
  52. /**
  53. * unixmode2p9mode - convert unix mode bits to plan 9
  54. * @v9ses: v9fs session information
  55. * @mode: mode to convert
  56. *
  57. */
  58. static int unixmode2p9mode(struct v9fs_session_info *v9ses, int mode)
  59. {
  60. int res;
  61. res = mode & 0777;
  62. if (S_ISDIR(mode))
  63. res |= P9_DMDIR;
  64. if (v9fs_proto_dotu(v9ses)) {
  65. if (S_ISLNK(mode))
  66. res |= P9_DMSYMLINK;
  67. if (v9ses->nodev == 0) {
  68. if (S_ISSOCK(mode))
  69. res |= P9_DMSOCKET;
  70. if (S_ISFIFO(mode))
  71. res |= P9_DMNAMEDPIPE;
  72. if (S_ISBLK(mode))
  73. res |= P9_DMDEVICE;
  74. if (S_ISCHR(mode))
  75. res |= P9_DMDEVICE;
  76. }
  77. if ((mode & S_ISUID) == S_ISUID)
  78. res |= P9_DMSETUID;
  79. if ((mode & S_ISGID) == S_ISGID)
  80. res |= P9_DMSETGID;
  81. if ((mode & S_ISVTX) == S_ISVTX)
  82. res |= P9_DMSETVTX;
  83. if ((mode & P9_DMLINK))
  84. res |= P9_DMLINK;
  85. }
  86. return res;
  87. }
  88. /**
  89. * p9mode2unixmode- convert plan9 mode bits to unix mode bits
  90. * @v9ses: v9fs session information
  91. * @mode: mode to convert
  92. *
  93. */
  94. static int p9mode2unixmode(struct v9fs_session_info *v9ses, int mode)
  95. {
  96. int res;
  97. res = mode & 0777;
  98. if ((mode & P9_DMDIR) == P9_DMDIR)
  99. res |= S_IFDIR;
  100. else if ((mode & P9_DMSYMLINK) && (v9fs_proto_dotu(v9ses)))
  101. res |= S_IFLNK;
  102. else if ((mode & P9_DMSOCKET) && (v9fs_proto_dotu(v9ses))
  103. && (v9ses->nodev == 0))
  104. res |= S_IFSOCK;
  105. else if ((mode & P9_DMNAMEDPIPE) && (v9fs_proto_dotu(v9ses))
  106. && (v9ses->nodev == 0))
  107. res |= S_IFIFO;
  108. else if ((mode & P9_DMDEVICE) && (v9fs_proto_dotu(v9ses))
  109. && (v9ses->nodev == 0))
  110. res |= S_IFBLK;
  111. else
  112. res |= S_IFREG;
  113. if (v9fs_proto_dotu(v9ses)) {
  114. if ((mode & P9_DMSETUID) == P9_DMSETUID)
  115. res |= S_ISUID;
  116. if ((mode & P9_DMSETGID) == P9_DMSETGID)
  117. res |= S_ISGID;
  118. if ((mode & P9_DMSETVTX) == P9_DMSETVTX)
  119. res |= S_ISVTX;
  120. }
  121. return res;
  122. }
  123. /**
  124. * v9fs_uflags2omode- convert posix open flags to plan 9 mode bits
  125. * @uflags: flags to convert
  126. * @extended: if .u extensions are active
  127. */
  128. int v9fs_uflags2omode(int uflags, int extended)
  129. {
  130. int ret;
  131. ret = 0;
  132. switch (uflags&3) {
  133. default:
  134. case O_RDONLY:
  135. ret = P9_OREAD;
  136. break;
  137. case O_WRONLY:
  138. ret = P9_OWRITE;
  139. break;
  140. case O_RDWR:
  141. ret = P9_ORDWR;
  142. break;
  143. }
  144. if (uflags & O_TRUNC)
  145. ret |= P9_OTRUNC;
  146. if (extended) {
  147. if (uflags & O_EXCL)
  148. ret |= P9_OEXCL;
  149. if (uflags & O_APPEND)
  150. ret |= P9_OAPPEND;
  151. }
  152. return ret;
  153. }
  154. /**
  155. * v9fs_blank_wstat - helper function to setup a 9P stat structure
  156. * @wstat: structure to initialize
  157. *
  158. */
  159. void
  160. v9fs_blank_wstat(struct p9_wstat *wstat)
  161. {
  162. wstat->type = ~0;
  163. wstat->dev = ~0;
  164. wstat->qid.type = ~0;
  165. wstat->qid.version = ~0;
  166. *((long long *)&wstat->qid.path) = ~0;
  167. wstat->mode = ~0;
  168. wstat->atime = ~0;
  169. wstat->mtime = ~0;
  170. wstat->length = ~0;
  171. wstat->name = NULL;
  172. wstat->uid = NULL;
  173. wstat->gid = NULL;
  174. wstat->muid = NULL;
  175. wstat->n_uid = ~0;
  176. wstat->n_gid = ~0;
  177. wstat->n_muid = ~0;
  178. wstat->extension = NULL;
  179. }
  180. #ifdef CONFIG_9P_FSCACHE
  181. /**
  182. * v9fs_alloc_inode - helper function to allocate an inode
  183. * This callback is executed before setting up the inode so that we
  184. * can associate a vcookie with each inode.
  185. *
  186. */
  187. struct inode *v9fs_alloc_inode(struct super_block *sb)
  188. {
  189. struct v9fs_cookie *vcookie;
  190. vcookie = (struct v9fs_cookie *)kmem_cache_alloc(vcookie_cache,
  191. GFP_KERNEL);
  192. if (!vcookie)
  193. return NULL;
  194. vcookie->fscache = NULL;
  195. vcookie->qid = NULL;
  196. spin_lock_init(&vcookie->lock);
  197. return &vcookie->inode;
  198. }
  199. /**
  200. * v9fs_destroy_inode - destroy an inode
  201. *
  202. */
  203. void v9fs_destroy_inode(struct inode *inode)
  204. {
  205. kmem_cache_free(vcookie_cache, v9fs_inode2cookie(inode));
  206. }
  207. #endif
  208. /**
  209. * v9fs_get_fsgid_for_create - Helper function to get the gid for creating a
  210. * new file system object. This checks the S_ISGID to determine the owning
  211. * group of the new file system object.
  212. */
  213. static gid_t v9fs_get_fsgid_for_create(struct inode *dir_inode)
  214. {
  215. BUG_ON(dir_inode == NULL);
  216. if (dir_inode->i_mode & S_ISGID) {
  217. /* set_gid bit is set.*/
  218. return dir_inode->i_gid;
  219. }
  220. return current_fsgid();
  221. }
  222. /**
  223. * v9fs_dentry_from_dir_inode - helper function to get the dentry from
  224. * dir inode.
  225. *
  226. */
  227. static struct dentry *v9fs_dentry_from_dir_inode(struct inode *inode)
  228. {
  229. struct dentry *dentry;
  230. spin_lock(&dcache_lock);
  231. /* Directory should have only one entry. */
  232. BUG_ON(S_ISDIR(inode->i_mode) && !list_is_singular(&inode->i_dentry));
  233. dentry = list_entry(inode->i_dentry.next, struct dentry, d_alias);
  234. spin_unlock(&dcache_lock);
  235. return dentry;
  236. }
  237. /**
  238. * v9fs_get_inode - helper function to setup an inode
  239. * @sb: superblock
  240. * @mode: mode to setup inode with
  241. *
  242. */
  243. struct inode *v9fs_get_inode(struct super_block *sb, int mode)
  244. {
  245. int err;
  246. struct inode *inode;
  247. struct v9fs_session_info *v9ses = sb->s_fs_info;
  248. P9_DPRINTK(P9_DEBUG_VFS, "super block: %p mode: %o\n", sb, mode);
  249. inode = new_inode(sb);
  250. if (!inode) {
  251. P9_EPRINTK(KERN_WARNING, "Problem allocating inode\n");
  252. return ERR_PTR(-ENOMEM);
  253. }
  254. inode_init_owner(inode, NULL, mode);
  255. inode->i_blocks = 0;
  256. inode->i_rdev = 0;
  257. inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
  258. inode->i_mapping->a_ops = &v9fs_addr_operations;
  259. switch (mode & S_IFMT) {
  260. case S_IFIFO:
  261. case S_IFBLK:
  262. case S_IFCHR:
  263. case S_IFSOCK:
  264. if (v9fs_proto_dotl(v9ses)) {
  265. inode->i_op = &v9fs_file_inode_operations_dotl;
  266. inode->i_fop = &v9fs_file_operations_dotl;
  267. } else if (v9fs_proto_dotu(v9ses)) {
  268. inode->i_op = &v9fs_file_inode_operations;
  269. inode->i_fop = &v9fs_file_operations;
  270. } else {
  271. P9_DPRINTK(P9_DEBUG_ERROR,
  272. "special files without extended mode\n");
  273. err = -EINVAL;
  274. goto error;
  275. }
  276. init_special_inode(inode, inode->i_mode, inode->i_rdev);
  277. break;
  278. case S_IFREG:
  279. if (v9fs_proto_dotl(v9ses)) {
  280. inode->i_op = &v9fs_file_inode_operations_dotl;
  281. inode->i_fop = &v9fs_file_operations_dotl;
  282. } else {
  283. inode->i_op = &v9fs_file_inode_operations;
  284. inode->i_fop = &v9fs_file_operations;
  285. }
  286. break;
  287. case S_IFLNK:
  288. if (!v9fs_proto_dotu(v9ses) && !v9fs_proto_dotl(v9ses)) {
  289. P9_DPRINTK(P9_DEBUG_ERROR, "extended modes used with "
  290. "legacy protocol.\n");
  291. err = -EINVAL;
  292. goto error;
  293. }
  294. if (v9fs_proto_dotl(v9ses))
  295. inode->i_op = &v9fs_symlink_inode_operations_dotl;
  296. else
  297. inode->i_op = &v9fs_symlink_inode_operations;
  298. break;
  299. case S_IFDIR:
  300. inc_nlink(inode);
  301. if (v9fs_proto_dotl(v9ses))
  302. inode->i_op = &v9fs_dir_inode_operations_dotl;
  303. else if (v9fs_proto_dotu(v9ses))
  304. inode->i_op = &v9fs_dir_inode_operations_dotu;
  305. else
  306. inode->i_op = &v9fs_dir_inode_operations;
  307. if (v9fs_proto_dotl(v9ses))
  308. inode->i_fop = &v9fs_dir_operations_dotl;
  309. else
  310. inode->i_fop = &v9fs_dir_operations;
  311. break;
  312. default:
  313. P9_DPRINTK(P9_DEBUG_ERROR, "BAD mode 0x%x S_IFMT 0x%x\n",
  314. mode, mode & S_IFMT);
  315. err = -EINVAL;
  316. goto error;
  317. }
  318. return inode;
  319. error:
  320. iput(inode);
  321. return ERR_PTR(err);
  322. }
  323. /*
  324. static struct v9fs_fid*
  325. v9fs_clone_walk(struct v9fs_session_info *v9ses, u32 fid, struct dentry *dentry)
  326. {
  327. int err;
  328. int nfid;
  329. struct v9fs_fid *ret;
  330. struct v9fs_fcall *fcall;
  331. nfid = v9fs_get_idpool(&v9ses->fidpool);
  332. if (nfid < 0) {
  333. eprintk(KERN_WARNING, "no free fids available\n");
  334. return ERR_PTR(-ENOSPC);
  335. }
  336. err = v9fs_t_walk(v9ses, fid, nfid, (char *) dentry->d_name.name,
  337. &fcall);
  338. if (err < 0) {
  339. if (fcall && fcall->id == RWALK)
  340. goto clunk_fid;
  341. PRINT_FCALL_ERROR("walk error", fcall);
  342. v9fs_put_idpool(nfid, &v9ses->fidpool);
  343. goto error;
  344. }
  345. kfree(fcall);
  346. fcall = NULL;
  347. ret = v9fs_fid_create(v9ses, nfid);
  348. if (!ret) {
  349. err = -ENOMEM;
  350. goto clunk_fid;
  351. }
  352. err = v9fs_fid_insert(ret, dentry);
  353. if (err < 0) {
  354. v9fs_fid_destroy(ret);
  355. goto clunk_fid;
  356. }
  357. return ret;
  358. clunk_fid:
  359. v9fs_t_clunk(v9ses, nfid);
  360. error:
  361. kfree(fcall);
  362. return ERR_PTR(err);
  363. }
  364. */
  365. /**
  366. * v9fs_clear_inode - release an inode
  367. * @inode: inode to release
  368. *
  369. */
  370. void v9fs_evict_inode(struct inode *inode)
  371. {
  372. truncate_inode_pages(inode->i_mapping, 0);
  373. end_writeback(inode);
  374. filemap_fdatawrite(inode->i_mapping);
  375. #ifdef CONFIG_9P_FSCACHE
  376. v9fs_cache_inode_put_cookie(inode);
  377. #endif
  378. }
  379. static struct inode *
  380. v9fs_inode(struct v9fs_session_info *v9ses, struct p9_fid *fid,
  381. struct super_block *sb)
  382. {
  383. int err, umode;
  384. struct inode *ret = NULL;
  385. struct p9_wstat *st;
  386. st = p9_client_stat(fid);
  387. if (IS_ERR(st))
  388. return ERR_CAST(st);
  389. umode = p9mode2unixmode(v9ses, st->mode);
  390. ret = v9fs_get_inode(sb, umode);
  391. if (IS_ERR(ret)) {
  392. err = PTR_ERR(ret);
  393. goto error;
  394. }
  395. v9fs_stat2inode(st, ret, sb);
  396. ret->i_ino = v9fs_qid2ino(&st->qid);
  397. #ifdef CONFIG_9P_FSCACHE
  398. v9fs_vcookie_set_qid(ret, &st->qid);
  399. v9fs_cache_inode_get_cookie(ret);
  400. #endif
  401. p9stat_free(st);
  402. kfree(st);
  403. return ret;
  404. error:
  405. p9stat_free(st);
  406. kfree(st);
  407. return ERR_PTR(err);
  408. }
  409. static struct inode *
  410. v9fs_inode_dotl(struct v9fs_session_info *v9ses, struct p9_fid *fid,
  411. struct super_block *sb)
  412. {
  413. struct inode *ret = NULL;
  414. int err;
  415. struct p9_stat_dotl *st;
  416. st = p9_client_getattr_dotl(fid, P9_STATS_BASIC);
  417. if (IS_ERR(st))
  418. return ERR_CAST(st);
  419. ret = v9fs_get_inode(sb, st->st_mode);
  420. if (IS_ERR(ret)) {
  421. err = PTR_ERR(ret);
  422. goto error;
  423. }
  424. v9fs_stat2inode_dotl(st, ret);
  425. ret->i_ino = v9fs_qid2ino(&st->qid);
  426. #ifdef CONFIG_9P_FSCACHE
  427. v9fs_vcookie_set_qid(ret, &st->qid);
  428. v9fs_cache_inode_get_cookie(ret);
  429. #endif
  430. kfree(st);
  431. return ret;
  432. error:
  433. kfree(st);
  434. return ERR_PTR(err);
  435. }
  436. /**
  437. * v9fs_inode_from_fid - Helper routine to populate an inode by
  438. * issuing a attribute request
  439. * @v9ses: session information
  440. * @fid: fid to issue attribute request for
  441. * @sb: superblock on which to create inode
  442. *
  443. */
  444. static inline struct inode *
  445. v9fs_inode_from_fid(struct v9fs_session_info *v9ses, struct p9_fid *fid,
  446. struct super_block *sb)
  447. {
  448. if (v9fs_proto_dotl(v9ses))
  449. return v9fs_inode_dotl(v9ses, fid, sb);
  450. else
  451. return v9fs_inode(v9ses, fid, sb);
  452. }
  453. /**
  454. * v9fs_remove - helper function to remove files and directories
  455. * @dir: directory inode that is being deleted
  456. * @file: dentry that is being deleted
  457. * @rmdir: removing a directory
  458. *
  459. */
  460. static int v9fs_remove(struct inode *dir, struct dentry *file, int rmdir)
  461. {
  462. int retval;
  463. struct inode *file_inode;
  464. struct p9_fid *v9fid;
  465. P9_DPRINTK(P9_DEBUG_VFS, "inode: %p dentry: %p rmdir: %d\n", dir, file,
  466. rmdir);
  467. file_inode = file->d_inode;
  468. v9fid = v9fs_fid_clone(file);
  469. if (IS_ERR(v9fid))
  470. return PTR_ERR(v9fid);
  471. retval = p9_client_remove(v9fid);
  472. if (!retval)
  473. drop_nlink(file_inode);
  474. return retval;
  475. }
  476. static int
  477. v9fs_open_created(struct inode *inode, struct file *file)
  478. {
  479. return 0;
  480. }
  481. /**
  482. * v9fs_create - Create a file
  483. * @v9ses: session information
  484. * @dir: directory that dentry is being created in
  485. * @dentry: dentry that is being created
  486. * @extension: 9p2000.u extension string to support devices, etc.
  487. * @perm: create permissions
  488. * @mode: open mode
  489. *
  490. */
  491. static struct p9_fid *
  492. v9fs_create(struct v9fs_session_info *v9ses, struct inode *dir,
  493. struct dentry *dentry, char *extension, u32 perm, u8 mode)
  494. {
  495. int err;
  496. char *name;
  497. struct p9_fid *dfid, *ofid, *fid;
  498. struct inode *inode;
  499. P9_DPRINTK(P9_DEBUG_VFS, "name %s\n", dentry->d_name.name);
  500. err = 0;
  501. ofid = NULL;
  502. fid = NULL;
  503. name = (char *) dentry->d_name.name;
  504. dfid = v9fs_fid_lookup(dentry->d_parent);
  505. if (IS_ERR(dfid)) {
  506. err = PTR_ERR(dfid);
  507. P9_DPRINTK(P9_DEBUG_VFS, "fid lookup failed %d\n", err);
  508. return ERR_PTR(err);
  509. }
  510. /* clone a fid to use for creation */
  511. ofid = p9_client_walk(dfid, 0, NULL, 1);
  512. if (IS_ERR(ofid)) {
  513. err = PTR_ERR(ofid);
  514. P9_DPRINTK(P9_DEBUG_VFS, "p9_client_walk failed %d\n", err);
  515. return ERR_PTR(err);
  516. }
  517. err = p9_client_fcreate(ofid, name, perm, mode, extension);
  518. if (err < 0) {
  519. P9_DPRINTK(P9_DEBUG_VFS, "p9_client_fcreate failed %d\n", err);
  520. goto error;
  521. }
  522. /* now walk from the parent so we can get unopened fid */
  523. fid = p9_client_walk(dfid, 1, &name, 1);
  524. if (IS_ERR(fid)) {
  525. err = PTR_ERR(fid);
  526. P9_DPRINTK(P9_DEBUG_VFS, "p9_client_walk failed %d\n", err);
  527. fid = NULL;
  528. goto error;
  529. }
  530. /* instantiate inode and assign the unopened fid to the dentry */
  531. inode = v9fs_inode_from_fid(v9ses, fid, dir->i_sb);
  532. if (IS_ERR(inode)) {
  533. err = PTR_ERR(inode);
  534. P9_DPRINTK(P9_DEBUG_VFS, "inode creation failed %d\n", err);
  535. goto error;
  536. }
  537. if (v9ses->cache)
  538. dentry->d_op = &v9fs_cached_dentry_operations;
  539. else
  540. dentry->d_op = &v9fs_dentry_operations;
  541. d_instantiate(dentry, inode);
  542. err = v9fs_fid_add(dentry, fid);
  543. if (err < 0)
  544. goto error;
  545. return ofid;
  546. error:
  547. if (ofid)
  548. p9_client_clunk(ofid);
  549. if (fid)
  550. p9_client_clunk(fid);
  551. return ERR_PTR(err);
  552. }
  553. /**
  554. * v9fs_vfs_create_dotl - VFS hook to create files for 9P2000.L protocol.
  555. * @dir: directory inode that is being created
  556. * @dentry: dentry that is being deleted
  557. * @mode: create permissions
  558. * @nd: path information
  559. *
  560. */
  561. static int
  562. v9fs_vfs_create_dotl(struct inode *dir, struct dentry *dentry, int mode,
  563. struct nameidata *nd)
  564. {
  565. int err = 0;
  566. char *name = NULL;
  567. gid_t gid;
  568. int flags;
  569. struct v9fs_session_info *v9ses;
  570. struct p9_fid *fid = NULL;
  571. struct p9_fid *dfid, *ofid;
  572. struct file *filp;
  573. struct p9_qid qid;
  574. struct inode *inode;
  575. v9ses = v9fs_inode2v9ses(dir);
  576. if (nd && nd->flags & LOOKUP_OPEN)
  577. flags = nd->intent.open.flags - 1;
  578. else
  579. flags = O_RDWR;
  580. name = (char *) dentry->d_name.name;
  581. P9_DPRINTK(P9_DEBUG_VFS, "v9fs_vfs_create_dotl: name:%s flags:0x%x "
  582. "mode:0x%x\n", name, flags, mode);
  583. dfid = v9fs_fid_lookup(dentry->d_parent);
  584. if (IS_ERR(dfid)) {
  585. err = PTR_ERR(dfid);
  586. P9_DPRINTK(P9_DEBUG_VFS, "fid lookup failed %d\n", err);
  587. return err;
  588. }
  589. /* clone a fid to use for creation */
  590. ofid = p9_client_walk(dfid, 0, NULL, 1);
  591. if (IS_ERR(ofid)) {
  592. err = PTR_ERR(ofid);
  593. P9_DPRINTK(P9_DEBUG_VFS, "p9_client_walk failed %d\n", err);
  594. return err;
  595. }
  596. gid = v9fs_get_fsgid_for_create(dir);
  597. err = p9_client_create_dotl(ofid, name, flags, mode, gid, &qid);
  598. if (err < 0) {
  599. P9_DPRINTK(P9_DEBUG_VFS,
  600. "p9_client_open_dotl failed in creat %d\n",
  601. err);
  602. goto error;
  603. }
  604. /* No need to populate the inode if we are not opening the file AND
  605. * not in cached mode.
  606. */
  607. if (!v9ses->cache && !(nd && nd->flags & LOOKUP_OPEN)) {
  608. /* Not in cached mode. No need to populate inode with stat */
  609. dentry->d_op = &v9fs_dentry_operations;
  610. p9_client_clunk(ofid);
  611. d_instantiate(dentry, NULL);
  612. return 0;
  613. }
  614. /* Now walk from the parent so we can get an unopened fid. */
  615. fid = p9_client_walk(dfid, 1, &name, 1);
  616. if (IS_ERR(fid)) {
  617. err = PTR_ERR(fid);
  618. P9_DPRINTK(P9_DEBUG_VFS, "p9_client_walk failed %d\n", err);
  619. fid = NULL;
  620. goto error;
  621. }
  622. /* instantiate inode and assign the unopened fid to dentry */
  623. inode = v9fs_inode_from_fid(v9ses, fid, dir->i_sb);
  624. if (IS_ERR(inode)) {
  625. err = PTR_ERR(inode);
  626. P9_DPRINTK(P9_DEBUG_VFS, "inode creation failed %d\n", err);
  627. goto error;
  628. }
  629. if (v9ses->cache)
  630. dentry->d_op = &v9fs_cached_dentry_operations;
  631. else
  632. dentry->d_op = &v9fs_dentry_operations;
  633. d_instantiate(dentry, inode);
  634. err = v9fs_fid_add(dentry, fid);
  635. if (err < 0)
  636. goto error;
  637. /* if we are opening a file, assign the open fid to the file */
  638. if (nd && nd->flags & LOOKUP_OPEN) {
  639. filp = lookup_instantiate_filp(nd, dentry, v9fs_open_created);
  640. if (IS_ERR(filp)) {
  641. p9_client_clunk(ofid);
  642. return PTR_ERR(filp);
  643. }
  644. filp->private_data = ofid;
  645. } else
  646. p9_client_clunk(ofid);
  647. return 0;
  648. error:
  649. if (ofid)
  650. p9_client_clunk(ofid);
  651. if (fid)
  652. p9_client_clunk(fid);
  653. return err;
  654. }
  655. /**
  656. * v9fs_vfs_create - VFS hook to create files
  657. * @dir: directory inode that is being created
  658. * @dentry: dentry that is being deleted
  659. * @mode: create permissions
  660. * @nd: path information
  661. *
  662. */
  663. static int
  664. v9fs_vfs_create(struct inode *dir, struct dentry *dentry, int mode,
  665. struct nameidata *nd)
  666. {
  667. int err;
  668. u32 perm;
  669. int flags;
  670. struct v9fs_session_info *v9ses;
  671. struct p9_fid *fid;
  672. struct file *filp;
  673. err = 0;
  674. fid = NULL;
  675. v9ses = v9fs_inode2v9ses(dir);
  676. perm = unixmode2p9mode(v9ses, mode);
  677. if (nd && nd->flags & LOOKUP_OPEN)
  678. flags = nd->intent.open.flags - 1;
  679. else
  680. flags = O_RDWR;
  681. fid = v9fs_create(v9ses, dir, dentry, NULL, perm,
  682. v9fs_uflags2omode(flags,
  683. v9fs_proto_dotu(v9ses)));
  684. if (IS_ERR(fid)) {
  685. err = PTR_ERR(fid);
  686. fid = NULL;
  687. goto error;
  688. }
  689. /* if we are opening a file, assign the open fid to the file */
  690. if (nd && nd->flags & LOOKUP_OPEN) {
  691. filp = lookup_instantiate_filp(nd, dentry, v9fs_open_created);
  692. if (IS_ERR(filp)) {
  693. err = PTR_ERR(filp);
  694. goto error;
  695. }
  696. filp->private_data = fid;
  697. } else
  698. p9_client_clunk(fid);
  699. return 0;
  700. error:
  701. if (fid)
  702. p9_client_clunk(fid);
  703. return err;
  704. }
  705. /**
  706. * v9fs_vfs_mkdir - VFS mkdir hook to create a directory
  707. * @dir: inode that is being unlinked
  708. * @dentry: dentry that is being unlinked
  709. * @mode: mode for new directory
  710. *
  711. */
  712. static int v9fs_vfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
  713. {
  714. int err;
  715. u32 perm;
  716. struct v9fs_session_info *v9ses;
  717. struct p9_fid *fid;
  718. P9_DPRINTK(P9_DEBUG_VFS, "name %s\n", dentry->d_name.name);
  719. err = 0;
  720. v9ses = v9fs_inode2v9ses(dir);
  721. perm = unixmode2p9mode(v9ses, mode | S_IFDIR);
  722. fid = v9fs_create(v9ses, dir, dentry, NULL, perm, P9_OREAD);
  723. if (IS_ERR(fid)) {
  724. err = PTR_ERR(fid);
  725. fid = NULL;
  726. }
  727. if (fid)
  728. p9_client_clunk(fid);
  729. return err;
  730. }
  731. /**
  732. * v9fs_vfs_mkdir_dotl - VFS mkdir hook to create a directory
  733. * @dir: inode that is being unlinked
  734. * @dentry: dentry that is being unlinked
  735. * @mode: mode for new directory
  736. *
  737. */
  738. static int v9fs_vfs_mkdir_dotl(struct inode *dir, struct dentry *dentry,
  739. int mode)
  740. {
  741. int err;
  742. struct v9fs_session_info *v9ses;
  743. struct p9_fid *fid = NULL, *dfid = NULL;
  744. gid_t gid;
  745. char *name;
  746. struct inode *inode;
  747. struct p9_qid qid;
  748. struct dentry *dir_dentry;
  749. P9_DPRINTK(P9_DEBUG_VFS, "name %s\n", dentry->d_name.name);
  750. err = 0;
  751. v9ses = v9fs_inode2v9ses(dir);
  752. mode |= S_IFDIR;
  753. dir_dentry = v9fs_dentry_from_dir_inode(dir);
  754. dfid = v9fs_fid_lookup(dir_dentry);
  755. if (IS_ERR(dfid)) {
  756. err = PTR_ERR(dfid);
  757. P9_DPRINTK(P9_DEBUG_VFS, "fid lookup failed %d\n", err);
  758. dfid = NULL;
  759. goto error;
  760. }
  761. gid = v9fs_get_fsgid_for_create(dir);
  762. if (gid < 0) {
  763. P9_DPRINTK(P9_DEBUG_VFS, "v9fs_get_fsgid_for_create failed\n");
  764. goto error;
  765. }
  766. name = (char *) dentry->d_name.name;
  767. err = p9_client_mkdir_dotl(dfid, name, mode, gid, &qid);
  768. if (err < 0)
  769. goto error;
  770. /* instantiate inode and assign the unopened fid to the dentry */
  771. if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) {
  772. fid = p9_client_walk(dfid, 1, &name, 1);
  773. if (IS_ERR(fid)) {
  774. err = PTR_ERR(fid);
  775. P9_DPRINTK(P9_DEBUG_VFS, "p9_client_walk failed %d\n",
  776. err);
  777. fid = NULL;
  778. goto error;
  779. }
  780. inode = v9fs_inode_from_fid(v9ses, fid, dir->i_sb);
  781. if (IS_ERR(inode)) {
  782. err = PTR_ERR(inode);
  783. P9_DPRINTK(P9_DEBUG_VFS, "inode creation failed %d\n",
  784. err);
  785. goto error;
  786. }
  787. dentry->d_op = &v9fs_cached_dentry_operations;
  788. d_instantiate(dentry, inode);
  789. err = v9fs_fid_add(dentry, fid);
  790. if (err < 0)
  791. goto error;
  792. fid = NULL;
  793. }
  794. error:
  795. if (fid)
  796. p9_client_clunk(fid);
  797. return err;
  798. }
  799. /**
  800. * v9fs_vfs_lookup - VFS lookup hook to "walk" to a new inode
  801. * @dir: inode that is being walked from
  802. * @dentry: dentry that is being walked to?
  803. * @nameidata: path data
  804. *
  805. */
  806. static struct dentry *v9fs_vfs_lookup(struct inode *dir, struct dentry *dentry,
  807. struct nameidata *nameidata)
  808. {
  809. struct super_block *sb;
  810. struct v9fs_session_info *v9ses;
  811. struct p9_fid *dfid, *fid;
  812. struct inode *inode;
  813. char *name;
  814. int result = 0;
  815. P9_DPRINTK(P9_DEBUG_VFS, "dir: %p dentry: (%s) %p nameidata: %p\n",
  816. dir, dentry->d_name.name, dentry, nameidata);
  817. if (dentry->d_name.len > NAME_MAX)
  818. return ERR_PTR(-ENAMETOOLONG);
  819. sb = dir->i_sb;
  820. v9ses = v9fs_inode2v9ses(dir);
  821. /* We can walk d_parent because we hold the dir->i_mutex */
  822. dfid = v9fs_fid_lookup(dentry->d_parent);
  823. if (IS_ERR(dfid))
  824. return ERR_CAST(dfid);
  825. name = (char *) dentry->d_name.name;
  826. fid = p9_client_walk(dfid, 1, &name, 1);
  827. if (IS_ERR(fid)) {
  828. result = PTR_ERR(fid);
  829. if (result == -ENOENT) {
  830. inode = NULL;
  831. goto inst_out;
  832. }
  833. return ERR_PTR(result);
  834. }
  835. inode = v9fs_inode_from_fid(v9ses, fid, dir->i_sb);
  836. if (IS_ERR(inode)) {
  837. result = PTR_ERR(inode);
  838. inode = NULL;
  839. goto error;
  840. }
  841. result = v9fs_fid_add(dentry, fid);
  842. if (result < 0)
  843. goto error;
  844. inst_out:
  845. if (v9ses->cache)
  846. dentry->d_op = &v9fs_cached_dentry_operations;
  847. else
  848. dentry->d_op = &v9fs_dentry_operations;
  849. d_add(dentry, inode);
  850. return NULL;
  851. error:
  852. p9_client_clunk(fid);
  853. return ERR_PTR(result);
  854. }
  855. /**
  856. * v9fs_vfs_unlink - VFS unlink hook to delete an inode
  857. * @i: inode that is being unlinked
  858. * @d: dentry that is being unlinked
  859. *
  860. */
  861. static int v9fs_vfs_unlink(struct inode *i, struct dentry *d)
  862. {
  863. return v9fs_remove(i, d, 0);
  864. }
  865. /**
  866. * v9fs_vfs_rmdir - VFS unlink hook to delete a directory
  867. * @i: inode that is being unlinked
  868. * @d: dentry that is being unlinked
  869. *
  870. */
  871. static int v9fs_vfs_rmdir(struct inode *i, struct dentry *d)
  872. {
  873. return v9fs_remove(i, d, 1);
  874. }
  875. /**
  876. * v9fs_vfs_rename - VFS hook to rename an inode
  877. * @old_dir: old dir inode
  878. * @old_dentry: old dentry
  879. * @new_dir: new dir inode
  880. * @new_dentry: new dentry
  881. *
  882. */
  883. static int
  884. v9fs_vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
  885. struct inode *new_dir, struct dentry *new_dentry)
  886. {
  887. struct inode *old_inode;
  888. struct v9fs_session_info *v9ses;
  889. struct p9_fid *oldfid;
  890. struct p9_fid *olddirfid;
  891. struct p9_fid *newdirfid;
  892. struct p9_wstat wstat;
  893. int retval;
  894. P9_DPRINTK(P9_DEBUG_VFS, "\n");
  895. retval = 0;
  896. old_inode = old_dentry->d_inode;
  897. v9ses = v9fs_inode2v9ses(old_inode);
  898. oldfid = v9fs_fid_lookup(old_dentry);
  899. if (IS_ERR(oldfid))
  900. return PTR_ERR(oldfid);
  901. olddirfid = v9fs_fid_clone(old_dentry->d_parent);
  902. if (IS_ERR(olddirfid)) {
  903. retval = PTR_ERR(olddirfid);
  904. goto done;
  905. }
  906. newdirfid = v9fs_fid_clone(new_dentry->d_parent);
  907. if (IS_ERR(newdirfid)) {
  908. retval = PTR_ERR(newdirfid);
  909. goto clunk_olddir;
  910. }
  911. down_write(&v9ses->rename_sem);
  912. if (v9fs_proto_dotl(v9ses)) {
  913. retval = p9_client_rename(oldfid, newdirfid,
  914. (char *) new_dentry->d_name.name);
  915. if (retval != -ENOSYS)
  916. goto clunk_newdir;
  917. }
  918. if (old_dentry->d_parent != new_dentry->d_parent) {
  919. /*
  920. * 9P .u can only handle file rename in the same directory
  921. */
  922. P9_DPRINTK(P9_DEBUG_ERROR,
  923. "old dir and new dir are different\n");
  924. retval = -EXDEV;
  925. goto clunk_newdir;
  926. }
  927. v9fs_blank_wstat(&wstat);
  928. wstat.muid = v9ses->uname;
  929. wstat.name = (char *) new_dentry->d_name.name;
  930. retval = p9_client_wstat(oldfid, &wstat);
  931. clunk_newdir:
  932. if (!retval)
  933. /* successful rename */
  934. d_move(old_dentry, new_dentry);
  935. up_write(&v9ses->rename_sem);
  936. p9_client_clunk(newdirfid);
  937. clunk_olddir:
  938. p9_client_clunk(olddirfid);
  939. done:
  940. return retval;
  941. }
  942. /**
  943. * v9fs_vfs_getattr - retrieve file metadata
  944. * @mnt: mount information
  945. * @dentry: file to get attributes on
  946. * @stat: metadata structure to populate
  947. *
  948. */
  949. static int
  950. v9fs_vfs_getattr(struct vfsmount *mnt, struct dentry *dentry,
  951. struct kstat *stat)
  952. {
  953. int err;
  954. struct v9fs_session_info *v9ses;
  955. struct p9_fid *fid;
  956. struct p9_wstat *st;
  957. P9_DPRINTK(P9_DEBUG_VFS, "dentry: %p\n", dentry);
  958. err = -EPERM;
  959. v9ses = v9fs_inode2v9ses(dentry->d_inode);
  960. if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE)
  961. return simple_getattr(mnt, dentry, stat);
  962. fid = v9fs_fid_lookup(dentry);
  963. if (IS_ERR(fid))
  964. return PTR_ERR(fid);
  965. st = p9_client_stat(fid);
  966. if (IS_ERR(st))
  967. return PTR_ERR(st);
  968. v9fs_stat2inode(st, dentry->d_inode, dentry->d_inode->i_sb);
  969. generic_fillattr(dentry->d_inode, stat);
  970. p9stat_free(st);
  971. kfree(st);
  972. return 0;
  973. }
  974. static int
  975. v9fs_vfs_getattr_dotl(struct vfsmount *mnt, struct dentry *dentry,
  976. struct kstat *stat)
  977. {
  978. int err;
  979. struct v9fs_session_info *v9ses;
  980. struct p9_fid *fid;
  981. struct p9_stat_dotl *st;
  982. P9_DPRINTK(P9_DEBUG_VFS, "dentry: %p\n", dentry);
  983. err = -EPERM;
  984. v9ses = v9fs_inode2v9ses(dentry->d_inode);
  985. if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE)
  986. return simple_getattr(mnt, dentry, stat);
  987. fid = v9fs_fid_lookup(dentry);
  988. if (IS_ERR(fid))
  989. return PTR_ERR(fid);
  990. /* Ask for all the fields in stat structure. Server will return
  991. * whatever it supports
  992. */
  993. st = p9_client_getattr_dotl(fid, P9_STATS_ALL);
  994. if (IS_ERR(st))
  995. return PTR_ERR(st);
  996. v9fs_stat2inode_dotl(st, dentry->d_inode);
  997. generic_fillattr(dentry->d_inode, stat);
  998. /* Change block size to what the server returned */
  999. stat->blksize = st->st_blksize;
  1000. kfree(st);
  1001. return 0;
  1002. }
  1003. /**
  1004. * v9fs_vfs_setattr - set file metadata
  1005. * @dentry: file whose metadata to set
  1006. * @iattr: metadata assignment structure
  1007. *
  1008. */
  1009. static int v9fs_vfs_setattr(struct dentry *dentry, struct iattr *iattr)
  1010. {
  1011. int retval;
  1012. struct v9fs_session_info *v9ses;
  1013. struct p9_fid *fid;
  1014. struct p9_wstat wstat;
  1015. P9_DPRINTK(P9_DEBUG_VFS, "\n");
  1016. retval = -EPERM;
  1017. v9ses = v9fs_inode2v9ses(dentry->d_inode);
  1018. fid = v9fs_fid_lookup(dentry);
  1019. if(IS_ERR(fid))
  1020. return PTR_ERR(fid);
  1021. v9fs_blank_wstat(&wstat);
  1022. if (iattr->ia_valid & ATTR_MODE)
  1023. wstat.mode = unixmode2p9mode(v9ses, iattr->ia_mode);
  1024. if (iattr->ia_valid & ATTR_MTIME)
  1025. wstat.mtime = iattr->ia_mtime.tv_sec;
  1026. if (iattr->ia_valid & ATTR_ATIME)
  1027. wstat.atime = iattr->ia_atime.tv_sec;
  1028. if (iattr->ia_valid & ATTR_SIZE)
  1029. wstat.length = iattr->ia_size;
  1030. if (v9fs_proto_dotu(v9ses)) {
  1031. if (iattr->ia_valid & ATTR_UID)
  1032. wstat.n_uid = iattr->ia_uid;
  1033. if (iattr->ia_valid & ATTR_GID)
  1034. wstat.n_gid = iattr->ia_gid;
  1035. }
  1036. retval = p9_client_wstat(fid, &wstat);
  1037. if (retval < 0)
  1038. return retval;
  1039. if ((iattr->ia_valid & ATTR_SIZE) &&
  1040. iattr->ia_size != i_size_read(dentry->d_inode)) {
  1041. retval = vmtruncate(dentry->d_inode, iattr->ia_size);
  1042. if (retval)
  1043. return retval;
  1044. }
  1045. setattr_copy(dentry->d_inode, iattr);
  1046. mark_inode_dirty(dentry->d_inode);
  1047. return 0;
  1048. }
  1049. /**
  1050. * v9fs_vfs_setattr_dotl - set file metadata
  1051. * @dentry: file whose metadata to set
  1052. * @iattr: metadata assignment structure
  1053. *
  1054. */
  1055. static int v9fs_vfs_setattr_dotl(struct dentry *dentry, struct iattr *iattr)
  1056. {
  1057. int retval;
  1058. struct v9fs_session_info *v9ses;
  1059. struct p9_fid *fid;
  1060. struct p9_iattr_dotl p9attr;
  1061. P9_DPRINTK(P9_DEBUG_VFS, "\n");
  1062. retval = inode_change_ok(dentry->d_inode, iattr);
  1063. if (retval)
  1064. return retval;
  1065. p9attr.valid = iattr->ia_valid;
  1066. p9attr.mode = iattr->ia_mode;
  1067. p9attr.uid = iattr->ia_uid;
  1068. p9attr.gid = iattr->ia_gid;
  1069. p9attr.size = iattr->ia_size;
  1070. p9attr.atime_sec = iattr->ia_atime.tv_sec;
  1071. p9attr.atime_nsec = iattr->ia_atime.tv_nsec;
  1072. p9attr.mtime_sec = iattr->ia_mtime.tv_sec;
  1073. p9attr.mtime_nsec = iattr->ia_mtime.tv_nsec;
  1074. retval = -EPERM;
  1075. v9ses = v9fs_inode2v9ses(dentry->d_inode);
  1076. fid = v9fs_fid_lookup(dentry);
  1077. if (IS_ERR(fid))
  1078. return PTR_ERR(fid);
  1079. retval = p9_client_setattr(fid, &p9attr);
  1080. if (retval < 0)
  1081. return retval;
  1082. if ((iattr->ia_valid & ATTR_SIZE) &&
  1083. iattr->ia_size != i_size_read(dentry->d_inode)) {
  1084. retval = vmtruncate(dentry->d_inode, iattr->ia_size);
  1085. if (retval)
  1086. return retval;
  1087. }
  1088. setattr_copy(dentry->d_inode, iattr);
  1089. mark_inode_dirty(dentry->d_inode);
  1090. return 0;
  1091. }
  1092. /**
  1093. * v9fs_stat2inode - populate an inode structure with mistat info
  1094. * @stat: Plan 9 metadata (mistat) structure
  1095. * @inode: inode to populate
  1096. * @sb: superblock of filesystem
  1097. *
  1098. */
  1099. void
  1100. v9fs_stat2inode(struct p9_wstat *stat, struct inode *inode,
  1101. struct super_block *sb)
  1102. {
  1103. char ext[32];
  1104. char tag_name[14];
  1105. unsigned int i_nlink;
  1106. struct v9fs_session_info *v9ses = sb->s_fs_info;
  1107. inode->i_nlink = 1;
  1108. inode->i_atime.tv_sec = stat->atime;
  1109. inode->i_mtime.tv_sec = stat->mtime;
  1110. inode->i_ctime.tv_sec = stat->mtime;
  1111. inode->i_uid = v9ses->dfltuid;
  1112. inode->i_gid = v9ses->dfltgid;
  1113. if (v9fs_proto_dotu(v9ses)) {
  1114. inode->i_uid = stat->n_uid;
  1115. inode->i_gid = stat->n_gid;
  1116. }
  1117. if ((S_ISREG(inode->i_mode)) || (S_ISDIR(inode->i_mode))) {
  1118. if (v9fs_proto_dotu(v9ses) && (stat->extension[0] != '\0')) {
  1119. /*
  1120. * Hadlink support got added later to
  1121. * to the .u extension. So there can be
  1122. * server out there that doesn't support
  1123. * this even with .u extension. So check
  1124. * for non NULL stat->extension
  1125. */
  1126. strncpy(ext, stat->extension, sizeof(ext));
  1127. /* HARDLINKCOUNT %u */
  1128. sscanf(ext, "%13s %u", tag_name, &i_nlink);
  1129. if (!strncmp(tag_name, "HARDLINKCOUNT", 13))
  1130. inode->i_nlink = i_nlink;
  1131. }
  1132. }
  1133. inode->i_mode = p9mode2unixmode(v9ses, stat->mode);
  1134. if ((S_ISBLK(inode->i_mode)) || (S_ISCHR(inode->i_mode))) {
  1135. char type = 0;
  1136. int major = -1;
  1137. int minor = -1;
  1138. strncpy(ext, stat->extension, sizeof(ext));
  1139. sscanf(ext, "%c %u %u", &type, &major, &minor);
  1140. switch (type) {
  1141. case 'c':
  1142. inode->i_mode &= ~S_IFBLK;
  1143. inode->i_mode |= S_IFCHR;
  1144. break;
  1145. case 'b':
  1146. break;
  1147. default:
  1148. P9_DPRINTK(P9_DEBUG_ERROR,
  1149. "Unknown special type %c %s\n", type,
  1150. stat->extension);
  1151. };
  1152. inode->i_rdev = MKDEV(major, minor);
  1153. init_special_inode(inode, inode->i_mode, inode->i_rdev);
  1154. } else
  1155. inode->i_rdev = 0;
  1156. i_size_write(inode, stat->length);
  1157. /* not real number of blocks, but 512 byte ones ... */
  1158. inode->i_blocks = (i_size_read(inode) + 512 - 1) >> 9;
  1159. }
  1160. /**
  1161. * v9fs_stat2inode_dotl - populate an inode structure with stat info
  1162. * @stat: stat structure
  1163. * @inode: inode to populate
  1164. * @sb: superblock of filesystem
  1165. *
  1166. */
  1167. void
  1168. v9fs_stat2inode_dotl(struct p9_stat_dotl *stat, struct inode *inode)
  1169. {
  1170. if ((stat->st_result_mask & P9_STATS_BASIC) == P9_STATS_BASIC) {
  1171. inode->i_atime.tv_sec = stat->st_atime_sec;
  1172. inode->i_atime.tv_nsec = stat->st_atime_nsec;
  1173. inode->i_mtime.tv_sec = stat->st_mtime_sec;
  1174. inode->i_mtime.tv_nsec = stat->st_mtime_nsec;
  1175. inode->i_ctime.tv_sec = stat->st_ctime_sec;
  1176. inode->i_ctime.tv_nsec = stat->st_ctime_nsec;
  1177. inode->i_uid = stat->st_uid;
  1178. inode->i_gid = stat->st_gid;
  1179. inode->i_nlink = stat->st_nlink;
  1180. inode->i_mode = stat->st_mode;
  1181. inode->i_rdev = new_decode_dev(stat->st_rdev);
  1182. if ((S_ISBLK(inode->i_mode)) || (S_ISCHR(inode->i_mode)))
  1183. init_special_inode(inode, inode->i_mode, inode->i_rdev);
  1184. i_size_write(inode, stat->st_size);
  1185. inode->i_blocks = stat->st_blocks;
  1186. } else {
  1187. if (stat->st_result_mask & P9_STATS_ATIME) {
  1188. inode->i_atime.tv_sec = stat->st_atime_sec;
  1189. inode->i_atime.tv_nsec = stat->st_atime_nsec;
  1190. }
  1191. if (stat->st_result_mask & P9_STATS_MTIME) {
  1192. inode->i_mtime.tv_sec = stat->st_mtime_sec;
  1193. inode->i_mtime.tv_nsec = stat->st_mtime_nsec;
  1194. }
  1195. if (stat->st_result_mask & P9_STATS_CTIME) {
  1196. inode->i_ctime.tv_sec = stat->st_ctime_sec;
  1197. inode->i_ctime.tv_nsec = stat->st_ctime_nsec;
  1198. }
  1199. if (stat->st_result_mask & P9_STATS_UID)
  1200. inode->i_uid = stat->st_uid;
  1201. if (stat->st_result_mask & P9_STATS_GID)
  1202. inode->i_gid = stat->st_gid;
  1203. if (stat->st_result_mask & P9_STATS_NLINK)
  1204. inode->i_nlink = stat->st_nlink;
  1205. if (stat->st_result_mask & P9_STATS_MODE) {
  1206. inode->i_mode = stat->st_mode;
  1207. if ((S_ISBLK(inode->i_mode)) ||
  1208. (S_ISCHR(inode->i_mode)))
  1209. init_special_inode(inode, inode->i_mode,
  1210. inode->i_rdev);
  1211. }
  1212. if (stat->st_result_mask & P9_STATS_RDEV)
  1213. inode->i_rdev = new_decode_dev(stat->st_rdev);
  1214. if (stat->st_result_mask & P9_STATS_SIZE)
  1215. i_size_write(inode, stat->st_size);
  1216. if (stat->st_result_mask & P9_STATS_BLOCKS)
  1217. inode->i_blocks = stat->st_blocks;
  1218. }
  1219. if (stat->st_result_mask & P9_STATS_GEN)
  1220. inode->i_generation = stat->st_gen;
  1221. /* Currently we don't support P9_STATS_BTIME and P9_STATS_DATA_VERSION
  1222. * because the inode structure does not have fields for them.
  1223. */
  1224. }
  1225. /**
  1226. * v9fs_qid2ino - convert qid into inode number
  1227. * @qid: qid to hash
  1228. *
  1229. * BUG: potential for inode number collisions?
  1230. */
  1231. ino_t v9fs_qid2ino(struct p9_qid *qid)
  1232. {
  1233. u64 path = qid->path + 2;
  1234. ino_t i = 0;
  1235. if (sizeof(ino_t) == sizeof(path))
  1236. memcpy(&i, &path, sizeof(ino_t));
  1237. else
  1238. i = (ino_t) (path ^ (path >> 32));
  1239. return i;
  1240. }
  1241. /**
  1242. * v9fs_readlink - read a symlink's location (internal version)
  1243. * @dentry: dentry for symlink
  1244. * @buffer: buffer to load symlink location into
  1245. * @buflen: length of buffer
  1246. *
  1247. */
  1248. static int v9fs_readlink(struct dentry *dentry, char *buffer, int buflen)
  1249. {
  1250. int retval;
  1251. struct v9fs_session_info *v9ses;
  1252. struct p9_fid *fid;
  1253. struct p9_wstat *st;
  1254. P9_DPRINTK(P9_DEBUG_VFS, " %s\n", dentry->d_name.name);
  1255. retval = -EPERM;
  1256. v9ses = v9fs_inode2v9ses(dentry->d_inode);
  1257. fid = v9fs_fid_lookup(dentry);
  1258. if (IS_ERR(fid))
  1259. return PTR_ERR(fid);
  1260. if (!v9fs_proto_dotu(v9ses) && !v9fs_proto_dotl(v9ses))
  1261. return -EBADF;
  1262. st = p9_client_stat(fid);
  1263. if (IS_ERR(st))
  1264. return PTR_ERR(st);
  1265. if (!(st->mode & P9_DMSYMLINK)) {
  1266. retval = -EINVAL;
  1267. goto done;
  1268. }
  1269. /* copy extension buffer into buffer */
  1270. strncpy(buffer, st->extension, buflen);
  1271. P9_DPRINTK(P9_DEBUG_VFS,
  1272. "%s -> %s (%s)\n", dentry->d_name.name, st->extension, buffer);
  1273. retval = strnlen(buffer, buflen);
  1274. done:
  1275. p9stat_free(st);
  1276. kfree(st);
  1277. return retval;
  1278. }
  1279. /**
  1280. * v9fs_vfs_follow_link - follow a symlink path
  1281. * @dentry: dentry for symlink
  1282. * @nd: nameidata
  1283. *
  1284. */
  1285. static void *v9fs_vfs_follow_link(struct dentry *dentry, struct nameidata *nd)
  1286. {
  1287. int len = 0;
  1288. char *link = __getname();
  1289. P9_DPRINTK(P9_DEBUG_VFS, "%s n", dentry->d_name.name);
  1290. if (!link)
  1291. link = ERR_PTR(-ENOMEM);
  1292. else {
  1293. len = v9fs_readlink(dentry, link, PATH_MAX);
  1294. if (len < 0) {
  1295. __putname(link);
  1296. link = ERR_PTR(len);
  1297. } else
  1298. link[min(len, PATH_MAX-1)] = 0;
  1299. }
  1300. nd_set_link(nd, link);
  1301. return NULL;
  1302. }
  1303. /**
  1304. * v9fs_vfs_put_link - release a symlink path
  1305. * @dentry: dentry for symlink
  1306. * @nd: nameidata
  1307. * @p: unused
  1308. *
  1309. */
  1310. static void
  1311. v9fs_vfs_put_link(struct dentry *dentry, struct nameidata *nd, void *p)
  1312. {
  1313. char *s = nd_get_link(nd);
  1314. P9_DPRINTK(P9_DEBUG_VFS, " %s %s\n", dentry->d_name.name,
  1315. IS_ERR(s) ? "<error>" : s);
  1316. if (!IS_ERR(s))
  1317. __putname(s);
  1318. }
  1319. /**
  1320. * v9fs_vfs_mkspecial - create a special file
  1321. * @dir: inode to create special file in
  1322. * @dentry: dentry to create
  1323. * @mode: mode to create special file
  1324. * @extension: 9p2000.u format extension string representing special file
  1325. *
  1326. */
  1327. static int v9fs_vfs_mkspecial(struct inode *dir, struct dentry *dentry,
  1328. int mode, const char *extension)
  1329. {
  1330. u32 perm;
  1331. struct v9fs_session_info *v9ses;
  1332. struct p9_fid *fid;
  1333. v9ses = v9fs_inode2v9ses(dir);
  1334. if (!v9fs_proto_dotu(v9ses)) {
  1335. P9_DPRINTK(P9_DEBUG_ERROR, "not extended\n");
  1336. return -EPERM;
  1337. }
  1338. perm = unixmode2p9mode(v9ses, mode);
  1339. fid = v9fs_create(v9ses, dir, dentry, (char *) extension, perm,
  1340. P9_OREAD);
  1341. if (IS_ERR(fid))
  1342. return PTR_ERR(fid);
  1343. p9_client_clunk(fid);
  1344. return 0;
  1345. }
  1346. /**
  1347. * v9fs_vfs_symlink_dotl - helper function to create symlinks
  1348. * @dir: directory inode containing symlink
  1349. * @dentry: dentry for symlink
  1350. * @symname: symlink data
  1351. *
  1352. * See Also: 9P2000.L RFC for more information
  1353. *
  1354. */
  1355. static int
  1356. v9fs_vfs_symlink_dotl(struct inode *dir, struct dentry *dentry,
  1357. const char *symname)
  1358. {
  1359. struct v9fs_session_info *v9ses;
  1360. struct p9_fid *dfid;
  1361. struct p9_fid *fid = NULL;
  1362. struct inode *inode;
  1363. struct p9_qid qid;
  1364. char *name;
  1365. int err;
  1366. gid_t gid;
  1367. name = (char *) dentry->d_name.name;
  1368. P9_DPRINTK(P9_DEBUG_VFS, "v9fs_vfs_symlink_dotl : %lu,%s,%s\n",
  1369. dir->i_ino, name, symname);
  1370. v9ses = v9fs_inode2v9ses(dir);
  1371. dfid = v9fs_fid_lookup(dentry->d_parent);
  1372. if (IS_ERR(dfid)) {
  1373. err = PTR_ERR(dfid);
  1374. P9_DPRINTK(P9_DEBUG_VFS, "fid lookup failed %d\n", err);
  1375. return err;
  1376. }
  1377. gid = v9fs_get_fsgid_for_create(dir);
  1378. if (gid < 0) {
  1379. P9_DPRINTK(P9_DEBUG_VFS, "v9fs_get_egid failed %d\n", gid);
  1380. goto error;
  1381. }
  1382. /* Server doesn't alter fid on TSYMLINK. Hence no need to clone it. */
  1383. err = p9_client_symlink(dfid, name, (char *)symname, gid, &qid);
  1384. if (err < 0) {
  1385. P9_DPRINTK(P9_DEBUG_VFS, "p9_client_symlink failed %d\n", err);
  1386. goto error;
  1387. }
  1388. if (v9ses->cache) {
  1389. /* Now walk from the parent so we can get an unopened fid. */
  1390. fid = p9_client_walk(dfid, 1, &name, 1);
  1391. if (IS_ERR(fid)) {
  1392. err = PTR_ERR(fid);
  1393. P9_DPRINTK(P9_DEBUG_VFS, "p9_client_walk failed %d\n",
  1394. err);
  1395. fid = NULL;
  1396. goto error;
  1397. }
  1398. /* instantiate inode and assign the unopened fid to dentry */
  1399. inode = v9fs_inode_from_fid(v9ses, fid, dir->i_sb);
  1400. if (IS_ERR(inode)) {
  1401. err = PTR_ERR(inode);
  1402. P9_DPRINTK(P9_DEBUG_VFS, "inode creation failed %d\n",
  1403. err);
  1404. goto error;
  1405. }
  1406. dentry->d_op = &v9fs_cached_dentry_operations;
  1407. d_instantiate(dentry, inode);
  1408. err = v9fs_fid_add(dentry, fid);
  1409. if (err < 0)
  1410. goto error;
  1411. fid = NULL;
  1412. } else {
  1413. /* Not in cached mode. No need to populate inode with stat */
  1414. inode = v9fs_get_inode(dir->i_sb, S_IFLNK);
  1415. if (IS_ERR(inode)) {
  1416. err = PTR_ERR(inode);
  1417. goto error;
  1418. }
  1419. dentry->d_op = &v9fs_dentry_operations;
  1420. d_instantiate(dentry, inode);
  1421. }
  1422. error:
  1423. if (fid)
  1424. p9_client_clunk(fid);
  1425. return err;
  1426. }
  1427. /**
  1428. * v9fs_vfs_symlink - helper function to create symlinks
  1429. * @dir: directory inode containing symlink
  1430. * @dentry: dentry for symlink
  1431. * @symname: symlink data
  1432. *
  1433. * See Also: 9P2000.u RFC for more information
  1434. *
  1435. */
  1436. static int
  1437. v9fs_vfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
  1438. {
  1439. P9_DPRINTK(P9_DEBUG_VFS, " %lu,%s,%s\n", dir->i_ino,
  1440. dentry->d_name.name, symname);
  1441. return v9fs_vfs_mkspecial(dir, dentry, S_IFLNK, symname);
  1442. }
  1443. /**
  1444. * v9fs_vfs_link - create a hardlink
  1445. * @old_dentry: dentry for file to link to
  1446. * @dir: inode destination for new link
  1447. * @dentry: dentry for link
  1448. *
  1449. */
  1450. static int
  1451. v9fs_vfs_link(struct dentry *old_dentry, struct inode *dir,
  1452. struct dentry *dentry)
  1453. {
  1454. int retval;
  1455. struct p9_fid *oldfid;
  1456. char *name;
  1457. P9_DPRINTK(P9_DEBUG_VFS,
  1458. " %lu,%s,%s\n", dir->i_ino, dentry->d_name.name,
  1459. old_dentry->d_name.name);
  1460. oldfid = v9fs_fid_clone(old_dentry);
  1461. if (IS_ERR(oldfid))
  1462. return PTR_ERR(oldfid);
  1463. name = __getname();
  1464. if (unlikely(!name)) {
  1465. retval = -ENOMEM;
  1466. goto clunk_fid;
  1467. }
  1468. sprintf(name, "%d\n", oldfid->fid);
  1469. retval = v9fs_vfs_mkspecial(dir, dentry, P9_DMLINK, name);
  1470. __putname(name);
  1471. clunk_fid:
  1472. p9_client_clunk(oldfid);
  1473. return retval;
  1474. }
  1475. /**
  1476. * v9fs_vfs_link_dotl - create a hardlink for dotl
  1477. * @old_dentry: dentry for file to link to
  1478. * @dir: inode destination for new link
  1479. * @dentry: dentry for link
  1480. *
  1481. */
  1482. static int
  1483. v9fs_vfs_link_dotl(struct dentry *old_dentry, struct inode *dir,
  1484. struct dentry *dentry)
  1485. {
  1486. int err;
  1487. struct p9_fid *dfid, *oldfid;
  1488. char *name;
  1489. struct v9fs_session_info *v9ses;
  1490. struct dentry *dir_dentry;
  1491. P9_DPRINTK(P9_DEBUG_VFS, "dir ino: %lu, old_name: %s, new_name: %s\n",
  1492. dir->i_ino, old_dentry->d_name.name,
  1493. dentry->d_name.name);
  1494. v9ses = v9fs_inode2v9ses(dir);
  1495. dir_dentry = v9fs_dentry_from_dir_inode(dir);
  1496. dfid = v9fs_fid_lookup(dir_dentry);
  1497. if (IS_ERR(dfid))
  1498. return PTR_ERR(dfid);
  1499. oldfid = v9fs_fid_lookup(old_dentry);
  1500. if (IS_ERR(oldfid))
  1501. return PTR_ERR(oldfid);
  1502. name = (char *) dentry->d_name.name;
  1503. err = p9_client_link(dfid, oldfid, (char *)dentry->d_name.name);
  1504. if (err < 0) {
  1505. P9_DPRINTK(P9_DEBUG_VFS, "p9_client_link failed %d\n", err);
  1506. return err;
  1507. }
  1508. if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) {
  1509. /* Get the latest stat info from server. */
  1510. struct p9_fid *fid;
  1511. struct p9_stat_dotl *st;
  1512. fid = v9fs_fid_lookup(old_dentry);
  1513. if (IS_ERR(fid))
  1514. return PTR_ERR(fid);
  1515. st = p9_client_getattr_dotl(fid, P9_STATS_BASIC);
  1516. if (IS_ERR(st))
  1517. return PTR_ERR(st);
  1518. v9fs_stat2inode_dotl(st, old_dentry->d_inode);
  1519. kfree(st);
  1520. } else {
  1521. /* Caching disabled. No need to get upto date stat info.
  1522. * This dentry will be released immediately. So, just i_count++
  1523. */
  1524. atomic_inc(&old_dentry->d_inode->i_count);
  1525. }
  1526. dentry->d_op = old_dentry->d_op;
  1527. d_instantiate(dentry, old_dentry->d_inode);
  1528. return err;
  1529. }
  1530. /**
  1531. * v9fs_vfs_mknod - create a special file
  1532. * @dir: inode destination for new link
  1533. * @dentry: dentry for file
  1534. * @mode: mode for creation
  1535. * @rdev: device associated with special file
  1536. *
  1537. */
  1538. static int
  1539. v9fs_vfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev)
  1540. {
  1541. int retval;
  1542. char *name;
  1543. P9_DPRINTK(P9_DEBUG_VFS,
  1544. " %lu,%s mode: %x MAJOR: %u MINOR: %u\n", dir->i_ino,
  1545. dentry->d_name.name, mode, MAJOR(rdev), MINOR(rdev));
  1546. if (!new_valid_dev(rdev))
  1547. return -EINVAL;
  1548. name = __getname();
  1549. if (!name)
  1550. return -ENOMEM;
  1551. /* build extension */
  1552. if (S_ISBLK(mode))
  1553. sprintf(name, "b %u %u", MAJOR(rdev), MINOR(rdev));
  1554. else if (S_ISCHR(mode))
  1555. sprintf(name, "c %u %u", MAJOR(rdev), MINOR(rdev));
  1556. else if (S_ISFIFO(mode))
  1557. *name = 0;
  1558. else if (S_ISSOCK(mode))
  1559. *name = 0;
  1560. else {
  1561. __putname(name);
  1562. return -EINVAL;
  1563. }
  1564. retval = v9fs_vfs_mkspecial(dir, dentry, mode, name);
  1565. __putname(name);
  1566. return retval;
  1567. }
  1568. /**
  1569. * v9fs_vfs_mknod_dotl - create a special file
  1570. * @dir: inode destination for new link
  1571. * @dentry: dentry for file
  1572. * @mode: mode for creation
  1573. * @rdev: device associated with special file
  1574. *
  1575. */
  1576. static int
  1577. v9fs_vfs_mknod_dotl(struct inode *dir, struct dentry *dentry, int mode,
  1578. dev_t rdev)
  1579. {
  1580. int err;
  1581. char *name;
  1582. struct v9fs_session_info *v9ses;
  1583. struct p9_fid *fid = NULL, *dfid = NULL;
  1584. struct inode *inode;
  1585. gid_t gid;
  1586. struct p9_qid qid;
  1587. struct dentry *dir_dentry;
  1588. P9_DPRINTK(P9_DEBUG_VFS,
  1589. " %lu,%s mode: %x MAJOR: %u MINOR: %u\n", dir->i_ino,
  1590. dentry->d_name.name, mode, MAJOR(rdev), MINOR(rdev));
  1591. if (!new_valid_dev(rdev))
  1592. return -EINVAL;
  1593. v9ses = v9fs_inode2v9ses(dir);
  1594. dir_dentry = v9fs_dentry_from_dir_inode(dir);
  1595. dfid = v9fs_fid_lookup(dir_dentry);
  1596. if (IS_ERR(dfid)) {
  1597. err = PTR_ERR(dfid);
  1598. P9_DPRINTK(P9_DEBUG_VFS, "fid lookup failed %d\n", err);
  1599. dfid = NULL;
  1600. goto error;
  1601. }
  1602. gid = v9fs_get_fsgid_for_create(dir);
  1603. if (gid < 0) {
  1604. P9_DPRINTK(P9_DEBUG_VFS, "v9fs_get_fsgid_for_create failed\n");
  1605. goto error;
  1606. }
  1607. name = (char *) dentry->d_name.name;
  1608. err = p9_client_mknod_dotl(dfid, name, mode, rdev, gid, &qid);
  1609. if (err < 0)
  1610. goto error;
  1611. /* instantiate inode and assign the unopened fid to the dentry */
  1612. if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) {
  1613. fid = p9_client_walk(dfid, 1, &name, 1);
  1614. if (IS_ERR(fid)) {
  1615. err = PTR_ERR(fid);
  1616. P9_DPRINTK(P9_DEBUG_VFS, "p9_client_walk failed %d\n",
  1617. err);
  1618. fid = NULL;
  1619. goto error;
  1620. }
  1621. inode = v9fs_inode_from_fid(v9ses, fid, dir->i_sb);
  1622. if (IS_ERR(inode)) {
  1623. err = PTR_ERR(inode);
  1624. P9_DPRINTK(P9_DEBUG_VFS, "inode creation failed %d\n",
  1625. err);
  1626. goto error;
  1627. }
  1628. dentry->d_op = &v9fs_cached_dentry_operations;
  1629. d_instantiate(dentry, inode);
  1630. err = v9fs_fid_add(dentry, fid);
  1631. if (err < 0)
  1632. goto error;
  1633. fid = NULL;
  1634. } else {
  1635. /*
  1636. * Not in cached mode. No need to populate inode with stat.
  1637. * socket syscall returns a fd, so we need instantiate
  1638. */
  1639. inode = v9fs_get_inode(dir->i_sb, mode);
  1640. if (IS_ERR(inode)) {
  1641. err = PTR_ERR(inode);
  1642. goto error;
  1643. }
  1644. dentry->d_op = &v9fs_dentry_operations;
  1645. d_instantiate(dentry, inode);
  1646. }
  1647. error:
  1648. if (fid)
  1649. p9_client_clunk(fid);
  1650. return err;
  1651. }
  1652. static const struct inode_operations v9fs_dir_inode_operations_dotu = {
  1653. .create = v9fs_vfs_create,
  1654. .lookup = v9fs_vfs_lookup,
  1655. .symlink = v9fs_vfs_symlink,
  1656. .link = v9fs_vfs_link,
  1657. .unlink = v9fs_vfs_unlink,
  1658. .mkdir = v9fs_vfs_mkdir,
  1659. .rmdir = v9fs_vfs_rmdir,
  1660. .mknod = v9fs_vfs_mknod,
  1661. .rename = v9fs_vfs_rename,
  1662. .getattr = v9fs_vfs_getattr,
  1663. .setattr = v9fs_vfs_setattr,
  1664. };
  1665. static const struct inode_operations v9fs_dir_inode_operations_dotl = {
  1666. .create = v9fs_vfs_create_dotl,
  1667. .lookup = v9fs_vfs_lookup,
  1668. .link = v9fs_vfs_link_dotl,
  1669. .symlink = v9fs_vfs_symlink_dotl,
  1670. .unlink = v9fs_vfs_unlink,
  1671. .mkdir = v9fs_vfs_mkdir_dotl,
  1672. .rmdir = v9fs_vfs_rmdir,
  1673. .mknod = v9fs_vfs_mknod_dotl,
  1674. .rename = v9fs_vfs_rename,
  1675. .getattr = v9fs_vfs_getattr_dotl,
  1676. .setattr = v9fs_vfs_setattr_dotl,
  1677. .setxattr = generic_setxattr,
  1678. .getxattr = generic_getxattr,
  1679. .removexattr = generic_removexattr,
  1680. .listxattr = v9fs_listxattr,
  1681. };
  1682. static const struct inode_operations v9fs_dir_inode_operations = {
  1683. .create = v9fs_vfs_create,
  1684. .lookup = v9fs_vfs_lookup,
  1685. .unlink = v9fs_vfs_unlink,
  1686. .mkdir = v9fs_vfs_mkdir,
  1687. .rmdir = v9fs_vfs_rmdir,
  1688. .mknod = v9fs_vfs_mknod,
  1689. .rename = v9fs_vfs_rename,
  1690. .getattr = v9fs_vfs_getattr,
  1691. .setattr = v9fs_vfs_setattr,
  1692. };
  1693. static const struct inode_operations v9fs_file_inode_operations = {
  1694. .getattr = v9fs_vfs_getattr,
  1695. .setattr = v9fs_vfs_setattr,
  1696. };
  1697. static const struct inode_operations v9fs_file_inode_operations_dotl = {
  1698. .getattr = v9fs_vfs_getattr_dotl,
  1699. .setattr = v9fs_vfs_setattr_dotl,
  1700. .setxattr = generic_setxattr,
  1701. .getxattr = generic_getxattr,
  1702. .removexattr = generic_removexattr,
  1703. .listxattr = v9fs_listxattr,
  1704. };
  1705. static const struct inode_operations v9fs_symlink_inode_operations = {
  1706. .readlink = generic_readlink,
  1707. .follow_link = v9fs_vfs_follow_link,
  1708. .put_link = v9fs_vfs_put_link,
  1709. .getattr = v9fs_vfs_getattr,
  1710. .setattr = v9fs_vfs_setattr,
  1711. };
  1712. static const struct inode_operations v9fs_symlink_inode_operations_dotl = {
  1713. .readlink = generic_readlink,
  1714. .follow_link = v9fs_vfs_follow_link,
  1715. .put_link = v9fs_vfs_put_link,
  1716. .getattr = v9fs_vfs_getattr_dotl,
  1717. .setattr = v9fs_vfs_setattr_dotl,
  1718. .setxattr = generic_setxattr,
  1719. .getxattr = generic_getxattr,
  1720. .removexattr = generic_removexattr,
  1721. .listxattr = v9fs_listxattr,
  1722. };