dir.c 35 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * linux/fs/fat/dir.c
  4. *
  5. * directory handling functions for fat-based filesystems
  6. *
  7. * Written 1992,1993 by Werner Almesberger
  8. *
  9. * Hidden files 1995 by Albert Cahalan <[email protected]> <[email protected]>
  10. *
  11. * VFAT extensions by Gordon Chaffee <[email protected]>
  12. * Merged with msdos fs by Henrik Storner <[email protected]>
  13. * Rewritten for constant inumbers. Plugged buffer overrun in readdir(). AV
  14. * Short name translation 1999, 2001 by Wolfram Pienkoss <[email protected]>
  15. */
  16. #include <linux/slab.h>
  17. #include <linux/compat.h>
  18. #include <linux/uaccess.h>
  19. #include <linux/iversion.h>
  20. #include "fat.h"
  21. /*
  22. * Maximum buffer size of short name.
  23. * [(MSDOS_NAME + '.') * max one char + nul]
  24. * For msdos style, ['.' (hidden) + MSDOS_NAME + '.' + nul]
  25. */
  26. #define FAT_MAX_SHORT_SIZE ((MSDOS_NAME + 1) * NLS_MAX_CHARSET_SIZE + 1)
  27. /*
  28. * Maximum buffer size of unicode chars from slots.
  29. * [(max longname slots * 13 (size in a slot) + nul) * sizeof(wchar_t)]
  30. */
  31. #define FAT_MAX_UNI_CHARS ((MSDOS_SLOTS - 1) * 13 + 1)
  32. #define FAT_MAX_UNI_SIZE (FAT_MAX_UNI_CHARS * sizeof(wchar_t))
  33. static inline unsigned char fat_tolower(unsigned char c)
  34. {
  35. return ((c >= 'A') && (c <= 'Z')) ? c+32 : c;
  36. }
  37. static inline loff_t fat_make_i_pos(struct super_block *sb,
  38. struct buffer_head *bh,
  39. struct msdos_dir_entry *de)
  40. {
  41. return ((loff_t)bh->b_blocknr << MSDOS_SB(sb)->dir_per_block_bits)
  42. | (de - (struct msdos_dir_entry *)bh->b_data);
  43. }
  44. static inline void fat_dir_readahead(struct inode *dir, sector_t iblock,
  45. sector_t phys)
  46. {
  47. struct super_block *sb = dir->i_sb;
  48. struct msdos_sb_info *sbi = MSDOS_SB(sb);
  49. struct buffer_head *bh;
  50. int sec;
  51. /* This is not a first sector of cluster, or sec_per_clus == 1 */
  52. if ((iblock & (sbi->sec_per_clus - 1)) || sbi->sec_per_clus == 1)
  53. return;
  54. /* root dir of FAT12/FAT16 */
  55. if (!is_fat32(sbi) && (dir->i_ino == MSDOS_ROOT_INO))
  56. return;
  57. bh = sb_find_get_block(sb, phys);
  58. if (bh == NULL || !buffer_uptodate(bh)) {
  59. for (sec = 0; sec < sbi->sec_per_clus; sec++)
  60. sb_breadahead(sb, phys + sec);
  61. }
  62. brelse(bh);
  63. }
  64. /* Returns the inode number of the directory entry at offset pos. If bh is
  65. non-NULL, it is brelse'd before. Pos is incremented. The buffer header is
  66. returned in bh.
  67. AV. Most often we do it item-by-item. Makes sense to optimize.
  68. AV. OK, there we go: if both bh and de are non-NULL we assume that we just
  69. AV. want the next entry (took one explicit de=NULL in vfat/namei.c).
  70. AV. It's done in fat_get_entry() (inlined), here the slow case lives.
  71. AV. Additionally, when we return -1 (i.e. reached the end of directory)
  72. AV. we make bh NULL.
  73. */
  74. static int fat__get_entry(struct inode *dir, loff_t *pos,
  75. struct buffer_head **bh, struct msdos_dir_entry **de)
  76. {
  77. struct super_block *sb = dir->i_sb;
  78. sector_t phys, iblock;
  79. unsigned long mapped_blocks;
  80. int err, offset;
  81. next:
  82. brelse(*bh);
  83. *bh = NULL;
  84. iblock = *pos >> sb->s_blocksize_bits;
  85. err = fat_bmap(dir, iblock, &phys, &mapped_blocks, 0, false);
  86. if (err || !phys)
  87. return -1; /* beyond EOF or error */
  88. fat_dir_readahead(dir, iblock, phys);
  89. *bh = sb_bread(sb, phys);
  90. if (*bh == NULL) {
  91. fat_msg_ratelimit(sb, KERN_ERR,
  92. "Directory bread(block %llu) failed", (llu)phys);
  93. /* skip this block */
  94. *pos = (iblock + 1) << sb->s_blocksize_bits;
  95. goto next;
  96. }
  97. offset = *pos & (sb->s_blocksize - 1);
  98. *pos += sizeof(struct msdos_dir_entry);
  99. *de = (struct msdos_dir_entry *)((*bh)->b_data + offset);
  100. return 0;
  101. }
  102. static inline int fat_get_entry(struct inode *dir, loff_t *pos,
  103. struct buffer_head **bh,
  104. struct msdos_dir_entry **de)
  105. {
  106. /* Fast stuff first */
  107. if (*bh && *de &&
  108. (*de - (struct msdos_dir_entry *)(*bh)->b_data) <
  109. MSDOS_SB(dir->i_sb)->dir_per_block - 1) {
  110. *pos += sizeof(struct msdos_dir_entry);
  111. (*de)++;
  112. return 0;
  113. }
  114. return fat__get_entry(dir, pos, bh, de);
  115. }
  116. /*
  117. * Convert Unicode 16 to UTF-8, translated Unicode, or ASCII.
  118. * If uni_xlate is enabled and we can't get a 1:1 conversion, use a
  119. * colon as an escape character since it is normally invalid on the vfat
  120. * filesystem. The following four characters are the hexadecimal digits
  121. * of Unicode value. This lets us do a full dump and restore of Unicode
  122. * filenames. We could get into some trouble with long Unicode names,
  123. * but ignore that right now.
  124. * Ahem... Stack smashing in ring 0 isn't fun. Fixed.
  125. */
  126. static int uni16_to_x8(struct super_block *sb, unsigned char *ascii,
  127. const wchar_t *uni, int len, struct nls_table *nls)
  128. {
  129. int uni_xlate = MSDOS_SB(sb)->options.unicode_xlate;
  130. const wchar_t *ip;
  131. wchar_t ec;
  132. unsigned char *op;
  133. int charlen;
  134. ip = uni;
  135. op = ascii;
  136. while (*ip && ((len - NLS_MAX_CHARSET_SIZE) > 0)) {
  137. ec = *ip++;
  138. charlen = nls->uni2char(ec, op, NLS_MAX_CHARSET_SIZE);
  139. if (charlen > 0) {
  140. op += charlen;
  141. len -= charlen;
  142. } else {
  143. if (uni_xlate == 1) {
  144. *op++ = ':';
  145. op = hex_byte_pack(op, ec >> 8);
  146. op = hex_byte_pack(op, ec);
  147. len -= 5;
  148. } else {
  149. *op++ = '?';
  150. len--;
  151. }
  152. }
  153. }
  154. if (unlikely(*ip)) {
  155. fat_msg(sb, KERN_WARNING,
  156. "filename was truncated while converting.");
  157. }
  158. *op = 0;
  159. return op - ascii;
  160. }
  161. static inline int fat_uni_to_x8(struct super_block *sb, const wchar_t *uni,
  162. unsigned char *buf, int size)
  163. {
  164. struct msdos_sb_info *sbi = MSDOS_SB(sb);
  165. if (sbi->options.utf8)
  166. return utf16s_to_utf8s(uni, FAT_MAX_UNI_CHARS,
  167. UTF16_HOST_ENDIAN, buf, size);
  168. else
  169. return uni16_to_x8(sb, buf, uni, size, sbi->nls_io);
  170. }
  171. static inline int
  172. fat_short2uni(struct nls_table *t, unsigned char *c, int clen, wchar_t *uni)
  173. {
  174. int charlen;
  175. charlen = t->char2uni(c, clen, uni);
  176. if (charlen < 0) {
  177. *uni = 0x003f; /* a question mark */
  178. charlen = 1;
  179. }
  180. return charlen;
  181. }
  182. static inline int
  183. fat_short2lower_uni(struct nls_table *t, unsigned char *c,
  184. int clen, wchar_t *uni)
  185. {
  186. int charlen;
  187. wchar_t wc;
  188. charlen = t->char2uni(c, clen, &wc);
  189. if (charlen < 0) {
  190. *uni = 0x003f; /* a question mark */
  191. charlen = 1;
  192. } else if (charlen <= 1) {
  193. unsigned char nc = t->charset2lower[*c];
  194. if (!nc)
  195. nc = *c;
  196. charlen = t->char2uni(&nc, 1, uni);
  197. if (charlen < 0) {
  198. *uni = 0x003f; /* a question mark */
  199. charlen = 1;
  200. }
  201. } else
  202. *uni = wc;
  203. return charlen;
  204. }
  205. static inline int
  206. fat_shortname2uni(struct nls_table *nls, unsigned char *buf, int buf_size,
  207. wchar_t *uni_buf, unsigned short opt, int lower)
  208. {
  209. int len = 0;
  210. if (opt & VFAT_SFN_DISPLAY_LOWER)
  211. len = fat_short2lower_uni(nls, buf, buf_size, uni_buf);
  212. else if (opt & VFAT_SFN_DISPLAY_WIN95)
  213. len = fat_short2uni(nls, buf, buf_size, uni_buf);
  214. else if (opt & VFAT_SFN_DISPLAY_WINNT) {
  215. if (lower)
  216. len = fat_short2lower_uni(nls, buf, buf_size, uni_buf);
  217. else
  218. len = fat_short2uni(nls, buf, buf_size, uni_buf);
  219. } else
  220. len = fat_short2uni(nls, buf, buf_size, uni_buf);
  221. return len;
  222. }
  223. static inline int fat_name_match(struct msdos_sb_info *sbi,
  224. const unsigned char *a, int a_len,
  225. const unsigned char *b, int b_len)
  226. {
  227. if (a_len != b_len)
  228. return 0;
  229. if (sbi->options.name_check != 's')
  230. return !nls_strnicmp(sbi->nls_io, a, b, a_len);
  231. else
  232. return !memcmp(a, b, a_len);
  233. }
  234. enum { PARSE_INVALID = 1, PARSE_NOT_LONGNAME, PARSE_EOF, };
  235. /**
  236. * fat_parse_long - Parse extended directory entry.
  237. *
  238. * This function returns zero on success, negative value on error, or one of
  239. * the following:
  240. *
  241. * %PARSE_INVALID - Directory entry is invalid.
  242. * %PARSE_NOT_LONGNAME - Directory entry does not contain longname.
  243. * %PARSE_EOF - Directory has no more entries.
  244. */
  245. static int fat_parse_long(struct inode *dir, loff_t *pos,
  246. struct buffer_head **bh, struct msdos_dir_entry **de,
  247. wchar_t **unicode, unsigned char *nr_slots)
  248. {
  249. struct msdos_dir_slot *ds;
  250. unsigned char id, slot, slots, alias_checksum;
  251. if (!*unicode) {
  252. *unicode = __getname();
  253. if (!*unicode) {
  254. brelse(*bh);
  255. return -ENOMEM;
  256. }
  257. }
  258. parse_long:
  259. ds = (struct msdos_dir_slot *)*de;
  260. id = ds->id;
  261. if (!(id & 0x40))
  262. return PARSE_INVALID;
  263. slots = id & ~0x40;
  264. if (slots > 20 || !slots) /* ceil(256 * 2 / 26) */
  265. return PARSE_INVALID;
  266. *nr_slots = slots;
  267. alias_checksum = ds->alias_checksum;
  268. slot = slots;
  269. while (1) {
  270. int offset;
  271. slot--;
  272. offset = slot * 13;
  273. fat16_towchar(*unicode + offset, ds->name0_4, 5);
  274. fat16_towchar(*unicode + offset + 5, ds->name5_10, 6);
  275. fat16_towchar(*unicode + offset + 11, ds->name11_12, 2);
  276. if (ds->id & 0x40)
  277. (*unicode)[offset + 13] = 0;
  278. if (fat_get_entry(dir, pos, bh, de) < 0)
  279. return PARSE_EOF;
  280. if (slot == 0)
  281. break;
  282. ds = (struct msdos_dir_slot *)*de;
  283. if (ds->attr != ATTR_EXT)
  284. return PARSE_NOT_LONGNAME;
  285. if ((ds->id & ~0x40) != slot)
  286. goto parse_long;
  287. if (ds->alias_checksum != alias_checksum)
  288. goto parse_long;
  289. }
  290. if ((*de)->name[0] == DELETED_FLAG)
  291. return PARSE_INVALID;
  292. if ((*de)->attr == ATTR_EXT)
  293. goto parse_long;
  294. if (IS_FREE((*de)->name) || ((*de)->attr & ATTR_VOLUME))
  295. return PARSE_INVALID;
  296. if (fat_checksum((*de)->name) != alias_checksum)
  297. *nr_slots = 0;
  298. return 0;
  299. }
  300. /**
  301. * fat_parse_short - Parse MS-DOS (short) directory entry.
  302. * @sb: superblock
  303. * @de: directory entry to parse
  304. * @name: FAT_MAX_SHORT_SIZE array in which to place extracted name
  305. * @dot_hidden: Nonzero == prepend '.' to names with ATTR_HIDDEN
  306. *
  307. * Returns the number of characters extracted into 'name'.
  308. */
  309. static int fat_parse_short(struct super_block *sb,
  310. const struct msdos_dir_entry *de,
  311. unsigned char *name, int dot_hidden)
  312. {
  313. const struct msdos_sb_info *sbi = MSDOS_SB(sb);
  314. int isvfat = sbi->options.isvfat;
  315. int nocase = sbi->options.nocase;
  316. unsigned short opt_shortname = sbi->options.shortname;
  317. struct nls_table *nls_disk = sbi->nls_disk;
  318. wchar_t uni_name[14];
  319. unsigned char c, work[MSDOS_NAME];
  320. unsigned char *ptname = name;
  321. int chi, chl, i, j, k;
  322. int dotoffset = 0;
  323. int name_len = 0, uni_len = 0;
  324. if (!isvfat && dot_hidden && (de->attr & ATTR_HIDDEN)) {
  325. *ptname++ = '.';
  326. dotoffset = 1;
  327. }
  328. memcpy(work, de->name, sizeof(work));
  329. /* For an explanation of the special treatment of 0x05 in
  330. * filenames, see msdos_format_name in namei_msdos.c
  331. */
  332. if (work[0] == 0x05)
  333. work[0] = 0xE5;
  334. /* Filename */
  335. for (i = 0, j = 0; i < 8;) {
  336. c = work[i];
  337. if (!c)
  338. break;
  339. chl = fat_shortname2uni(nls_disk, &work[i], 8 - i,
  340. &uni_name[j++], opt_shortname,
  341. de->lcase & CASE_LOWER_BASE);
  342. if (chl <= 1) {
  343. if (!isvfat)
  344. ptname[i] = nocase ? c : fat_tolower(c);
  345. i++;
  346. if (c != ' ') {
  347. name_len = i;
  348. uni_len = j;
  349. }
  350. } else {
  351. uni_len = j;
  352. if (isvfat)
  353. i += min(chl, 8-i);
  354. else {
  355. for (chi = 0; chi < chl && i < 8; chi++, i++)
  356. ptname[i] = work[i];
  357. }
  358. if (chl)
  359. name_len = i;
  360. }
  361. }
  362. i = name_len;
  363. j = uni_len;
  364. fat_short2uni(nls_disk, ".", 1, &uni_name[j++]);
  365. if (!isvfat)
  366. ptname[i] = '.';
  367. i++;
  368. /* Extension */
  369. for (k = 8; k < MSDOS_NAME;) {
  370. c = work[k];
  371. if (!c)
  372. break;
  373. chl = fat_shortname2uni(nls_disk, &work[k], MSDOS_NAME - k,
  374. &uni_name[j++], opt_shortname,
  375. de->lcase & CASE_LOWER_EXT);
  376. if (chl <= 1) {
  377. k++;
  378. if (!isvfat)
  379. ptname[i] = nocase ? c : fat_tolower(c);
  380. i++;
  381. if (c != ' ') {
  382. name_len = i;
  383. uni_len = j;
  384. }
  385. } else {
  386. uni_len = j;
  387. if (isvfat) {
  388. int offset = min(chl, MSDOS_NAME-k);
  389. k += offset;
  390. i += offset;
  391. } else {
  392. for (chi = 0; chi < chl && k < MSDOS_NAME;
  393. chi++, i++, k++) {
  394. ptname[i] = work[k];
  395. }
  396. }
  397. if (chl)
  398. name_len = i;
  399. }
  400. }
  401. if (name_len > 0) {
  402. name_len += dotoffset;
  403. if (sbi->options.isvfat) {
  404. uni_name[uni_len] = 0x0000;
  405. name_len = fat_uni_to_x8(sb, uni_name, name,
  406. FAT_MAX_SHORT_SIZE);
  407. }
  408. }
  409. return name_len;
  410. }
  411. /*
  412. * Return values: negative -> error/not found, 0 -> found.
  413. */
  414. int fat_search_long(struct inode *inode, const unsigned char *name,
  415. int name_len, struct fat_slot_info *sinfo)
  416. {
  417. struct super_block *sb = inode->i_sb;
  418. struct msdos_sb_info *sbi = MSDOS_SB(sb);
  419. struct buffer_head *bh = NULL;
  420. struct msdos_dir_entry *de;
  421. unsigned char nr_slots;
  422. wchar_t *unicode = NULL;
  423. unsigned char bufname[FAT_MAX_SHORT_SIZE];
  424. loff_t cpos = 0;
  425. int err, len;
  426. err = -ENOENT;
  427. while (1) {
  428. if (fat_get_entry(inode, &cpos, &bh, &de) == -1)
  429. goto end_of_dir;
  430. parse_record:
  431. nr_slots = 0;
  432. if (de->name[0] == DELETED_FLAG)
  433. continue;
  434. if (de->attr != ATTR_EXT && (de->attr & ATTR_VOLUME))
  435. continue;
  436. if (de->attr != ATTR_EXT && IS_FREE(de->name))
  437. continue;
  438. if (de->attr == ATTR_EXT) {
  439. int status = fat_parse_long(inode, &cpos, &bh, &de,
  440. &unicode, &nr_slots);
  441. if (status < 0) {
  442. err = status;
  443. goto end_of_dir;
  444. } else if (status == PARSE_INVALID)
  445. continue;
  446. else if (status == PARSE_NOT_LONGNAME)
  447. goto parse_record;
  448. else if (status == PARSE_EOF)
  449. goto end_of_dir;
  450. }
  451. /* Never prepend '.' to hidden files here.
  452. * That is done only for msdos mounts (and only when
  453. * 'dotsOK=yes'); if we are executing here, it is in the
  454. * context of a vfat mount.
  455. */
  456. len = fat_parse_short(sb, de, bufname, 0);
  457. if (len == 0)
  458. continue;
  459. /* Compare shortname */
  460. if (fat_name_match(sbi, name, name_len, bufname, len))
  461. goto found;
  462. if (nr_slots) {
  463. void *longname = unicode + FAT_MAX_UNI_CHARS;
  464. int size = PATH_MAX - FAT_MAX_UNI_SIZE;
  465. /* Compare longname */
  466. len = fat_uni_to_x8(sb, unicode, longname, size);
  467. if (fat_name_match(sbi, name, name_len, longname, len))
  468. goto found;
  469. }
  470. }
  471. found:
  472. nr_slots++; /* include the de */
  473. sinfo->slot_off = cpos - nr_slots * sizeof(*de);
  474. sinfo->nr_slots = nr_slots;
  475. sinfo->de = de;
  476. sinfo->bh = bh;
  477. sinfo->i_pos = fat_make_i_pos(sb, sinfo->bh, sinfo->de);
  478. err = 0;
  479. end_of_dir:
  480. if (unicode)
  481. __putname(unicode);
  482. return err;
  483. }
  484. EXPORT_SYMBOL_GPL(fat_search_long);
  485. struct fat_ioctl_filldir_callback {
  486. struct dir_context ctx;
  487. void __user *dirent;
  488. int result;
  489. /* for dir ioctl */
  490. const char *longname;
  491. int long_len;
  492. const char *shortname;
  493. int short_len;
  494. };
  495. static int __fat_readdir(struct inode *inode, struct file *file,
  496. struct dir_context *ctx, int short_only,
  497. struct fat_ioctl_filldir_callback *both)
  498. {
  499. struct super_block *sb = inode->i_sb;
  500. struct msdos_sb_info *sbi = MSDOS_SB(sb);
  501. struct buffer_head *bh;
  502. struct msdos_dir_entry *de;
  503. unsigned char nr_slots;
  504. wchar_t *unicode = NULL;
  505. unsigned char bufname[FAT_MAX_SHORT_SIZE];
  506. int isvfat = sbi->options.isvfat;
  507. const char *fill_name = NULL;
  508. int fake_offset = 0;
  509. loff_t cpos;
  510. int short_len = 0, fill_len = 0;
  511. int ret = 0;
  512. mutex_lock(&sbi->s_lock);
  513. cpos = ctx->pos;
  514. /* Fake . and .. for the root directory. */
  515. if (inode->i_ino == MSDOS_ROOT_INO) {
  516. if (!dir_emit_dots(file, ctx))
  517. goto out;
  518. if (ctx->pos == 2) {
  519. fake_offset = 1;
  520. cpos = 0;
  521. }
  522. }
  523. if (cpos & (sizeof(struct msdos_dir_entry) - 1)) {
  524. ret = -ENOENT;
  525. goto out;
  526. }
  527. bh = NULL;
  528. get_new:
  529. if (fat_get_entry(inode, &cpos, &bh, &de) == -1)
  530. goto end_of_dir;
  531. parse_record:
  532. nr_slots = 0;
  533. /*
  534. * Check for long filename entry, but if short_only, we don't
  535. * need to parse long filename.
  536. */
  537. if (isvfat && !short_only) {
  538. if (de->name[0] == DELETED_FLAG)
  539. goto record_end;
  540. if (de->attr != ATTR_EXT && (de->attr & ATTR_VOLUME))
  541. goto record_end;
  542. if (de->attr != ATTR_EXT && IS_FREE(de->name))
  543. goto record_end;
  544. } else {
  545. if ((de->attr & ATTR_VOLUME) || IS_FREE(de->name))
  546. goto record_end;
  547. }
  548. if (isvfat && de->attr == ATTR_EXT) {
  549. int status = fat_parse_long(inode, &cpos, &bh, &de,
  550. &unicode, &nr_slots);
  551. if (status < 0) {
  552. bh = NULL;
  553. ret = status;
  554. goto end_of_dir;
  555. } else if (status == PARSE_INVALID)
  556. goto record_end;
  557. else if (status == PARSE_NOT_LONGNAME)
  558. goto parse_record;
  559. else if (status == PARSE_EOF)
  560. goto end_of_dir;
  561. if (nr_slots) {
  562. void *longname = unicode + FAT_MAX_UNI_CHARS;
  563. int size = PATH_MAX - FAT_MAX_UNI_SIZE;
  564. int len = fat_uni_to_x8(sb, unicode, longname, size);
  565. fill_name = longname;
  566. fill_len = len;
  567. /* !both && !short_only, so we don't need shortname. */
  568. if (!both)
  569. goto start_filldir;
  570. short_len = fat_parse_short(sb, de, bufname,
  571. sbi->options.dotsOK);
  572. if (short_len == 0)
  573. goto record_end;
  574. /* hack for fat_ioctl_filldir() */
  575. both->longname = fill_name;
  576. both->long_len = fill_len;
  577. both->shortname = bufname;
  578. both->short_len = short_len;
  579. fill_name = NULL;
  580. fill_len = 0;
  581. goto start_filldir;
  582. }
  583. }
  584. short_len = fat_parse_short(sb, de, bufname, sbi->options.dotsOK);
  585. if (short_len == 0)
  586. goto record_end;
  587. fill_name = bufname;
  588. fill_len = short_len;
  589. start_filldir:
  590. ctx->pos = cpos - (nr_slots + 1) * sizeof(struct msdos_dir_entry);
  591. if (fake_offset && ctx->pos < 2)
  592. ctx->pos = 2;
  593. if (!memcmp(de->name, MSDOS_DOT, MSDOS_NAME)) {
  594. if (!dir_emit_dot(file, ctx))
  595. goto fill_failed;
  596. } else if (!memcmp(de->name, MSDOS_DOTDOT, MSDOS_NAME)) {
  597. if (!dir_emit_dotdot(file, ctx))
  598. goto fill_failed;
  599. } else {
  600. unsigned long inum;
  601. loff_t i_pos = fat_make_i_pos(sb, bh, de);
  602. struct inode *tmp = fat_iget(sb, i_pos);
  603. if (tmp) {
  604. inum = tmp->i_ino;
  605. iput(tmp);
  606. } else
  607. inum = iunique(sb, MSDOS_ROOT_INO);
  608. if (!dir_emit(ctx, fill_name, fill_len, inum,
  609. (de->attr & ATTR_DIR) ? DT_DIR : DT_REG))
  610. goto fill_failed;
  611. }
  612. record_end:
  613. fake_offset = 0;
  614. ctx->pos = cpos;
  615. goto get_new;
  616. end_of_dir:
  617. if (fake_offset && cpos < 2)
  618. ctx->pos = 2;
  619. else
  620. ctx->pos = cpos;
  621. fill_failed:
  622. brelse(bh);
  623. if (unicode)
  624. __putname(unicode);
  625. out:
  626. mutex_unlock(&sbi->s_lock);
  627. return ret;
  628. }
  629. static int fat_readdir(struct file *file, struct dir_context *ctx)
  630. {
  631. return __fat_readdir(file_inode(file), file, ctx, 0, NULL);
  632. }
  633. #define FAT_IOCTL_FILLDIR_FUNC(func, dirent_type) \
  634. static bool func(struct dir_context *ctx, const char *name, int name_len, \
  635. loff_t offset, u64 ino, unsigned int d_type) \
  636. { \
  637. struct fat_ioctl_filldir_callback *buf = \
  638. container_of(ctx, struct fat_ioctl_filldir_callback, ctx); \
  639. struct dirent_type __user *d1 = buf->dirent; \
  640. struct dirent_type __user *d2 = d1 + 1; \
  641. \
  642. if (buf->result) \
  643. return false; \
  644. buf->result++; \
  645. \
  646. if (name != NULL) { \
  647. /* dirent has only short name */ \
  648. if (name_len >= sizeof(d1->d_name)) \
  649. name_len = sizeof(d1->d_name) - 1; \
  650. \
  651. if (put_user(0, &d2->d_name[0]) || \
  652. put_user(0, &d2->d_reclen) || \
  653. copy_to_user(d1->d_name, name, name_len) || \
  654. put_user(0, d1->d_name + name_len) || \
  655. put_user(name_len, &d1->d_reclen)) \
  656. goto efault; \
  657. } else { \
  658. /* dirent has short and long name */ \
  659. const char *longname = buf->longname; \
  660. int long_len = buf->long_len; \
  661. const char *shortname = buf->shortname; \
  662. int short_len = buf->short_len; \
  663. \
  664. if (long_len >= sizeof(d1->d_name)) \
  665. long_len = sizeof(d1->d_name) - 1; \
  666. if (short_len >= sizeof(d1->d_name)) \
  667. short_len = sizeof(d1->d_name) - 1; \
  668. \
  669. if (copy_to_user(d2->d_name, longname, long_len) || \
  670. put_user(0, d2->d_name + long_len) || \
  671. put_user(long_len, &d2->d_reclen) || \
  672. put_user(ino, &d2->d_ino) || \
  673. put_user(offset, &d2->d_off) || \
  674. copy_to_user(d1->d_name, shortname, short_len) || \
  675. put_user(0, d1->d_name + short_len) || \
  676. put_user(short_len, &d1->d_reclen)) \
  677. goto efault; \
  678. } \
  679. return true; \
  680. efault: \
  681. buf->result = -EFAULT; \
  682. return false; \
  683. }
  684. FAT_IOCTL_FILLDIR_FUNC(fat_ioctl_filldir, __fat_dirent)
  685. static int fat_ioctl_readdir(struct inode *inode, struct file *file,
  686. void __user *dirent, filldir_t filldir,
  687. int short_only, int both)
  688. {
  689. struct fat_ioctl_filldir_callback buf = {
  690. .ctx.actor = filldir,
  691. .dirent = dirent
  692. };
  693. int ret;
  694. buf.dirent = dirent;
  695. buf.result = 0;
  696. inode_lock_shared(inode);
  697. buf.ctx.pos = file->f_pos;
  698. ret = -ENOENT;
  699. if (!IS_DEADDIR(inode)) {
  700. ret = __fat_readdir(inode, file, &buf.ctx,
  701. short_only, both ? &buf : NULL);
  702. file->f_pos = buf.ctx.pos;
  703. }
  704. inode_unlock_shared(inode);
  705. if (ret >= 0)
  706. ret = buf.result;
  707. return ret;
  708. }
  709. static long fat_dir_ioctl(struct file *filp, unsigned int cmd,
  710. unsigned long arg)
  711. {
  712. struct inode *inode = file_inode(filp);
  713. struct __fat_dirent __user *d1 = (struct __fat_dirent __user *)arg;
  714. int short_only, both;
  715. switch (cmd) {
  716. case VFAT_IOCTL_READDIR_SHORT:
  717. short_only = 1;
  718. both = 0;
  719. break;
  720. case VFAT_IOCTL_READDIR_BOTH:
  721. short_only = 0;
  722. both = 1;
  723. break;
  724. default:
  725. return fat_generic_ioctl(filp, cmd, arg);
  726. }
  727. /*
  728. * Yes, we don't need this put_user() absolutely. However old
  729. * code didn't return the right value. So, app use this value,
  730. * in order to check whether it is EOF.
  731. */
  732. if (put_user(0, &d1->d_reclen))
  733. return -EFAULT;
  734. return fat_ioctl_readdir(inode, filp, d1, fat_ioctl_filldir,
  735. short_only, both);
  736. }
  737. #ifdef CONFIG_COMPAT
  738. #define VFAT_IOCTL_READDIR_BOTH32 _IOR('r', 1, struct compat_dirent[2])
  739. #define VFAT_IOCTL_READDIR_SHORT32 _IOR('r', 2, struct compat_dirent[2])
  740. FAT_IOCTL_FILLDIR_FUNC(fat_compat_ioctl_filldir, compat_dirent)
  741. static long fat_compat_dir_ioctl(struct file *filp, unsigned cmd,
  742. unsigned long arg)
  743. {
  744. struct inode *inode = file_inode(filp);
  745. struct compat_dirent __user *d1 = compat_ptr(arg);
  746. int short_only, both;
  747. switch (cmd) {
  748. case VFAT_IOCTL_READDIR_SHORT32:
  749. short_only = 1;
  750. both = 0;
  751. break;
  752. case VFAT_IOCTL_READDIR_BOTH32:
  753. short_only = 0;
  754. both = 1;
  755. break;
  756. default:
  757. return fat_generic_ioctl(filp, cmd, (unsigned long)arg);
  758. }
  759. /*
  760. * Yes, we don't need this put_user() absolutely. However old
  761. * code didn't return the right value. So, app use this value,
  762. * in order to check whether it is EOF.
  763. */
  764. if (put_user(0, &d1->d_reclen))
  765. return -EFAULT;
  766. return fat_ioctl_readdir(inode, filp, d1, fat_compat_ioctl_filldir,
  767. short_only, both);
  768. }
  769. #endif /* CONFIG_COMPAT */
  770. const struct file_operations fat_dir_operations = {
  771. .llseek = generic_file_llseek,
  772. .read = generic_read_dir,
  773. .iterate_shared = fat_readdir,
  774. .unlocked_ioctl = fat_dir_ioctl,
  775. #ifdef CONFIG_COMPAT
  776. .compat_ioctl = fat_compat_dir_ioctl,
  777. #endif
  778. .fsync = fat_file_fsync,
  779. };
  780. static int fat_get_short_entry(struct inode *dir, loff_t *pos,
  781. struct buffer_head **bh,
  782. struct msdos_dir_entry **de)
  783. {
  784. while (fat_get_entry(dir, pos, bh, de) >= 0) {
  785. /* free entry or long name entry or volume label */
  786. if (!IS_FREE((*de)->name) && !((*de)->attr & ATTR_VOLUME))
  787. return 0;
  788. }
  789. return -ENOENT;
  790. }
  791. /*
  792. * The ".." entry can not provide the "struct fat_slot_info" information
  793. * for inode, nor a usable i_pos. So, this function provides some information
  794. * only.
  795. *
  796. * Since this function walks through the on-disk inodes within a directory,
  797. * callers are responsible for taking any locks necessary to prevent the
  798. * directory from changing.
  799. */
  800. int fat_get_dotdot_entry(struct inode *dir, struct buffer_head **bh,
  801. struct msdos_dir_entry **de)
  802. {
  803. loff_t offset = 0;
  804. *de = NULL;
  805. while (fat_get_short_entry(dir, &offset, bh, de) >= 0) {
  806. if (!strncmp((*de)->name, MSDOS_DOTDOT, MSDOS_NAME))
  807. return 0;
  808. }
  809. return -ENOENT;
  810. }
  811. EXPORT_SYMBOL_GPL(fat_get_dotdot_entry);
  812. /* See if directory is empty */
  813. int fat_dir_empty(struct inode *dir)
  814. {
  815. struct buffer_head *bh;
  816. struct msdos_dir_entry *de;
  817. loff_t cpos;
  818. int result = 0;
  819. bh = NULL;
  820. cpos = 0;
  821. while (fat_get_short_entry(dir, &cpos, &bh, &de) >= 0) {
  822. if (strncmp(de->name, MSDOS_DOT , MSDOS_NAME) &&
  823. strncmp(de->name, MSDOS_DOTDOT, MSDOS_NAME)) {
  824. result = -ENOTEMPTY;
  825. break;
  826. }
  827. }
  828. brelse(bh);
  829. return result;
  830. }
  831. EXPORT_SYMBOL_GPL(fat_dir_empty);
  832. /*
  833. * fat_subdirs counts the number of sub-directories of dir. It can be run
  834. * on directories being created.
  835. */
  836. int fat_subdirs(struct inode *dir)
  837. {
  838. struct buffer_head *bh;
  839. struct msdos_dir_entry *de;
  840. loff_t cpos;
  841. int count = 0;
  842. bh = NULL;
  843. cpos = 0;
  844. while (fat_get_short_entry(dir, &cpos, &bh, &de) >= 0) {
  845. if (de->attr & ATTR_DIR)
  846. count++;
  847. }
  848. brelse(bh);
  849. return count;
  850. }
  851. /*
  852. * Scans a directory for a given file (name points to its formatted name).
  853. * Returns an error code or zero.
  854. */
  855. int fat_scan(struct inode *dir, const unsigned char *name,
  856. struct fat_slot_info *sinfo)
  857. {
  858. struct super_block *sb = dir->i_sb;
  859. sinfo->slot_off = 0;
  860. sinfo->bh = NULL;
  861. while (fat_get_short_entry(dir, &sinfo->slot_off, &sinfo->bh,
  862. &sinfo->de) >= 0) {
  863. if (!strncmp(sinfo->de->name, name, MSDOS_NAME)) {
  864. sinfo->slot_off -= sizeof(*sinfo->de);
  865. sinfo->nr_slots = 1;
  866. sinfo->i_pos = fat_make_i_pos(sb, sinfo->bh, sinfo->de);
  867. return 0;
  868. }
  869. }
  870. return -ENOENT;
  871. }
  872. EXPORT_SYMBOL_GPL(fat_scan);
  873. /*
  874. * Scans a directory for a given logstart.
  875. * Returns an error code or zero.
  876. */
  877. int fat_scan_logstart(struct inode *dir, int i_logstart,
  878. struct fat_slot_info *sinfo)
  879. {
  880. struct super_block *sb = dir->i_sb;
  881. sinfo->slot_off = 0;
  882. sinfo->bh = NULL;
  883. while (fat_get_short_entry(dir, &sinfo->slot_off, &sinfo->bh,
  884. &sinfo->de) >= 0) {
  885. if (fat_get_start(MSDOS_SB(sb), sinfo->de) == i_logstart) {
  886. sinfo->slot_off -= sizeof(*sinfo->de);
  887. sinfo->nr_slots = 1;
  888. sinfo->i_pos = fat_make_i_pos(sb, sinfo->bh, sinfo->de);
  889. return 0;
  890. }
  891. }
  892. return -ENOENT;
  893. }
  894. static int __fat_remove_entries(struct inode *dir, loff_t pos, int nr_slots)
  895. {
  896. struct super_block *sb = dir->i_sb;
  897. struct buffer_head *bh;
  898. struct msdos_dir_entry *de, *endp;
  899. int err = 0, orig_slots;
  900. while (nr_slots) {
  901. bh = NULL;
  902. if (fat_get_entry(dir, &pos, &bh, &de) < 0) {
  903. err = -EIO;
  904. break;
  905. }
  906. orig_slots = nr_slots;
  907. endp = (struct msdos_dir_entry *)(bh->b_data + sb->s_blocksize);
  908. while (nr_slots && de < endp) {
  909. de->name[0] = DELETED_FLAG;
  910. de++;
  911. nr_slots--;
  912. }
  913. mark_buffer_dirty_inode(bh, dir);
  914. if (IS_DIRSYNC(dir))
  915. err = sync_dirty_buffer(bh);
  916. brelse(bh);
  917. if (err)
  918. break;
  919. /* pos is *next* de's position, so this does `- sizeof(de)' */
  920. pos += ((orig_slots - nr_slots) * sizeof(*de)) - sizeof(*de);
  921. }
  922. return err;
  923. }
  924. int fat_remove_entries(struct inode *dir, struct fat_slot_info *sinfo)
  925. {
  926. struct super_block *sb = dir->i_sb;
  927. struct msdos_dir_entry *de;
  928. struct buffer_head *bh;
  929. int err = 0, nr_slots;
  930. /*
  931. * First stage: Remove the shortname. By this, the directory
  932. * entry is removed.
  933. */
  934. nr_slots = sinfo->nr_slots;
  935. de = sinfo->de;
  936. sinfo->de = NULL;
  937. bh = sinfo->bh;
  938. sinfo->bh = NULL;
  939. while (nr_slots && de >= (struct msdos_dir_entry *)bh->b_data) {
  940. de->name[0] = DELETED_FLAG;
  941. de--;
  942. nr_slots--;
  943. }
  944. mark_buffer_dirty_inode(bh, dir);
  945. if (IS_DIRSYNC(dir))
  946. err = sync_dirty_buffer(bh);
  947. brelse(bh);
  948. if (err)
  949. return err;
  950. inode_inc_iversion(dir);
  951. if (nr_slots) {
  952. /*
  953. * Second stage: remove the remaining longname slots.
  954. * (This directory entry is already removed, and so return
  955. * the success)
  956. */
  957. err = __fat_remove_entries(dir, sinfo->slot_off, nr_slots);
  958. if (err) {
  959. fat_msg(sb, KERN_WARNING,
  960. "Couldn't remove the long name slots");
  961. }
  962. }
  963. fat_truncate_time(dir, NULL, S_ATIME|S_MTIME);
  964. if (IS_DIRSYNC(dir))
  965. (void)fat_sync_inode(dir);
  966. else
  967. mark_inode_dirty(dir);
  968. return 0;
  969. }
  970. EXPORT_SYMBOL_GPL(fat_remove_entries);
  971. static int fat_zeroed_cluster(struct inode *dir, sector_t blknr, int nr_used,
  972. struct buffer_head **bhs, int nr_bhs)
  973. {
  974. struct super_block *sb = dir->i_sb;
  975. sector_t last_blknr = blknr + MSDOS_SB(sb)->sec_per_clus;
  976. int err, i, n;
  977. /* Zeroing the unused blocks on this cluster */
  978. blknr += nr_used;
  979. n = nr_used;
  980. while (blknr < last_blknr) {
  981. bhs[n] = sb_getblk(sb, blknr);
  982. if (!bhs[n]) {
  983. err = -ENOMEM;
  984. goto error;
  985. }
  986. /* Avoid race with userspace read via bdev */
  987. lock_buffer(bhs[n]);
  988. memset(bhs[n]->b_data, 0, sb->s_blocksize);
  989. set_buffer_uptodate(bhs[n]);
  990. unlock_buffer(bhs[n]);
  991. mark_buffer_dirty_inode(bhs[n], dir);
  992. n++;
  993. blknr++;
  994. if (n == nr_bhs) {
  995. if (IS_DIRSYNC(dir)) {
  996. err = fat_sync_bhs(bhs, n);
  997. if (err)
  998. goto error;
  999. }
  1000. for (i = 0; i < n; i++)
  1001. brelse(bhs[i]);
  1002. n = 0;
  1003. }
  1004. }
  1005. if (IS_DIRSYNC(dir)) {
  1006. err = fat_sync_bhs(bhs, n);
  1007. if (err)
  1008. goto error;
  1009. }
  1010. for (i = 0; i < n; i++)
  1011. brelse(bhs[i]);
  1012. return 0;
  1013. error:
  1014. for (i = 0; i < n; i++)
  1015. bforget(bhs[i]);
  1016. return err;
  1017. }
  1018. int fat_alloc_new_dir(struct inode *dir, struct timespec64 *ts)
  1019. {
  1020. struct super_block *sb = dir->i_sb;
  1021. struct msdos_sb_info *sbi = MSDOS_SB(sb);
  1022. struct buffer_head *bhs[MAX_BUF_PER_PAGE];
  1023. struct msdos_dir_entry *de;
  1024. sector_t blknr;
  1025. __le16 date, time;
  1026. u8 time_cs;
  1027. int err, cluster;
  1028. err = fat_alloc_clusters(dir, &cluster, 1);
  1029. if (err)
  1030. goto error;
  1031. blknr = fat_clus_to_blknr(sbi, cluster);
  1032. bhs[0] = sb_getblk(sb, blknr);
  1033. if (!bhs[0]) {
  1034. err = -ENOMEM;
  1035. goto error_free;
  1036. }
  1037. fat_time_unix2fat(sbi, ts, &time, &date, &time_cs);
  1038. de = (struct msdos_dir_entry *)bhs[0]->b_data;
  1039. /* Avoid race with userspace read via bdev */
  1040. lock_buffer(bhs[0]);
  1041. /* filling the new directory slots ("." and ".." entries) */
  1042. memcpy(de[0].name, MSDOS_DOT, MSDOS_NAME);
  1043. memcpy(de[1].name, MSDOS_DOTDOT, MSDOS_NAME);
  1044. de->attr = de[1].attr = ATTR_DIR;
  1045. de[0].lcase = de[1].lcase = 0;
  1046. de[0].time = de[1].time = time;
  1047. de[0].date = de[1].date = date;
  1048. if (sbi->options.isvfat) {
  1049. /* extra timestamps */
  1050. de[0].ctime = de[1].ctime = time;
  1051. de[0].ctime_cs = de[1].ctime_cs = time_cs;
  1052. de[0].adate = de[0].cdate = de[1].adate = de[1].cdate = date;
  1053. } else {
  1054. de[0].ctime = de[1].ctime = 0;
  1055. de[0].ctime_cs = de[1].ctime_cs = 0;
  1056. de[0].adate = de[0].cdate = de[1].adate = de[1].cdate = 0;
  1057. }
  1058. fat_set_start(&de[0], cluster);
  1059. fat_set_start(&de[1], MSDOS_I(dir)->i_logstart);
  1060. de[0].size = de[1].size = 0;
  1061. memset(de + 2, 0, sb->s_blocksize - 2 * sizeof(*de));
  1062. set_buffer_uptodate(bhs[0]);
  1063. unlock_buffer(bhs[0]);
  1064. mark_buffer_dirty_inode(bhs[0], dir);
  1065. err = fat_zeroed_cluster(dir, blknr, 1, bhs, MAX_BUF_PER_PAGE);
  1066. if (err)
  1067. goto error_free;
  1068. return cluster;
  1069. error_free:
  1070. fat_free_clusters(dir, cluster);
  1071. error:
  1072. return err;
  1073. }
  1074. EXPORT_SYMBOL_GPL(fat_alloc_new_dir);
  1075. static int fat_add_new_entries(struct inode *dir, void *slots, int nr_slots,
  1076. int *nr_cluster, struct msdos_dir_entry **de,
  1077. struct buffer_head **bh, loff_t *i_pos)
  1078. {
  1079. struct super_block *sb = dir->i_sb;
  1080. struct msdos_sb_info *sbi = MSDOS_SB(sb);
  1081. struct buffer_head *bhs[MAX_BUF_PER_PAGE];
  1082. sector_t blknr, start_blknr, last_blknr;
  1083. unsigned long size, copy;
  1084. int err, i, n, offset, cluster[2];
  1085. /*
  1086. * The minimum cluster size is 512bytes, and maximum entry
  1087. * size is 32*slots (672bytes). So, iff the cluster size is
  1088. * 512bytes, we may need two clusters.
  1089. */
  1090. size = nr_slots * sizeof(struct msdos_dir_entry);
  1091. *nr_cluster = (size + (sbi->cluster_size - 1)) >> sbi->cluster_bits;
  1092. BUG_ON(*nr_cluster > 2);
  1093. err = fat_alloc_clusters(dir, cluster, *nr_cluster);
  1094. if (err)
  1095. goto error;
  1096. /*
  1097. * First stage: Fill the directory entry. NOTE: This cluster
  1098. * is not referenced from any inode yet, so updates order is
  1099. * not important.
  1100. */
  1101. i = n = copy = 0;
  1102. do {
  1103. start_blknr = blknr = fat_clus_to_blknr(sbi, cluster[i]);
  1104. last_blknr = start_blknr + sbi->sec_per_clus;
  1105. while (blknr < last_blknr) {
  1106. bhs[n] = sb_getblk(sb, blknr);
  1107. if (!bhs[n]) {
  1108. err = -ENOMEM;
  1109. goto error_nomem;
  1110. }
  1111. /* fill the directory entry */
  1112. copy = min(size, sb->s_blocksize);
  1113. /* Avoid race with userspace read via bdev */
  1114. lock_buffer(bhs[n]);
  1115. memcpy(bhs[n]->b_data, slots, copy);
  1116. set_buffer_uptodate(bhs[n]);
  1117. unlock_buffer(bhs[n]);
  1118. mark_buffer_dirty_inode(bhs[n], dir);
  1119. slots += copy;
  1120. size -= copy;
  1121. if (!size)
  1122. break;
  1123. n++;
  1124. blknr++;
  1125. }
  1126. } while (++i < *nr_cluster);
  1127. memset(bhs[n]->b_data + copy, 0, sb->s_blocksize - copy);
  1128. offset = copy - sizeof(struct msdos_dir_entry);
  1129. get_bh(bhs[n]);
  1130. *bh = bhs[n];
  1131. *de = (struct msdos_dir_entry *)((*bh)->b_data + offset);
  1132. *i_pos = fat_make_i_pos(sb, *bh, *de);
  1133. /* Second stage: clear the rest of cluster, and write outs */
  1134. err = fat_zeroed_cluster(dir, start_blknr, ++n, bhs, MAX_BUF_PER_PAGE);
  1135. if (err)
  1136. goto error_free;
  1137. return cluster[0];
  1138. error_free:
  1139. brelse(*bh);
  1140. *bh = NULL;
  1141. n = 0;
  1142. error_nomem:
  1143. for (i = 0; i < n; i++)
  1144. bforget(bhs[i]);
  1145. fat_free_clusters(dir, cluster[0]);
  1146. error:
  1147. return err;
  1148. }
  1149. int fat_add_entries(struct inode *dir, void *slots, int nr_slots,
  1150. struct fat_slot_info *sinfo)
  1151. {
  1152. struct super_block *sb = dir->i_sb;
  1153. struct msdos_sb_info *sbi = MSDOS_SB(sb);
  1154. struct buffer_head *bh, *prev, *bhs[3]; /* 32*slots (672bytes) */
  1155. struct msdos_dir_entry *de;
  1156. int err, free_slots, i, nr_bhs;
  1157. loff_t pos, i_pos;
  1158. sinfo->nr_slots = nr_slots;
  1159. /* First stage: search free directory entries */
  1160. free_slots = nr_bhs = 0;
  1161. bh = prev = NULL;
  1162. pos = 0;
  1163. err = -ENOSPC;
  1164. while (fat_get_entry(dir, &pos, &bh, &de) > -1) {
  1165. /* check the maximum size of directory */
  1166. if (pos >= FAT_MAX_DIR_SIZE)
  1167. goto error;
  1168. if (IS_FREE(de->name)) {
  1169. if (prev != bh) {
  1170. get_bh(bh);
  1171. bhs[nr_bhs] = prev = bh;
  1172. nr_bhs++;
  1173. }
  1174. free_slots++;
  1175. if (free_slots == nr_slots)
  1176. goto found;
  1177. } else {
  1178. for (i = 0; i < nr_bhs; i++)
  1179. brelse(bhs[i]);
  1180. prev = NULL;
  1181. free_slots = nr_bhs = 0;
  1182. }
  1183. }
  1184. if (dir->i_ino == MSDOS_ROOT_INO) {
  1185. if (!is_fat32(sbi))
  1186. goto error;
  1187. } else if (MSDOS_I(dir)->i_start == 0) {
  1188. fat_msg(sb, KERN_ERR, "Corrupted directory (i_pos %lld)",
  1189. MSDOS_I(dir)->i_pos);
  1190. err = -EIO;
  1191. goto error;
  1192. }
  1193. found:
  1194. err = 0;
  1195. pos -= free_slots * sizeof(*de);
  1196. nr_slots -= free_slots;
  1197. if (free_slots) {
  1198. /*
  1199. * Second stage: filling the free entries with new entries.
  1200. * NOTE: If this slots has shortname, first, we write
  1201. * the long name slots, then write the short name.
  1202. */
  1203. int size = free_slots * sizeof(*de);
  1204. int offset = pos & (sb->s_blocksize - 1);
  1205. int long_bhs = nr_bhs - (nr_slots == 0);
  1206. /* Fill the long name slots. */
  1207. for (i = 0; i < long_bhs; i++) {
  1208. int copy = min_t(int, sb->s_blocksize - offset, size);
  1209. memcpy(bhs[i]->b_data + offset, slots, copy);
  1210. mark_buffer_dirty_inode(bhs[i], dir);
  1211. offset = 0;
  1212. slots += copy;
  1213. size -= copy;
  1214. }
  1215. if (long_bhs && IS_DIRSYNC(dir))
  1216. err = fat_sync_bhs(bhs, long_bhs);
  1217. if (!err && i < nr_bhs) {
  1218. /* Fill the short name slot. */
  1219. int copy = min_t(int, sb->s_blocksize - offset, size);
  1220. memcpy(bhs[i]->b_data + offset, slots, copy);
  1221. mark_buffer_dirty_inode(bhs[i], dir);
  1222. if (IS_DIRSYNC(dir))
  1223. err = sync_dirty_buffer(bhs[i]);
  1224. }
  1225. for (i = 0; i < nr_bhs; i++)
  1226. brelse(bhs[i]);
  1227. if (err)
  1228. goto error_remove;
  1229. }
  1230. if (nr_slots) {
  1231. int cluster, nr_cluster;
  1232. /*
  1233. * Third stage: allocate the cluster for new entries.
  1234. * And initialize the cluster with new entries, then
  1235. * add the cluster to dir.
  1236. */
  1237. cluster = fat_add_new_entries(dir, slots, nr_slots, &nr_cluster,
  1238. &de, &bh, &i_pos);
  1239. if (cluster < 0) {
  1240. err = cluster;
  1241. goto error_remove;
  1242. }
  1243. err = fat_chain_add(dir, cluster, nr_cluster);
  1244. if (err) {
  1245. fat_free_clusters(dir, cluster);
  1246. goto error_remove;
  1247. }
  1248. if (dir->i_size & (sbi->cluster_size - 1)) {
  1249. fat_fs_error(sb, "Odd directory size");
  1250. dir->i_size = (dir->i_size + sbi->cluster_size - 1)
  1251. & ~((loff_t)sbi->cluster_size - 1);
  1252. }
  1253. dir->i_size += nr_cluster << sbi->cluster_bits;
  1254. MSDOS_I(dir)->mmu_private += nr_cluster << sbi->cluster_bits;
  1255. }
  1256. sinfo->slot_off = pos;
  1257. sinfo->de = de;
  1258. sinfo->bh = bh;
  1259. sinfo->i_pos = fat_make_i_pos(sb, sinfo->bh, sinfo->de);
  1260. return 0;
  1261. error:
  1262. brelse(bh);
  1263. for (i = 0; i < nr_bhs; i++)
  1264. brelse(bhs[i]);
  1265. return err;
  1266. error_remove:
  1267. brelse(bh);
  1268. if (free_slots)
  1269. __fat_remove_entries(dir, pos, free_slots);
  1270. return err;
  1271. }
  1272. EXPORT_SYMBOL_GPL(fat_add_entries);