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