blob: cff4f41ced612d9b0f344be66a17e434981f8861 [file] [log] [blame]
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001/*
Mingming Cao617ba132006-10-11 01:20:53 -07002 * linux/fs/ext4/xattr.c
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003 *
4 * Copyright (C) 2001-2003 Andreas Gruenbacher, <agruen@suse.de>
5 *
6 * Fix by Harrison Xing <harrison@mountainviewdata.com>.
Mingming Cao617ba132006-10-11 01:20:53 -07007 * Ext4 code with a lot of help from Eric Jarman <ejarman@acm.org>.
Dave Kleikampac27a0e2006-10-11 01:20:50 -07008 * Extended attributes for symlinks and special files added per
9 * suggestion of Luka Renko <luka.renko@hermes.si>.
10 * xattr consolidation Copyright (c) 2004 James Morris <jmorris@redhat.com>,
11 * Red Hat Inc.
12 * ea-in-inode support by Alex Tomas <alex@clusterfs.com> aka bzzz
13 * and Andreas Gruenbacher <agruen@suse.de>.
14 */
15
16/*
17 * Extended attributes are stored directly in inodes (on file systems with
18 * inodes bigger than 128 bytes) and on additional disk blocks. The i_file_acl
19 * field contains the block number if an inode uses an additional block. All
20 * attributes must fit in the inode and one additional block. Blocks that
21 * contain the identical set of attributes may be shared among several inodes.
22 * Identical blocks are detected by keeping a cache of blocks that have
23 * recently been accessed.
24 *
25 * The attributes in inodes and on blocks have a different header; the entries
26 * are stored in the same format:
27 *
28 * +------------------+
29 * | header |
30 * | entry 1 | |
31 * | entry 2 | | growing downwards
32 * | entry 3 | v
33 * | four null bytes |
34 * | . . . |
35 * | value 1 | ^
36 * | value 3 | | growing upwards
37 * | value 2 | |
38 * +------------------+
39 *
40 * The header is followed by multiple entry descriptors. In disk blocks, the
41 * entry descriptors are kept sorted. In inodes, they are unsorted. The
42 * attribute values are aligned to the end of the block in no specific order.
43 *
44 * Locking strategy
45 * ----------------
Mingming Cao617ba132006-10-11 01:20:53 -070046 * EXT4_I(inode)->i_file_acl is protected by EXT4_I(inode)->xattr_sem.
Dave Kleikampac27a0e2006-10-11 01:20:50 -070047 * EA blocks are only changed if they are exclusive to an inode, so
48 * holding xattr_sem also means that nothing but the EA block's reference
49 * count can change. Multiple writers to the same block are synchronized
50 * by the buffer lock.
51 */
52
53#include <linux/init.h>
54#include <linux/fs.h>
55#include <linux/slab.h>
Jan Kara7a2508e2016-02-22 22:35:22 -050056#include <linux/mbcache.h>
Dave Kleikampac27a0e2006-10-11 01:20:50 -070057#include <linux/quotaops.h>
Christoph Hellwig3dcf5452008-04-29 18:13:32 -040058#include "ext4_jbd2.h"
59#include "ext4.h"
Dave Kleikampac27a0e2006-10-11 01:20:50 -070060#include "xattr.h"
61#include "acl.h"
62
Mingming Cao617ba132006-10-11 01:20:53 -070063#ifdef EXT4_XATTR_DEBUG
Joe Perchesd74f3d22016-10-15 09:57:31 -040064# define ea_idebug(inode, fmt, ...) \
65 printk(KERN_DEBUG "inode %s:%lu: " fmt "\n", \
66 inode->i_sb->s_id, inode->i_ino, ##__VA_ARGS__)
67# define ea_bdebug(bh, fmt, ...) \
68 printk(KERN_DEBUG "block %pg:%lu: " fmt "\n", \
69 bh->b_bdev, (unsigned long)bh->b_blocknr, ##__VA_ARGS__)
Dave Kleikampac27a0e2006-10-11 01:20:50 -070070#else
Joe Perchesace36ad2012-03-19 23:11:43 -040071# define ea_idebug(inode, fmt, ...) no_printk(fmt, ##__VA_ARGS__)
72# define ea_bdebug(bh, fmt, ...) no_printk(fmt, ##__VA_ARGS__)
Dave Kleikampac27a0e2006-10-11 01:20:50 -070073#endif
74
Tahsin Erdogan47387402017-06-22 11:28:55 -040075static void ext4_xattr_block_cache_insert(struct mb_cache *,
76 struct buffer_head *);
77static struct buffer_head *
78ext4_xattr_block_cache_find(struct inode *, struct ext4_xattr_header *,
79 struct mb_cache_entry **);
Tahsin Erdoganb9fc7612017-06-22 11:53:15 -040080static __le32 ext4_xattr_hash_entry(char *name, size_t name_len, __le32 *value,
81 size_t value_count);
Tahsin Erdogandaf83282017-06-22 11:52:03 -040082static void ext4_xattr_rehash(struct ext4_xattr_header *);
Dave Kleikampac27a0e2006-10-11 01:20:50 -070083
Eric Biggersd6006182017-04-29 23:47:50 -040084static const struct xattr_handler * const ext4_xattr_handler_map[] = {
Mingming Cao617ba132006-10-11 01:20:53 -070085 [EXT4_XATTR_INDEX_USER] = &ext4_xattr_user_handler,
Theodore Ts'o03010a32008-10-10 20:02:48 -040086#ifdef CONFIG_EXT4_FS_POSIX_ACL
Christoph Hellwig64e178a2013-12-20 05:16:44 -080087 [EXT4_XATTR_INDEX_POSIX_ACL_ACCESS] = &posix_acl_access_xattr_handler,
88 [EXT4_XATTR_INDEX_POSIX_ACL_DEFAULT] = &posix_acl_default_xattr_handler,
Dave Kleikampac27a0e2006-10-11 01:20:50 -070089#endif
Mingming Cao617ba132006-10-11 01:20:53 -070090 [EXT4_XATTR_INDEX_TRUSTED] = &ext4_xattr_trusted_handler,
Theodore Ts'o03010a32008-10-10 20:02:48 -040091#ifdef CONFIG_EXT4_FS_SECURITY
Mingming Cao617ba132006-10-11 01:20:53 -070092 [EXT4_XATTR_INDEX_SECURITY] = &ext4_xattr_security_handler,
Dave Kleikampac27a0e2006-10-11 01:20:50 -070093#endif
94};
95
Stephen Hemminger11e27522010-05-13 17:53:18 -070096const struct xattr_handler *ext4_xattr_handlers[] = {
Mingming Cao617ba132006-10-11 01:20:53 -070097 &ext4_xattr_user_handler,
98 &ext4_xattr_trusted_handler,
Theodore Ts'o03010a32008-10-10 20:02:48 -040099#ifdef CONFIG_EXT4_FS_POSIX_ACL
Christoph Hellwig64e178a2013-12-20 05:16:44 -0800100 &posix_acl_access_xattr_handler,
101 &posix_acl_default_xattr_handler,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700102#endif
Theodore Ts'o03010a32008-10-10 20:02:48 -0400103#ifdef CONFIG_EXT4_FS_SECURITY
Mingming Cao617ba132006-10-11 01:20:53 -0700104 &ext4_xattr_security_handler,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700105#endif
106 NULL
107};
108
Tahsin Erdogan47387402017-06-22 11:28:55 -0400109#define EA_BLOCK_CACHE(inode) (((struct ext4_sb_info *) \
110 inode->i_sb->s_fs_info)->s_ea_block_cache)
T Makphaibulchoke9c191f72014-03-18 19:24:49 -0400111
Tahsin Erdogandec214d2017-06-22 11:44:55 -0400112#define EA_INODE_CACHE(inode) (((struct ext4_sb_info *) \
113 inode->i_sb->s_fs_info)->s_ea_inode_cache)
114
Tahsin Erdogan30a7eb92017-06-22 11:42:09 -0400115static int
116ext4_expand_inode_array(struct ext4_xattr_inode_array **ea_inode_array,
117 struct inode *inode);
118
Tahsin Erdogan33d201e2017-06-21 21:17:10 -0400119#ifdef CONFIG_LOCKDEP
120void ext4_xattr_inode_set_class(struct inode *ea_inode)
121{
122 lockdep_set_subclass(&ea_inode->i_rwsem, 1);
123}
124#endif
125
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400126static __le32 ext4_xattr_block_csum(struct inode *inode,
127 sector_t block_nr,
128 struct ext4_xattr_header *hdr)
129{
130 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
Theodore Ts'od6a77102013-04-09 23:59:55 -0400131 __u32 csum;
Theodore Ts'od6a77102013-04-09 23:59:55 -0400132 __le64 dsk_block_nr = cpu_to_le64(block_nr);
Daeho Jeongb47820e2016-07-03 17:51:39 -0400133 __u32 dummy_csum = 0;
134 int offset = offsetof(struct ext4_xattr_header, h_checksum);
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400135
Theodore Ts'od6a77102013-04-09 23:59:55 -0400136 csum = ext4_chksum(sbi, sbi->s_csum_seed, (__u8 *)&dsk_block_nr,
137 sizeof(dsk_block_nr));
Daeho Jeongb47820e2016-07-03 17:51:39 -0400138 csum = ext4_chksum(sbi, csum, (__u8 *)hdr, offset);
139 csum = ext4_chksum(sbi, csum, (__u8 *)&dummy_csum, sizeof(dummy_csum));
140 offset += sizeof(dummy_csum);
141 csum = ext4_chksum(sbi, csum, (__u8 *)hdr + offset,
142 EXT4_BLOCK_SIZE(inode->i_sb) - offset);
Tao Ma41eb70d2012-07-09 16:29:27 -0400143
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400144 return cpu_to_le32(csum);
145}
146
147static int ext4_xattr_block_csum_verify(struct inode *inode,
Theodore Ts'odac7a4b2017-03-25 17:22:47 -0400148 struct buffer_head *bh)
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400149{
Theodore Ts'odac7a4b2017-03-25 17:22:47 -0400150 struct ext4_xattr_header *hdr = BHDR(bh);
151 int ret = 1;
152
153 if (ext4_has_metadata_csum(inode->i_sb)) {
154 lock_buffer(bh);
155 ret = (hdr->h_checksum == ext4_xattr_block_csum(inode,
156 bh->b_blocknr, hdr));
157 unlock_buffer(bh);
158 }
159 return ret;
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400160}
161
162static void ext4_xattr_block_csum_set(struct inode *inode,
Theodore Ts'odac7a4b2017-03-25 17:22:47 -0400163 struct buffer_head *bh)
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400164{
Theodore Ts'odac7a4b2017-03-25 17:22:47 -0400165 if (ext4_has_metadata_csum(inode->i_sb))
166 BHDR(bh)->h_checksum = ext4_xattr_block_csum(inode,
167 bh->b_blocknr, BHDR(bh));
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400168}
169
Stephen Hemminger11e27522010-05-13 17:53:18 -0700170static inline const struct xattr_handler *
Mingming Cao617ba132006-10-11 01:20:53 -0700171ext4_xattr_handler(int name_index)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700172{
Stephen Hemminger11e27522010-05-13 17:53:18 -0700173 const struct xattr_handler *handler = NULL;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700174
Mingming Cao617ba132006-10-11 01:20:53 -0700175 if (name_index > 0 && name_index < ARRAY_SIZE(ext4_xattr_handler_map))
176 handler = ext4_xattr_handler_map[name_index];
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700177 return handler;
178}
179
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700180static int
Eric Biggers2c4f9922017-04-29 23:56:52 -0400181ext4_xattr_check_entries(struct ext4_xattr_entry *entry, void *end,
182 void *value_start)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700183{
Darrick J. Wonga0626e752014-09-16 14:34:59 -0400184 struct ext4_xattr_entry *e = entry;
185
Eric Biggersd7614cc2016-12-01 14:57:29 -0500186 /* Find the end of the names list */
Darrick J. Wonga0626e752014-09-16 14:34:59 -0400187 while (!IS_LAST_ENTRY(e)) {
188 struct ext4_xattr_entry *next = EXT4_XATTR_NEXT(e);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700189 if ((void *)next >= end)
Darrick J. Wong6a797d22015-10-17 16:16:04 -0400190 return -EFSCORRUPTED;
Darrick J. Wonga0626e752014-09-16 14:34:59 -0400191 e = next;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700192 }
Darrick J. Wonga0626e752014-09-16 14:34:59 -0400193
Eric Biggersd7614cc2016-12-01 14:57:29 -0500194 /* Check the values */
Darrick J. Wonga0626e752014-09-16 14:34:59 -0400195 while (!IS_LAST_ENTRY(entry)) {
Andreas Dilgere50e5122017-06-21 21:10:32 -0400196 if (entry->e_value_size != 0 &&
197 entry->e_value_inum == 0) {
Eric Biggersd7614cc2016-12-01 14:57:29 -0500198 u16 offs = le16_to_cpu(entry->e_value_offs);
199 u32 size = le32_to_cpu(entry->e_value_size);
200 void *value;
201
202 /*
203 * The value cannot overlap the names, and the value
204 * with padding cannot extend beyond 'end'. Check both
205 * the padded and unpadded sizes, since the size may
206 * overflow to 0 when adding padding.
207 */
208 if (offs > end - value_start)
209 return -EFSCORRUPTED;
210 value = value_start + offs;
211 if (value < (void *)e + sizeof(u32) ||
212 size > end - value ||
213 EXT4_XATTR_SIZE(size) > end - value)
214 return -EFSCORRUPTED;
215 }
Darrick J. Wonga0626e752014-09-16 14:34:59 -0400216 entry = EXT4_XATTR_NEXT(entry);
217 }
218
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700219 return 0;
220}
221
222static inline int
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400223ext4_xattr_check_block(struct inode *inode, struct buffer_head *bh)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700224{
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400225 int error;
226
227 if (buffer_verified(bh))
228 return 0;
229
Mingming Cao617ba132006-10-11 01:20:53 -0700230 if (BHDR(bh)->h_magic != cpu_to_le32(EXT4_XATTR_MAGIC) ||
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700231 BHDR(bh)->h_blocks != cpu_to_le32(1))
Darrick J. Wong6a797d22015-10-17 16:16:04 -0400232 return -EFSCORRUPTED;
Theodore Ts'odac7a4b2017-03-25 17:22:47 -0400233 if (!ext4_xattr_block_csum_verify(inode, bh))
Darrick J. Wong6a797d22015-10-17 16:16:04 -0400234 return -EFSBADCRC;
Eric Biggers2c4f9922017-04-29 23:56:52 -0400235 error = ext4_xattr_check_entries(BFIRST(bh), bh->b_data + bh->b_size,
236 bh->b_data);
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400237 if (!error)
238 set_buffer_verified(bh);
239 return error;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700240}
241
Theodore Ts'o9e92f482016-03-22 16:13:15 -0400242static int
243__xattr_check_inode(struct inode *inode, struct ext4_xattr_ibody_header *header,
244 void *end, const char *function, unsigned int line)
245{
Theodore Ts'o9e92f482016-03-22 16:13:15 -0400246 int error = -EFSCORRUPTED;
247
Eric Biggers290ab232016-12-01 14:51:58 -0500248 if (end - (void *)header < sizeof(*header) + sizeof(u32) ||
Eric Biggers19962502016-10-15 09:39:31 -0400249 (header->h_magic != cpu_to_le32(EXT4_XATTR_MAGIC)))
Theodore Ts'o9e92f482016-03-22 16:13:15 -0400250 goto errout;
Eric Biggers2c4f9922017-04-29 23:56:52 -0400251 error = ext4_xattr_check_entries(IFIRST(header), end, IFIRST(header));
Theodore Ts'o9e92f482016-03-22 16:13:15 -0400252errout:
253 if (error)
254 __ext4_error_inode(inode, function, line, 0,
255 "corrupted in-inode xattr");
256 return error;
257}
258
259#define xattr_check_inode(inode, header, end) \
260 __xattr_check_inode((inode), (header), (end), __func__, __LINE__)
261
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700262static int
Mingming Cao617ba132006-10-11 01:20:53 -0700263ext4_xattr_find_entry(struct ext4_xattr_entry **pentry, int name_index,
Eric Biggers6ba644b2017-04-30 00:01:02 -0400264 const char *name, int sorted)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700265{
Mingming Cao617ba132006-10-11 01:20:53 -0700266 struct ext4_xattr_entry *entry;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700267 size_t name_len;
268 int cmp = 1;
269
270 if (name == NULL)
271 return -EINVAL;
272 name_len = strlen(name);
273 entry = *pentry;
Mingming Cao617ba132006-10-11 01:20:53 -0700274 for (; !IS_LAST_ENTRY(entry); entry = EXT4_XATTR_NEXT(entry)) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700275 cmp = name_index - entry->e_name_index;
276 if (!cmp)
277 cmp = name_len - entry->e_name_len;
278 if (!cmp)
279 cmp = memcmp(name, entry->e_name, name_len);
280 if (cmp <= 0 && (sorted || cmp == 0))
281 break;
282 }
283 *pentry = entry;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700284 return cmp ? -ENODATA : 0;
285}
286
Tahsin Erdogandec214d2017-06-22 11:44:55 -0400287static u32
288ext4_xattr_inode_hash(struct ext4_sb_info *sbi, const void *buffer, size_t size)
289{
290 return ext4_chksum(sbi, sbi->s_csum_seed, buffer, size);
291}
292
293static u64 ext4_xattr_inode_get_ref(struct inode *ea_inode)
294{
295 return ((u64)ea_inode->i_ctime.tv_sec << 32) |
296 ((u32)ea_inode->i_version);
297}
298
299static void ext4_xattr_inode_set_ref(struct inode *ea_inode, u64 ref_count)
300{
301 ea_inode->i_ctime.tv_sec = (u32)(ref_count >> 32);
302 ea_inode->i_version = (u32)ref_count;
303}
304
305static u32 ext4_xattr_inode_get_hash(struct inode *ea_inode)
306{
307 return (u32)ea_inode->i_atime.tv_sec;
308}
309
310static void ext4_xattr_inode_set_hash(struct inode *ea_inode, u32 hash)
311{
312 ea_inode->i_atime.tv_sec = hash;
313}
314
Andreas Dilgere50e5122017-06-21 21:10:32 -0400315/*
316 * Read the EA value from an inode.
317 */
Tahsin Erdogan909666932017-06-21 21:57:36 -0400318static int ext4_xattr_inode_read(struct inode *ea_inode, void *buf, size_t size)
Andreas Dilgere50e5122017-06-21 21:10:32 -0400319{
320 unsigned long block = 0;
Tahsin Erdogandec214d2017-06-22 11:44:55 -0400321 struct buffer_head *bh;
Tahsin Erdogan909666932017-06-21 21:57:36 -0400322 int blocksize = ea_inode->i_sb->s_blocksize;
323 size_t csize, copied = 0;
Tahsin Erdogandec214d2017-06-22 11:44:55 -0400324 void *copy_pos = buf;
Andreas Dilgere50e5122017-06-21 21:10:32 -0400325
Tahsin Erdogan909666932017-06-21 21:57:36 -0400326 while (copied < size) {
327 csize = (size - copied) > blocksize ? blocksize : size - copied;
Andreas Dilgere50e5122017-06-21 21:10:32 -0400328 bh = ext4_bread(NULL, ea_inode, block, 0);
Tahsin Erdogan909666932017-06-21 21:57:36 -0400329 if (IS_ERR(bh))
Andreas Dilgere50e5122017-06-21 21:10:32 -0400330 return PTR_ERR(bh);
Tahsin Erdogan909666932017-06-21 21:57:36 -0400331 if (!bh)
332 return -EFSCORRUPTED;
333
Tahsin Erdogandec214d2017-06-22 11:44:55 -0400334 memcpy(copy_pos, bh->b_data, csize);
Andreas Dilgere50e5122017-06-21 21:10:32 -0400335 brelse(bh);
336
Tahsin Erdogandec214d2017-06-22 11:44:55 -0400337 copy_pos += csize;
Andreas Dilgere50e5122017-06-21 21:10:32 -0400338 block += 1;
Tahsin Erdogan909666932017-06-21 21:57:36 -0400339 copied += csize;
Andreas Dilgere50e5122017-06-21 21:10:32 -0400340 }
Andreas Dilgere50e5122017-06-21 21:10:32 -0400341 return 0;
342}
343
Tahsin Erdoganbab79b02017-06-21 21:49:53 -0400344static int ext4_xattr_inode_iget(struct inode *parent, unsigned long ea_ino,
345 struct inode **ea_inode)
Andreas Dilgere50e5122017-06-21 21:10:32 -0400346{
Tahsin Erdoganbab79b02017-06-21 21:49:53 -0400347 struct inode *inode;
348 int err;
Andreas Dilgere50e5122017-06-21 21:10:32 -0400349
Tahsin Erdoganbab79b02017-06-21 21:49:53 -0400350 inode = ext4_iget(parent->i_sb, ea_ino);
351 if (IS_ERR(inode)) {
352 err = PTR_ERR(inode);
Tahsin Erdogandec214d2017-06-22 11:44:55 -0400353 ext4_error(parent->i_sb,
354 "error while reading EA inode %lu err=%d", ea_ino,
355 err);
Tahsin Erdoganbab79b02017-06-21 21:49:53 -0400356 return err;
Andreas Dilgere50e5122017-06-21 21:10:32 -0400357 }
358
Tahsin Erdoganbab79b02017-06-21 21:49:53 -0400359 if (is_bad_inode(inode)) {
Tahsin Erdogandec214d2017-06-22 11:44:55 -0400360 ext4_error(parent->i_sb,
361 "error while reading EA inode %lu is_bad_inode",
362 ea_ino);
Tahsin Erdoganbab79b02017-06-21 21:49:53 -0400363 err = -EIO;
Andreas Dilgere50e5122017-06-21 21:10:32 -0400364 goto error;
365 }
366
Tahsin Erdoganbab79b02017-06-21 21:49:53 -0400367 if (!(EXT4_I(inode)->i_flags & EXT4_EA_INODE_FL)) {
Tahsin Erdogandec214d2017-06-22 11:44:55 -0400368 ext4_error(parent->i_sb,
369 "EA inode %lu does not have EXT4_EA_INODE_FL flag",
370 ea_ino);
Tahsin Erdoganbab79b02017-06-21 21:49:53 -0400371 err = -EINVAL;
Andreas Dilgere50e5122017-06-21 21:10:32 -0400372 goto error;
373 }
374
Tahsin Erdoganbab79b02017-06-21 21:49:53 -0400375 *ea_inode = inode;
376 return 0;
Andreas Dilgere50e5122017-06-21 21:10:32 -0400377error:
Tahsin Erdoganbab79b02017-06-21 21:49:53 -0400378 iput(inode);
379 return err;
Andreas Dilgere50e5122017-06-21 21:10:32 -0400380}
381
Tahsin Erdogandec214d2017-06-22 11:44:55 -0400382static int
Tahsin Erdoganb9fc7612017-06-22 11:53:15 -0400383ext4_xattr_inode_verify_hashes(struct inode *ea_inode,
384 struct ext4_xattr_entry *entry, void *buffer,
385 size_t size)
Tahsin Erdogandec214d2017-06-22 11:44:55 -0400386{
387 u32 hash;
388
389 /* Verify stored hash matches calculated hash. */
390 hash = ext4_xattr_inode_hash(EXT4_SB(ea_inode->i_sb), buffer, size);
391 if (hash != ext4_xattr_inode_get_hash(ea_inode))
392 return -EFSCORRUPTED;
Tahsin Erdoganb9fc7612017-06-22 11:53:15 -0400393
394 if (entry) {
395 __le32 e_hash, tmp_data;
396
397 /* Verify entry hash. */
398 tmp_data = cpu_to_le32(hash);
399 e_hash = ext4_xattr_hash_entry(entry->e_name, entry->e_name_len,
400 &tmp_data, 1);
401 if (e_hash != entry->e_hash)
402 return -EFSCORRUPTED;
403 }
Tahsin Erdogandec214d2017-06-22 11:44:55 -0400404 return 0;
405}
406
407#define EXT4_XATTR_INODE_GET_PARENT(inode) ((__u32)(inode)->i_mtime.tv_sec)
408
Andreas Dilgere50e5122017-06-21 21:10:32 -0400409/*
Tahsin Erdoganb9fc7612017-06-22 11:53:15 -0400410 * Read xattr value from the EA inode.
Andreas Dilgere50e5122017-06-21 21:10:32 -0400411 */
412static int
Tahsin Erdoganb9fc7612017-06-22 11:53:15 -0400413ext4_xattr_inode_get(struct inode *inode, struct ext4_xattr_entry *entry,
414 void *buffer, size_t size)
Andreas Dilgere50e5122017-06-21 21:10:32 -0400415{
Tahsin Erdogandec214d2017-06-22 11:44:55 -0400416 struct mb_cache *ea_inode_cache = EA_INODE_CACHE(inode);
Tahsin Erdoganbab79b02017-06-21 21:49:53 -0400417 struct inode *ea_inode;
Tahsin Erdogandec214d2017-06-22 11:44:55 -0400418 int err;
Andreas Dilgere50e5122017-06-21 21:10:32 -0400419
Tahsin Erdoganb9fc7612017-06-22 11:53:15 -0400420 err = ext4_xattr_inode_iget(inode, le32_to_cpu(entry->e_value_inum),
421 &ea_inode);
Tahsin Erdogandec214d2017-06-22 11:44:55 -0400422 if (err) {
423 ea_inode = NULL;
424 goto out;
425 }
Andreas Dilgere50e5122017-06-21 21:10:32 -0400426
Tahsin Erdogandec214d2017-06-22 11:44:55 -0400427 if (i_size_read(ea_inode) != size) {
428 ext4_warning_inode(ea_inode,
429 "ea_inode file size=%llu entry size=%zu",
430 i_size_read(ea_inode), size);
431 err = -EFSCORRUPTED;
432 goto out;
433 }
434
435 err = ext4_xattr_inode_read(ea_inode, buffer, size);
436 if (err)
437 goto out;
438
Tahsin Erdoganb9fc7612017-06-22 11:53:15 -0400439 err = ext4_xattr_inode_verify_hashes(ea_inode, entry, buffer, size);
Tahsin Erdogandec214d2017-06-22 11:44:55 -0400440 /*
441 * Compatibility check for old Lustre ea_inode implementation. Old
442 * version does not have hash validation, but it has a backpointer
443 * from ea_inode to the parent inode.
444 */
445 if (err == -EFSCORRUPTED) {
446 if (EXT4_XATTR_INODE_GET_PARENT(ea_inode) != inode->i_ino ||
447 ea_inode->i_generation != inode->i_generation) {
448 ext4_warning_inode(ea_inode,
449 "EA inode hash validation failed");
450 goto out;
451 }
452 /* Do not add ea_inode to the cache. */
453 ea_inode_cache = NULL;
454 } else if (err)
455 goto out;
456
457 if (ea_inode_cache)
458 mb_cache_entry_create(ea_inode_cache, GFP_NOFS,
459 ext4_xattr_inode_get_hash(ea_inode),
460 ea_inode->i_ino, true /* reusable */);
461out:
Andreas Dilgere50e5122017-06-21 21:10:32 -0400462 iput(ea_inode);
Tahsin Erdogandec214d2017-06-22 11:44:55 -0400463 return err;
Andreas Dilgere50e5122017-06-21 21:10:32 -0400464}
465
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700466static int
Mingming Cao617ba132006-10-11 01:20:53 -0700467ext4_xattr_block_get(struct inode *inode, int name_index, const char *name,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700468 void *buffer, size_t buffer_size)
469{
470 struct buffer_head *bh = NULL;
Mingming Cao617ba132006-10-11 01:20:53 -0700471 struct ext4_xattr_entry *entry;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700472 size_t size;
473 int error;
Tahsin Erdogan47387402017-06-22 11:28:55 -0400474 struct mb_cache *ea_block_cache = EA_BLOCK_CACHE(inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700475
476 ea_idebug(inode, "name=%d.%s, buffer=%p, buffer_size=%ld",
477 name_index, name, buffer, (long)buffer_size);
478
479 error = -ENODATA;
Mingming Cao617ba132006-10-11 01:20:53 -0700480 if (!EXT4_I(inode)->i_file_acl)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700481 goto cleanup;
Joe Perchesace36ad2012-03-19 23:11:43 -0400482 ea_idebug(inode, "reading block %llu",
483 (unsigned long long)EXT4_I(inode)->i_file_acl);
Mingming Cao617ba132006-10-11 01:20:53 -0700484 bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700485 if (!bh)
486 goto cleanup;
487 ea_bdebug(bh, "b_count=%d, refcount=%d",
488 atomic_read(&(bh->b_count)), le32_to_cpu(BHDR(bh)->h_refcount));
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400489 if (ext4_xattr_check_block(inode, bh)) {
Theodore Ts'o24676da2010-05-16 21:00:00 -0400490 EXT4_ERROR_INODE(inode, "bad block %llu",
491 EXT4_I(inode)->i_file_acl);
Darrick J. Wong6a797d22015-10-17 16:16:04 -0400492 error = -EFSCORRUPTED;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700493 goto cleanup;
494 }
Tahsin Erdogan47387402017-06-22 11:28:55 -0400495 ext4_xattr_block_cache_insert(ea_block_cache, bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700496 entry = BFIRST(bh);
Eric Biggers6ba644b2017-04-30 00:01:02 -0400497 error = ext4_xattr_find_entry(&entry, name_index, name, 1);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700498 if (error)
499 goto cleanup;
500 size = le32_to_cpu(entry->e_value_size);
501 if (buffer) {
502 error = -ERANGE;
503 if (size > buffer_size)
504 goto cleanup;
Andreas Dilgere50e5122017-06-21 21:10:32 -0400505 if (entry->e_value_inum) {
Tahsin Erdoganb9fc7612017-06-22 11:53:15 -0400506 error = ext4_xattr_inode_get(inode, entry, buffer,
507 size);
Andreas Dilgere50e5122017-06-21 21:10:32 -0400508 if (error)
509 goto cleanup;
510 } else {
511 memcpy(buffer, bh->b_data +
512 le16_to_cpu(entry->e_value_offs), size);
513 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700514 }
515 error = size;
516
517cleanup:
518 brelse(bh);
519 return error;
520}
521
Tao Ma879b3822012-12-05 10:28:46 -0500522int
Mingming Cao617ba132006-10-11 01:20:53 -0700523ext4_xattr_ibody_get(struct inode *inode, int name_index, const char *name,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700524 void *buffer, size_t buffer_size)
525{
Mingming Cao617ba132006-10-11 01:20:53 -0700526 struct ext4_xattr_ibody_header *header;
527 struct ext4_xattr_entry *entry;
528 struct ext4_inode *raw_inode;
529 struct ext4_iloc iloc;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700530 size_t size;
531 void *end;
532 int error;
533
Theodore Ts'o19f5fb72010-01-24 14:34:07 -0500534 if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR))
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700535 return -ENODATA;
Mingming Cao617ba132006-10-11 01:20:53 -0700536 error = ext4_get_inode_loc(inode, &iloc);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700537 if (error)
538 return error;
Mingming Cao617ba132006-10-11 01:20:53 -0700539 raw_inode = ext4_raw_inode(&iloc);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700540 header = IHDR(inode, raw_inode);
Mingming Cao617ba132006-10-11 01:20:53 -0700541 end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
Theodore Ts'o9e92f482016-03-22 16:13:15 -0400542 error = xattr_check_inode(inode, header, end);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700543 if (error)
544 goto cleanup;
Eric Biggers6ba644b2017-04-30 00:01:02 -0400545 entry = IFIRST(header);
546 error = ext4_xattr_find_entry(&entry, name_index, name, 0);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700547 if (error)
548 goto cleanup;
549 size = le32_to_cpu(entry->e_value_size);
550 if (buffer) {
551 error = -ERANGE;
552 if (size > buffer_size)
553 goto cleanup;
Andreas Dilgere50e5122017-06-21 21:10:32 -0400554 if (entry->e_value_inum) {
Tahsin Erdoganb9fc7612017-06-22 11:53:15 -0400555 error = ext4_xattr_inode_get(inode, entry, buffer,
556 size);
Andreas Dilgere50e5122017-06-21 21:10:32 -0400557 if (error)
558 goto cleanup;
559 } else {
560 memcpy(buffer, (void *)IFIRST(header) +
561 le16_to_cpu(entry->e_value_offs), size);
562 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700563 }
564 error = size;
565
566cleanup:
567 brelse(iloc.bh);
568 return error;
569}
570
571/*
Mingming Cao617ba132006-10-11 01:20:53 -0700572 * ext4_xattr_get()
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700573 *
574 * Copy an extended attribute into the buffer
575 * provided, or compute the buffer size required.
576 * Buffer is NULL to compute the size of the buffer required.
577 *
578 * Returns a negative error number on failure, or the number of bytes
579 * used / required on success.
580 */
581int
Mingming Cao617ba132006-10-11 01:20:53 -0700582ext4_xattr_get(struct inode *inode, int name_index, const char *name,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700583 void *buffer, size_t buffer_size)
584{
585 int error;
586
Theodore Ts'o0db1ff22017-02-05 01:28:48 -0500587 if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb))))
588 return -EIO;
589
Zhang Zhen230b8c1a2014-05-12 09:57:59 -0400590 if (strlen(name) > 255)
591 return -ERANGE;
592
Mingming Cao617ba132006-10-11 01:20:53 -0700593 down_read(&EXT4_I(inode)->xattr_sem);
594 error = ext4_xattr_ibody_get(inode, name_index, name, buffer,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700595 buffer_size);
596 if (error == -ENODATA)
Mingming Cao617ba132006-10-11 01:20:53 -0700597 error = ext4_xattr_block_get(inode, name_index, name, buffer,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700598 buffer_size);
Mingming Cao617ba132006-10-11 01:20:53 -0700599 up_read(&EXT4_I(inode)->xattr_sem);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700600 return error;
601}
602
603static int
Christoph Hellwig431547b2009-11-13 09:52:56 +0000604ext4_xattr_list_entries(struct dentry *dentry, struct ext4_xattr_entry *entry,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700605 char *buffer, size_t buffer_size)
606{
607 size_t rest = buffer_size;
608
Mingming Cao617ba132006-10-11 01:20:53 -0700609 for (; !IS_LAST_ENTRY(entry); entry = EXT4_XATTR_NEXT(entry)) {
Stephen Hemminger11e27522010-05-13 17:53:18 -0700610 const struct xattr_handler *handler =
Mingming Cao617ba132006-10-11 01:20:53 -0700611 ext4_xattr_handler(entry->e_name_index);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700612
Andreas Gruenbacher764a5c62015-12-02 14:44:43 +0100613 if (handler && (!handler->list || handler->list(dentry))) {
614 const char *prefix = handler->prefix ?: handler->name;
615 size_t prefix_len = strlen(prefix);
616 size_t size = prefix_len + entry->e_name_len + 1;
617
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700618 if (buffer) {
619 if (size > rest)
620 return -ERANGE;
Andreas Gruenbacher764a5c62015-12-02 14:44:43 +0100621 memcpy(buffer, prefix, prefix_len);
622 buffer += prefix_len;
623 memcpy(buffer, entry->e_name, entry->e_name_len);
624 buffer += entry->e_name_len;
625 *buffer++ = 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700626 }
627 rest -= size;
628 }
629 }
Andreas Gruenbacher764a5c62015-12-02 14:44:43 +0100630 return buffer_size - rest; /* total size */
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700631}
632
633static int
Christoph Hellwig431547b2009-11-13 09:52:56 +0000634ext4_xattr_block_list(struct dentry *dentry, char *buffer, size_t buffer_size)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700635{
David Howells2b0143b2015-03-17 22:25:59 +0000636 struct inode *inode = d_inode(dentry);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700637 struct buffer_head *bh = NULL;
638 int error;
639
640 ea_idebug(inode, "buffer=%p, buffer_size=%ld",
641 buffer, (long)buffer_size);
642
643 error = 0;
Mingming Cao617ba132006-10-11 01:20:53 -0700644 if (!EXT4_I(inode)->i_file_acl)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700645 goto cleanup;
Joe Perchesace36ad2012-03-19 23:11:43 -0400646 ea_idebug(inode, "reading block %llu",
647 (unsigned long long)EXT4_I(inode)->i_file_acl);
Mingming Cao617ba132006-10-11 01:20:53 -0700648 bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700649 error = -EIO;
650 if (!bh)
651 goto cleanup;
652 ea_bdebug(bh, "b_count=%d, refcount=%d",
653 atomic_read(&(bh->b_count)), le32_to_cpu(BHDR(bh)->h_refcount));
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400654 if (ext4_xattr_check_block(inode, bh)) {
Theodore Ts'o24676da2010-05-16 21:00:00 -0400655 EXT4_ERROR_INODE(inode, "bad block %llu",
656 EXT4_I(inode)->i_file_acl);
Darrick J. Wong6a797d22015-10-17 16:16:04 -0400657 error = -EFSCORRUPTED;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700658 goto cleanup;
659 }
Tahsin Erdogan47387402017-06-22 11:28:55 -0400660 ext4_xattr_block_cache_insert(EA_BLOCK_CACHE(inode), bh);
Christoph Hellwig431547b2009-11-13 09:52:56 +0000661 error = ext4_xattr_list_entries(dentry, BFIRST(bh), buffer, buffer_size);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700662
663cleanup:
664 brelse(bh);
665
666 return error;
667}
668
669static int
Christoph Hellwig431547b2009-11-13 09:52:56 +0000670ext4_xattr_ibody_list(struct dentry *dentry, char *buffer, size_t buffer_size)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700671{
David Howells2b0143b2015-03-17 22:25:59 +0000672 struct inode *inode = d_inode(dentry);
Mingming Cao617ba132006-10-11 01:20:53 -0700673 struct ext4_xattr_ibody_header *header;
674 struct ext4_inode *raw_inode;
675 struct ext4_iloc iloc;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700676 void *end;
677 int error;
678
Theodore Ts'o19f5fb72010-01-24 14:34:07 -0500679 if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR))
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700680 return 0;
Mingming Cao617ba132006-10-11 01:20:53 -0700681 error = ext4_get_inode_loc(inode, &iloc);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700682 if (error)
683 return error;
Mingming Cao617ba132006-10-11 01:20:53 -0700684 raw_inode = ext4_raw_inode(&iloc);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700685 header = IHDR(inode, raw_inode);
Mingming Cao617ba132006-10-11 01:20:53 -0700686 end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
Theodore Ts'o9e92f482016-03-22 16:13:15 -0400687 error = xattr_check_inode(inode, header, end);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700688 if (error)
689 goto cleanup;
Christoph Hellwig431547b2009-11-13 09:52:56 +0000690 error = ext4_xattr_list_entries(dentry, IFIRST(header),
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700691 buffer, buffer_size);
692
693cleanup:
694 brelse(iloc.bh);
695 return error;
696}
697
698/*
Eric Biggersba7ea1d2017-04-29 23:53:17 -0400699 * Inode operation listxattr()
700 *
701 * d_inode(dentry)->i_rwsem: don't care
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700702 *
703 * Copy a list of attribute names into the buffer
704 * provided, or compute the buffer size required.
705 * Buffer is NULL to compute the size of the buffer required.
706 *
707 * Returns a negative error number on failure, or the number of bytes
708 * used / required on success.
709 */
Eric Biggersba7ea1d2017-04-29 23:53:17 -0400710ssize_t
711ext4_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700712{
Theodore Ts'oeaeef862011-01-10 12:10:07 -0500713 int ret, ret2;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700714
David Howells2b0143b2015-03-17 22:25:59 +0000715 down_read(&EXT4_I(d_inode(dentry))->xattr_sem);
Theodore Ts'oeaeef862011-01-10 12:10:07 -0500716 ret = ret2 = ext4_xattr_ibody_list(dentry, buffer, buffer_size);
717 if (ret < 0)
718 goto errout;
719 if (buffer) {
720 buffer += ret;
721 buffer_size -= ret;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700722 }
Theodore Ts'oeaeef862011-01-10 12:10:07 -0500723 ret = ext4_xattr_block_list(dentry, buffer, buffer_size);
724 if (ret < 0)
725 goto errout;
726 ret += ret2;
727errout:
David Howells2b0143b2015-03-17 22:25:59 +0000728 up_read(&EXT4_I(d_inode(dentry))->xattr_sem);
Theodore Ts'oeaeef862011-01-10 12:10:07 -0500729 return ret;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700730}
731
732/*
Mingming Cao617ba132006-10-11 01:20:53 -0700733 * If the EXT4_FEATURE_COMPAT_EXT_ATTR feature of this file system is
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700734 * not set, set it.
735 */
Mingming Cao617ba132006-10-11 01:20:53 -0700736static void ext4_xattr_update_super_block(handle_t *handle,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700737 struct super_block *sb)
738{
Darrick J. Wonge2b911c2015-10-17 16:18:43 -0400739 if (ext4_has_feature_xattr(sb))
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700740 return;
741
liang xie5d601252014-05-12 22:06:43 -0400742 BUFFER_TRACE(EXT4_SB(sb)->s_sbh, "get_write_access");
Mingming Cao617ba132006-10-11 01:20:53 -0700743 if (ext4_journal_get_write_access(handle, EXT4_SB(sb)->s_sbh) == 0) {
Darrick J. Wonge2b911c2015-10-17 16:18:43 -0400744 ext4_set_feature_xattr(sb);
Theodore Ts'oa0375152010-06-11 23:14:04 -0400745 ext4_handle_dirty_super(handle, sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700746 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700747}
748
Tahsin Erdogan7a9ca532017-06-22 11:46:48 -0400749int ext4_get_inode_usage(struct inode *inode, qsize_t *usage)
750{
751 struct ext4_iloc iloc = { .bh = NULL };
752 struct buffer_head *bh = NULL;
753 struct ext4_inode *raw_inode;
754 struct ext4_xattr_ibody_header *header;
755 struct ext4_xattr_entry *entry;
756 qsize_t ea_inode_refs = 0;
757 void *end;
758 int ret;
759
760 lockdep_assert_held_read(&EXT4_I(inode)->xattr_sem);
761
762 if (ext4_test_inode_state(inode, EXT4_STATE_XATTR)) {
763 ret = ext4_get_inode_loc(inode, &iloc);
764 if (ret)
765 goto out;
766 raw_inode = ext4_raw_inode(&iloc);
767 header = IHDR(inode, raw_inode);
768 end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
769 ret = xattr_check_inode(inode, header, end);
770 if (ret)
771 goto out;
772
773 for (entry = IFIRST(header); !IS_LAST_ENTRY(entry);
774 entry = EXT4_XATTR_NEXT(entry))
775 if (entry->e_value_inum)
776 ea_inode_refs++;
777 }
778
779 if (EXT4_I(inode)->i_file_acl) {
780 bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl);
781 if (!bh) {
782 ret = -EIO;
783 goto out;
784 }
785
786 if (ext4_xattr_check_block(inode, bh)) {
787 ret = -EFSCORRUPTED;
788 goto out;
789 }
790
791 for (entry = BFIRST(bh); !IS_LAST_ENTRY(entry);
792 entry = EXT4_XATTR_NEXT(entry))
793 if (entry->e_value_inum)
794 ea_inode_refs++;
795 }
796 *usage = ea_inode_refs + 1;
797 ret = 0;
798out:
799 brelse(iloc.bh);
800 brelse(bh);
801 return ret;
802}
803
Tahsin Erdogandec214d2017-06-22 11:44:55 -0400804static inline size_t round_up_cluster(struct inode *inode, size_t length)
805{
806 struct super_block *sb = inode->i_sb;
807 size_t cluster_size = 1 << (EXT4_SB(sb)->s_cluster_bits +
808 inode->i_blkbits);
809 size_t mask = ~(cluster_size - 1);
810
811 return (length + cluster_size - 1) & mask;
812}
813
814static int ext4_xattr_inode_alloc_quota(struct inode *inode, size_t len)
815{
816 int err;
817
818 err = dquot_alloc_inode(inode);
819 if (err)
820 return err;
821 err = dquot_alloc_space_nodirty(inode, round_up_cluster(inode, len));
822 if (err)
823 dquot_free_inode(inode);
824 return err;
825}
826
827static void ext4_xattr_inode_free_quota(struct inode *inode, size_t len)
828{
829 dquot_free_space_nodirty(inode, round_up_cluster(inode, len));
830 dquot_free_inode(inode);
831}
832
Tahsin Erdoganaf652072017-07-06 00:01:59 -0400833int __ext4_xattr_set_credits(struct super_block *sb, struct inode *inode,
834 struct buffer_head *block_bh, size_t value_len,
835 bool is_create)
Tahsin Erdogandec214d2017-06-22 11:44:55 -0400836{
Tahsin Erdogandec214d2017-06-22 11:44:55 -0400837 int credits;
838 int blocks;
839
840 /*
841 * 1) Owner inode update
842 * 2) Ref count update on old xattr block
843 * 3) new xattr block
844 * 4) block bitmap update for new xattr block
845 * 5) group descriptor for new xattr block
846 * 6) block bitmap update for old xattr block
847 * 7) group descriptor for old block
848 *
849 * 6 & 7 can happen if we have two racing threads T_a and T_b
850 * which are each trying to set an xattr on inodes I_a and I_b
851 * which were both initially sharing an xattr block.
852 */
853 credits = 7;
854
855 /* Quota updates. */
856 credits += EXT4_MAXQUOTAS_TRANS_BLOCKS(sb);
857
858 /*
859 * In case of inline data, we may push out the data to a block,
860 * so we need to reserve credits for this eventuality
861 */
Tahsin Erdoganaf652072017-07-06 00:01:59 -0400862 if (inode && ext4_has_inline_data(inode))
Tahsin Erdogandec214d2017-06-22 11:44:55 -0400863 credits += ext4_writepage_trans_blocks(inode) + 1;
864
865 /* We are done if ea_inode feature is not enabled. */
866 if (!ext4_has_feature_ea_inode(sb))
867 return credits;
868
869 /* New ea_inode, inode map, block bitmap, group descriptor. */
870 credits += 4;
871
872 /* Data blocks. */
873 blocks = (value_len + sb->s_blocksize - 1) >> sb->s_blocksize_bits;
874
875 /* Indirection block or one level of extent tree. */
876 blocks += 1;
877
878 /* Block bitmap and group descriptor updates for each block. */
879 credits += blocks * 2;
880
881 /* Blocks themselves. */
882 credits += blocks;
883
Tahsin Erdoganaf652072017-07-06 00:01:59 -0400884 if (!is_create) {
885 /* Dereference ea_inode holding old xattr value.
886 * Old ea_inode, inode map, block bitmap, group descriptor.
887 */
888 credits += 4;
Tahsin Erdogandec214d2017-06-22 11:44:55 -0400889
Tahsin Erdoganaf652072017-07-06 00:01:59 -0400890 /* Data blocks for old ea_inode. */
891 blocks = XATTR_SIZE_MAX >> sb->s_blocksize_bits;
Tahsin Erdogandec214d2017-06-22 11:44:55 -0400892
Tahsin Erdoganaf652072017-07-06 00:01:59 -0400893 /* Indirection block or one level of extent tree for old
894 * ea_inode.
895 */
896 blocks += 1;
Tahsin Erdogandec214d2017-06-22 11:44:55 -0400897
Tahsin Erdoganaf652072017-07-06 00:01:59 -0400898 /* Block bitmap and group descriptor updates for each block. */
899 credits += blocks * 2;
900 }
Tahsin Erdogandec214d2017-06-22 11:44:55 -0400901
902 /* We may need to clone the existing xattr block in which case we need
903 * to increment ref counts for existing ea_inodes referenced by it.
904 */
905 if (block_bh) {
906 struct ext4_xattr_entry *entry = BFIRST(block_bh);
907
908 for (; !IS_LAST_ENTRY(entry); entry = EXT4_XATTR_NEXT(entry))
909 if (entry->e_value_inum)
910 /* Ref count update on ea_inode. */
911 credits += 1;
912 }
913 return credits;
914}
915
Tahsin Erdogan30a7eb92017-06-22 11:42:09 -0400916static int ext4_xattr_ensure_credits(handle_t *handle, struct inode *inode,
917 int credits, struct buffer_head *bh,
918 bool dirty, bool block_csum)
919{
920 int error;
921
922 if (!ext4_handle_valid(handle))
923 return 0;
924
925 if (handle->h_buffer_credits >= credits)
926 return 0;
927
928 error = ext4_journal_extend(handle, credits - handle->h_buffer_credits);
929 if (!error)
930 return 0;
931 if (error < 0) {
932 ext4_warning(inode->i_sb, "Extend journal (error %d)", error);
933 return error;
934 }
935
936 if (bh && dirty) {
937 if (block_csum)
938 ext4_xattr_block_csum_set(inode, bh);
939 error = ext4_handle_dirty_metadata(handle, NULL, bh);
940 if (error) {
941 ext4_warning(inode->i_sb, "Handle metadata (error %d)",
942 error);
943 return error;
944 }
945 }
946
947 error = ext4_journal_restart(handle, credits);
948 if (error) {
949 ext4_warning(inode->i_sb, "Restart journal (error %d)", error);
950 return error;
951 }
952
953 if (bh) {
954 error = ext4_journal_get_write_access(handle, bh);
955 if (error) {
956 ext4_warning(inode->i_sb,
957 "Get write access failed (error %d)",
958 error);
959 return error;
960 }
961 }
962 return 0;
963}
964
Tahsin Erdogandec214d2017-06-22 11:44:55 -0400965static int ext4_xattr_inode_update_ref(handle_t *handle, struct inode *ea_inode,
966 int ref_change)
967{
968 struct mb_cache *ea_inode_cache = EA_INODE_CACHE(ea_inode);
969 struct ext4_iloc iloc;
970 s64 ref_count;
971 u32 hash;
972 int ret;
973
974 inode_lock(ea_inode);
975
976 ret = ext4_reserve_inode_write(handle, ea_inode, &iloc);
977 if (ret) {
978 iloc.bh = NULL;
979 goto out;
980 }
981
982 ref_count = ext4_xattr_inode_get_ref(ea_inode);
983 ref_count += ref_change;
984 ext4_xattr_inode_set_ref(ea_inode, ref_count);
985
986 if (ref_change > 0) {
987 WARN_ONCE(ref_count <= 0, "EA inode %lu ref_count=%lld",
988 ea_inode->i_ino, ref_count);
989
990 if (ref_count == 1) {
991 WARN_ONCE(ea_inode->i_nlink, "EA inode %lu i_nlink=%u",
992 ea_inode->i_ino, ea_inode->i_nlink);
993
994 set_nlink(ea_inode, 1);
995 ext4_orphan_del(handle, ea_inode);
996
Tahsin Erdogancdb7ee42017-06-22 11:55:14 -0400997 if (ea_inode_cache) {
998 hash = ext4_xattr_inode_get_hash(ea_inode);
999 mb_cache_entry_create(ea_inode_cache,
1000 GFP_NOFS, hash,
1001 ea_inode->i_ino,
1002 true /* reusable */);
1003 }
Tahsin Erdogandec214d2017-06-22 11:44:55 -04001004 }
1005 } else {
1006 WARN_ONCE(ref_count < 0, "EA inode %lu ref_count=%lld",
1007 ea_inode->i_ino, ref_count);
1008
1009 if (ref_count == 0) {
1010 WARN_ONCE(ea_inode->i_nlink != 1,
1011 "EA inode %lu i_nlink=%u",
1012 ea_inode->i_ino, ea_inode->i_nlink);
1013
1014 clear_nlink(ea_inode);
1015 ext4_orphan_add(handle, ea_inode);
1016
Tahsin Erdogancdb7ee42017-06-22 11:55:14 -04001017 if (ea_inode_cache) {
1018 hash = ext4_xattr_inode_get_hash(ea_inode);
1019 mb_cache_entry_delete(ea_inode_cache, hash,
1020 ea_inode->i_ino);
1021 }
Tahsin Erdogandec214d2017-06-22 11:44:55 -04001022 }
1023 }
1024
1025 ret = ext4_mark_iloc_dirty(handle, ea_inode, &iloc);
1026 iloc.bh = NULL;
1027 if (ret)
1028 ext4_warning_inode(ea_inode,
1029 "ext4_mark_iloc_dirty() failed ret=%d", ret);
1030out:
1031 brelse(iloc.bh);
1032 inode_unlock(ea_inode);
1033 return ret;
1034}
1035
1036static int ext4_xattr_inode_inc_ref(handle_t *handle, struct inode *ea_inode)
1037{
1038 return ext4_xattr_inode_update_ref(handle, ea_inode, 1);
1039}
1040
1041static int ext4_xattr_inode_dec_ref(handle_t *handle, struct inode *ea_inode)
1042{
1043 return ext4_xattr_inode_update_ref(handle, ea_inode, -1);
1044}
1045
1046static int ext4_xattr_inode_inc_ref_all(handle_t *handle, struct inode *parent,
1047 struct ext4_xattr_entry *first)
1048{
1049 struct inode *ea_inode;
1050 struct ext4_xattr_entry *entry;
1051 struct ext4_xattr_entry *failed_entry;
1052 unsigned int ea_ino;
1053 int err, saved_err;
1054
1055 for (entry = first; !IS_LAST_ENTRY(entry);
1056 entry = EXT4_XATTR_NEXT(entry)) {
1057 if (!entry->e_value_inum)
1058 continue;
1059 ea_ino = le32_to_cpu(entry->e_value_inum);
1060 err = ext4_xattr_inode_iget(parent, ea_ino, &ea_inode);
1061 if (err)
1062 goto cleanup;
1063 err = ext4_xattr_inode_inc_ref(handle, ea_inode);
1064 if (err) {
1065 ext4_warning_inode(ea_inode, "inc ref error %d", err);
1066 iput(ea_inode);
1067 goto cleanup;
1068 }
1069 iput(ea_inode);
1070 }
1071 return 0;
1072
1073cleanup:
1074 saved_err = err;
1075 failed_entry = entry;
1076
1077 for (entry = first; entry != failed_entry;
1078 entry = EXT4_XATTR_NEXT(entry)) {
1079 if (!entry->e_value_inum)
1080 continue;
1081 ea_ino = le32_to_cpu(entry->e_value_inum);
1082 err = ext4_xattr_inode_iget(parent, ea_ino, &ea_inode);
1083 if (err) {
1084 ext4_warning(parent->i_sb,
1085 "cleanup ea_ino %u iget error %d", ea_ino,
1086 err);
1087 continue;
1088 }
1089 err = ext4_xattr_inode_dec_ref(handle, ea_inode);
1090 if (err)
1091 ext4_warning_inode(ea_inode, "cleanup dec ref error %d",
1092 err);
1093 iput(ea_inode);
1094 }
1095 return saved_err;
1096}
1097
Tahsin Erdogan30a7eb92017-06-22 11:42:09 -04001098static void
Tahsin Erdogandec214d2017-06-22 11:44:55 -04001099ext4_xattr_inode_dec_ref_all(handle_t *handle, struct inode *parent,
1100 struct buffer_head *bh,
1101 struct ext4_xattr_entry *first, bool block_csum,
1102 struct ext4_xattr_inode_array **ea_inode_array,
1103 int extra_credits, bool skip_quota)
Tahsin Erdogan30a7eb92017-06-22 11:42:09 -04001104{
1105 struct inode *ea_inode;
1106 struct ext4_xattr_entry *entry;
1107 bool dirty = false;
1108 unsigned int ea_ino;
1109 int err;
1110 int credits;
1111
1112 /* One credit for dec ref on ea_inode, one for orphan list addition, */
1113 credits = 2 + extra_credits;
1114
1115 for (entry = first; !IS_LAST_ENTRY(entry);
1116 entry = EXT4_XATTR_NEXT(entry)) {
1117 if (!entry->e_value_inum)
1118 continue;
1119 ea_ino = le32_to_cpu(entry->e_value_inum);
1120 err = ext4_xattr_inode_iget(parent, ea_ino, &ea_inode);
1121 if (err)
1122 continue;
1123
1124 err = ext4_expand_inode_array(ea_inode_array, ea_inode);
1125 if (err) {
1126 ext4_warning_inode(ea_inode,
1127 "Expand inode array err=%d", err);
1128 iput(ea_inode);
1129 continue;
1130 }
1131
1132 err = ext4_xattr_ensure_credits(handle, parent, credits, bh,
1133 dirty, block_csum);
1134 if (err) {
1135 ext4_warning_inode(ea_inode, "Ensure credits err=%d",
1136 err);
1137 continue;
1138 }
1139
Tahsin Erdogandec214d2017-06-22 11:44:55 -04001140 err = ext4_xattr_inode_dec_ref(handle, ea_inode);
1141 if (err) {
1142 ext4_warning_inode(ea_inode, "ea_inode dec ref err=%d",
1143 err);
1144 continue;
1145 }
1146
1147 if (!skip_quota)
1148 ext4_xattr_inode_free_quota(parent,
1149 le32_to_cpu(entry->e_value_size));
Tahsin Erdogan30a7eb92017-06-22 11:42:09 -04001150
1151 /*
1152 * Forget about ea_inode within the same transaction that
1153 * decrements the ref count. This avoids duplicate decrements in
1154 * case the rest of the work spills over to subsequent
1155 * transactions.
1156 */
1157 entry->e_value_inum = 0;
1158 entry->e_value_size = 0;
1159
1160 dirty = true;
1161 }
1162
1163 if (dirty) {
1164 /*
1165 * Note that we are deliberately skipping csum calculation for
1166 * the final update because we do not expect any journal
1167 * restarts until xattr block is freed.
1168 */
1169
1170 err = ext4_handle_dirty_metadata(handle, NULL, bh);
1171 if (err)
1172 ext4_warning_inode(parent,
1173 "handle dirty metadata err=%d", err);
1174 }
1175}
1176
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001177/*
Jan Karaec4cb1a2014-04-07 10:54:21 -04001178 * Release the xattr block BH: If the reference count is > 1, decrement it;
1179 * otherwise free the block.
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001180 */
1181static void
Mingming Cao617ba132006-10-11 01:20:53 -07001182ext4_xattr_release_block(handle_t *handle, struct inode *inode,
Tahsin Erdogandec214d2017-06-22 11:44:55 -04001183 struct buffer_head *bh,
1184 struct ext4_xattr_inode_array **ea_inode_array,
1185 int extra_credits)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001186{
Tahsin Erdogan47387402017-06-22 11:28:55 -04001187 struct mb_cache *ea_block_cache = EA_BLOCK_CACHE(inode);
Andreas Gruenbacher6048c642016-02-22 22:44:04 -05001188 u32 hash, ref;
Mingming Cao8a2bfdc2007-02-28 20:13:35 -08001189 int error = 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001190
liang xie5d601252014-05-12 22:06:43 -04001191 BUFFER_TRACE(bh, "get_write_access");
Mingming Cao8a2bfdc2007-02-28 20:13:35 -08001192 error = ext4_journal_get_write_access(handle, bh);
1193 if (error)
1194 goto out;
1195
1196 lock_buffer(bh);
Andreas Gruenbacher6048c642016-02-22 22:44:04 -05001197 hash = le32_to_cpu(BHDR(bh)->h_hash);
1198 ref = le32_to_cpu(BHDR(bh)->h_refcount);
1199 if (ref == 1) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001200 ea_bdebug(bh, "refcount now=0; freeing");
Jan Kara82939d72016-02-22 11:50:13 -05001201 /*
1202 * This must happen under buffer lock for
1203 * ext4_xattr_block_set() to reliably detect freed block
1204 */
Tahsin Erdogancdb7ee42017-06-22 11:55:14 -04001205 if (ea_block_cache)
1206 mb_cache_entry_delete(ea_block_cache, hash,
1207 bh->b_blocknr);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001208 get_bh(bh);
Jan Karaec4cb1a2014-04-07 10:54:21 -04001209 unlock_buffer(bh);
Tahsin Erdogandec214d2017-06-22 11:44:55 -04001210
1211 if (ext4_has_feature_ea_inode(inode->i_sb))
1212 ext4_xattr_inode_dec_ref_all(handle, inode, bh,
1213 BFIRST(bh),
1214 true /* block_csum */,
1215 ea_inode_array,
1216 extra_credits,
1217 true /* skip_quota */);
Theodore Ts'oe6362602009-11-23 07:17:05 -05001218 ext4_free_blocks(handle, inode, bh, 0, 1,
1219 EXT4_FREE_BLOCKS_METADATA |
1220 EXT4_FREE_BLOCKS_FORGET);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001221 } else {
Andreas Gruenbacher6048c642016-02-22 22:44:04 -05001222 ref--;
1223 BHDR(bh)->h_refcount = cpu_to_le32(ref);
1224 if (ref == EXT4_XATTR_REFCOUNT_MAX - 1) {
1225 struct mb_cache_entry *ce;
1226
Tahsin Erdogancdb7ee42017-06-22 11:55:14 -04001227 if (ea_block_cache) {
1228 ce = mb_cache_entry_get(ea_block_cache, hash,
1229 bh->b_blocknr);
1230 if (ce) {
1231 ce->e_reusable = 1;
1232 mb_cache_entry_put(ea_block_cache, ce);
1233 }
Andreas Gruenbacher6048c642016-02-22 22:44:04 -05001234 }
1235 }
1236
Theodore Ts'odac7a4b2017-03-25 17:22:47 -04001237 ext4_xattr_block_csum_set(inode, bh);
Jan Karaec4cb1a2014-04-07 10:54:21 -04001238 /*
1239 * Beware of this ugliness: Releasing of xattr block references
1240 * from different inodes can race and so we have to protect
1241 * from a race where someone else frees the block (and releases
1242 * its journal_head) before we are done dirtying the buffer. In
1243 * nojournal mode this race is harmless and we actually cannot
Theodore Ts'odac7a4b2017-03-25 17:22:47 -04001244 * call ext4_handle_dirty_metadata() with locked buffer as
Jan Karaec4cb1a2014-04-07 10:54:21 -04001245 * that function can call sync_dirty_buffer() so for that case
1246 * we handle the dirtying after unlocking the buffer.
1247 */
1248 if (ext4_handle_valid(handle))
Theodore Ts'odac7a4b2017-03-25 17:22:47 -04001249 error = ext4_handle_dirty_metadata(handle, inode, bh);
Eric Sandeenc1bb05a2012-02-20 23:06:18 -05001250 unlock_buffer(bh);
Jan Karaec4cb1a2014-04-07 10:54:21 -04001251 if (!ext4_handle_valid(handle))
Theodore Ts'odac7a4b2017-03-25 17:22:47 -04001252 error = ext4_handle_dirty_metadata(handle, inode, bh);
Mingming Cao8a2bfdc2007-02-28 20:13:35 -08001253 if (IS_SYNC(inode))
Frank Mayhar03901312009-01-07 00:06:22 -05001254 ext4_handle_sync(handle);
Lukas Czerner1231b3a2013-02-18 12:12:07 -05001255 dquot_free_block(inode, EXT4_C2B(EXT4_SB(inode->i_sb), 1));
Mingming Cao8a2bfdc2007-02-28 20:13:35 -08001256 ea_bdebug(bh, "refcount now=%d; releasing",
1257 le32_to_cpu(BHDR(bh)->h_refcount));
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001258 }
Mingming Cao8a2bfdc2007-02-28 20:13:35 -08001259out:
1260 ext4_std_error(inode->i_sb, error);
1261 return;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001262}
1263
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04001264/*
1265 * Find the available free space for EAs. This also returns the total number of
1266 * bytes used by EA entries.
1267 */
1268static size_t ext4_xattr_free_space(struct ext4_xattr_entry *last,
1269 size_t *min_offs, void *base, int *total)
1270{
1271 for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
Andreas Dilgere50e5122017-06-21 21:10:32 -04001272 if (!last->e_value_inum && last->e_value_size) {
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04001273 size_t offs = le16_to_cpu(last->e_value_offs);
1274 if (offs < *min_offs)
1275 *min_offs = offs;
1276 }
Theodore Ts'o7b1b2c12014-02-19 20:15:21 -05001277 if (total)
1278 *total += EXT4_XATTR_LEN(last->e_name_len);
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04001279 }
1280 return (*min_offs - ((void *)last - base) - sizeof(__u32));
1281}
1282
Andreas Dilgere50e5122017-06-21 21:10:32 -04001283/*
1284 * Write the value of the EA in an inode.
1285 */
1286static int ext4_xattr_inode_write(handle_t *handle, struct inode *ea_inode,
1287 const void *buf, int bufsize)
1288{
1289 struct buffer_head *bh = NULL;
1290 unsigned long block = 0;
Tahsin Erdogandec214d2017-06-22 11:44:55 -04001291 int blocksize = ea_inode->i_sb->s_blocksize;
1292 int max_blocks = (bufsize + blocksize - 1) >> ea_inode->i_blkbits;
Andreas Dilgere50e5122017-06-21 21:10:32 -04001293 int csize, wsize = 0;
1294 int ret = 0;
1295 int retries = 0;
1296
1297retry:
1298 while (ret >= 0 && ret < max_blocks) {
1299 struct ext4_map_blocks map;
1300 map.m_lblk = block += ret;
1301 map.m_len = max_blocks -= ret;
1302
1303 ret = ext4_map_blocks(handle, ea_inode, &map,
1304 EXT4_GET_BLOCKS_CREATE);
1305 if (ret <= 0) {
1306 ext4_mark_inode_dirty(handle, ea_inode);
1307 if (ret == -ENOSPC &&
1308 ext4_should_retry_alloc(ea_inode->i_sb, &retries)) {
1309 ret = 0;
1310 goto retry;
1311 }
1312 break;
1313 }
1314 }
1315
1316 if (ret < 0)
1317 return ret;
1318
1319 block = 0;
1320 while (wsize < bufsize) {
1321 if (bh != NULL)
1322 brelse(bh);
1323 csize = (bufsize - wsize) > blocksize ? blocksize :
1324 bufsize - wsize;
1325 bh = ext4_getblk(handle, ea_inode, block, 0);
1326 if (IS_ERR(bh))
1327 return PTR_ERR(bh);
1328 ret = ext4_journal_get_write_access(handle, bh);
1329 if (ret)
1330 goto out;
1331
1332 memcpy(bh->b_data, buf, csize);
1333 set_buffer_uptodate(bh);
1334 ext4_handle_dirty_metadata(handle, ea_inode, bh);
1335
1336 buf += csize;
1337 wsize += csize;
1338 block += 1;
1339 }
1340
1341 inode_lock(ea_inode);
1342 i_size_write(ea_inode, wsize);
1343 ext4_update_i_disksize(ea_inode, wsize);
1344 inode_unlock(ea_inode);
1345
1346 ext4_mark_inode_dirty(handle, ea_inode);
1347
1348out:
1349 brelse(bh);
1350
1351 return ret;
1352}
1353
1354/*
1355 * Create an inode to store the value of a large EA.
1356 */
1357static struct inode *ext4_xattr_inode_create(handle_t *handle,
Tahsin Erdogandec214d2017-06-22 11:44:55 -04001358 struct inode *inode, u32 hash)
Andreas Dilgere50e5122017-06-21 21:10:32 -04001359{
1360 struct inode *ea_inode = NULL;
Tahsin Erdogan9e1ba002017-06-21 21:27:00 -04001361 uid_t owner[2] = { i_uid_read(inode), i_gid_read(inode) };
Tahsin Erdoganbd3b9632017-06-21 21:24:31 -04001362 int err;
Andreas Dilgere50e5122017-06-21 21:10:32 -04001363
1364 /*
1365 * Let the next inode be the goal, so we try and allocate the EA inode
1366 * in the same group, or nearby one.
1367 */
1368 ea_inode = ext4_new_inode(handle, inode->i_sb->s_root->d_inode,
Tahsin Erdogan9e1ba002017-06-21 21:27:00 -04001369 S_IFREG | 0600, NULL, inode->i_ino + 1, owner,
Tahsin Erdogan1b917ed2017-06-21 21:21:39 -04001370 EXT4_EA_INODE_FL);
Andreas Dilgere50e5122017-06-21 21:10:32 -04001371 if (!IS_ERR(ea_inode)) {
1372 ea_inode->i_op = &ext4_file_inode_operations;
1373 ea_inode->i_fop = &ext4_file_operations;
1374 ext4_set_aops(ea_inode);
Tahsin Erdogan33d201e2017-06-21 21:17:10 -04001375 ext4_xattr_inode_set_class(ea_inode);
Andreas Dilgere50e5122017-06-21 21:10:32 -04001376 unlock_new_inode(ea_inode);
Tahsin Erdogandec214d2017-06-22 11:44:55 -04001377 ext4_xattr_inode_set_ref(ea_inode, 1);
1378 ext4_xattr_inode_set_hash(ea_inode, hash);
1379 err = ext4_mark_inode_dirty(handle, ea_inode);
1380 if (!err)
1381 err = ext4_inode_attach_jinode(ea_inode);
Tahsin Erdoganbd3b9632017-06-21 21:24:31 -04001382 if (err) {
1383 iput(ea_inode);
1384 return ERR_PTR(err);
1385 }
Tahsin Erdogandec214d2017-06-22 11:44:55 -04001386
1387 /*
1388 * Xattr inodes are shared therefore quota charging is performed
1389 * at a higher level.
1390 */
1391 dquot_free_inode(ea_inode);
1392 dquot_drop(ea_inode);
1393 inode_lock(ea_inode);
1394 ea_inode->i_flags |= S_NOQUOTA;
1395 inode_unlock(ea_inode);
Andreas Dilgere50e5122017-06-21 21:10:32 -04001396 }
1397
1398 return ea_inode;
1399}
1400
Tahsin Erdogandec214d2017-06-22 11:44:55 -04001401static struct inode *
1402ext4_xattr_inode_cache_find(struct inode *inode, const void *value,
1403 size_t value_len, u32 hash)
Andreas Dilgere50e5122017-06-21 21:10:32 -04001404{
Tahsin Erdogandec214d2017-06-22 11:44:55 -04001405 struct inode *ea_inode;
1406 struct mb_cache_entry *ce;
1407 struct mb_cache *ea_inode_cache = EA_INODE_CACHE(inode);
1408 void *ea_data;
Andreas Dilgere50e5122017-06-21 21:10:32 -04001409
Tahsin Erdogancdb7ee42017-06-22 11:55:14 -04001410 if (!ea_inode_cache)
1411 return NULL;
1412
Tahsin Erdogandec214d2017-06-22 11:44:55 -04001413 ce = mb_cache_entry_find_first(ea_inode_cache, hash);
1414 if (!ce)
1415 return NULL;
Andreas Dilgere50e5122017-06-21 21:10:32 -04001416
Tahsin Erdogandec214d2017-06-22 11:44:55 -04001417 ea_data = ext4_kvmalloc(value_len, GFP_NOFS);
1418 if (!ea_data) {
1419 mb_cache_entry_put(ea_inode_cache, ce);
1420 return NULL;
1421 }
Andreas Dilgere50e5122017-06-21 21:10:32 -04001422
Tahsin Erdogandec214d2017-06-22 11:44:55 -04001423 while (ce) {
1424 ea_inode = ext4_iget(inode->i_sb, ce->e_value);
1425 if (!IS_ERR(ea_inode) &&
1426 !is_bad_inode(ea_inode) &&
1427 (EXT4_I(ea_inode)->i_flags & EXT4_EA_INODE_FL) &&
1428 i_size_read(ea_inode) == value_len &&
1429 !ext4_xattr_inode_read(ea_inode, ea_data, value_len) &&
Tahsin Erdoganb9fc7612017-06-22 11:53:15 -04001430 !ext4_xattr_inode_verify_hashes(ea_inode, NULL, ea_data,
1431 value_len) &&
Tahsin Erdogandec214d2017-06-22 11:44:55 -04001432 !memcmp(value, ea_data, value_len)) {
1433 mb_cache_entry_touch(ea_inode_cache, ce);
1434 mb_cache_entry_put(ea_inode_cache, ce);
1435 kvfree(ea_data);
1436 return ea_inode;
1437 }
1438
1439 if (!IS_ERR(ea_inode))
1440 iput(ea_inode);
1441 ce = mb_cache_entry_find_next(ea_inode_cache, ce);
1442 }
1443 kvfree(ea_data);
1444 return NULL;
Andreas Dilgere50e5122017-06-21 21:10:32 -04001445}
1446
1447/*
1448 * Add value of the EA in an inode.
1449 */
Tahsin Erdogandec214d2017-06-22 11:44:55 -04001450static int ext4_xattr_inode_lookup_create(handle_t *handle, struct inode *inode,
1451 const void *value, size_t value_len,
1452 struct inode **ret_inode)
Andreas Dilgere50e5122017-06-21 21:10:32 -04001453{
1454 struct inode *ea_inode;
Tahsin Erdogandec214d2017-06-22 11:44:55 -04001455 u32 hash;
Andreas Dilgere50e5122017-06-21 21:10:32 -04001456 int err;
1457
Tahsin Erdogandec214d2017-06-22 11:44:55 -04001458 hash = ext4_xattr_inode_hash(EXT4_SB(inode->i_sb), value, value_len);
1459 ea_inode = ext4_xattr_inode_cache_find(inode, value, value_len, hash);
1460 if (ea_inode) {
1461 err = ext4_xattr_inode_inc_ref(handle, ea_inode);
1462 if (err) {
1463 iput(ea_inode);
1464 return err;
1465 }
1466
1467 *ret_inode = ea_inode;
1468 return 0;
1469 }
1470
Andreas Dilgere50e5122017-06-21 21:10:32 -04001471 /* Create an inode for the EA value */
Tahsin Erdogandec214d2017-06-22 11:44:55 -04001472 ea_inode = ext4_xattr_inode_create(handle, inode, hash);
Andreas Dilgere50e5122017-06-21 21:10:32 -04001473 if (IS_ERR(ea_inode))
1474 return PTR_ERR(ea_inode);
1475
1476 err = ext4_xattr_inode_write(handle, ea_inode, value, value_len);
Tahsin Erdogandec214d2017-06-22 11:44:55 -04001477 if (err) {
1478 ext4_xattr_inode_dec_ref(handle, ea_inode);
1479 iput(ea_inode);
1480 return err;
1481 }
Andreas Dilgere50e5122017-06-21 21:10:32 -04001482
Tahsin Erdogancdb7ee42017-06-22 11:55:14 -04001483 if (EA_INODE_CACHE(inode))
1484 mb_cache_entry_create(EA_INODE_CACHE(inode), GFP_NOFS, hash,
1485 ea_inode->i_ino, true /* reusable */);
Andreas Dilgere50e5122017-06-21 21:10:32 -04001486
Tahsin Erdogandec214d2017-06-22 11:44:55 -04001487 *ret_inode = ea_inode;
1488 return 0;
Andreas Dilgere50e5122017-06-21 21:10:32 -04001489}
1490
Tahsin Erdogan9c6e7852017-06-22 11:48:53 -04001491/*
1492 * Reserve min(block_size/8, 1024) bytes for xattr entries/names if ea_inode
1493 * feature is enabled.
1494 */
1495#define EXT4_XATTR_BLOCK_RESERVE(inode) min(i_blocksize(inode)/8, 1024U)
1496
Andreas Dilgere50e5122017-06-21 21:10:32 -04001497static int ext4_xattr_set_entry(struct ext4_xattr_info *i,
1498 struct ext4_xattr_search *s,
Tahsin Erdogandaf83282017-06-22 11:52:03 -04001499 handle_t *handle, struct inode *inode,
1500 bool is_block)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001501{
Mingming Cao617ba132006-10-11 01:20:53 -07001502 struct ext4_xattr_entry *last;
Tahsin Erdogandec214d2017-06-22 11:44:55 -04001503 struct ext4_xattr_entry *here = s->here;
1504 size_t min_offs = s->end - s->base, name_len = strlen(i->name);
Andreas Dilgere50e5122017-06-21 21:10:32 -04001505 int in_inode = i->in_inode;
Tahsin Erdogandec214d2017-06-22 11:44:55 -04001506 struct inode *old_ea_inode = NULL;
1507 struct inode *new_ea_inode = NULL;
1508 size_t old_size, new_size;
1509 int ret;
1510
1511 /* Space used by old and new values. */
1512 old_size = (!s->not_found && !here->e_value_inum) ?
1513 EXT4_XATTR_SIZE(le32_to_cpu(here->e_value_size)) : 0;
1514 new_size = (i->value && !in_inode) ? EXT4_XATTR_SIZE(i->value_len) : 0;
1515
1516 /*
1517 * Optimization for the simple case when old and new values have the
1518 * same padded sizes. Not applicable if external inodes are involved.
1519 */
1520 if (new_size && new_size == old_size) {
1521 size_t offs = le16_to_cpu(here->e_value_offs);
1522 void *val = s->base + offs;
1523
1524 here->e_value_size = cpu_to_le32(i->value_len);
1525 if (i->value == EXT4_ZERO_XATTR_VALUE) {
1526 memset(val, 0, new_size);
1527 } else {
1528 memcpy(val, i->value, i->value_len);
1529 /* Clear padding bytes. */
1530 memset(val + i->value_len, 0, new_size - i->value_len);
1531 }
1532 return 0;
1533 }
Andreas Dilgere50e5122017-06-21 21:10:32 -04001534
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001535 /* Compute min_offs and last. */
1536 last = s->first;
Mingming Cao617ba132006-10-11 01:20:53 -07001537 for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
Andreas Dilgere50e5122017-06-21 21:10:32 -04001538 if (!last->e_value_inum && last->e_value_size) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001539 size_t offs = le16_to_cpu(last->e_value_offs);
1540 if (offs < min_offs)
1541 min_offs = offs;
1542 }
1543 }
Tahsin Erdogandec214d2017-06-22 11:44:55 -04001544
1545 /* Check whether we have enough space. */
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001546 if (i->value) {
Tahsin Erdogandec214d2017-06-22 11:44:55 -04001547 size_t free;
Andreas Dilgere50e5122017-06-21 21:10:32 -04001548
Tahsin Erdogandec214d2017-06-22 11:44:55 -04001549 free = min_offs - ((void *)last - s->base) - sizeof(__u32);
1550 if (!s->not_found)
1551 free += EXT4_XATTR_LEN(name_len) + old_size;
Andreas Dilgere50e5122017-06-21 21:10:32 -04001552
Tahsin Erdogandec214d2017-06-22 11:44:55 -04001553 if (free < EXT4_XATTR_LEN(name_len) + new_size) {
1554 ret = -ENOSPC;
1555 goto out;
1556 }
Tahsin Erdogan9c6e7852017-06-22 11:48:53 -04001557
1558 /*
1559 * If storing the value in an external inode is an option,
1560 * reserve space for xattr entries/names in the external
1561 * attribute block so that a long value does not occupy the
1562 * whole space and prevent futher entries being added.
1563 */
Tahsin Erdogandaf83282017-06-22 11:52:03 -04001564 if (ext4_has_feature_ea_inode(inode->i_sb) &&
1565 new_size && is_block &&
Tahsin Erdogan9c6e7852017-06-22 11:48:53 -04001566 (min_offs + old_size - new_size) <
1567 EXT4_XATTR_BLOCK_RESERVE(inode)) {
1568 ret = -ENOSPC;
1569 goto out;
1570 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001571 }
1572
Tahsin Erdogandec214d2017-06-22 11:44:55 -04001573 /*
1574 * Getting access to old and new ea inodes is subject to failures.
1575 * Finish that work before doing any modifications to the xattr data.
1576 */
1577 if (!s->not_found && here->e_value_inum) {
1578 ret = ext4_xattr_inode_iget(inode,
1579 le32_to_cpu(here->e_value_inum),
1580 &old_ea_inode);
1581 if (ret) {
1582 old_ea_inode = NULL;
1583 goto out;
1584 }
1585 }
1586 if (i->value && in_inode) {
1587 WARN_ON_ONCE(!i->value_len);
1588
1589 ret = ext4_xattr_inode_alloc_quota(inode, i->value_len);
1590 if (ret)
1591 goto out;
1592
1593 ret = ext4_xattr_inode_lookup_create(handle, inode, i->value,
1594 i->value_len,
1595 &new_ea_inode);
1596 if (ret) {
1597 new_ea_inode = NULL;
1598 ext4_xattr_inode_free_quota(inode, i->value_len);
1599 goto out;
1600 }
1601 }
1602
1603 if (old_ea_inode) {
1604 /* We are ready to release ref count on the old_ea_inode. */
1605 ret = ext4_xattr_inode_dec_ref(handle, old_ea_inode);
1606 if (ret) {
1607 /* Release newly required ref count on new_ea_inode. */
1608 if (new_ea_inode) {
1609 int err;
1610
1611 err = ext4_xattr_inode_dec_ref(handle,
1612 new_ea_inode);
1613 if (err)
1614 ext4_warning_inode(new_ea_inode,
1615 "dec ref new_ea_inode err=%d",
1616 err);
1617 ext4_xattr_inode_free_quota(inode,
1618 i->value_len);
1619 }
1620 goto out;
1621 }
1622
1623 ext4_xattr_inode_free_quota(inode,
1624 le32_to_cpu(here->e_value_size));
1625 }
1626
1627 /* No failures allowed past this point. */
1628
1629 if (!s->not_found && here->e_value_offs) {
1630 /* Remove the old value. */
1631 void *first_val = s->base + min_offs;
1632 size_t offs = le16_to_cpu(here->e_value_offs);
1633 void *val = s->base + offs;
1634
1635 memmove(first_val + old_size, first_val, val - first_val);
1636 memset(first_val, 0, old_size);
1637 min_offs += old_size;
1638
1639 /* Adjust all value offsets. */
1640 last = s->first;
1641 while (!IS_LAST_ENTRY(last)) {
1642 size_t o = le16_to_cpu(last->e_value_offs);
1643
1644 if (!last->e_value_inum &&
1645 last->e_value_size && o < offs)
1646 last->e_value_offs = cpu_to_le16(o + old_size);
1647 last = EXT4_XATTR_NEXT(last);
1648 }
1649 }
1650
1651 if (!i->value) {
1652 /* Remove old name. */
Mingming Cao617ba132006-10-11 01:20:53 -07001653 size_t size = EXT4_XATTR_LEN(name_len);
Tahsin Erdogandec214d2017-06-22 11:44:55 -04001654
1655 last = ENTRY((void *)last - size);
1656 memmove(here, (void *)here + size,
1657 (void *)last - (void *)here + sizeof(__u32));
1658 memset(last, 0, size);
1659 } else if (s->not_found) {
1660 /* Insert new name. */
1661 size_t size = EXT4_XATTR_LEN(name_len);
1662 size_t rest = (void *)last - (void *)here + sizeof(__u32);
1663
1664 memmove((void *)here + size, here, rest);
1665 memset(here, 0, size);
1666 here->e_name_index = i->name_index;
1667 here->e_name_len = name_len;
1668 memcpy(here->e_name, i->name, name_len);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001669 } else {
Tahsin Erdogandec214d2017-06-22 11:44:55 -04001670 /* This is an update, reset value info. */
1671 here->e_value_inum = 0;
1672 here->e_value_offs = 0;
1673 here->e_value_size = 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001674 }
1675
1676 if (i->value) {
Tahsin Erdogandec214d2017-06-22 11:44:55 -04001677 /* Insert new value. */
Andreas Dilgere50e5122017-06-21 21:10:32 -04001678 if (in_inode) {
Tahsin Erdogandec214d2017-06-22 11:44:55 -04001679 here->e_value_inum = cpu_to_le32(new_ea_inode->i_ino);
Andreas Dilgere50e5122017-06-21 21:10:32 -04001680 } else if (i->value_len) {
Tahsin Erdogandec214d2017-06-22 11:44:55 -04001681 void *val = s->base + min_offs - new_size;
1682
1683 here->e_value_offs = cpu_to_le16(min_offs - new_size);
Theodore Ts'obd9926e2012-12-11 03:31:49 -05001684 if (i->value == EXT4_ZERO_XATTR_VALUE) {
Tahsin Erdogandec214d2017-06-22 11:44:55 -04001685 memset(val, 0, new_size);
Theodore Ts'obd9926e2012-12-11 03:31:49 -05001686 } else {
Theodore Ts'obd9926e2012-12-11 03:31:49 -05001687 memcpy(val, i->value, i->value_len);
Tahsin Erdogandec214d2017-06-22 11:44:55 -04001688 /* Clear padding bytes. */
1689 memset(val + i->value_len, 0,
1690 new_size - i->value_len);
Theodore Ts'obd9926e2012-12-11 03:31:49 -05001691 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001692 }
Tahsin Erdogandec214d2017-06-22 11:44:55 -04001693 here->e_value_size = cpu_to_le32(i->value_len);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001694 }
Tahsin Erdogandaf83282017-06-22 11:52:03 -04001695
Tahsin Erdoganb9fc7612017-06-22 11:53:15 -04001696 if (i->value) {
1697 __le32 hash = 0;
1698
1699 /* Entry hash calculation. */
1700 if (in_inode) {
1701 __le32 crc32c_hash;
1702
1703 /*
1704 * Feed crc32c hash instead of the raw value for entry
1705 * hash calculation. This is to avoid walking
1706 * potentially long value buffer again.
1707 */
1708 crc32c_hash = cpu_to_le32(
1709 ext4_xattr_inode_get_hash(new_ea_inode));
1710 hash = ext4_xattr_hash_entry(here->e_name,
1711 here->e_name_len,
1712 &crc32c_hash, 1);
1713 } else if (is_block) {
1714 __le32 *value = s->base + min_offs - new_size;
1715
1716 hash = ext4_xattr_hash_entry(here->e_name,
1717 here->e_name_len, value,
1718 new_size >> 2);
1719 }
1720 here->e_hash = hash;
Tahsin Erdogandaf83282017-06-22 11:52:03 -04001721 }
1722
Tahsin Erdoganb9fc7612017-06-22 11:53:15 -04001723 if (is_block)
1724 ext4_xattr_rehash((struct ext4_xattr_header *)s->base);
1725
Tahsin Erdogandec214d2017-06-22 11:44:55 -04001726 ret = 0;
Andreas Dilgere50e5122017-06-21 21:10:32 -04001727out:
Tahsin Erdogandec214d2017-06-22 11:44:55 -04001728 iput(old_ea_inode);
1729 iput(new_ea_inode);
1730 return ret;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001731}
1732
Mingming Cao617ba132006-10-11 01:20:53 -07001733struct ext4_xattr_block_find {
1734 struct ext4_xattr_search s;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001735 struct buffer_head *bh;
1736};
1737
1738static int
Mingming Cao617ba132006-10-11 01:20:53 -07001739ext4_xattr_block_find(struct inode *inode, struct ext4_xattr_info *i,
1740 struct ext4_xattr_block_find *bs)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001741{
1742 struct super_block *sb = inode->i_sb;
1743 int error;
1744
1745 ea_idebug(inode, "name=%d.%s, value=%p, value_len=%ld",
1746 i->name_index, i->name, i->value, (long)i->value_len);
1747
Mingming Cao617ba132006-10-11 01:20:53 -07001748 if (EXT4_I(inode)->i_file_acl) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001749 /* The inode already has an extended attribute block. */
Mingming Cao617ba132006-10-11 01:20:53 -07001750 bs->bh = sb_bread(sb, EXT4_I(inode)->i_file_acl);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001751 error = -EIO;
1752 if (!bs->bh)
1753 goto cleanup;
1754 ea_bdebug(bs->bh, "b_count=%d, refcount=%d",
1755 atomic_read(&(bs->bh->b_count)),
1756 le32_to_cpu(BHDR(bs->bh)->h_refcount));
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -04001757 if (ext4_xattr_check_block(inode, bs->bh)) {
Theodore Ts'o24676da2010-05-16 21:00:00 -04001758 EXT4_ERROR_INODE(inode, "bad block %llu",
1759 EXT4_I(inode)->i_file_acl);
Darrick J. Wong6a797d22015-10-17 16:16:04 -04001760 error = -EFSCORRUPTED;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001761 goto cleanup;
1762 }
1763 /* Find the named attribute. */
1764 bs->s.base = BHDR(bs->bh);
1765 bs->s.first = BFIRST(bs->bh);
1766 bs->s.end = bs->bh->b_data + bs->bh->b_size;
1767 bs->s.here = bs->s.first;
Mingming Cao617ba132006-10-11 01:20:53 -07001768 error = ext4_xattr_find_entry(&bs->s.here, i->name_index,
Eric Biggers6ba644b2017-04-30 00:01:02 -04001769 i->name, 1);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001770 if (error && error != -ENODATA)
1771 goto cleanup;
1772 bs->s.not_found = error;
1773 }
1774 error = 0;
1775
1776cleanup:
1777 return error;
1778}
1779
1780static int
Mingming Cao617ba132006-10-11 01:20:53 -07001781ext4_xattr_block_set(handle_t *handle, struct inode *inode,
1782 struct ext4_xattr_info *i,
1783 struct ext4_xattr_block_find *bs)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001784{
1785 struct super_block *sb = inode->i_sb;
1786 struct buffer_head *new_bh = NULL;
Tahsin Erdoganb347e2b2017-06-21 22:20:32 -04001787 struct ext4_xattr_search s_copy = bs->s;
1788 struct ext4_xattr_search *s = &s_copy;
Jan Kara7a2508e2016-02-22 22:35:22 -05001789 struct mb_cache_entry *ce = NULL;
Mingming Cao8a2bfdc2007-02-28 20:13:35 -08001790 int error = 0;
Tahsin Erdogan47387402017-06-22 11:28:55 -04001791 struct mb_cache *ea_block_cache = EA_BLOCK_CACHE(inode);
Tahsin Erdogandec214d2017-06-22 11:44:55 -04001792 struct inode *ea_inode = NULL;
1793 size_t old_ea_inode_size = 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001794
Mingming Cao617ba132006-10-11 01:20:53 -07001795#define header(x) ((struct ext4_xattr_header *)(x))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001796
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001797 if (s->base) {
liang xie5d601252014-05-12 22:06:43 -04001798 BUFFER_TRACE(bs->bh, "get_write_access");
Mingming Cao8a2bfdc2007-02-28 20:13:35 -08001799 error = ext4_journal_get_write_access(handle, bs->bh);
1800 if (error)
1801 goto cleanup;
1802 lock_buffer(bs->bh);
1803
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001804 if (header(s->base)->h_refcount == cpu_to_le32(1)) {
Jan Kara82939d72016-02-22 11:50:13 -05001805 __u32 hash = le32_to_cpu(BHDR(bs->bh)->h_hash);
1806
1807 /*
1808 * This must happen under buffer lock for
1809 * ext4_xattr_block_set() to reliably detect modified
1810 * block
1811 */
Tahsin Erdogancdb7ee42017-06-22 11:55:14 -04001812 if (ea_block_cache)
1813 mb_cache_entry_delete(ea_block_cache, hash,
1814 bs->bh->b_blocknr);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001815 ea_bdebug(bs->bh, "modifying in-place");
Tahsin Erdogandaf83282017-06-22 11:52:03 -04001816 error = ext4_xattr_set_entry(i, s, handle, inode,
1817 true /* is_block */);
1818 if (!error)
Tahsin Erdogan47387402017-06-22 11:28:55 -04001819 ext4_xattr_block_cache_insert(ea_block_cache,
1820 bs->bh);
Theodore Ts'odac7a4b2017-03-25 17:22:47 -04001821 ext4_xattr_block_csum_set(inode, bs->bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001822 unlock_buffer(bs->bh);
Darrick J. Wong6a797d22015-10-17 16:16:04 -04001823 if (error == -EFSCORRUPTED)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001824 goto bad_block;
1825 if (!error)
Theodore Ts'odac7a4b2017-03-25 17:22:47 -04001826 error = ext4_handle_dirty_metadata(handle,
1827 inode,
1828 bs->bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001829 if (error)
1830 goto cleanup;
1831 goto inserted;
1832 } else {
1833 int offset = (char *)s->here - bs->bh->b_data;
1834
Mingming Cao8a2bfdc2007-02-28 20:13:35 -08001835 unlock_buffer(bs->bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001836 ea_bdebug(bs->bh, "cloning");
Josef Bacik216553c2008-04-29 22:02:02 -04001837 s->base = kmalloc(bs->bh->b_size, GFP_NOFS);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001838 error = -ENOMEM;
1839 if (s->base == NULL)
1840 goto cleanup;
1841 memcpy(s->base, BHDR(bs->bh), bs->bh->b_size);
1842 s->first = ENTRY(header(s->base)+1);
1843 header(s->base)->h_refcount = cpu_to_le32(1);
1844 s->here = ENTRY(s->base + offset);
1845 s->end = s->base + bs->bh->b_size;
Tahsin Erdogandec214d2017-06-22 11:44:55 -04001846
1847 /*
1848 * If existing entry points to an xattr inode, we need
1849 * to prevent ext4_xattr_set_entry() from decrementing
1850 * ref count on it because the reference belongs to the
1851 * original block. In this case, make the entry look
1852 * like it has an empty value.
1853 */
1854 if (!s->not_found && s->here->e_value_inum) {
1855 /*
1856 * Defer quota free call for previous inode
1857 * until success is guaranteed.
1858 */
1859 old_ea_inode_size = le32_to_cpu(
1860 s->here->e_value_size);
1861 s->here->e_value_inum = 0;
1862 s->here->e_value_size = 0;
1863 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001864 }
1865 } else {
1866 /* Allocate a buffer where we construct the new block. */
Josef Bacik216553c2008-04-29 22:02:02 -04001867 s->base = kzalloc(sb->s_blocksize, GFP_NOFS);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001868 /* assert(header == s->base) */
1869 error = -ENOMEM;
1870 if (s->base == NULL)
1871 goto cleanup;
Mingming Cao617ba132006-10-11 01:20:53 -07001872 header(s->base)->h_magic = cpu_to_le32(EXT4_XATTR_MAGIC);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001873 header(s->base)->h_blocks = cpu_to_le32(1);
1874 header(s->base)->h_refcount = cpu_to_le32(1);
1875 s->first = ENTRY(header(s->base)+1);
1876 s->here = ENTRY(header(s->base)+1);
1877 s->end = s->base + sb->s_blocksize;
1878 }
1879
Tahsin Erdogandaf83282017-06-22 11:52:03 -04001880 error = ext4_xattr_set_entry(i, s, handle, inode, true /* is_block */);
Darrick J. Wong6a797d22015-10-17 16:16:04 -04001881 if (error == -EFSCORRUPTED)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001882 goto bad_block;
1883 if (error)
1884 goto cleanup;
Tahsin Erdogandec214d2017-06-22 11:44:55 -04001885
1886 if (i->value && s->here->e_value_inum) {
1887 unsigned int ea_ino;
1888
1889 /*
1890 * A ref count on ea_inode has been taken as part of the call to
1891 * ext4_xattr_set_entry() above. We would like to drop this
1892 * extra ref but we have to wait until the xattr block is
1893 * initialized and has its own ref count on the ea_inode.
1894 */
1895 ea_ino = le32_to_cpu(s->here->e_value_inum);
1896 error = ext4_xattr_inode_iget(inode, ea_ino, &ea_inode);
1897 if (error) {
1898 ea_inode = NULL;
1899 goto cleanup;
1900 }
1901 }
1902
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001903inserted:
1904 if (!IS_LAST_ENTRY(s->first)) {
Tahsin Erdogan47387402017-06-22 11:28:55 -04001905 new_bh = ext4_xattr_block_cache_find(inode, header(s->base),
1906 &ce);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001907 if (new_bh) {
1908 /* We found an identical block in the cache. */
1909 if (new_bh == bs->bh)
1910 ea_bdebug(new_bh, "keeping");
1911 else {
Andreas Gruenbacher6048c642016-02-22 22:44:04 -05001912 u32 ref;
1913
Tahsin Erdoganb8cb5a52017-05-24 18:24:07 -04001914 WARN_ON_ONCE(dquot_initialize_needed(inode));
1915
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001916 /* The old block is released after updating
1917 the inode. */
Lukas Czerner1231b3a2013-02-18 12:12:07 -05001918 error = dquot_alloc_block(inode,
1919 EXT4_C2B(EXT4_SB(sb), 1));
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001920 if (error)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001921 goto cleanup;
liang xie5d601252014-05-12 22:06:43 -04001922 BUFFER_TRACE(new_bh, "get_write_access");
Mingming Cao617ba132006-10-11 01:20:53 -07001923 error = ext4_journal_get_write_access(handle,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001924 new_bh);
1925 if (error)
1926 goto cleanup_dquot;
1927 lock_buffer(new_bh);
Jan Kara82939d72016-02-22 11:50:13 -05001928 /*
1929 * We have to be careful about races with
Andreas Gruenbacher6048c642016-02-22 22:44:04 -05001930 * freeing, rehashing or adding references to
1931 * xattr block. Once we hold buffer lock xattr
1932 * block's state is stable so we can check
1933 * whether the block got freed / rehashed or
1934 * not. Since we unhash mbcache entry under
1935 * buffer lock when freeing / rehashing xattr
1936 * block, checking whether entry is still
1937 * hashed is reliable. Same rules hold for
1938 * e_reusable handling.
Jan Kara82939d72016-02-22 11:50:13 -05001939 */
Andreas Gruenbacher6048c642016-02-22 22:44:04 -05001940 if (hlist_bl_unhashed(&ce->e_hash_list) ||
1941 !ce->e_reusable) {
Jan Kara82939d72016-02-22 11:50:13 -05001942 /*
1943 * Undo everything and check mbcache
1944 * again.
1945 */
1946 unlock_buffer(new_bh);
1947 dquot_free_block(inode,
1948 EXT4_C2B(EXT4_SB(sb),
1949 1));
1950 brelse(new_bh);
Tahsin Erdogan47387402017-06-22 11:28:55 -04001951 mb_cache_entry_put(ea_block_cache, ce);
Jan Kara82939d72016-02-22 11:50:13 -05001952 ce = NULL;
1953 new_bh = NULL;
1954 goto inserted;
1955 }
Andreas Gruenbacher6048c642016-02-22 22:44:04 -05001956 ref = le32_to_cpu(BHDR(new_bh)->h_refcount) + 1;
1957 BHDR(new_bh)->h_refcount = cpu_to_le32(ref);
1958 if (ref >= EXT4_XATTR_REFCOUNT_MAX)
1959 ce->e_reusable = 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001960 ea_bdebug(new_bh, "reusing; refcount now=%d",
Andreas Gruenbacher6048c642016-02-22 22:44:04 -05001961 ref);
Theodore Ts'odac7a4b2017-03-25 17:22:47 -04001962 ext4_xattr_block_csum_set(inode, new_bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001963 unlock_buffer(new_bh);
Theodore Ts'odac7a4b2017-03-25 17:22:47 -04001964 error = ext4_handle_dirty_metadata(handle,
1965 inode,
1966 new_bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001967 if (error)
1968 goto cleanup_dquot;
1969 }
Tahsin Erdogan47387402017-06-22 11:28:55 -04001970 mb_cache_entry_touch(ea_block_cache, ce);
1971 mb_cache_entry_put(ea_block_cache, ce);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001972 ce = NULL;
1973 } else if (bs->bh && s->base == bs->bh->b_data) {
1974 /* We were modifying this block in-place. */
1975 ea_bdebug(bs->bh, "keeping this block");
1976 new_bh = bs->bh;
1977 get_bh(new_bh);
1978 } else {
1979 /* We need to allocate a new block */
Eric Sandeenfb0a3872009-09-16 14:45:10 -04001980 ext4_fsblk_t goal, block;
1981
Tahsin Erdoganb8cb5a52017-05-24 18:24:07 -04001982 WARN_ON_ONCE(dquot_initialize_needed(inode));
1983
Eric Sandeenfb0a3872009-09-16 14:45:10 -04001984 goal = ext4_group_first_block_no(sb,
Akinobu Mitad00a6d72008-04-17 10:38:59 -04001985 EXT4_I(inode)->i_block_group);
Eric Sandeenfb0a3872009-09-16 14:45:10 -04001986
1987 /* non-extent files can't have physical blocks past 2^32 */
Dmitry Monakhov12e9b892010-05-16 22:00:00 -04001988 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
Eric Sandeenfb0a3872009-09-16 14:45:10 -04001989 goal = goal & EXT4_MAX_BLOCK_FILE_PHYS;
1990
Allison Henderson55f020d2011-05-25 07:41:26 -04001991 block = ext4_new_meta_blocks(handle, inode, goal, 0,
1992 NULL, &error);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001993 if (error)
1994 goto cleanup;
Eric Sandeenfb0a3872009-09-16 14:45:10 -04001995
Dmitry Monakhov12e9b892010-05-16 22:00:00 -04001996 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
Eric Sandeenfb0a3872009-09-16 14:45:10 -04001997 BUG_ON(block > EXT4_MAX_BLOCK_FILE_PHYS);
1998
Joe Perchesace36ad2012-03-19 23:11:43 -04001999 ea_idebug(inode, "creating block %llu",
2000 (unsigned long long)block);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002001
2002 new_bh = sb_getblk(sb, block);
Wang Shilongaebf0242013-01-12 16:28:47 -05002003 if (unlikely(!new_bh)) {
Theodore Ts'o860d21e2013-01-12 16:19:36 -05002004 error = -ENOMEM;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002005getblk_failed:
Peter Huewe7dc57612011-02-21 21:01:42 -05002006 ext4_free_blocks(handle, inode, NULL, block, 1,
Theodore Ts'oe6362602009-11-23 07:17:05 -05002007 EXT4_FREE_BLOCKS_METADATA);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002008 goto cleanup;
2009 }
Tahsin Erdogandec214d2017-06-22 11:44:55 -04002010 error = ext4_xattr_inode_inc_ref_all(handle, inode,
2011 ENTRY(header(s->base)+1));
2012 if (error)
2013 goto getblk_failed;
2014 if (ea_inode) {
2015 /* Drop the extra ref on ea_inode. */
2016 error = ext4_xattr_inode_dec_ref(handle,
2017 ea_inode);
2018 if (error)
2019 ext4_warning_inode(ea_inode,
2020 "dec ref error=%d",
2021 error);
2022 iput(ea_inode);
2023 ea_inode = NULL;
2024 }
2025
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002026 lock_buffer(new_bh);
Mingming Cao617ba132006-10-11 01:20:53 -07002027 error = ext4_journal_get_create_access(handle, new_bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002028 if (error) {
2029 unlock_buffer(new_bh);
Theodore Ts'o860d21e2013-01-12 16:19:36 -05002030 error = -EIO;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002031 goto getblk_failed;
2032 }
2033 memcpy(new_bh->b_data, s->base, new_bh->b_size);
Theodore Ts'odac7a4b2017-03-25 17:22:47 -04002034 ext4_xattr_block_csum_set(inode, new_bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002035 set_buffer_uptodate(new_bh);
2036 unlock_buffer(new_bh);
Tahsin Erdogan47387402017-06-22 11:28:55 -04002037 ext4_xattr_block_cache_insert(ea_block_cache, new_bh);
Theodore Ts'odac7a4b2017-03-25 17:22:47 -04002038 error = ext4_handle_dirty_metadata(handle, inode,
2039 new_bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002040 if (error)
2041 goto cleanup;
2042 }
2043 }
2044
Tahsin Erdogandec214d2017-06-22 11:44:55 -04002045 if (old_ea_inode_size)
2046 ext4_xattr_inode_free_quota(inode, old_ea_inode_size);
2047
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002048 /* Update the inode. */
Mingming Cao617ba132006-10-11 01:20:53 -07002049 EXT4_I(inode)->i_file_acl = new_bh ? new_bh->b_blocknr : 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002050
2051 /* Drop the previous xattr block. */
Tahsin Erdogandec214d2017-06-22 11:44:55 -04002052 if (bs->bh && bs->bh != new_bh) {
2053 struct ext4_xattr_inode_array *ea_inode_array = NULL;
2054
2055 ext4_xattr_release_block(handle, inode, bs->bh,
2056 &ea_inode_array,
2057 0 /* extra_credits */);
2058 ext4_xattr_inode_array_free(ea_inode_array);
2059 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002060 error = 0;
2061
2062cleanup:
Tahsin Erdogandec214d2017-06-22 11:44:55 -04002063 if (ea_inode) {
2064 int error2;
2065
2066 error2 = ext4_xattr_inode_dec_ref(handle, ea_inode);
2067 if (error2)
2068 ext4_warning_inode(ea_inode, "dec ref error=%d",
2069 error2);
2070
2071 /* If there was an error, revert the quota charge. */
2072 if (error)
2073 ext4_xattr_inode_free_quota(inode,
2074 i_size_read(ea_inode));
2075 iput(ea_inode);
2076 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002077 if (ce)
Tahsin Erdogan47387402017-06-22 11:28:55 -04002078 mb_cache_entry_put(ea_block_cache, ce);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002079 brelse(new_bh);
2080 if (!(bs->bh && s->base == bs->bh->b_data))
2081 kfree(s->base);
2082
2083 return error;
2084
2085cleanup_dquot:
Lukas Czerner1231b3a2013-02-18 12:12:07 -05002086 dquot_free_block(inode, EXT4_C2B(EXT4_SB(sb), 1));
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002087 goto cleanup;
2088
2089bad_block:
Theodore Ts'o24676da2010-05-16 21:00:00 -04002090 EXT4_ERROR_INODE(inode, "bad block %llu",
2091 EXT4_I(inode)->i_file_acl);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002092 goto cleanup;
2093
2094#undef header
2095}
2096
Tao Ma879b3822012-12-05 10:28:46 -05002097int ext4_xattr_ibody_find(struct inode *inode, struct ext4_xattr_info *i,
2098 struct ext4_xattr_ibody_find *is)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002099{
Mingming Cao617ba132006-10-11 01:20:53 -07002100 struct ext4_xattr_ibody_header *header;
2101 struct ext4_inode *raw_inode;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002102 int error;
2103
Mingming Cao617ba132006-10-11 01:20:53 -07002104 if (EXT4_I(inode)->i_extra_isize == 0)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002105 return 0;
Mingming Cao617ba132006-10-11 01:20:53 -07002106 raw_inode = ext4_raw_inode(&is->iloc);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002107 header = IHDR(inode, raw_inode);
2108 is->s.base = is->s.first = IFIRST(header);
2109 is->s.here = is->s.first;
Mingming Cao617ba132006-10-11 01:20:53 -07002110 is->s.end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
Theodore Ts'o19f5fb72010-01-24 14:34:07 -05002111 if (ext4_test_inode_state(inode, EXT4_STATE_XATTR)) {
Theodore Ts'o9e92f482016-03-22 16:13:15 -04002112 error = xattr_check_inode(inode, header, is->s.end);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002113 if (error)
2114 return error;
2115 /* Find the named attribute. */
Mingming Cao617ba132006-10-11 01:20:53 -07002116 error = ext4_xattr_find_entry(&is->s.here, i->name_index,
Eric Biggers6ba644b2017-04-30 00:01:02 -04002117 i->name, 0);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002118 if (error && error != -ENODATA)
2119 return error;
2120 is->s.not_found = error;
2121 }
2122 return 0;
2123}
2124
Tao Ma0d812f72012-12-10 14:06:02 -05002125int ext4_xattr_ibody_inline_set(handle_t *handle, struct inode *inode,
2126 struct ext4_xattr_info *i,
2127 struct ext4_xattr_ibody_find *is)
2128{
2129 struct ext4_xattr_ibody_header *header;
2130 struct ext4_xattr_search *s = &is->s;
2131 int error;
2132
2133 if (EXT4_I(inode)->i_extra_isize == 0)
2134 return -ENOSPC;
Tahsin Erdogandaf83282017-06-22 11:52:03 -04002135 error = ext4_xattr_set_entry(i, s, handle, inode, false /* is_block */);
Tao Ma0d812f72012-12-10 14:06:02 -05002136 if (error) {
2137 if (error == -ENOSPC &&
2138 ext4_has_inline_data(inode)) {
2139 error = ext4_try_to_evict_inline_data(handle, inode,
2140 EXT4_XATTR_LEN(strlen(i->name) +
2141 EXT4_XATTR_SIZE(i->value_len)));
2142 if (error)
2143 return error;
2144 error = ext4_xattr_ibody_find(inode, i, is);
2145 if (error)
2146 return error;
Tahsin Erdogandaf83282017-06-22 11:52:03 -04002147 error = ext4_xattr_set_entry(i, s, handle, inode,
2148 false /* is_block */);
Tao Ma0d812f72012-12-10 14:06:02 -05002149 }
2150 if (error)
2151 return error;
2152 }
2153 header = IHDR(inode, ext4_raw_inode(&is->iloc));
2154 if (!IS_LAST_ENTRY(s->first)) {
2155 header->h_magic = cpu_to_le32(EXT4_XATTR_MAGIC);
2156 ext4_set_inode_state(inode, EXT4_STATE_XATTR);
2157 } else {
2158 header->h_magic = cpu_to_le32(0);
2159 ext4_clear_inode_state(inode, EXT4_STATE_XATTR);
2160 }
2161 return 0;
2162}
2163
Andreas Dilgere50e5122017-06-21 21:10:32 -04002164static int ext4_xattr_ibody_set(handle_t *handle, struct inode *inode,
Tao Ma0d812f72012-12-10 14:06:02 -05002165 struct ext4_xattr_info *i,
2166 struct ext4_xattr_ibody_find *is)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002167{
Mingming Cao617ba132006-10-11 01:20:53 -07002168 struct ext4_xattr_ibody_header *header;
2169 struct ext4_xattr_search *s = &is->s;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002170 int error;
2171
Mingming Cao617ba132006-10-11 01:20:53 -07002172 if (EXT4_I(inode)->i_extra_isize == 0)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002173 return -ENOSPC;
Tahsin Erdogandaf83282017-06-22 11:52:03 -04002174 error = ext4_xattr_set_entry(i, s, handle, inode, false /* is_block */);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002175 if (error)
2176 return error;
Mingming Cao617ba132006-10-11 01:20:53 -07002177 header = IHDR(inode, ext4_raw_inode(&is->iloc));
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002178 if (!IS_LAST_ENTRY(s->first)) {
Mingming Cao617ba132006-10-11 01:20:53 -07002179 header->h_magic = cpu_to_le32(EXT4_XATTR_MAGIC);
Theodore Ts'o19f5fb72010-01-24 14:34:07 -05002180 ext4_set_inode_state(inode, EXT4_STATE_XATTR);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002181 } else {
2182 header->h_magic = cpu_to_le32(0);
Theodore Ts'o19f5fb72010-01-24 14:34:07 -05002183 ext4_clear_inode_state(inode, EXT4_STATE_XATTR);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002184 }
2185 return 0;
2186}
2187
Jan Kara3fd16462016-02-22 22:43:04 -05002188static int ext4_xattr_value_same(struct ext4_xattr_search *s,
2189 struct ext4_xattr_info *i)
2190{
2191 void *value;
2192
Tahsin Erdogan0bd454c2017-06-21 22:02:06 -04002193 /* When e_value_inum is set the value is stored externally. */
2194 if (s->here->e_value_inum)
2195 return 0;
Jan Kara3fd16462016-02-22 22:43:04 -05002196 if (le32_to_cpu(s->here->e_value_size) != i->value_len)
2197 return 0;
2198 value = ((void *)s->base) + le16_to_cpu(s->here->e_value_offs);
2199 return !memcmp(value, i->value, i->value_len);
2200}
2201
Tahsin Erdogandec214d2017-06-22 11:44:55 -04002202static struct buffer_head *ext4_xattr_get_block(struct inode *inode)
2203{
2204 struct buffer_head *bh;
2205 int error;
2206
2207 if (!EXT4_I(inode)->i_file_acl)
2208 return NULL;
2209 bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl);
2210 if (!bh)
2211 return ERR_PTR(-EIO);
2212 error = ext4_xattr_check_block(inode, bh);
2213 if (error)
2214 return ERR_PTR(error);
2215 return bh;
2216}
2217
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002218/*
Mingming Cao617ba132006-10-11 01:20:53 -07002219 * ext4_xattr_set_handle()
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002220 *
Wang Sheng-Hui6e9510b2011-01-10 12:10:30 -05002221 * Create, replace or remove an extended attribute for this inode. Value
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002222 * is NULL to remove an existing extended attribute, and non-NULL to
2223 * either replace an existing extended attribute, or create a new extended
2224 * attribute. The flags XATTR_REPLACE and XATTR_CREATE
2225 * specify that an extended attribute must exist and must not exist
2226 * previous to the call, respectively.
2227 *
2228 * Returns 0, or a negative error number on failure.
2229 */
2230int
Mingming Cao617ba132006-10-11 01:20:53 -07002231ext4_xattr_set_handle(handle_t *handle, struct inode *inode, int name_index,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002232 const char *name, const void *value, size_t value_len,
2233 int flags)
2234{
Mingming Cao617ba132006-10-11 01:20:53 -07002235 struct ext4_xattr_info i = {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002236 .name_index = name_index,
2237 .name = name,
2238 .value = value,
2239 .value_len = value_len,
Andreas Dilgere50e5122017-06-21 21:10:32 -04002240 .in_inode = 0,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002241 };
Mingming Cao617ba132006-10-11 01:20:53 -07002242 struct ext4_xattr_ibody_find is = {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002243 .s = { .not_found = -ENODATA, },
2244 };
Mingming Cao617ba132006-10-11 01:20:53 -07002245 struct ext4_xattr_block_find bs = {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002246 .s = { .not_found = -ENODATA, },
2247 };
Theodore Ts'oc755e252017-01-11 21:50:46 -05002248 int no_expand;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002249 int error;
2250
2251 if (!name)
2252 return -EINVAL;
2253 if (strlen(name) > 255)
2254 return -ERANGE;
Tahsin Erdoganb8cb5a52017-05-24 18:24:07 -04002255
Theodore Ts'oc755e252017-01-11 21:50:46 -05002256 ext4_write_lock_xattr(inode, &no_expand);
Kalpak Shah4d20c682008-10-08 23:21:54 -04002257
Tahsin Erdoganc1a5d5f2017-06-21 22:28:40 -04002258 /* Check journal credits under write lock. */
2259 if (ext4_handle_valid(handle)) {
Tahsin Erdogandec214d2017-06-22 11:44:55 -04002260 struct buffer_head *bh;
Tahsin Erdoganc1a5d5f2017-06-21 22:28:40 -04002261 int credits;
2262
Tahsin Erdogandec214d2017-06-22 11:44:55 -04002263 bh = ext4_xattr_get_block(inode);
2264 if (IS_ERR(bh)) {
2265 error = PTR_ERR(bh);
2266 goto cleanup;
2267 }
2268
Tahsin Erdoganaf652072017-07-06 00:01:59 -04002269 credits = __ext4_xattr_set_credits(inode->i_sb, inode, bh,
2270 value_len,
2271 flags & XATTR_CREATE);
Tahsin Erdogandec214d2017-06-22 11:44:55 -04002272 brelse(bh);
2273
Tahsin Erdoganc1a5d5f2017-06-21 22:28:40 -04002274 if (!ext4_handle_has_enough_credits(handle, credits)) {
2275 error = -ENOSPC;
2276 goto cleanup;
2277 }
2278 }
2279
Eric Sandeen66543612011-10-26 03:32:07 -04002280 error = ext4_reserve_inode_write(handle, inode, &is.iloc);
Eric Sandeen86ebfd02009-11-15 15:30:52 -05002281 if (error)
2282 goto cleanup;
2283
Theodore Ts'o19f5fb72010-01-24 14:34:07 -05002284 if (ext4_test_inode_state(inode, EXT4_STATE_NEW)) {
Mingming Cao617ba132006-10-11 01:20:53 -07002285 struct ext4_inode *raw_inode = ext4_raw_inode(&is.iloc);
2286 memset(raw_inode, 0, EXT4_SB(inode->i_sb)->s_inode_size);
Theodore Ts'o19f5fb72010-01-24 14:34:07 -05002287 ext4_clear_inode_state(inode, EXT4_STATE_NEW);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002288 }
2289
Mingming Cao617ba132006-10-11 01:20:53 -07002290 error = ext4_xattr_ibody_find(inode, &i, &is);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002291 if (error)
2292 goto cleanup;
2293 if (is.s.not_found)
Mingming Cao617ba132006-10-11 01:20:53 -07002294 error = ext4_xattr_block_find(inode, &i, &bs);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002295 if (error)
2296 goto cleanup;
2297 if (is.s.not_found && bs.s.not_found) {
2298 error = -ENODATA;
2299 if (flags & XATTR_REPLACE)
2300 goto cleanup;
2301 error = 0;
2302 if (!value)
2303 goto cleanup;
2304 } else {
2305 error = -EEXIST;
2306 if (flags & XATTR_CREATE)
2307 goto cleanup;
2308 }
Tahsin Erdogandec214d2017-06-22 11:44:55 -04002309
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002310 if (!value) {
2311 if (!is.s.not_found)
Andreas Dilgere50e5122017-06-21 21:10:32 -04002312 error = ext4_xattr_ibody_set(handle, inode, &i, &is);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002313 else if (!bs.s.not_found)
Mingming Cao617ba132006-10-11 01:20:53 -07002314 error = ext4_xattr_block_set(handle, inode, &i, &bs);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002315 } else {
Jan Kara3fd16462016-02-22 22:43:04 -05002316 error = 0;
2317 /* Xattr value did not change? Save us some work and bail out */
2318 if (!is.s.not_found && ext4_xattr_value_same(&is.s, &i))
2319 goto cleanup;
2320 if (!bs.s.not_found && ext4_xattr_value_same(&bs.s, &i))
2321 goto cleanup;
2322
Tahsin Erdoganb347e2b2017-06-21 22:20:32 -04002323 if (ext4_has_feature_ea_inode(inode->i_sb) &&
2324 (EXT4_XATTR_SIZE(i.value_len) >
2325 EXT4_XATTR_MIN_LARGE_EA_SIZE(inode->i_sb->s_blocksize)))
2326 i.in_inode = 1;
2327retry_inode:
Andreas Dilgere50e5122017-06-21 21:10:32 -04002328 error = ext4_xattr_ibody_set(handle, inode, &i, &is);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002329 if (!error && !bs.s.not_found) {
2330 i.value = NULL;
Mingming Cao617ba132006-10-11 01:20:53 -07002331 error = ext4_xattr_block_set(handle, inode, &i, &bs);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002332 } else if (error == -ENOSPC) {
Tiger Yang7e01c8e2008-05-14 16:05:47 -07002333 if (EXT4_I(inode)->i_file_acl && !bs.s.base) {
2334 error = ext4_xattr_block_find(inode, &i, &bs);
2335 if (error)
2336 goto cleanup;
2337 }
Mingming Cao617ba132006-10-11 01:20:53 -07002338 error = ext4_xattr_block_set(handle, inode, &i, &bs);
Tahsin Erdoganb347e2b2017-06-21 22:20:32 -04002339 if (!error && !is.s.not_found) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002340 i.value = NULL;
Andreas Dilgere50e5122017-06-21 21:10:32 -04002341 error = ext4_xattr_ibody_set(handle, inode, &i,
2342 &is);
Tahsin Erdoganb347e2b2017-06-21 22:20:32 -04002343 } else if (error == -ENOSPC) {
2344 /*
2345 * Xattr does not fit in the block, store at
2346 * external inode if possible.
2347 */
2348 if (ext4_has_feature_ea_inode(inode->i_sb) &&
2349 !i.in_inode) {
2350 i.in_inode = 1;
2351 goto retry_inode;
2352 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002353 }
2354 }
2355 }
2356 if (!error) {
Mingming Cao617ba132006-10-11 01:20:53 -07002357 ext4_xattr_update_super_block(handle, inode->i_sb);
Deepa Dinamanieeca7ea2016-11-14 21:40:10 -05002358 inode->i_ctime = current_time(inode);
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04002359 if (!value)
Theodore Ts'oc755e252017-01-11 21:50:46 -05002360 no_expand = 0;
Mingming Cao617ba132006-10-11 01:20:53 -07002361 error = ext4_mark_iloc_dirty(handle, inode, &is.iloc);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002362 /*
Mingming Cao617ba132006-10-11 01:20:53 -07002363 * The bh is consumed by ext4_mark_iloc_dirty, even with
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002364 * error != 0.
2365 */
2366 is.iloc.bh = NULL;
2367 if (IS_SYNC(inode))
Frank Mayhar03901312009-01-07 00:06:22 -05002368 ext4_handle_sync(handle);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002369 }
2370
2371cleanup:
2372 brelse(is.iloc.bh);
2373 brelse(bs.bh);
Theodore Ts'oc755e252017-01-11 21:50:46 -05002374 ext4_write_unlock_xattr(inode, &no_expand);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002375 return error;
2376}
2377
Tahsin Erdoganaf652072017-07-06 00:01:59 -04002378int ext4_xattr_set_credits(struct inode *inode, size_t value_len,
2379 bool is_create, int *credits)
Tahsin Erdoganc1a5d5f2017-06-21 22:28:40 -04002380{
Tahsin Erdogandec214d2017-06-22 11:44:55 -04002381 struct buffer_head *bh;
2382 int err;
Tahsin Erdoganc1a5d5f2017-06-21 22:28:40 -04002383
Tahsin Erdogandec214d2017-06-22 11:44:55 -04002384 *credits = 0;
2385
2386 if (!EXT4_SB(inode->i_sb)->s_journal)
Tahsin Erdoganc1a5d5f2017-06-21 22:28:40 -04002387 return 0;
2388
Tahsin Erdogandec214d2017-06-22 11:44:55 -04002389 down_read(&EXT4_I(inode)->xattr_sem);
Tahsin Erdoganc1a5d5f2017-06-21 22:28:40 -04002390
Tahsin Erdogandec214d2017-06-22 11:44:55 -04002391 bh = ext4_xattr_get_block(inode);
2392 if (IS_ERR(bh)) {
2393 err = PTR_ERR(bh);
2394 } else {
Tahsin Erdoganaf652072017-07-06 00:01:59 -04002395 *credits = __ext4_xattr_set_credits(inode->i_sb, inode, bh,
2396 value_len, is_create);
Tahsin Erdogandec214d2017-06-22 11:44:55 -04002397 brelse(bh);
2398 err = 0;
Tahsin Erdoganc1a5d5f2017-06-21 22:28:40 -04002399 }
Tahsin Erdogandec214d2017-06-22 11:44:55 -04002400
2401 up_read(&EXT4_I(inode)->xattr_sem);
2402 return err;
Tahsin Erdoganc1a5d5f2017-06-21 22:28:40 -04002403}
2404
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002405/*
Mingming Cao617ba132006-10-11 01:20:53 -07002406 * ext4_xattr_set()
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002407 *
Mingming Cao617ba132006-10-11 01:20:53 -07002408 * Like ext4_xattr_set_handle, but start from an inode. This extended
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002409 * attribute modification is a filesystem transaction by itself.
2410 *
2411 * Returns 0, or a negative error number on failure.
2412 */
2413int
Mingming Cao617ba132006-10-11 01:20:53 -07002414ext4_xattr_set(struct inode *inode, int name_index, const char *name,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002415 const void *value, size_t value_len, int flags)
2416{
2417 handle_t *handle;
Andreas Dilgere50e5122017-06-21 21:10:32 -04002418 struct super_block *sb = inode->i_sb;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002419 int error, retries = 0;
Tahsin Erdoganc1a5d5f2017-06-21 22:28:40 -04002420 int credits;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002421
Tahsin Erdoganb8cb5a52017-05-24 18:24:07 -04002422 error = dquot_initialize(inode);
2423 if (error)
2424 return error;
Andreas Dilgere50e5122017-06-21 21:10:32 -04002425
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002426retry:
Tahsin Erdoganaf652072017-07-06 00:01:59 -04002427 error = ext4_xattr_set_credits(inode, value_len, flags & XATTR_CREATE,
2428 &credits);
Tahsin Erdogandec214d2017-06-22 11:44:55 -04002429 if (error)
2430 return error;
2431
Theodore Ts'o9924a922013-02-08 21:59:22 -05002432 handle = ext4_journal_start(inode, EXT4_HT_XATTR, credits);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002433 if (IS_ERR(handle)) {
2434 error = PTR_ERR(handle);
2435 } else {
2436 int error2;
2437
Mingming Cao617ba132006-10-11 01:20:53 -07002438 error = ext4_xattr_set_handle(handle, inode, name_index, name,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002439 value, value_len, flags);
Mingming Cao617ba132006-10-11 01:20:53 -07002440 error2 = ext4_journal_stop(handle);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002441 if (error == -ENOSPC &&
Andreas Dilgere50e5122017-06-21 21:10:32 -04002442 ext4_should_retry_alloc(sb, &retries))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002443 goto retry;
2444 if (error == 0)
2445 error = error2;
2446 }
2447
2448 return error;
2449}
2450
2451/*
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04002452 * Shift the EA entries in the inode to create space for the increased
2453 * i_extra_isize.
2454 */
2455static void ext4_xattr_shift_entries(struct ext4_xattr_entry *entry,
2456 int value_offs_shift, void *to,
Jan Kara94405712016-08-29 15:41:11 -04002457 void *from, size_t n)
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04002458{
2459 struct ext4_xattr_entry *last = entry;
2460 int new_offs;
2461
Jan Kara94405712016-08-29 15:41:11 -04002462 /* We always shift xattr headers further thus offsets get lower */
2463 BUG_ON(value_offs_shift > 0);
2464
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04002465 /* Adjust the value offsets of the entries */
2466 for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
Andreas Dilgere50e5122017-06-21 21:10:32 -04002467 if (!last->e_value_inum && last->e_value_size) {
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04002468 new_offs = le16_to_cpu(last->e_value_offs) +
2469 value_offs_shift;
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04002470 last->e_value_offs = cpu_to_le16(new_offs);
2471 }
2472 }
2473 /* Shift the entries by n bytes */
2474 memmove(to, from, n);
2475}
2476
2477/*
Jan Kara3f2571c2016-08-29 15:42:11 -04002478 * Move xattr pointed to by 'entry' from inode into external xattr block
2479 */
2480static int ext4_xattr_move_to_block(handle_t *handle, struct inode *inode,
2481 struct ext4_inode *raw_inode,
2482 struct ext4_xattr_entry *entry)
2483{
2484 struct ext4_xattr_ibody_find *is = NULL;
2485 struct ext4_xattr_block_find *bs = NULL;
2486 char *buffer = NULL, *b_entry_name = NULL;
Tahsin Erdoganf6109102017-06-21 22:11:54 -04002487 size_t value_size = le32_to_cpu(entry->e_value_size);
Jan Kara3f2571c2016-08-29 15:42:11 -04002488 struct ext4_xattr_info i = {
2489 .value = NULL,
2490 .value_len = 0,
2491 .name_index = entry->e_name_index,
Tahsin Erdoganf6109102017-06-21 22:11:54 -04002492 .in_inode = !!entry->e_value_inum,
Jan Kara3f2571c2016-08-29 15:42:11 -04002493 };
2494 struct ext4_xattr_ibody_header *header = IHDR(inode, raw_inode);
2495 int error;
2496
Jan Kara3f2571c2016-08-29 15:42:11 -04002497 is = kzalloc(sizeof(struct ext4_xattr_ibody_find), GFP_NOFS);
2498 bs = kzalloc(sizeof(struct ext4_xattr_block_find), GFP_NOFS);
2499 buffer = kmalloc(value_size, GFP_NOFS);
2500 b_entry_name = kmalloc(entry->e_name_len + 1, GFP_NOFS);
2501 if (!is || !bs || !buffer || !b_entry_name) {
2502 error = -ENOMEM;
2503 goto out;
2504 }
2505
2506 is->s.not_found = -ENODATA;
2507 bs->s.not_found = -ENODATA;
2508 is->iloc.bh = NULL;
2509 bs->bh = NULL;
2510
2511 /* Save the entry name and the entry value */
Tahsin Erdoganf6109102017-06-21 22:11:54 -04002512 if (entry->e_value_inum) {
Tahsin Erdoganb9fc7612017-06-22 11:53:15 -04002513 error = ext4_xattr_inode_get(inode, entry, buffer, value_size);
Tahsin Erdoganf6109102017-06-21 22:11:54 -04002514 if (error)
2515 goto out;
2516 } else {
2517 size_t value_offs = le16_to_cpu(entry->e_value_offs);
2518 memcpy(buffer, (void *)IFIRST(header) + value_offs, value_size);
2519 }
2520
Jan Kara3f2571c2016-08-29 15:42:11 -04002521 memcpy(b_entry_name, entry->e_name, entry->e_name_len);
2522 b_entry_name[entry->e_name_len] = '\0';
2523 i.name = b_entry_name;
2524
2525 error = ext4_get_inode_loc(inode, &is->iloc);
2526 if (error)
2527 goto out;
2528
2529 error = ext4_xattr_ibody_find(inode, &i, is);
2530 if (error)
2531 goto out;
2532
2533 /* Remove the chosen entry from the inode */
Andreas Dilgere50e5122017-06-21 21:10:32 -04002534 error = ext4_xattr_ibody_set(handle, inode, &i, is);
Jan Kara3f2571c2016-08-29 15:42:11 -04002535 if (error)
2536 goto out;
2537
Jan Kara3f2571c2016-08-29 15:42:11 -04002538 i.value = buffer;
2539 i.value_len = value_size;
2540 error = ext4_xattr_block_find(inode, &i, bs);
2541 if (error)
2542 goto out;
2543
2544 /* Add entry which was removed from the inode into the block */
2545 error = ext4_xattr_block_set(handle, inode, &i, bs);
2546 if (error)
2547 goto out;
2548 error = 0;
2549out:
2550 kfree(b_entry_name);
2551 kfree(buffer);
2552 if (is)
2553 brelse(is->iloc.bh);
2554 kfree(is);
2555 kfree(bs);
2556
2557 return error;
2558}
2559
Jan Karadfa20642016-08-29 15:44:11 -04002560static int ext4_xattr_make_inode_space(handle_t *handle, struct inode *inode,
2561 struct ext4_inode *raw_inode,
2562 int isize_diff, size_t ifree,
2563 size_t bfree, int *total_ino)
2564{
2565 struct ext4_xattr_ibody_header *header = IHDR(inode, raw_inode);
2566 struct ext4_xattr_entry *small_entry;
2567 struct ext4_xattr_entry *entry;
2568 struct ext4_xattr_entry *last;
2569 unsigned int entry_size; /* EA entry size */
2570 unsigned int total_size; /* EA entry size + value size */
2571 unsigned int min_total_size;
2572 int error;
2573
2574 while (isize_diff > ifree) {
2575 entry = NULL;
2576 small_entry = NULL;
2577 min_total_size = ~0U;
2578 last = IFIRST(header);
2579 /* Find the entry best suited to be pushed into EA block */
2580 for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
Tahsin Erdogan9bb21ce2017-06-21 22:05:44 -04002581 total_size = EXT4_XATTR_LEN(last->e_name_len);
2582 if (!last->e_value_inum)
2583 total_size += EXT4_XATTR_SIZE(
2584 le32_to_cpu(last->e_value_size));
Jan Karadfa20642016-08-29 15:44:11 -04002585 if (total_size <= bfree &&
2586 total_size < min_total_size) {
2587 if (total_size + ifree < isize_diff) {
2588 small_entry = last;
2589 } else {
2590 entry = last;
2591 min_total_size = total_size;
2592 }
2593 }
2594 }
2595
2596 if (entry == NULL) {
2597 if (small_entry == NULL)
2598 return -ENOSPC;
2599 entry = small_entry;
2600 }
2601
2602 entry_size = EXT4_XATTR_LEN(entry->e_name_len);
Tahsin Erdogan9bb21ce2017-06-21 22:05:44 -04002603 total_size = entry_size;
2604 if (!entry->e_value_inum)
2605 total_size += EXT4_XATTR_SIZE(
2606 le32_to_cpu(entry->e_value_size));
Jan Karadfa20642016-08-29 15:44:11 -04002607 error = ext4_xattr_move_to_block(handle, inode, raw_inode,
2608 entry);
2609 if (error)
2610 return error;
2611
2612 *total_ino -= entry_size;
2613 ifree += total_size;
2614 bfree -= total_size;
2615 }
2616
2617 return 0;
2618}
2619
Jan Kara3f2571c2016-08-29 15:42:11 -04002620/*
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04002621 * Expand an inode by new_extra_isize bytes when EAs are present.
2622 * Returns 0 on success or negative error number on failure.
2623 */
2624int ext4_expand_extra_isize_ea(struct inode *inode, int new_extra_isize,
2625 struct ext4_inode *raw_inode, handle_t *handle)
2626{
2627 struct ext4_xattr_ibody_header *header;
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04002628 struct buffer_head *bh = NULL;
Jan Karae3014d12016-08-29 15:38:11 -04002629 size_t min_offs;
2630 size_t ifree, bfree;
Theodore Ts'o7b1b2c12014-02-19 20:15:21 -05002631 int total_ino;
Jan Kara6e0cd082016-08-29 15:43:11 -04002632 void *base, *end;
Jan Karad0141192016-08-11 11:50:30 -04002633 int error = 0, tried_min_extra_isize = 0;
Aneesh Kumar K.Vac398492007-10-16 18:38:25 -04002634 int s_min_extra_isize = le16_to_cpu(EXT4_SB(inode->i_sb)->s_es->s_min_extra_isize);
Jan Karad0141192016-08-11 11:50:30 -04002635 int isize_diff; /* How much do we need to grow i_extra_isize */
Theodore Ts'oc755e252017-01-11 21:50:46 -05002636 int no_expand;
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04002637
Theodore Ts'oc755e252017-01-11 21:50:46 -05002638 if (ext4_write_trylock_xattr(inode, &no_expand) == 0)
2639 return 0;
2640
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04002641retry:
Jan Karad0141192016-08-11 11:50:30 -04002642 isize_diff = new_extra_isize - EXT4_I(inode)->i_extra_isize;
Jan Kara2e81a4e2016-08-11 12:38:55 -04002643 if (EXT4_I(inode)->i_extra_isize >= new_extra_isize)
2644 goto out;
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04002645
2646 header = IHDR(inode, raw_inode);
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04002647
2648 /*
2649 * Check if enough free space is available in the inode to shift the
2650 * entries ahead by new_extra_isize.
2651 */
2652
Jan Kara6e0cd082016-08-29 15:43:11 -04002653 base = IFIRST(header);
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04002654 end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
2655 min_offs = end - base;
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04002656 total_ino = sizeof(struct ext4_xattr_ibody_header);
2657
Theodore Ts'o9e92f482016-03-22 16:13:15 -04002658 error = xattr_check_inode(inode, header, end);
2659 if (error)
2660 goto cleanup;
2661
Jan Kara6e0cd082016-08-29 15:43:11 -04002662 ifree = ext4_xattr_free_space(base, &min_offs, base, &total_ino);
Jan Karae3014d12016-08-29 15:38:11 -04002663 if (ifree >= isize_diff)
2664 goto shift;
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04002665
2666 /*
2667 * Enough free space isn't available in the inode, check if
2668 * EA block can hold new_extra_isize bytes.
2669 */
2670 if (EXT4_I(inode)->i_file_acl) {
2671 bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl);
2672 error = -EIO;
2673 if (!bh)
2674 goto cleanup;
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -04002675 if (ext4_xattr_check_block(inode, bh)) {
Theodore Ts'o24676da2010-05-16 21:00:00 -04002676 EXT4_ERROR_INODE(inode, "bad block %llu",
2677 EXT4_I(inode)->i_file_acl);
Darrick J. Wong6a797d22015-10-17 16:16:04 -04002678 error = -EFSCORRUPTED;
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04002679 goto cleanup;
2680 }
2681 base = BHDR(bh);
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04002682 end = bh->b_data + bh->b_size;
2683 min_offs = end - base;
Jan Kara6e0cd082016-08-29 15:43:11 -04002684 bfree = ext4_xattr_free_space(BFIRST(bh), &min_offs, base,
2685 NULL);
Jan Karae3014d12016-08-29 15:38:11 -04002686 if (bfree + ifree < isize_diff) {
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04002687 if (!tried_min_extra_isize && s_min_extra_isize) {
2688 tried_min_extra_isize++;
2689 new_extra_isize = s_min_extra_isize;
2690 brelse(bh);
2691 goto retry;
2692 }
Jan Karadfa20642016-08-29 15:44:11 -04002693 error = -ENOSPC;
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04002694 goto cleanup;
2695 }
2696 } else {
Jan Karae3014d12016-08-29 15:38:11 -04002697 bfree = inode->i_sb->s_blocksize;
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04002698 }
2699
Jan Karadfa20642016-08-29 15:44:11 -04002700 error = ext4_xattr_make_inode_space(handle, inode, raw_inode,
2701 isize_diff, ifree, bfree,
2702 &total_ino);
2703 if (error) {
2704 if (error == -ENOSPC && !tried_min_extra_isize &&
2705 s_min_extra_isize) {
2706 tried_min_extra_isize++;
2707 new_extra_isize = s_min_extra_isize;
2708 brelse(bh);
2709 goto retry;
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04002710 }
Jan Karadfa20642016-08-29 15:44:11 -04002711 goto cleanup;
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04002712 }
Jan Karae3014d12016-08-29 15:38:11 -04002713shift:
2714 /* Adjust the offsets and shift the remaining entries ahead */
Jan Kara6e0cd082016-08-29 15:43:11 -04002715 ext4_xattr_shift_entries(IFIRST(header), EXT4_I(inode)->i_extra_isize
Jan Karae3014d12016-08-29 15:38:11 -04002716 - new_extra_isize, (void *)raw_inode +
2717 EXT4_GOOD_OLD_INODE_SIZE + new_extra_isize,
Jan Kara94405712016-08-29 15:41:11 -04002718 (void *)header, total_ino);
Jan Karae3014d12016-08-29 15:38:11 -04002719 EXT4_I(inode)->i_extra_isize = new_extra_isize;
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04002720 brelse(bh);
Jan Kara2e81a4e2016-08-11 12:38:55 -04002721out:
Theodore Ts'oc755e252017-01-11 21:50:46 -05002722 ext4_write_unlock_xattr(inode, &no_expand);
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04002723 return 0;
2724
2725cleanup:
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04002726 brelse(bh);
Jan Kara2e81a4e2016-08-11 12:38:55 -04002727 /*
Theodore Ts'oc755e252017-01-11 21:50:46 -05002728 * Inode size expansion failed; don't try again
Jan Kara2e81a4e2016-08-11 12:38:55 -04002729 */
Theodore Ts'oc755e252017-01-11 21:50:46 -05002730 no_expand = 1;
2731 ext4_write_unlock_xattr(inode, &no_expand);
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04002732 return error;
2733}
2734
Andreas Dilgere50e5122017-06-21 21:10:32 -04002735#define EIA_INCR 16 /* must be 2^n */
2736#define EIA_MASK (EIA_INCR - 1)
Tahsin Erdogandec214d2017-06-22 11:44:55 -04002737
2738/* Add the large xattr @inode into @ea_inode_array for deferred iput().
Tahsin Erdogan0421a182017-06-22 10:26:31 -04002739 * If @ea_inode_array is new or full it will be grown and the old
Andreas Dilgere50e5122017-06-21 21:10:32 -04002740 * contents copied over.
2741 */
2742static int
Tahsin Erdogan0421a182017-06-22 10:26:31 -04002743ext4_expand_inode_array(struct ext4_xattr_inode_array **ea_inode_array,
2744 struct inode *inode)
Andreas Dilgere50e5122017-06-21 21:10:32 -04002745{
Tahsin Erdogan0421a182017-06-22 10:26:31 -04002746 if (*ea_inode_array == NULL) {
Andreas Dilgere50e5122017-06-21 21:10:32 -04002747 /*
2748 * Start with 15 inodes, so it fits into a power-of-two size.
Tahsin Erdogan0421a182017-06-22 10:26:31 -04002749 * If *ea_inode_array is NULL, this is essentially offsetof()
Andreas Dilgere50e5122017-06-21 21:10:32 -04002750 */
Tahsin Erdogan0421a182017-06-22 10:26:31 -04002751 (*ea_inode_array) =
2752 kmalloc(offsetof(struct ext4_xattr_inode_array,
2753 inodes[EIA_MASK]),
Andreas Dilgere50e5122017-06-21 21:10:32 -04002754 GFP_NOFS);
Tahsin Erdogan0421a182017-06-22 10:26:31 -04002755 if (*ea_inode_array == NULL)
Andreas Dilgere50e5122017-06-21 21:10:32 -04002756 return -ENOMEM;
Tahsin Erdogan0421a182017-06-22 10:26:31 -04002757 (*ea_inode_array)->count = 0;
2758 } else if (((*ea_inode_array)->count & EIA_MASK) == EIA_MASK) {
Andreas Dilgere50e5122017-06-21 21:10:32 -04002759 /* expand the array once all 15 + n * 16 slots are full */
Tahsin Erdogan0421a182017-06-22 10:26:31 -04002760 struct ext4_xattr_inode_array *new_array = NULL;
2761 int count = (*ea_inode_array)->count;
Andreas Dilgere50e5122017-06-21 21:10:32 -04002762
2763 /* if new_array is NULL, this is essentially offsetof() */
2764 new_array = kmalloc(
Tahsin Erdogan0421a182017-06-22 10:26:31 -04002765 offsetof(struct ext4_xattr_inode_array,
2766 inodes[count + EIA_INCR]),
Andreas Dilgere50e5122017-06-21 21:10:32 -04002767 GFP_NOFS);
2768 if (new_array == NULL)
2769 return -ENOMEM;
Tahsin Erdogan0421a182017-06-22 10:26:31 -04002770 memcpy(new_array, *ea_inode_array,
2771 offsetof(struct ext4_xattr_inode_array, inodes[count]));
2772 kfree(*ea_inode_array);
2773 *ea_inode_array = new_array;
Andreas Dilgere50e5122017-06-21 21:10:32 -04002774 }
Tahsin Erdogan0421a182017-06-22 10:26:31 -04002775 (*ea_inode_array)->inodes[(*ea_inode_array)->count++] = inode;
Andreas Dilgere50e5122017-06-21 21:10:32 -04002776 return 0;
2777}
2778
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04002779/*
Mingming Cao617ba132006-10-11 01:20:53 -07002780 * ext4_xattr_delete_inode()
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002781 *
Andreas Dilgere50e5122017-06-21 21:10:32 -04002782 * Free extended attribute resources associated with this inode. Traverse
Tahsin Erdogandec214d2017-06-22 11:44:55 -04002783 * all entries and decrement reference on any xattr inodes associated with this
2784 * inode. This is called immediately before an inode is freed. We have exclusive
2785 * access to the inode. If an orphan inode is deleted it will also release its
2786 * references on xattr block and xattr inodes.
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002787 */
Tahsin Erdogandec214d2017-06-22 11:44:55 -04002788int ext4_xattr_delete_inode(handle_t *handle, struct inode *inode,
2789 struct ext4_xattr_inode_array **ea_inode_array,
2790 int extra_credits)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002791{
2792 struct buffer_head *bh = NULL;
Andreas Dilgere50e5122017-06-21 21:10:32 -04002793 struct ext4_xattr_ibody_header *header;
Tahsin Erdogan30a7eb92017-06-22 11:42:09 -04002794 struct ext4_iloc iloc = { .bh = NULL };
Tahsin Erdogandec214d2017-06-22 11:44:55 -04002795 struct ext4_xattr_entry *entry;
Tahsin Erdogan30a7eb92017-06-22 11:42:09 -04002796 int error;
2797
2798 error = ext4_xattr_ensure_credits(handle, inode, extra_credits,
2799 NULL /* bh */,
2800 false /* dirty */,
2801 false /* block_csum */);
2802 if (error) {
2803 EXT4_ERROR_INODE(inode, "ensure credits (error %d)", error);
2804 goto cleanup;
2805 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002806
Tahsin Erdogandec214d2017-06-22 11:44:55 -04002807 if (ext4_has_feature_ea_inode(inode->i_sb) &&
2808 ext4_test_inode_state(inode, EXT4_STATE_XATTR)) {
Andreas Dilgere50e5122017-06-21 21:10:32 -04002809
Tahsin Erdogandec214d2017-06-22 11:44:55 -04002810 error = ext4_get_inode_loc(inode, &iloc);
Tahsin Erdogan65d30002017-06-21 22:24:38 -04002811 if (error) {
Tahsin Erdogandec214d2017-06-22 11:44:55 -04002812 EXT4_ERROR_INODE(inode, "inode loc (error %d)", error);
Andreas Dilgere50e5122017-06-21 21:10:32 -04002813 goto cleanup;
2814 }
Tahsin Erdogandec214d2017-06-22 11:44:55 -04002815
2816 error = ext4_journal_get_write_access(handle, iloc.bh);
2817 if (error) {
2818 EXT4_ERROR_INODE(inode, "write access (error %d)",
2819 error);
2820 goto cleanup;
2821 }
2822
2823 header = IHDR(inode, ext4_raw_inode(&iloc));
2824 if (header->h_magic == cpu_to_le32(EXT4_XATTR_MAGIC))
2825 ext4_xattr_inode_dec_ref_all(handle, inode, iloc.bh,
2826 IFIRST(header),
2827 false /* block_csum */,
2828 ea_inode_array,
2829 extra_credits,
2830 false /* skip_quota */);
Andreas Dilgere50e5122017-06-21 21:10:32 -04002831 }
2832
Tahsin Erdogandec214d2017-06-22 11:44:55 -04002833 if (EXT4_I(inode)->i_file_acl) {
2834 bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl);
2835 if (!bh) {
2836 EXT4_ERROR_INODE(inode, "block %llu read error",
2837 EXT4_I(inode)->i_file_acl);
2838 error = -EIO;
2839 goto cleanup;
2840 }
2841 error = ext4_xattr_check_block(inode, bh);
2842 if (error) {
2843 EXT4_ERROR_INODE(inode, "bad block %llu (error %d)",
2844 EXT4_I(inode)->i_file_acl, error);
2845 goto cleanup;
2846 }
2847
2848 if (ext4_has_feature_ea_inode(inode->i_sb)) {
2849 for (entry = BFIRST(bh); !IS_LAST_ENTRY(entry);
2850 entry = EXT4_XATTR_NEXT(entry))
2851 if (entry->e_value_inum)
2852 ext4_xattr_inode_free_quota(inode,
2853 le32_to_cpu(entry->e_value_size));
2854
2855 }
2856
2857 ext4_xattr_release_block(handle, inode, bh, ea_inode_array,
2858 extra_credits);
2859 /*
2860 * Update i_file_acl value in the same transaction that releases
2861 * block.
2862 */
2863 EXT4_I(inode)->i_file_acl = 0;
2864 error = ext4_mark_inode_dirty(handle, inode);
2865 if (error) {
2866 EXT4_ERROR_INODE(inode, "mark inode dirty (error %d)",
2867 error);
2868 goto cleanup;
2869 }
Tahsin Erdogan30a7eb92017-06-22 11:42:09 -04002870 }
Tahsin Erdogandec214d2017-06-22 11:44:55 -04002871 error = 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002872cleanup:
Tahsin Erdogan30a7eb92017-06-22 11:42:09 -04002873 brelse(iloc.bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002874 brelse(bh);
Andreas Dilgere50e5122017-06-21 21:10:32 -04002875 return error;
2876}
2877
Tahsin Erdogan0421a182017-06-22 10:26:31 -04002878void ext4_xattr_inode_array_free(struct ext4_xattr_inode_array *ea_inode_array)
Andreas Dilgere50e5122017-06-21 21:10:32 -04002879{
Tahsin Erdogandec214d2017-06-22 11:44:55 -04002880 int idx;
Andreas Dilgere50e5122017-06-21 21:10:32 -04002881
Tahsin Erdogan0421a182017-06-22 10:26:31 -04002882 if (ea_inode_array == NULL)
Andreas Dilgere50e5122017-06-21 21:10:32 -04002883 return;
2884
Tahsin Erdogandec214d2017-06-22 11:44:55 -04002885 for (idx = 0; idx < ea_inode_array->count; ++idx)
2886 iput(ea_inode_array->inodes[idx]);
Tahsin Erdogan0421a182017-06-22 10:26:31 -04002887 kfree(ea_inode_array);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002888}
2889
2890/*
Tahsin Erdogan47387402017-06-22 11:28:55 -04002891 * ext4_xattr_block_cache_insert()
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002892 *
Tahsin Erdogan47387402017-06-22 11:28:55 -04002893 * Create a new entry in the extended attribute block cache, and insert
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002894 * it unless such an entry is already in the cache.
2895 *
2896 * Returns 0, or a negative error number on failure.
2897 */
2898static void
Tahsin Erdogan47387402017-06-22 11:28:55 -04002899ext4_xattr_block_cache_insert(struct mb_cache *ea_block_cache,
2900 struct buffer_head *bh)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002901{
Andreas Gruenbacher6048c642016-02-22 22:44:04 -05002902 struct ext4_xattr_header *header = BHDR(bh);
2903 __u32 hash = le32_to_cpu(header->h_hash);
2904 int reusable = le32_to_cpu(header->h_refcount) <
2905 EXT4_XATTR_REFCOUNT_MAX;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002906 int error;
2907
Tahsin Erdogancdb7ee42017-06-22 11:55:14 -04002908 if (!ea_block_cache)
2909 return;
Tahsin Erdogan47387402017-06-22 11:28:55 -04002910 error = mb_cache_entry_create(ea_block_cache, GFP_NOFS, hash,
Andreas Gruenbacher6048c642016-02-22 22:44:04 -05002911 bh->b_blocknr, reusable);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002912 if (error) {
Jan Kara82939d72016-02-22 11:50:13 -05002913 if (error == -EBUSY)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002914 ea_bdebug(bh, "already in cache");
Jan Kara82939d72016-02-22 11:50:13 -05002915 } else
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002916 ea_bdebug(bh, "inserting [%x]", (int)hash);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002917}
2918
2919/*
Mingming Cao617ba132006-10-11 01:20:53 -07002920 * ext4_xattr_cmp()
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002921 *
2922 * Compare two extended attribute blocks for equality.
2923 *
2924 * Returns 0 if the blocks are equal, 1 if they differ, and
2925 * a negative error number on errors.
2926 */
2927static int
Mingming Cao617ba132006-10-11 01:20:53 -07002928ext4_xattr_cmp(struct ext4_xattr_header *header1,
2929 struct ext4_xattr_header *header2)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002930{
Mingming Cao617ba132006-10-11 01:20:53 -07002931 struct ext4_xattr_entry *entry1, *entry2;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002932
2933 entry1 = ENTRY(header1+1);
2934 entry2 = ENTRY(header2+1);
2935 while (!IS_LAST_ENTRY(entry1)) {
2936 if (IS_LAST_ENTRY(entry2))
2937 return 1;
2938 if (entry1->e_hash != entry2->e_hash ||
2939 entry1->e_name_index != entry2->e_name_index ||
2940 entry1->e_name_len != entry2->e_name_len ||
2941 entry1->e_value_size != entry2->e_value_size ||
Andreas Dilgere50e5122017-06-21 21:10:32 -04002942 entry1->e_value_inum != entry2->e_value_inum ||
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002943 memcmp(entry1->e_name, entry2->e_name, entry1->e_name_len))
2944 return 1;
Tahsin Erdogan7cec1912017-06-21 22:14:30 -04002945 if (!entry1->e_value_inum &&
2946 memcmp((char *)header1 + le16_to_cpu(entry1->e_value_offs),
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002947 (char *)header2 + le16_to_cpu(entry2->e_value_offs),
2948 le32_to_cpu(entry1->e_value_size)))
2949 return 1;
2950
Mingming Cao617ba132006-10-11 01:20:53 -07002951 entry1 = EXT4_XATTR_NEXT(entry1);
2952 entry2 = EXT4_XATTR_NEXT(entry2);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002953 }
2954 if (!IS_LAST_ENTRY(entry2))
2955 return 1;
2956 return 0;
2957}
2958
2959/*
Tahsin Erdogan47387402017-06-22 11:28:55 -04002960 * ext4_xattr_block_cache_find()
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002961 *
2962 * Find an identical extended attribute block.
2963 *
2964 * Returns a pointer to the block found, or NULL if such a block was
2965 * not found or an error occurred.
2966 */
2967static struct buffer_head *
Tahsin Erdogan47387402017-06-22 11:28:55 -04002968ext4_xattr_block_cache_find(struct inode *inode,
2969 struct ext4_xattr_header *header,
2970 struct mb_cache_entry **pce)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002971{
2972 __u32 hash = le32_to_cpu(header->h_hash);
Jan Kara7a2508e2016-02-22 22:35:22 -05002973 struct mb_cache_entry *ce;
Tahsin Erdogan47387402017-06-22 11:28:55 -04002974 struct mb_cache *ea_block_cache = EA_BLOCK_CACHE(inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002975
Tahsin Erdogancdb7ee42017-06-22 11:55:14 -04002976 if (!ea_block_cache)
2977 return NULL;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002978 if (!header->h_hash)
2979 return NULL; /* never share */
2980 ea_idebug(inode, "looking for cached blocks [%x]", (int)hash);
Tahsin Erdogan47387402017-06-22 11:28:55 -04002981 ce = mb_cache_entry_find_first(ea_block_cache, hash);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002982 while (ce) {
2983 struct buffer_head *bh;
2984
Tahsin Erdoganc07dfcb2017-06-22 10:29:53 -04002985 bh = sb_bread(inode->i_sb, ce->e_value);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002986 if (!bh) {
Theodore Ts'o24676da2010-05-16 21:00:00 -04002987 EXT4_ERROR_INODE(inode, "block %lu read error",
Tahsin Erdoganc07dfcb2017-06-22 10:29:53 -04002988 (unsigned long)ce->e_value);
Mingming Cao617ba132006-10-11 01:20:53 -07002989 } else if (ext4_xattr_cmp(header, BHDR(bh)) == 0) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002990 *pce = ce;
2991 return bh;
2992 }
2993 brelse(bh);
Tahsin Erdogan47387402017-06-22 11:28:55 -04002994 ce = mb_cache_entry_find_next(ea_block_cache, ce);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002995 }
2996 return NULL;
2997}
2998
2999#define NAME_HASH_SHIFT 5
3000#define VALUE_HASH_SHIFT 16
3001
3002/*
Mingming Cao617ba132006-10-11 01:20:53 -07003003 * ext4_xattr_hash_entry()
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003004 *
3005 * Compute the hash of an extended attribute.
3006 */
Tahsin Erdoganb9fc7612017-06-22 11:53:15 -04003007static __le32 ext4_xattr_hash_entry(char *name, size_t name_len, __le32 *value,
3008 size_t value_count)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003009{
3010 __u32 hash = 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003011
Tahsin Erdoganb9fc7612017-06-22 11:53:15 -04003012 while (name_len--) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003013 hash = (hash << NAME_HASH_SHIFT) ^
3014 (hash >> (8*sizeof(hash) - NAME_HASH_SHIFT)) ^
3015 *name++;
3016 }
Tahsin Erdoganb9fc7612017-06-22 11:53:15 -04003017 while (value_count--) {
3018 hash = (hash << VALUE_HASH_SHIFT) ^
3019 (hash >> (8*sizeof(hash) - VALUE_HASH_SHIFT)) ^
3020 le32_to_cpu(*value++);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003021 }
Tahsin Erdoganb9fc7612017-06-22 11:53:15 -04003022 return cpu_to_le32(hash);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003023}
3024
3025#undef NAME_HASH_SHIFT
3026#undef VALUE_HASH_SHIFT
3027
3028#define BLOCK_HASH_SHIFT 16
3029
3030/*
Mingming Cao617ba132006-10-11 01:20:53 -07003031 * ext4_xattr_rehash()
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003032 *
3033 * Re-compute the extended attribute hash value after an entry has changed.
3034 */
Tahsin Erdogandaf83282017-06-22 11:52:03 -04003035static void ext4_xattr_rehash(struct ext4_xattr_header *header)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003036{
Mingming Cao617ba132006-10-11 01:20:53 -07003037 struct ext4_xattr_entry *here;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003038 __u32 hash = 0;
3039
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003040 here = ENTRY(header+1);
3041 while (!IS_LAST_ENTRY(here)) {
3042 if (!here->e_hash) {
3043 /* Block is not shared if an entry's hash value == 0 */
3044 hash = 0;
3045 break;
3046 }
3047 hash = (hash << BLOCK_HASH_SHIFT) ^
3048 (hash >> (8*sizeof(hash) - BLOCK_HASH_SHIFT)) ^
3049 le32_to_cpu(here->e_hash);
Mingming Cao617ba132006-10-11 01:20:53 -07003050 here = EXT4_XATTR_NEXT(here);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003051 }
3052 header->h_hash = cpu_to_le32(hash);
3053}
3054
3055#undef BLOCK_HASH_SHIFT
3056
T Makphaibulchoke9c191f72014-03-18 19:24:49 -04003057#define HASH_BUCKET_BITS 10
3058
Jan Kara7a2508e2016-02-22 22:35:22 -05003059struct mb_cache *
Jan Kara82939d72016-02-22 11:50:13 -05003060ext4_xattr_create_cache(void)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003061{
Jan Kara7a2508e2016-02-22 22:35:22 -05003062 return mb_cache_create(HASH_BUCKET_BITS);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003063}
3064
Jan Kara7a2508e2016-02-22 22:35:22 -05003065void ext4_xattr_destroy_cache(struct mb_cache *cache)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003066{
T Makphaibulchoke9c191f72014-03-18 19:24:49 -04003067 if (cache)
Jan Kara7a2508e2016-02-22 22:35:22 -05003068 mb_cache_destroy(cache);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003069}
T Makphaibulchoke9c191f72014-03-18 19:24:49 -04003070