开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
namei.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：30k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

namei.c：源码内容
  1. /*
  2.  *  linux/fs/vfat/namei.c
  3.  *
  4.  *  Written 1992,1993 by Werner Almesberger
  5.  *
  6.  *  Windows95/Windows NT compatible extended MSDOS filesystem
  7.  *    by Gordon Chaffee Copyright (C) 1995.  Send bug reports for the
  8.  *    VFAT filesystem to <chaffee@cs.berkeley.edu>.  Specify
  9.  *    what file operation caused you trouble and if you can duplicate
  10.  *    the problem, send a script that demonstrates it.
  11.  *
  12.  *  Short name translation 1999, 2001 by Wolfram Pienkoss <wp@bszh.de>
  13.  *
  14.  *  Support Multibyte character and cleanup by
  15.  *   OGAWA Hirofumi <hirofumi@mail.parknet.co.jp>
  16.  */
  18. #include <linux/module.h>
  20. #include <linux/sched.h>
  21. #include <linux/msdos_fs.h>
  22. #include <linux/nls.h>
  23. #include <linux/kernel.h>
  24. #include <linux/errno.h>
  25. #include <linux/string.h>
  26. #include <linux/ctype.h>
  27. #include <linux/stat.h>
  28. #include <linux/mm.h>
  29. #include <linux/slab.h>
  31. #define DEBUG_LEVEL 0
  32. #if (DEBUG_LEVEL >= 1)
  33. #  define PRINTK1(x) printk x
  34. #else
  35. #  define PRINTK1(x)
  36. #endif
  37. #if (DEBUG_LEVEL >= 2)
  38. #  define PRINTK2(x) printk x
  39. #else
  40. #  define PRINTK2(x)
  41. #endif
  42. #if (DEBUG_LEVEL >= 3)
  43. #  define PRINTK3(x) printk x
  44. #else
  45. #  define PRINTK3(x)
  46. #endif
  48. static int vfat_hashi(struct dentry *parent, struct qstr *qstr);
  49. static int vfat_hash(struct dentry *parent, struct qstr *qstr);
  50. static int vfat_cmpi(struct dentry *dentry, struct qstr *a, struct qstr *b);
  51. static int vfat_cmp(struct dentry *dentry, struct qstr *a, struct qstr *b);
  52. static int vfat_revalidate(struct dentry *dentry, int);
  54. static struct dentry_operations vfat_dentry_ops[4] = {
  55. {
  56. d_hash: vfat_hashi,
  57. d_compare: vfat_cmpi,
  58. },
  59. {
  60. d_revalidate: vfat_revalidate,
  61. d_hash: vfat_hashi,
  62. d_compare: vfat_cmpi,
  63. },
  64. {
  65. d_hash: vfat_hash,
  66. d_compare: vfat_cmp,
  67. },
  68. {
  69. d_revalidate: vfat_revalidate,
  70. d_hash: vfat_hash,
  71. d_compare: vfat_cmp,
  72. }
  73. };
  75. static int vfat_revalidate(struct dentry *dentry, int flags)
  76. {
  77. PRINTK1(("vfat_revalidate: %sn", dentry->d_name.name));
  78. spin_lock(&dcache_lock);
  79. if (dentry->d_time == dentry->d_parent->d_inode->i_version) {
  80. spin_unlock(&dcache_lock);
  81. return 1;
  82. }
  83. spin_unlock(&dcache_lock);
  84. return 0;
  85. }
  87. static int simple_getbool(char *s, int *setval)
  88. {
  89. if (s) {
  90. if (!strcmp(s,"1") || !strcmp(s,"yes") || !strcmp(s,"true")) {
  91. *setval = 1;
  92. } else if (!strcmp(s,"0") || !strcmp(s,"no") || !strcmp(s,"false")) {
  93. *setval = 0;
  94. } else {
  95. return 0;
  96. }
  97. } else {
  98. *setval = 1;
  99. }
  100. return 1;
  101. }
  103. static int parse_options(char *options, struct fat_mount_options *opts)
  104. {
  105. char *this_char,*value,save,*savep;
  106. int ret, val;
  108. opts->unicode_xlate = opts->posixfs = 0;
  109. opts->numtail = 1;
  110. opts->utf8 = 0;
  111. opts->shortname = VFAT_SFN_DISPLAY_LOWER | VFAT_SFN_CREATE_WIN95;
  112. /* for backward compatible */
  113. if (opts->nocase) {
  114. opts->nocase = 0;
  115. opts->shortname = VFAT_SFN_DISPLAY_WIN95
  116.    | VFAT_SFN_CREATE_WIN95;
  117. }
  119. if (!options) return 1;
  120. save = 0;
  121. savep = NULL;
  122. ret = 1;
  123. for (this_char = strtok(options,","); this_char; this_char = strtok(NULL,",")) {
  124. if ((value = strchr(this_char,'=')) != NULL) {
  125. save = *value;
  126. savep = value;
  127. *value++ = 0;
  128. }
  129. if (!strcmp(this_char,"utf8")) {
  130. ret = simple_getbool(value, &val);
  131. if (ret) opts->utf8 = val;
  132. } else if (!strcmp(this_char,"uni_xlate")) {
  133. ret = simple_getbool(value, &val);
  134. if (ret) opts->unicode_xlate = val;
  135. } else if (!strcmp(this_char,"posix")) {
  136. ret = simple_getbool(value, &val);
  137. if (ret) opts->posixfs = val;
  138. } else if (!strcmp(this_char,"nonumtail")) {
  139. ret = simple_getbool(value, &val);
  140. if (ret) {
  141. opts->numtail = !val;
  142. }
  143. } else if (!strcmp(this_char, "shortname")) {
  144. if (!strcmp(value, "lower"))
  145. opts->shortname = VFAT_SFN_DISPLAY_LOWER
  146. | VFAT_SFN_CREATE_WIN95;
  147. else if (!strcmp(value, "win95"))
  148. opts->shortname = VFAT_SFN_DISPLAY_WIN95
  149. | VFAT_SFN_CREATE_WIN95;
  150. else if (!strcmp(value, "winnt"))
  151. opts->shortname = VFAT_SFN_DISPLAY_WINNT
  152. | VFAT_SFN_CREATE_WINNT;
  153. else if (!strcmp(value, "mixed"))
  154. opts->shortname = VFAT_SFN_DISPLAY_WINNT
  155. | VFAT_SFN_CREATE_WIN95;
  156. else
  157. ret = 0;
  158. }
  159. if (this_char != options)
  160. *(this_char-1) = ',';
  161. if (value) {
  162. *savep = save;
  163. }
  164. if (ret == 0) {
  165. return 0;
  166. }
  167. }
  168. if (opts->unicode_xlate) {
  169. opts->utf8 = 0;
  170. }
  171. return 1;
  172. }
  174. static inline unsigned char
  175. vfat_tolower(struct nls_table *t, unsigned char c)
  176. {
  177. unsigned char nc = t->charset2lower[c];
  179. return nc ? nc : c;
  180. }
  182. static inline unsigned char
  183. vfat_toupper(struct nls_table *t, unsigned char c)
  184. {
  185. unsigned char nc = t->charset2upper[c];
  187. return nc ? nc : c;
  188. }
  190. static int
  191. vfat_strnicmp(struct nls_table *t, const unsigned char *s1,
  192. const unsigned char *s2, int len)
  193. {
  194. while(len--)
  195. if (vfat_tolower(t, *s1++) != vfat_tolower(t, *s2++))
  196. return 1;
  198. return 0;
  199. }
  201. /*
  202.  * Compute the hash for the vfat name corresponding to the dentry.
  203.  * Note: if the name is invalid, we leave the hash code unchanged so
  204.  * that the existing dentry can be used. The vfat fs routines will
  205.  * return ENOENT or EINVAL as appropriate.
  206.  */
  207. static int vfat_hash(struct dentry *dentry, struct qstr *qstr)
  208. {
  209. const char *name;
  210. int len;
  212. len = qstr->len;
  213. name = qstr->name;
  214. while (len && name[len-1] == '.')
  215. len--;
  217. qstr->hash = full_name_hash(name, len);
  219. return 0;
  220. }
  222. /*
  223.  * Compute the hash for the vfat name corresponding to the dentry.
  224.  * Note: if the name is invalid, we leave the hash code unchanged so
  225.  * that the existing dentry can be used. The vfat fs routines will
  226.  * return ENOENT or EINVAL as appropriate.
  227.  */
  228. static int vfat_hashi(struct dentry *dentry, struct qstr *qstr)
  229. {
  230. struct nls_table *t = MSDOS_SB(dentry->d_inode->i_sb)->nls_io;
  231. const char *name;
  232. int len;
  233. unsigned long hash;
  235. len = qstr->len;
  236. name = qstr->name;
  237. while (len && name[len-1] == '.')
  238. len--;
  240. hash = init_name_hash();
  241. while (len--)
  242. hash = partial_name_hash(vfat_tolower(t, *name++), hash);
  243. qstr->hash = end_name_hash(hash);
  245. return 0;
  246. }
  248. /*
  249.  * Case insensitive compare of two vfat names.
  250.  */
  251. static int vfat_cmpi(struct dentry *dentry, struct qstr *a, struct qstr *b)
  252. {
  253. struct nls_table *t = MSDOS_SB(dentry->d_inode->i_sb)->nls_io;
  254. int alen, blen;
  256. /* A filename cannot end in '.' or we treat it like it has none */
  257. alen = a->len;
  258. blen = b->len;
  259. while (alen && a->name[alen-1] == '.')
  260. alen--;
  261. while (blen && b->name[blen-1] == '.')
  262. blen--;
  263. if (alen == blen) {
  264. if (vfat_strnicmp(t, a->name, b->name, alen) == 0)
  265. return 0;
  266. }
  267. return 1;
  268. }
  270. /*
  271.  * Case sensitive compare of two vfat names.
  272.  */
  273. static int vfat_cmp(struct dentry *dentry, struct qstr *a, struct qstr *b)
  274. {
  275. int alen, blen;
  277. /* A filename cannot end in '.' or we treat it like it has none */
  278. alen = a->len;
  279. blen = b->len;
  280. while (alen && a->name[alen-1] == '.')
  281. alen--;
  282. while (blen && b->name[blen-1] == '.')
  283. blen--;
  284. if (alen == blen) {
  285. if (strncmp(a->name, b->name, alen) == 0)
  286. return 0;
  287. }
  288. return 1;
  289. }
  291. #ifdef DEBUG
  293. static void dump_fat(struct super_block *sb,int start)
  294. {
  295. printk("[");
  296. while (start) {
  297. printk("%d ",start);
  298. start = fat_access(sb,start,-1);
  299. if (!start) {
  300. printk("ERROR");
  301. break;
  302. }
  303. if (start == -1) break;
  304. }
  305. printk("]n");
  306. }
  308. static void dump_de(struct msdos_dir_entry *de)
  309. {
  310. int i;
  311. unsigned char *p = (unsigned char *) de;
  312. printk("[");
  314. for (i = 0; i < 32; i++, p++) {
  315. printk("%02x ", *p);
  316. }
  317. printk("]n");
  318. }
  320. #endif
  322. /* MS-DOS "device special files" */
  324. static const char *reserved3_names[] = {
  325. "con     ", "prn     ", "nul     ", "aux     ", NULL
  326. };
  328. static const char *reserved4_names[] = {
  329. "com1    ", "com2    ", "com3    ", "com4    ", "com5    ",
  330. "com6    ", "com7    ", "com8    ", "com9    ",
  331. "lpt1    ", "lpt2    ", "lpt3    ", "lpt4    ", "lpt5    ",
  332. "lpt6    ", "lpt7    ", "lpt8    ", "lpt9    ",
  333. NULL };
  336. /* Characters that are undesirable in an MS-DOS file name */
  338. static wchar_t bad_chars[] = {
  339. /*  `*'     `?'     `<'    `>'      `|'     `"'     `:'     `/' */
  340. 0x002A, 0x003F, 0x003C, 0x003E, 0x007C, 0x0022, 0x003A, 0x002F,
  341. /*  `' */
  342. 0x005C, 0,
  343. };
  344. #define IS_BADCHAR(uni) (vfat_unistrchr(bad_chars, (uni)) != NULL)
  346. static wchar_t replace_chars[] = {
  347. /*  `['     `]'    `;'     `,'     `+'      `=' */
  348. 0x005B, 0x005D, 0x003B, 0x002C, 0x002B, 0x003D, 0,
  349. };
  350. #define IS_REPLACECHAR(uni) (vfat_unistrchr(replace_chars, (uni)) != NULL)
  352. static wchar_t skip_chars[] = {
  353. /*  `.'     ` ' */
  354. 0x002E, 0x0020, 0,
  355. };
  356. #define IS_SKIPCHAR(uni) 
  357. ((wchar_t)(uni) == skip_chars[0] || (wchar_t)(uni) == skip_chars[1])
  359. static inline wchar_t *vfat_unistrchr(const wchar_t *s, const wchar_t c)
  360. {
  361. for(; *s != c; ++s)
  362. if (*s == 0)
  363. return NULL;
  364. return (wchar_t *) s;
  365. }
  367. static inline int vfat_is_used_badchars(const wchar_t *s, int len)
  368. {
  369. int i;
  371. for (i = 0; i < len; i++)
  372. if (s[i] < 0x0020 || IS_BADCHAR(s[i]))
  373. return -EINVAL;
  374. return 0;
  375. }
  377. /* Checks the validity of a long MS-DOS filename */
  378. /* Returns negative number on error, 0 for a normal
  379.  * return, and 1 for . or .. */
  381. static int vfat_valid_longname(const char *name, int len, int xlate)
  382. {
  383. const char **reserved, *walk;
  384. int baselen;
  386. if (len && name[len-1] == ' ') return -EINVAL;
  387. if (len >= 256) return -EINVAL;
  388.   if (len < 3) return 0;
  390. for (walk = name; *walk != 0 && *walk != '.'; walk++);
  391. baselen = walk - name;
  393. if (baselen == 3) {
  394. for (reserved = reserved3_names; *reserved; reserved++) {
  395. if (!strnicmp(name,*reserved,baselen))
  396. return -EINVAL;
  397. }
  398. } else if (baselen == 4) {
  399. for (reserved = reserved4_names; *reserved; reserved++) {
  400. if (!strnicmp(name,*reserved,baselen))
  401. return -EINVAL;
  402. }
  403. }
  404. return 0;
  405. }
  407. static int vfat_find_form(struct inode *dir,char *name)
  408. {
  409. struct msdos_dir_entry *de;
  410. struct buffer_head *bh = NULL;
  411. int ino,res;
  413. res=fat_scan(dir,name,&bh,&de,&ino);
  414. fat_brelse(dir->i_sb, bh);
  415. if (res<0)
  416. return -ENOENT;
  417. return 0;
  418. }
  420. /* 
  421.  * 1) Valid characters for the 8.3 format alias are any combination of
  422.  * letters, uppercase alphabets, digits, any of the
  423.  * following special characters:
  424.  *     $ % ' ` - @ { } ~ ! # ( ) & _ ^
  425.  * In this case Longfilename is not stored in disk.
  426.  *
  427.  * WinNT's Extension:
  428.  * File name and extension name is contain uppercase/lowercase
  429.  * only. And it is expressed by CASE_LOWER_BASE and CASE_LOWER_EXT.
  430.  *     
  431.  * 2) File name is 8.3 format, but it contain the uppercase and
  432.  * lowercase char, muliti bytes char, etc. In this case numtail is not
  433.  * added, but Longfilename is stored.
  434.  * 
  435.  * 3) When the one except for the above, or the following special
  436.  * character are contained:
  437.  *        .   [ ] ; , + =
  438.  * numtail is added, and Longfilename must be stored in disk .
  439.  */
  440. struct shortname_info {
  441. unsigned char lower:1,
  442.       upper:1,
  443.       valid:1;
  444. };
  445. #define INIT_SHORTNAME_INFO(x) do {
  446. (x)->lower = 1;
  447. (x)->upper = 1;
  448. (x)->valid = 1;
  449. } while (0);
  451. static inline unsigned char
  452. shortname_info_to_lcase(struct shortname_info *base,
  453. struct shortname_info *ext)
  454. {
  455. unsigned char lcase = 0;
  457. if (base->valid && ext->valid) {
  458. if (!base->upper && base->lower && (ext->lower || ext->upper))
  459. lcase |= CASE_LOWER_BASE;
  460. if (!ext->upper && ext->lower && (base->lower || base->upper))
  461. lcase |= CASE_LOWER_EXT;
  462. }
  464. return lcase;
  465. }
  467. static inline int to_shortname_char(struct nls_table *nls,
  468.     char *buf, int buf_size, wchar_t *src,
  469.     struct shortname_info *info)
  470. {
  471. int len;
  473. if (IS_SKIPCHAR(*src)) {
  474. info->valid = 0;
  475. return 0;
  476. }
  477. if (IS_REPLACECHAR(*src)) {
  478. info->valid = 0;
  479. buf[0] = '_';
  480. return 1;
  481. }
  483. len = nls->uni2char(*src, buf, buf_size);
  484. if (len <= 0) {
  485. info->valid = 0;
  486. buf[0] = '_';
  487. len = 1;
  488. } else if (len == 1) {
  489. unsigned char prev = buf[0];
  491. if (buf[0] >= 0x7F) {
  492. info->lower = 0;
  493. info->upper = 0;
  494. }
  496. buf[0] = vfat_toupper(nls, buf[0]);
  497. if (isalpha(buf[0])) {
  498. if (buf[0] == prev)
  499. info->lower = 0;
  500. else
  501. info->upper = 0;
  502. }
  503. } else {
  504. info->lower = 0;
  505. info->upper = 0;
  506. }
  508. return len;
  509. }
  511. /*
  512.  * Given a valid longname, create a unique shortname.  Make sure the
  513.  * shortname does not exist
  514.  * Returns negative number on error, 0 for a normal
  515.  * return, and 1 for valid shortname
  516.  */
  517. static int vfat_create_shortname(struct inode *dir, struct nls_table *nls,
  518.  wchar_t *uname, int ulen,
  519.  char *name_res, unsigned char *lcase)
  520. {
  521. wchar_t *ip, *ext_start, *end, *name_start;
  522. unsigned char base[9], ext[4], buf[8], *p;
  523. unsigned char charbuf[NLS_MAX_CHARSET_SIZE];
  524. int chl, chi;
  525. int sz = 0, extlen, baselen, i, numtail_baselen, numtail2_baselen;
  526. int is_shortname;
  527. struct shortname_info base_info, ext_info;
  528. unsigned short opt_shortname = MSDOS_SB(dir->i_sb)->options.shortname;
  530. is_shortname = 1;
  531. INIT_SHORTNAME_INFO(&base_info);
  532. INIT_SHORTNAME_INFO(&ext_info);
  534. /* Now, we need to create a shortname from the long name */
  535. ext_start = end = &uname[ulen];
  536. while (--ext_start >= uname) {
  537. if (*ext_start == 0x002E) { /* is `.' */
  538. if (ext_start == end - 1) {
  539. sz = ulen;
  540. ext_start = NULL;
  541. }
  542. break;
  543. }
  544. }
  546. if (ext_start == uname - 1) {
  547. sz = ulen;
  548. ext_start = NULL;
  549. } else if (ext_start) {
  550. /*
  551.  * Names which start with a dot could be just
  552.  * an extension eg. "...test".  In this case Win95
  553.  * uses the extension as the name and sets no extension.
  554.  */
  555. name_start = &uname[0];
  556. while (name_start < ext_start) {
  557. if (!IS_SKIPCHAR(*name_start))
  558. break;
  559. name_start++;
  560. }
  561. if (name_start != ext_start) {
  562. sz = ext_start - uname;
  563. ext_start++;
  564. } else {
  565. sz = ulen;
  566. ext_start=NULL;
  567. }
  568. }
  570. numtail_baselen = 6;
  571. numtail2_baselen = 2;
  572. for (baselen = i = 0, p = base, ip = uname; i < sz; i++, ip++) {
  573. chl = to_shortname_char(nls, charbuf, sizeof(charbuf),
  574. ip, &base_info);
  575. if (chl == 0)
  576. continue;
  578. if (baselen < 2 && (baselen + chl) > 2)
  579. numtail2_baselen = baselen;
  580. if (baselen < 6 && (baselen + chl) > 6)
  581. numtail_baselen = baselen;
  582. for (chi = 0; chi < chl; chi++){
  583. *p++ = charbuf[chi];
  584. baselen++;
  585. if (baselen >= 8)
  586. break;
  587. }
  588. if (baselen >= 8) {
  589. if ((chi < chl - 1) || (ip + 1) - uname < sz)
  590. is_shortname = 0;
  591. break;
  592. }
  593. }
  594. if (baselen == 0) {
  595. return -EINVAL;
  596. }
  598. extlen = 0;
  599. if (ext_start) {
  600. for (p = ext, ip = ext_start; extlen < 3 && ip < end; ip++) {
  601. chl = to_shortname_char(nls, charbuf, sizeof(charbuf),
  602. ip, &ext_info);
  603. if (chl == 0)
  604. continue;
  606. if ((extlen + chl) > 3) {
  607. is_shortname = 0;
  608. break;
  609. }
  610. for (chi = 0; chi < chl; chi++) {
  611. *p++ = charbuf[chi];
  612. extlen++;
  613. }
  614. if (extlen >= 3) {
  615. if (ip + 1 != end)
  616. is_shortname = 0;
  617. break;
  618. }
  619. }
  620. }
  621. ext[extlen] = '';
  622. base[baselen] = '';
  624. /* Yes, it can happen. ".xe5" would do it. */
  625. if (base[0] == DELETED_FLAG)
  626. base[0] = 0x05;
  628. /* OK, at this point we know that base is not longer than 8 symbols,
  629.  * ext is not longer than 3, base is nonempty, both don't contain
  630.  * any bad symbols (lowercase transformed to uppercase).
  631.  */
  633. memset(name_res, ' ', MSDOS_NAME);
  634. memcpy(name_res, base, baselen);
  635. memcpy(name_res + 8, ext, extlen);
  636. *lcase = 0;
  637. if (is_shortname && base_info.valid && ext_info.valid) {
  638. if (vfat_find_form(dir, name_res) == 0)
  639. return -EEXIST;
  641. if (opt_shortname & VFAT_SFN_CREATE_WIN95) {
  642. return (base_info.upper && ext_info.upper);
  643. } else if (opt_shortname & VFAT_SFN_CREATE_WINNT) {
  644. if ((base_info.upper || base_info.lower)
  645.     && (ext_info.upper || ext_info.lower)) {
  646. *lcase = shortname_info_to_lcase(&base_info,
  647.  &ext_info);
  648. return 1;
  649. }
  650. return 0;
  651. } else {
  652. BUG();
  653. }
  654. }
  656. if (MSDOS_SB(dir->i_sb)->options.numtail == 0)
  657. if (vfat_find_form(dir, name_res) < 0)
  658. return 0;
  660. /*
  661.  * Try to find a unique extension.  This used to
  662.  * iterate through all possibilities sequentially,
  663.  * but that gave extremely bad performance.  Windows
  664.  * only tries a few cases before using random
  665.  * values for part of the base.
  666.  */
  668. if (baselen>6) {
  669. baselen = numtail_baselen;
  670. name_res[7] = ' ';
  671. }
  672. name_res[baselen] = '~';
  673. for (i = 1; i < 10; i++) {
  674. name_res[baselen+1] = i + '0';
  675. if (vfat_find_form(dir, name_res) < 0)
  676. return 0;
  677. }
  679. i = jiffies & 0xffff;
  680. sz = (jiffies >> 16) & 0x7;
  681. if (baselen>2) {
  682. baselen = numtail2_baselen;
  683. name_res[7] = ' ';
  684. }
  685. name_res[baselen+4] = '~';
  686. name_res[baselen+5] = '1' + sz;
  687. while (1) {
  688. sprintf(buf, "%04X", i);
  689. memcpy(&name_res[baselen], buf, 4);
  690. if (vfat_find_form(dir, name_res) < 0)
  691. break;
  692. i -= 11;
  693. }
  694. return 0;
  695. }
  697. /* Translate a string, including coded sequences into Unicode */
  698. static int
  699. xlate_to_uni(const char *name, int len, char *outname, int *longlen, int *outlen,
  700.      int escape, int utf8, struct nls_table *nls)
  701. {
  702. const unsigned char *ip;
  703. unsigned char nc;
  704. char *op;
  705. unsigned int ec;
  706. int i, k, fill;
  707. int charlen;
  709. if (utf8) {
  710. *outlen = utf8_mbstowcs((__u16 *) outname, name, PAGE_SIZE);
  711. if (name[len-1] == '.')
  712. *outlen-=2;
  713. op = &outname[*outlen * sizeof(__u16)];
  714. } else {
  715. if (name[len-1] == '.') 
  716. len--;
  717. if (nls) {
  718. for (i = 0, ip = name, op = outname, *outlen = 0;
  719.      i < len && *outlen <= 260; *outlen += 1)
  720. {
  721. if (escape && (*ip == ':')) {
  722. if (i > len - 5)
  723. return -EINVAL;
  724. ec = 0;
  725. for (k = 1; k < 5; k++) {
  726. nc = ip[k];
  727. ec <<= 4;
  728. if (nc >= '0' && nc <= '9') {
  729. ec |= nc - '0';
  730. continue;
  731. }
  732. if (nc >= 'a' && nc <= 'f') {
  733. ec |= nc - ('a' - 10);
  734. continue;
  735. }
  736. if (nc >= 'A' && nc <= 'F') {
  737. ec |= nc - ('A' - 10);
  738. continue;
  739. }
  740. return -EINVAL;
  741. }
  742. *op++ = ec & 0xFF;
  743. *op++ = ec >> 8;
  744. ip += 5;
  745. i += 5;
  746. } else {
  747. if ((charlen = nls->char2uni(ip, len-i, (wchar_t *)op)) < 0)
  748. return -EINVAL;
  749. ip += charlen;
  750. i += charlen;
  751. op += 2;
  752. }
  753. }
  754. } else {
  755. for (i = 0, ip = name, op = outname, *outlen = 0;
  756.      i < len && *outlen <= 260; i++, *outlen += 1)
  757. {
  758. *op++ = *ip++;
  759. *op++ = 0;
  760. }
  761. }
  762. }
  763. if (*outlen > 260)
  764. return -ENAMETOOLONG;
  766. *longlen = *outlen;
  767. if (*outlen % 13) {
  768. *op++ = 0;
  769. *op++ = 0;
  770. *outlen += 1;
  771. if (*outlen % 13) {
  772. fill = 13 - (*outlen % 13);
  773. for (i = 0; i < fill; i++) {
  774. *op++ = 0xff;
  775. *op++ = 0xff;
  776. }
  777. *outlen += fill;
  778. }
  779. }
  781. return 0;
  782. }
  784. static int
  785. vfat_fill_slots(struct inode *dir, struct msdos_dir_slot *ds, const char *name,
  786. int len, int *slots, int is_dir, int uni_xlate)
  787. {
  788. struct nls_table *nls_io, *nls_disk;
  789. wchar_t *uname;
  790. struct msdos_dir_slot *ps;
  791. struct msdos_dir_entry *de;
  792. unsigned long page;
  793. unsigned char cksum, lcase;
  794. char *uniname, msdos_name[MSDOS_NAME];
  795. int res, utf8, slot, ulen, unilen, i;
  796. loff_t offset;
  798. *slots = 0;
  799. utf8 = MSDOS_SB(dir->i_sb)->options.utf8;
  800. nls_io = MSDOS_SB(dir->i_sb)->nls_io;
  801. nls_disk = MSDOS_SB(dir->i_sb)->nls_disk;
  803. if (name[len-1] == '.')
  804. len--;
  805. if(!(page = __get_free_page(GFP_KERNEL)))
  806. return -ENOMEM;
  808. uniname = (char *) page;
  809. res = xlate_to_uni(name, len, uniname, &ulen, &unilen, uni_xlate,
  810.    utf8, nls_io);
  811. if (res < 0)
  812. goto out_free;
  814. uname = (wchar_t *) page;
  815. res = vfat_is_used_badchars(uname, ulen);
  816. if (res < 0)
  817. goto out_free;
  819. res = vfat_create_shortname(dir, nls_disk, uname, ulen,
  820.     msdos_name, &lcase);
  821. if (res < 0)
  822. goto out_free;
  823. else if (res == 1) {
  824. de = (struct msdos_dir_entry *)ds;
  825. res = 0;
  826. goto shortname;
  827. }
  829. /* build the entry of long file name */
  830. *slots = unilen / 13;
  831. for (cksum = i = 0; i < 11; i++) {
  832. cksum = (((cksum&1)<<7)|((cksum&0xfe)>>1)) + msdos_name[i];
  833. }
  834. PRINTK3(("vfat_fill_slots 3: slots=%dn",*slots));
  836. for (ps = ds, slot = *slots; slot > 0; slot--, ps++) {
  837. ps->id = slot;
  838. ps->attr = ATTR_EXT;
  839. ps->reserved = 0;
  840. ps->alias_checksum = cksum;
  841. ps->start = 0;
  842. offset = (slot - 1) * 13;
  843. fatwchar_to16(ps->name0_4, uname + offset, 5);
  844. fatwchar_to16(ps->name5_10, uname + offset + 5, 6);
  845. fatwchar_to16(ps->name11_12, uname + offset + 11, 2);
  846. }
  847. ds[0].id |= 0x40;
  848. de = (struct msdos_dir_entry *) ps;
  850. shortname:
  851. PRINTK3(("vfat_fill_slots 9n"));
  852. /* build the entry of 8.3 alias name */
  853. (*slots)++;
  854. strncpy(de->name, msdos_name, MSDOS_NAME);
  855. de->attr = is_dir ? ATTR_DIR : ATTR_ARCH;
  856. de->lcase = lcase;
  857. de->adate = de->cdate = de->date = 0;
  858. de->ctime_ms = de->ctime = de->time = 0;
  859. de->start = 0;
  860. de->starthi = 0;
  861. de->size = 0;
  863. out_free:
  864. free_page(page);
  865. return res;
  866. }
  868. /* We can't get "." or ".." here - VFS takes care of those cases */
  870. static int vfat_build_slots(struct inode *dir, const char *name, int len,
  871.     struct msdos_dir_slot *ds, int *slots, int is_dir)
  872. {
  873. int res, xlate;
  875. xlate = MSDOS_SB(dir->i_sb)->options.unicode_xlate;
  876. res = vfat_valid_longname(name, len, xlate);
  877. if (res < 0)
  878. return res;
  880. return vfat_fill_slots(dir, ds, name, len, slots, is_dir, xlate);
  881. }
  883. static int vfat_add_entry(struct inode *dir,struct qstr* qname,
  884.   int is_dir, struct vfat_slot_info *sinfo_out,
  885.   struct buffer_head **bh, struct msdos_dir_entry **de)
  886. {
  887. struct super_block *sb = dir->i_sb;
  888. struct msdos_dir_slot *dir_slots;
  889. loff_t offset;
  890. int slots, slot;
  891. int res, len;
  892. struct msdos_dir_entry *dummy_de;
  893. struct buffer_head *dummy_bh;
  894. int dummy_ino;
  895. loff_t dummy;
  897. dir_slots = (struct msdos_dir_slot *)
  898.        kmalloc(sizeof(struct msdos_dir_slot) * MSDOS_SLOTS, GFP_KERNEL);
  899. if (dir_slots == NULL)
  900. return -ENOMEM;
  902. len = qname->len;
  903. while (len && qname->name[len-1] == '.')
  904. len--;
  905. res = fat_search_long(dir, qname->name, len,
  906.       (MSDOS_SB(sb)->options.name_check != 's')
  907.       || !MSDOS_SB(sb)->options.posixfs,
  908.       &dummy, &dummy);
  909. if (res > 0) /* found */
  910. res = -EEXIST;
  911. if (res)
  912. goto cleanup;
  914. res = vfat_build_slots(dir, qname->name, len,
  915.        dir_slots, &slots, is_dir);
  916. if (res < 0)
  917. goto cleanup;
  919. /* build the empty directory entry of number of slots */
  920. offset = fat_add_entries(dir, slots, &dummy_bh, &dummy_de, &dummy_ino);
  921. if (offset < 0) {
  922. res = offset;
  923. goto cleanup;
  924. }
  925. fat_brelse(sb, dummy_bh);
  927. /* Now create the new entry */
  928. *bh = NULL;
  929. for (slot = 0; slot < slots; slot++) {
  930. if (fat_get_entry(dir, &offset, bh, de, &sinfo_out->ino) < 0) {
  931. res = -EIO;
  932. goto cleanup;
  933. }
  934. memcpy(*de, dir_slots + slot, sizeof(struct msdos_dir_slot));
  935. fat_mark_buffer_dirty(sb, *bh);
  936. }
  938. res = 0;
  939. /* update timestamp */
  940. dir->i_ctime = dir->i_mtime = dir->i_atime = CURRENT_TIME;
  941. mark_inode_dirty(dir);
  943. fat_date_unix2dos(dir->i_mtime, &(*de)->time, &(*de)->date);
  944. (*de)->ctime = (*de)->time;
  945. (*de)->adate = (*de)->cdate = (*de)->date;
  947. fat_mark_buffer_dirty(sb, *bh);
  949. /* slots can't be less than 1 */
  950. sinfo_out->long_slots = slots - 1;
  951. sinfo_out->longname_offset =
  952. offset - sizeof(struct msdos_dir_slot) * slots;
  954. cleanup:
  955. kfree(dir_slots);
  956. return res;
  957. }
  959. static int vfat_find(struct inode *dir,struct qstr* qname,
  960. struct vfat_slot_info *sinfo, struct buffer_head **last_bh,
  961. struct msdos_dir_entry **last_de)
  962. {
  963. struct super_block *sb = dir->i_sb;
  964. loff_t offset;
  965. int res,len;
  967. len = qname->len;
  968. while (len && qname->name[len-1] == '.') 
  969. len--;
  970. res = fat_search_long(dir, qname->name, len,
  971. (MSDOS_SB(sb)->options.name_check != 's'),
  972. &offset,&sinfo->longname_offset);
  973. if (res>0) {
  974. sinfo->long_slots = res-1;
  975. if (fat_get_entry(dir,&offset,last_bh,last_de,&sinfo->ino)>=0)
  976. return 0;
  977. res = -EIO;
  978. } 
  979. return res ? res : -ENOENT;
  980. }
  982. struct dentry *vfat_lookup(struct inode *dir,struct dentry *dentry)
  983. {
  984. int res;
  985. struct vfat_slot_info sinfo;
  986. struct inode *inode;
  987. struct dentry *alias;
  988. struct buffer_head *bh = NULL;
  989. struct msdos_dir_entry *de;
  990. int table;
  992. PRINTK2(("vfat_lookup: name=%s, len=%dn", 
  993.  dentry->d_name.name, dentry->d_name.len));
  995. table = (MSDOS_SB(dir->i_sb)->options.name_check == 's') ? 2 : 0;
  996. dentry->d_op = &vfat_dentry_ops[table];
  998. inode = NULL;
  999. res = vfat_find(dir,&dentry->d_name,&sinfo,&bh,&de);
  1000. if (res < 0) {
  1001. table++;
  1002. goto error;
  1003. }
  1004. inode = fat_build_inode(dir->i_sb, de, sinfo.ino, &res);
  1005. fat_brelse(dir->i_sb, bh);
  1006. if (res)
  1007. return ERR_PTR(res);
  1008. alias = d_find_alias(inode);
  1009. if (alias) {
  1010. if (d_invalidate(alias)==0)
  1011. dput(alias);
  1012. else {
  1013. iput(inode);
  1014. return alias;
  1015. }
  1017. }
  1018. error:
  1019. dentry->d_op = &vfat_dentry_ops[table];
  1020. dentry->d_time = dentry->d_parent->d_inode->i_version;
  1021. d_add(dentry,inode);
  1022. return NULL;
  1023. }
  1025. int vfat_create(struct inode *dir,struct dentry* dentry,int mode)
  1026. {
  1027. struct super_block *sb = dir->i_sb;
  1028. struct inode *inode = NULL;
  1029. struct buffer_head *bh = NULL;
  1030. struct msdos_dir_entry *de;
  1031. struct vfat_slot_info sinfo;
  1032. int res;
  1034. res = vfat_add_entry(dir, &dentry->d_name, 0, &sinfo, &bh, &de);
  1035. if (res < 0)
  1036. return res;
  1037. inode = fat_build_inode(sb, de, sinfo.ino, &res);
  1038. fat_brelse(sb, bh);
  1039. if (!inode)
  1040. return res;
  1041. inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
  1042. mark_inode_dirty(inode);
  1043. inode->i_version = ++event;
  1044. dir->i_version = event;
  1045. dentry->d_time = dentry->d_parent->d_inode->i_version;
  1046. d_instantiate(dentry,inode);
  1047. return 0;
  1048. }
  1050. static void vfat_remove_entry(struct inode *dir,struct vfat_slot_info *sinfo,
  1051.      struct buffer_head *bh, struct msdos_dir_entry *de)
  1052. {
  1053. struct super_block *sb = dir->i_sb;
  1054. loff_t offset;
  1055. int i,ino;
  1057. /* remove the shortname */
  1058. dir->i_mtime = CURRENT_TIME;
  1059. dir->i_atime = CURRENT_TIME;
  1060. dir->i_version = ++event;
  1061. mark_inode_dirty(dir);
  1062. de->name[0] = DELETED_FLAG;
  1063. fat_mark_buffer_dirty(sb, bh);
  1064. /* remove the longname */
  1065. offset = sinfo->longname_offset; de = NULL;
  1066. for (i = sinfo->long_slots; i > 0; --i) {
  1067. if (fat_get_entry(dir, &offset, &bh, &de, &ino) < 0)
  1068. continue;
  1069. de->name[0] = DELETED_FLAG;
  1070. de->attr = 0;
  1071. fat_mark_buffer_dirty(sb, bh);
  1072. }
  1073. if (bh) fat_brelse(sb, bh);
  1074. }
  1076. int vfat_rmdir(struct inode *dir,struct dentry* dentry)
  1077. {
  1078. int res;
  1079. struct vfat_slot_info sinfo;
  1080. struct buffer_head *bh = NULL;
  1081. struct msdos_dir_entry *de;
  1083. res = fat_dir_empty(dentry->d_inode);
  1084. if (res)
  1085. return res;
  1087. res = vfat_find(dir,&dentry->d_name,&sinfo, &bh, &de);
  1088. if (res<0)
  1089. return res;
  1090. dentry->d_inode->i_nlink = 0;
  1091. dentry->d_inode->i_mtime = CURRENT_TIME;
  1092. dentry->d_inode->i_atime = CURRENT_TIME;
  1093. fat_detach(dentry->d_inode);
  1094. mark_inode_dirty(dentry->d_inode);
  1095. /* releases bh */
  1096. vfat_remove_entry(dir,&sinfo,bh,de);
  1097. dir->i_nlink--;
  1098. return 0;
  1099. }
  1101. int vfat_unlink(struct inode *dir, struct dentry* dentry)
  1102. {
  1103. int res;
  1104. struct vfat_slot_info sinfo;
  1105. struct buffer_head *bh = NULL;
  1106. struct msdos_dir_entry *de;
  1108. PRINTK1(("vfat_unlink: %sn", dentry->d_name.name));
  1109. res = vfat_find(dir,&dentry->d_name,&sinfo,&bh,&de);
  1110. if (res < 0)
  1111. return res;
  1112. dentry->d_inode->i_nlink = 0;
  1113. dentry->d_inode->i_mtime = CURRENT_TIME;
  1114. dentry->d_inode->i_atime = CURRENT_TIME;
  1115. fat_detach(dentry->d_inode);
  1116. mark_inode_dirty(dentry->d_inode);
  1117. /* releases bh */
  1118. vfat_remove_entry(dir,&sinfo,bh,de);
  1120. return res;
  1121. }
  1124. int vfat_mkdir(struct inode *dir,struct dentry* dentry,int mode)
  1125. {
  1126. struct super_block *sb = dir->i_sb;
  1127. struct inode *inode = NULL;
  1128. struct vfat_slot_info sinfo;
  1129. struct buffer_head *bh = NULL;
  1130. struct msdos_dir_entry *de;
  1131. int res;
  1133. res = vfat_add_entry(dir, &dentry->d_name, 1, &sinfo, &bh, &de);
  1134. if (res < 0)
  1135. return res;
  1136. inode = fat_build_inode(sb, de, sinfo.ino, &res);
  1137. if (!inode)
  1138. goto out;
  1139. inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
  1140. mark_inode_dirty(inode);
  1141. inode->i_version = ++event;
  1142. dir->i_version = event;
  1143. dir->i_nlink++;
  1144. inode->i_nlink = 2; /* no need to mark them dirty */
  1145. res = fat_new_dir(inode, dir, 1);
  1146. if (res < 0)
  1147. goto mkdir_failed;
  1148. dentry->d_time = dentry->d_parent->d_inode->i_version;
  1149. d_instantiate(dentry,inode);
  1150. out:
  1151. fat_brelse(sb, bh);
  1152. return res;
  1154. mkdir_failed:
  1155. inode->i_nlink = 0;
  1156. inode->i_mtime = CURRENT_TIME;
  1157. inode->i_atime = CURRENT_TIME;
  1158. fat_detach(inode);
  1159. mark_inode_dirty(inode);
  1160. /* releases bh */
  1161. vfat_remove_entry(dir,&sinfo,bh,de);
  1162. iput(inode);
  1163. dir->i_nlink--;
  1164. return res;
  1165. }
  1166.  
  1167. int vfat_rename(struct inode *old_dir,struct dentry *old_dentry,
  1168. struct inode *new_dir,struct dentry *new_dentry)
  1169. {
  1170. struct super_block *sb = old_dir->i_sb;
  1171. struct buffer_head *old_bh,*new_bh,*dotdot_bh;
  1172. struct msdos_dir_entry *old_de,*new_de,*dotdot_de;
  1173. int dotdot_ino;
  1174. struct inode *old_inode, *new_inode;
  1175. int res, is_dir;
  1176. struct vfat_slot_info old_sinfo,sinfo;
  1178. old_bh = new_bh = dotdot_bh = NULL;
  1179. old_inode = old_dentry->d_inode;
  1180. new_inode = new_dentry->d_inode;
  1181. res = vfat_find(old_dir,&old_dentry->d_name,&old_sinfo,&old_bh,&old_de);
  1182. PRINTK3(("vfat_rename 2n"));
  1183. if (res < 0) goto rename_done;
  1185. is_dir = S_ISDIR(old_inode->i_mode);
  1187. if (is_dir && (res = fat_scan(old_inode,MSDOS_DOTDOT,&dotdot_bh,
  1188. &dotdot_de,&dotdot_ino)) < 0)
  1189. goto rename_done;
  1191. if (new_dentry->d_inode) {
  1192. res = vfat_find(new_dir,&new_dentry->d_name,&sinfo,&new_bh,
  1193. &new_de);
  1194. if (res < 0 || MSDOS_I(new_inode)->i_location != sinfo.ino) {
  1195. /* WTF??? Cry and fail. */
  1196. printk(KERN_WARNING "vfat_rename: fs corruptedn");
  1197. goto rename_done;
  1198. }
  1200. if (is_dir) {
  1201. res = fat_dir_empty(new_inode);
  1202. if (res)
  1203. goto rename_done;
  1204. }
  1205. fat_detach(new_inode);
  1206. } else {
  1207. res = vfat_add_entry(new_dir,&new_dentry->d_name,is_dir,&sinfo,
  1208. &new_bh,&new_de);
  1209. if (res < 0) goto rename_done;
  1210. }
  1212. new_dir->i_version = ++event;
  1214. /* releases old_bh */
  1215. vfat_remove_entry(old_dir,&old_sinfo,old_bh,old_de);
  1216. old_bh=NULL;
  1217. fat_detach(old_inode);
  1218. fat_attach(old_inode, sinfo.ino);
  1219. mark_inode_dirty(old_inode);
  1221. old_dir->i_version = ++event;
  1222. old_dir->i_ctime = old_dir->i_mtime = CURRENT_TIME;
  1223. mark_inode_dirty(old_dir);
  1224. if (new_inode) {
  1225. new_inode->i_nlink--;
  1226. new_inode->i_ctime=CURRENT_TIME;
  1227. }
  1229. if (is_dir) {
  1230. int start = MSDOS_I(new_dir)->i_logstart;
  1231. dotdot_de->start = CT_LE_W(start);
  1232. dotdot_de->starthi = CT_LE_W(start>>16);
  1233. fat_mark_buffer_dirty(sb, dotdot_bh);
  1234. old_dir->i_nlink--;
  1235. if (new_inode) {
  1236. new_inode->i_nlink--;
  1237. } else {
  1238. new_dir->i_nlink++;
  1239. mark_inode_dirty(new_dir);
  1240. }
  1241. }
  1243. rename_done:
  1244. fat_brelse(sb, dotdot_bh);
  1245. fat_brelse(sb, old_bh);
  1246. fat_brelse(sb, new_bh);
  1247. return res;
  1249. }
  1252. /* Public inode operations for the VFAT fs */
  1253. struct inode_operations vfat_dir_inode_operations = {
  1254. create: vfat_create,
  1255. lookup: vfat_lookup,
  1256. unlink: vfat_unlink,
  1257. mkdir: vfat_mkdir,
  1258. rmdir: vfat_rmdir,
  1259. rename: vfat_rename,
  1260. setattr: fat_notify_change,
  1261. };
  1263. struct super_block *vfat_read_super(struct super_block *sb,void *data,
  1264.     int silent)
  1265. {
  1266. struct super_block *res;
  1267.   
  1268. MSDOS_SB(sb)->options.isvfat = 1;
  1270. res = fat_read_super(sb, data, silent, &vfat_dir_inode_operations);
  1271. if (res == NULL)
  1272. return NULL;
  1274. if (parse_options((char *) data, &(MSDOS_SB(sb)->options))) {
  1275. MSDOS_SB(sb)->options.dotsOK = 0;
  1276. if (MSDOS_SB(sb)->options.posixfs) {
  1277. MSDOS_SB(sb)->options.name_check = 's';
  1278. }
  1279. if (MSDOS_SB(sb)->options.name_check != 's') {
  1280. sb->s_root->d_op = &vfat_dentry_ops[0];
  1281. } else {
  1282. sb->s_root->d_op = &vfat_dentry_ops[2];
  1283. }
  1284. }
  1286. return res;
  1287. }