vfs_inode.c 28 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356
  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/smp_lock.h>
  33. #include <linux/inet.h>
  34. #include <linux/namei.h>
  35. #include <linux/idr.h>
  36. #include "debug.h"
  37. #include "v9fs.h"
  38. #include "9p.h"
  39. #include "v9fs_vfs.h"
  40. #include "fid.h"
  41. static const struct inode_operations v9fs_dir_inode_operations;
  42. static const struct inode_operations v9fs_dir_inode_operations_ext;
  43. static const struct inode_operations v9fs_file_inode_operations;
  44. static const struct inode_operations v9fs_symlink_inode_operations;
  45. /**
  46. * unixmode2p9mode - convert unix mode bits to plan 9
  47. * @v9ses: v9fs session information
  48. * @mode: mode to convert
  49. *
  50. */
  51. static int unixmode2p9mode(struct v9fs_session_info *v9ses, int mode)
  52. {
  53. int res;
  54. res = mode & 0777;
  55. if (S_ISDIR(mode))
  56. res |= V9FS_DMDIR;
  57. if (v9ses->extended) {
  58. if (S_ISLNK(mode))
  59. res |= V9FS_DMSYMLINK;
  60. if (v9ses->nodev == 0) {
  61. if (S_ISSOCK(mode))
  62. res |= V9FS_DMSOCKET;
  63. if (S_ISFIFO(mode))
  64. res |= V9FS_DMNAMEDPIPE;
  65. if (S_ISBLK(mode))
  66. res |= V9FS_DMDEVICE;
  67. if (S_ISCHR(mode))
  68. res |= V9FS_DMDEVICE;
  69. }
  70. if ((mode & S_ISUID) == S_ISUID)
  71. res |= V9FS_DMSETUID;
  72. if ((mode & S_ISGID) == S_ISGID)
  73. res |= V9FS_DMSETGID;
  74. if ((mode & V9FS_DMLINK))
  75. res |= V9FS_DMLINK;
  76. }
  77. return res;
  78. }
  79. /**
  80. * p9mode2unixmode- convert plan9 mode bits to unix mode bits
  81. * @v9ses: v9fs session information
  82. * @mode: mode to convert
  83. *
  84. */
  85. static int p9mode2unixmode(struct v9fs_session_info *v9ses, int mode)
  86. {
  87. int res;
  88. res = mode & 0777;
  89. if ((mode & V9FS_DMDIR) == V9FS_DMDIR)
  90. res |= S_IFDIR;
  91. else if ((mode & V9FS_DMSYMLINK) && (v9ses->extended))
  92. res |= S_IFLNK;
  93. else if ((mode & V9FS_DMSOCKET) && (v9ses->extended)
  94. && (v9ses->nodev == 0))
  95. res |= S_IFSOCK;
  96. else if ((mode & V9FS_DMNAMEDPIPE) && (v9ses->extended)
  97. && (v9ses->nodev == 0))
  98. res |= S_IFIFO;
  99. else if ((mode & V9FS_DMDEVICE) && (v9ses->extended)
  100. && (v9ses->nodev == 0))
  101. res |= S_IFBLK;
  102. else
  103. res |= S_IFREG;
  104. if (v9ses->extended) {
  105. if ((mode & V9FS_DMSETUID) == V9FS_DMSETUID)
  106. res |= S_ISUID;
  107. if ((mode & V9FS_DMSETGID) == V9FS_DMSETGID)
  108. res |= S_ISGID;
  109. }
  110. return res;
  111. }
  112. int v9fs_uflags2omode(int uflags)
  113. {
  114. int ret;
  115. ret = 0;
  116. switch (uflags&3) {
  117. default:
  118. case O_RDONLY:
  119. ret = V9FS_OREAD;
  120. break;
  121. case O_WRONLY:
  122. ret = V9FS_OWRITE;
  123. break;
  124. case O_RDWR:
  125. ret = V9FS_ORDWR;
  126. break;
  127. }
  128. if (uflags & O_EXCL)
  129. ret |= V9FS_OEXCL;
  130. if (uflags & O_TRUNC)
  131. ret |= V9FS_OTRUNC;
  132. if (uflags & O_APPEND)
  133. ret |= V9FS_OAPPEND;
  134. return ret;
  135. }
  136. /**
  137. * v9fs_blank_wstat - helper function to setup a 9P stat structure
  138. * @v9ses: 9P session info (for determining extended mode)
  139. * @wstat: structure to initialize
  140. *
  141. */
  142. static void
  143. v9fs_blank_wstat(struct v9fs_wstat *wstat)
  144. {
  145. wstat->type = ~0;
  146. wstat->dev = ~0;
  147. wstat->qid.type = ~0;
  148. wstat->qid.version = ~0;
  149. *((long long *)&wstat->qid.path) = ~0;
  150. wstat->mode = ~0;
  151. wstat->atime = ~0;
  152. wstat->mtime = ~0;
  153. wstat->length = ~0;
  154. wstat->name = NULL;
  155. wstat->uid = NULL;
  156. wstat->gid = NULL;
  157. wstat->muid = NULL;
  158. wstat->n_uid = ~0;
  159. wstat->n_gid = ~0;
  160. wstat->n_muid = ~0;
  161. wstat->extension = NULL;
  162. }
  163. /**
  164. * v9fs_get_inode - helper function to setup an inode
  165. * @sb: superblock
  166. * @mode: mode to setup inode with
  167. *
  168. */
  169. struct inode *v9fs_get_inode(struct super_block *sb, int mode)
  170. {
  171. struct inode *inode;
  172. struct v9fs_session_info *v9ses = sb->s_fs_info;
  173. dprintk(DEBUG_VFS, "super block: %p mode: %o\n", sb, mode);
  174. inode = new_inode(sb);
  175. if (inode) {
  176. inode->i_mode = mode;
  177. inode->i_uid = current->fsuid;
  178. inode->i_gid = current->fsgid;
  179. inode->i_blocks = 0;
  180. inode->i_rdev = 0;
  181. inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
  182. inode->i_mapping->a_ops = &v9fs_addr_operations;
  183. switch (mode & S_IFMT) {
  184. case S_IFIFO:
  185. case S_IFBLK:
  186. case S_IFCHR:
  187. case S_IFSOCK:
  188. if(!v9ses->extended) {
  189. dprintk(DEBUG_ERROR, "special files without extended mode\n");
  190. return ERR_PTR(-EINVAL);
  191. }
  192. init_special_inode(inode, inode->i_mode,
  193. inode->i_rdev);
  194. break;
  195. case S_IFREG:
  196. inode->i_op = &v9fs_file_inode_operations;
  197. inode->i_fop = &v9fs_file_operations;
  198. break;
  199. case S_IFLNK:
  200. if(!v9ses->extended) {
  201. dprintk(DEBUG_ERROR, "extended modes used w/o 9P2000.u\n");
  202. return ERR_PTR(-EINVAL);
  203. }
  204. inode->i_op = &v9fs_symlink_inode_operations;
  205. break;
  206. case S_IFDIR:
  207. inc_nlink(inode);
  208. if(v9ses->extended)
  209. inode->i_op = &v9fs_dir_inode_operations_ext;
  210. else
  211. inode->i_op = &v9fs_dir_inode_operations;
  212. inode->i_fop = &v9fs_dir_operations;
  213. break;
  214. default:
  215. dprintk(DEBUG_ERROR, "BAD mode 0x%x S_IFMT 0x%x\n",
  216. mode, mode & S_IFMT);
  217. return ERR_PTR(-EINVAL);
  218. }
  219. } else {
  220. eprintk(KERN_WARNING, "Problem allocating inode\n");
  221. return ERR_PTR(-ENOMEM);
  222. }
  223. return inode;
  224. }
  225. static int
  226. v9fs_create(struct v9fs_session_info *v9ses, u32 pfid, char *name, u32 perm,
  227. u8 mode, char *extension, u32 *fidp, struct v9fs_qid *qid, u32 *iounit)
  228. {
  229. int fid;
  230. int err;
  231. struct v9fs_fcall *fcall;
  232. fid = v9fs_get_idpool(&v9ses->fidpool);
  233. if (fid < 0) {
  234. eprintk(KERN_WARNING, "no free fids available\n");
  235. return -ENOSPC;
  236. }
  237. err = v9fs_t_walk(v9ses, pfid, fid, NULL, &fcall);
  238. if (err < 0) {
  239. PRINT_FCALL_ERROR("clone error", fcall);
  240. if (fcall && fcall->id == RWALK)
  241. goto clunk_fid;
  242. else
  243. goto put_fid;
  244. }
  245. kfree(fcall);
  246. err = v9fs_t_create(v9ses, fid, name, perm, mode, extension, &fcall);
  247. if (err < 0) {
  248. PRINT_FCALL_ERROR("create fails", fcall);
  249. goto clunk_fid;
  250. }
  251. if (iounit)
  252. *iounit = fcall->params.rcreate.iounit;
  253. if (qid)
  254. *qid = fcall->params.rcreate.qid;
  255. if (fidp)
  256. *fidp = fid;
  257. kfree(fcall);
  258. return 0;
  259. clunk_fid:
  260. v9fs_t_clunk(v9ses, fid);
  261. fid = V9FS_NOFID;
  262. put_fid:
  263. if (fid != V9FS_NOFID)
  264. v9fs_put_idpool(fid, &v9ses->fidpool);
  265. kfree(fcall);
  266. return err;
  267. }
  268. static struct v9fs_fid*
  269. v9fs_clone_walk(struct v9fs_session_info *v9ses, u32 fid, struct dentry *dentry)
  270. {
  271. int err;
  272. int nfid;
  273. struct v9fs_fid *ret;
  274. struct v9fs_fcall *fcall;
  275. nfid = v9fs_get_idpool(&v9ses->fidpool);
  276. if (nfid < 0) {
  277. eprintk(KERN_WARNING, "no free fids available\n");
  278. return ERR_PTR(-ENOSPC);
  279. }
  280. err = v9fs_t_walk(v9ses, fid, nfid, (char *) dentry->d_name.name,
  281. &fcall);
  282. if (err < 0) {
  283. if (fcall && fcall->id == RWALK)
  284. goto clunk_fid;
  285. PRINT_FCALL_ERROR("walk error", fcall);
  286. v9fs_put_idpool(nfid, &v9ses->fidpool);
  287. goto error;
  288. }
  289. kfree(fcall);
  290. fcall = NULL;
  291. ret = v9fs_fid_create(v9ses, nfid);
  292. if (!ret) {
  293. err = -ENOMEM;
  294. goto clunk_fid;
  295. }
  296. err = v9fs_fid_insert(ret, dentry);
  297. if (err < 0) {
  298. v9fs_fid_destroy(ret);
  299. goto clunk_fid;
  300. }
  301. return ret;
  302. clunk_fid:
  303. v9fs_t_clunk(v9ses, nfid);
  304. error:
  305. kfree(fcall);
  306. return ERR_PTR(err);
  307. }
  308. static struct inode *
  309. v9fs_inode_from_fid(struct v9fs_session_info *v9ses, u32 fid,
  310. struct super_block *sb)
  311. {
  312. int err, umode;
  313. struct inode *ret;
  314. struct v9fs_fcall *fcall;
  315. ret = NULL;
  316. err = v9fs_t_stat(v9ses, fid, &fcall);
  317. if (err) {
  318. PRINT_FCALL_ERROR("stat error", fcall);
  319. goto error;
  320. }
  321. umode = p9mode2unixmode(v9ses, fcall->params.rstat.stat.mode);
  322. ret = v9fs_get_inode(sb, umode);
  323. if (IS_ERR(ret)) {
  324. err = PTR_ERR(ret);
  325. ret = NULL;
  326. goto error;
  327. }
  328. v9fs_stat2inode(&fcall->params.rstat.stat, ret, sb);
  329. kfree(fcall);
  330. return ret;
  331. error:
  332. kfree(fcall);
  333. if (ret)
  334. iput(ret);
  335. return ERR_PTR(err);
  336. }
  337. /**
  338. * v9fs_remove - helper function to remove files and directories
  339. * @dir: directory inode that is being deleted
  340. * @file: dentry that is being deleted
  341. * @rmdir: removing a directory
  342. *
  343. */
  344. static int v9fs_remove(struct inode *dir, struct dentry *file, int rmdir)
  345. {
  346. struct v9fs_fcall *fcall = NULL;
  347. struct super_block *sb = NULL;
  348. struct v9fs_session_info *v9ses = NULL;
  349. struct v9fs_fid *v9fid = NULL;
  350. struct inode *file_inode = NULL;
  351. int fid = -1;
  352. int result = 0;
  353. dprintk(DEBUG_VFS, "inode: %p dentry: %p rmdir: %d\n", dir, file,
  354. rmdir);
  355. file_inode = file->d_inode;
  356. sb = file_inode->i_sb;
  357. v9ses = v9fs_inode2v9ses(file_inode);
  358. v9fid = v9fs_fid_clone(file);
  359. if(IS_ERR(v9fid))
  360. return PTR_ERR(v9fid);
  361. fid = v9fid->fid;
  362. if (fid < 0) {
  363. dprintk(DEBUG_ERROR, "inode #%lu, no fid!\n",
  364. file_inode->i_ino);
  365. return -EBADF;
  366. }
  367. result = v9fs_t_remove(v9ses, fid, &fcall);
  368. if (result < 0) {
  369. PRINT_FCALL_ERROR("remove fails", fcall);
  370. goto Error;
  371. }
  372. v9fs_put_idpool(fid, &v9ses->fidpool);
  373. v9fs_fid_destroy(v9fid);
  374. Error:
  375. kfree(fcall);
  376. return result;
  377. }
  378. static int
  379. v9fs_open_created(struct inode *inode, struct file *file)
  380. {
  381. return 0;
  382. }
  383. /**
  384. * v9fs_vfs_create - VFS hook to create files
  385. * @inode: directory inode that is being deleted
  386. * @dentry: dentry that is being deleted
  387. * @mode: create permissions
  388. * @nd: path information
  389. *
  390. */
  391. static int
  392. v9fs_vfs_create(struct inode *dir, struct dentry *dentry, int mode,
  393. struct nameidata *nd)
  394. {
  395. int err;
  396. u32 fid, perm, iounit;
  397. int flags;
  398. struct v9fs_session_info *v9ses;
  399. struct v9fs_fid *dfid, *vfid, *ffid;
  400. struct inode *inode;
  401. struct v9fs_qid qid;
  402. struct file *filp;
  403. inode = NULL;
  404. vfid = NULL;
  405. v9ses = v9fs_inode2v9ses(dir);
  406. dfid = v9fs_fid_clone(dentry->d_parent);
  407. if(IS_ERR(dfid)) {
  408. err = PTR_ERR(dfid);
  409. goto error;
  410. }
  411. perm = unixmode2p9mode(v9ses, mode);
  412. if (nd && nd->flags & LOOKUP_OPEN)
  413. flags = nd->intent.open.flags - 1;
  414. else
  415. flags = O_RDWR;
  416. err = v9fs_create(v9ses, dfid->fid, (char *) dentry->d_name.name,
  417. perm, v9fs_uflags2omode(flags), NULL, &fid, &qid, &iounit);
  418. if (err)
  419. goto clunk_dfid;
  420. vfid = v9fs_clone_walk(v9ses, dfid->fid, dentry);
  421. v9fs_fid_clunk(v9ses, dfid);
  422. if (IS_ERR(vfid)) {
  423. err = PTR_ERR(vfid);
  424. vfid = NULL;
  425. goto error;
  426. }
  427. inode = v9fs_inode_from_fid(v9ses, vfid->fid, dir->i_sb);
  428. if (IS_ERR(inode)) {
  429. err = PTR_ERR(inode);
  430. inode = NULL;
  431. goto error;
  432. }
  433. if(v9ses->cache)
  434. dentry->d_op = &v9fs_cached_dentry_operations;
  435. else
  436. dentry->d_op = &v9fs_dentry_operations;
  437. d_instantiate(dentry, inode);
  438. if (nd && nd->flags & LOOKUP_OPEN) {
  439. ffid = v9fs_fid_create(v9ses, fid);
  440. if (!ffid)
  441. return -ENOMEM;
  442. filp = lookup_instantiate_filp(nd, dentry, v9fs_open_created);
  443. if (IS_ERR(filp)) {
  444. v9fs_fid_destroy(ffid);
  445. return PTR_ERR(filp);
  446. }
  447. ffid->rdir_pos = 0;
  448. ffid->rdir_fcall = NULL;
  449. ffid->fidopen = 1;
  450. ffid->iounit = iounit;
  451. ffid->filp = filp;
  452. filp->private_data = ffid;
  453. }
  454. return 0;
  455. clunk_dfid:
  456. v9fs_fid_clunk(v9ses, dfid);
  457. error:
  458. if (vfid)
  459. v9fs_fid_destroy(vfid);
  460. return err;
  461. }
  462. /**
  463. * v9fs_vfs_mkdir - VFS mkdir hook to create a directory
  464. * @inode: inode that is being unlinked
  465. * @dentry: dentry that is being unlinked
  466. * @mode: mode for new directory
  467. *
  468. */
  469. static int v9fs_vfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
  470. {
  471. int err;
  472. u32 fid, perm;
  473. struct v9fs_session_info *v9ses;
  474. struct v9fs_fid *dfid, *vfid;
  475. struct inode *inode;
  476. inode = NULL;
  477. vfid = NULL;
  478. v9ses = v9fs_inode2v9ses(dir);
  479. dfid = v9fs_fid_clone(dentry->d_parent);
  480. if(IS_ERR(dfid)) {
  481. err = PTR_ERR(dfid);
  482. goto error;
  483. }
  484. perm = unixmode2p9mode(v9ses, mode | S_IFDIR);
  485. err = v9fs_create(v9ses, dfid->fid, (char *) dentry->d_name.name,
  486. perm, V9FS_OREAD, NULL, &fid, NULL, NULL);
  487. if (err) {
  488. dprintk(DEBUG_ERROR, "create error %d\n", err);
  489. goto clean_up_dfid;
  490. }
  491. vfid = v9fs_clone_walk(v9ses, dfid->fid, dentry);
  492. if (IS_ERR(vfid)) {
  493. err = PTR_ERR(vfid);
  494. vfid = NULL;
  495. goto clean_up_dfid;
  496. }
  497. v9fs_fid_clunk(v9ses, dfid);
  498. inode = v9fs_inode_from_fid(v9ses, vfid->fid, dir->i_sb);
  499. if (IS_ERR(inode)) {
  500. err = PTR_ERR(inode);
  501. inode = NULL;
  502. v9fs_fid_destroy(vfid);
  503. goto error;
  504. }
  505. if(v9ses->cache)
  506. dentry->d_op = &v9fs_cached_dentry_operations;
  507. else
  508. dentry->d_op = &v9fs_dentry_operations;
  509. d_instantiate(dentry, inode);
  510. return 0;
  511. clean_up_dfid:
  512. v9fs_fid_clunk(v9ses, dfid);
  513. error:
  514. return err;
  515. }
  516. /**
  517. * v9fs_vfs_lookup - VFS lookup hook to "walk" to a new inode
  518. * @dir: inode that is being walked from
  519. * @dentry: dentry that is being walked to?
  520. * @nameidata: path data
  521. *
  522. */
  523. static struct dentry *v9fs_vfs_lookup(struct inode *dir, struct dentry *dentry,
  524. struct nameidata *nameidata)
  525. {
  526. struct super_block *sb;
  527. struct v9fs_session_info *v9ses;
  528. struct v9fs_fid *dirfid;
  529. struct v9fs_fid *fid;
  530. struct inode *inode;
  531. struct v9fs_fcall *fcall = NULL;
  532. int dirfidnum = -1;
  533. int newfid = -1;
  534. int result = 0;
  535. dprintk(DEBUG_VFS, "dir: %p dentry: (%s) %p nameidata: %p\n",
  536. dir, dentry->d_name.name, dentry, nameidata);
  537. sb = dir->i_sb;
  538. v9ses = v9fs_inode2v9ses(dir);
  539. dirfid = v9fs_fid_lookup(dentry->d_parent);
  540. if(IS_ERR(dirfid))
  541. return ERR_PTR(PTR_ERR(dirfid));
  542. dirfidnum = dirfid->fid;
  543. newfid = v9fs_get_idpool(&v9ses->fidpool);
  544. if (newfid < 0) {
  545. eprintk(KERN_WARNING, "newfid fails!\n");
  546. result = -ENOSPC;
  547. goto Release_Dirfid;
  548. }
  549. result = v9fs_t_walk(v9ses, dirfidnum, newfid,
  550. (char *)dentry->d_name.name, &fcall);
  551. up(&dirfid->lock);
  552. if (result < 0) {
  553. if (fcall && fcall->id == RWALK)
  554. v9fs_t_clunk(v9ses, newfid);
  555. else
  556. v9fs_put_idpool(newfid, &v9ses->fidpool);
  557. if (result == -ENOENT) {
  558. d_add(dentry, NULL);
  559. dprintk(DEBUG_VFS,
  560. "Return negative dentry %p count %d\n",
  561. dentry, atomic_read(&dentry->d_count));
  562. kfree(fcall);
  563. return NULL;
  564. }
  565. dprintk(DEBUG_ERROR, "walk error:%d\n", result);
  566. goto FreeFcall;
  567. }
  568. kfree(fcall);
  569. result = v9fs_t_stat(v9ses, newfid, &fcall);
  570. if (result < 0) {
  571. dprintk(DEBUG_ERROR, "stat error\n");
  572. goto FreeFcall;
  573. }
  574. inode = v9fs_get_inode(sb, p9mode2unixmode(v9ses,
  575. fcall->params.rstat.stat.mode));
  576. if (IS_ERR(inode) && (PTR_ERR(inode) == -ENOSPC)) {
  577. eprintk(KERN_WARNING, "inode alloc failes, returns %ld\n",
  578. PTR_ERR(inode));
  579. result = -ENOSPC;
  580. goto FreeFcall;
  581. }
  582. inode->i_ino = v9fs_qid2ino(&fcall->params.rstat.stat.qid);
  583. fid = v9fs_fid_create(v9ses, newfid);
  584. if (fid == NULL) {
  585. dprintk(DEBUG_ERROR, "couldn't insert\n");
  586. result = -ENOMEM;
  587. goto FreeFcall;
  588. }
  589. result = v9fs_fid_insert(fid, dentry);
  590. if (result < 0)
  591. goto FreeFcall;
  592. fid->qid = fcall->params.rstat.stat.qid;
  593. v9fs_stat2inode(&fcall->params.rstat.stat, inode, inode->i_sb);
  594. if((fid->qid.version)&&(v9ses->cache))
  595. dentry->d_op = &v9fs_cached_dentry_operations;
  596. else
  597. dentry->d_op = &v9fs_dentry_operations;
  598. d_add(dentry, inode);
  599. kfree(fcall);
  600. return NULL;
  601. Release_Dirfid:
  602. up(&dirfid->lock);
  603. FreeFcall:
  604. kfree(fcall);
  605. return ERR_PTR(result);
  606. }
  607. /**
  608. * v9fs_vfs_unlink - VFS unlink hook to delete an inode
  609. * @i: inode that is being unlinked
  610. * @d: dentry that is being unlinked
  611. *
  612. */
  613. static int v9fs_vfs_unlink(struct inode *i, struct dentry *d)
  614. {
  615. return v9fs_remove(i, d, 0);
  616. }
  617. /**
  618. * v9fs_vfs_rmdir - VFS unlink hook to delete a directory
  619. * @i: inode that is being unlinked
  620. * @d: dentry that is being unlinked
  621. *
  622. */
  623. static int v9fs_vfs_rmdir(struct inode *i, struct dentry *d)
  624. {
  625. return v9fs_remove(i, d, 1);
  626. }
  627. /**
  628. * v9fs_vfs_rename - VFS hook to rename an inode
  629. * @old_dir: old dir inode
  630. * @old_dentry: old dentry
  631. * @new_dir: new dir inode
  632. * @new_dentry: new dentry
  633. *
  634. */
  635. static int
  636. v9fs_vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
  637. struct inode *new_dir, struct dentry *new_dentry)
  638. {
  639. struct inode *old_inode = old_dentry->d_inode;
  640. struct v9fs_session_info *v9ses = v9fs_inode2v9ses(old_inode);
  641. struct v9fs_fid *oldfid = v9fs_fid_lookup(old_dentry);
  642. struct v9fs_fid *olddirfid;
  643. struct v9fs_fid *newdirfid;
  644. struct v9fs_wstat wstat;
  645. struct v9fs_fcall *fcall = NULL;
  646. int fid = -1;
  647. int olddirfidnum = -1;
  648. int newdirfidnum = -1;
  649. int retval = 0;
  650. dprintk(DEBUG_VFS, "\n");
  651. if(IS_ERR(oldfid))
  652. return PTR_ERR(oldfid);
  653. olddirfid = v9fs_fid_clone(old_dentry->d_parent);
  654. if(IS_ERR(olddirfid)) {
  655. retval = PTR_ERR(olddirfid);
  656. goto Release_lock;
  657. }
  658. newdirfid = v9fs_fid_clone(new_dentry->d_parent);
  659. if(IS_ERR(newdirfid)) {
  660. retval = PTR_ERR(newdirfid);
  661. goto Clunk_olddir;
  662. }
  663. /* 9P can only handle file rename in the same directory */
  664. if (memcmp(&olddirfid->qid, &newdirfid->qid, sizeof(newdirfid->qid))) {
  665. dprintk(DEBUG_ERROR, "old dir and new dir are different\n");
  666. retval = -EXDEV;
  667. goto Clunk_newdir;
  668. }
  669. fid = oldfid->fid;
  670. olddirfidnum = olddirfid->fid;
  671. newdirfidnum = newdirfid->fid;
  672. if (fid < 0) {
  673. dprintk(DEBUG_ERROR, "no fid for old file #%lu\n",
  674. old_inode->i_ino);
  675. retval = -EBADF;
  676. goto Clunk_newdir;
  677. }
  678. v9fs_blank_wstat(&wstat);
  679. wstat.muid = v9ses->name;
  680. wstat.name = (char *) new_dentry->d_name.name;
  681. retval = v9fs_t_wstat(v9ses, fid, &wstat, &fcall);
  682. if (retval < 0)
  683. PRINT_FCALL_ERROR("wstat error", fcall);
  684. kfree(fcall);
  685. Clunk_newdir:
  686. v9fs_fid_clunk(v9ses, newdirfid);
  687. Clunk_olddir:
  688. v9fs_fid_clunk(v9ses, olddirfid);
  689. Release_lock:
  690. up(&oldfid->lock);
  691. return retval;
  692. }
  693. /**
  694. * v9fs_vfs_getattr - retrieve file metadata
  695. * @mnt - mount information
  696. * @dentry - file to get attributes on
  697. * @stat - metadata structure to populate
  698. *
  699. */
  700. static int
  701. v9fs_vfs_getattr(struct vfsmount *mnt, struct dentry *dentry,
  702. struct kstat *stat)
  703. {
  704. struct v9fs_fcall *fcall = NULL;
  705. struct v9fs_session_info *v9ses = v9fs_inode2v9ses(dentry->d_inode);
  706. struct v9fs_fid *fid = v9fs_fid_clone(dentry);
  707. int err = -EPERM;
  708. dprintk(DEBUG_VFS, "dentry: %p\n", dentry);
  709. if(IS_ERR(fid))
  710. return PTR_ERR(fid);
  711. err = v9fs_t_stat(v9ses, fid->fid, &fcall);
  712. if (err < 0)
  713. dprintk(DEBUG_ERROR, "stat error\n");
  714. else {
  715. v9fs_stat2inode(&fcall->params.rstat.stat, dentry->d_inode,
  716. dentry->d_inode->i_sb);
  717. generic_fillattr(dentry->d_inode, stat);
  718. }
  719. kfree(fcall);
  720. v9fs_fid_clunk(v9ses, fid);
  721. return err;
  722. }
  723. /**
  724. * v9fs_vfs_setattr - set file metadata
  725. * @dentry: file whose metadata to set
  726. * @iattr: metadata assignment structure
  727. *
  728. */
  729. static int v9fs_vfs_setattr(struct dentry *dentry, struct iattr *iattr)
  730. {
  731. struct v9fs_session_info *v9ses = v9fs_inode2v9ses(dentry->d_inode);
  732. struct v9fs_fid *fid = v9fs_fid_clone(dentry);
  733. struct v9fs_fcall *fcall = NULL;
  734. struct v9fs_wstat wstat;
  735. int res = -EPERM;
  736. dprintk(DEBUG_VFS, "\n");
  737. if(IS_ERR(fid))
  738. return PTR_ERR(fid);
  739. v9fs_blank_wstat(&wstat);
  740. if (iattr->ia_valid & ATTR_MODE)
  741. wstat.mode = unixmode2p9mode(v9ses, iattr->ia_mode);
  742. if (iattr->ia_valid & ATTR_MTIME)
  743. wstat.mtime = iattr->ia_mtime.tv_sec;
  744. if (iattr->ia_valid & ATTR_ATIME)
  745. wstat.atime = iattr->ia_atime.tv_sec;
  746. if (iattr->ia_valid & ATTR_SIZE)
  747. wstat.length = iattr->ia_size;
  748. if (v9ses->extended) {
  749. if (iattr->ia_valid & ATTR_UID)
  750. wstat.n_uid = iattr->ia_uid;
  751. if (iattr->ia_valid & ATTR_GID)
  752. wstat.n_gid = iattr->ia_gid;
  753. }
  754. res = v9fs_t_wstat(v9ses, fid->fid, &wstat, &fcall);
  755. if (res < 0)
  756. PRINT_FCALL_ERROR("wstat error", fcall);
  757. kfree(fcall);
  758. if (res >= 0)
  759. res = inode_setattr(dentry->d_inode, iattr);
  760. v9fs_fid_clunk(v9ses, fid);
  761. return res;
  762. }
  763. /**
  764. * v9fs_stat2inode - populate an inode structure with mistat info
  765. * @stat: Plan 9 metadata (mistat) structure
  766. * @inode: inode to populate
  767. * @sb: superblock of filesystem
  768. *
  769. */
  770. void
  771. v9fs_stat2inode(struct v9fs_stat *stat, struct inode *inode,
  772. struct super_block *sb)
  773. {
  774. int n;
  775. char ext[32];
  776. struct v9fs_session_info *v9ses = sb->s_fs_info;
  777. inode->i_nlink = 1;
  778. inode->i_atime.tv_sec = stat->atime;
  779. inode->i_mtime.tv_sec = stat->mtime;
  780. inode->i_ctime.tv_sec = stat->mtime;
  781. inode->i_uid = v9ses->uid;
  782. inode->i_gid = v9ses->gid;
  783. if (v9ses->extended) {
  784. inode->i_uid = stat->n_uid;
  785. inode->i_gid = stat->n_gid;
  786. }
  787. inode->i_mode = p9mode2unixmode(v9ses, stat->mode);
  788. if ((S_ISBLK(inode->i_mode)) || (S_ISCHR(inode->i_mode))) {
  789. char type = 0;
  790. int major = -1;
  791. int minor = -1;
  792. n = stat->extension.len;
  793. if (n > sizeof(ext)-1)
  794. n = sizeof(ext)-1;
  795. memmove(ext, stat->extension.str, n);
  796. ext[n] = 0;
  797. sscanf(ext, "%c %u %u", &type, &major, &minor);
  798. switch (type) {
  799. case 'c':
  800. inode->i_mode &= ~S_IFBLK;
  801. inode->i_mode |= S_IFCHR;
  802. break;
  803. case 'b':
  804. break;
  805. default:
  806. dprintk(DEBUG_ERROR, "Unknown special type %c (%.*s)\n",
  807. type, stat->extension.len, stat->extension.str);
  808. };
  809. inode->i_rdev = MKDEV(major, minor);
  810. } else
  811. inode->i_rdev = 0;
  812. inode->i_size = stat->length;
  813. inode->i_blocks =
  814. (inode->i_size + sb->s_blocksize - 1) >> sb->s_blocksize_bits;
  815. }
  816. /**
  817. * v9fs_qid2ino - convert qid into inode number
  818. * @qid: qid to hash
  819. *
  820. * BUG: potential for inode number collisions?
  821. */
  822. ino_t v9fs_qid2ino(struct v9fs_qid *qid)
  823. {
  824. u64 path = qid->path + 2;
  825. ino_t i = 0;
  826. if (sizeof(ino_t) == sizeof(path))
  827. memcpy(&i, &path, sizeof(ino_t));
  828. else
  829. i = (ino_t) (path ^ (path >> 32));
  830. return i;
  831. }
  832. /**
  833. * v9fs_readlink - read a symlink's location (internal version)
  834. * @dentry: dentry for symlink
  835. * @buffer: buffer to load symlink location into
  836. * @buflen: length of buffer
  837. *
  838. */
  839. static int v9fs_readlink(struct dentry *dentry, char *buffer, int buflen)
  840. {
  841. int retval = -EPERM;
  842. struct v9fs_fcall *fcall = NULL;
  843. struct v9fs_session_info *v9ses = v9fs_inode2v9ses(dentry->d_inode);
  844. struct v9fs_fid *fid = v9fs_fid_clone(dentry);
  845. if(IS_ERR(fid))
  846. return PTR_ERR(fid);
  847. if (!v9ses->extended) {
  848. retval = -EBADF;
  849. dprintk(DEBUG_ERROR, "not extended\n");
  850. goto ClunkFid;
  851. }
  852. dprintk(DEBUG_VFS, " %s\n", dentry->d_name.name);
  853. retval = v9fs_t_stat(v9ses, fid->fid, &fcall);
  854. if (retval < 0) {
  855. dprintk(DEBUG_ERROR, "stat error\n");
  856. goto FreeFcall;
  857. }
  858. if (!fcall) {
  859. retval = -EIO;
  860. goto ClunkFid;
  861. }
  862. if (!(fcall->params.rstat.stat.mode & V9FS_DMSYMLINK)) {
  863. retval = -EINVAL;
  864. goto FreeFcall;
  865. }
  866. /* copy extension buffer into buffer */
  867. if (fcall->params.rstat.stat.extension.len < buflen)
  868. buflen = fcall->params.rstat.stat.extension.len + 1;
  869. memmove(buffer, fcall->params.rstat.stat.extension.str, buflen - 1);
  870. buffer[buflen-1] = 0;
  871. dprintk(DEBUG_ERROR, "%s -> %.*s (%s)\n", dentry->d_name.name, fcall->params.rstat.stat.extension.len,
  872. fcall->params.rstat.stat.extension.str, buffer);
  873. retval = buflen;
  874. FreeFcall:
  875. kfree(fcall);
  876. ClunkFid:
  877. v9fs_fid_clunk(v9ses, fid);
  878. return retval;
  879. }
  880. /**
  881. * v9fs_vfs_readlink - read a symlink's location
  882. * @dentry: dentry for symlink
  883. * @buf: buffer to load symlink location into
  884. * @buflen: length of buffer
  885. *
  886. */
  887. static int v9fs_vfs_readlink(struct dentry *dentry, char __user * buffer,
  888. int buflen)
  889. {
  890. int retval;
  891. int ret;
  892. char *link = __getname();
  893. if (unlikely(!link))
  894. return -ENOMEM;
  895. if (buflen > PATH_MAX)
  896. buflen = PATH_MAX;
  897. dprintk(DEBUG_VFS, " dentry: %s (%p)\n", dentry->d_iname, dentry);
  898. retval = v9fs_readlink(dentry, link, buflen);
  899. if (retval > 0) {
  900. if ((ret = copy_to_user(buffer, link, retval)) != 0) {
  901. dprintk(DEBUG_ERROR, "problem copying to user: %d\n",
  902. ret);
  903. retval = ret;
  904. }
  905. }
  906. __putname(link);
  907. return retval;
  908. }
  909. /**
  910. * v9fs_vfs_follow_link - follow a symlink path
  911. * @dentry: dentry for symlink
  912. * @nd: nameidata
  913. *
  914. */
  915. static void *v9fs_vfs_follow_link(struct dentry *dentry, struct nameidata *nd)
  916. {
  917. int len = 0;
  918. char *link = __getname();
  919. dprintk(DEBUG_VFS, "%s n", dentry->d_name.name);
  920. if (!link)
  921. link = ERR_PTR(-ENOMEM);
  922. else {
  923. len = v9fs_readlink(dentry, link, PATH_MAX);
  924. if (len < 0) {
  925. __putname(link);
  926. link = ERR_PTR(len);
  927. } else
  928. link[len] = 0;
  929. }
  930. nd_set_link(nd, link);
  931. return NULL;
  932. }
  933. /**
  934. * v9fs_vfs_put_link - release a symlink path
  935. * @dentry: dentry for symlink
  936. * @nd: nameidata
  937. *
  938. */
  939. static void v9fs_vfs_put_link(struct dentry *dentry, struct nameidata *nd, void *p)
  940. {
  941. char *s = nd_get_link(nd);
  942. dprintk(DEBUG_VFS, " %s %s\n", dentry->d_name.name, s);
  943. if (!IS_ERR(s))
  944. __putname(s);
  945. }
  946. static int v9fs_vfs_mkspecial(struct inode *dir, struct dentry *dentry,
  947. int mode, const char *extension)
  948. {
  949. int err;
  950. u32 fid, perm;
  951. struct v9fs_session_info *v9ses;
  952. struct v9fs_fid *dfid, *vfid = NULL;
  953. struct inode *inode = NULL;
  954. v9ses = v9fs_inode2v9ses(dir);
  955. if (!v9ses->extended) {
  956. dprintk(DEBUG_ERROR, "not extended\n");
  957. return -EPERM;
  958. }
  959. dfid = v9fs_fid_clone(dentry->d_parent);
  960. if(IS_ERR(dfid)) {
  961. err = PTR_ERR(dfid);
  962. goto error;
  963. }
  964. perm = unixmode2p9mode(v9ses, mode);
  965. err = v9fs_create(v9ses, dfid->fid, (char *) dentry->d_name.name,
  966. perm, V9FS_OREAD, (char *) extension, &fid, NULL, NULL);
  967. if (err)
  968. goto clunk_dfid;
  969. err = v9fs_t_clunk(v9ses, fid);
  970. if (err)
  971. goto clunk_dfid;
  972. vfid = v9fs_clone_walk(v9ses, dfid->fid, dentry);
  973. if (IS_ERR(vfid)) {
  974. err = PTR_ERR(vfid);
  975. vfid = NULL;
  976. goto clunk_dfid;
  977. }
  978. inode = v9fs_inode_from_fid(v9ses, vfid->fid, dir->i_sb);
  979. if (IS_ERR(inode)) {
  980. err = PTR_ERR(inode);
  981. inode = NULL;
  982. goto free_vfid;
  983. }
  984. if(v9ses->cache)
  985. dentry->d_op = &v9fs_cached_dentry_operations;
  986. else
  987. dentry->d_op = &v9fs_dentry_operations;
  988. d_instantiate(dentry, inode);
  989. return 0;
  990. free_vfid:
  991. v9fs_fid_destroy(vfid);
  992. clunk_dfid:
  993. v9fs_fid_clunk(v9ses, dfid);
  994. error:
  995. return err;
  996. }
  997. /**
  998. * v9fs_vfs_symlink - helper function to create symlinks
  999. * @dir: directory inode containing symlink
  1000. * @dentry: dentry for symlink
  1001. * @symname: symlink data
  1002. *
  1003. * See 9P2000.u RFC for more information
  1004. *
  1005. */
  1006. static int
  1007. v9fs_vfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
  1008. {
  1009. dprintk(DEBUG_VFS, " %lu,%s,%s\n", dir->i_ino, dentry->d_name.name,
  1010. symname);
  1011. return v9fs_vfs_mkspecial(dir, dentry, S_IFLNK, symname);
  1012. }
  1013. /**
  1014. * v9fs_vfs_link - create a hardlink
  1015. * @old_dentry: dentry for file to link to
  1016. * @dir: inode destination for new link
  1017. * @dentry: dentry for link
  1018. *
  1019. */
  1020. /* XXX - lots of code dup'd from symlink and creates,
  1021. * figure out a better reuse strategy
  1022. */
  1023. static int
  1024. v9fs_vfs_link(struct dentry *old_dentry, struct inode *dir,
  1025. struct dentry *dentry)
  1026. {
  1027. int retval;
  1028. struct v9fs_session_info *v9ses = v9fs_inode2v9ses(dir);
  1029. struct v9fs_fid *oldfid;
  1030. char *name;
  1031. dprintk(DEBUG_VFS, " %lu,%s,%s\n", dir->i_ino, dentry->d_name.name,
  1032. old_dentry->d_name.name);
  1033. oldfid = v9fs_fid_clone(old_dentry);
  1034. if(IS_ERR(oldfid))
  1035. return PTR_ERR(oldfid);
  1036. name = __getname();
  1037. if (unlikely(!name)) {
  1038. retval = -ENOMEM;
  1039. goto clunk_fid;
  1040. }
  1041. sprintf(name, "%d\n", oldfid->fid);
  1042. retval = v9fs_vfs_mkspecial(dir, dentry, V9FS_DMLINK, name);
  1043. __putname(name);
  1044. clunk_fid:
  1045. v9fs_fid_clunk(v9ses, oldfid);
  1046. return retval;
  1047. }
  1048. /**
  1049. * v9fs_vfs_mknod - create a special file
  1050. * @dir: inode destination for new link
  1051. * @dentry: dentry for file
  1052. * @mode: mode for creation
  1053. * @dev_t: device associated with special file
  1054. *
  1055. */
  1056. static int
  1057. v9fs_vfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev)
  1058. {
  1059. int retval;
  1060. char *name;
  1061. dprintk(DEBUG_VFS, " %lu,%s mode: %x MAJOR: %u MINOR: %u\n", dir->i_ino,
  1062. dentry->d_name.name, mode, MAJOR(rdev), MINOR(rdev));
  1063. if (!new_valid_dev(rdev))
  1064. return -EINVAL;
  1065. name = __getname();
  1066. if (!name)
  1067. return -ENOMEM;
  1068. /* build extension */
  1069. if (S_ISBLK(mode))
  1070. sprintf(name, "b %u %u", MAJOR(rdev), MINOR(rdev));
  1071. else if (S_ISCHR(mode))
  1072. sprintf(name, "c %u %u", MAJOR(rdev), MINOR(rdev));
  1073. else if (S_ISFIFO(mode))
  1074. *name = 0;
  1075. else {
  1076. __putname(name);
  1077. return -EINVAL;
  1078. }
  1079. retval = v9fs_vfs_mkspecial(dir, dentry, mode, name);
  1080. __putname(name);
  1081. return retval;
  1082. }
  1083. static const struct inode_operations v9fs_dir_inode_operations_ext = {
  1084. .create = v9fs_vfs_create,
  1085. .lookup = v9fs_vfs_lookup,
  1086. .symlink = v9fs_vfs_symlink,
  1087. .link = v9fs_vfs_link,
  1088. .unlink = v9fs_vfs_unlink,
  1089. .mkdir = v9fs_vfs_mkdir,
  1090. .rmdir = v9fs_vfs_rmdir,
  1091. .mknod = v9fs_vfs_mknod,
  1092. .rename = v9fs_vfs_rename,
  1093. .readlink = v9fs_vfs_readlink,
  1094. .getattr = v9fs_vfs_getattr,
  1095. .setattr = v9fs_vfs_setattr,
  1096. };
  1097. static const struct inode_operations v9fs_dir_inode_operations = {
  1098. .create = v9fs_vfs_create,
  1099. .lookup = v9fs_vfs_lookup,
  1100. .unlink = v9fs_vfs_unlink,
  1101. .mkdir = v9fs_vfs_mkdir,
  1102. .rmdir = v9fs_vfs_rmdir,
  1103. .mknod = v9fs_vfs_mknod,
  1104. .rename = v9fs_vfs_rename,
  1105. .getattr = v9fs_vfs_getattr,
  1106. .setattr = v9fs_vfs_setattr,
  1107. };
  1108. static const struct inode_operations v9fs_file_inode_operations = {
  1109. .getattr = v9fs_vfs_getattr,
  1110. .setattr = v9fs_vfs_setattr,
  1111. };
  1112. static const struct inode_operations v9fs_symlink_inode_operations = {
  1113. .readlink = v9fs_vfs_readlink,
  1114. .follow_link = v9fs_vfs_follow_link,
  1115. .put_link = v9fs_vfs_put_link,
  1116. .getattr = v9fs_vfs_getattr,
  1117. .setattr = v9fs_vfs_setattr,
  1118. };