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 (!is_fat32(sbi) && (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(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(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 (!is_fat32(sbi)) 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); 1411