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