LCOV - code coverage report
Current view: top level - lkbce/fs/ext2 - xattr.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 519 519 100.0 %
Date: 2017-01-25 Functions: 16 16 100.0 %

          Line data    Source code
       1             : /*
       2             :  * linux/fs/ext2/xattr.c
       3             :  *
       4             :  * Copyright (C) 2001-2003 Andreas Gruenbacher <agruen@suse.de>
       5             :  *
       6             :  * Fix by Harrison Xing <harrison@mountainviewdata.com>.
       7             :  * Extended attributes for symlinks and special files added per
       8             :  *  suggestion of Luka Renko <luka.renko@hermes.si>.
       9             :  * xattr consolidation Copyright (c) 2004 James Morris <jmorris@redhat.com>,
      10             :  *  Red Hat Inc.
      11             :  *
      12             :  */
      13             : 
      14             : /*
      15             :  * Extended attributes are stored on disk blocks allocated outside of
      16             :  * any inode. The i_file_acl field is then made to point to this allocated
      17             :  * block. If all extended attributes of an inode are identical, these
      18             :  * inodes may share the same extended attribute block. Such situations
      19             :  * are automatically detected by keeping a cache of recent attribute block
      20             :  * numbers and hashes over the block's contents in memory.
      21             :  *
      22             :  *
      23             :  * Extended attribute block layout:
      24             :  *
      25             :  *   +------------------+
      26             :  *   | header           |
      27             :  *   | entry 1          | |
      28             :  *   | entry 2          | | growing downwards
      29             :  *   | entry 3          | v
      30             :  *   | four null bytes  |
      31             :  *   | . . .            |
      32             :  *   | value 1          | ^
      33             :  *   | value 3          | | growing upwards
      34             :  *   | value 2          | |
      35             :  *   +------------------+
      36             :  *
      37             :  * The block header is followed by multiple entry descriptors. These entry
      38             :  * descriptors are variable in size, and alligned to EXT2_XATTR_PAD
      39             :  * byte boundaries. The entry descriptors are sorted by attribute name,
      40             :  * so that two extended attribute blocks can be compared efficiently.
      41             :  *
      42             :  * Attribute values are aligned to the end of the block, stored in
      43             :  * no specific order. They are also padded to EXT2_XATTR_PAD byte
      44             :  * boundaries. No additional gaps are left between them.
      45             :  *
      46             :  * Locking strategy
      47             :  * ----------------
      48             :  * EXT2_I(inode)->i_file_acl is protected by EXT2_I(inode)->xattr_sem.
      49             :  * EA blocks are only changed if they are exclusive to an inode, so
      50             :  * holding xattr_sem also means that nothing but the EA block's reference
      51             :  * count will change. Multiple writers to an EA block are synchronized
      52             :  * by the bh lock. No more than a single bh lock is held at any time
      53             :  * to avoid deadlocks.
      54             :  */
      55             : 
      56             : #include <linux/buffer_head.h>
      57             : #include <linux/module.h>
      58             : #include <linux/init.h>
      59             : #include <linux/slab.h>
      60             : #include <linux/mbcache.h>
      61             : #include <linux/quotaops.h>
      62             : #include <linux/rwsem.h>
      63             : #include <linux/security.h>
      64             : #include "ext2.h"
      65             : #include "xattr.h"
      66             : #include "acl.h"
      67             : 
      68             : #define HDR(bh) ((struct ext2_xattr_header *)((bh)->b_data))
      69             : #define ENTRY(ptr) ((struct ext2_xattr_entry *)(ptr))
      70             : #define FIRST_ENTRY(bh) ENTRY(HDR(bh)+1)
      71             : #define IS_LAST_ENTRY(entry) (*(__u32 *)(entry) == 0)
      72             : 
      73             : #ifdef EXT2_XATTR_DEBUG
      74             : # define ea_idebug(inode, f...) do { \
      75             :                 printk(KERN_DEBUG "inode %s:%ld: ", \
      76             :                         inode->i_sb->s_id, inode->i_ino); \
      77             :                 printk(f); \
      78             :                 printk("\n"); \
      79             :         } while (0)
      80             : # define ea_bdebug(bh, f...) do { \
      81             :                 char b[BDEVNAME_SIZE]; \
      82             :                 printk(KERN_DEBUG "block %s:%lu: ", \
      83             :                         bdevname(bh->b_bdev, b), \
      84             :                         (unsigned long) bh->b_blocknr); \
      85             :                 printk(f); \
      86             :                 printk("\n"); \
      87             :         } while (0)
      88             : #else
      89             : # define ea_idebug(f...)
      90             : # define ea_bdebug(f...)
      91             : #endif
      92             : 
      93             : static int ext2_xattr_set2(struct inode *, struct buffer_head *,
      94             :                            struct ext2_xattr_header *);
      95             : 
      96             : static int ext2_xattr_cache_insert(struct buffer_head *);
      97             : static struct buffer_head *ext2_xattr_cache_find(struct inode *,
      98             :                                                  struct ext2_xattr_header *);
      99             : static void ext2_xattr_rehash(struct ext2_xattr_header *,
     100             :                               struct ext2_xattr_entry *);
     101             : 
     102           1 : static struct mb_cache *ext2_xattr_cache;
     103             : 
     104           1 : static struct xattr_handler *ext2_xattr_handler_map[] = {
     105             :         [EXT2_XATTR_INDEX_USER]              = &ext2_xattr_user_handler,
     106             : #ifdef CONFIG_EXT2_FS_POSIX_ACL
     107             :         [EXT2_XATTR_INDEX_POSIX_ACL_ACCESS]  = &ext2_xattr_acl_access_handler,
     108             :         [EXT2_XATTR_INDEX_POSIX_ACL_DEFAULT] = &ext2_xattr_acl_default_handler,
     109             : #endif
     110             :         [EXT2_XATTR_INDEX_TRUSTED]           = &ext2_xattr_trusted_handler,
     111             : #ifdef CONFIG_EXT2_FS_SECURITY
     112             :         [EXT2_XATTR_INDEX_SECURITY]          = &ext2_xattr_security_handler,
     113             : #endif
     114             : };
     115             : 
     116           1 : struct xattr_handler *ext2_xattr_handlers[] = {
     117             :         &ext2_xattr_user_handler,
     118             :         &ext2_xattr_trusted_handler,
     119             : #ifdef CONFIG_EXT2_FS_POSIX_ACL
     120             :         &ext2_xattr_acl_access_handler,
     121             :         &ext2_xattr_acl_default_handler,
     122             : #endif
     123             : #ifdef CONFIG_EXT2_FS_SECURITY
     124             :         &ext2_xattr_security_handler,
     125             : #endif
     126             :         NULL
     127             : };
     128             : 
     129             : static inline struct xattr_handler *
     130             : ext2_xattr_handler(int name_index)
     131             : {
     132           8 :         struct xattr_handler *handler = NULL;
     133             : 
     134           8 :         if (name_index > 0 && name_index < ARRAY_SIZE(ext2_xattr_handler_map))
     135           4 :                 handler = ext2_xattr_handler_map[name_index];
     136           4 :         return handler;
     137             : }
     138             : 
     139             : /*
     140             :  * ext2_xattr_get()
     141             :  *
     142             :  * Copy an extended attribute into the buffer
     143             :  * provided, or compute the buffer size required.
     144             :  * Buffer is NULL to compute the size of the buffer required.
     145             :  *
     146             :  * Returns a negative error number on failure, or the number of bytes
     147             :  * used / required on success.
     148             :  */
     149             : int
     150             : ext2_xattr_get(struct inode *inode, int name_index, const char *name,
     151             :                void *buffer, size_t buffer_size)
     152             : {
     153           8 :         struct buffer_head *bh = NULL;
     154           4 :         struct ext2_xattr_entry *entry;
     155           4 :         size_t name_len, size;
     156           4 :         char *end;
     157           4 :         int error;
     158           4 : 
     159           4 :         ea_idebug(inode, "name=%d.%s, buffer=%p, buffer_size=%ld",
     160           4 :                   name_index, name, buffer, (long)buffer_size);
     161           4 : 
     162          12 :         if (name == NULL)
     163           8 :                 return -EINVAL;
     164          16 :         down_read(&EXT2_I(inode)->xattr_sem);
     165           8 :         error = -ENODATA;
     166          20 :         if (!EXT2_I(inode)->i_file_acl)
     167           8 :                 goto cleanup;
     168           4 :         ea_idebug(inode, "reading block %d", EXT2_I(inode)->i_file_acl);
     169          20 :         bh = sb_bread(inode->i_sb, EXT2_I(inode)->i_file_acl);
     170           4 :         error = -EIO;
     171           8 :         if (!bh)
     172           4 :                 goto cleanup;
     173             :         ea_bdebug(bh, "b_count=%d, refcount=%d",
     174             :                 atomic_read(&(bh->b_count)), le32_to_cpu(HDR(bh)->h_refcount));
     175           4 :         end = bh->b_data + bh->b_size;
     176          24 :         if (HDR(bh)->h_magic != cpu_to_le32(EXT2_XATTR_MAGIC) ||
     177           4 :             HDR(bh)->h_blocks != cpu_to_le32(1)) {
     178          36 : bad_block:      ext2_error(inode->i_sb, "ext2_xattr_get",
     179             :                         "inode %ld: bad block %d", inode->i_ino,
     180             :                         EXT2_I(inode)->i_file_acl);
     181           4 :                 error = -EIO;
     182           4 :                 goto cleanup;
     183             :         }
     184             :         /* find named attribute */
     185           4 :         name_len = strlen(name);
     186             : 
     187           4 :         error = -ERANGE;
     188           8 :         if (name_len > 255)
     189           4 :                 goto cleanup;
     190           4 :         entry = FIRST_ENTRY(bh);
     191          12 :         while (!IS_LAST_ENTRY(entry)) {
     192          12 :                 struct ext2_xattr_entry *next =
     193           4 :                         EXT2_XATTR_NEXT(entry);
     194           8 :                 if ((char *)next >= end)
     195           4 :                         goto bad_block;
     196          36 :                 if (name_index == entry->e_name_index &&
     197             :                     name_len == entry->e_name_len &&
     198             :                     memcmp(name, entry->e_name, name_len) == 0)
     199           4 :                         goto found;
     200           4 :                 entry = next;
     201           4 :         }
     202             :         /* Check the remaining name entries */
     203          12 :         while (!IS_LAST_ENTRY(entry)) {
     204          12 :                 struct ext2_xattr_entry *next =
     205           4 :                         EXT2_XATTR_NEXT(entry);
     206           8 :                 if ((char *)next >= end)
     207           4 :                         goto bad_block;
     208           4 :                 entry = next;
     209           4 :         }
     210           8 :         if (ext2_xattr_cache_insert(bh))
     211             :                 ea_idebug(inode, "cache insert failed");
     212           4 :         error = -ENODATA;
     213           4 :         goto cleanup;
     214           4 : found:
     215             :         /* check the buffer size */
     216           8 :         if (entry->e_value_block != 0)
     217           4 :                 goto bad_block;
     218           8 :         size = le32_to_cpu(entry->e_value_size);
     219          20 :         if (size > inode->i_sb->s_blocksize ||
     220             :             le16_to_cpu(entry->e_value_offs) + size > inode->i_sb->s_blocksize)
     221           4 :                 goto bad_block;
     222             : 
     223           8 :         if (ext2_xattr_cache_insert(bh))
     224             :                 ea_idebug(inode, "cache insert failed");
     225           8 :         if (buffer) {
     226           4 :                 error = -ERANGE;
     227           8 :                 if (size > buffer_size)
     228           4 :                         goto cleanup;
     229             :                 /* return value of attribute */
     230           8 :                 memcpy(buffer, bh->b_data + le16_to_cpu(entry->e_value_offs),
     231             :                         size);
     232             :         }
     233           4 :         error = size;
     234           4 : 
     235             : cleanup:
     236          40 :         brelse(bh);
     237          12 :         up_read(&EXT2_I(inode)->xattr_sem);
     238             : 
     239           4 :         return error;
     240             : }
     241             : 
     242             : /*
     243             :  * ext2_xattr_list()
     244             :  *
     245             :  * Copy a list of attribute names into the buffer
     246             :  * provided, or compute the buffer size required.
     247             :  * Buffer is NULL to compute the size of the buffer required.
     248             :  *
     249             :  * Returns a negative error number on failure, or the number of bytes
     250             :  * used / required on success.
     251             :  */
     252             : static int
     253             : ext2_xattr_list(struct dentry *dentry, char *buffer, size_t buffer_size)
     254             : {
     255           8 :         struct inode *inode = dentry->d_inode;
     256           8 :         struct buffer_head *bh = NULL;
     257           4 :         struct ext2_xattr_entry *entry;
     258           4 :         char *end;
     259           8 :         size_t rest = buffer_size;
     260           4 :         int error;
     261           4 : 
     262           4 :         ea_idebug(inode, "buffer=%p, buffer_size=%ld",
     263           4 :                   buffer, (long)buffer_size);
     264           4 : 
     265          16 :         down_read(&EXT2_I(inode)->xattr_sem);
     266           8 :         error = 0;
     267          20 :         if (!EXT2_I(inode)->i_file_acl)
     268           8 :                 goto cleanup;
     269           4 :         ea_idebug(inode, "reading block %d", EXT2_I(inode)->i_file_acl);
     270          24 :         bh = sb_bread(inode->i_sb, EXT2_I(inode)->i_file_acl);
     271           8 :         error = -EIO;
     272           8 :         if (!bh)
     273           4 :                 goto cleanup;
     274             :         ea_bdebug(bh, "b_count=%d, refcount=%d",
     275             :                 atomic_read(&(bh->b_count)), le32_to_cpu(HDR(bh)->h_refcount));
     276           4 :         end = bh->b_data + bh->b_size;
     277          24 :         if (HDR(bh)->h_magic != cpu_to_le32(EXT2_XATTR_MAGIC) ||
     278           4 :             HDR(bh)->h_blocks != cpu_to_le32(1)) {
     279          28 : bad_block:      ext2_error(inode->i_sb, "ext2_xattr_list",
     280             :                         "inode %ld: bad block %d", inode->i_ino,
     281             :                         EXT2_I(inode)->i_file_acl);
     282           4 :                 error = -EIO;
     283           4 :                 goto cleanup;
     284             :         }
     285             : 
     286             :         /* check the on-disk data structure */
     287           4 :         entry = FIRST_ENTRY(bh);
     288          12 :         while (!IS_LAST_ENTRY(entry)) {
     289          12 :                 struct ext2_xattr_entry *next = EXT2_XATTR_NEXT(entry);
     290           4 : 
     291           8 :                 if ((char *)next >= end)
     292           4 :                         goto bad_block;
     293           4 :                 entry = next;
     294           4 :         }
     295           8 :         if (ext2_xattr_cache_insert(bh))
     296             :                 ea_idebug(inode, "cache insert failed");
     297             : 
     298             :         /* list the attribute names */
     299          16 :         for (entry = FIRST_ENTRY(bh); !IS_LAST_ENTRY(entry);
     300          12 :              entry = EXT2_XATTR_NEXT(entry)) {
     301          24 :                 struct xattr_handler *handler =
     302             :                         ext2_xattr_handler(entry->e_name_index);
     303             : 
     304           8 :                 if (handler) {
     305          24 :                         size_t size = handler->list(dentry, buffer, rest,
     306             :                                                     entry->e_name,
     307             :                                                     entry->e_name_len,
     308             :                                                     handler->flags);
     309           8 :                         if (buffer) {
     310           8 :                                 if (size > rest) {
     311           4 :                                         error = -ERANGE;
     312           4 :                                         goto cleanup;
     313             :                                 }
     314           4 :                                 buffer += size;
     315             :                         }
     316           4 :                         rest -= size;
     317             :                 }
     318             :         }
     319           4 :         error = buffer_size - rest;  /* total size */
     320           4 : 
     321             : cleanup:
     322          40 :         brelse(bh);
     323          12 :         up_read(&EXT2_I(inode)->xattr_sem);
     324             : 
     325           4 :         return error;
     326             : }
     327             : 
     328             : /*
     329             :  * Inode operation listxattr()
     330             :  *
     331             :  * dentry->d_inode->i_mutex: don't care
     332             :  */
     333             : ssize_t
     334             : ext2_listxattr(struct dentry *dentry, char *buffer, size_t size)
     335             : {
     336          16 :         return ext2_xattr_list(dentry, buffer, size);
     337             : }
     338             : 
     339             : /*
     340             :  * If the EXT2_FEATURE_COMPAT_EXT_ATTR feature of this file system is
     341             :  * not set, set it.
     342             :  */
     343             : static void ext2_xattr_update_super_block(struct super_block *sb)
     344             : {
     345         500 :         if (EXT2_HAS_COMPAT_FEATURE(sb, EXT2_FEATURE_COMPAT_EXT_ATTR))
     346         200 :                 return;
     347         100 : 
     348         300 :         EXT2_SET_COMPAT_FEATURE(sb, EXT2_FEATURE_COMPAT_EXT_ATTR);
     349         100 :         sb->s_dirt = 1;
     350         300 :         mark_buffer_dirty(EXT2_SB(sb)->s_sbh);
     351         100 : }
     352             : 
     353             : /*
     354             :  * ext2_xattr_set()
     355             :  *
     356             :  * Create, replace or remove an extended attribute for this inode. Buffer
     357             :  * is NULL to remove an existing extended attribute, and non-NULL to
     358             :  * either replace an existing extended attribute, or create a new extended
     359             :  * attribute. The flags XATTR_REPLACE and XATTR_CREATE
     360             :  * specify that an extended attribute must exist and must not exist
     361             :  * previous to the call, respectively.
     362             :  *
     363             :  * Returns 0, or a negative error number on failure.
     364             :  */
     365             : int
     366             : ext2_xattr_set(struct inode *inode, int name_index, const char *name,
     367             :                const void *value, size_t value_len, int flags)
     368             : {
     369          40 :         struct super_block *sb = inode->i_sb;
     370          40 :         struct buffer_head *bh = NULL;
     371          40 :         struct ext2_xattr_header *header = NULL;
     372          20 :         struct ext2_xattr_entry *here, *last;
     373          40 :         size_t name_len, free, min_offs = sb->s_blocksize;
     374          40 :         int not_found = 1, error;
     375          20 :         char *end;
     376          20 :         
     377          20 :         /*
     378          20 :          * header -- Points either into bh, or to a temporarily
     379          20 :          *           allocated buffer.
     380          20 :          * here -- The named entry found, or the place for inserting, within
     381          20 :          *         the block pointed to by header.
     382          20 :          * last -- Points right after the last named entry within the block
     383          20 :          *         pointed to by header.
     384          20 :          * min_offs -- The offset of the first value (values are aligned
     385          20 :          *             towards the end of the block).
     386          20 :          * end -- Points right after the block pointed to by header.
     387          20 :          */
     388          20 :         
     389          20 :         ea_idebug(inode, "name=%d.%s, value=%p, value_len=%ld",
     390          20 :                   name_index, name, value, (long)value_len);
     391          20 : 
     392          60 :         if (value == NULL)
     393          40 :                 value_len = 0;
     394          60 :         if (name == NULL)
     395          40 :                 return -EINVAL;
     396          40 :         name_len = strlen(name);
     397         100 :         if (name_len > 255 || value_len > sb->s_blocksize)
     398          40 :                 return -ERANGE;
     399          80 :         down_write(&EXT2_I(inode)->xattr_sem);
     400         100 :         if (EXT2_I(inode)->i_file_acl) {
     401          20 :                 /* The inode already has an extended attribute block. */
     402         120 :                 bh = sb_bread(sb, EXT2_I(inode)->i_file_acl);
     403          40 :                 error = -EIO;
     404          60 :                 if (!bh)
     405          20 :                         goto cleanup;
     406             :                 ea_bdebug(bh, "b_count=%d, refcount=%d",
     407             :                         atomic_read(&(bh->b_count)),
     408             :                         le32_to_cpu(HDR(bh)->h_refcount));
     409          40 :                 header = HDR(bh);
     410          20 :                 end = bh->b_data + bh->b_size;
     411          80 :                 if (header->h_magic != cpu_to_le32(EXT2_XATTR_MAGIC) ||
     412          20 :                     header->h_blocks != cpu_to_le32(1)) {
     413         220 : bad_block:              ext2_error(sb, "ext2_xattr_set",
     414             :                                 "inode %ld: bad block %d", inode->i_ino, 
     415             :                                    EXT2_I(inode)->i_file_acl);
     416          20 :                         error = -EIO;
     417          20 :                         goto cleanup;
     418             :                 }
     419             :                 /* Find the named attribute. */
     420          20 :                 here = FIRST_ENTRY(bh);
     421          60 :                 while (!IS_LAST_ENTRY(here)) {
     422          60 :                         struct ext2_xattr_entry *next = EXT2_XATTR_NEXT(here);
     423          60 :                         if ((char *)next >= end)
     424          20 :                                 goto bad_block;
     425          80 :                         if (!here->e_value_block && here->e_value_size) {
     426          40 :                                 size_t offs = le16_to_cpu(here->e_value_offs);
     427          60 :                                 if (offs < min_offs)
     428          20 :                                         min_offs = offs;
     429             :                         }
     430          40 :                         not_found = name_index - here->e_name_index;
     431          40 :                         if (!not_found)
     432          40 :                                 not_found = name_len - here->e_name_len;
     433          40 :                         if (!not_found)
     434          20 :                                 not_found = memcmp(name, here->e_name,name_len);
     435          40 :                         if (not_found <= 0)
     436          20 :                                 break;
     437          20 :                         here = next;
     438          20 :                 }
     439          20 :                 last = here;
     440             :                 /* We still need to compute min_offs and last. */
     441          60 :                 while (!IS_LAST_ENTRY(last)) {
     442          60 :                         struct ext2_xattr_entry *next = EXT2_XATTR_NEXT(last);
     443          60 :                         if ((char *)next >= end)
     444          20 :                                 goto bad_block;
     445          80 :                         if (!last->e_value_block && last->e_value_size) {
     446          40 :                                 size_t offs = le16_to_cpu(last->e_value_offs);
     447          40 :                                 if (offs < min_offs)
     448          20 :                                         min_offs = offs;
     449             :                         }
     450          20 :                         last = next;
     451          20 :                 }
     452             : 
     453             :                 /* Check whether we have enough space left. */
     454          20 :                 free = min_offs - ((char*)last - (char*)header) - sizeof(__u32);
     455             :         } else {
     456             :                 /* We will use a new extended attribute block. */
     457          20 :                 free = sb->s_blocksize -
     458             :                         sizeof(struct ext2_xattr_header) - sizeof(__u32);
     459          40 :                 here = last = NULL;  /* avoid gcc uninitialized warning. */
     460             :         }
     461             : 
     462          80 :         if (not_found) {
     463             :                 /* Request to remove a nonexistent attribute? */
     464          40 :                 error = -ENODATA;
     465          80 :                 if (flags & XATTR_REPLACE)
     466          40 :                         goto cleanup;
     467          40 :                 error = 0;
     468          80 :                 if (value == NULL)
     469          40 :                         goto cleanup;
     470             :         } else {
     471             :                 /* Request to create an existing attribute? */
     472          40 :                 error = -EEXIST;
     473          80 :                 if (flags & XATTR_CREATE)
     474          40 :                         goto cleanup;
     475         160 :                 if (!here->e_value_block && here->e_value_size) {
     476          80 :                         size_t size = le32_to_cpu(here->e_value_size);
     477             : 
     478         200 :                         if (le16_to_cpu(here->e_value_offs) + size > 
     479             :                             sb->s_blocksize || size > sb->s_blocksize)
     480          40 :                                 goto bad_block;
     481          40 :                         free += EXT2_XATTR_SIZE(size);
     482             :                 }
     483          40 :                 free += EXT2_XATTR_LEN(name_len);
     484             :         }
     485          40 :         error = -ENOSPC;
     486          80 :         if (free < EXT2_XATTR_LEN(name_len) + EXT2_XATTR_SIZE(value_len))
     487          40 :                 goto cleanup;
     488             : 
     489             :         /* Here we know that we can set the new attribute. */
     490             : 
     491          80 :         if (header) {
     492             :                 struct mb_cache_entry *ce;
     493             : 
     494             :                 /* assert(header == HDR(bh)); */
     495          40 :                 ce = mb_cache_entry_get(ext2_xattr_cache, bh->b_bdev,
     496             :                                         bh->b_blocknr);
     497          80 :                 lock_buffer(bh);
     498          40 :                 if (header->h_refcount == cpu_to_le32(1)) {
     499             :                         ea_bdebug(bh, "modifying in-place");
     500          40 :                         if (ce)
     501          20 :                                 mb_cache_entry_free(ce);
     502             :                         /* keep the buffer locked while modifying it. */
     503             :                 } else {
     504             :                         int offset;
     505             : 
     506          40 :                         if (ce)
     507          20 :                                 mb_cache_entry_release(ce);
     508          20 :                         unlock_buffer(bh);
     509             :                         ea_bdebug(bh, "cloning");
     510          60 :                         header = kmalloc(bh->b_size, GFP_KERNEL);
     511          20 :                         error = -ENOMEM;
     512          40 :                         if (header == NULL)
     513          20 :                                 goto cleanup;
     514          40 :                         memcpy(header, HDR(bh), bh->b_size);
     515          20 :                         header->h_refcount = cpu_to_le32(1);
     516             : 
     517          40 :                         offset = (char *)here - bh->b_data;
     518          20 :                         here = ENTRY((char *)header + offset);
     519          40 :                         offset = (char *)last - bh->b_data;
     520          20 :                         last = ENTRY((char *)header + offset);
     521             :                 }
     522             :         } else {
     523             :                 /* Allocate a buffer where we construct the new block. */
     524         100 :                 header = kzalloc(sb->s_blocksize, GFP_KERNEL);
     525          20 :                 error = -ENOMEM;
     526          40 :                 if (header == NULL)
     527          20 :                         goto cleanup;
     528          20 :                 end = (char *)header + sb->s_blocksize;
     529          20 :                 header->h_magic = cpu_to_le32(EXT2_XATTR_MAGIC);
     530          60 :                 header->h_blocks = header->h_refcount = cpu_to_le32(1);
     531          40 :                 last = here = ENTRY(header+1);
     532             :         }
     533             : 
     534             :         /* Iff we are modifying the block in-place, bh is locked here. */
     535             : 
     536         120 :         if (not_found) {
     537             :                 /* Insert the new name. */
     538          60 :                 size_t size = EXT2_XATTR_LEN(name_len);
     539          60 :                 size_t rest = (char *)last - (char *)here;
     540          60 :                 memmove((char *)here + size, here, rest);
     541          60 :                 memset(here, 0, size);
     542          60 :                 here->e_name_index = name_index;
     543          60 :                 here->e_name_len = name_len;
     544          60 :                 memcpy(here->e_name, name, name_len);
     545             :         } else {
     546         240 :                 if (!here->e_value_block && here->e_value_size) {
     547          60 :                         char *first_val = (char *)header + min_offs;
     548         120 :                         size_t offs = le16_to_cpu(here->e_value_offs);
     549          60 :                         char *val = (char *)header + offs;
     550          60 :                         size_t size = EXT2_XATTR_SIZE(
     551             :                                 le32_to_cpu(here->e_value_size));
     552             : 
     553         120 :                         if (size == EXT2_XATTR_SIZE(value_len)) {
     554             :                                 /* The old and the new value have the same
     555             :                                    size. Just replace. */
     556          60 :                                 here->e_value_size = cpu_to_le32(value_len);
     557          60 :                                 memset(val + size - EXT2_XATTR_PAD, 0,
     558             :                                        EXT2_XATTR_PAD); /* Clear pad bytes. */
     559          60 :                                 memcpy(val, value, value_len);
     560          60 :                                 goto skip_replace;
     561             :                         }
     562             : 
     563             :                         /* Remove the old value. */
     564          60 :                         memmove(first_val + size, first_val, val - first_val);
     565          60 :                         memset(first_val, 0, size);
     566          60 :                         here->e_value_offs = 0;
     567          60 :                         min_offs += size;
     568             : 
     569             :                         /* Adjust all value offsets. */
     570          60 :                         last = ENTRY(header+1);
     571         100 :                         while (!IS_LAST_ENTRY(last)) {
     572          60 :                                 size_t o = le16_to_cpu(last->e_value_offs);
     573         100 :                                 if (!last->e_value_block && o < offs)
     574          20 :                                         last->e_value_offs =
     575             :                                                 cpu_to_le16(o + size);
     576          40 :                                 last = EXT2_XATTR_NEXT(last);
     577          20 :                         }
     578             :                 }
     579         160 :                 if (value == NULL) {
     580             :                         /* Remove the old name. */
     581          80 :                         size_t size = EXT2_XATTR_LEN(name_len);
     582          80 :                         last = ENTRY((char *)last - size);
     583          80 :                         memmove(here, (char*)here + size,
     584             :                                 (char*)last - (char*)here);
     585          80 :                         memset(last, 0, size);
     586             :                 }
     587             :         }
     588             : 
     589         160 :         if (value != NULL) {
     590             :                 /* Insert the new value. */
     591          80 :                 here->e_value_size = cpu_to_le32(value_len);
     592         160 :                 if (value_len) {
     593          80 :                         size_t size = EXT2_XATTR_SIZE(value_len);
     594          80 :                         char *val = (char *)header + min_offs - size;
     595          80 :                         here->e_value_offs =
     596             :                                 cpu_to_le16((char *)val - (char *)header);
     597          80 :                         memset(val + size - EXT2_XATTR_PAD, 0,
     598             :                                EXT2_XATTR_PAD); /* Clear the pad bytes. */
     599          80 :                         memcpy(val, value, value_len);
     600             :                 }
     601             :         }
     602             : 
     603             : skip_replace:
     604         160 :         if (IS_LAST_ENTRY(ENTRY(header+1))) {
     605             :                 /* This block is now empty. */
     606         400 :                 if (bh && header == HDR(bh))
     607         160 :                         unlock_buffer(bh);  /* we were modifying in-place. */
     608         160 :                 error = ext2_xattr_set2(inode, bh, NULL);
     609             :         } else {
     610         160 :                 ext2_xattr_rehash(header, here);
     611         100 :                 if (bh && header == HDR(bh))
     612          20 :                         unlock_buffer(bh);  /* we were modifying in-place. */
     613          40 :                 error = ext2_xattr_set2(inode, bh, header);
     614             :         }
     615             : 
     616          40 : cleanup:
     617         320 :         brelse(bh);
     618         100 :         if (!(bh && header == HDR(bh)))
     619          20 :                 kfree(header);
     620          60 :         up_write(&EXT2_I(inode)->xattr_sem);
     621             : 
     622          20 :         return error;
     623             : }
     624             : 
     625             : /*
     626             :  * Second half of ext2_xattr_set(): Update the file system.
     627             :  */
     628             : static int
     629             : ext2_xattr_set2(struct inode *inode, struct buffer_head *old_bh,
     630             :                 struct ext2_xattr_header *header)
     631         100 : {
     632         200 :         struct super_block *sb = inode->i_sb;
     633         200 :         struct buffer_head *new_bh = NULL;
     634         100 :         int error;
     635         100 : 
     636         300 :         if (header) {
     637         600 :                 new_bh = ext2_xattr_cache_find(inode, header);
     638         300 :                 if (new_bh) {
     639         100 :                         /* We found an identical block in the cache. */
     640         300 :                         if (new_bh == old_bh) {
     641         100 :                                 ea_bdebug(new_bh, "keeping this block");
     642         100 :                         } else {
     643         100 :                                 /* The old block is released after updating
     644         100 :                                    the inode.  */
     645         100 :                                 ea_bdebug(new_bh, "reusing block");
     646             : 
     647         100 :                                 error = -EDQUOT;
     648         400 :                                 if (vfs_dq_alloc_block(inode, 1)) {
     649         100 :                                         unlock_buffer(new_bh);
     650         100 :                                         goto cleanup;
     651             :                                 }
     652         300 :                                 le32_add_cpu(&HDR(new_bh)->h_refcount, 1);
     653             :                                 ea_bdebug(new_bh, "refcount now=%d",
     654             :                                         le32_to_cpu(HDR(new_bh)->h_refcount));
     655             :                         }
     656         200 :                         unlock_buffer(new_bh);
     657         500 :                 } else if (old_bh && header == HDR(old_bh)) {
     658             :                         /* Keep this block. No need to lock the block as we
     659             :                            don't need to change the reference count. */
     660         100 :                         new_bh = old_bh;
     661         200 :                         get_bh(new_bh);
     662         200 :                         ext2_xattr_cache_insert(new_bh);
     663             :                 } else {
     664             :                         /* We need to allocate a new block */
     665         600 :                         ext2_fsblk_t goal = ext2_group_first_block_no(sb,
     666             :                                                 EXT2_I(inode)->i_block_group);
     667         300 :                         int block = ext2_new_block(inode, goal, &error);
     668         200 :                         if (error)
     669         100 :                                 goto cleanup;
     670             :                         ea_idebug(inode, "creating block %d", block);
     671             : 
     672         200 :                         new_bh = sb_getblk(sb, block);
     673         200 :                         if (!new_bh) {
     674         200 :                                 ext2_free_blocks(inode, block, 1);
     675         100 :                                 error = -EIO;
     676         100 :                                 goto cleanup;
     677             :                         }
     678         200 :                         lock_buffer(new_bh);
     679         200 :                         memcpy(new_bh->b_data, header, new_bh->b_size);
     680         200 :                         set_buffer_uptodate(new_bh);
     681         100 :                         unlock_buffer(new_bh);
     682         200 :                         ext2_xattr_cache_insert(new_bh);
     683             :                         
     684         300 :                         ext2_xattr_update_super_block(sb);
     685             :                 }
     686         400 :                 mark_buffer_dirty(new_bh);
     687        2000 :                 if (IS_SYNC(inode)) {
     688         400 :                         sync_dirty_buffer(new_bh);
     689         400 :                         error = -EIO;
     690        1400 :                         if (buffer_req(new_bh) && !buffer_uptodate(new_bh))
     691         100 :                                 goto cleanup;
     692             :                 }
     693             :         }
     694             : 
     695             :         /* Update the inode. */
     696        2100 :         EXT2_I(inode)->i_file_acl = new_bh ? new_bh->b_blocknr : 0;
     697         400 :         inode->i_ctime = CURRENT_TIME_SEC;
     698         500 :         if (IS_SYNC(inode)) {
     699         200 :                 error = ext2_sync_inode (inode);
     700             :                 /* In case sync failed due to ENOSPC the inode was actually
     701             :                  * written (only some dirty data were not) so we just proceed
     702             :                  * as if nothing happened and cleanup the unused block */
     703         400 :                 if (error && error != -ENOSPC) {
     704         400 :                         if (new_bh && new_bh != old_bh)
     705         200 :                                 vfs_dq_free_block(inode, 1);
     706         200 :                         goto cleanup;
     707             :                 }
     708             :         } else
     709         200 :                 mark_inode_dirty(inode);
     710             : 
     711         200 :         error = 0;
     712         800 :         if (old_bh && old_bh != new_bh) {
     713             :                 struct mb_cache_entry *ce;
     714             : 
     715             :                 /*
     716             :                  * If there was an old block and we are no longer using it,
     717             :                  * release the old block.
     718             :                  */
     719         200 :                 ce = mb_cache_entry_get(ext2_xattr_cache, old_bh->b_bdev,
     720             :                                         old_bh->b_blocknr);
     721         400 :                 lock_buffer(old_bh);
     722         300 :                 if (HDR(old_bh)->h_refcount == cpu_to_le32(1)) {
     723             :                         /* Free the old block. */
     724         200 :                         if (ce)
     725         100 :                                 mb_cache_entry_free(ce);
     726             :                         ea_bdebug(old_bh, "freeing");
     727         200 :                         ext2_free_blocks(inode, old_bh->b_blocknr, 1);
     728             :                         /* We let our caller release old_bh, so we
     729             :                          * need to duplicate the buffer before. */
     730         200 :                         get_bh(old_bh);
     731         200 :                         bforget(old_bh);
     732             :                 } else {
     733             :                         /* Decrement the refcount only. */
     734         300 :                         le32_add_cpu(&HDR(old_bh)->h_refcount, -1);
     735         200 :                         if (ce)
     736         100 :                                 mb_cache_entry_release(ce);
     737         200 :                         vfs_dq_free_block(inode, 1);
     738         100 :                         mark_buffer_dirty(old_bh);
     739             :                         ea_bdebug(old_bh, "refcount now=%d",
     740             :                                 le32_to_cpu(HDR(old_bh)->h_refcount));
     741             :                 }
     742         200 :                 unlock_buffer(old_bh);
     743             :         }
     744             : 
     745             : cleanup:
     746        1800 :         brelse(new_bh);
     747         400 : 
     748         100 :         return error;
     749             : }
     750             : 
     751             : /*
     752             :  * ext2_xattr_delete_inode()
     753             :  *
     754             :  * Free extended attribute resources associated with this inode. This
     755             :  * is called immediately before an inode is freed.
     756             :  */
     757             : void
     758             : ext2_xattr_delete_inode(struct inode *inode)
     759             : {
     760           4 :         struct buffer_head *bh = NULL;
     761           2 :         struct mb_cache_entry *ce;
     762           2 : 
     763           8 :         down_write(&EXT2_I(inode)->xattr_sem);
     764          10 :         if (!EXT2_I(inode)->i_file_acl)
     765           4 :                 goto cleanup;
     766          12 :         bh = sb_bread(inode->i_sb, EXT2_I(inode)->i_file_acl);
     767           6 :         if (!bh) {
     768          12 :                 ext2_error(inode->i_sb, "ext2_xattr_delete_inode",
     769           2 :                         "inode %ld: block %d read error", inode->i_ino,
     770             :                         EXT2_I(inode)->i_file_acl);
     771           2 :                 goto cleanup;
     772             :         }
     773             :         ea_bdebug(bh, "b_count=%d", atomic_read(&(bh->b_count)));
     774          12 :         if (HDR(bh)->h_magic != cpu_to_le32(EXT2_XATTR_MAGIC) ||
     775             :             HDR(bh)->h_blocks != cpu_to_le32(1)) {
     776          10 :                 ext2_error(inode->i_sb, "ext2_xattr_delete_inode",
     777             :                         "inode %ld: bad block %d", inode->i_ino,
     778             :                         EXT2_I(inode)->i_file_acl);
     779           2 :                 goto cleanup;
     780             :         }
     781           2 :         ce = mb_cache_entry_get(ext2_xattr_cache, bh->b_bdev, bh->b_blocknr);
     782           4 :         lock_buffer(bh);
     783           6 :         if (HDR(bh)->h_refcount == cpu_to_le32(1)) {
     784           4 :                 if (ce)
     785           2 :                         mb_cache_entry_free(ce);
     786          10 :                 ext2_free_blocks(inode, EXT2_I(inode)->i_file_acl, 1);
     787           4 :                 get_bh(bh);
     788           4 :                 bforget(bh);
     789           2 :                 unlock_buffer(bh);
     790             :         } else {
     791           6 :                 le32_add_cpu(&HDR(bh)->h_refcount, -1);
     792           4 :                 if (ce)
     793           2 :                         mb_cache_entry_release(ce);
     794             :                 ea_bdebug(bh, "refcount now=%d",
     795             :                         le32_to_cpu(HDR(bh)->h_refcount));
     796           2 :                 unlock_buffer(bh);
     797           2 :                 mark_buffer_dirty(bh);
     798          10 :                 if (IS_SYNC(inode))
     799           2 :                         sync_dirty_buffer(bh);
     800           4 :                 vfs_dq_free_block(inode, 1);
     801             :         }
     802          10 :         EXT2_I(inode)->i_file_acl = 0;
     803             : 
     804           2 : cleanup:
     805          16 :         brelse(bh);
     806           6 :         up_write(&EXT2_I(inode)->xattr_sem);
     807           2 : }
     808             : 
     809             : /*
     810             :  * ext2_xattr_put_super()
     811             :  *
     812             :  * This is called when a file system is unmounted.
     813             :  */
     814             : void
     815             : ext2_xattr_put_super(struct super_block *sb)
     816             : {
     817           2 :         mb_cache_shrink(sb->s_bdev);
     818           2 : }
     819             : 
     820             : 
     821             : /*
     822             :  * ext2_xattr_cache_insert()
     823             :  *
     824             :  * Create a new entry in the extended attribute cache, and insert
     825             :  * it unless such an entry is already in the cache.
     826             :  *
     827             :  * Returns 0, or a negative error number on failure.
     828             :  */
     829             : static int
     830             : ext2_xattr_cache_insert(struct buffer_head *bh)
     831             : {
     832         636 :         __u32 hash = le32_to_cpu(HDR(bh)->h_hash);
     833         212 :         struct mb_cache_entry *ce;
     834         212 :         int error;
     835             : 
     836         212 :         ce = mb_cache_entry_alloc(ext2_xattr_cache, GFP_NOFS);
     837         424 :         if (!ce)
     838         212 :                 return -ENOMEM;
     839         212 :         error = mb_cache_entry_insert(ce, bh->b_bdev, bh->b_blocknr, &hash);
     840         424 :         if (error) {
     841         212 :                 mb_cache_entry_free(ce);
     842         424 :                 if (error == -EBUSY) {
     843             :                         ea_bdebug(bh, "already in cache (%d cache entries)",
     844             :                                 atomic_read(&ext2_xattr_cache->c_entry_count));
     845         212 :                         error = 0;
     846             :                 }
     847             :         } else {
     848             :                 ea_bdebug(bh, "inserting [%x] (%d cache entries)", (int)hash,
     849             :                           atomic_read(&ext2_xattr_cache->c_entry_count));
     850         212 :                 mb_cache_entry_release(ce);
     851             :         }
     852         212 :         return error;
     853             : }
     854             : 
     855             : /*
     856             :  * ext2_xattr_cmp()
     857             :  *
     858             :  * Compare two extended attribute blocks for equality.
     859             :  *
     860             :  * Returns 0 if the blocks are equal, 1 if they differ, and
     861             :  * a negative error number on errors.
     862             :  */
     863             : static int
     864             : ext2_xattr_cmp(struct ext2_xattr_header *header1,
     865             :                struct ext2_xattr_header *header2)
     866         100 : {
     867         100 :         struct ext2_xattr_entry *entry1, *entry2;
     868         100 : 
     869         200 :         entry1 = ENTRY(header1+1);
     870         100 :         entry2 = ENTRY(header2+1);
     871         300 :         while (!IS_LAST_ENTRY(entry1)) {
     872         300 :                 if (IS_LAST_ENTRY(entry2))
     873         200 :                         return 1;
     874        1000 :                 if (entry1->e_hash != entry2->e_hash ||
     875             :                     entry1->e_name_index != entry2->e_name_index ||
     876             :                     entry1->e_name_len != entry2->e_name_len ||
     877             :                     entry1->e_value_size != entry2->e_value_size ||
     878             :                     memcmp(entry1->e_name, entry2->e_name, entry1->e_name_len))
     879         200 :                         return 1;
     880         400 :                 if (entry1->e_value_block != 0 || entry2->e_value_block != 0)
     881         100 :                         return -EIO;
     882         600 :                 if (memcmp((char *)header1 + le16_to_cpu(entry1->e_value_offs),
     883             :                            (char *)header2 + le16_to_cpu(entry2->e_value_offs),
     884             :                            le32_to_cpu(entry1->e_value_size)))
     885         100 :                         return 1;
     886             : 
     887         200 :                 entry1 = EXT2_XATTR_NEXT(entry1);
     888         200 :                 entry2 = EXT2_XATTR_NEXT(entry2);
     889         100 :         }
     890         200 :         if (!IS_LAST_ENTRY(entry2))
     891         100 :                 return 1;
     892         100 :         return 0;
     893             : }
     894             : 
     895             : /*
     896             :  * ext2_xattr_cache_find()
     897             :  *
     898             :  * Find an identical extended attribute block.
     899             :  *
     900             :  * Returns a locked buffer head to the block found, or NULL if such
     901             :  * a block was not found or an error occurred.
     902             :  */
     903             : static struct buffer_head *
     904             : ext2_xattr_cache_find(struct inode *inode, struct ext2_xattr_header *header)
     905             : {
     906         200 :         __u32 hash = le32_to_cpu(header->h_hash);
     907         100 :         struct mb_cache_entry *ce;
     908         100 : 
     909         300 :         if (!header->h_hash)
     910         200 :                 return NULL;  /* never share */
     911         100 :         ea_idebug(inode, "looking for cached blocks [%x]", (int)hash);
     912             : again:
     913         100 :         ce = mb_cache_entry_find_first(ext2_xattr_cache, 0,
     914         100 :                                        inode->i_sb->s_bdev, hash);
     915         300 :         while (ce) {
     916         100 :                 struct buffer_head *bh;
     917         100 : 
     918         400 :                 if (IS_ERR(ce)) {
     919         400 :                         if (PTR_ERR(ce) == -EAGAIN)
     920         100 :                                 goto again;
     921         200 :                         break;
     922             :                 }
     923             : 
     924         200 :                 bh = sb_bread(inode->i_sb, ce->e_block);
     925         200 :                 if (!bh) {
     926         300 :                         ext2_error(inode->i_sb, "ext2_xattr_cache_find",
     927             :                                 "inode %ld: block %ld read error",
     928             :                                 inode->i_ino, (unsigned long) ce->e_block);
     929             :                 } else {
     930         200 :                         lock_buffer(bh);
     931         300 :                         if (le32_to_cpu(HDR(bh)->h_refcount) >
     932             :                                    EXT2_XATTR_REFCOUNT_MAX) {
     933             :                                 ea_idebug(inode, "block %ld refcount %d>%d",
     934             :                                           (unsigned long) ce->e_block,
     935             :                                           le32_to_cpu(HDR(bh)->h_refcount),
     936             :                                           EXT2_XATTR_REFCOUNT_MAX);
     937         500 :                         } else if (!ext2_xattr_cmp(header, HDR(bh))) {
     938             :                                 ea_bdebug(bh, "b_count=%d",
     939             :                                           atomic_read(&(bh->b_count)));
     940         100 :                                 mb_cache_entry_release(ce);
     941         100 :                                 return bh;
     942             :                         }
     943         200 :                         unlock_buffer(bh);
     944         400 :                         brelse(bh);
     945             :                 }
     946         200 :                 ce = mb_cache_entry_find_next(ce, 0, inode->i_sb->s_bdev, hash);
     947             :         }
     948         400 :         return NULL;
     949             : }
     950             : 
     951             : #define NAME_HASH_SHIFT 5
     952             : #define VALUE_HASH_SHIFT 16
     953             : 
     954             : /*
     955             :  * ext2_xattr_hash_entry()
     956             :  *
     957             :  * Compute the hash of an extended attribute.
     958             :  */
     959             : static inline void ext2_xattr_hash_entry(struct ext2_xattr_header *header,
     960             :                                          struct ext2_xattr_entry *entry)
     961          80 : {
     962         160 :         __u32 hash = 0;
     963         160 :         char *name = entry->e_name;
     964          80 :         int n;
     965          80 : 
     966         560 :         for (n=0; n < entry->e_name_len; n++) {
     967         400 :                 hash = (hash << NAME_HASH_SHIFT) ^
     968          80 :                        (hash >> (8*sizeof(hash) - NAME_HASH_SHIFT)) ^
     969             :                        *name++;
     970             :         }
     971             : 
     972         320 :         if (entry->e_value_block == 0 && entry->e_value_size != 0) {
     973         160 :                 __le32 *value = (__le32 *)((char *)header +
     974             :                         le16_to_cpu(entry->e_value_offs));
     975         320 :                 for (n = (le32_to_cpu(entry->e_value_size) +
     976         160 :                      EXT2_XATTR_ROUND) >> EXT2_XATTR_PAD_BITS; n; n--) {
     977         320 :                         hash = (hash << VALUE_HASH_SHIFT) ^
     978          80 :                                (hash >> (8*sizeof(hash) - VALUE_HASH_SHIFT)) ^
     979             :                                le32_to_cpu(*value++);
     980             :                 }
     981             :         }
     982         160 :         entry->e_hash = cpu_to_le32(hash);
     983         160 : }
     984             : 
     985             : #undef NAME_HASH_SHIFT
     986             : #undef VALUE_HASH_SHIFT
     987             : 
     988             : #define BLOCK_HASH_SHIFT 16
     989             : 
     990             : /*
     991             :  * ext2_xattr_rehash()
     992             :  *
     993             :  * Re-compute the extended attribute hash value after an entry has changed.
     994             :  */
     995             : static void ext2_xattr_rehash(struct ext2_xattr_header *header,
     996             :                               struct ext2_xattr_entry *entry)
     997          80 : {
     998          80 :         struct ext2_xattr_entry *here;
     999          80 :         __u32 hash = 0;
    1000             :         
    1001         240 :         ext2_xattr_hash_entry(header, entry);
    1002          80 :         here = ENTRY(header+1);
    1003         240 :         while (!IS_LAST_ENTRY(here)) {
    1004         240 :                 if (!here->e_hash) {
    1005          80 :                         /* Block is not shared if an entry's hash value == 0 */
    1006          80 :                         hash = 0;
    1007          80 :                         break;
    1008             :                 }
    1009         160 :                 hash = (hash << BLOCK_HASH_SHIFT) ^
    1010             :                        (hash >> (8*sizeof(hash) - BLOCK_HASH_SHIFT)) ^
    1011             :                        le32_to_cpu(here->e_hash);
    1012         160 :                 here = EXT2_XATTR_NEXT(here);
    1013          80 :         }
    1014          80 :         header->h_hash = cpu_to_le32(hash);
    1015          80 : }
    1016             : 
    1017             : #undef BLOCK_HASH_SHIFT
    1018             : 
    1019             : int __init
    1020             : init_ext2_xattr(void)
    1021             : {
    1022           1 :         ext2_xattr_cache = mb_cache_create("ext2_xattr", NULL,
    1023             :                 sizeof(struct mb_cache_entry) +
    1024             :                 sizeof(((struct mb_cache_entry *) 0)->e_indexes[0]), 1, 6);
    1025           2 :         if (!ext2_xattr_cache)
    1026           1 :                 return -ENOMEM;
    1027           1 :         return 0;
    1028             : }
    1029             : 
    1030             : void
    1031             : exit_ext2_xattr(void)
    1032             : {
    1033           4 :         mb_cache_destroy(ext2_xattr_cache);
    1034           4 : }

Generated by: LCOV version 1.10