fs/fat/dir.c

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