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