namei.c 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701
  1. /*
  2. * linux/fs/msdos/namei.c
  3. *
  4. * Written 1992,1993 by Werner Almesberger
  5. * Hidden files 1995 by Albert Cahalan <albert@ccs.neu.edu> <adc@coe.neu.edu>
  6. * Rewritten for constant inumbers 1999 by Al Viro
  7. */
  8. #include <linux/module.h>
  9. #include <linux/time.h>
  10. #include <linux/buffer_head.h>
  11. #include <linux/msdos_fs.h>
  12. #include <linux/smp_lock.h>
  13. /* Characters that are undesirable in an MS-DOS file name */
  14. static unsigned char bad_chars[] = "*?<>|\"";
  15. static unsigned char bad_if_strict[] = "+=,; ";
  16. /***** Formats an MS-DOS file name. Rejects invalid names. */
  17. static int msdos_format_name(const unsigned char *name, int len,
  18. unsigned char *res, struct fat_mount_options *opts)
  19. /*
  20. * name is the proposed name, len is its length, res is
  21. * the resulting name, opts->name_check is either (r)elaxed,
  22. * (n)ormal or (s)trict, opts->dotsOK allows dots at the
  23. * beginning of name (for hidden files)
  24. */
  25. {
  26. unsigned char *walk;
  27. unsigned char c;
  28. int space;
  29. if (name[0] == '.') { /* dotfile because . and .. already done */
  30. if (opts->dotsOK) {
  31. /* Get rid of dot - test for it elsewhere */
  32. name++;
  33. len--;
  34. } else
  35. return -EINVAL;
  36. }
  37. /*
  38. * disallow names that _really_ start with a dot
  39. */
  40. space = 1;
  41. c = 0;
  42. for (walk = res; len && walk - res < 8; walk++) {
  43. c = *name++;
  44. len--;
  45. if (opts->name_check != 'r' && strchr(bad_chars, c))
  46. return -EINVAL;
  47. if (opts->name_check == 's' && strchr(bad_if_strict, c))
  48. return -EINVAL;
  49. if (c >= 'A' && c <= 'Z' && opts->name_check == 's')
  50. return -EINVAL;
  51. if (c < ' ' || c == ':' || c == '\\')
  52. return -EINVAL;
  53. /*
  54. * 0xE5 is legal as a first character, but we must substitute
  55. * 0x05 because 0xE5 marks deleted files. Yes, DOS really
  56. * does this.
  57. * It seems that Microsoft hacked DOS to support non-US
  58. * characters after the 0xE5 character was already in use to
  59. * mark deleted files.
  60. */
  61. if ((res == walk) && (c == 0xE5))
  62. c = 0x05;
  63. if (c == '.')
  64. break;
  65. space = (c == ' ');
  66. *walk = (!opts->nocase && c >= 'a' && c <= 'z') ? c - 32 : c;
  67. }
  68. if (space)
  69. return -EINVAL;
  70. if (opts->name_check == 's' && len && c != '.') {
  71. c = *name++;
  72. len--;
  73. if (c != '.')
  74. return -EINVAL;
  75. }
  76. while (c != '.' && len--)
  77. c = *name++;
  78. if (c == '.') {
  79. while (walk - res < 8)
  80. *walk++ = ' ';
  81. while (len > 0 && walk - res < MSDOS_NAME) {
  82. c = *name++;
  83. len--;
  84. if (opts->name_check != 'r' && strchr(bad_chars, c))
  85. return -EINVAL;
  86. if (opts->name_check == 's' &&
  87. strchr(bad_if_strict, c))
  88. return -EINVAL;
  89. if (c < ' ' || c == ':' || c == '\\')
  90. return -EINVAL;
  91. if (c == '.') {
  92. if (opts->name_check == 's')
  93. return -EINVAL;
  94. break;
  95. }
  96. if (c >= 'A' && c <= 'Z' && opts->name_check == 's')
  97. return -EINVAL;
  98. space = c == ' ';
  99. if (!opts->nocase && c >= 'a' && c <= 'z')
  100. *walk++ = c - 32;
  101. else
  102. *walk++ = c;
  103. }
  104. if (space)
  105. return -EINVAL;
  106. if (opts->name_check == 's' && len)
  107. return -EINVAL;
  108. }
  109. while (walk - res < MSDOS_NAME)
  110. *walk++ = ' ';
  111. return 0;
  112. }
  113. /***** Locates a directory entry. Uses unformatted name. */
  114. static int msdos_find(struct inode *dir, const unsigned char *name, int len,
  115. struct fat_slot_info *sinfo)
  116. {
  117. struct msdos_sb_info *sbi = MSDOS_SB(dir->i_sb);
  118. unsigned char msdos_name[MSDOS_NAME];
  119. int err;
  120. err = msdos_format_name(name, len, msdos_name, &sbi->options);
  121. if (err)
  122. return -ENOENT;
  123. err = fat_scan(dir, msdos_name, sinfo);
  124. if (!err && sbi->options.dotsOK) {
  125. if (name[0] == '.') {
  126. if (!(sinfo->de->attr & ATTR_HIDDEN))
  127. err = -ENOENT;
  128. } else {
  129. if (sinfo->de->attr & ATTR_HIDDEN)
  130. err = -ENOENT;
  131. }
  132. if (err)
  133. brelse(sinfo->bh);
  134. }
  135. return err;
  136. }
  137. /*
  138. * Compute the hash for the msdos name corresponding to the dentry.
  139. * Note: if the name is invalid, we leave the hash code unchanged so
  140. * that the existing dentry can be used. The msdos fs routines will
  141. * return ENOENT or EINVAL as appropriate.
  142. */
  143. static int msdos_hash(struct dentry *dentry, struct qstr *qstr)
  144. {
  145. struct fat_mount_options *options = &MSDOS_SB(dentry->d_sb)->options;
  146. unsigned char msdos_name[MSDOS_NAME];
  147. int error;
  148. error = msdos_format_name(qstr->name, qstr->len, msdos_name, options);
  149. if (!error)
  150. qstr->hash = full_name_hash(msdos_name, MSDOS_NAME);
  151. return 0;
  152. }
  153. /*
  154. * Compare two msdos names. If either of the names are invalid,
  155. * we fall back to doing the standard name comparison.
  156. */
  157. static int msdos_cmp(struct dentry *dentry, struct qstr *a, struct qstr *b)
  158. {
  159. struct fat_mount_options *options = &MSDOS_SB(dentry->d_sb)->options;
  160. unsigned char a_msdos_name[MSDOS_NAME], b_msdos_name[MSDOS_NAME];
  161. int error;
  162. error = msdos_format_name(a->name, a->len, a_msdos_name, options);
  163. if (error)
  164. goto old_compare;
  165. error = msdos_format_name(b->name, b->len, b_msdos_name, options);
  166. if (error)
  167. goto old_compare;
  168. error = memcmp(a_msdos_name, b_msdos_name, MSDOS_NAME);
  169. out:
  170. return error;
  171. old_compare:
  172. error = 1;
  173. if (a->len == b->len)
  174. error = memcmp(a->name, b->name, a->len);
  175. goto out;
  176. }
  177. static struct dentry_operations msdos_dentry_operations = {
  178. .d_hash = msdos_hash,
  179. .d_compare = msdos_cmp,
  180. };
  181. /*
  182. * AV. Wrappers for FAT sb operations. Is it wise?
  183. */
  184. /***** Get inode using directory and name */
  185. static struct dentry *msdos_lookup(struct inode *dir, struct dentry *dentry,
  186. struct nameidata *nd)
  187. {
  188. struct super_block *sb = dir->i_sb;
  189. struct fat_slot_info sinfo;
  190. struct inode *inode = NULL;
  191. int res;
  192. dentry->d_op = &msdos_dentry_operations;
  193. lock_super(sb);
  194. res = msdos_find(dir, dentry->d_name.name, dentry->d_name.len, &sinfo);
  195. if (res == -ENOENT)
  196. goto add;
  197. if (res < 0)
  198. goto out;
  199. inode = fat_build_inode(sb, sinfo.de, sinfo.i_pos);
  200. brelse(sinfo.bh);
  201. if (IS_ERR(inode)) {
  202. res = PTR_ERR(inode);
  203. goto out;
  204. }
  205. add:
  206. res = 0;
  207. dentry = d_splice_alias(inode, dentry);
  208. if (dentry)
  209. dentry->d_op = &msdos_dentry_operations;
  210. out:
  211. unlock_super(sb);
  212. if (!res)
  213. return dentry;
  214. return ERR_PTR(res);
  215. }
  216. /***** Creates a directory entry (name is already formatted). */
  217. static int msdos_add_entry(struct inode *dir, const unsigned char *name,
  218. int is_dir, int is_hid, int cluster,
  219. struct timespec *ts, struct fat_slot_info *sinfo)
  220. {
  221. struct msdos_dir_entry de;
  222. __le16 time, date;
  223. int err;
  224. memcpy(de.name, name, MSDOS_NAME);
  225. de.attr = is_dir ? ATTR_DIR : ATTR_ARCH;
  226. if (is_hid)
  227. de.attr |= ATTR_HIDDEN;
  228. de.lcase = 0;
  229. fat_date_unix2dos(ts->tv_sec, &time, &date);
  230. de.cdate = de.adate = 0;
  231. de.ctime = 0;
  232. de.ctime_cs = 0;
  233. de.time = time;
  234. de.date = date;
  235. de.start = cpu_to_le16(cluster);
  236. de.starthi = cpu_to_le16(cluster >> 16);
  237. de.size = 0;
  238. err = fat_add_entries(dir, &de, 1, sinfo);
  239. if (err)
  240. return err;
  241. dir->i_ctime = dir->i_mtime = *ts;
  242. if (IS_DIRSYNC(dir))
  243. (void)fat_sync_inode(dir);
  244. else
  245. mark_inode_dirty(dir);
  246. return 0;
  247. }
  248. /***** Create a file */
  249. static int msdos_create(struct inode *dir, struct dentry *dentry, int mode,
  250. struct nameidata *nd)
  251. {
  252. struct super_block *sb = dir->i_sb;
  253. struct inode *inode = NULL;
  254. struct fat_slot_info sinfo;
  255. struct timespec ts;
  256. unsigned char msdos_name[MSDOS_NAME];
  257. int err, is_hid;
  258. lock_super(sb);
  259. err = msdos_format_name(dentry->d_name.name, dentry->d_name.len,
  260. msdos_name, &MSDOS_SB(sb)->options);
  261. if (err)
  262. goto out;
  263. is_hid = (dentry->d_name.name[0] == '.') && (msdos_name[0] != '.');
  264. /* Have to do it due to foo vs. .foo conflicts */
  265. if (!fat_scan(dir, msdos_name, &sinfo)) {
  266. brelse(sinfo.bh);
  267. err = -EINVAL;
  268. goto out;
  269. }
  270. ts = CURRENT_TIME_SEC;
  271. err = msdos_add_entry(dir, msdos_name, 0, is_hid, 0, &ts, &sinfo);
  272. if (err)
  273. goto out;
  274. inode = fat_build_inode(sb, sinfo.de, sinfo.i_pos);
  275. brelse(sinfo.bh);
  276. if (IS_ERR(inode)) {
  277. err = PTR_ERR(inode);
  278. goto out;
  279. }
  280. inode->i_mtime = inode->i_atime = inode->i_ctime = ts;
  281. /* timestamp is already written, so mark_inode_dirty() is unneeded. */
  282. d_instantiate(dentry, inode);
  283. out:
  284. unlock_super(sb);
  285. if (!err)
  286. err = fat_flush_inodes(sb, dir, inode);
  287. return err;
  288. }
  289. /***** Remove a directory */
  290. static int msdos_rmdir(struct inode *dir, struct dentry *dentry)
  291. {
  292. struct super_block *sb = dir->i_sb;
  293. struct inode *inode = dentry->d_inode;
  294. struct fat_slot_info sinfo;
  295. int err;
  296. lock_super(sb);
  297. /*
  298. * Check whether the directory is not in use, then check
  299. * whether it is empty.
  300. */
  301. err = fat_dir_empty(inode);
  302. if (err)
  303. goto out;
  304. err = msdos_find(dir, dentry->d_name.name, dentry->d_name.len, &sinfo);
  305. if (err)
  306. goto out;
  307. err = fat_remove_entries(dir, &sinfo); /* and releases bh */
  308. if (err)
  309. goto out;
  310. drop_nlink(dir);
  311. clear_nlink(inode);
  312. inode->i_ctime = CURRENT_TIME_SEC;
  313. fat_detach(inode);
  314. out:
  315. unlock_super(sb);
  316. if (!err)
  317. err = fat_flush_inodes(sb, dir, inode);
  318. return err;
  319. }
  320. /***** Make a directory */
  321. static int msdos_mkdir(struct inode *dir, struct dentry *dentry, int mode)
  322. {
  323. struct super_block *sb = dir->i_sb;
  324. struct fat_slot_info sinfo;
  325. struct inode *inode;
  326. unsigned char msdos_name[MSDOS_NAME];
  327. struct timespec ts;
  328. int err, is_hid, cluster;
  329. lock_super(sb);
  330. err = msdos_format_name(dentry->d_name.name, dentry->d_name.len,
  331. msdos_name, &MSDOS_SB(sb)->options);
  332. if (err)
  333. goto out;
  334. is_hid = (dentry->d_name.name[0] == '.') && (msdos_name[0] != '.');
  335. /* foo vs .foo situation */
  336. if (!fat_scan(dir, msdos_name, &sinfo)) {
  337. brelse(sinfo.bh);
  338. err = -EINVAL;
  339. goto out;
  340. }
  341. ts = CURRENT_TIME_SEC;
  342. cluster = fat_alloc_new_dir(dir, &ts);
  343. if (cluster < 0) {
  344. err = cluster;
  345. goto out;
  346. }
  347. err = msdos_add_entry(dir, msdos_name, 1, is_hid, cluster, &ts, &sinfo);
  348. if (err)
  349. goto out_free;
  350. inc_nlink(dir);
  351. inode = fat_build_inode(sb, sinfo.de, sinfo.i_pos);
  352. brelse(sinfo.bh);
  353. if (IS_ERR(inode)) {
  354. err = PTR_ERR(inode);
  355. /* the directory was completed, just return a error */
  356. goto out;
  357. }
  358. inode->i_nlink = 2;
  359. inode->i_mtime = inode->i_atime = inode->i_ctime = ts;
  360. /* timestamp is already written, so mark_inode_dirty() is unneeded. */
  361. d_instantiate(dentry, inode);
  362. unlock_super(sb);
  363. fat_flush_inodes(sb, dir, inode);
  364. return 0;
  365. out_free:
  366. fat_free_clusters(dir, cluster);
  367. out:
  368. unlock_super(sb);
  369. return err;
  370. }
  371. /***** Unlink a file */
  372. static int msdos_unlink(struct inode *dir, struct dentry *dentry)
  373. {
  374. struct inode *inode = dentry->d_inode;
  375. struct super_block *sb= inode->i_sb;
  376. struct fat_slot_info sinfo;
  377. int err;
  378. lock_super(sb);
  379. err = msdos_find(dir, dentry->d_name.name, dentry->d_name.len, &sinfo);
  380. if (err)
  381. goto out;
  382. err = fat_remove_entries(dir, &sinfo); /* and releases bh */
  383. if (err)
  384. goto out;
  385. clear_nlink(inode);
  386. inode->i_ctime = CURRENT_TIME_SEC;
  387. fat_detach(inode);
  388. out:
  389. unlock_super(sb);
  390. if (!err)
  391. err = fat_flush_inodes(sb, dir, inode);
  392. return err;
  393. }
  394. static int do_msdos_rename(struct inode *old_dir, unsigned char *old_name,
  395. struct dentry *old_dentry,
  396. struct inode *new_dir, unsigned char *new_name,
  397. struct dentry *new_dentry, int is_hid)
  398. {
  399. struct buffer_head *dotdot_bh;
  400. struct msdos_dir_entry *dotdot_de;
  401. struct inode *old_inode, *new_inode;
  402. struct fat_slot_info old_sinfo, sinfo;
  403. struct timespec ts;
  404. loff_t dotdot_i_pos, new_i_pos;
  405. int err, old_attrs, is_dir, update_dotdot, corrupt = 0;
  406. old_sinfo.bh = sinfo.bh = dotdot_bh = NULL;
  407. old_inode = old_dentry->d_inode;
  408. new_inode = new_dentry->d_inode;
  409. err = fat_scan(old_dir, old_name, &old_sinfo);
  410. if (err) {
  411. err = -EIO;
  412. goto out;
  413. }
  414. is_dir = S_ISDIR(old_inode->i_mode);
  415. update_dotdot = (is_dir && old_dir != new_dir);
  416. if (update_dotdot) {
  417. if (fat_get_dotdot_entry(old_inode, &dotdot_bh, &dotdot_de,
  418. &dotdot_i_pos) < 0) {
  419. err = -EIO;
  420. goto out;
  421. }
  422. }
  423. old_attrs = MSDOS_I(old_inode)->i_attrs;
  424. err = fat_scan(new_dir, new_name, &sinfo);
  425. if (!err) {
  426. if (!new_inode) {
  427. /* "foo" -> ".foo" case. just change the ATTR_HIDDEN */
  428. if (sinfo.de != old_sinfo.de) {
  429. err = -EINVAL;
  430. goto out;
  431. }
  432. if (is_hid)
  433. MSDOS_I(old_inode)->i_attrs |= ATTR_HIDDEN;
  434. else
  435. MSDOS_I(old_inode)->i_attrs &= ~ATTR_HIDDEN;
  436. if (IS_DIRSYNC(old_dir)) {
  437. err = fat_sync_inode(old_inode);
  438. if (err) {
  439. MSDOS_I(old_inode)->i_attrs = old_attrs;
  440. goto out;
  441. }
  442. } else
  443. mark_inode_dirty(old_inode);
  444. old_dir->i_version++;
  445. old_dir->i_ctime = old_dir->i_mtime = CURRENT_TIME_SEC;
  446. if (IS_DIRSYNC(old_dir))
  447. (void)fat_sync_inode(old_dir);
  448. else
  449. mark_inode_dirty(old_dir);
  450. goto out;
  451. }
  452. }
  453. ts = CURRENT_TIME_SEC;
  454. if (new_inode) {
  455. if (err)
  456. goto out;
  457. if (is_dir) {
  458. err = fat_dir_empty(new_inode);
  459. if (err)
  460. goto out;
  461. }
  462. new_i_pos = MSDOS_I(new_inode)->i_pos;
  463. fat_detach(new_inode);
  464. } else {
  465. err = msdos_add_entry(new_dir, new_name, is_dir, is_hid, 0,
  466. &ts, &sinfo);
  467. if (err)
  468. goto out;
  469. new_i_pos = sinfo.i_pos;
  470. }
  471. new_dir->i_version++;
  472. fat_detach(old_inode);
  473. fat_attach(old_inode, new_i_pos);
  474. if (is_hid)
  475. MSDOS_I(old_inode)->i_attrs |= ATTR_HIDDEN;
  476. else
  477. MSDOS_I(old_inode)->i_attrs &= ~ATTR_HIDDEN;
  478. if (IS_DIRSYNC(new_dir)) {
  479. err = fat_sync_inode(old_inode);
  480. if (err)
  481. goto error_inode;
  482. } else
  483. mark_inode_dirty(old_inode);
  484. if (update_dotdot) {
  485. int start = MSDOS_I(new_dir)->i_logstart;
  486. dotdot_de->start = cpu_to_le16(start);
  487. dotdot_de->starthi = cpu_to_le16(start >> 16);
  488. mark_buffer_dirty(dotdot_bh);
  489. if (IS_DIRSYNC(new_dir)) {
  490. err = sync_dirty_buffer(dotdot_bh);
  491. if (err)
  492. goto error_dotdot;
  493. }
  494. drop_nlink(old_dir);
  495. if (!new_inode)
  496. inc_nlink(new_dir);
  497. }
  498. err = fat_remove_entries(old_dir, &old_sinfo); /* and releases bh */
  499. old_sinfo.bh = NULL;
  500. if (err)
  501. goto error_dotdot;
  502. old_dir->i_version++;
  503. old_dir->i_ctime = old_dir->i_mtime = ts;
  504. if (IS_DIRSYNC(old_dir))
  505. (void)fat_sync_inode(old_dir);
  506. else
  507. mark_inode_dirty(old_dir);
  508. if (new_inode) {
  509. drop_nlink(new_inode);
  510. if (is_dir)
  511. drop_nlink(new_inode);
  512. new_inode->i_ctime = ts;
  513. }
  514. out:
  515. brelse(sinfo.bh);
  516. brelse(dotdot_bh);
  517. brelse(old_sinfo.bh);
  518. return err;
  519. error_dotdot:
  520. /* data cluster is shared, serious corruption */
  521. corrupt = 1;
  522. if (update_dotdot) {
  523. int start = MSDOS_I(old_dir)->i_logstart;
  524. dotdot_de->start = cpu_to_le16(start);
  525. dotdot_de->starthi = cpu_to_le16(start >> 16);
  526. mark_buffer_dirty(dotdot_bh);
  527. corrupt |= sync_dirty_buffer(dotdot_bh);
  528. }
  529. error_inode:
  530. fat_detach(old_inode);
  531. fat_attach(old_inode, old_sinfo.i_pos);
  532. MSDOS_I(old_inode)->i_attrs = old_attrs;
  533. if (new_inode) {
  534. fat_attach(new_inode, new_i_pos);
  535. if (corrupt)
  536. corrupt |= fat_sync_inode(new_inode);
  537. } else {
  538. /*
  539. * If new entry was not sharing the data cluster, it
  540. * shouldn't be serious corruption.
  541. */
  542. int err2 = fat_remove_entries(new_dir, &sinfo);
  543. if (corrupt)
  544. corrupt |= err2;
  545. sinfo.bh = NULL;
  546. }
  547. if (corrupt < 0) {
  548. fat_fs_panic(new_dir->i_sb,
  549. "%s: Filesystem corrupted (i_pos %lld)",
  550. __func__, sinfo.i_pos);
  551. }
  552. goto out;
  553. }
  554. /***** Rename, a wrapper for rename_same_dir & rename_diff_dir */
  555. static int msdos_rename(struct inode *old_dir, struct dentry *old_dentry,
  556. struct inode *new_dir, struct dentry *new_dentry)
  557. {
  558. struct super_block *sb = old_dir->i_sb;
  559. unsigned char old_msdos_name[MSDOS_NAME], new_msdos_name[MSDOS_NAME];
  560. int err, is_hid;
  561. lock_super(sb);
  562. err = msdos_format_name(old_dentry->d_name.name,
  563. old_dentry->d_name.len, old_msdos_name,
  564. &MSDOS_SB(old_dir->i_sb)->options);
  565. if (err)
  566. goto out;
  567. err = msdos_format_name(new_dentry->d_name.name,
  568. new_dentry->d_name.len, new_msdos_name,
  569. &MSDOS_SB(new_dir->i_sb)->options);
  570. if (err)
  571. goto out;
  572. is_hid =
  573. (new_dentry->d_name.name[0] == '.') && (new_msdos_name[0] != '.');
  574. err = do_msdos_rename(old_dir, old_msdos_name, old_dentry,
  575. new_dir, new_msdos_name, new_dentry, is_hid);
  576. out:
  577. unlock_super(sb);
  578. if (!err)
  579. err = fat_flush_inodes(sb, old_dir, new_dir);
  580. return err;
  581. }
  582. static const struct inode_operations msdos_dir_inode_operations = {
  583. .create = msdos_create,
  584. .lookup = msdos_lookup,
  585. .unlink = msdos_unlink,
  586. .mkdir = msdos_mkdir,
  587. .rmdir = msdos_rmdir,
  588. .rename = msdos_rename,
  589. .setattr = fat_setattr,
  590. .getattr = fat_getattr,
  591. };
  592. static int msdos_fill_super(struct super_block *sb, void *data, int silent)
  593. {
  594. int res;
  595. res = fat_fill_super(sb, data, silent, &msdos_dir_inode_operations, 0);
  596. if (res)
  597. return res;
  598. sb->s_flags |= MS_NOATIME;
  599. sb->s_root->d_op = &msdos_dentry_operations;
  600. return 0;
  601. }
  602. static int msdos_get_sb(struct file_system_type *fs_type,
  603. int flags, const char *dev_name,
  604. void *data, struct vfsmount *mnt)
  605. {
  606. return get_sb_bdev(fs_type, flags, dev_name, data, msdos_fill_super,
  607. mnt);
  608. }
  609. static struct file_system_type msdos_fs_type = {
  610. .owner = THIS_MODULE,
  611. .name = "msdos",
  612. .get_sb = msdos_get_sb,
  613. .kill_sb = kill_block_super,
  614. .fs_flags = FS_REQUIRES_DEV,
  615. };
  616. static int __init init_msdos_fs(void)
  617. {
  618. return register_filesystem(&msdos_fs_type);
  619. }
  620. static void __exit exit_msdos_fs(void)
  621. {
  622. unregister_filesystem(&msdos_fs_type);
  623. }
  624. MODULE_LICENSE("GPL");
  625. MODULE_AUTHOR("Werner Almesberger");
  626. MODULE_DESCRIPTION("MS-DOS filesystem support");
  627. module_init(init_msdos_fs)
  628. module_exit(exit_msdos_fs)