~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/ext4/xattr.c

Version: ~ [ linux-5.4-rc7 ] ~ [ linux-5.3.11 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.84 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.154 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.201 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.201 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.77 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp