LCOV - code coverage report
Current view: top level - fs/ext4 - xattr.c (source / functions) Hit Total Coverage
Test: Real Lines: 83 1235 6.7 %
Date: 2020-10-17 15:46:43 Functions: 0 57 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : /*
       3                 :            :  * linux/fs/ext4/xattr.c
       4                 :            :  *
       5                 :            :  * Copyright (C) 2001-2003 Andreas Gruenbacher, <agruen@suse.de>
       6                 :            :  *
       7                 :            :  * Fix by Harrison Xing <harrison@mountainviewdata.com>.
       8                 :            :  * Ext4 code with a lot of help from Eric Jarman <ejarman@acm.org>.
       9                 :            :  * Extended attributes for symlinks and special files added per
      10                 :            :  *  suggestion of Luka Renko <luka.renko@hermes.si>.
      11                 :            :  * xattr consolidation Copyright (c) 2004 James Morris <jmorris@redhat.com>,
      12                 :            :  *  Red Hat Inc.
      13                 :            :  * ea-in-inode support by Alex Tomas <alex@clusterfs.com> aka bzzz
      14                 :            :  *  and Andreas Gruenbacher <agruen@suse.de>.
      15                 :            :  */
      16                 :            : 
      17                 :            : /*
      18                 :            :  * Extended attributes are stored directly in inodes (on file systems with
      19                 :            :  * inodes bigger than 128 bytes) and on additional disk blocks. The i_file_acl
      20                 :            :  * field contains the block number if an inode uses an additional block. All
      21                 :            :  * attributes must fit in the inode and one additional block. Blocks that
      22                 :            :  * contain the identical set of attributes may be shared among several inodes.
      23                 :            :  * Identical blocks are detected by keeping a cache of blocks that have
      24                 :            :  * recently been accessed.
      25                 :            :  *
      26                 :            :  * The attributes in inodes and on blocks have a different header; the entries
      27                 :            :  * are stored in the same format:
      28                 :            :  *
      29                 :            :  *   +------------------+
      30                 :            :  *   | header           |
      31                 :            :  *   | entry 1          | |
      32                 :            :  *   | entry 2          | | growing downwards
      33                 :            :  *   | entry 3          | v
      34                 :            :  *   | four null bytes  |
      35                 :            :  *   | . . .            |
      36                 :            :  *   | value 1          | ^
      37                 :            :  *   | value 3          | | growing upwards
      38                 :            :  *   | value 2          | |
      39                 :            :  *   +------------------+
      40                 :            :  *
      41                 :            :  * The header is followed by multiple entry descriptors. In disk blocks, the
      42                 :            :  * entry descriptors are kept sorted. In inodes, they are unsorted. The
      43                 :            :  * attribute values are aligned to the end of the block in no specific order.
      44                 :            :  *
      45                 :            :  * Locking strategy
      46                 :            :  * ----------------
      47                 :            :  * EXT4_I(inode)->i_file_acl is protected by EXT4_I(inode)->xattr_sem.
      48                 :            :  * EA blocks are only changed if they are exclusive to an inode, so
      49                 :            :  * holding xattr_sem also means that nothing but the EA block's reference
      50                 :            :  * count can change. Multiple writers to the same block are synchronized
      51                 :            :  * by the buffer lock.
      52                 :            :  */
      53                 :            : 
      54                 :            : #include <linux/init.h>
      55                 :            : #include <linux/fs.h>
      56                 :            : #include <linux/slab.h>
      57                 :            : #include <linux/mbcache.h>
      58                 :            : #include <linux/quotaops.h>
      59                 :            : #include <linux/iversion.h>
      60                 :            : #include "ext4_jbd2.h"
      61                 :            : #include "ext4.h"
      62                 :            : #include "xattr.h"
      63                 :            : #include "acl.h"
      64                 :            : 
      65                 :            : #ifdef EXT4_XATTR_DEBUG
      66                 :            : # define ea_idebug(inode, fmt, ...)                                     \
      67                 :            :         printk(KERN_DEBUG "inode %s:%lu: " fmt "\n",                        \
      68                 :            :                inode->i_sb->s_id, inode->i_ino, ##__VA_ARGS__)
      69                 :            : # define ea_bdebug(bh, fmt, ...)                                        \
      70                 :            :         printk(KERN_DEBUG "block %pg:%lu: " fmt "\n",                       \
      71                 :            :                bh->b_bdev, (unsigned long)bh->b_blocknr, ##__VA_ARGS__)
      72                 :            : #else
      73                 :            : # define ea_idebug(inode, fmt, ...)     no_printk(fmt, ##__VA_ARGS__)
      74                 :            : # define ea_bdebug(bh, fmt, ...)        no_printk(fmt, ##__VA_ARGS__)
      75                 :            : #endif
      76                 :            : 
      77                 :            : static void ext4_xattr_block_cache_insert(struct mb_cache *,
      78                 :            :                                           struct buffer_head *);
      79                 :            : static struct buffer_head *
      80                 :            : ext4_xattr_block_cache_find(struct inode *, struct ext4_xattr_header *,
      81                 :            :                             struct mb_cache_entry **);
      82                 :            : static __le32 ext4_xattr_hash_entry(char *name, size_t name_len, __le32 *value,
      83                 :            :                                     size_t value_count);
      84                 :            : static void ext4_xattr_rehash(struct ext4_xattr_header *);
      85                 :            : 
      86                 :            : static const struct xattr_handler * const ext4_xattr_handler_map[] = {
      87                 :            :         [EXT4_XATTR_INDEX_USER]              = &ext4_xattr_user_handler,
      88                 :            : #ifdef CONFIG_EXT4_FS_POSIX_ACL
      89                 :            :         [EXT4_XATTR_INDEX_POSIX_ACL_ACCESS]  = &posix_acl_access_xattr_handler,
      90                 :            :         [EXT4_XATTR_INDEX_POSIX_ACL_DEFAULT] = &posix_acl_default_xattr_handler,
      91                 :            : #endif
      92                 :            :         [EXT4_XATTR_INDEX_TRUSTED]           = &ext4_xattr_trusted_handler,
      93                 :            : #ifdef CONFIG_EXT4_FS_SECURITY
      94                 :            :         [EXT4_XATTR_INDEX_SECURITY]          = &ext4_xattr_security_handler,
      95                 :            : #endif
      96                 :            : };
      97                 :            : 
      98                 :            : const struct xattr_handler *ext4_xattr_handlers[] = {
      99                 :            :         &ext4_xattr_user_handler,
     100                 :            :         &ext4_xattr_trusted_handler,
     101                 :            : #ifdef CONFIG_EXT4_FS_POSIX_ACL
     102                 :            :         &posix_acl_access_xattr_handler,
     103                 :            :         &posix_acl_default_xattr_handler,
     104                 :            : #endif
     105                 :            : #ifdef CONFIG_EXT4_FS_SECURITY
     106                 :            :         &ext4_xattr_security_handler,
     107                 :            : #endif
     108                 :            :         NULL
     109                 :            : };
     110                 :            : 
     111                 :            : #define EA_BLOCK_CACHE(inode)   (((struct ext4_sb_info *) \
     112                 :            :                                 inode->i_sb->s_fs_info)->s_ea_block_cache)
     113                 :            : 
     114                 :            : #define EA_INODE_CACHE(inode)   (((struct ext4_sb_info *) \
     115                 :            :                                 inode->i_sb->s_fs_info)->s_ea_inode_cache)
     116                 :            : 
     117                 :            : static int
     118                 :            : ext4_expand_inode_array(struct ext4_xattr_inode_array **ea_inode_array,
     119                 :            :                         struct inode *inode);
     120                 :            : 
     121                 :            : #ifdef CONFIG_LOCKDEP
     122                 :            : void ext4_xattr_inode_set_class(struct inode *ea_inode)
     123                 :            : {
     124                 :            :         lockdep_set_subclass(&ea_inode->i_rwsem, 1);
     125                 :            : }
     126                 :            : #endif
     127                 :            : 
     128                 :          0 : static __le32 ext4_xattr_block_csum(struct inode *inode,
     129                 :            :                                     sector_t block_nr,
     130                 :            :                                     struct ext4_xattr_header *hdr)
     131                 :            : {
     132                 :          0 :         struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
     133                 :            :         __u32 csum;
     134                 :          0 :         __le64 dsk_block_nr = cpu_to_le64(block_nr);
     135                 :          0 :         __u32 dummy_csum = 0;
     136                 :            :         int offset = offsetof(struct ext4_xattr_header, h_checksum);
     137                 :            : 
     138                 :          0 :         csum = ext4_chksum(sbi, sbi->s_csum_seed, (__u8 *)&dsk_block_nr,
     139                 :            :                            sizeof(dsk_block_nr));
     140                 :          0 :         csum = ext4_chksum(sbi, csum, (__u8 *)hdr, offset);
     141                 :          0 :         csum = ext4_chksum(sbi, csum, (__u8 *)&dummy_csum, sizeof(dummy_csum));
     142                 :            :         offset += sizeof(dummy_csum);
     143                 :          0 :         csum = ext4_chksum(sbi, csum, (__u8 *)hdr + offset,
     144                 :          0 :                            EXT4_BLOCK_SIZE(inode->i_sb) - offset);
     145                 :            : 
     146                 :          0 :         return cpu_to_le32(csum);
     147                 :            : }
     148                 :            : 
     149                 :          0 : static int ext4_xattr_block_csum_verify(struct inode *inode,
     150                 :            :                                         struct buffer_head *bh)
     151                 :            : {
     152                 :          0 :         struct ext4_xattr_header *hdr = BHDR(bh);
     153                 :            :         int ret = 1;
     154                 :            : 
     155                 :          0 :         if (ext4_has_metadata_csum(inode->i_sb)) {
     156                 :          0 :                 lock_buffer(bh);
     157                 :          0 :                 ret = (hdr->h_checksum == ext4_xattr_block_csum(inode,
     158                 :            :                                                         bh->b_blocknr, hdr));
     159                 :          0 :                 unlock_buffer(bh);
     160                 :            :         }
     161                 :          0 :         return ret;
     162                 :            : }
     163                 :            : 
     164                 :          0 : static void ext4_xattr_block_csum_set(struct inode *inode,
     165                 :            :                                       struct buffer_head *bh)
     166                 :            : {
     167                 :          0 :         if (ext4_has_metadata_csum(inode->i_sb))
     168                 :          0 :                 BHDR(bh)->h_checksum = ext4_xattr_block_csum(inode,
     169                 :          0 :                                                 bh->b_blocknr, BHDR(bh));
     170                 :          0 : }
     171                 :            : 
     172                 :            : static inline const struct xattr_handler *
     173                 :            : ext4_xattr_handler(int name_index)
     174                 :            : {
     175                 :            :         const struct xattr_handler *handler = NULL;
     176                 :            : 
     177                 :          0 :         if (name_index > 0 && name_index < ARRAY_SIZE(ext4_xattr_handler_map))
     178                 :          0 :                 handler = ext4_xattr_handler_map[name_index];
     179                 :            :         return handler;
     180                 :            : }
     181                 :            : 
     182                 :            : static int
     183                 :          0 : ext4_xattr_check_entries(struct ext4_xattr_entry *entry, void *end,
     184                 :            :                          void *value_start)
     185                 :            : {
     186                 :            :         struct ext4_xattr_entry *e = entry;
     187                 :            : 
     188                 :            :         /* Find the end of the names list */
     189                 :          0 :         while (!IS_LAST_ENTRY(e)) {
     190                 :          0 :                 struct ext4_xattr_entry *next = EXT4_XATTR_NEXT(e);
     191                 :          0 :                 if ((void *)next >= end)
     192                 :            :                         return -EFSCORRUPTED;
     193                 :          0 :                 if (strnlen(e->e_name, e->e_name_len) != e->e_name_len)
     194                 :            :                         return -EFSCORRUPTED;
     195                 :            :                 e = next;
     196                 :            :         }
     197                 :            : 
     198                 :            :         /* Check the values */
     199                 :          0 :         while (!IS_LAST_ENTRY(entry)) {
     200                 :          0 :                 u32 size = le32_to_cpu(entry->e_value_size);
     201                 :            : 
     202                 :          0 :                 if (size > EXT4_XATTR_SIZE_MAX)
     203                 :            :                         return -EFSCORRUPTED;
     204                 :            : 
     205                 :          0 :                 if (size != 0 && entry->e_value_inum == 0) {
     206                 :          0 :                         u16 offs = le16_to_cpu(entry->e_value_offs);
     207                 :            :                         void *value;
     208                 :            : 
     209                 :            :                         /*
     210                 :            :                          * The value cannot overlap the names, and the value
     211                 :            :                          * with padding cannot extend beyond 'end'.  Check both
     212                 :            :                          * the padded and unpadded sizes, since the size may
     213                 :            :                          * overflow to 0 when adding padding.
     214                 :            :                          */
     215                 :          0 :                         if (offs > end - value_start)
     216                 :            :                                 return -EFSCORRUPTED;
     217                 :          0 :                         value = value_start + offs;
     218                 :          0 :                         if (value < (void *)e + sizeof(u32) ||
     219                 :          0 :                             size > end - value ||
     220                 :          0 :                             EXT4_XATTR_SIZE(size) > end - value)
     221                 :            :                                 return -EFSCORRUPTED;
     222                 :            :                 }
     223                 :          0 :                 entry = EXT4_XATTR_NEXT(entry);
     224                 :            :         }
     225                 :            : 
     226                 :            :         return 0;
     227                 :            : }
     228                 :            : 
     229                 :            : static inline int
     230                 :          0 : __ext4_xattr_check_block(struct inode *inode, struct buffer_head *bh,
     231                 :            :                          const char *function, unsigned int line)
     232                 :            : {
     233                 :            :         int error = -EFSCORRUPTED;
     234                 :            : 
     235                 :          0 :         if (BHDR(bh)->h_magic != cpu_to_le32(EXT4_XATTR_MAGIC) ||
     236                 :          0 :             BHDR(bh)->h_blocks != cpu_to_le32(1))
     237                 :            :                 goto errout;
     238                 :          0 :         if (buffer_verified(bh))
     239                 :            :                 return 0;
     240                 :            : 
     241                 :            :         error = -EFSBADCRC;
     242                 :          0 :         if (!ext4_xattr_block_csum_verify(inode, bh))
     243                 :            :                 goto errout;
     244                 :          0 :         error = ext4_xattr_check_entries(BFIRST(bh), bh->b_data + bh->b_size,
     245                 :            :                                          bh->b_data);
     246                 :            : errout:
     247                 :          0 :         if (error)
     248                 :          0 :                 __ext4_error_inode(inode, function, line, 0,
     249                 :            :                                    "corrupted xattr block %llu",
     250                 :            :                                    (unsigned long long) bh->b_blocknr);
     251                 :            :         else
     252                 :            :                 set_buffer_verified(bh);
     253                 :          0 :         return error;
     254                 :            : }
     255                 :            : 
     256                 :            : #define ext4_xattr_check_block(inode, bh) \
     257                 :            :         __ext4_xattr_check_block((inode), (bh),  __func__, __LINE__)
     258                 :            : 
     259                 :            : 
     260                 :            : static int
     261                 :          0 : __xattr_check_inode(struct inode *inode, struct ext4_xattr_ibody_header *header,
     262                 :            :                          void *end, const char *function, unsigned int line)
     263                 :            : {
     264                 :            :         int error = -EFSCORRUPTED;
     265                 :            : 
     266                 :          0 :         if (end - (void *)header < sizeof(*header) + sizeof(u32) ||
     267                 :          0 :             (header->h_magic != cpu_to_le32(EXT4_XATTR_MAGIC)))
     268                 :            :                 goto errout;
     269                 :          0 :         error = ext4_xattr_check_entries(IFIRST(header), end, IFIRST(header));
     270                 :            : errout:
     271                 :          0 :         if (error)
     272                 :          0 :                 __ext4_error_inode(inode, function, line, 0,
     273                 :            :                                    "corrupted in-inode xattr");
     274                 :          0 :         return error;
     275                 :            : }
     276                 :            : 
     277                 :            : #define xattr_check_inode(inode, header, end) \
     278                 :            :         __xattr_check_inode((inode), (header), (end), __func__, __LINE__)
     279                 :            : 
     280                 :            : static int
     281                 :          0 : xattr_find_entry(struct inode *inode, struct ext4_xattr_entry **pentry,
     282                 :            :                  void *end, int name_index, const char *name, int sorted)
     283                 :            : {
     284                 :            :         struct ext4_xattr_entry *entry, *next;
     285                 :            :         size_t name_len;
     286                 :            :         int cmp = 1;
     287                 :            : 
     288                 :          0 :         if (name == NULL)
     289                 :            :                 return -EINVAL;
     290                 :          0 :         name_len = strlen(name);
     291                 :          0 :         for (entry = *pentry; !IS_LAST_ENTRY(entry); entry = next) {
     292                 :          0 :                 next = EXT4_XATTR_NEXT(entry);
     293                 :          0 :                 if ((void *) next >= end) {
     294                 :          0 :                         EXT4_ERROR_INODE(inode, "corrupted xattr entries");
     295                 :          0 :                         return -EFSCORRUPTED;
     296                 :            :                 }
     297                 :          0 :                 cmp = name_index - entry->e_name_index;
     298                 :          0 :                 if (!cmp)
     299                 :          0 :                         cmp = name_len - entry->e_name_len;
     300                 :          0 :                 if (!cmp)
     301                 :          0 :                         cmp = memcmp(name, entry->e_name, name_len);
     302                 :          0 :                 if (cmp <= 0 && (sorted || cmp == 0))
     303                 :            :                         break;
     304                 :            :         }
     305                 :          0 :         *pentry = entry;
     306                 :          0 :         return cmp ? -ENODATA : 0;
     307                 :            : }
     308                 :            : 
     309                 :            : static u32
     310                 :            : ext4_xattr_inode_hash(struct ext4_sb_info *sbi, const void *buffer, size_t size)
     311                 :            : {
     312                 :          0 :         return ext4_chksum(sbi, sbi->s_csum_seed, buffer, size);
     313                 :            : }
     314                 :            : 
     315                 :            : static u64 ext4_xattr_inode_get_ref(struct inode *ea_inode)
     316                 :            : {
     317                 :          0 :         return ((u64)ea_inode->i_ctime.tv_sec << 32) |
     318                 :            :                 (u32) inode_peek_iversion_raw(ea_inode);
     319                 :            : }
     320                 :            : 
     321                 :            : static void ext4_xattr_inode_set_ref(struct inode *ea_inode, u64 ref_count)
     322                 :            : {
     323                 :          0 :         ea_inode->i_ctime.tv_sec = (u32)(ref_count >> 32);
     324                 :          0 :         inode_set_iversion_raw(ea_inode, ref_count & 0xffffffff);
     325                 :            : }
     326                 :            : 
     327                 :            : static u32 ext4_xattr_inode_get_hash(struct inode *ea_inode)
     328                 :            : {
     329                 :          0 :         return (u32)ea_inode->i_atime.tv_sec;
     330                 :            : }
     331                 :            : 
     332                 :            : static void ext4_xattr_inode_set_hash(struct inode *ea_inode, u32 hash)
     333                 :            : {
     334                 :          0 :         ea_inode->i_atime.tv_sec = hash;
     335                 :            : }
     336                 :            : 
     337                 :            : /*
     338                 :            :  * Read the EA value from an inode.
     339                 :            :  */
     340                 :          0 : static int ext4_xattr_inode_read(struct inode *ea_inode, void *buf, size_t size)
     341                 :            : {
     342                 :          0 :         int blocksize = 1 << ea_inode->i_blkbits;
     343                 :          0 :         int bh_count = (size + blocksize - 1) >> ea_inode->i_blkbits;
     344                 :          0 :         int tail_size = (size % blocksize) ?: blocksize;
     345                 :            :         struct buffer_head *bhs_inline[8];
     346                 :            :         struct buffer_head **bhs = bhs_inline;
     347                 :            :         int i, ret;
     348                 :            : 
     349                 :          0 :         if (bh_count > ARRAY_SIZE(bhs_inline)) {
     350                 :          0 :                 bhs = kmalloc_array(bh_count, sizeof(*bhs), GFP_NOFS);
     351                 :          0 :                 if (!bhs)
     352                 :            :                         return -ENOMEM;
     353                 :            :         }
     354                 :            : 
     355                 :          0 :         ret = ext4_bread_batch(ea_inode, 0 /* block */, bh_count,
     356                 :            :                                true /* wait */, bhs);
     357                 :          0 :         if (ret)
     358                 :            :                 goto free_bhs;
     359                 :            : 
     360                 :          0 :         for (i = 0; i < bh_count; i++) {
     361                 :            :                 /* There shouldn't be any holes in ea_inode. */
     362                 :          0 :                 if (!bhs[i]) {
     363                 :            :                         ret = -EFSCORRUPTED;
     364                 :            :                         goto put_bhs;
     365                 :            :                 }
     366                 :          0 :                 memcpy((char *)buf + blocksize * i, bhs[i]->b_data,
     367                 :          0 :                        i < bh_count - 1 ? blocksize : tail_size);
     368                 :            :         }
     369                 :            :         ret = 0;
     370                 :            : put_bhs:
     371                 :          0 :         for (i = 0; i < bh_count; i++)
     372                 :          0 :                 brelse(bhs[i]);
     373                 :            : free_bhs:
     374                 :          0 :         if (bhs != bhs_inline)
     375                 :          0 :                 kfree(bhs);
     376                 :          0 :         return ret;
     377                 :            : }
     378                 :            : 
     379                 :            : #define EXT4_XATTR_INODE_GET_PARENT(inode) ((__u32)(inode)->i_mtime.tv_sec)
     380                 :            : 
     381                 :          0 : static int ext4_xattr_inode_iget(struct inode *parent, unsigned long ea_ino,
     382                 :            :                                  u32 ea_inode_hash, struct inode **ea_inode)
     383                 :            : {
     384                 :            :         struct inode *inode;
     385                 :            :         int err;
     386                 :            : 
     387                 :          0 :         inode = ext4_iget(parent->i_sb, ea_ino, EXT4_IGET_NORMAL);
     388                 :          0 :         if (IS_ERR(inode)) {
     389                 :            :                 err = PTR_ERR(inode);
     390                 :          0 :                 ext4_error(parent->i_sb,
     391                 :            :                            "error while reading EA inode %lu err=%d", ea_ino,
     392                 :            :                            err);
     393                 :          0 :                 return err;
     394                 :            :         }
     395                 :            : 
     396                 :          0 :         if (is_bad_inode(inode)) {
     397                 :          0 :                 ext4_error(parent->i_sb,
     398                 :            :                            "error while reading EA inode %lu is_bad_inode",
     399                 :            :                            ea_ino);
     400                 :            :                 err = -EIO;
     401                 :          0 :                 goto error;
     402                 :            :         }
     403                 :            : 
     404                 :          0 :         if (!(EXT4_I(inode)->i_flags & EXT4_EA_INODE_FL)) {
     405                 :          0 :                 ext4_error(parent->i_sb,
     406                 :            :                            "EA inode %lu does not have EXT4_EA_INODE_FL flag",
     407                 :            :                             ea_ino);
     408                 :            :                 err = -EINVAL;
     409                 :          0 :                 goto error;
     410                 :            :         }
     411                 :            : 
     412                 :            :         ext4_xattr_inode_set_class(inode);
     413                 :            : 
     414                 :            :         /*
     415                 :            :          * Check whether this is an old Lustre-style xattr inode. Lustre
     416                 :            :          * implementation does not have hash validation, rather it has a
     417                 :            :          * backpointer from ea_inode to the parent inode.
     418                 :            :          */
     419                 :          0 :         if (ea_inode_hash != ext4_xattr_inode_get_hash(inode) &&
     420                 :          0 :             EXT4_XATTR_INODE_GET_PARENT(inode) == parent->i_ino &&
     421                 :          0 :             inode->i_generation == parent->i_generation) {
     422                 :            :                 ext4_set_inode_state(inode, EXT4_STATE_LUSTRE_EA_INODE);
     423                 :            :                 ext4_xattr_inode_set_ref(inode, 1);
     424                 :            :         } else {
     425                 :            :                 inode_lock(inode);
     426                 :          0 :                 inode->i_flags |= S_NOQUOTA;
     427                 :            :                 inode_unlock(inode);
     428                 :            :         }
     429                 :            : 
     430                 :          0 :         *ea_inode = inode;
     431                 :          0 :         return 0;
     432                 :            : error:
     433                 :          0 :         iput(inode);
     434                 :          0 :         return err;
     435                 :            : }
     436                 :            : 
     437                 :            : static int
     438                 :          0 : ext4_xattr_inode_verify_hashes(struct inode *ea_inode,
     439                 :            :                                struct ext4_xattr_entry *entry, void *buffer,
     440                 :            :                                size_t size)
     441                 :            : {
     442                 :            :         u32 hash;
     443                 :            : 
     444                 :            :         /* Verify stored hash matches calculated hash. */
     445                 :          0 :         hash = ext4_xattr_inode_hash(EXT4_SB(ea_inode->i_sb), buffer, size);
     446                 :          0 :         if (hash != ext4_xattr_inode_get_hash(ea_inode))
     447                 :            :                 return -EFSCORRUPTED;
     448                 :            : 
     449                 :          0 :         if (entry) {
     450                 :            :                 __le32 e_hash, tmp_data;
     451                 :            : 
     452                 :            :                 /* Verify entry hash. */
     453                 :          0 :                 tmp_data = cpu_to_le32(hash);
     454                 :          0 :                 e_hash = ext4_xattr_hash_entry(entry->e_name, entry->e_name_len,
     455                 :            :                                                &tmp_data, 1);
     456                 :          0 :                 if (e_hash != entry->e_hash)
     457                 :          0 :                         return -EFSCORRUPTED;
     458                 :            :         }
     459                 :            :         return 0;
     460                 :            : }
     461                 :            : 
     462                 :            : /*
     463                 :            :  * Read xattr value from the EA inode.
     464                 :            :  */
     465                 :            : static int
     466                 :          0 : ext4_xattr_inode_get(struct inode *inode, struct ext4_xattr_entry *entry,
     467                 :            :                      void *buffer, size_t size)
     468                 :            : {
     469                 :          0 :         struct mb_cache *ea_inode_cache = EA_INODE_CACHE(inode);
     470                 :            :         struct inode *ea_inode;
     471                 :            :         int err;
     472                 :            : 
     473                 :          0 :         err = ext4_xattr_inode_iget(inode, le32_to_cpu(entry->e_value_inum),
     474                 :            :                                     le32_to_cpu(entry->e_hash), &ea_inode);
     475                 :          0 :         if (err) {
     476                 :          0 :                 ea_inode = NULL;
     477                 :          0 :                 goto out;
     478                 :            :         }
     479                 :            : 
     480                 :          0 :         if (i_size_read(ea_inode) != size) {
     481                 :          0 :                 ext4_warning_inode(ea_inode,
     482                 :            :                                    "ea_inode file size=%llu entry size=%zu",
     483                 :            :                                    i_size_read(ea_inode), size);
     484                 :            :                 err = -EFSCORRUPTED;
     485                 :          0 :                 goto out;
     486                 :            :         }
     487                 :            : 
     488                 :          0 :         err = ext4_xattr_inode_read(ea_inode, buffer, size);
     489                 :          0 :         if (err)
     490                 :            :                 goto out;
     491                 :            : 
     492                 :          0 :         if (!ext4_test_inode_state(ea_inode, EXT4_STATE_LUSTRE_EA_INODE)) {
     493                 :          0 :                 err = ext4_xattr_inode_verify_hashes(ea_inode, entry, buffer,
     494                 :            :                                                      size);
     495                 :          0 :                 if (err) {
     496                 :          0 :                         ext4_warning_inode(ea_inode,
     497                 :            :                                            "EA inode hash validation failed");
     498                 :          0 :                         goto out;
     499                 :            :                 }
     500                 :            : 
     501                 :          0 :                 if (ea_inode_cache)
     502                 :          0 :                         mb_cache_entry_create(ea_inode_cache, GFP_NOFS,
     503                 :            :                                         ext4_xattr_inode_get_hash(ea_inode),
     504                 :          0 :                                         ea_inode->i_ino, true /* reusable */);
     505                 :            :         }
     506                 :            : out:
     507                 :          0 :         iput(ea_inode);
     508                 :          0 :         return err;
     509                 :            : }
     510                 :            : 
     511                 :            : static int
     512                 :          3 : ext4_xattr_block_get(struct inode *inode, int name_index, const char *name,
     513                 :            :                      void *buffer, size_t buffer_size)
     514                 :            : {
     515                 :            :         struct buffer_head *bh = NULL;
     516                 :            :         struct ext4_xattr_entry *entry;
     517                 :            :         size_t size;
     518                 :            :         void *end;
     519                 :            :         int error;
     520                 :          3 :         struct mb_cache *ea_block_cache = EA_BLOCK_CACHE(inode);
     521                 :            : 
     522                 :            :         ea_idebug(inode, "name=%d.%s, buffer=%p, buffer_size=%ld",
     523                 :            :                   name_index, name, buffer, (long)buffer_size);
     524                 :            : 
     525                 :          3 :         if (!EXT4_I(inode)->i_file_acl)
     526                 :            :                 return -ENODATA;
     527                 :            :         ea_idebug(inode, "reading block %llu",
     528                 :            :                   (unsigned long long)EXT4_I(inode)->i_file_acl);
     529                 :          0 :         bh = ext4_sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl, REQ_PRIO);
     530                 :          0 :         if (IS_ERR(bh))
     531                 :          0 :                 return PTR_ERR(bh);
     532                 :            :         ea_bdebug(bh, "b_count=%d, refcount=%d",
     533                 :            :                 atomic_read(&(bh->b_count)), le32_to_cpu(BHDR(bh)->h_refcount));
     534                 :          0 :         error = ext4_xattr_check_block(inode, bh);
     535                 :          0 :         if (error)
     536                 :            :                 goto cleanup;
     537                 :          0 :         ext4_xattr_block_cache_insert(ea_block_cache, bh);
     538                 :          0 :         entry = BFIRST(bh);
     539                 :          0 :         end = bh->b_data + bh->b_size;
     540                 :          0 :         error = xattr_find_entry(inode, &entry, end, name_index, name, 1);
     541                 :          0 :         if (error)
     542                 :            :                 goto cleanup;
     543                 :          0 :         size = le32_to_cpu(entry->e_value_size);
     544                 :            :         error = -ERANGE;
     545                 :          0 :         if (unlikely(size > EXT4_XATTR_SIZE_MAX))
     546                 :            :                 goto cleanup;
     547                 :          0 :         if (buffer) {
     548                 :          0 :                 if (size > buffer_size)
     549                 :            :                         goto cleanup;
     550                 :          0 :                 if (entry->e_value_inum) {
     551                 :          0 :                         error = ext4_xattr_inode_get(inode, entry, buffer,
     552                 :            :                                                      size);
     553                 :          0 :                         if (error)
     554                 :            :                                 goto cleanup;
     555                 :            :                 } else {
     556                 :          0 :                         u16 offset = le16_to_cpu(entry->e_value_offs);
     557                 :          0 :                         void *p = bh->b_data + offset;
     558                 :            : 
     559                 :          0 :                         if (unlikely(p + size > end))
     560                 :            :                                 goto cleanup;
     561                 :          0 :                         memcpy(buffer, p, size);
     562                 :            :                 }
     563                 :            :         }
     564                 :          0 :         error = size;
     565                 :            : 
     566                 :            : cleanup:
     567                 :            :         brelse(bh);
     568                 :          0 :         return error;
     569                 :            : }
     570                 :            : 
     571                 :            : int
     572                 :          3 : ext4_xattr_ibody_get(struct inode *inode, int name_index, const char *name,
     573                 :            :                      void *buffer, size_t buffer_size)
     574                 :            : {
     575                 :            :         struct ext4_xattr_ibody_header *header;
     576                 :            :         struct ext4_xattr_entry *entry;
     577                 :            :         struct ext4_inode *raw_inode;
     578                 :            :         struct ext4_iloc iloc;
     579                 :            :         size_t size;
     580                 :            :         void *end;
     581                 :            :         int error;
     582                 :            : 
     583                 :          3 :         if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR))
     584                 :            :                 return -ENODATA;
     585                 :          0 :         error = ext4_get_inode_loc(inode, &iloc);
     586                 :          0 :         if (error)
     587                 :            :                 return error;
     588                 :            :         raw_inode = ext4_raw_inode(&iloc);
     589                 :          0 :         header = IHDR(inode, raw_inode);
     590                 :          0 :         end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
     591                 :          0 :         error = xattr_check_inode(inode, header, end);
     592                 :          0 :         if (error)
     593                 :            :                 goto cleanup;
     594                 :          0 :         entry = IFIRST(header);
     595                 :          0 :         error = xattr_find_entry(inode, &entry, end, name_index, name, 0);
     596                 :          0 :         if (error)
     597                 :            :                 goto cleanup;
     598                 :          0 :         size = le32_to_cpu(entry->e_value_size);
     599                 :            :         error = -ERANGE;
     600                 :          0 :         if (unlikely(size > EXT4_XATTR_SIZE_MAX))
     601                 :            :                 goto cleanup;
     602                 :          0 :         if (buffer) {
     603                 :          0 :                 if (size > buffer_size)
     604                 :            :                         goto cleanup;
     605                 :          0 :                 if (entry->e_value_inum) {
     606                 :          0 :                         error = ext4_xattr_inode_get(inode, entry, buffer,
     607                 :            :                                                      size);
     608                 :          0 :                         if (error)
     609                 :            :                                 goto cleanup;
     610                 :            :                 } else {
     611                 :          0 :                         u16 offset = le16_to_cpu(entry->e_value_offs);
     612                 :          0 :                         void *p = (void *)IFIRST(header) + offset;
     613                 :            : 
     614                 :          0 :                         if (unlikely(p + size > end))
     615                 :            :                                 goto cleanup;
     616                 :          0 :                         memcpy(buffer, p, size);
     617                 :            :                 }
     618                 :            :         }
     619                 :          0 :         error = size;
     620                 :            : 
     621                 :            : cleanup:
     622                 :          0 :         brelse(iloc.bh);
     623                 :          0 :         return error;
     624                 :            : }
     625                 :            : 
     626                 :            : /*
     627                 :            :  * ext4_xattr_get()
     628                 :            :  *
     629                 :            :  * Copy an extended attribute into the buffer
     630                 :            :  * provided, or compute the buffer size required.
     631                 :            :  * Buffer is NULL to compute the size of the buffer required.
     632                 :            :  *
     633                 :            :  * Returns a negative error number on failure, or the number of bytes
     634                 :            :  * used / required on success.
     635                 :            :  */
     636                 :            : int
     637                 :          3 : ext4_xattr_get(struct inode *inode, int name_index, const char *name,
     638                 :            :                void *buffer, size_t buffer_size)
     639                 :            : {
     640                 :            :         int error;
     641                 :            : 
     642                 :          3 :         if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb))))
     643                 :            :                 return -EIO;
     644                 :            : 
     645                 :          3 :         if (strlen(name) > 255)
     646                 :            :                 return -ERANGE;
     647                 :            : 
     648                 :          3 :         down_read(&EXT4_I(inode)->xattr_sem);
     649                 :          3 :         error = ext4_xattr_ibody_get(inode, name_index, name, buffer,
     650                 :            :                                      buffer_size);
     651                 :          3 :         if (error == -ENODATA)
     652                 :          3 :                 error = ext4_xattr_block_get(inode, name_index, name, buffer,
     653                 :            :                                              buffer_size);
     654                 :          3 :         up_read(&EXT4_I(inode)->xattr_sem);
     655                 :          3 :         return error;
     656                 :            : }
     657                 :            : 
     658                 :            : static int
     659                 :          0 : ext4_xattr_list_entries(struct dentry *dentry, struct ext4_xattr_entry *entry,
     660                 :            :                         char *buffer, size_t buffer_size)
     661                 :            : {
     662                 :            :         size_t rest = buffer_size;
     663                 :            : 
     664                 :          0 :         for (; !IS_LAST_ENTRY(entry); entry = EXT4_XATTR_NEXT(entry)) {
     665                 :            :                 const struct xattr_handler *handler =
     666                 :          0 :                         ext4_xattr_handler(entry->e_name_index);
     667                 :            : 
     668                 :          0 :                 if (handler && (!handler->list || handler->list(dentry))) {
     669                 :          0 :                         const char *prefix = handler->prefix ?: handler->name;
     670                 :          0 :                         size_t prefix_len = strlen(prefix);
     671                 :          0 :                         size_t size = prefix_len + entry->e_name_len + 1;
     672                 :            : 
     673                 :          0 :                         if (buffer) {
     674                 :          0 :                                 if (size > rest)
     675                 :            :                                         return -ERANGE;
     676                 :          0 :                                 memcpy(buffer, prefix, prefix_len);
     677                 :          0 :                                 buffer += prefix_len;
     678                 :          0 :                                 memcpy(buffer, entry->e_name, entry->e_name_len);
     679                 :          0 :                                 buffer += entry->e_name_len;
     680                 :          0 :                                 *buffer++ = 0;
     681                 :            :                         }
     682                 :          0 :                         rest -= size;
     683                 :            :                 }
     684                 :            :         }
     685                 :          0 :         return buffer_size - rest;  /* total size */
     686                 :            : }
     687                 :            : 
     688                 :            : static int
     689                 :          0 : ext4_xattr_block_list(struct dentry *dentry, char *buffer, size_t buffer_size)
     690                 :            : {
     691                 :            :         struct inode *inode = d_inode(dentry);
     692                 :            :         struct buffer_head *bh = NULL;
     693                 :            :         int error;
     694                 :            : 
     695                 :            :         ea_idebug(inode, "buffer=%p, buffer_size=%ld",
     696                 :            :                   buffer, (long)buffer_size);
     697                 :            : 
     698                 :          0 :         if (!EXT4_I(inode)->i_file_acl)
     699                 :            :                 return 0;
     700                 :            :         ea_idebug(inode, "reading block %llu",
     701                 :            :                   (unsigned long long)EXT4_I(inode)->i_file_acl);
     702                 :          0 :         bh = ext4_sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl, REQ_PRIO);
     703                 :          0 :         if (IS_ERR(bh))
     704                 :          0 :                 return PTR_ERR(bh);
     705                 :            :         ea_bdebug(bh, "b_count=%d, refcount=%d",
     706                 :            :                 atomic_read(&(bh->b_count)), le32_to_cpu(BHDR(bh)->h_refcount));
     707                 :          0 :         error = ext4_xattr_check_block(inode, bh);
     708                 :          0 :         if (error)
     709                 :            :                 goto cleanup;
     710                 :          0 :         ext4_xattr_block_cache_insert(EA_BLOCK_CACHE(inode), bh);
     711                 :          0 :         error = ext4_xattr_list_entries(dentry, BFIRST(bh), buffer,
     712                 :            :                                         buffer_size);
     713                 :            : cleanup:
     714                 :            :         brelse(bh);
     715                 :          0 :         return error;
     716                 :            : }
     717                 :            : 
     718                 :            : static int
     719                 :          0 : ext4_xattr_ibody_list(struct dentry *dentry, char *buffer, size_t buffer_size)
     720                 :            : {
     721                 :            :         struct inode *inode = d_inode(dentry);
     722                 :            :         struct ext4_xattr_ibody_header *header;
     723                 :            :         struct ext4_inode *raw_inode;
     724                 :            :         struct ext4_iloc iloc;
     725                 :            :         void *end;
     726                 :            :         int error;
     727                 :            : 
     728                 :          0 :         if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR))
     729                 :            :                 return 0;
     730                 :          0 :         error = ext4_get_inode_loc(inode, &iloc);
     731                 :          0 :         if (error)
     732                 :            :                 return error;
     733                 :            :         raw_inode = ext4_raw_inode(&iloc);
     734                 :          0 :         header = IHDR(inode, raw_inode);
     735                 :          0 :         end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
     736                 :          0 :         error = xattr_check_inode(inode, header, end);
     737                 :          0 :         if (error)
     738                 :            :                 goto cleanup;
     739                 :          0 :         error = ext4_xattr_list_entries(dentry, IFIRST(header),
     740                 :            :                                         buffer, buffer_size);
     741                 :            : 
     742                 :            : cleanup:
     743                 :          0 :         brelse(iloc.bh);
     744                 :          0 :         return error;
     745                 :            : }
     746                 :            : 
     747                 :            : /*
     748                 :            :  * Inode operation listxattr()
     749                 :            :  *
     750                 :            :  * d_inode(dentry)->i_rwsem: don't care
     751                 :            :  *
     752                 :            :  * Copy a list of attribute names into the buffer
     753                 :            :  * provided, or compute the buffer size required.
     754                 :            :  * Buffer is NULL to compute the size of the buffer required.
     755                 :            :  *
     756                 :            :  * Returns a negative error number on failure, or the number of bytes
     757                 :            :  * used / required on success.
     758                 :            :  */
     759                 :            : ssize_t
     760                 :          0 : ext4_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size)
     761                 :            : {
     762                 :            :         int ret, ret2;
     763                 :            : 
     764                 :          0 :         down_read(&EXT4_I(d_inode(dentry))->xattr_sem);
     765                 :          0 :         ret = ret2 = ext4_xattr_ibody_list(dentry, buffer, buffer_size);
     766                 :          0 :         if (ret < 0)
     767                 :            :                 goto errout;
     768                 :          0 :         if (buffer) {
     769                 :          0 :                 buffer += ret;
     770                 :          0 :                 buffer_size -= ret;
     771                 :            :         }
     772                 :          0 :         ret = ext4_xattr_block_list(dentry, buffer, buffer_size);
     773                 :          0 :         if (ret < 0)
     774                 :            :                 goto errout;
     775                 :          0 :         ret += ret2;
     776                 :            : errout:
     777                 :          0 :         up_read(&EXT4_I(d_inode(dentry))->xattr_sem);
     778                 :          0 :         return ret;
     779                 :            : }
     780                 :            : 
     781                 :            : /*
     782                 :            :  * If the EXT4_FEATURE_COMPAT_EXT_ATTR feature of this file system is
     783                 :            :  * not set, set it.
     784                 :            :  */
     785                 :          0 : static void ext4_xattr_update_super_block(handle_t *handle,
     786                 :            :                                           struct super_block *sb)
     787                 :            : {
     788                 :          0 :         if (ext4_has_feature_xattr(sb))
     789                 :          0 :                 return;
     790                 :            : 
     791                 :            :         BUFFER_TRACE(EXT4_SB(sb)->s_sbh, "get_write_access");
     792                 :          0 :         if (ext4_journal_get_write_access(handle, EXT4_SB(sb)->s_sbh) == 0) {
     793                 :            :                 ext4_set_feature_xattr(sb);
     794                 :          0 :                 ext4_handle_dirty_super(handle, sb);
     795                 :            :         }
     796                 :            : }
     797                 :            : 
     798                 :          0 : int ext4_get_inode_usage(struct inode *inode, qsize_t *usage)
     799                 :            : {
     800                 :          0 :         struct ext4_iloc iloc = { .bh = NULL };
     801                 :            :         struct buffer_head *bh = NULL;
     802                 :            :         struct ext4_inode *raw_inode;
     803                 :            :         struct ext4_xattr_ibody_header *header;
     804                 :            :         struct ext4_xattr_entry *entry;
     805                 :            :         qsize_t ea_inode_refs = 0;
     806                 :            :         void *end;
     807                 :            :         int ret;
     808                 :            : 
     809                 :            :         lockdep_assert_held_read(&EXT4_I(inode)->xattr_sem);
     810                 :            : 
     811                 :          0 :         if (ext4_test_inode_state(inode, EXT4_STATE_XATTR)) {
     812                 :          0 :                 ret = ext4_get_inode_loc(inode, &iloc);
     813                 :          0 :                 if (ret)
     814                 :            :                         goto out;
     815                 :            :                 raw_inode = ext4_raw_inode(&iloc);
     816                 :          0 :                 header = IHDR(inode, raw_inode);
     817                 :          0 :                 end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
     818                 :          0 :                 ret = xattr_check_inode(inode, header, end);
     819                 :          0 :                 if (ret)
     820                 :            :                         goto out;
     821                 :            : 
     822                 :          0 :                 for (entry = IFIRST(header); !IS_LAST_ENTRY(entry);
     823                 :          0 :                      entry = EXT4_XATTR_NEXT(entry))
     824                 :          0 :                         if (entry->e_value_inum)
     825                 :          0 :                                 ea_inode_refs++;
     826                 :            :         }
     827                 :            : 
     828                 :          0 :         if (EXT4_I(inode)->i_file_acl) {
     829                 :          0 :                 bh = ext4_sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl, REQ_PRIO);
     830                 :          0 :                 if (IS_ERR(bh)) {
     831                 :            :                         ret = PTR_ERR(bh);
     832                 :            :                         bh = NULL;
     833                 :          0 :                         goto out;
     834                 :            :                 }
     835                 :            : 
     836                 :          0 :                 ret = ext4_xattr_check_block(inode, bh);
     837                 :          0 :                 if (ret)
     838                 :            :                         goto out;
     839                 :            : 
     840                 :          0 :                 for (entry = BFIRST(bh); !IS_LAST_ENTRY(entry);
     841                 :          0 :                      entry = EXT4_XATTR_NEXT(entry))
     842                 :          0 :                         if (entry->e_value_inum)
     843                 :          0 :                                 ea_inode_refs++;
     844                 :            :         }
     845                 :          0 :         *usage = ea_inode_refs + 1;
     846                 :            :         ret = 0;
     847                 :            : out:
     848                 :          0 :         brelse(iloc.bh);
     849                 :            :         brelse(bh);
     850                 :          0 :         return ret;
     851                 :            : }
     852                 :            : 
     853                 :            : static inline size_t round_up_cluster(struct inode *inode, size_t length)
     854                 :            : {
     855                 :          0 :         struct super_block *sb = inode->i_sb;
     856                 :          0 :         size_t cluster_size = 1 << (EXT4_SB(sb)->s_cluster_bits +
     857                 :          0 :                                     inode->i_blkbits);
     858                 :          0 :         size_t mask = ~(cluster_size - 1);
     859                 :            : 
     860                 :          0 :         return (length + cluster_size - 1) & mask;
     861                 :            : }
     862                 :            : 
     863                 :          0 : static int ext4_xattr_inode_alloc_quota(struct inode *inode, size_t len)
     864                 :            : {
     865                 :            :         int err;
     866                 :            : 
     867                 :          0 :         err = dquot_alloc_inode(inode);
     868                 :          0 :         if (err)
     869                 :            :                 return err;
     870                 :          0 :         err = dquot_alloc_space_nodirty(inode, round_up_cluster(inode, len));
     871                 :          0 :         if (err)
     872                 :          0 :                 dquot_free_inode(inode);
     873                 :          0 :         return err;
     874                 :            : }
     875                 :            : 
     876                 :          0 : static void ext4_xattr_inode_free_quota(struct inode *parent,
     877                 :            :                                         struct inode *ea_inode,
     878                 :            :                                         size_t len)
     879                 :            : {
     880                 :          0 :         if (ea_inode &&
     881                 :            :             ext4_test_inode_state(ea_inode, EXT4_STATE_LUSTRE_EA_INODE))
     882                 :          0 :                 return;
     883                 :          0 :         dquot_free_space_nodirty(parent, round_up_cluster(parent, len));
     884                 :          0 :         dquot_free_inode(parent);
     885                 :            : }
     886                 :            : 
     887                 :          3 : int __ext4_xattr_set_credits(struct super_block *sb, struct inode *inode,
     888                 :            :                              struct buffer_head *block_bh, size_t value_len,
     889                 :            :                              bool is_create)
     890                 :            : {
     891                 :            :         int credits;
     892                 :            :         int blocks;
     893                 :            : 
     894                 :            :         /*
     895                 :            :          * 1) Owner inode update
     896                 :            :          * 2) Ref count update on old xattr block
     897                 :            :          * 3) new xattr block
     898                 :            :          * 4) block bitmap update for new xattr block
     899                 :            :          * 5) group descriptor for new xattr block
     900                 :            :          * 6) block bitmap update for old xattr block
     901                 :            :          * 7) group descriptor for old block
     902                 :            :          *
     903                 :            :          * 6 & 7 can happen if we have two racing threads T_a and T_b
     904                 :            :          * which are each trying to set an xattr on inodes I_a and I_b
     905                 :            :          * which were both initially sharing an xattr block.
     906                 :            :          */
     907                 :            :         credits = 7;
     908                 :            : 
     909                 :            :         /* Quota updates. */
     910                 :          3 :         credits += EXT4_MAXQUOTAS_TRANS_BLOCKS(sb);
     911                 :            : 
     912                 :            :         /*
     913                 :            :          * In case of inline data, we may push out the data to a block,
     914                 :            :          * so we need to reserve credits for this eventuality
     915                 :            :          */
     916                 :          3 :         if (inode && ext4_has_inline_data(inode))
     917                 :          0 :                 credits += ext4_writepage_trans_blocks(inode) + 1;
     918                 :            : 
     919                 :            :         /* We are done if ea_inode feature is not enabled. */
     920                 :          3 :         if (!ext4_has_feature_ea_inode(sb))
     921                 :            :                 return credits;
     922                 :            : 
     923                 :            :         /* New ea_inode, inode map, block bitmap, group descriptor. */
     924                 :          0 :         credits += 4;
     925                 :            : 
     926                 :            :         /* Data blocks. */
     927                 :          0 :         blocks = (value_len + sb->s_blocksize - 1) >> sb->s_blocksize_bits;
     928                 :            : 
     929                 :            :         /* Indirection block or one level of extent tree. */
     930                 :          0 :         blocks += 1;
     931                 :            : 
     932                 :            :         /* Block bitmap and group descriptor updates for each block. */
     933                 :          0 :         credits += blocks * 2;
     934                 :            : 
     935                 :            :         /* Blocks themselves. */
     936                 :          0 :         credits += blocks;
     937                 :            : 
     938                 :          0 :         if (!is_create) {
     939                 :            :                 /* Dereference ea_inode holding old xattr value.
     940                 :            :                  * Old ea_inode, inode map, block bitmap, group descriptor.
     941                 :            :                  */
     942                 :          0 :                 credits += 4;
     943                 :            : 
     944                 :            :                 /* Data blocks for old ea_inode. */
     945                 :          0 :                 blocks = XATTR_SIZE_MAX >> sb->s_blocksize_bits;
     946                 :            : 
     947                 :            :                 /* Indirection block or one level of extent tree for old
     948                 :            :                  * ea_inode.
     949                 :            :                  */
     950                 :          0 :                 blocks += 1;
     951                 :            : 
     952                 :            :                 /* Block bitmap and group descriptor updates for each block. */
     953                 :          0 :                 credits += blocks * 2;
     954                 :            :         }
     955                 :            : 
     956                 :            :         /* We may need to clone the existing xattr block in which case we need
     957                 :            :          * to increment ref counts for existing ea_inodes referenced by it.
     958                 :            :          */
     959                 :          0 :         if (block_bh) {
     960                 :          0 :                 struct ext4_xattr_entry *entry = BFIRST(block_bh);
     961                 :            : 
     962                 :          0 :                 for (; !IS_LAST_ENTRY(entry); entry = EXT4_XATTR_NEXT(entry))
     963                 :          0 :                         if (entry->e_value_inum)
     964                 :            :                                 /* Ref count update on ea_inode. */
     965                 :          0 :                                 credits += 1;
     966                 :            :         }
     967                 :          0 :         return credits;
     968                 :            : }
     969                 :            : 
     970                 :          3 : static int ext4_xattr_ensure_credits(handle_t *handle, struct inode *inode,
     971                 :            :                                      int credits, struct buffer_head *bh,
     972                 :            :                                      bool dirty, bool block_csum)
     973                 :            : {
     974                 :            :         int error;
     975                 :            : 
     976                 :          3 :         if (!ext4_handle_valid(handle))
     977                 :            :                 return 0;
     978                 :            : 
     979                 :          3 :         if (handle->h_buffer_credits >= credits)
     980                 :            :                 return 0;
     981                 :            : 
     982                 :          0 :         error = ext4_journal_extend(handle, credits - handle->h_buffer_credits);
     983                 :          0 :         if (!error)
     984                 :            :                 return 0;
     985                 :          0 :         if (error < 0) {
     986                 :          0 :                 ext4_warning(inode->i_sb, "Extend journal (error %d)", error);
     987                 :          0 :                 return error;
     988                 :            :         }
     989                 :            : 
     990                 :          0 :         if (bh && dirty) {
     991                 :          0 :                 if (block_csum)
     992                 :          0 :                         ext4_xattr_block_csum_set(inode, bh);
     993                 :          0 :                 error = ext4_handle_dirty_metadata(handle, NULL, bh);
     994                 :          0 :                 if (error) {
     995                 :          0 :                         ext4_warning(inode->i_sb, "Handle metadata (error %d)",
     996                 :            :                                      error);
     997                 :          0 :                         return error;
     998                 :            :                 }
     999                 :            :         }
    1000                 :            : 
    1001                 :            :         error = ext4_journal_restart(handle, credits);
    1002                 :          0 :         if (error) {
    1003                 :          0 :                 ext4_warning(inode->i_sb, "Restart journal (error %d)", error);
    1004                 :          0 :                 return error;
    1005                 :            :         }
    1006                 :            : 
    1007                 :          0 :         if (bh) {
    1008                 :          0 :                 error = ext4_journal_get_write_access(handle, bh);
    1009                 :          0 :                 if (error) {
    1010                 :          0 :                         ext4_warning(inode->i_sb,
    1011                 :            :                                      "Get write access failed (error %d)",
    1012                 :            :                                      error);
    1013                 :          0 :                         return error;
    1014                 :            :                 }
    1015                 :            :         }
    1016                 :            :         return 0;
    1017                 :            : }
    1018                 :            : 
    1019                 :          0 : static int ext4_xattr_inode_update_ref(handle_t *handle, struct inode *ea_inode,
    1020                 :            :                                        int ref_change)
    1021                 :            : {
    1022                 :          0 :         struct mb_cache *ea_inode_cache = EA_INODE_CACHE(ea_inode);
    1023                 :            :         struct ext4_iloc iloc;
    1024                 :            :         s64 ref_count;
    1025                 :            :         u32 hash;
    1026                 :            :         int ret;
    1027                 :            : 
    1028                 :            :         inode_lock(ea_inode);
    1029                 :            : 
    1030                 :          0 :         ret = ext4_reserve_inode_write(handle, ea_inode, &iloc);
    1031                 :          0 :         if (ret)
    1032                 :            :                 goto out;
    1033                 :            : 
    1034                 :          0 :         ref_count = ext4_xattr_inode_get_ref(ea_inode);
    1035                 :          0 :         ref_count += ref_change;
    1036                 :          0 :         ext4_xattr_inode_set_ref(ea_inode, ref_count);
    1037                 :            : 
    1038                 :          0 :         if (ref_change > 0) {
    1039                 :          0 :                 WARN_ONCE(ref_count <= 0, "EA inode %lu ref_count=%lld",
    1040                 :            :                           ea_inode->i_ino, ref_count);
    1041                 :            : 
    1042                 :          0 :                 if (ref_count == 1) {
    1043                 :          0 :                         WARN_ONCE(ea_inode->i_nlink, "EA inode %lu i_nlink=%u",
    1044                 :            :                                   ea_inode->i_ino, ea_inode->i_nlink);
    1045                 :            : 
    1046                 :          0 :                         set_nlink(ea_inode, 1);
    1047                 :          0 :                         ext4_orphan_del(handle, ea_inode);
    1048                 :            : 
    1049                 :          0 :                         if (ea_inode_cache) {
    1050                 :            :                                 hash = ext4_xattr_inode_get_hash(ea_inode);
    1051                 :          0 :                                 mb_cache_entry_create(ea_inode_cache,
    1052                 :            :                                                       GFP_NOFS, hash,
    1053                 :          0 :                                                       ea_inode->i_ino,
    1054                 :            :                                                       true /* reusable */);
    1055                 :            :                         }
    1056                 :            :                 }
    1057                 :            :         } else {
    1058                 :          0 :                 WARN_ONCE(ref_count < 0, "EA inode %lu ref_count=%lld",
    1059                 :            :                           ea_inode->i_ino, ref_count);
    1060                 :            : 
    1061                 :          0 :                 if (ref_count == 0) {
    1062                 :          0 :                         WARN_ONCE(ea_inode->i_nlink != 1,
    1063                 :            :                                   "EA inode %lu i_nlink=%u",
    1064                 :            :                                   ea_inode->i_ino, ea_inode->i_nlink);
    1065                 :            : 
    1066                 :          0 :                         clear_nlink(ea_inode);
    1067                 :          0 :                         ext4_orphan_add(handle, ea_inode);
    1068                 :            : 
    1069                 :          0 :                         if (ea_inode_cache) {
    1070                 :            :                                 hash = ext4_xattr_inode_get_hash(ea_inode);
    1071                 :          0 :                                 mb_cache_entry_delete(ea_inode_cache, hash,
    1072                 :          0 :                                                       ea_inode->i_ino);
    1073                 :            :                         }
    1074                 :            :                 }
    1075                 :            :         }
    1076                 :            : 
    1077                 :          0 :         ret = ext4_mark_iloc_dirty(handle, ea_inode, &iloc);
    1078                 :          0 :         if (ret)
    1079                 :          0 :                 ext4_warning_inode(ea_inode,
    1080                 :            :                                    "ext4_mark_iloc_dirty() failed ret=%d", ret);
    1081                 :            : out:
    1082                 :            :         inode_unlock(ea_inode);
    1083                 :          0 :         return ret;
    1084                 :            : }
    1085                 :            : 
    1086                 :            : static int ext4_xattr_inode_inc_ref(handle_t *handle, struct inode *ea_inode)
    1087                 :            : {
    1088                 :          0 :         return ext4_xattr_inode_update_ref(handle, ea_inode, 1);
    1089                 :            : }
    1090                 :            : 
    1091                 :            : static int ext4_xattr_inode_dec_ref(handle_t *handle, struct inode *ea_inode)
    1092                 :            : {
    1093                 :          0 :         return ext4_xattr_inode_update_ref(handle, ea_inode, -1);
    1094                 :            : }
    1095                 :            : 
    1096                 :          0 : static int ext4_xattr_inode_inc_ref_all(handle_t *handle, struct inode *parent,
    1097                 :            :                                         struct ext4_xattr_entry *first)
    1098                 :            : {
    1099                 :            :         struct inode *ea_inode;
    1100                 :            :         struct ext4_xattr_entry *entry;
    1101                 :            :         struct ext4_xattr_entry *failed_entry;
    1102                 :            :         unsigned int ea_ino;
    1103                 :            :         int err, saved_err;
    1104                 :            : 
    1105                 :          0 :         for (entry = first; !IS_LAST_ENTRY(entry);
    1106                 :          0 :              entry = EXT4_XATTR_NEXT(entry)) {
    1107                 :          0 :                 if (!entry->e_value_inum)
    1108                 :          0 :                         continue;
    1109                 :            :                 ea_ino = le32_to_cpu(entry->e_value_inum);
    1110                 :          0 :                 err = ext4_xattr_inode_iget(parent, ea_ino,
    1111                 :            :                                             le32_to_cpu(entry->e_hash),
    1112                 :            :                                             &ea_inode);
    1113                 :          0 :                 if (err)
    1114                 :            :                         goto cleanup;
    1115                 :          0 :                 err = ext4_xattr_inode_inc_ref(handle, ea_inode);
    1116                 :          0 :                 if (err) {
    1117                 :          0 :                         ext4_warning_inode(ea_inode, "inc ref error %d", err);
    1118                 :          0 :                         iput(ea_inode);
    1119                 :          0 :                         goto cleanup;
    1120                 :            :                 }
    1121                 :          0 :                 iput(ea_inode);
    1122                 :            :         }
    1123                 :            :         return 0;
    1124                 :            : 
    1125                 :            : cleanup:
    1126                 :            :         saved_err = err;
    1127                 :          0 :         failed_entry = entry;
    1128                 :            : 
    1129                 :          0 :         for (entry = first; entry != failed_entry;
    1130                 :          0 :              entry = EXT4_XATTR_NEXT(entry)) {
    1131                 :          0 :                 if (!entry->e_value_inum)
    1132                 :          0 :                         continue;
    1133                 :            :                 ea_ino = le32_to_cpu(entry->e_value_inum);
    1134                 :          0 :                 err = ext4_xattr_inode_iget(parent, ea_ino,
    1135                 :            :                                             le32_to_cpu(entry->e_hash),
    1136                 :            :                                             &ea_inode);
    1137                 :          0 :                 if (err) {
    1138                 :          0 :                         ext4_warning(parent->i_sb,
    1139                 :            :                                      "cleanup ea_ino %u iget error %d", ea_ino,
    1140                 :            :                                      err);
    1141                 :          0 :                         continue;
    1142                 :            :                 }
    1143                 :          0 :                 err = ext4_xattr_inode_dec_ref(handle, ea_inode);
    1144                 :          0 :                 if (err)
    1145                 :          0 :                         ext4_warning_inode(ea_inode, "cleanup dec ref error %d",
    1146                 :            :                                            err);
    1147                 :          0 :                 iput(ea_inode);
    1148                 :            :         }
    1149                 :            :         return saved_err;
    1150                 :            : }
    1151                 :            : 
    1152                 :            : static void
    1153                 :          0 : ext4_xattr_inode_dec_ref_all(handle_t *handle, struct inode *parent,
    1154                 :            :                              struct buffer_head *bh,
    1155                 :            :                              struct ext4_xattr_entry *first, bool block_csum,
    1156                 :            :                              struct ext4_xattr_inode_array **ea_inode_array,
    1157                 :            :                              int extra_credits, bool skip_quota)
    1158                 :            : {
    1159                 :            :         struct inode *ea_inode;
    1160                 :            :         struct ext4_xattr_entry *entry;
    1161                 :            :         bool dirty = false;
    1162                 :            :         unsigned int ea_ino;
    1163                 :            :         int err;
    1164                 :            :         int credits;
    1165                 :            : 
    1166                 :            :         /* One credit for dec ref on ea_inode, one for orphan list addition, */
    1167                 :          0 :         credits = 2 + extra_credits;
    1168                 :            : 
    1169                 :          0 :         for (entry = first; !IS_LAST_ENTRY(entry);
    1170                 :          0 :              entry = EXT4_XATTR_NEXT(entry)) {
    1171                 :          0 :                 if (!entry->e_value_inum)
    1172                 :          0 :                         continue;
    1173                 :            :                 ea_ino = le32_to_cpu(entry->e_value_inum);
    1174                 :          0 :                 err = ext4_xattr_inode_iget(parent, ea_ino,
    1175                 :            :                                             le32_to_cpu(entry->e_hash),
    1176                 :            :                                             &ea_inode);
    1177                 :          0 :                 if (err)
    1178                 :          0 :                         continue;
    1179                 :            : 
    1180                 :          0 :                 err = ext4_expand_inode_array(ea_inode_array, ea_inode);
    1181                 :          0 :                 if (err) {
    1182                 :          0 :                         ext4_warning_inode(ea_inode,
    1183                 :            :                                            "Expand inode array err=%d", err);
    1184                 :          0 :                         iput(ea_inode);
    1185                 :          0 :                         continue;
    1186                 :            :                 }
    1187                 :            : 
    1188                 :          0 :                 err = ext4_xattr_ensure_credits(handle, parent, credits, bh,
    1189                 :            :                                                 dirty, block_csum);
    1190                 :          0 :                 if (err) {
    1191                 :          0 :                         ext4_warning_inode(ea_inode, "Ensure credits err=%d",
    1192                 :            :                                            err);
    1193                 :          0 :                         continue;
    1194                 :            :                 }
    1195                 :            : 
    1196                 :          0 :                 err = ext4_xattr_inode_dec_ref(handle, ea_inode);
    1197                 :          0 :                 if (err) {
    1198                 :          0 :                         ext4_warning_inode(ea_inode, "ea_inode dec ref err=%d",
    1199                 :            :                                            err);
    1200                 :          0 :                         continue;
    1201                 :            :                 }
    1202                 :            : 
    1203                 :          0 :                 if (!skip_quota)
    1204                 :          0 :                         ext4_xattr_inode_free_quota(parent, ea_inode,
    1205                 :            :                                               le32_to_cpu(entry->e_value_size));
    1206                 :            : 
    1207                 :            :                 /*
    1208                 :            :                  * Forget about ea_inode within the same transaction that
    1209                 :            :                  * decrements the ref count. This avoids duplicate decrements in
    1210                 :            :                  * case the rest of the work spills over to subsequent
    1211                 :            :                  * transactions.
    1212                 :            :                  */
    1213                 :          0 :                 entry->e_value_inum = 0;
    1214                 :          0 :                 entry->e_value_size = 0;
    1215                 :            : 
    1216                 :            :                 dirty = true;
    1217                 :            :         }
    1218                 :            : 
    1219                 :          0 :         if (dirty) {
    1220                 :            :                 /*
    1221                 :            :                  * Note that we are deliberately skipping csum calculation for
    1222                 :            :                  * the final update because we do not expect any journal
    1223                 :            :                  * restarts until xattr block is freed.
    1224                 :            :                  */
    1225                 :            : 
    1226                 :          0 :                 err = ext4_handle_dirty_metadata(handle, NULL, bh);
    1227                 :          0 :                 if (err)
    1228                 :          0 :                         ext4_warning_inode(parent,
    1229                 :            :                                            "handle dirty metadata err=%d", err);
    1230                 :            :         }
    1231                 :          0 : }
    1232                 :            : 
    1233                 :            : /*
    1234                 :            :  * Release the xattr block BH: If the reference count is > 1, decrement it;
    1235                 :            :  * otherwise free the block.
    1236                 :            :  */
    1237                 :            : static void
    1238                 :          0 : ext4_xattr_release_block(handle_t *handle, struct inode *inode,
    1239                 :            :                          struct buffer_head *bh,
    1240                 :            :                          struct ext4_xattr_inode_array **ea_inode_array,
    1241                 :            :                          int extra_credits)
    1242                 :            : {
    1243                 :          0 :         struct mb_cache *ea_block_cache = EA_BLOCK_CACHE(inode);
    1244                 :            :         u32 hash, ref;
    1245                 :            :         int error = 0;
    1246                 :            : 
    1247                 :            :         BUFFER_TRACE(bh, "get_write_access");
    1248                 :          0 :         error = ext4_journal_get_write_access(handle, bh);
    1249                 :          0 :         if (error)
    1250                 :            :                 goto out;
    1251                 :            : 
    1252                 :          0 :         lock_buffer(bh);
    1253                 :          0 :         hash = le32_to_cpu(BHDR(bh)->h_hash);
    1254                 :          0 :         ref = le32_to_cpu(BHDR(bh)->h_refcount);
    1255                 :          0 :         if (ref == 1) {
    1256                 :            :                 ea_bdebug(bh, "refcount now=0; freeing");
    1257                 :            :                 /*
    1258                 :            :                  * This must happen under buffer lock for
    1259                 :            :                  * ext4_xattr_block_set() to reliably detect freed block
    1260                 :            :                  */
    1261                 :          0 :                 if (ea_block_cache)
    1262                 :          0 :                         mb_cache_entry_delete(ea_block_cache, hash,
    1263                 :            :                                               bh->b_blocknr);
    1264                 :            :                 get_bh(bh);
    1265                 :          0 :                 unlock_buffer(bh);
    1266                 :            : 
    1267                 :          0 :                 if (ext4_has_feature_ea_inode(inode->i_sb))
    1268                 :          0 :                         ext4_xattr_inode_dec_ref_all(handle, inode, bh,
    1269                 :          0 :                                                      BFIRST(bh),
    1270                 :            :                                                      true /* block_csum */,
    1271                 :            :                                                      ea_inode_array,
    1272                 :            :                                                      extra_credits,
    1273                 :            :                                                      true /* skip_quota */);
    1274                 :          0 :                 ext4_free_blocks(handle, inode, bh, 0, 1,
    1275                 :            :                                  EXT4_FREE_BLOCKS_METADATA |
    1276                 :            :                                  EXT4_FREE_BLOCKS_FORGET);
    1277                 :            :         } else {
    1278                 :          0 :                 ref--;
    1279                 :          0 :                 BHDR(bh)->h_refcount = cpu_to_le32(ref);
    1280                 :          0 :                 if (ref == EXT4_XATTR_REFCOUNT_MAX - 1) {
    1281                 :            :                         struct mb_cache_entry *ce;
    1282                 :            : 
    1283                 :          0 :                         if (ea_block_cache) {
    1284                 :          0 :                                 ce = mb_cache_entry_get(ea_block_cache, hash,
    1285                 :            :                                                         bh->b_blocknr);
    1286                 :          0 :                                 if (ce) {
    1287                 :          0 :                                         ce->e_reusable = 1;
    1288                 :          0 :                                         mb_cache_entry_put(ea_block_cache, ce);
    1289                 :            :                                 }
    1290                 :            :                         }
    1291                 :            :                 }
    1292                 :            : 
    1293                 :          0 :                 ext4_xattr_block_csum_set(inode, bh);
    1294                 :            :                 /*
    1295                 :            :                  * Beware of this ugliness: Releasing of xattr block references
    1296                 :            :                  * from different inodes can race and so we have to protect
    1297                 :            :                  * from a race where someone else frees the block (and releases
    1298                 :            :                  * its journal_head) before we are done dirtying the buffer. In
    1299                 :            :                  * nojournal mode this race is harmless and we actually cannot
    1300                 :            :                  * call ext4_handle_dirty_metadata() with locked buffer as
    1301                 :            :                  * that function can call sync_dirty_buffer() so for that case
    1302                 :            :                  * we handle the dirtying after unlocking the buffer.
    1303                 :            :                  */
    1304                 :          0 :                 if (ext4_handle_valid(handle))
    1305                 :          0 :                         error = ext4_handle_dirty_metadata(handle, inode, bh);
    1306                 :          0 :                 unlock_buffer(bh);
    1307                 :          0 :                 if (!ext4_handle_valid(handle))
    1308                 :          0 :                         error = ext4_handle_dirty_metadata(handle, inode, bh);
    1309                 :          0 :                 if (IS_SYNC(inode))
    1310                 :            :                         ext4_handle_sync(handle);
    1311                 :          0 :                 dquot_free_block(inode, EXT4_C2B(EXT4_SB(inode->i_sb), 1));
    1312                 :            :                 ea_bdebug(bh, "refcount now=%d; releasing",
    1313                 :            :                           le32_to_cpu(BHDR(bh)->h_refcount));
    1314                 :            :         }
    1315                 :            : out:
    1316                 :          0 :         ext4_std_error(inode->i_sb, error);
    1317                 :          0 :         return;
    1318                 :            : }
    1319                 :            : 
    1320                 :            : /*
    1321                 :            :  * Find the available free space for EAs. This also returns the total number of
    1322                 :            :  * bytes used by EA entries.
    1323                 :            :  */
    1324                 :          0 : static size_t ext4_xattr_free_space(struct ext4_xattr_entry *last,
    1325                 :            :                                     size_t *min_offs, void *base, int *total)
    1326                 :            : {
    1327                 :          0 :         for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
    1328                 :          0 :                 if (!last->e_value_inum && last->e_value_size) {
    1329                 :          0 :                         size_t offs = le16_to_cpu(last->e_value_offs);
    1330                 :          0 :                         if (offs < *min_offs)
    1331                 :          0 :                                 *min_offs = offs;
    1332                 :            :                 }
    1333                 :          0 :                 if (total)
    1334                 :          0 :                         *total += EXT4_XATTR_LEN(last->e_name_len);
    1335                 :            :         }
    1336                 :          0 :         return (*min_offs - ((void *)last - base) - sizeof(__u32));
    1337                 :            : }
    1338                 :            : 
    1339                 :            : /*
    1340                 :            :  * Write the value of the EA in an inode.
    1341                 :            :  */
    1342                 :          0 : static int ext4_xattr_inode_write(handle_t *handle, struct inode *ea_inode,
    1343                 :            :                                   const void *buf, int bufsize)
    1344                 :            : {
    1345                 :            :         struct buffer_head *bh = NULL;
    1346                 :            :         unsigned long block = 0;
    1347                 :          0 :         int blocksize = ea_inode->i_sb->s_blocksize;
    1348                 :          0 :         int max_blocks = (bufsize + blocksize - 1) >> ea_inode->i_blkbits;
    1349                 :            :         int csize, wsize = 0;
    1350                 :            :         int ret = 0;
    1351                 :          0 :         int retries = 0;
    1352                 :            : 
    1353                 :            : retry:
    1354                 :          0 :         while (ret >= 0 && ret < max_blocks) {
    1355                 :            :                 struct ext4_map_blocks map;
    1356                 :          0 :                 map.m_lblk = block += ret;
    1357                 :          0 :                 map.m_len = max_blocks -= ret;
    1358                 :            : 
    1359                 :          0 :                 ret = ext4_map_blocks(handle, ea_inode, &map,
    1360                 :            :                                       EXT4_GET_BLOCKS_CREATE);
    1361                 :          0 :                 if (ret <= 0) {
    1362                 :          0 :                         ext4_mark_inode_dirty(handle, ea_inode);
    1363                 :          0 :                         if (ret == -ENOSPC &&
    1364                 :          0 :                             ext4_should_retry_alloc(ea_inode->i_sb, &retries)) {
    1365                 :            :                                 ret = 0;
    1366                 :          0 :                                 goto retry;
    1367                 :            :                         }
    1368                 :          0 :                         break;
    1369                 :            :                 }
    1370                 :            :         }
    1371                 :            : 
    1372                 :          0 :         if (ret < 0)
    1373                 :            :                 return ret;
    1374                 :            : 
    1375                 :            :         block = 0;
    1376                 :          0 :         while (wsize < bufsize) {
    1377                 :          0 :                 if (bh != NULL)
    1378                 :            :                         brelse(bh);
    1379                 :          0 :                 csize = (bufsize - wsize) > blocksize ? blocksize :
    1380                 :          0 :                                                                 bufsize - wsize;
    1381                 :          0 :                 bh = ext4_getblk(handle, ea_inode, block, 0);
    1382                 :          0 :                 if (IS_ERR(bh))
    1383                 :          0 :                         return PTR_ERR(bh);
    1384                 :          0 :                 if (!bh) {
    1385                 :          0 :                         WARN_ON_ONCE(1);
    1386                 :          0 :                         EXT4_ERROR_INODE(ea_inode,
    1387                 :            :                                          "ext4_getblk() return bh = NULL");
    1388                 :          0 :                         return -EFSCORRUPTED;
    1389                 :            :                 }
    1390                 :          0 :                 ret = ext4_journal_get_write_access(handle, bh);
    1391                 :          0 :                 if (ret)
    1392                 :            :                         goto out;
    1393                 :            : 
    1394                 :          0 :                 memcpy(bh->b_data, buf, csize);
    1395                 :            :                 set_buffer_uptodate(bh);
    1396                 :          0 :                 ext4_handle_dirty_metadata(handle, ea_inode, bh);
    1397                 :            : 
    1398                 :          0 :                 buf += csize;
    1399                 :          0 :                 wsize += csize;
    1400                 :          0 :                 block += 1;
    1401                 :            :         }
    1402                 :            : 
    1403                 :            :         inode_lock(ea_inode);
    1404                 :          0 :         i_size_write(ea_inode, wsize);
    1405                 :          0 :         ext4_update_i_disksize(ea_inode, wsize);
    1406                 :            :         inode_unlock(ea_inode);
    1407                 :            : 
    1408                 :          0 :         ext4_mark_inode_dirty(handle, ea_inode);
    1409                 :            : 
    1410                 :            : out:
    1411                 :            :         brelse(bh);
    1412                 :            : 
    1413                 :          0 :         return ret;
    1414                 :            : }
    1415                 :            : 
    1416                 :            : /*
    1417                 :            :  * Create an inode to store the value of a large EA.
    1418                 :            :  */
    1419                 :          0 : static struct inode *ext4_xattr_inode_create(handle_t *handle,
    1420                 :            :                                              struct inode *inode, u32 hash)
    1421                 :            : {
    1422                 :            :         struct inode *ea_inode = NULL;
    1423                 :          0 :         uid_t owner[2] = { i_uid_read(inode), i_gid_read(inode) };
    1424                 :            :         int err;
    1425                 :            : 
    1426                 :            :         /*
    1427                 :            :          * Let the next inode be the goal, so we try and allocate the EA inode
    1428                 :            :          * in the same group, or nearby one.
    1429                 :            :          */
    1430                 :          0 :         ea_inode = ext4_new_inode(handle, inode->i_sb->s_root->d_inode,
    1431                 :            :                                   S_IFREG | 0600, NULL, inode->i_ino + 1, owner,
    1432                 :            :                                   EXT4_EA_INODE_FL);
    1433                 :          0 :         if (!IS_ERR(ea_inode)) {
    1434                 :          0 :                 ea_inode->i_op = &ext4_file_inode_operations;
    1435                 :          0 :                 ea_inode->i_fop = &ext4_file_operations;
    1436                 :          0 :                 ext4_set_aops(ea_inode);
    1437                 :            :                 ext4_xattr_inode_set_class(ea_inode);
    1438                 :          0 :                 unlock_new_inode(ea_inode);
    1439                 :            :                 ext4_xattr_inode_set_ref(ea_inode, 1);
    1440                 :            :                 ext4_xattr_inode_set_hash(ea_inode, hash);
    1441                 :          0 :                 err = ext4_mark_inode_dirty(handle, ea_inode);
    1442                 :          0 :                 if (!err)
    1443                 :          0 :                         err = ext4_inode_attach_jinode(ea_inode);
    1444                 :          0 :                 if (err) {
    1445                 :          0 :                         iput(ea_inode);
    1446                 :          0 :                         return ERR_PTR(err);
    1447                 :            :                 }
    1448                 :            : 
    1449                 :            :                 /*
    1450                 :            :                  * Xattr inodes are shared therefore quota charging is performed
    1451                 :            :                  * at a higher level.
    1452                 :            :                  */
    1453                 :          0 :                 dquot_free_inode(ea_inode);
    1454                 :          0 :                 dquot_drop(ea_inode);
    1455                 :            :                 inode_lock(ea_inode);
    1456                 :          0 :                 ea_inode->i_flags |= S_NOQUOTA;
    1457                 :            :                 inode_unlock(ea_inode);
    1458                 :            :         }
    1459                 :            : 
    1460                 :          0 :         return ea_inode;
    1461                 :            : }
    1462                 :            : 
    1463                 :            : static struct inode *
    1464                 :          0 : ext4_xattr_inode_cache_find(struct inode *inode, const void *value,
    1465                 :            :                             size_t value_len, u32 hash)
    1466                 :            : {
    1467                 :            :         struct inode *ea_inode;
    1468                 :            :         struct mb_cache_entry *ce;
    1469                 :          0 :         struct mb_cache *ea_inode_cache = EA_INODE_CACHE(inode);
    1470                 :            :         void *ea_data;
    1471                 :            : 
    1472                 :          0 :         if (!ea_inode_cache)
    1473                 :            :                 return NULL;
    1474                 :            : 
    1475                 :          0 :         ce = mb_cache_entry_find_first(ea_inode_cache, hash);
    1476                 :          0 :         if (!ce)
    1477                 :            :                 return NULL;
    1478                 :            : 
    1479                 :          0 :         ea_data = ext4_kvmalloc(value_len, GFP_NOFS);
    1480                 :          0 :         if (!ea_data) {
    1481                 :          0 :                 mb_cache_entry_put(ea_inode_cache, ce);
    1482                 :          0 :                 return NULL;
    1483                 :            :         }
    1484                 :            : 
    1485                 :          0 :         while (ce) {
    1486                 :          0 :                 ea_inode = ext4_iget(inode->i_sb, ce->e_value,
    1487                 :            :                                      EXT4_IGET_NORMAL);
    1488                 :          0 :                 if (!IS_ERR(ea_inode) &&
    1489                 :          0 :                     !is_bad_inode(ea_inode) &&
    1490                 :          0 :                     (EXT4_I(ea_inode)->i_flags & EXT4_EA_INODE_FL) &&
    1491                 :          0 :                     i_size_read(ea_inode) == value_len &&
    1492                 :          0 :                     !ext4_xattr_inode_read(ea_inode, ea_data, value_len) &&
    1493                 :          0 :                     !ext4_xattr_inode_verify_hashes(ea_inode, NULL, ea_data,
    1494                 :          0 :                                                     value_len) &&
    1495                 :          0 :                     !memcmp(value, ea_data, value_len)) {
    1496                 :          0 :                         mb_cache_entry_touch(ea_inode_cache, ce);
    1497                 :          0 :                         mb_cache_entry_put(ea_inode_cache, ce);
    1498                 :          0 :                         kvfree(ea_data);
    1499                 :          0 :                         return ea_inode;
    1500                 :            :                 }
    1501                 :            : 
    1502                 :          0 :                 if (!IS_ERR(ea_inode))
    1503                 :          0 :                         iput(ea_inode);
    1504                 :          0 :                 ce = mb_cache_entry_find_next(ea_inode_cache, ce);
    1505                 :            :         }
    1506                 :          0 :         kvfree(ea_data);
    1507                 :          0 :         return NULL;
    1508                 :            : }
    1509                 :            : 
    1510                 :            : /*
    1511                 :            :  * Add value of the EA in an inode.
    1512                 :            :  */
    1513                 :          0 : static int ext4_xattr_inode_lookup_create(handle_t *handle, struct inode *inode,
    1514                 :            :                                           const void *value, size_t value_len,
    1515                 :            :                                           struct inode **ret_inode)
    1516                 :            : {
    1517                 :            :         struct inode *ea_inode;
    1518                 :            :         u32 hash;
    1519                 :            :         int err;
    1520                 :            : 
    1521                 :          0 :         hash = ext4_xattr_inode_hash(EXT4_SB(inode->i_sb), value, value_len);
    1522                 :          0 :         ea_inode = ext4_xattr_inode_cache_find(inode, value, value_len, hash);
    1523                 :          0 :         if (ea_inode) {
    1524                 :            :                 err = ext4_xattr_inode_inc_ref(handle, ea_inode);
    1525                 :          0 :                 if (err) {
    1526                 :          0 :                         iput(ea_inode);
    1527                 :          0 :                         return err;
    1528                 :            :                 }
    1529                 :            : 
    1530                 :          0 :                 *ret_inode = ea_inode;
    1531                 :          0 :                 return 0;
    1532                 :            :         }
    1533                 :            : 
    1534                 :            :         /* Create an inode for the EA value */
    1535                 :          0 :         ea_inode = ext4_xattr_inode_create(handle, inode, hash);
    1536                 :          0 :         if (IS_ERR(ea_inode))
    1537                 :          0 :                 return PTR_ERR(ea_inode);
    1538                 :            : 
    1539                 :          0 :         err = ext4_xattr_inode_write(handle, ea_inode, value, value_len);
    1540                 :          0 :         if (err) {
    1541                 :            :                 ext4_xattr_inode_dec_ref(handle, ea_inode);
    1542                 :          0 :                 iput(ea_inode);
    1543                 :          0 :                 return err;
    1544                 :            :         }
    1545                 :            : 
    1546                 :          0 :         if (EA_INODE_CACHE(inode))
    1547                 :          0 :                 mb_cache_entry_create(EA_INODE_CACHE(inode), GFP_NOFS, hash,
    1548                 :          0 :                                       ea_inode->i_ino, true /* reusable */);
    1549                 :            : 
    1550                 :          0 :         *ret_inode = ea_inode;
    1551                 :          0 :         return 0;
    1552                 :            : }
    1553                 :            : 
    1554                 :            : /*
    1555                 :            :  * Reserve min(block_size/8, 1024) bytes for xattr entries/names if ea_inode
    1556                 :            :  * feature is enabled.
    1557                 :            :  */
    1558                 :            : #define EXT4_XATTR_BLOCK_RESERVE(inode) min(i_blocksize(inode)/8, 1024U)
    1559                 :            : 
    1560                 :          0 : static int ext4_xattr_set_entry(struct ext4_xattr_info *i,
    1561                 :            :                                 struct ext4_xattr_search *s,
    1562                 :            :                                 handle_t *handle, struct inode *inode,
    1563                 :            :                                 bool is_block)
    1564                 :            : {
    1565                 :            :         struct ext4_xattr_entry *last, *next;
    1566                 :          0 :         struct ext4_xattr_entry *here = s->here;
    1567                 :          0 :         size_t min_offs = s->end - s->base, name_len = strlen(i->name);
    1568                 :          0 :         int in_inode = i->in_inode;
    1569                 :          0 :         struct inode *old_ea_inode = NULL;
    1570                 :          0 :         struct inode *new_ea_inode = NULL;
    1571                 :            :         size_t old_size, new_size;
    1572                 :            :         int ret;
    1573                 :            : 
    1574                 :            :         /* Space used by old and new values. */
    1575                 :          0 :         old_size = (!s->not_found && !here->e_value_inum) ?
    1576                 :          0 :                         EXT4_XATTR_SIZE(le32_to_cpu(here->e_value_size)) : 0;
    1577                 :          0 :         new_size = (i->value && !in_inode) ? EXT4_XATTR_SIZE(i->value_len) : 0;
    1578                 :            : 
    1579                 :            :         /*
    1580                 :            :          * Optimization for the simple case when old and new values have the
    1581                 :            :          * same padded sizes. Not applicable if external inodes are involved.
    1582                 :            :          */
    1583                 :          0 :         if (new_size && new_size == old_size) {
    1584                 :          0 :                 size_t offs = le16_to_cpu(here->e_value_offs);
    1585                 :          0 :                 void *val = s->base + offs;
    1586                 :            : 
    1587                 :          0 :                 here->e_value_size = cpu_to_le32(i->value_len);
    1588                 :          0 :                 if (i->value == EXT4_ZERO_XATTR_VALUE) {
    1589                 :          0 :                         memset(val, 0, new_size);
    1590                 :            :                 } else {
    1591                 :          0 :                         memcpy(val, i->value, i->value_len);
    1592                 :            :                         /* Clear padding bytes. */
    1593                 :          0 :                         memset(val + i->value_len, 0, new_size - i->value_len);
    1594                 :            :                 }
    1595                 :            :                 goto update_hash;
    1596                 :            :         }
    1597                 :            : 
    1598                 :            :         /* Compute min_offs and last. */
    1599                 :          0 :         last = s->first;
    1600                 :          0 :         for (; !IS_LAST_ENTRY(last); last = next) {
    1601                 :          0 :                 next = EXT4_XATTR_NEXT(last);
    1602                 :          0 :                 if ((void *)next >= s->end) {
    1603                 :          0 :                         EXT4_ERROR_INODE(inode, "corrupted xattr entries");
    1604                 :            :                         ret = -EFSCORRUPTED;
    1605                 :          0 :                         goto out;
    1606                 :            :                 }
    1607                 :          0 :                 if (!last->e_value_inum && last->e_value_size) {
    1608                 :          0 :                         size_t offs = le16_to_cpu(last->e_value_offs);
    1609                 :          0 :                         if (offs < min_offs)
    1610                 :            :                                 min_offs = offs;
    1611                 :            :                 }
    1612                 :            :         }
    1613                 :            : 
    1614                 :            :         /* Check whether we have enough space. */
    1615                 :          0 :         if (i->value) {
    1616                 :            :                 size_t free;
    1617                 :            : 
    1618                 :          0 :                 free = min_offs - ((void *)last - s->base) - sizeof(__u32);
    1619                 :          0 :                 if (!s->not_found)
    1620                 :          0 :                         free += EXT4_XATTR_LEN(name_len) + old_size;
    1621                 :            : 
    1622                 :          0 :                 if (free < EXT4_XATTR_LEN(name_len) + new_size) {
    1623                 :            :                         ret = -ENOSPC;
    1624                 :            :                         goto out;
    1625                 :            :                 }
    1626                 :            : 
    1627                 :            :                 /*
    1628                 :            :                  * If storing the value in an external inode is an option,
    1629                 :            :                  * reserve space for xattr entries/names in the external
    1630                 :            :                  * attribute block so that a long value does not occupy the
    1631                 :            :                  * whole space and prevent futher entries being added.
    1632                 :            :                  */
    1633                 :          0 :                 if (ext4_has_feature_ea_inode(inode->i_sb) &&
    1634                 :          0 :                     new_size && is_block &&
    1635                 :          0 :                     (min_offs + old_size - new_size) <
    1636                 :          0 :                                         EXT4_XATTR_BLOCK_RESERVE(inode)) {
    1637                 :            :                         ret = -ENOSPC;
    1638                 :            :                         goto out;
    1639                 :            :                 }
    1640                 :            :         }
    1641                 :            : 
    1642                 :            :         /*
    1643                 :            :          * Getting access to old and new ea inodes is subject to failures.
    1644                 :            :          * Finish that work before doing any modifications to the xattr data.
    1645                 :            :          */
    1646                 :          0 :         if (!s->not_found && here->e_value_inum) {
    1647                 :          0 :                 ret = ext4_xattr_inode_iget(inode,
    1648                 :            :                                             le32_to_cpu(here->e_value_inum),
    1649                 :            :                                             le32_to_cpu(here->e_hash),
    1650                 :            :                                             &old_ea_inode);
    1651                 :          0 :                 if (ret) {
    1652                 :          0 :                         old_ea_inode = NULL;
    1653                 :          0 :                         goto out;
    1654                 :            :                 }
    1655                 :            :         }
    1656                 :          0 :         if (i->value && in_inode) {
    1657                 :          0 :                 WARN_ON_ONCE(!i->value_len);
    1658                 :            : 
    1659                 :          0 :                 ret = ext4_xattr_inode_alloc_quota(inode, i->value_len);
    1660                 :          0 :                 if (ret)
    1661                 :            :                         goto out;
    1662                 :            : 
    1663                 :          0 :                 ret = ext4_xattr_inode_lookup_create(handle, inode, i->value,
    1664                 :            :                                                      i->value_len,
    1665                 :            :                                                      &new_ea_inode);
    1666                 :          0 :                 if (ret) {
    1667                 :          0 :                         new_ea_inode = NULL;
    1668                 :          0 :                         ext4_xattr_inode_free_quota(inode, NULL, i->value_len);
    1669                 :          0 :                         goto out;
    1670                 :            :                 }
    1671                 :            :         }
    1672                 :            : 
    1673                 :          0 :         if (old_ea_inode) {
    1674                 :            :                 /* We are ready to release ref count on the old_ea_inode. */
    1675                 :            :                 ret = ext4_xattr_inode_dec_ref(handle, old_ea_inode);
    1676                 :          0 :                 if (ret) {
    1677                 :            :                         /* Release newly required ref count on new_ea_inode. */
    1678                 :          0 :                         if (new_ea_inode) {
    1679                 :            :                                 int err;
    1680                 :            : 
    1681                 :            :                                 err = ext4_xattr_inode_dec_ref(handle,
    1682                 :            :                                                                new_ea_inode);
    1683                 :          0 :                                 if (err)
    1684                 :          0 :                                         ext4_warning_inode(new_ea_inode,
    1685                 :            :                                                   "dec ref new_ea_inode err=%d",
    1686                 :            :                                                   err);
    1687                 :          0 :                                 ext4_xattr_inode_free_quota(inode, new_ea_inode,
    1688                 :            :                                                             i->value_len);
    1689                 :            :                         }
    1690                 :            :                         goto out;
    1691                 :            :                 }
    1692                 :            : 
    1693                 :          0 :                 ext4_xattr_inode_free_quota(inode, old_ea_inode,
    1694                 :            :                                             le32_to_cpu(here->e_value_size));
    1695                 :            :         }
    1696                 :            : 
    1697                 :            :         /* No failures allowed past this point. */
    1698                 :            : 
    1699                 :          0 :         if (!s->not_found && here->e_value_size && !here->e_value_inum) {
    1700                 :            :                 /* Remove the old value. */
    1701                 :          0 :                 void *first_val = s->base + min_offs;
    1702                 :          0 :                 size_t offs = le16_to_cpu(here->e_value_offs);
    1703                 :          0 :                 void *val = s->base + offs;
    1704                 :            : 
    1705                 :          0 :                 memmove(first_val + old_size, first_val, val - first_val);
    1706                 :          0 :                 memset(first_val, 0, old_size);
    1707                 :          0 :                 min_offs += old_size;
    1708                 :            : 
    1709                 :            :                 /* Adjust all value offsets. */
    1710                 :          0 :                 last = s->first;
    1711                 :          0 :                 while (!IS_LAST_ENTRY(last)) {
    1712                 :          0 :                         size_t o = le16_to_cpu(last->e_value_offs);
    1713                 :            : 
    1714                 :          0 :                         if (!last->e_value_inum &&
    1715                 :          0 :                             last->e_value_size && o < offs)
    1716                 :          0 :                                 last->e_value_offs = cpu_to_le16(o + old_size);
    1717                 :          0 :                         last = EXT4_XATTR_NEXT(last);
    1718                 :            :                 }
    1719                 :            :         }
    1720                 :            : 
    1721                 :          0 :         if (!i->value) {
    1722                 :            :                 /* Remove old name. */
    1723                 :          0 :                 size_t size = EXT4_XATTR_LEN(name_len);
    1724                 :            : 
    1725                 :          0 :                 last = ENTRY((void *)last - size);
    1726                 :          0 :                 memmove(here, (void *)here + size,
    1727                 :          0 :                         (void *)last - (void *)here + sizeof(__u32));
    1728                 :          0 :                 memset(last, 0, size);
    1729                 :          0 :         } else if (s->not_found) {
    1730                 :            :                 /* Insert new name. */
    1731                 :          0 :                 size_t size = EXT4_XATTR_LEN(name_len);
    1732                 :          0 :                 size_t rest = (void *)last - (void *)here + sizeof(__u32);
    1733                 :            : 
    1734                 :          0 :                 memmove((void *)here + size, here, rest);
    1735                 :          0 :                 memset(here, 0, size);
    1736                 :          0 :                 here->e_name_index = i->name_index;
    1737                 :          0 :                 here->e_name_len = name_len;
    1738                 :          0 :                 memcpy(here->e_name, i->name, name_len);
    1739                 :            :         } else {
    1740                 :            :                 /* This is an update, reset value info. */
    1741                 :          0 :                 here->e_value_inum = 0;
    1742                 :          0 :                 here->e_value_offs = 0;
    1743                 :          0 :                 here->e_value_size = 0;
    1744                 :            :         }
    1745                 :            : 
    1746                 :          0 :         if (i->value) {
    1747                 :            :                 /* Insert new value. */
    1748                 :          0 :                 if (in_inode) {
    1749                 :          0 :                         here->e_value_inum = cpu_to_le32(new_ea_inode->i_ino);
    1750                 :          0 :                 } else if (i->value_len) {
    1751                 :          0 :                         void *val = s->base + min_offs - new_size;
    1752                 :            : 
    1753                 :          0 :                         here->e_value_offs = cpu_to_le16(min_offs - new_size);
    1754                 :          0 :                         if (i->value == EXT4_ZERO_XATTR_VALUE) {
    1755                 :          0 :                                 memset(val, 0, new_size);
    1756                 :            :                         } else {
    1757                 :          0 :                                 memcpy(val, i->value, i->value_len);
    1758                 :            :                                 /* Clear padding bytes. */
    1759                 :          0 :                                 memset(val + i->value_len, 0,
    1760                 :            :                                        new_size - i->value_len);
    1761                 :            :                         }
    1762                 :            :                 }
    1763                 :          0 :                 here->e_value_size = cpu_to_le32(i->value_len);
    1764                 :            :         }
    1765                 :            : 
    1766                 :            : update_hash:
    1767                 :          0 :         if (i->value) {
    1768                 :            :                 __le32 hash = 0;
    1769                 :            : 
    1770                 :            :                 /* Entry hash calculation. */
    1771                 :          0 :                 if (in_inode) {
    1772                 :            :                         __le32 crc32c_hash;
    1773                 :            : 
    1774                 :            :                         /*
    1775                 :            :                          * Feed crc32c hash instead of the raw value for entry
    1776                 :            :                          * hash calculation. This is to avoid walking
    1777                 :            :                          * potentially long value buffer again.
    1778                 :            :                          */
    1779                 :          0 :                         crc32c_hash = cpu_to_le32(
    1780                 :            :                                        ext4_xattr_inode_get_hash(new_ea_inode));
    1781                 :          0 :                         hash = ext4_xattr_hash_entry(here->e_name,
    1782                 :          0 :                                                      here->e_name_len,
    1783                 :            :                                                      &crc32c_hash, 1);
    1784                 :          0 :                 } else if (is_block) {
    1785                 :          0 :                         __le32 *value = s->base + le16_to_cpu(
    1786                 :            :                                                         here->e_value_offs);
    1787                 :            : 
    1788                 :          0 :                         hash = ext4_xattr_hash_entry(here->e_name,
    1789                 :          0 :                                                      here->e_name_len, value,
    1790                 :            :                                                      new_size >> 2);
    1791                 :            :                 }
    1792                 :          0 :                 here->e_hash = hash;
    1793                 :            :         }
    1794                 :            : 
    1795                 :          0 :         if (is_block)
    1796                 :          0 :                 ext4_xattr_rehash((struct ext4_xattr_header *)s->base);
    1797                 :            : 
    1798                 :            :         ret = 0;
    1799                 :            : out:
    1800                 :          0 :         iput(old_ea_inode);
    1801                 :          0 :         iput(new_ea_inode);
    1802                 :          0 :         return ret;
    1803                 :            : }
    1804                 :            : 
    1805                 :            : struct ext4_xattr_block_find {
    1806                 :            :         struct ext4_xattr_search s;
    1807                 :            :         struct buffer_head *bh;
    1808                 :            : };
    1809                 :            : 
    1810                 :            : static int
    1811                 :          3 : ext4_xattr_block_find(struct inode *inode, struct ext4_xattr_info *i,
    1812                 :            :                       struct ext4_xattr_block_find *bs)
    1813                 :            : {
    1814                 :          3 :         struct super_block *sb = inode->i_sb;
    1815                 :            :         int error;
    1816                 :            : 
    1817                 :            :         ea_idebug(inode, "name=%d.%s, value=%p, value_len=%ld",
    1818                 :            :                   i->name_index, i->name, i->value, (long)i->value_len);
    1819                 :            : 
    1820                 :          3 :         if (EXT4_I(inode)->i_file_acl) {
    1821                 :            :                 /* The inode already has an extended attribute block. */
    1822                 :          0 :                 bs->bh = ext4_sb_bread(sb, EXT4_I(inode)->i_file_acl, REQ_PRIO);
    1823                 :          0 :                 if (IS_ERR(bs->bh)) {
    1824                 :            :                         error = PTR_ERR(bs->bh);
    1825                 :          0 :                         bs->bh = NULL;
    1826                 :          0 :                         return error;
    1827                 :            :                 }
    1828                 :            :                 ea_bdebug(bs->bh, "b_count=%d, refcount=%d",
    1829                 :            :                         atomic_read(&(bs->bh->b_count)),
    1830                 :            :                         le32_to_cpu(BHDR(bs->bh)->h_refcount));
    1831                 :          0 :                 error = ext4_xattr_check_block(inode, bs->bh);
    1832                 :          0 :                 if (error)
    1833                 :            :                         return error;
    1834                 :            :                 /* Find the named attribute. */
    1835                 :          0 :                 bs->s.base = BHDR(bs->bh);
    1836                 :          0 :                 bs->s.first = BFIRST(bs->bh);
    1837                 :          0 :                 bs->s.end = bs->bh->b_data + bs->bh->b_size;
    1838                 :          0 :                 bs->s.here = bs->s.first;
    1839                 :          0 :                 error = xattr_find_entry(inode, &bs->s.here, bs->s.end,
    1840                 :            :                                          i->name_index, i->name, 1);
    1841                 :          0 :                 if (error && error != -ENODATA)
    1842                 :            :                         return error;
    1843                 :          0 :                 bs->s.not_found = error;
    1844                 :            :         }
    1845                 :            :         return 0;
    1846                 :            : }
    1847                 :            : 
    1848                 :            : static int
    1849                 :          0 : ext4_xattr_block_set(handle_t *handle, struct inode *inode,
    1850                 :            :                      struct ext4_xattr_info *i,
    1851                 :            :                      struct ext4_xattr_block_find *bs)
    1852                 :            : {
    1853                 :          0 :         struct super_block *sb = inode->i_sb;
    1854                 :            :         struct buffer_head *new_bh = NULL;
    1855                 :          0 :         struct ext4_xattr_search s_copy = bs->s;
    1856                 :            :         struct ext4_xattr_search *s = &s_copy;
    1857                 :          0 :         struct mb_cache_entry *ce = NULL;
    1858                 :          0 :         int error = 0;
    1859                 :          0 :         struct mb_cache *ea_block_cache = EA_BLOCK_CACHE(inode);
    1860                 :          0 :         struct inode *ea_inode = NULL, *tmp_inode;
    1861                 :            :         size_t old_ea_inode_quota = 0;
    1862                 :            :         unsigned int ea_ino;
    1863                 :            : 
    1864                 :            : 
    1865                 :            : #define header(x) ((struct ext4_xattr_header *)(x))
    1866                 :            : 
    1867                 :          0 :         if (s->base) {
    1868                 :            :                 BUFFER_TRACE(bs->bh, "get_write_access");
    1869                 :          0 :                 error = ext4_journal_get_write_access(handle, bs->bh);
    1870                 :          0 :                 if (error)
    1871                 :            :                         goto cleanup;
    1872                 :          0 :                 lock_buffer(bs->bh);
    1873                 :            : 
    1874                 :          0 :                 if (header(s->base)->h_refcount == cpu_to_le32(1)) {
    1875                 :          0 :                         __u32 hash = le32_to_cpu(BHDR(bs->bh)->h_hash);
    1876                 :            : 
    1877                 :            :                         /*
    1878                 :            :                          * This must happen under buffer lock for
    1879                 :            :                          * ext4_xattr_block_set() to reliably detect modified
    1880                 :            :                          * block
    1881                 :            :                          */
    1882                 :          0 :                         if (ea_block_cache)
    1883                 :          0 :                                 mb_cache_entry_delete(ea_block_cache, hash,
    1884                 :            :                                                       bs->bh->b_blocknr);
    1885                 :            :                         ea_bdebug(bs->bh, "modifying in-place");
    1886                 :          0 :                         error = ext4_xattr_set_entry(i, s, handle, inode,
    1887                 :            :                                                      true /* is_block */);
    1888                 :          0 :                         ext4_xattr_block_csum_set(inode, bs->bh);
    1889                 :          0 :                         unlock_buffer(bs->bh);
    1890                 :          0 :                         if (error == -EFSCORRUPTED)
    1891                 :            :                                 goto bad_block;
    1892                 :          0 :                         if (!error)
    1893                 :          0 :                                 error = ext4_handle_dirty_metadata(handle,
    1894                 :            :                                                                    inode,
    1895                 :            :                                                                    bs->bh);
    1896                 :          0 :                         if (error)
    1897                 :            :                                 goto cleanup;
    1898                 :            :                         goto inserted;
    1899                 :            :                 } else {
    1900                 :          0 :                         int offset = (char *)s->here - bs->bh->b_data;
    1901                 :            : 
    1902                 :          0 :                         unlock_buffer(bs->bh);
    1903                 :            :                         ea_bdebug(bs->bh, "cloning");
    1904                 :          0 :                         s->base = kmalloc(bs->bh->b_size, GFP_NOFS);
    1905                 :          0 :                         error = -ENOMEM;
    1906                 :          0 :                         if (s->base == NULL)
    1907                 :            :                                 goto cleanup;
    1908                 :          0 :                         memcpy(s->base, BHDR(bs->bh), bs->bh->b_size);
    1909                 :          0 :                         s->first = ENTRY(header(s->base)+1);
    1910                 :          0 :                         header(s->base)->h_refcount = cpu_to_le32(1);
    1911                 :          0 :                         s->here = ENTRY(s->base + offset);
    1912                 :          0 :                         s->end = s->base + bs->bh->b_size;
    1913                 :            : 
    1914                 :            :                         /*
    1915                 :            :                          * If existing entry points to an xattr inode, we need
    1916                 :            :                          * to prevent ext4_xattr_set_entry() from decrementing
    1917                 :            :                          * ref count on it because the reference belongs to the
    1918                 :            :                          * original block. In this case, make the entry look
    1919                 :            :                          * like it has an empty value.
    1920                 :            :                          */
    1921                 :          0 :                         if (!s->not_found && s->here->e_value_inum) {
    1922                 :            :                                 ea_ino = le32_to_cpu(s->here->e_value_inum);
    1923                 :          0 :                                 error = ext4_xattr_inode_iget(inode, ea_ino,
    1924                 :            :                                               le32_to_cpu(s->here->e_hash),
    1925                 :            :                                               &tmp_inode);
    1926                 :          0 :                                 if (error)
    1927                 :            :                                         goto cleanup;
    1928                 :            : 
    1929                 :          0 :                                 if (!ext4_test_inode_state(tmp_inode,
    1930                 :            :                                                 EXT4_STATE_LUSTRE_EA_INODE)) {
    1931                 :            :                                         /*
    1932                 :            :                                          * Defer quota free call for previous
    1933                 :            :                                          * inode until success is guaranteed.
    1934                 :            :                                          */
    1935                 :          0 :                                         old_ea_inode_quota = le32_to_cpu(
    1936                 :            :                                                         s->here->e_value_size);
    1937                 :            :                                 }
    1938                 :          0 :                                 iput(tmp_inode);
    1939                 :            : 
    1940                 :          0 :                                 s->here->e_value_inum = 0;
    1941                 :          0 :                                 s->here->e_value_size = 0;
    1942                 :            :                         }
    1943                 :            :                 }
    1944                 :            :         } else {
    1945                 :            :                 /* Allocate a buffer where we construct the new block. */
    1946                 :          0 :                 s->base = kzalloc(sb->s_blocksize, GFP_NOFS);
    1947                 :            :                 /* assert(header == s->base) */
    1948                 :          0 :                 error = -ENOMEM;
    1949                 :          0 :                 if (s->base == NULL)
    1950                 :            :                         goto cleanup;
    1951                 :          0 :                 header(s->base)->h_magic = cpu_to_le32(EXT4_XATTR_MAGIC);
    1952                 :          0 :                 header(s->base)->h_blocks = cpu_to_le32(1);
    1953                 :          0 :                 header(s->base)->h_refcount = cpu_to_le32(1);
    1954                 :          0 :                 s->first = ENTRY(header(s->base)+1);
    1955                 :          0 :                 s->here = ENTRY(header(s->base)+1);
    1956                 :          0 :                 s->end = s->base + sb->s_blocksize;
    1957                 :            :         }
    1958                 :            : 
    1959                 :          0 :         error = ext4_xattr_set_entry(i, s, handle, inode, true /* is_block */);
    1960                 :          0 :         if (error == -EFSCORRUPTED)
    1961                 :            :                 goto bad_block;
    1962                 :          0 :         if (error)
    1963                 :            :                 goto cleanup;
    1964                 :            : 
    1965                 :          0 :         if (i->value && s->here->e_value_inum) {
    1966                 :            :                 /*
    1967                 :            :                  * A ref count on ea_inode has been taken as part of the call to
    1968                 :            :                  * ext4_xattr_set_entry() above. We would like to drop this
    1969                 :            :                  * extra ref but we have to wait until the xattr block is
    1970                 :            :                  * initialized and has its own ref count on the ea_inode.
    1971                 :            :                  */
    1972                 :            :                 ea_ino = le32_to_cpu(s->here->e_value_inum);
    1973                 :          0 :                 error = ext4_xattr_inode_iget(inode, ea_ino,
    1974                 :            :                                               le32_to_cpu(s->here->e_hash),
    1975                 :            :                                               &ea_inode);
    1976                 :          0 :                 if (error) {
    1977                 :          0 :                         ea_inode = NULL;
    1978                 :          0 :                         goto cleanup;
    1979                 :            :                 }
    1980                 :            :         }
    1981                 :            : 
    1982                 :            : inserted:
    1983                 :          0 :         if (!IS_LAST_ENTRY(s->first)) {
    1984                 :          0 :                 new_bh = ext4_xattr_block_cache_find(inode, header(s->base),
    1985                 :            :                                                      &ce);
    1986                 :          0 :                 if (new_bh) {
    1987                 :            :                         /* We found an identical block in the cache. */
    1988                 :          0 :                         if (new_bh == bs->bh)
    1989                 :            :                                 ea_bdebug(new_bh, "keeping");
    1990                 :            :                         else {
    1991                 :            :                                 u32 ref;
    1992                 :            : 
    1993                 :          0 :                                 WARN_ON_ONCE(dquot_initialize_needed(inode));
    1994                 :            : 
    1995                 :            :                                 /* The old block is released after updating
    1996                 :            :                                    the inode. */
    1997                 :          0 :                                 error = dquot_alloc_block(inode,
    1998                 :          0 :                                                 EXT4_C2B(EXT4_SB(sb), 1));
    1999                 :          0 :                                 if (error)
    2000                 :            :                                         goto cleanup;
    2001                 :            :                                 BUFFER_TRACE(new_bh, "get_write_access");
    2002                 :          0 :                                 error = ext4_journal_get_write_access(handle,
    2003                 :            :                                                                       new_bh);
    2004                 :          0 :                                 if (error)
    2005                 :            :                                         goto cleanup_dquot;
    2006                 :          0 :                                 lock_buffer(new_bh);
    2007                 :            :                                 /*
    2008                 :            :                                  * We have to be careful about races with
    2009                 :            :                                  * freeing, rehashing or adding references to
    2010                 :            :                                  * xattr block. Once we hold buffer lock xattr
    2011                 :            :                                  * block's state is stable so we can check
    2012                 :            :                                  * whether the block got freed / rehashed or
    2013                 :            :                                  * not.  Since we unhash mbcache entry under
    2014                 :            :                                  * buffer lock when freeing / rehashing xattr
    2015                 :            :                                  * block, checking whether entry is still
    2016                 :            :                                  * hashed is reliable. Same rules hold for
    2017                 :            :                                  * e_reusable handling.
    2018                 :            :                                  */
    2019                 :          0 :                                 if (hlist_bl_unhashed(&ce->e_hash_list) ||
    2020                 :          0 :                                     !ce->e_reusable) {
    2021                 :            :                                         /*
    2022                 :            :                                          * Undo everything and check mbcache
    2023                 :            :                                          * again.
    2024                 :            :                                          */
    2025                 :          0 :                                         unlock_buffer(new_bh);
    2026                 :          0 :                                         dquot_free_block(inode,
    2027                 :          0 :                                                          EXT4_C2B(EXT4_SB(sb),
    2028                 :            :                                                                   1));
    2029                 :            :                                         brelse(new_bh);
    2030                 :          0 :                                         mb_cache_entry_put(ea_block_cache, ce);
    2031                 :          0 :                                         ce = NULL;
    2032                 :            :                                         new_bh = NULL;
    2033                 :          0 :                                         goto inserted;
    2034                 :            :                                 }
    2035                 :          0 :                                 ref = le32_to_cpu(BHDR(new_bh)->h_refcount) + 1;
    2036                 :          0 :                                 BHDR(new_bh)->h_refcount = cpu_to_le32(ref);
    2037                 :          0 :                                 if (ref >= EXT4_XATTR_REFCOUNT_MAX)
    2038                 :          0 :                                         ce->e_reusable = 0;
    2039                 :            :                                 ea_bdebug(new_bh, "reusing; refcount now=%d",
    2040                 :            :                                           ref);
    2041                 :          0 :                                 ext4_xattr_block_csum_set(inode, new_bh);
    2042                 :          0 :                                 unlock_buffer(new_bh);
    2043                 :          0 :                                 error = ext4_handle_dirty_metadata(handle,
    2044                 :            :                                                                    inode,
    2045                 :            :                                                                    new_bh);
    2046                 :          0 :                                 if (error)
    2047                 :            :                                         goto cleanup_dquot;
    2048                 :            :                         }
    2049                 :          0 :                         mb_cache_entry_touch(ea_block_cache, ce);
    2050                 :          0 :                         mb_cache_entry_put(ea_block_cache, ce);
    2051                 :          0 :                         ce = NULL;
    2052                 :          0 :                 } else if (bs->bh && s->base == bs->bh->b_data) {
    2053                 :            :                         /* We were modifying this block in-place. */
    2054                 :            :                         ea_bdebug(bs->bh, "keeping this block");
    2055                 :          0 :                         ext4_xattr_block_cache_insert(ea_block_cache, bs->bh);
    2056                 :          0 :                         new_bh = bs->bh;
    2057                 :            :                         get_bh(new_bh);
    2058                 :            :                 } else {
    2059                 :            :                         /* We need to allocate a new block */
    2060                 :            :                         ext4_fsblk_t goal, block;
    2061                 :            : 
    2062                 :          0 :                         WARN_ON_ONCE(dquot_initialize_needed(inode));
    2063                 :            : 
    2064                 :          0 :                         goal = ext4_group_first_block_no(sb,
    2065                 :            :                                                 EXT4_I(inode)->i_block_group);
    2066                 :            : 
    2067                 :            :                         /* non-extent files can't have physical blocks past 2^32 */
    2068                 :          0 :                         if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
    2069                 :          0 :                                 goal = goal & EXT4_MAX_BLOCK_FILE_PHYS;
    2070                 :            : 
    2071                 :          0 :                         block = ext4_new_meta_blocks(handle, inode, goal, 0,
    2072                 :            :                                                      NULL, &error);
    2073                 :          0 :                         if (error)
    2074                 :            :                                 goto cleanup;
    2075                 :            : 
    2076                 :          0 :                         if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
    2077                 :          0 :                                 BUG_ON(block > EXT4_MAX_BLOCK_FILE_PHYS);
    2078                 :            : 
    2079                 :            :                         ea_idebug(inode, "creating block %llu",
    2080                 :            :                                   (unsigned long long)block);
    2081                 :            : 
    2082                 :            :                         new_bh = sb_getblk(sb, block);
    2083                 :          0 :                         if (unlikely(!new_bh)) {
    2084                 :          0 :                                 error = -ENOMEM;
    2085                 :            : getblk_failed:
    2086                 :          0 :                                 ext4_free_blocks(handle, inode, NULL, block, 1,
    2087                 :            :                                                  EXT4_FREE_BLOCKS_METADATA);
    2088                 :          0 :                                 goto cleanup;
    2089                 :            :                         }
    2090                 :          0 :                         error = ext4_xattr_inode_inc_ref_all(handle, inode,
    2091                 :          0 :                                                       ENTRY(header(s->base)+1));
    2092                 :          0 :                         if (error)
    2093                 :            :                                 goto getblk_failed;
    2094                 :          0 :                         if (ea_inode) {
    2095                 :            :                                 /* Drop the extra ref on ea_inode. */
    2096                 :          0 :                                 error = ext4_xattr_inode_dec_ref(handle,
    2097                 :            :                                                                  ea_inode);
    2098                 :          0 :                                 if (error)
    2099                 :          0 :                                         ext4_warning_inode(ea_inode,
    2100                 :            :                                                            "dec ref error=%d",
    2101                 :            :                                                            error);
    2102                 :          0 :                                 iput(ea_inode);
    2103                 :          0 :                                 ea_inode = NULL;
    2104                 :            :                         }
    2105                 :            : 
    2106                 :          0 :                         lock_buffer(new_bh);
    2107                 :          0 :                         error = ext4_journal_get_create_access(handle, new_bh);
    2108                 :          0 :                         if (error) {
    2109                 :          0 :                                 unlock_buffer(new_bh);
    2110                 :          0 :                                 error = -EIO;
    2111                 :          0 :                                 goto getblk_failed;
    2112                 :            :                         }
    2113                 :          0 :                         memcpy(new_bh->b_data, s->base, new_bh->b_size);
    2114                 :          0 :                         ext4_xattr_block_csum_set(inode, new_bh);
    2115                 :            :                         set_buffer_uptodate(new_bh);
    2116                 :          0 :                         unlock_buffer(new_bh);
    2117                 :          0 :                         ext4_xattr_block_cache_insert(ea_block_cache, new_bh);
    2118                 :          0 :                         error = ext4_handle_dirty_metadata(handle, inode,
    2119                 :            :                                                            new_bh);
    2120                 :          0 :                         if (error)
    2121                 :            :                                 goto cleanup;
    2122                 :            :                 }
    2123                 :            :         }
    2124                 :            : 
    2125                 :          0 :         if (old_ea_inode_quota)
    2126                 :          0 :                 ext4_xattr_inode_free_quota(inode, NULL, old_ea_inode_quota);
    2127                 :            : 
    2128                 :            :         /* Update the inode. */
    2129                 :          0 :         EXT4_I(inode)->i_file_acl = new_bh ? new_bh->b_blocknr : 0;
    2130                 :            : 
    2131                 :            :         /* Drop the previous xattr block. */
    2132                 :          0 :         if (bs->bh && bs->bh != new_bh) {
    2133                 :          0 :                 struct ext4_xattr_inode_array *ea_inode_array = NULL;
    2134                 :            : 
    2135                 :          0 :                 ext4_xattr_release_block(handle, inode, bs->bh,
    2136                 :            :                                          &ea_inode_array,
    2137                 :            :                                          0 /* extra_credits */);
    2138                 :          0 :                 ext4_xattr_inode_array_free(ea_inode_array);
    2139                 :            :         }
    2140                 :          0 :         error = 0;
    2141                 :            : 
    2142                 :            : cleanup:
    2143                 :          0 :         if (ea_inode) {
    2144                 :            :                 int error2;
    2145                 :            : 
    2146                 :            :                 error2 = ext4_xattr_inode_dec_ref(handle, ea_inode);
    2147                 :          0 :                 if (error2)
    2148                 :          0 :                         ext4_warning_inode(ea_inode, "dec ref error=%d",
    2149                 :            :                                            error2);
    2150                 :            : 
    2151                 :            :                 /* If there was an error, revert the quota charge. */
    2152                 :          0 :                 if (error)
    2153                 :          0 :                         ext4_xattr_inode_free_quota(inode, ea_inode,
    2154                 :          0 :                                                     i_size_read(ea_inode));
    2155                 :          0 :                 iput(ea_inode);
    2156                 :            :         }
    2157                 :          0 :         if (ce)
    2158                 :          0 :                 mb_cache_entry_put(ea_block_cache, ce);
    2159                 :            :         brelse(new_bh);
    2160                 :          0 :         if (!(bs->bh && s->base == bs->bh->b_data))
    2161                 :          0 :                 kfree(s->base);
    2162                 :            : 
    2163                 :          0 :         return error;
    2164                 :            : 
    2165                 :            : cleanup_dquot:
    2166                 :          0 :         dquot_free_block(inode, EXT4_C2B(EXT4_SB(sb), 1));
    2167                 :            :         goto cleanup;
    2168                 :            : 
    2169                 :            : bad_block:
    2170                 :          0 :         EXT4_ERROR_INODE(inode, "bad block %llu",
    2171                 :            :                          EXT4_I(inode)->i_file_acl);
    2172                 :          0 :         goto cleanup;
    2173                 :            : 
    2174                 :            : #undef header
    2175                 :            : }
    2176                 :            : 
    2177                 :          3 : int ext4_xattr_ibody_find(struct inode *inode, struct ext4_xattr_info *i,
    2178                 :            :                           struct ext4_xattr_ibody_find *is)
    2179                 :            : {
    2180                 :            :         struct ext4_xattr_ibody_header *header;
    2181                 :            :         struct ext4_inode *raw_inode;
    2182                 :            :         int error;
    2183                 :            : 
    2184                 :          3 :         if (EXT4_I(inode)->i_extra_isize == 0)
    2185                 :            :                 return 0;
    2186                 :            :         raw_inode = ext4_raw_inode(&is->iloc);
    2187                 :          3 :         header = IHDR(inode, raw_inode);
    2188                 :          3 :         is->s.base = is->s.first = IFIRST(header);
    2189                 :          3 :         is->s.here = is->s.first;
    2190                 :          3 :         is->s.end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
    2191                 :          3 :         if (ext4_test_inode_state(inode, EXT4_STATE_XATTR)) {
    2192                 :          0 :                 error = xattr_check_inode(inode, header, is->s.end);
    2193                 :          0 :                 if (error)
    2194                 :            :                         return error;
    2195                 :            :                 /* Find the named attribute. */
    2196                 :          0 :                 error = xattr_find_entry(inode, &is->s.here, is->s.end,
    2197                 :            :                                          i->name_index, i->name, 0);
    2198                 :          0 :                 if (error && error != -ENODATA)
    2199                 :            :                         return error;
    2200                 :          0 :                 is->s.not_found = error;
    2201                 :            :         }
    2202                 :            :         return 0;
    2203                 :            : }
    2204                 :            : 
    2205                 :          0 : int ext4_xattr_ibody_inline_set(handle_t *handle, struct inode *inode,
    2206                 :            :                                 struct ext4_xattr_info *i,
    2207                 :            :                                 struct ext4_xattr_ibody_find *is)
    2208                 :            : {
    2209                 :            :         struct ext4_xattr_ibody_header *header;
    2210                 :          0 :         struct ext4_xattr_search *s = &is->s;
    2211                 :            :         int error;
    2212                 :            : 
    2213                 :          0 :         if (EXT4_I(inode)->i_extra_isize == 0)
    2214                 :            :                 return -ENOSPC;
    2215                 :          0 :         error = ext4_xattr_set_entry(i, s, handle, inode, false /* is_block */);
    2216                 :          0 :         if (error)
    2217                 :            :                 return error;
    2218                 :          0 :         header = IHDR(inode, ext4_raw_inode(&is->iloc));
    2219                 :          0 :         if (!IS_LAST_ENTRY(s->first)) {
    2220                 :          0 :                 header->h_magic = cpu_to_le32(EXT4_XATTR_MAGIC);
    2221                 :            :                 ext4_set_inode_state(inode, EXT4_STATE_XATTR);
    2222                 :            :         } else {
    2223                 :          0 :                 header->h_magic = cpu_to_le32(0);
    2224                 :            :                 ext4_clear_inode_state(inode, EXT4_STATE_XATTR);
    2225                 :            :         }
    2226                 :            :         return 0;
    2227                 :            : }
    2228                 :            : 
    2229                 :          0 : static int ext4_xattr_ibody_set(handle_t *handle, struct inode *inode,
    2230                 :            :                                 struct ext4_xattr_info *i,
    2231                 :            :                                 struct ext4_xattr_ibody_find *is)
    2232                 :            : {
    2233                 :            :         struct ext4_xattr_ibody_header *header;
    2234                 :          0 :         struct ext4_xattr_search *s = &is->s;
    2235                 :            :         int error;
    2236                 :            : 
    2237                 :          0 :         if (EXT4_I(inode)->i_extra_isize == 0)
    2238                 :            :                 return -ENOSPC;
    2239                 :          0 :         error = ext4_xattr_set_entry(i, s, handle, inode, false /* is_block */);
    2240                 :          0 :         if (error)
    2241                 :            :                 return error;
    2242                 :          0 :         header = IHDR(inode, ext4_raw_inode(&is->iloc));
    2243                 :          0 :         if (!IS_LAST_ENTRY(s->first)) {
    2244                 :          0 :                 header->h_magic = cpu_to_le32(EXT4_XATTR_MAGIC);
    2245                 :            :                 ext4_set_inode_state(inode, EXT4_STATE_XATTR);
    2246                 :            :         } else {
    2247                 :          0 :                 header->h_magic = cpu_to_le32(0);
    2248                 :            :                 ext4_clear_inode_state(inode, EXT4_STATE_XATTR);
    2249                 :            :         }
    2250                 :            :         return 0;
    2251                 :            : }
    2252                 :            : 
    2253                 :          0 : static int ext4_xattr_value_same(struct ext4_xattr_search *s,
    2254                 :            :                                  struct ext4_xattr_info *i)
    2255                 :            : {
    2256                 :            :         void *value;
    2257                 :            : 
    2258                 :            :         /* When e_value_inum is set the value is stored externally. */
    2259                 :          0 :         if (s->here->e_value_inum)
    2260                 :            :                 return 0;
    2261                 :          0 :         if (le32_to_cpu(s->here->e_value_size) != i->value_len)
    2262                 :            :                 return 0;
    2263                 :          0 :         value = ((void *)s->base) + le16_to_cpu(s->here->e_value_offs);
    2264                 :          0 :         return !memcmp(value, i->value, i->value_len);
    2265                 :            : }
    2266                 :            : 
    2267                 :          3 : static struct buffer_head *ext4_xattr_get_block(struct inode *inode)
    2268                 :            : {
    2269                 :            :         struct buffer_head *bh;
    2270                 :            :         int error;
    2271                 :            : 
    2272                 :          3 :         if (!EXT4_I(inode)->i_file_acl)
    2273                 :            :                 return NULL;
    2274                 :          0 :         bh = ext4_sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl, REQ_PRIO);
    2275                 :          0 :         if (IS_ERR(bh))
    2276                 :            :                 return bh;
    2277                 :          0 :         error = ext4_xattr_check_block(inode, bh);
    2278                 :          0 :         if (error) {
    2279                 :            :                 brelse(bh);
    2280                 :          0 :                 return ERR_PTR(error);
    2281                 :            :         }
    2282                 :            :         return bh;
    2283                 :            : }
    2284                 :            : 
    2285                 :            : /*
    2286                 :            :  * ext4_xattr_set_handle()
    2287                 :            :  *
    2288                 :            :  * Create, replace or remove an extended attribute for this inode.  Value
    2289                 :            :  * is NULL to remove an existing extended attribute, and non-NULL to
    2290                 :            :  * either replace an existing extended attribute, or create a new extended
    2291                 :            :  * attribute. The flags XATTR_REPLACE and XATTR_CREATE
    2292                 :            :  * specify that an extended attribute must exist and must not exist
    2293                 :            :  * previous to the call, respectively.
    2294                 :            :  *
    2295                 :            :  * Returns 0, or a negative error number on failure.
    2296                 :            :  */
    2297                 :            : int
    2298                 :          3 : ext4_xattr_set_handle(handle_t *handle, struct inode *inode, int name_index,
    2299                 :            :                       const char *name, const void *value, size_t value_len,
    2300                 :            :                       int flags)
    2301                 :            : {
    2302                 :          3 :         struct ext4_xattr_info i = {
    2303                 :            :                 .name_index = name_index,
    2304                 :            :                 .name = name,
    2305                 :            :                 .value = value,
    2306                 :            :                 .value_len = value_len,
    2307                 :            :                 .in_inode = 0,
    2308                 :            :         };
    2309                 :          3 :         struct ext4_xattr_ibody_find is = {
    2310                 :            :                 .s = { .not_found = -ENODATA, },
    2311                 :            :         };
    2312                 :          3 :         struct ext4_xattr_block_find bs = {
    2313                 :            :                 .s = { .not_found = -ENODATA, },
    2314                 :            :         };
    2315                 :            :         int no_expand;
    2316                 :            :         int error;
    2317                 :            : 
    2318                 :          3 :         if (!name)
    2319                 :            :                 return -EINVAL;
    2320                 :          3 :         if (strlen(name) > 255)
    2321                 :            :                 return -ERANGE;
    2322                 :            : 
    2323                 :          3 :         ext4_write_lock_xattr(inode, &no_expand);
    2324                 :            : 
    2325                 :            :         /* Check journal credits under write lock. */
    2326                 :          3 :         if (ext4_handle_valid(handle)) {
    2327                 :            :                 struct buffer_head *bh;
    2328                 :            :                 int credits;
    2329                 :            : 
    2330                 :          3 :                 bh = ext4_xattr_get_block(inode);
    2331                 :          3 :                 if (IS_ERR(bh)) {
    2332                 :            :                         error = PTR_ERR(bh);
    2333                 :          0 :                         goto cleanup;
    2334                 :            :                 }
    2335                 :            : 
    2336                 :          3 :                 credits = __ext4_xattr_set_credits(inode->i_sb, inode, bh,
    2337                 :            :                                                    value_len,
    2338                 :          3 :                                                    flags & XATTR_CREATE);
    2339                 :            :                 brelse(bh);
    2340                 :            : 
    2341                 :          3 :                 if (!ext4_handle_has_enough_credits(handle, credits)) {
    2342                 :            :                         error = -ENOSPC;
    2343                 :            :                         goto cleanup;
    2344                 :            :                 }
    2345                 :            :         }
    2346                 :            : 
    2347                 :          3 :         error = ext4_reserve_inode_write(handle, inode, &is.iloc);
    2348                 :          3 :         if (error)
    2349                 :            :                 goto cleanup;
    2350                 :            : 
    2351                 :          3 :         if (ext4_test_inode_state(inode, EXT4_STATE_NEW)) {
    2352                 :            :                 struct ext4_inode *raw_inode = ext4_raw_inode(&is.iloc);
    2353                 :          0 :                 memset(raw_inode, 0, EXT4_SB(inode->i_sb)->s_inode_size);
    2354                 :            :                 ext4_clear_inode_state(inode, EXT4_STATE_NEW);
    2355                 :            :         }
    2356                 :            : 
    2357                 :          3 :         error = ext4_xattr_ibody_find(inode, &i, &is);
    2358                 :          3 :         if (error)
    2359                 :            :                 goto cleanup;
    2360                 :          3 :         if (is.s.not_found)
    2361                 :          3 :                 error = ext4_xattr_block_find(inode, &i, &bs);
    2362                 :          3 :         if (error)
    2363                 :            :                 goto cleanup;
    2364                 :          3 :         if (is.s.not_found && bs.s.not_found) {
    2365                 :            :                 error = -ENODATA;
    2366                 :          3 :                 if (flags & XATTR_REPLACE)
    2367                 :            :                         goto cleanup;
    2368                 :            :                 error = 0;
    2369                 :          3 :                 if (!value)
    2370                 :            :                         goto cleanup;
    2371                 :            :         } else {
    2372                 :            :                 error = -EEXIST;
    2373                 :          0 :                 if (flags & XATTR_CREATE)
    2374                 :            :                         goto cleanup;
    2375                 :            :         }
    2376                 :            : 
    2377                 :          0 :         if (!value) {
    2378                 :          0 :                 if (!is.s.not_found)
    2379                 :          0 :                         error = ext4_xattr_ibody_set(handle, inode, &i, &is);
    2380                 :          0 :                 else if (!bs.s.not_found)
    2381                 :          0 :                         error = ext4_xattr_block_set(handle, inode, &i, &bs);
    2382                 :            :         } else {
    2383                 :            :                 error = 0;
    2384                 :            :                 /* Xattr value did not change? Save us some work and bail out */
    2385                 :          0 :                 if (!is.s.not_found && ext4_xattr_value_same(&is.s, &i))
    2386                 :            :                         goto cleanup;
    2387                 :          0 :                 if (!bs.s.not_found && ext4_xattr_value_same(&bs.s, &i))
    2388                 :            :                         goto cleanup;
    2389                 :            : 
    2390                 :          0 :                 if (ext4_has_feature_ea_inode(inode->i_sb) &&
    2391                 :          0 :                     (EXT4_XATTR_SIZE(i.value_len) >
    2392                 :          0 :                         EXT4_XATTR_MIN_LARGE_EA_SIZE(inode->i_sb->s_blocksize)))
    2393                 :          0 :                         i.in_inode = 1;
    2394                 :            : retry_inode:
    2395                 :          0 :                 error = ext4_xattr_ibody_set(handle, inode, &i, &is);
    2396                 :          0 :                 if (!error && !bs.s.not_found) {
    2397                 :          0 :                         i.value = NULL;
    2398                 :          0 :                         error = ext4_xattr_block_set(handle, inode, &i, &bs);
    2399                 :          0 :                 } else if (error == -ENOSPC) {
    2400                 :          0 :                         if (EXT4_I(inode)->i_file_acl && !bs.s.base) {
    2401                 :          0 :                                 brelse(bs.bh);
    2402                 :          0 :                                 bs.bh = NULL;
    2403                 :          0 :                                 error = ext4_xattr_block_find(inode, &i, &bs);
    2404                 :          0 :                                 if (error)
    2405                 :            :                                         goto cleanup;
    2406                 :            :                         }
    2407                 :          0 :                         error = ext4_xattr_block_set(handle, inode, &i, &bs);
    2408                 :          0 :                         if (!error && !is.s.not_found) {
    2409                 :          0 :                                 i.value = NULL;
    2410                 :          0 :                                 error = ext4_xattr_ibody_set(handle, inode, &i,
    2411                 :            :                                                              &is);
    2412                 :          0 :                         } else if (error == -ENOSPC) {
    2413                 :            :                                 /*
    2414                 :            :                                  * Xattr does not fit in the block, store at
    2415                 :            :                                  * external inode if possible.
    2416                 :            :                                  */
    2417                 :          0 :                                 if (ext4_has_feature_ea_inode(inode->i_sb) &&
    2418                 :          0 :                                     !i.in_inode) {
    2419                 :          0 :                                         i.in_inode = 1;
    2420                 :          0 :                                         goto retry_inode;
    2421                 :            :                                 }
    2422                 :            :                         }
    2423                 :            :                 }
    2424                 :            :         }
    2425                 :          0 :         if (!error) {
    2426                 :          0 :                 ext4_xattr_update_super_block(handle, inode->i_sb);
    2427                 :          0 :                 inode->i_ctime = current_time(inode);
    2428                 :          0 :                 if (!value)
    2429                 :          0 :                         no_expand = 0;
    2430                 :          0 :                 error = ext4_mark_iloc_dirty(handle, inode, &is.iloc);
    2431                 :            :                 /*
    2432                 :            :                  * The bh is consumed by ext4_mark_iloc_dirty, even with
    2433                 :            :                  * error != 0.
    2434                 :            :                  */
    2435                 :          0 :                 is.iloc.bh = NULL;
    2436                 :          0 :                 if (IS_SYNC(inode))
    2437                 :            :                         ext4_handle_sync(handle);
    2438                 :            :         }
    2439                 :            : 
    2440                 :            : cleanup:
    2441                 :          3 :         brelse(is.iloc.bh);
    2442                 :          3 :         brelse(bs.bh);
    2443                 :          3 :         ext4_write_unlock_xattr(inode, &no_expand);
    2444                 :          3 :         return error;
    2445                 :            : }
    2446                 :            : 
    2447                 :          3 : int ext4_xattr_set_credits(struct inode *inode, size_t value_len,
    2448                 :            :                            bool is_create, int *credits)
    2449                 :            : {
    2450                 :            :         struct buffer_head *bh;
    2451                 :            :         int err;
    2452                 :            : 
    2453                 :          3 :         *credits = 0;
    2454                 :            : 
    2455                 :          3 :         if (!EXT4_SB(inode->i_sb)->s_journal)
    2456                 :            :                 return 0;
    2457                 :            : 
    2458                 :          3 :         down_read(&EXT4_I(inode)->xattr_sem);
    2459                 :            : 
    2460                 :          3 :         bh = ext4_xattr_get_block(inode);
    2461                 :          3 :         if (IS_ERR(bh)) {
    2462                 :            :                 err = PTR_ERR(bh);
    2463                 :            :         } else {
    2464                 :          3 :                 *credits = __ext4_xattr_set_credits(inode->i_sb, inode, bh,
    2465                 :            :                                                     value_len, is_create);
    2466                 :            :                 brelse(bh);
    2467                 :            :                 err = 0;
    2468                 :            :         }
    2469                 :            : 
    2470                 :          3 :         up_read(&EXT4_I(inode)->xattr_sem);
    2471                 :          3 :         return err;
    2472                 :            : }
    2473                 :            : 
    2474                 :            : /*
    2475                 :            :  * ext4_xattr_set()
    2476                 :            :  *
    2477                 :            :  * Like ext4_xattr_set_handle, but start from an inode. This extended
    2478                 :            :  * attribute modification is a filesystem transaction by itself.
    2479                 :            :  *
    2480                 :            :  * Returns 0, or a negative error number on failure.
    2481                 :            :  */
    2482                 :            : int
    2483                 :          0 : ext4_xattr_set(struct inode *inode, int name_index, const char *name,
    2484                 :            :                const void *value, size_t value_len, int flags)
    2485                 :            : {
    2486                 :            :         handle_t *handle;
    2487                 :          0 :         struct super_block *sb = inode->i_sb;
    2488                 :          0 :         int error, retries = 0;
    2489                 :            :         int credits;
    2490                 :            : 
    2491                 :          0 :         error = dquot_initialize(inode);
    2492                 :          0 :         if (error)
    2493                 :            :                 return error;
    2494                 :            : 
    2495                 :            : retry:
    2496                 :          0 :         error = ext4_xattr_set_credits(inode, value_len, flags & XATTR_CREATE,
    2497                 :            :                                        &credits);
    2498                 :          0 :         if (error)
    2499                 :          0 :                 return error;
    2500                 :            : 
    2501                 :          0 :         handle = ext4_journal_start(inode, EXT4_HT_XATTR, credits);
    2502                 :          0 :         if (IS_ERR(handle)) {
    2503                 :            :                 error = PTR_ERR(handle);
    2504                 :            :         } else {
    2505                 :            :                 int error2;
    2506                 :            : 
    2507                 :          0 :                 error = ext4_xattr_set_handle(handle, inode, name_index, name,
    2508                 :            :                                               value, value_len, flags);
    2509                 :          0 :                 error2 = ext4_journal_stop(handle);
    2510                 :          0 :                 if (error == -ENOSPC &&
    2511                 :          0 :                     ext4_should_retry_alloc(sb, &retries))
    2512                 :            :                         goto retry;
    2513                 :          0 :                 if (error == 0)
    2514                 :          0 :                         error = error2;
    2515                 :            :         }
    2516                 :            : 
    2517                 :          0 :         return error;
    2518                 :            : }
    2519                 :            : 
    2520                 :            : /*
    2521                 :            :  * Shift the EA entries in the inode to create space for the increased
    2522                 :            :  * i_extra_isize.
    2523                 :            :  */
    2524                 :          0 : static void ext4_xattr_shift_entries(struct ext4_xattr_entry *entry,
    2525                 :            :                                      int value_offs_shift, void *to,
    2526                 :            :                                      void *from, size_t n)
    2527                 :            : {
    2528                 :            :         struct ext4_xattr_entry *last = entry;
    2529                 :            :         int new_offs;
    2530                 :            : 
    2531                 :            :         /* We always shift xattr headers further thus offsets get lower */
    2532                 :          0 :         BUG_ON(value_offs_shift > 0);
    2533                 :            : 
    2534                 :            :         /* Adjust the value offsets of the entries */
    2535                 :          0 :         for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
    2536                 :          0 :                 if (!last->e_value_inum && last->e_value_size) {
    2537                 :          0 :                         new_offs = le16_to_cpu(last->e_value_offs) +
    2538                 :            :                                                         value_offs_shift;
    2539                 :          0 :                         last->e_value_offs = cpu_to_le16(new_offs);
    2540                 :            :                 }
    2541                 :            :         }
    2542                 :            :         /* Shift the entries by n bytes */
    2543                 :          0 :         memmove(to, from, n);
    2544                 :          0 : }
    2545                 :            : 
    2546                 :            : /*
    2547                 :            :  * Move xattr pointed to by 'entry' from inode into external xattr block
    2548                 :            :  */
    2549                 :          0 : static int ext4_xattr_move_to_block(handle_t *handle, struct inode *inode,
    2550                 :            :                                     struct ext4_inode *raw_inode,
    2551                 :            :                                     struct ext4_xattr_entry *entry)
    2552                 :            : {
    2553                 :            :         struct ext4_xattr_ibody_find *is = NULL;
    2554                 :            :         struct ext4_xattr_block_find *bs = NULL;
    2555                 :            :         char *buffer = NULL, *b_entry_name = NULL;
    2556                 :          0 :         size_t value_size = le32_to_cpu(entry->e_value_size);
    2557                 :          0 :         struct ext4_xattr_info i = {
    2558                 :            :                 .value = NULL,
    2559                 :            :                 .value_len = 0,
    2560                 :          0 :                 .name_index = entry->e_name_index,
    2561                 :          0 :                 .in_inode = !!entry->e_value_inum,
    2562                 :            :         };
    2563                 :          0 :         struct ext4_xattr_ibody_header *header = IHDR(inode, raw_inode);
    2564                 :            :         int error;
    2565                 :            : 
    2566                 :          0 :         is = kzalloc(sizeof(struct ext4_xattr_ibody_find), GFP_NOFS);
    2567                 :          0 :         bs = kzalloc(sizeof(struct ext4_xattr_block_find), GFP_NOFS);
    2568                 :            :         buffer = kmalloc(value_size, GFP_NOFS);
    2569                 :          0 :         b_entry_name = kmalloc(entry->e_name_len + 1, GFP_NOFS);
    2570                 :          0 :         if (!is || !bs || !buffer || !b_entry_name) {
    2571                 :            :                 error = -ENOMEM;
    2572                 :            :                 goto out;
    2573                 :            :         }
    2574                 :            : 
    2575                 :          0 :         is->s.not_found = -ENODATA;
    2576                 :          0 :         bs->s.not_found = -ENODATA;
    2577                 :          0 :         is->iloc.bh = NULL;
    2578                 :          0 :         bs->bh = NULL;
    2579                 :            : 
    2580                 :            :         /* Save the entry name and the entry value */
    2581                 :          0 :         if (entry->e_value_inum) {
    2582                 :          0 :                 error = ext4_xattr_inode_get(inode, entry, buffer, value_size);
    2583                 :          0 :                 if (error)
    2584                 :            :                         goto out;
    2585                 :            :         } else {
    2586                 :          0 :                 size_t value_offs = le16_to_cpu(entry->e_value_offs);
    2587                 :          0 :                 memcpy(buffer, (void *)IFIRST(header) + value_offs, value_size);
    2588                 :            :         }
    2589                 :            : 
    2590                 :          0 :         memcpy(b_entry_name, entry->e_name, entry->e_name_len);
    2591                 :          0 :         b_entry_name[entry->e_name_len] = '\0';
    2592                 :          0 :         i.name = b_entry_name;
    2593                 :            : 
    2594                 :          0 :         error = ext4_get_inode_loc(inode, &is->iloc);
    2595                 :          0 :         if (error)
    2596                 :            :                 goto out;
    2597                 :            : 
    2598                 :          0 :         error = ext4_xattr_ibody_find(inode, &i, is);
    2599                 :          0 :         if (error)
    2600                 :            :                 goto out;
    2601                 :            : 
    2602                 :            :         /* Remove the chosen entry from the inode */
    2603                 :          0 :         error = ext4_xattr_ibody_set(handle, inode, &i, is);
    2604                 :          0 :         if (error)
    2605                 :            :                 goto out;
    2606                 :            : 
    2607                 :          0 :         i.value = buffer;
    2608                 :          0 :         i.value_len = value_size;
    2609                 :          0 :         error = ext4_xattr_block_find(inode, &i, bs);
    2610                 :          0 :         if (error)
    2611                 :            :                 goto out;
    2612                 :            : 
    2613                 :            :         /* Add entry which was removed from the inode into the block */
    2614                 :          0 :         error = ext4_xattr_block_set(handle, inode, &i, bs);
    2615                 :          0 :         if (error)
    2616                 :            :                 goto out;
    2617                 :            :         error = 0;
    2618                 :            : out:
    2619                 :          0 :         kfree(b_entry_name);
    2620                 :          0 :         kfree(buffer);
    2621                 :          0 :         if (is)
    2622                 :          0 :                 brelse(is->iloc.bh);
    2623                 :          0 :         if (bs)
    2624                 :          0 :                 brelse(bs->bh);
    2625                 :          0 :         kfree(is);
    2626                 :          0 :         kfree(bs);
    2627                 :            : 
    2628                 :          0 :         return error;
    2629                 :            : }
    2630                 :            : 
    2631                 :          0 : static int ext4_xattr_make_inode_space(handle_t *handle, struct inode *inode,
    2632                 :            :                                        struct ext4_inode *raw_inode,
    2633                 :            :                                        int isize_diff, size_t ifree,
    2634                 :            :                                        size_t bfree, int *total_ino)
    2635                 :            : {
    2636                 :          0 :         struct ext4_xattr_ibody_header *header = IHDR(inode, raw_inode);
    2637                 :            :         struct ext4_xattr_entry *small_entry;
    2638                 :            :         struct ext4_xattr_entry *entry;
    2639                 :            :         struct ext4_xattr_entry *last;
    2640                 :            :         unsigned int entry_size;        /* EA entry size */
    2641                 :            :         unsigned int total_size;        /* EA entry size + value size */
    2642                 :            :         unsigned int min_total_size;
    2643                 :            :         int error;
    2644                 :            : 
    2645                 :          0 :         while (isize_diff > ifree) {
    2646                 :            :                 entry = NULL;
    2647                 :            :                 small_entry = NULL;
    2648                 :            :                 min_total_size = ~0U;
    2649                 :          0 :                 last = IFIRST(header);
    2650                 :            :                 /* Find the entry best suited to be pushed into EA block */
    2651                 :          0 :                 for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
    2652                 :            :                         /* never move system.data out of the inode */
    2653                 :          0 :                         if ((last->e_name_len == 4) &&
    2654                 :          0 :                             (last->e_name_index == EXT4_XATTR_INDEX_SYSTEM) &&
    2655                 :          0 :                             !memcmp(last->e_name, "data", 4))
    2656                 :          0 :                                 continue;
    2657                 :          0 :                         total_size = EXT4_XATTR_LEN(last->e_name_len);
    2658                 :          0 :                         if (!last->e_value_inum)
    2659                 :          0 :                                 total_size += EXT4_XATTR_SIZE(
    2660                 :            :                                                le32_to_cpu(last->e_value_size));
    2661                 :          0 :                         if (total_size <= bfree &&
    2662                 :          0 :                             total_size < min_total_size) {
    2663                 :          0 :                                 if (total_size + ifree < isize_diff) {
    2664                 :            :                                         small_entry = last;
    2665                 :            :                                 } else {
    2666                 :            :                                         entry = last;
    2667                 :            :                                         min_total_size = total_size;
    2668                 :            :                                 }
    2669                 :            :                         }
    2670                 :            :                 }
    2671                 :            : 
    2672                 :          0 :                 if (entry == NULL) {
    2673                 :          0 :                         if (small_entry == NULL)
    2674                 :            :                                 return -ENOSPC;
    2675                 :          0 :                         entry = small_entry;
    2676                 :            :                 }
    2677                 :            : 
    2678                 :          0 :                 entry_size = EXT4_XATTR_LEN(entry->e_name_len);
    2679                 :            :                 total_size = entry_size;
    2680                 :          0 :                 if (!entry->e_value_inum)
    2681                 :          0 :                         total_size += EXT4_XATTR_SIZE(
    2682                 :            :                                               le32_to_cpu(entry->e_value_size));
    2683                 :          0 :                 error = ext4_xattr_move_to_block(handle, inode, raw_inode,
    2684                 :            :                                                  entry);
    2685                 :          0 :                 if (error)
    2686                 :          0 :                         return error;
    2687                 :            : 
    2688                 :          0 :                 *total_ino -= entry_size;
    2689                 :          0 :                 ifree += total_size;
    2690                 :          0 :                 bfree -= total_size;
    2691                 :            :         }
    2692                 :            : 
    2693                 :            :         return 0;
    2694                 :            : }
    2695                 :            : 
    2696                 :            : /*
    2697                 :            :  * Expand an inode by new_extra_isize bytes when EAs are present.
    2698                 :            :  * Returns 0 on success or negative error number on failure.
    2699                 :            :  */
    2700                 :          0 : int ext4_expand_extra_isize_ea(struct inode *inode, int new_extra_isize,
    2701                 :            :                                struct ext4_inode *raw_inode, handle_t *handle)
    2702                 :            : {
    2703                 :            :         struct ext4_xattr_ibody_header *header;
    2704                 :          0 :         struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
    2705                 :            :         static unsigned int mnt_count;
    2706                 :            :         size_t min_offs;
    2707                 :            :         size_t ifree, bfree;
    2708                 :            :         int total_ino;
    2709                 :            :         void *base, *end;
    2710                 :            :         int error = 0, tried_min_extra_isize = 0;
    2711                 :          0 :         int s_min_extra_isize = le16_to_cpu(sbi->s_es->s_min_extra_isize);
    2712                 :            :         int isize_diff; /* How much do we need to grow i_extra_isize */
    2713                 :            : 
    2714                 :            : retry:
    2715                 :          0 :         isize_diff = new_extra_isize - EXT4_I(inode)->i_extra_isize;
    2716                 :          0 :         if (EXT4_I(inode)->i_extra_isize >= new_extra_isize)
    2717                 :            :                 return 0;
    2718                 :            : 
    2719                 :          0 :         header = IHDR(inode, raw_inode);
    2720                 :            : 
    2721                 :            :         /*
    2722                 :            :          * Check if enough free space is available in the inode to shift the
    2723                 :            :          * entries ahead by new_extra_isize.
    2724                 :            :          */
    2725                 :            : 
    2726                 :          0 :         base = IFIRST(header);
    2727                 :          0 :         end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
    2728                 :          0 :         min_offs = end - base;
    2729                 :          0 :         total_ino = sizeof(struct ext4_xattr_ibody_header) + sizeof(u32);
    2730                 :            : 
    2731                 :          0 :         error = xattr_check_inode(inode, header, end);
    2732                 :          0 :         if (error)
    2733                 :            :                 goto cleanup;
    2734                 :            : 
    2735                 :          0 :         ifree = ext4_xattr_free_space(base, &min_offs, base, &total_ino);
    2736                 :          0 :         if (ifree >= isize_diff)
    2737                 :            :                 goto shift;
    2738                 :            : 
    2739                 :            :         /*
    2740                 :            :          * Enough free space isn't available in the inode, check if
    2741                 :            :          * EA block can hold new_extra_isize bytes.
    2742                 :            :          */
    2743                 :          0 :         if (EXT4_I(inode)->i_file_acl) {
    2744                 :            :                 struct buffer_head *bh;
    2745                 :            : 
    2746                 :          0 :                 bh = ext4_sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl, REQ_PRIO);
    2747                 :          0 :                 if (IS_ERR(bh)) {
    2748                 :            :                         error = PTR_ERR(bh);
    2749                 :          0 :                         goto cleanup;
    2750                 :            :                 }
    2751                 :          0 :                 error = ext4_xattr_check_block(inode, bh);
    2752                 :          0 :                 if (error) {
    2753                 :            :                         brelse(bh);
    2754                 :            :                         goto cleanup;
    2755                 :            :                 }
    2756                 :          0 :                 base = BHDR(bh);
    2757                 :          0 :                 end = bh->b_data + bh->b_size;
    2758                 :          0 :                 min_offs = end - base;
    2759                 :          0 :                 bfree = ext4_xattr_free_space(BFIRST(bh), &min_offs, base,
    2760                 :            :                                               NULL);
    2761                 :            :                 brelse(bh);
    2762                 :          0 :                 if (bfree + ifree < isize_diff) {
    2763                 :          0 :                         if (!tried_min_extra_isize && s_min_extra_isize) {
    2764                 :          0 :                                 tried_min_extra_isize++;
    2765                 :            :                                 new_extra_isize = s_min_extra_isize;
    2766                 :          0 :                                 goto retry;
    2767                 :            :                         }
    2768                 :            :                         error = -ENOSPC;
    2769                 :            :                         goto cleanup;
    2770                 :            :                 }
    2771                 :            :         } else {
    2772                 :          0 :                 bfree = inode->i_sb->s_blocksize;
    2773                 :            :         }
    2774                 :            : 
    2775                 :          0 :         error = ext4_xattr_make_inode_space(handle, inode, raw_inode,
    2776                 :            :                                             isize_diff, ifree, bfree,
    2777                 :            :                                             &total_ino);
    2778                 :          0 :         if (error) {
    2779                 :          0 :                 if (error == -ENOSPC && !tried_min_extra_isize &&
    2780                 :            :                     s_min_extra_isize) {
    2781                 :          0 :                         tried_min_extra_isize++;
    2782                 :            :                         new_extra_isize = s_min_extra_isize;
    2783                 :          0 :                         goto retry;
    2784                 :            :                 }
    2785                 :            :                 goto cleanup;
    2786                 :            :         }
    2787                 :            : shift:
    2788                 :            :         /* Adjust the offsets and shift the remaining entries ahead */
    2789                 :          0 :         ext4_xattr_shift_entries(IFIRST(header), EXT4_I(inode)->i_extra_isize
    2790                 :            :                         - new_extra_isize, (void *)raw_inode +
    2791                 :          0 :                         EXT4_GOOD_OLD_INODE_SIZE + new_extra_isize,
    2792                 :            :                         (void *)header, total_ino);
    2793                 :          0 :         EXT4_I(inode)->i_extra_isize = new_extra_isize;
    2794                 :            : 
    2795                 :            : cleanup:
    2796                 :          0 :         if (error && (mnt_count != le16_to_cpu(sbi->s_es->s_mnt_count))) {
    2797                 :          0 :                 ext4_warning(inode->i_sb, "Unable to expand inode %lu. Delete some EAs or run e2fsck.",
    2798                 :            :                              inode->i_ino);
    2799                 :          0 :                 mnt_count = le16_to_cpu(sbi->s_es->s_mnt_count);
    2800                 :            :         }
    2801                 :          0 :         return error;
    2802                 :            : }
    2803                 :            : 
    2804                 :            : #define EIA_INCR 16 /* must be 2^n */
    2805                 :            : #define EIA_MASK (EIA_INCR - 1)
    2806                 :            : 
    2807                 :            : /* Add the large xattr @inode into @ea_inode_array for deferred iput().
    2808                 :            :  * If @ea_inode_array is new or full it will be grown and the old
    2809                 :            :  * contents copied over.
    2810                 :            :  */
    2811                 :            : static int
    2812                 :          0 : ext4_expand_inode_array(struct ext4_xattr_inode_array **ea_inode_array,
    2813                 :            :                         struct inode *inode)
    2814                 :            : {
    2815                 :          0 :         if (*ea_inode_array == NULL) {
    2816                 :            :                 /*
    2817                 :            :                  * Start with 15 inodes, so it fits into a power-of-two size.
    2818                 :            :                  * If *ea_inode_array is NULL, this is essentially offsetof()
    2819                 :            :                  */
    2820                 :          0 :                 (*ea_inode_array) =
    2821                 :            :                         kmalloc(offsetof(struct ext4_xattr_inode_array,
    2822                 :            :                                          inodes[EIA_MASK]),
    2823                 :            :                                 GFP_NOFS);
    2824                 :          0 :                 if (*ea_inode_array == NULL)
    2825                 :            :                         return -ENOMEM;
    2826                 :          0 :                 (*ea_inode_array)->count = 0;
    2827                 :          0 :         } else if (((*ea_inode_array)->count & EIA_MASK) == EIA_MASK) {
    2828                 :            :                 /* expand the array once all 15 + n * 16 slots are full */
    2829                 :            :                 struct ext4_xattr_inode_array *new_array = NULL;
    2830                 :          0 :                 int count = (*ea_inode_array)->count;
    2831                 :            : 
    2832                 :            :                 /* if new_array is NULL, this is essentially offsetof() */
    2833                 :          0 :                 new_array = kmalloc(
    2834                 :          0 :                                 offsetof(struct ext4_xattr_inode_array,
    2835                 :            :                                          inodes[count + EIA_INCR]),
    2836                 :            :                                 GFP_NOFS);
    2837                 :          0 :                 if (new_array == NULL)
    2838                 :            :                         return -ENOMEM;
    2839                 :          0 :                 memcpy(new_array, *ea_inode_array,
    2840                 :            :                        offsetof(struct ext4_xattr_inode_array, inodes[count]));
    2841                 :          0 :                 kfree(*ea_inode_array);
    2842                 :          0 :                 *ea_inode_array = new_array;
    2843                 :            :         }
    2844                 :          0 :         (*ea_inode_array)->inodes[(*ea_inode_array)->count++] = inode;
    2845                 :          0 :         return 0;
    2846                 :            : }
    2847                 :            : 
    2848                 :            : /*
    2849                 :            :  * ext4_xattr_delete_inode()
    2850                 :            :  *
    2851                 :            :  * Free extended attribute resources associated with this inode. Traverse
    2852                 :            :  * all entries and decrement reference on any xattr inodes associated with this
    2853                 :            :  * inode. This is called immediately before an inode is freed. We have exclusive
    2854                 :            :  * access to the inode. If an orphan inode is deleted it will also release its
    2855                 :            :  * references on xattr block and xattr inodes.
    2856                 :            :  */
    2857                 :          3 : int ext4_xattr_delete_inode(handle_t *handle, struct inode *inode,
    2858                 :            :                             struct ext4_xattr_inode_array **ea_inode_array,
    2859                 :            :                             int extra_credits)
    2860                 :            : {
    2861                 :            :         struct buffer_head *bh = NULL;
    2862                 :            :         struct ext4_xattr_ibody_header *header;
    2863                 :          3 :         struct ext4_iloc iloc = { .bh = NULL };
    2864                 :            :         struct ext4_xattr_entry *entry;
    2865                 :            :         struct inode *ea_inode;
    2866                 :            :         int error;
    2867                 :            : 
    2868                 :          3 :         error = ext4_xattr_ensure_credits(handle, inode, extra_credits,
    2869                 :            :                                           NULL /* bh */,
    2870                 :            :                                           false /* dirty */,
    2871                 :            :                                           false /* block_csum */);
    2872                 :          3 :         if (error) {
    2873                 :          0 :                 EXT4_ERROR_INODE(inode, "ensure credits (error %d)", error);
    2874                 :          0 :                 goto cleanup;
    2875                 :            :         }
    2876                 :            : 
    2877                 :          3 :         if (ext4_has_feature_ea_inode(inode->i_sb) &&
    2878                 :            :             ext4_test_inode_state(inode, EXT4_STATE_XATTR)) {
    2879                 :            : 
    2880                 :          0 :                 error = ext4_get_inode_loc(inode, &iloc);
    2881                 :          0 :                 if (error) {
    2882                 :          0 :                         EXT4_ERROR_INODE(inode, "inode loc (error %d)", error);
    2883                 :          0 :                         goto cleanup;
    2884                 :            :                 }
    2885                 :            : 
    2886                 :          0 :                 error = ext4_journal_get_write_access(handle, iloc.bh);
    2887                 :          0 :                 if (error) {
    2888                 :          0 :                         EXT4_ERROR_INODE(inode, "write access (error %d)",
    2889                 :            :                                          error);
    2890                 :          0 :                         goto cleanup;
    2891                 :            :                 }
    2892                 :            : 
    2893                 :          0 :                 header = IHDR(inode, ext4_raw_inode(&iloc));
    2894                 :          0 :                 if (header->h_magic == cpu_to_le32(EXT4_XATTR_MAGIC))
    2895                 :          0 :                         ext4_xattr_inode_dec_ref_all(handle, inode, iloc.bh,
    2896                 :            :                                                      IFIRST(header),
    2897                 :            :                                                      false /* block_csum */,
    2898                 :            :                                                      ea_inode_array,
    2899                 :            :                                                      extra_credits,
    2900                 :            :                                                      false /* skip_quota */);
    2901                 :            :         }
    2902                 :            : 
    2903                 :          3 :         if (EXT4_I(inode)->i_file_acl) {
    2904                 :          0 :                 bh = ext4_sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl, REQ_PRIO);
    2905                 :          0 :                 if (IS_ERR(bh)) {
    2906                 :            :                         error = PTR_ERR(bh);
    2907                 :          0 :                         if (error == -EIO)
    2908                 :          0 :                                 EXT4_ERROR_INODE(inode, "block %llu read error",
    2909                 :            :                                                  EXT4_I(inode)->i_file_acl);
    2910                 :            :                         bh = NULL;
    2911                 :            :                         goto cleanup;
    2912                 :            :                 }
    2913                 :          0 :                 error = ext4_xattr_check_block(inode, bh);
    2914                 :          0 :                 if (error)
    2915                 :            :                         goto cleanup;
    2916                 :            : 
    2917                 :          0 :                 if (ext4_has_feature_ea_inode(inode->i_sb)) {
    2918                 :          0 :                         for (entry = BFIRST(bh); !IS_LAST_ENTRY(entry);
    2919                 :          0 :                              entry = EXT4_XATTR_NEXT(entry)) {
    2920                 :          0 :                                 if (!entry->e_value_inum)
    2921                 :          0 :                                         continue;
    2922                 :          0 :                                 error = ext4_xattr_inode_iget(inode,
    2923                 :            :                                               le32_to_cpu(entry->e_value_inum),
    2924                 :            :                                               le32_to_cpu(entry->e_hash),
    2925                 :            :                                               &ea_inode);
    2926                 :          0 :                                 if (error)
    2927                 :          0 :                                         continue;
    2928                 :          0 :                                 ext4_xattr_inode_free_quota(inode, ea_inode,
    2929                 :            :                                               le32_to_cpu(entry->e_value_size));
    2930                 :          0 :                                 iput(ea_inode);
    2931                 :            :                         }
    2932                 :            : 
    2933                 :            :                 }
    2934                 :            : 
    2935                 :          0 :                 ext4_xattr_release_block(handle, inode, bh, ea_inode_array,
    2936                 :            :                                          extra_credits);
    2937                 :            :                 /*
    2938                 :            :                  * Update i_file_acl value in the same transaction that releases
    2939                 :            :                  * block.
    2940                 :            :                  */
    2941                 :          0 :                 EXT4_I(inode)->i_file_acl = 0;
    2942                 :          0 :                 error = ext4_mark_inode_dirty(handle, inode);
    2943                 :          0 :                 if (error) {
    2944                 :          0 :                         EXT4_ERROR_INODE(inode, "mark inode dirty (error %d)",
    2945                 :            :                                          error);
    2946                 :          0 :                         goto cleanup;
    2947                 :            :                 }
    2948                 :            :         }
    2949                 :            :         error = 0;
    2950                 :            : cleanup:
    2951                 :          3 :         brelse(iloc.bh);
    2952                 :            :         brelse(bh);
    2953                 :          3 :         return error;
    2954                 :            : }
    2955                 :            : 
    2956                 :          3 : void ext4_xattr_inode_array_free(struct ext4_xattr_inode_array *ea_inode_array)
    2957                 :            : {
    2958                 :            :         int idx;
    2959                 :            : 
    2960                 :          3 :         if (ea_inode_array == NULL)
    2961                 :          3 :                 return;
    2962                 :            : 
    2963                 :          0 :         for (idx = 0; idx < ea_inode_array->count; ++idx)
    2964                 :          0 :                 iput(ea_inode_array->inodes[idx]);
    2965                 :          0 :         kfree(ea_inode_array);
    2966                 :            : }
    2967                 :            : 
    2968                 :            : /*
    2969                 :            :  * ext4_xattr_block_cache_insert()
    2970                 :            :  *
    2971                 :            :  * Create a new entry in the extended attribute block cache, and insert
    2972                 :            :  * it unless such an entry is already in the cache.
    2973                 :            :  *
    2974                 :            :  * Returns 0, or a negative error number on failure.
    2975                 :            :  */
    2976                 :            : static void
    2977                 :          0 : ext4_xattr_block_cache_insert(struct mb_cache *ea_block_cache,
    2978                 :            :                               struct buffer_head *bh)
    2979                 :            : {
    2980                 :          0 :         struct ext4_xattr_header *header = BHDR(bh);
    2981                 :          0 :         __u32 hash = le32_to_cpu(header->h_hash);
    2982                 :          0 :         int reusable = le32_to_cpu(header->h_refcount) <
    2983                 :            :                        EXT4_XATTR_REFCOUNT_MAX;
    2984                 :            :         int error;
    2985                 :            : 
    2986                 :          0 :         if (!ea_block_cache)
    2987                 :          0 :                 return;
    2988                 :          0 :         error = mb_cache_entry_create(ea_block_cache, GFP_NOFS, hash,
    2989                 :            :                                       bh->b_blocknr, reusable);
    2990                 :            :         if (error) {
    2991                 :            :                 if (error == -EBUSY)
    2992                 :            :                         ea_bdebug(bh, "already in cache");
    2993                 :            :         } else
    2994                 :            :                 ea_bdebug(bh, "inserting [%x]", (int)hash);
    2995                 :            : }
    2996                 :            : 
    2997                 :            : /*
    2998                 :            :  * ext4_xattr_cmp()
    2999                 :            :  *
    3000                 :            :  * Compare two extended attribute blocks for equality.
    3001                 :            :  *
    3002                 :            :  * Returns 0 if the blocks are equal, 1 if they differ, and
    3003                 :            :  * a negative error number on errors.
    3004                 :            :  */
    3005                 :            : static int
    3006                 :          0 : ext4_xattr_cmp(struct ext4_xattr_header *header1,
    3007                 :            :                struct ext4_xattr_header *header2)
    3008                 :            : {
    3009                 :            :         struct ext4_xattr_entry *entry1, *entry2;
    3010                 :            : 
    3011                 :          0 :         entry1 = ENTRY(header1+1);
    3012                 :          0 :         entry2 = ENTRY(header2+1);
    3013                 :          0 :         while (!IS_LAST_ENTRY(entry1)) {
    3014                 :          0 :                 if (IS_LAST_ENTRY(entry2))
    3015                 :            :                         return 1;
    3016                 :          0 :                 if (entry1->e_hash != entry2->e_hash ||
    3017                 :          0 :                     entry1->e_name_index != entry2->e_name_index ||
    3018                 :          0 :                     entry1->e_name_len != entry2->e_name_len ||
    3019                 :          0 :                     entry1->e_value_size != entry2->e_value_size ||
    3020                 :          0 :                     entry1->e_value_inum != entry2->e_value_inum ||
    3021                 :          0 :                     memcmp(entry1->e_name, entry2->e_name, entry1->e_name_len))
    3022                 :            :                         return 1;
    3023                 :          0 :                 if (!entry1->e_value_inum &&
    3024                 :          0 :                     memcmp((char *)header1 + le16_to_cpu(entry1->e_value_offs),
    3025                 :          0 :                            (char *)header2 + le16_to_cpu(entry2->e_value_offs),
    3026                 :            :                            le32_to_cpu(entry1->e_value_size)))
    3027                 :            :                         return 1;
    3028                 :            : 
    3029                 :          0 :                 entry1 = EXT4_XATTR_NEXT(entry1);
    3030                 :          0 :                 entry2 = EXT4_XATTR_NEXT(entry2);
    3031                 :            :         }
    3032                 :          0 :         if (!IS_LAST_ENTRY(entry2))
    3033                 :            :                 return 1;
    3034                 :          0 :         return 0;
    3035                 :            : }
    3036                 :            : 
    3037                 :            : /*
    3038                 :            :  * ext4_xattr_block_cache_find()
    3039                 :            :  *
    3040                 :            :  * Find an identical extended attribute block.
    3041                 :            :  *
    3042                 :            :  * Returns a pointer to the block found, or NULL if such a block was
    3043                 :            :  * not found or an error occurred.
    3044                 :            :  */
    3045                 :            : static struct buffer_head *
    3046                 :          0 : ext4_xattr_block_cache_find(struct inode *inode,
    3047                 :            :                             struct ext4_xattr_header *header,
    3048                 :            :                             struct mb_cache_entry **pce)
    3049                 :            : {
    3050                 :          0 :         __u32 hash = le32_to_cpu(header->h_hash);
    3051                 :            :         struct mb_cache_entry *ce;
    3052                 :          0 :         struct mb_cache *ea_block_cache = EA_BLOCK_CACHE(inode);
    3053                 :            : 
    3054                 :          0 :         if (!ea_block_cache)
    3055                 :            :                 return NULL;
    3056                 :          0 :         if (!header->h_hash)
    3057                 :            :                 return NULL;  /* never share */
    3058                 :            :         ea_idebug(inode, "looking for cached blocks [%x]", (int)hash);
    3059                 :          0 :         ce = mb_cache_entry_find_first(ea_block_cache, hash);
    3060                 :          0 :         while (ce) {
    3061                 :            :                 struct buffer_head *bh;
    3062                 :            : 
    3063                 :          0 :                 bh = ext4_sb_bread(inode->i_sb, ce->e_value, REQ_PRIO);
    3064                 :          0 :                 if (IS_ERR(bh)) {
    3065                 :          0 :                         if (PTR_ERR(bh) == -ENOMEM)
    3066                 :            :                                 return NULL;
    3067                 :            :                         bh = NULL;
    3068                 :          0 :                         EXT4_ERROR_INODE(inode, "block %lu read error",
    3069                 :            :                                          (unsigned long)ce->e_value);
    3070                 :          0 :                 } else if (ext4_xattr_cmp(header, BHDR(bh)) == 0) {
    3071                 :          0 :                         *pce = ce;
    3072                 :          0 :                         return bh;
    3073                 :            :                 }
    3074                 :            :                 brelse(bh);
    3075                 :          0 :                 ce = mb_cache_entry_find_next(ea_block_cache, ce);
    3076                 :            :         }
    3077                 :            :         return NULL;
    3078                 :            : }
    3079                 :            : 
    3080                 :            : #define NAME_HASH_SHIFT 5
    3081                 :            : #define VALUE_HASH_SHIFT 16
    3082                 :            : 
    3083                 :            : /*
    3084                 :            :  * ext4_xattr_hash_entry()
    3085                 :            :  *
    3086                 :            :  * Compute the hash of an extended attribute.
    3087                 :            :  */
    3088                 :            : static __le32 ext4_xattr_hash_entry(char *name, size_t name_len, __le32 *value,
    3089                 :            :                                     size_t value_count)
    3090                 :            : {
    3091                 :            :         __u32 hash = 0;
    3092                 :            : 
    3093                 :          0 :         while (name_len--) {
    3094                 :          0 :                 hash = (hash << NAME_HASH_SHIFT) ^
    3095                 :          0 :                        (hash >> (8*sizeof(hash) - NAME_HASH_SHIFT)) ^
    3096                 :          0 :                        *name++;
    3097                 :            :         }
    3098                 :          0 :         while (value_count--) {
    3099                 :          0 :                 hash = (hash << VALUE_HASH_SHIFT) ^
    3100                 :            :                        (hash >> (8*sizeof(hash) - VALUE_HASH_SHIFT)) ^
    3101                 :          0 :                        le32_to_cpu(*value++);
    3102                 :            :         }
    3103                 :          0 :         return cpu_to_le32(hash);
    3104                 :            : }
    3105                 :            : 
    3106                 :            : #undef NAME_HASH_SHIFT
    3107                 :            : #undef VALUE_HASH_SHIFT
    3108                 :            : 
    3109                 :            : #define BLOCK_HASH_SHIFT 16
    3110                 :            : 
    3111                 :            : /*
    3112                 :            :  * ext4_xattr_rehash()
    3113                 :            :  *
    3114                 :            :  * Re-compute the extended attribute hash value after an entry has changed.
    3115                 :            :  */
    3116                 :          0 : static void ext4_xattr_rehash(struct ext4_xattr_header *header)
    3117                 :            : {
    3118                 :            :         struct ext4_xattr_entry *here;
    3119                 :            :         __u32 hash = 0;
    3120                 :            : 
    3121                 :          0 :         here = ENTRY(header+1);
    3122                 :          0 :         while (!IS_LAST_ENTRY(here)) {
    3123                 :          0 :                 if (!here->e_hash) {
    3124                 :            :                         /* Block is not shared if an entry's hash value == 0 */
    3125                 :            :                         hash = 0;
    3126                 :            :                         break;
    3127                 :            :                 }
    3128                 :          0 :                 hash = (hash << BLOCK_HASH_SHIFT) ^
    3129                 :            :                        (hash >> (8*sizeof(hash) - BLOCK_HASH_SHIFT)) ^
    3130                 :            :                        le32_to_cpu(here->e_hash);
    3131                 :          0 :                 here = EXT4_XATTR_NEXT(here);
    3132                 :            :         }
    3133                 :          0 :         header->h_hash = cpu_to_le32(hash);
    3134                 :          0 : }
    3135                 :            : 
    3136                 :            : #undef BLOCK_HASH_SHIFT
    3137                 :            : 
    3138                 :            : #define HASH_BUCKET_BITS        10
    3139                 :            : 
    3140                 :            : struct mb_cache *
    3141                 :          3 : ext4_xattr_create_cache(void)
    3142                 :            : {
    3143                 :          3 :         return mb_cache_create(HASH_BUCKET_BITS);
    3144                 :            : }
    3145                 :            : 
    3146                 :          0 : void ext4_xattr_destroy_cache(struct mb_cache *cache)
    3147                 :            : {
    3148                 :          0 :         if (cache)
    3149                 :          0 :                 mb_cache_destroy(cache);
    3150                 :          0 : }
    3151                 :            : 
    

Generated by: LCOV version 1.14