namei.c 17 KB

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