LCOV - code coverage report
Current view: top level - fs/fat - dir.c (source / functions) Hit Total Coverage
Test: Real Lines: 159 554 28.7 %
Date: 2020-10-17 15:46:43 Functions: 0 28 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

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

Generated by: LCOV version 1.14