blob: 0441e055c8e8b734a86a31b2f2afcac1d43a013b [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
Dave Kleikampac27a0e2006-10-11 01:20:50 -070064# define ea_idebug(inode, f...) do { \
65 printk(KERN_DEBUG "inode %s:%lu: ", \
66 inode->i_sb->s_id, inode->i_ino); \
67 printk(f); \
68 printk("\n"); \
69 } while (0)
70# define ea_bdebug(bh, f...) do { \
Dmitry Monakhova1c6f0572015-04-13 16:31:37 +040071 printk(KERN_DEBUG "block %pg:%lu: ", \
72 bh->b_bdev, (unsigned long) bh->b_blocknr); \
Dave Kleikampac27a0e2006-10-11 01:20:50 -070073 printk(f); \
74 printk("\n"); \
75 } while (0)
76#else
Joe Perchesace36ad2012-03-19 23:11:43 -040077# define ea_idebug(inode, fmt, ...) no_printk(fmt, ##__VA_ARGS__)
78# define ea_bdebug(bh, fmt, ...) no_printk(fmt, ##__VA_ARGS__)
Dave Kleikampac27a0e2006-10-11 01:20:50 -070079#endif
80
Jan Kara7a2508e2016-02-22 22:35:22 -050081static void ext4_xattr_cache_insert(struct mb_cache *, struct buffer_head *);
Mingming Cao617ba132006-10-11 01:20:53 -070082static struct buffer_head *ext4_xattr_cache_find(struct inode *,
83 struct ext4_xattr_header *,
Jan Kara7a2508e2016-02-22 22:35:22 -050084 struct mb_cache_entry **);
Mingming Cao617ba132006-10-11 01:20:53 -070085static void ext4_xattr_rehash(struct ext4_xattr_header *,
86 struct ext4_xattr_entry *);
Christoph Hellwig431547b2009-11-13 09:52:56 +000087static int ext4_xattr_list(struct dentry *dentry, char *buffer,
Mingming Caod3a95d42008-04-17 10:38:59 -040088 size_t buffer_size);
Dave Kleikampac27a0e2006-10-11 01:20:50 -070089
Stephen Hemminger11e27522010-05-13 17:53:18 -070090static const struct xattr_handler *ext4_xattr_handler_map[] = {
Mingming Cao617ba132006-10-11 01:20:53 -070091 [EXT4_XATTR_INDEX_USER] = &ext4_xattr_user_handler,
Theodore Ts'o03010a32008-10-10 20:02:48 -040092#ifdef CONFIG_EXT4_FS_POSIX_ACL
Christoph Hellwig64e178a2013-12-20 05:16:44 -080093 [EXT4_XATTR_INDEX_POSIX_ACL_ACCESS] = &posix_acl_access_xattr_handler,
94 [EXT4_XATTR_INDEX_POSIX_ACL_DEFAULT] = &posix_acl_default_xattr_handler,
Dave Kleikampac27a0e2006-10-11 01:20:50 -070095#endif
Mingming Cao617ba132006-10-11 01:20:53 -070096 [EXT4_XATTR_INDEX_TRUSTED] = &ext4_xattr_trusted_handler,
Theodore Ts'o03010a32008-10-10 20:02:48 -040097#ifdef CONFIG_EXT4_FS_SECURITY
Mingming Cao617ba132006-10-11 01:20:53 -070098 [EXT4_XATTR_INDEX_SECURITY] = &ext4_xattr_security_handler,
Dave Kleikampac27a0e2006-10-11 01:20:50 -070099#endif
100};
101
Stephen Hemminger11e27522010-05-13 17:53:18 -0700102const struct xattr_handler *ext4_xattr_handlers[] = {
Mingming Cao617ba132006-10-11 01:20:53 -0700103 &ext4_xattr_user_handler,
104 &ext4_xattr_trusted_handler,
Theodore Ts'o03010a32008-10-10 20:02:48 -0400105#ifdef CONFIG_EXT4_FS_POSIX_ACL
Christoph Hellwig64e178a2013-12-20 05:16:44 -0800106 &posix_acl_access_xattr_handler,
107 &posix_acl_default_xattr_handler,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700108#endif
Theodore Ts'o03010a32008-10-10 20:02:48 -0400109#ifdef CONFIG_EXT4_FS_SECURITY
Mingming Cao617ba132006-10-11 01:20:53 -0700110 &ext4_xattr_security_handler,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700111#endif
112 NULL
113};
114
T Makphaibulchoke9c191f72014-03-18 19:24:49 -0400115#define EXT4_GET_MB_CACHE(inode) (((struct ext4_sb_info *) \
116 inode->i_sb->s_fs_info)->s_mb_cache)
117
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400118static __le32 ext4_xattr_block_csum(struct inode *inode,
119 sector_t block_nr,
120 struct ext4_xattr_header *hdr)
121{
122 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
Theodore Ts'od6a77102013-04-09 23:59:55 -0400123 __u32 csum;
124 __le32 save_csum;
125 __le64 dsk_block_nr = cpu_to_le64(block_nr);
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400126
Theodore Ts'od6a77102013-04-09 23:59:55 -0400127 save_csum = hdr->h_checksum;
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400128 hdr->h_checksum = 0;
Theodore Ts'od6a77102013-04-09 23:59:55 -0400129 csum = ext4_chksum(sbi, sbi->s_csum_seed, (__u8 *)&dsk_block_nr,
130 sizeof(dsk_block_nr));
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400131 csum = ext4_chksum(sbi, csum, (__u8 *)hdr,
132 EXT4_BLOCK_SIZE(inode->i_sb));
Tao Ma41eb70d2012-07-09 16:29:27 -0400133
Theodore Ts'od6a77102013-04-09 23:59:55 -0400134 hdr->h_checksum = save_csum;
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400135 return cpu_to_le32(csum);
136}
137
138static int ext4_xattr_block_csum_verify(struct inode *inode,
139 sector_t block_nr,
140 struct ext4_xattr_header *hdr)
141{
Dmitry Monakhov9aa5d322014-10-13 03:36:16 -0400142 if (ext4_has_metadata_csum(inode->i_sb) &&
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400143 (hdr->h_checksum != ext4_xattr_block_csum(inode, block_nr, hdr)))
144 return 0;
145 return 1;
146}
147
148static void ext4_xattr_block_csum_set(struct inode *inode,
149 sector_t block_nr,
150 struct ext4_xattr_header *hdr)
151{
Dmitry Monakhov9aa5d322014-10-13 03:36:16 -0400152 if (!ext4_has_metadata_csum(inode->i_sb))
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400153 return;
154
155 hdr->h_checksum = ext4_xattr_block_csum(inode, block_nr, hdr);
156}
157
158static inline int ext4_handle_dirty_xattr_block(handle_t *handle,
159 struct inode *inode,
160 struct buffer_head *bh)
161{
162 ext4_xattr_block_csum_set(inode, bh->b_blocknr, BHDR(bh));
163 return ext4_handle_dirty_metadata(handle, inode, bh);
164}
165
Stephen Hemminger11e27522010-05-13 17:53:18 -0700166static inline const struct xattr_handler *
Mingming Cao617ba132006-10-11 01:20:53 -0700167ext4_xattr_handler(int name_index)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700168{
Stephen Hemminger11e27522010-05-13 17:53:18 -0700169 const struct xattr_handler *handler = NULL;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700170
Mingming Cao617ba132006-10-11 01:20:53 -0700171 if (name_index > 0 && name_index < ARRAY_SIZE(ext4_xattr_handler_map))
172 handler = ext4_xattr_handler_map[name_index];
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700173 return handler;
174}
175
176/*
177 * Inode operation listxattr()
178 *
David Howells2b0143b2015-03-17 22:25:59 +0000179 * d_inode(dentry)->i_mutex: don't care
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700180 */
181ssize_t
Mingming Cao617ba132006-10-11 01:20:53 -0700182ext4_listxattr(struct dentry *dentry, char *buffer, size_t size)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700183{
Christoph Hellwig431547b2009-11-13 09:52:56 +0000184 return ext4_xattr_list(dentry, buffer, size);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700185}
186
187static int
Darrick J. Wonga0626e752014-09-16 14:34:59 -0400188ext4_xattr_check_names(struct ext4_xattr_entry *entry, void *end,
189 void *value_start)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700190{
Darrick J. Wonga0626e752014-09-16 14:34:59 -0400191 struct ext4_xattr_entry *e = entry;
192
193 while (!IS_LAST_ENTRY(e)) {
194 struct ext4_xattr_entry *next = EXT4_XATTR_NEXT(e);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700195 if ((void *)next >= end)
Darrick J. Wong6a797d22015-10-17 16:16:04 -0400196 return -EFSCORRUPTED;
Darrick J. Wonga0626e752014-09-16 14:34:59 -0400197 e = next;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700198 }
Darrick J. Wonga0626e752014-09-16 14:34:59 -0400199
200 while (!IS_LAST_ENTRY(entry)) {
201 if (entry->e_value_size != 0 &&
202 (value_start + le16_to_cpu(entry->e_value_offs) <
203 (void *)e + sizeof(__u32) ||
204 value_start + le16_to_cpu(entry->e_value_offs) +
205 le32_to_cpu(entry->e_value_size) > end))
Darrick J. Wong6a797d22015-10-17 16:16:04 -0400206 return -EFSCORRUPTED;
Darrick J. Wonga0626e752014-09-16 14:34:59 -0400207 entry = EXT4_XATTR_NEXT(entry);
208 }
209
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700210 return 0;
211}
212
213static inline int
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400214ext4_xattr_check_block(struct inode *inode, struct buffer_head *bh)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700215{
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400216 int error;
217
218 if (buffer_verified(bh))
219 return 0;
220
Mingming Cao617ba132006-10-11 01:20:53 -0700221 if (BHDR(bh)->h_magic != cpu_to_le32(EXT4_XATTR_MAGIC) ||
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700222 BHDR(bh)->h_blocks != cpu_to_le32(1))
Darrick J. Wong6a797d22015-10-17 16:16:04 -0400223 return -EFSCORRUPTED;
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400224 if (!ext4_xattr_block_csum_verify(inode, bh->b_blocknr, BHDR(bh)))
Darrick J. Wong6a797d22015-10-17 16:16:04 -0400225 return -EFSBADCRC;
Darrick J. Wonga0626e752014-09-16 14:34:59 -0400226 error = ext4_xattr_check_names(BFIRST(bh), bh->b_data + bh->b_size,
227 bh->b_data);
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400228 if (!error)
229 set_buffer_verified(bh);
230 return error;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700231}
232
233static inline int
Mingming Cao617ba132006-10-11 01:20:53 -0700234ext4_xattr_check_entry(struct ext4_xattr_entry *entry, size_t size)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700235{
236 size_t value_size = le32_to_cpu(entry->e_value_size);
237
238 if (entry->e_value_block != 0 || value_size > size ||
239 le16_to_cpu(entry->e_value_offs) + value_size > size)
Darrick J. Wong6a797d22015-10-17 16:16:04 -0400240 return -EFSCORRUPTED;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700241 return 0;
242}
243
244static int
Mingming Cao617ba132006-10-11 01:20:53 -0700245ext4_xattr_find_entry(struct ext4_xattr_entry **pentry, int name_index,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700246 const char *name, size_t size, int sorted)
247{
Mingming Cao617ba132006-10-11 01:20:53 -0700248 struct ext4_xattr_entry *entry;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700249 size_t name_len;
250 int cmp = 1;
251
252 if (name == NULL)
253 return -EINVAL;
254 name_len = strlen(name);
255 entry = *pentry;
Mingming Cao617ba132006-10-11 01:20:53 -0700256 for (; !IS_LAST_ENTRY(entry); entry = EXT4_XATTR_NEXT(entry)) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700257 cmp = name_index - entry->e_name_index;
258 if (!cmp)
259 cmp = name_len - entry->e_name_len;
260 if (!cmp)
261 cmp = memcmp(name, entry->e_name, name_len);
262 if (cmp <= 0 && (sorted || cmp == 0))
263 break;
264 }
265 *pentry = entry;
Mingming Cao617ba132006-10-11 01:20:53 -0700266 if (!cmp && ext4_xattr_check_entry(entry, size))
Darrick J. Wong6a797d22015-10-17 16:16:04 -0400267 return -EFSCORRUPTED;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700268 return cmp ? -ENODATA : 0;
269}
270
271static int
Mingming Cao617ba132006-10-11 01:20:53 -0700272ext4_xattr_block_get(struct inode *inode, int name_index, const char *name,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700273 void *buffer, size_t buffer_size)
274{
275 struct buffer_head *bh = NULL;
Mingming Cao617ba132006-10-11 01:20:53 -0700276 struct ext4_xattr_entry *entry;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700277 size_t size;
278 int error;
Jan Kara7a2508e2016-02-22 22:35:22 -0500279 struct mb_cache *ext4_mb_cache = EXT4_GET_MB_CACHE(inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700280
281 ea_idebug(inode, "name=%d.%s, buffer=%p, buffer_size=%ld",
282 name_index, name, buffer, (long)buffer_size);
283
284 error = -ENODATA;
Mingming Cao617ba132006-10-11 01:20:53 -0700285 if (!EXT4_I(inode)->i_file_acl)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700286 goto cleanup;
Joe Perchesace36ad2012-03-19 23:11:43 -0400287 ea_idebug(inode, "reading block %llu",
288 (unsigned long long)EXT4_I(inode)->i_file_acl);
Mingming Cao617ba132006-10-11 01:20:53 -0700289 bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700290 if (!bh)
291 goto cleanup;
292 ea_bdebug(bh, "b_count=%d, refcount=%d",
293 atomic_read(&(bh->b_count)), le32_to_cpu(BHDR(bh)->h_refcount));
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400294 if (ext4_xattr_check_block(inode, bh)) {
Eric Sandeen12062dd2010-02-15 14:19:27 -0500295bad_block:
Theodore Ts'o24676da2010-05-16 21:00:00 -0400296 EXT4_ERROR_INODE(inode, "bad block %llu",
297 EXT4_I(inode)->i_file_acl);
Darrick J. Wong6a797d22015-10-17 16:16:04 -0400298 error = -EFSCORRUPTED;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700299 goto cleanup;
300 }
T Makphaibulchoke9c191f72014-03-18 19:24:49 -0400301 ext4_xattr_cache_insert(ext4_mb_cache, bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700302 entry = BFIRST(bh);
Mingming Cao617ba132006-10-11 01:20:53 -0700303 error = ext4_xattr_find_entry(&entry, name_index, name, bh->b_size, 1);
Darrick J. Wong6a797d22015-10-17 16:16:04 -0400304 if (error == -EFSCORRUPTED)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700305 goto bad_block;
306 if (error)
307 goto cleanup;
308 size = le32_to_cpu(entry->e_value_size);
309 if (buffer) {
310 error = -ERANGE;
311 if (size > buffer_size)
312 goto cleanup;
313 memcpy(buffer, bh->b_data + le16_to_cpu(entry->e_value_offs),
314 size);
315 }
316 error = size;
317
318cleanup:
319 brelse(bh);
320 return error;
321}
322
Tao Ma879b3822012-12-05 10:28:46 -0500323int
Mingming Cao617ba132006-10-11 01:20:53 -0700324ext4_xattr_ibody_get(struct inode *inode, int name_index, const char *name,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700325 void *buffer, size_t buffer_size)
326{
Mingming Cao617ba132006-10-11 01:20:53 -0700327 struct ext4_xattr_ibody_header *header;
328 struct ext4_xattr_entry *entry;
329 struct ext4_inode *raw_inode;
330 struct ext4_iloc iloc;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700331 size_t size;
332 void *end;
333 int error;
334
Theodore Ts'o19f5fb72010-01-24 14:34:07 -0500335 if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR))
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700336 return -ENODATA;
Mingming Cao617ba132006-10-11 01:20:53 -0700337 error = ext4_get_inode_loc(inode, &iloc);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700338 if (error)
339 return error;
Mingming Cao617ba132006-10-11 01:20:53 -0700340 raw_inode = ext4_raw_inode(&iloc);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700341 header = IHDR(inode, raw_inode);
342 entry = IFIRST(header);
Mingming Cao617ba132006-10-11 01:20:53 -0700343 end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
Darrick J. Wonga0626e752014-09-16 14:34:59 -0400344 error = ext4_xattr_check_names(entry, end, entry);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700345 if (error)
346 goto cleanup;
Mingming Cao617ba132006-10-11 01:20:53 -0700347 error = ext4_xattr_find_entry(&entry, name_index, name,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700348 end - (void *)entry, 0);
349 if (error)
350 goto cleanup;
351 size = le32_to_cpu(entry->e_value_size);
352 if (buffer) {
353 error = -ERANGE;
354 if (size > buffer_size)
355 goto cleanup;
356 memcpy(buffer, (void *)IFIRST(header) +
357 le16_to_cpu(entry->e_value_offs), size);
358 }
359 error = size;
360
361cleanup:
362 brelse(iloc.bh);
363 return error;
364}
365
366/*
Mingming Cao617ba132006-10-11 01:20:53 -0700367 * ext4_xattr_get()
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700368 *
369 * Copy an extended attribute into the buffer
370 * provided, or compute the buffer size required.
371 * Buffer is NULL to compute the size of the buffer required.
372 *
373 * Returns a negative error number on failure, or the number of bytes
374 * used / required on success.
375 */
376int
Mingming Cao617ba132006-10-11 01:20:53 -0700377ext4_xattr_get(struct inode *inode, int name_index, const char *name,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700378 void *buffer, size_t buffer_size)
379{
380 int error;
381
Zhang Zhen230b8c1a2014-05-12 09:57:59 -0400382 if (strlen(name) > 255)
383 return -ERANGE;
384
Mingming Cao617ba132006-10-11 01:20:53 -0700385 down_read(&EXT4_I(inode)->xattr_sem);
386 error = ext4_xattr_ibody_get(inode, name_index, name, buffer,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700387 buffer_size);
388 if (error == -ENODATA)
Mingming Cao617ba132006-10-11 01:20:53 -0700389 error = ext4_xattr_block_get(inode, name_index, name, buffer,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700390 buffer_size);
Mingming Cao617ba132006-10-11 01:20:53 -0700391 up_read(&EXT4_I(inode)->xattr_sem);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700392 return error;
393}
394
395static int
Christoph Hellwig431547b2009-11-13 09:52:56 +0000396ext4_xattr_list_entries(struct dentry *dentry, struct ext4_xattr_entry *entry,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700397 char *buffer, size_t buffer_size)
398{
399 size_t rest = buffer_size;
400
Mingming Cao617ba132006-10-11 01:20:53 -0700401 for (; !IS_LAST_ENTRY(entry); entry = EXT4_XATTR_NEXT(entry)) {
Stephen Hemminger11e27522010-05-13 17:53:18 -0700402 const struct xattr_handler *handler =
Mingming Cao617ba132006-10-11 01:20:53 -0700403 ext4_xattr_handler(entry->e_name_index);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700404
Andreas Gruenbacher764a5c62015-12-02 14:44:43 +0100405 if (handler && (!handler->list || handler->list(dentry))) {
406 const char *prefix = handler->prefix ?: handler->name;
407 size_t prefix_len = strlen(prefix);
408 size_t size = prefix_len + entry->e_name_len + 1;
409
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700410 if (buffer) {
411 if (size > rest)
412 return -ERANGE;
Andreas Gruenbacher764a5c62015-12-02 14:44:43 +0100413 memcpy(buffer, prefix, prefix_len);
414 buffer += prefix_len;
415 memcpy(buffer, entry->e_name, entry->e_name_len);
416 buffer += entry->e_name_len;
417 *buffer++ = 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700418 }
419 rest -= size;
420 }
421 }
Andreas Gruenbacher764a5c62015-12-02 14:44:43 +0100422 return buffer_size - rest; /* total size */
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700423}
424
425static int
Christoph Hellwig431547b2009-11-13 09:52:56 +0000426ext4_xattr_block_list(struct dentry *dentry, char *buffer, size_t buffer_size)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700427{
David Howells2b0143b2015-03-17 22:25:59 +0000428 struct inode *inode = d_inode(dentry);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700429 struct buffer_head *bh = NULL;
430 int error;
Jan Kara7a2508e2016-02-22 22:35:22 -0500431 struct mb_cache *ext4_mb_cache = EXT4_GET_MB_CACHE(inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700432
433 ea_idebug(inode, "buffer=%p, buffer_size=%ld",
434 buffer, (long)buffer_size);
435
436 error = 0;
Mingming Cao617ba132006-10-11 01:20:53 -0700437 if (!EXT4_I(inode)->i_file_acl)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700438 goto cleanup;
Joe Perchesace36ad2012-03-19 23:11:43 -0400439 ea_idebug(inode, "reading block %llu",
440 (unsigned long long)EXT4_I(inode)->i_file_acl);
Mingming Cao617ba132006-10-11 01:20:53 -0700441 bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700442 error = -EIO;
443 if (!bh)
444 goto cleanup;
445 ea_bdebug(bh, "b_count=%d, refcount=%d",
446 atomic_read(&(bh->b_count)), le32_to_cpu(BHDR(bh)->h_refcount));
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400447 if (ext4_xattr_check_block(inode, bh)) {
Theodore Ts'o24676da2010-05-16 21:00:00 -0400448 EXT4_ERROR_INODE(inode, "bad block %llu",
449 EXT4_I(inode)->i_file_acl);
Darrick J. Wong6a797d22015-10-17 16:16:04 -0400450 error = -EFSCORRUPTED;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700451 goto cleanup;
452 }
T Makphaibulchoke9c191f72014-03-18 19:24:49 -0400453 ext4_xattr_cache_insert(ext4_mb_cache, bh);
Christoph Hellwig431547b2009-11-13 09:52:56 +0000454 error = ext4_xattr_list_entries(dentry, BFIRST(bh), buffer, buffer_size);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700455
456cleanup:
457 brelse(bh);
458
459 return error;
460}
461
462static int
Christoph Hellwig431547b2009-11-13 09:52:56 +0000463ext4_xattr_ibody_list(struct dentry *dentry, char *buffer, size_t buffer_size)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700464{
David Howells2b0143b2015-03-17 22:25:59 +0000465 struct inode *inode = d_inode(dentry);
Mingming Cao617ba132006-10-11 01:20:53 -0700466 struct ext4_xattr_ibody_header *header;
467 struct ext4_inode *raw_inode;
468 struct ext4_iloc iloc;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700469 void *end;
470 int error;
471
Theodore Ts'o19f5fb72010-01-24 14:34:07 -0500472 if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR))
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700473 return 0;
Mingming Cao617ba132006-10-11 01:20:53 -0700474 error = ext4_get_inode_loc(inode, &iloc);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700475 if (error)
476 return error;
Mingming Cao617ba132006-10-11 01:20:53 -0700477 raw_inode = ext4_raw_inode(&iloc);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700478 header = IHDR(inode, raw_inode);
Mingming Cao617ba132006-10-11 01:20:53 -0700479 end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
Darrick J. Wonga0626e752014-09-16 14:34:59 -0400480 error = ext4_xattr_check_names(IFIRST(header), end, IFIRST(header));
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700481 if (error)
482 goto cleanup;
Christoph Hellwig431547b2009-11-13 09:52:56 +0000483 error = ext4_xattr_list_entries(dentry, IFIRST(header),
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700484 buffer, buffer_size);
485
486cleanup:
487 brelse(iloc.bh);
488 return error;
489}
490
491/*
Mingming Cao617ba132006-10-11 01:20:53 -0700492 * ext4_xattr_list()
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700493 *
494 * Copy a list of attribute names into the buffer
495 * provided, or compute the buffer size required.
496 * Buffer is NULL to compute the size of the buffer required.
497 *
498 * Returns a negative error number on failure, or the number of bytes
499 * used / required on success.
500 */
Mingming Caod3a95d42008-04-17 10:38:59 -0400501static int
Christoph Hellwig431547b2009-11-13 09:52:56 +0000502ext4_xattr_list(struct dentry *dentry, char *buffer, size_t buffer_size)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700503{
Theodore Ts'oeaeef862011-01-10 12:10:07 -0500504 int ret, ret2;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700505
David Howells2b0143b2015-03-17 22:25:59 +0000506 down_read(&EXT4_I(d_inode(dentry))->xattr_sem);
Theodore Ts'oeaeef862011-01-10 12:10:07 -0500507 ret = ret2 = ext4_xattr_ibody_list(dentry, buffer, buffer_size);
508 if (ret < 0)
509 goto errout;
510 if (buffer) {
511 buffer += ret;
512 buffer_size -= ret;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700513 }
Theodore Ts'oeaeef862011-01-10 12:10:07 -0500514 ret = ext4_xattr_block_list(dentry, buffer, buffer_size);
515 if (ret < 0)
516 goto errout;
517 ret += ret2;
518errout:
David Howells2b0143b2015-03-17 22:25:59 +0000519 up_read(&EXT4_I(d_inode(dentry))->xattr_sem);
Theodore Ts'oeaeef862011-01-10 12:10:07 -0500520 return ret;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700521}
522
523/*
Mingming Cao617ba132006-10-11 01:20:53 -0700524 * If the EXT4_FEATURE_COMPAT_EXT_ATTR feature of this file system is
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700525 * not set, set it.
526 */
Mingming Cao617ba132006-10-11 01:20:53 -0700527static void ext4_xattr_update_super_block(handle_t *handle,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700528 struct super_block *sb)
529{
Darrick J. Wonge2b911c2015-10-17 16:18:43 -0400530 if (ext4_has_feature_xattr(sb))
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700531 return;
532
liang xie5d601252014-05-12 22:06:43 -0400533 BUFFER_TRACE(EXT4_SB(sb)->s_sbh, "get_write_access");
Mingming Cao617ba132006-10-11 01:20:53 -0700534 if (ext4_journal_get_write_access(handle, EXT4_SB(sb)->s_sbh) == 0) {
Darrick J. Wonge2b911c2015-10-17 16:18:43 -0400535 ext4_set_feature_xattr(sb);
Theodore Ts'oa0375152010-06-11 23:14:04 -0400536 ext4_handle_dirty_super(handle, sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700537 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700538}
539
540/*
Jan Karaec4cb1a2014-04-07 10:54:21 -0400541 * Release the xattr block BH: If the reference count is > 1, decrement it;
542 * otherwise free the block.
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700543 */
544static void
Mingming Cao617ba132006-10-11 01:20:53 -0700545ext4_xattr_release_block(handle_t *handle, struct inode *inode,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700546 struct buffer_head *bh)
547{
Andreas Gruenbacher6048c642016-02-22 22:44:04 -0500548 struct mb_cache *ext4_mb_cache = EXT4_GET_MB_CACHE(inode);
549 u32 hash, ref;
Mingming Cao8a2bfdc2007-02-28 20:13:35 -0800550 int error = 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700551
liang xie5d601252014-05-12 22:06:43 -0400552 BUFFER_TRACE(bh, "get_write_access");
Mingming Cao8a2bfdc2007-02-28 20:13:35 -0800553 error = ext4_journal_get_write_access(handle, bh);
554 if (error)
555 goto out;
556
557 lock_buffer(bh);
Andreas Gruenbacher6048c642016-02-22 22:44:04 -0500558 hash = le32_to_cpu(BHDR(bh)->h_hash);
559 ref = le32_to_cpu(BHDR(bh)->h_refcount);
560 if (ref == 1) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700561 ea_bdebug(bh, "refcount now=0; freeing");
Jan Kara82939d72016-02-22 11:50:13 -0500562 /*
563 * This must happen under buffer lock for
564 * ext4_xattr_block_set() to reliably detect freed block
565 */
Andreas Gruenbacher6048c642016-02-22 22:44:04 -0500566 mb_cache_entry_delete_block(ext4_mb_cache, hash, bh->b_blocknr);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700567 get_bh(bh);
Jan Karaec4cb1a2014-04-07 10:54:21 -0400568 unlock_buffer(bh);
Theodore Ts'oe6362602009-11-23 07:17:05 -0500569 ext4_free_blocks(handle, inode, bh, 0, 1,
570 EXT4_FREE_BLOCKS_METADATA |
571 EXT4_FREE_BLOCKS_FORGET);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700572 } else {
Andreas Gruenbacher6048c642016-02-22 22:44:04 -0500573 ref--;
574 BHDR(bh)->h_refcount = cpu_to_le32(ref);
575 if (ref == EXT4_XATTR_REFCOUNT_MAX - 1) {
576 struct mb_cache_entry *ce;
577
578 ce = mb_cache_entry_get(ext4_mb_cache, hash,
579 bh->b_blocknr);
580 if (ce) {
581 ce->e_reusable = 1;
582 mb_cache_entry_put(ext4_mb_cache, ce);
583 }
584 }
585
Jan Karaec4cb1a2014-04-07 10:54:21 -0400586 /*
587 * Beware of this ugliness: Releasing of xattr block references
588 * from different inodes can race and so we have to protect
589 * from a race where someone else frees the block (and releases
590 * its journal_head) before we are done dirtying the buffer. In
591 * nojournal mode this race is harmless and we actually cannot
592 * call ext4_handle_dirty_xattr_block() with locked buffer as
593 * that function can call sync_dirty_buffer() so for that case
594 * we handle the dirtying after unlocking the buffer.
595 */
596 if (ext4_handle_valid(handle))
597 error = ext4_handle_dirty_xattr_block(handle, inode,
598 bh);
Eric Sandeenc1bb05a2012-02-20 23:06:18 -0500599 unlock_buffer(bh);
Jan Karaec4cb1a2014-04-07 10:54:21 -0400600 if (!ext4_handle_valid(handle))
601 error = ext4_handle_dirty_xattr_block(handle, inode,
602 bh);
Mingming Cao8a2bfdc2007-02-28 20:13:35 -0800603 if (IS_SYNC(inode))
Frank Mayhar03901312009-01-07 00:06:22 -0500604 ext4_handle_sync(handle);
Lukas Czerner1231b3a2013-02-18 12:12:07 -0500605 dquot_free_block(inode, EXT4_C2B(EXT4_SB(inode->i_sb), 1));
Mingming Cao8a2bfdc2007-02-28 20:13:35 -0800606 ea_bdebug(bh, "refcount now=%d; releasing",
607 le32_to_cpu(BHDR(bh)->h_refcount));
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700608 }
Mingming Cao8a2bfdc2007-02-28 20:13:35 -0800609out:
610 ext4_std_error(inode->i_sb, error);
611 return;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700612}
613
Kalpak Shah6dd4ee72007-07-18 09:19:57 -0400614/*
615 * Find the available free space for EAs. This also returns the total number of
616 * bytes used by EA entries.
617 */
618static size_t ext4_xattr_free_space(struct ext4_xattr_entry *last,
619 size_t *min_offs, void *base, int *total)
620{
621 for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
Kalpak Shah6dd4ee72007-07-18 09:19:57 -0400622 if (!last->e_value_block && last->e_value_size) {
623 size_t offs = le16_to_cpu(last->e_value_offs);
624 if (offs < *min_offs)
625 *min_offs = offs;
626 }
Theodore Ts'o7b1b2c12014-02-19 20:15:21 -0500627 if (total)
628 *total += EXT4_XATTR_LEN(last->e_name_len);
Kalpak Shah6dd4ee72007-07-18 09:19:57 -0400629 }
630 return (*min_offs - ((void *)last - base) - sizeof(__u32));
631}
632
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700633static int
Mingming Cao617ba132006-10-11 01:20:53 -0700634ext4_xattr_set_entry(struct ext4_xattr_info *i, struct ext4_xattr_search *s)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700635{
Mingming Cao617ba132006-10-11 01:20:53 -0700636 struct ext4_xattr_entry *last;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700637 size_t free, min_offs = s->end - s->base, name_len = strlen(i->name);
638
639 /* Compute min_offs and last. */
640 last = s->first;
Mingming Cao617ba132006-10-11 01:20:53 -0700641 for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700642 if (!last->e_value_block && last->e_value_size) {
643 size_t offs = le16_to_cpu(last->e_value_offs);
644 if (offs < min_offs)
645 min_offs = offs;
646 }
647 }
648 free = min_offs - ((void *)last - s->base) - sizeof(__u32);
649 if (!s->not_found) {
650 if (!s->here->e_value_block && s->here->e_value_size) {
651 size_t size = le32_to_cpu(s->here->e_value_size);
Mingming Cao617ba132006-10-11 01:20:53 -0700652 free += EXT4_XATTR_SIZE(size);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700653 }
Mingming Cao617ba132006-10-11 01:20:53 -0700654 free += EXT4_XATTR_LEN(name_len);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700655 }
656 if (i->value) {
Wei Yuan5f80f622015-04-02 23:50:48 -0400657 if (free < EXT4_XATTR_LEN(name_len) +
Mingming Cao617ba132006-10-11 01:20:53 -0700658 EXT4_XATTR_SIZE(i->value_len))
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700659 return -ENOSPC;
660 }
661
662 if (i->value && s->not_found) {
663 /* Insert the new name. */
Mingming Cao617ba132006-10-11 01:20:53 -0700664 size_t size = EXT4_XATTR_LEN(name_len);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700665 size_t rest = (void *)last - (void *)s->here + sizeof(__u32);
666 memmove((void *)s->here + size, s->here, rest);
667 memset(s->here, 0, size);
668 s->here->e_name_index = i->name_index;
669 s->here->e_name_len = name_len;
670 memcpy(s->here->e_name, i->name, name_len);
671 } else {
672 if (!s->here->e_value_block && s->here->e_value_size) {
673 void *first_val = s->base + min_offs;
674 size_t offs = le16_to_cpu(s->here->e_value_offs);
675 void *val = s->base + offs;
Mingming Cao617ba132006-10-11 01:20:53 -0700676 size_t size = EXT4_XATTR_SIZE(
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700677 le32_to_cpu(s->here->e_value_size));
678
Mingming Cao617ba132006-10-11 01:20:53 -0700679 if (i->value && size == EXT4_XATTR_SIZE(i->value_len)) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700680 /* The old and the new value have the same
681 size. Just replace. */
682 s->here->e_value_size =
683 cpu_to_le32(i->value_len);
Theodore Ts'obd9926e2012-12-11 03:31:49 -0500684 if (i->value == EXT4_ZERO_XATTR_VALUE) {
685 memset(val, 0, size);
686 } else {
687 /* Clear pad bytes first. */
688 memset(val + size - EXT4_XATTR_PAD, 0,
689 EXT4_XATTR_PAD);
690 memcpy(val, i->value, i->value_len);
691 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700692 return 0;
693 }
694
695 /* Remove the old value. */
696 memmove(first_val + size, first_val, val - first_val);
697 memset(first_val, 0, size);
698 s->here->e_value_size = 0;
699 s->here->e_value_offs = 0;
700 min_offs += size;
701
702 /* Adjust all value offsets. */
703 last = s->first;
704 while (!IS_LAST_ENTRY(last)) {
705 size_t o = le16_to_cpu(last->e_value_offs);
706 if (!last->e_value_block &&
707 last->e_value_size && o < offs)
708 last->e_value_offs =
709 cpu_to_le16(o + size);
Mingming Cao617ba132006-10-11 01:20:53 -0700710 last = EXT4_XATTR_NEXT(last);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700711 }
712 }
713 if (!i->value) {
714 /* Remove the old name. */
Mingming Cao617ba132006-10-11 01:20:53 -0700715 size_t size = EXT4_XATTR_LEN(name_len);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700716 last = ENTRY((void *)last - size);
717 memmove(s->here, (void *)s->here + size,
718 (void *)last - (void *)s->here + sizeof(__u32));
719 memset(last, 0, size);
720 }
721 }
722
723 if (i->value) {
724 /* Insert the new value. */
725 s->here->e_value_size = cpu_to_le32(i->value_len);
726 if (i->value_len) {
Mingming Cao617ba132006-10-11 01:20:53 -0700727 size_t size = EXT4_XATTR_SIZE(i->value_len);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700728 void *val = s->base + min_offs - size;
729 s->here->e_value_offs = cpu_to_le16(min_offs - size);
Theodore Ts'obd9926e2012-12-11 03:31:49 -0500730 if (i->value == EXT4_ZERO_XATTR_VALUE) {
731 memset(val, 0, size);
732 } else {
733 /* Clear the pad bytes first. */
734 memset(val + size - EXT4_XATTR_PAD, 0,
735 EXT4_XATTR_PAD);
736 memcpy(val, i->value, i->value_len);
737 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700738 }
739 }
740 return 0;
741}
742
Mingming Cao617ba132006-10-11 01:20:53 -0700743struct ext4_xattr_block_find {
744 struct ext4_xattr_search s;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700745 struct buffer_head *bh;
746};
747
748static int
Mingming Cao617ba132006-10-11 01:20:53 -0700749ext4_xattr_block_find(struct inode *inode, struct ext4_xattr_info *i,
750 struct ext4_xattr_block_find *bs)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700751{
752 struct super_block *sb = inode->i_sb;
753 int error;
754
755 ea_idebug(inode, "name=%d.%s, value=%p, value_len=%ld",
756 i->name_index, i->name, i->value, (long)i->value_len);
757
Mingming Cao617ba132006-10-11 01:20:53 -0700758 if (EXT4_I(inode)->i_file_acl) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700759 /* The inode already has an extended attribute block. */
Mingming Cao617ba132006-10-11 01:20:53 -0700760 bs->bh = sb_bread(sb, EXT4_I(inode)->i_file_acl);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700761 error = -EIO;
762 if (!bs->bh)
763 goto cleanup;
764 ea_bdebug(bs->bh, "b_count=%d, refcount=%d",
765 atomic_read(&(bs->bh->b_count)),
766 le32_to_cpu(BHDR(bs->bh)->h_refcount));
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400767 if (ext4_xattr_check_block(inode, bs->bh)) {
Theodore Ts'o24676da2010-05-16 21:00:00 -0400768 EXT4_ERROR_INODE(inode, "bad block %llu",
769 EXT4_I(inode)->i_file_acl);
Darrick J. Wong6a797d22015-10-17 16:16:04 -0400770 error = -EFSCORRUPTED;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700771 goto cleanup;
772 }
773 /* Find the named attribute. */
774 bs->s.base = BHDR(bs->bh);
775 bs->s.first = BFIRST(bs->bh);
776 bs->s.end = bs->bh->b_data + bs->bh->b_size;
777 bs->s.here = bs->s.first;
Mingming Cao617ba132006-10-11 01:20:53 -0700778 error = ext4_xattr_find_entry(&bs->s.here, i->name_index,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700779 i->name, bs->bh->b_size, 1);
780 if (error && error != -ENODATA)
781 goto cleanup;
782 bs->s.not_found = error;
783 }
784 error = 0;
785
786cleanup:
787 return error;
788}
789
790static int
Mingming Cao617ba132006-10-11 01:20:53 -0700791ext4_xattr_block_set(handle_t *handle, struct inode *inode,
792 struct ext4_xattr_info *i,
793 struct ext4_xattr_block_find *bs)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700794{
795 struct super_block *sb = inode->i_sb;
796 struct buffer_head *new_bh = NULL;
Mingming Cao617ba132006-10-11 01:20:53 -0700797 struct ext4_xattr_search *s = &bs->s;
Jan Kara7a2508e2016-02-22 22:35:22 -0500798 struct mb_cache_entry *ce = NULL;
Mingming Cao8a2bfdc2007-02-28 20:13:35 -0800799 int error = 0;
Jan Kara7a2508e2016-02-22 22:35:22 -0500800 struct mb_cache *ext4_mb_cache = EXT4_GET_MB_CACHE(inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700801
Mingming Cao617ba132006-10-11 01:20:53 -0700802#define header(x) ((struct ext4_xattr_header *)(x))
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700803
804 if (i->value && i->value_len > sb->s_blocksize)
805 return -ENOSPC;
806 if (s->base) {
liang xie5d601252014-05-12 22:06:43 -0400807 BUFFER_TRACE(bs->bh, "get_write_access");
Mingming Cao8a2bfdc2007-02-28 20:13:35 -0800808 error = ext4_journal_get_write_access(handle, bs->bh);
809 if (error)
810 goto cleanup;
811 lock_buffer(bs->bh);
812
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700813 if (header(s->base)->h_refcount == cpu_to_le32(1)) {
Jan Kara82939d72016-02-22 11:50:13 -0500814 __u32 hash = le32_to_cpu(BHDR(bs->bh)->h_hash);
815
816 /*
817 * This must happen under buffer lock for
818 * ext4_xattr_block_set() to reliably detect modified
819 * block
820 */
Jan Kara7a2508e2016-02-22 22:35:22 -0500821 mb_cache_entry_delete_block(ext4_mb_cache, hash,
822 bs->bh->b_blocknr);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700823 ea_bdebug(bs->bh, "modifying in-place");
Mingming Cao617ba132006-10-11 01:20:53 -0700824 error = ext4_xattr_set_entry(i, s);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700825 if (!error) {
826 if (!IS_LAST_ENTRY(s->first))
Mingming Cao617ba132006-10-11 01:20:53 -0700827 ext4_xattr_rehash(header(s->base),
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700828 s->here);
T Makphaibulchoke9c191f72014-03-18 19:24:49 -0400829 ext4_xattr_cache_insert(ext4_mb_cache,
830 bs->bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700831 }
832 unlock_buffer(bs->bh);
Darrick J. Wong6a797d22015-10-17 16:16:04 -0400833 if (error == -EFSCORRUPTED)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700834 goto bad_block;
835 if (!error)
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400836 error = ext4_handle_dirty_xattr_block(handle,
837 inode,
838 bs->bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700839 if (error)
840 goto cleanup;
841 goto inserted;
842 } else {
843 int offset = (char *)s->here - bs->bh->b_data;
844
Mingming Cao8a2bfdc2007-02-28 20:13:35 -0800845 unlock_buffer(bs->bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700846 ea_bdebug(bs->bh, "cloning");
Josef Bacik216553c2008-04-29 22:02:02 -0400847 s->base = kmalloc(bs->bh->b_size, GFP_NOFS);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700848 error = -ENOMEM;
849 if (s->base == NULL)
850 goto cleanup;
851 memcpy(s->base, BHDR(bs->bh), bs->bh->b_size);
852 s->first = ENTRY(header(s->base)+1);
853 header(s->base)->h_refcount = cpu_to_le32(1);
854 s->here = ENTRY(s->base + offset);
855 s->end = s->base + bs->bh->b_size;
856 }
857 } else {
858 /* Allocate a buffer where we construct the new block. */
Josef Bacik216553c2008-04-29 22:02:02 -0400859 s->base = kzalloc(sb->s_blocksize, GFP_NOFS);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700860 /* assert(header == s->base) */
861 error = -ENOMEM;
862 if (s->base == NULL)
863 goto cleanup;
Mingming Cao617ba132006-10-11 01:20:53 -0700864 header(s->base)->h_magic = cpu_to_le32(EXT4_XATTR_MAGIC);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700865 header(s->base)->h_blocks = cpu_to_le32(1);
866 header(s->base)->h_refcount = cpu_to_le32(1);
867 s->first = ENTRY(header(s->base)+1);
868 s->here = ENTRY(header(s->base)+1);
869 s->end = s->base + sb->s_blocksize;
870 }
871
Mingming Cao617ba132006-10-11 01:20:53 -0700872 error = ext4_xattr_set_entry(i, s);
Darrick J. Wong6a797d22015-10-17 16:16:04 -0400873 if (error == -EFSCORRUPTED)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700874 goto bad_block;
875 if (error)
876 goto cleanup;
877 if (!IS_LAST_ENTRY(s->first))
Mingming Cao617ba132006-10-11 01:20:53 -0700878 ext4_xattr_rehash(header(s->base), s->here);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700879
880inserted:
881 if (!IS_LAST_ENTRY(s->first)) {
Mingming Cao617ba132006-10-11 01:20:53 -0700882 new_bh = ext4_xattr_cache_find(inode, header(s->base), &ce);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700883 if (new_bh) {
884 /* We found an identical block in the cache. */
885 if (new_bh == bs->bh)
886 ea_bdebug(new_bh, "keeping");
887 else {
Andreas Gruenbacher6048c642016-02-22 22:44:04 -0500888 u32 ref;
889
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700890 /* The old block is released after updating
891 the inode. */
Lukas Czerner1231b3a2013-02-18 12:12:07 -0500892 error = dquot_alloc_block(inode,
893 EXT4_C2B(EXT4_SB(sb), 1));
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500894 if (error)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700895 goto cleanup;
liang xie5d601252014-05-12 22:06:43 -0400896 BUFFER_TRACE(new_bh, "get_write_access");
Mingming Cao617ba132006-10-11 01:20:53 -0700897 error = ext4_journal_get_write_access(handle,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700898 new_bh);
899 if (error)
900 goto cleanup_dquot;
901 lock_buffer(new_bh);
Jan Kara82939d72016-02-22 11:50:13 -0500902 /*
903 * We have to be careful about races with
Andreas Gruenbacher6048c642016-02-22 22:44:04 -0500904 * freeing, rehashing or adding references to
905 * xattr block. Once we hold buffer lock xattr
906 * block's state is stable so we can check
907 * whether the block got freed / rehashed or
908 * not. Since we unhash mbcache entry under
909 * buffer lock when freeing / rehashing xattr
910 * block, checking whether entry is still
911 * hashed is reliable. Same rules hold for
912 * e_reusable handling.
Jan Kara82939d72016-02-22 11:50:13 -0500913 */
Andreas Gruenbacher6048c642016-02-22 22:44:04 -0500914 if (hlist_bl_unhashed(&ce->e_hash_list) ||
915 !ce->e_reusable) {
Jan Kara82939d72016-02-22 11:50:13 -0500916 /*
917 * Undo everything and check mbcache
918 * again.
919 */
920 unlock_buffer(new_bh);
921 dquot_free_block(inode,
922 EXT4_C2B(EXT4_SB(sb),
923 1));
924 brelse(new_bh);
Jan Kara7a2508e2016-02-22 22:35:22 -0500925 mb_cache_entry_put(ext4_mb_cache, ce);
Jan Kara82939d72016-02-22 11:50:13 -0500926 ce = NULL;
927 new_bh = NULL;
928 goto inserted;
929 }
Andreas Gruenbacher6048c642016-02-22 22:44:04 -0500930 ref = le32_to_cpu(BHDR(new_bh)->h_refcount) + 1;
931 BHDR(new_bh)->h_refcount = cpu_to_le32(ref);
932 if (ref >= EXT4_XATTR_REFCOUNT_MAX)
933 ce->e_reusable = 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700934 ea_bdebug(new_bh, "reusing; refcount now=%d",
Andreas Gruenbacher6048c642016-02-22 22:44:04 -0500935 ref);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700936 unlock_buffer(new_bh);
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400937 error = ext4_handle_dirty_xattr_block(handle,
938 inode,
939 new_bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700940 if (error)
941 goto cleanup_dquot;
942 }
Jan Kara7a2508e2016-02-22 22:35:22 -0500943 mb_cache_entry_touch(ext4_mb_cache, ce);
944 mb_cache_entry_put(ext4_mb_cache, ce);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700945 ce = NULL;
946 } else if (bs->bh && s->base == bs->bh->b_data) {
947 /* We were modifying this block in-place. */
948 ea_bdebug(bs->bh, "keeping this block");
949 new_bh = bs->bh;
950 get_bh(new_bh);
951 } else {
952 /* We need to allocate a new block */
Eric Sandeenfb0a3872009-09-16 14:45:10 -0400953 ext4_fsblk_t goal, block;
954
955 goal = ext4_group_first_block_no(sb,
Akinobu Mitad00a6d72008-04-17 10:38:59 -0400956 EXT4_I(inode)->i_block_group);
Eric Sandeenfb0a3872009-09-16 14:45:10 -0400957
958 /* non-extent files can't have physical blocks past 2^32 */
Dmitry Monakhov12e9b892010-05-16 22:00:00 -0400959 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
Eric Sandeenfb0a3872009-09-16 14:45:10 -0400960 goal = goal & EXT4_MAX_BLOCK_FILE_PHYS;
961
Allison Henderson55f020d2011-05-25 07:41:26 -0400962 block = ext4_new_meta_blocks(handle, inode, goal, 0,
963 NULL, &error);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700964 if (error)
965 goto cleanup;
Eric Sandeenfb0a3872009-09-16 14:45:10 -0400966
Dmitry Monakhov12e9b892010-05-16 22:00:00 -0400967 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
Eric Sandeenfb0a3872009-09-16 14:45:10 -0400968 BUG_ON(block > EXT4_MAX_BLOCK_FILE_PHYS);
969
Joe Perchesace36ad2012-03-19 23:11:43 -0400970 ea_idebug(inode, "creating block %llu",
971 (unsigned long long)block);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700972
973 new_bh = sb_getblk(sb, block);
Wang Shilongaebf0242013-01-12 16:28:47 -0500974 if (unlikely(!new_bh)) {
Theodore Ts'o860d21e2013-01-12 16:19:36 -0500975 error = -ENOMEM;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700976getblk_failed:
Peter Huewe7dc57612011-02-21 21:01:42 -0500977 ext4_free_blocks(handle, inode, NULL, block, 1,
Theodore Ts'oe6362602009-11-23 07:17:05 -0500978 EXT4_FREE_BLOCKS_METADATA);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700979 goto cleanup;
980 }
981 lock_buffer(new_bh);
Mingming Cao617ba132006-10-11 01:20:53 -0700982 error = ext4_journal_get_create_access(handle, new_bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700983 if (error) {
984 unlock_buffer(new_bh);
Theodore Ts'o860d21e2013-01-12 16:19:36 -0500985 error = -EIO;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700986 goto getblk_failed;
987 }
988 memcpy(new_bh->b_data, s->base, new_bh->b_size);
989 set_buffer_uptodate(new_bh);
990 unlock_buffer(new_bh);
T Makphaibulchoke9c191f72014-03-18 19:24:49 -0400991 ext4_xattr_cache_insert(ext4_mb_cache, new_bh);
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400992 error = ext4_handle_dirty_xattr_block(handle,
993 inode, new_bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700994 if (error)
995 goto cleanup;
996 }
997 }
998
999 /* Update the inode. */
Mingming Cao617ba132006-10-11 01:20:53 -07001000 EXT4_I(inode)->i_file_acl = new_bh ? new_bh->b_blocknr : 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001001
1002 /* Drop the previous xattr block. */
1003 if (bs->bh && bs->bh != new_bh)
Mingming Cao617ba132006-10-11 01:20:53 -07001004 ext4_xattr_release_block(handle, inode, bs->bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001005 error = 0;
1006
1007cleanup:
1008 if (ce)
Jan Kara7a2508e2016-02-22 22:35:22 -05001009 mb_cache_entry_put(ext4_mb_cache, ce);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001010 brelse(new_bh);
1011 if (!(bs->bh && s->base == bs->bh->b_data))
1012 kfree(s->base);
1013
1014 return error;
1015
1016cleanup_dquot:
Lukas Czerner1231b3a2013-02-18 12:12:07 -05001017 dquot_free_block(inode, EXT4_C2B(EXT4_SB(sb), 1));
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001018 goto cleanup;
1019
1020bad_block:
Theodore Ts'o24676da2010-05-16 21:00:00 -04001021 EXT4_ERROR_INODE(inode, "bad block %llu",
1022 EXT4_I(inode)->i_file_acl);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001023 goto cleanup;
1024
1025#undef header
1026}
1027
Tao Ma879b3822012-12-05 10:28:46 -05001028int ext4_xattr_ibody_find(struct inode *inode, struct ext4_xattr_info *i,
1029 struct ext4_xattr_ibody_find *is)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001030{
Mingming Cao617ba132006-10-11 01:20:53 -07001031 struct ext4_xattr_ibody_header *header;
1032 struct ext4_inode *raw_inode;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001033 int error;
1034
Mingming Cao617ba132006-10-11 01:20:53 -07001035 if (EXT4_I(inode)->i_extra_isize == 0)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001036 return 0;
Mingming Cao617ba132006-10-11 01:20:53 -07001037 raw_inode = ext4_raw_inode(&is->iloc);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001038 header = IHDR(inode, raw_inode);
1039 is->s.base = is->s.first = IFIRST(header);
1040 is->s.here = is->s.first;
Mingming Cao617ba132006-10-11 01:20:53 -07001041 is->s.end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
Theodore Ts'o19f5fb72010-01-24 14:34:07 -05001042 if (ext4_test_inode_state(inode, EXT4_STATE_XATTR)) {
Darrick J. Wonga0626e752014-09-16 14:34:59 -04001043 error = ext4_xattr_check_names(IFIRST(header), is->s.end,
1044 IFIRST(header));
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001045 if (error)
1046 return error;
1047 /* Find the named attribute. */
Mingming Cao617ba132006-10-11 01:20:53 -07001048 error = ext4_xattr_find_entry(&is->s.here, i->name_index,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001049 i->name, is->s.end -
1050 (void *)is->s.base, 0);
1051 if (error && error != -ENODATA)
1052 return error;
1053 is->s.not_found = error;
1054 }
1055 return 0;
1056}
1057
Tao Ma0d812f72012-12-10 14:06:02 -05001058int ext4_xattr_ibody_inline_set(handle_t *handle, struct inode *inode,
1059 struct ext4_xattr_info *i,
1060 struct ext4_xattr_ibody_find *is)
1061{
1062 struct ext4_xattr_ibody_header *header;
1063 struct ext4_xattr_search *s = &is->s;
1064 int error;
1065
1066 if (EXT4_I(inode)->i_extra_isize == 0)
1067 return -ENOSPC;
1068 error = ext4_xattr_set_entry(i, s);
1069 if (error) {
1070 if (error == -ENOSPC &&
1071 ext4_has_inline_data(inode)) {
1072 error = ext4_try_to_evict_inline_data(handle, inode,
1073 EXT4_XATTR_LEN(strlen(i->name) +
1074 EXT4_XATTR_SIZE(i->value_len)));
1075 if (error)
1076 return error;
1077 error = ext4_xattr_ibody_find(inode, i, is);
1078 if (error)
1079 return error;
1080 error = ext4_xattr_set_entry(i, s);
1081 }
1082 if (error)
1083 return error;
1084 }
1085 header = IHDR(inode, ext4_raw_inode(&is->iloc));
1086 if (!IS_LAST_ENTRY(s->first)) {
1087 header->h_magic = cpu_to_le32(EXT4_XATTR_MAGIC);
1088 ext4_set_inode_state(inode, EXT4_STATE_XATTR);
1089 } else {
1090 header->h_magic = cpu_to_le32(0);
1091 ext4_clear_inode_state(inode, EXT4_STATE_XATTR);
1092 }
1093 return 0;
1094}
1095
1096static int ext4_xattr_ibody_set(handle_t *handle, struct inode *inode,
1097 struct ext4_xattr_info *i,
1098 struct ext4_xattr_ibody_find *is)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001099{
Mingming Cao617ba132006-10-11 01:20:53 -07001100 struct ext4_xattr_ibody_header *header;
1101 struct ext4_xattr_search *s = &is->s;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001102 int error;
1103
Mingming Cao617ba132006-10-11 01:20:53 -07001104 if (EXT4_I(inode)->i_extra_isize == 0)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001105 return -ENOSPC;
Mingming Cao617ba132006-10-11 01:20:53 -07001106 error = ext4_xattr_set_entry(i, s);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001107 if (error)
1108 return error;
Mingming Cao617ba132006-10-11 01:20:53 -07001109 header = IHDR(inode, ext4_raw_inode(&is->iloc));
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001110 if (!IS_LAST_ENTRY(s->first)) {
Mingming Cao617ba132006-10-11 01:20:53 -07001111 header->h_magic = cpu_to_le32(EXT4_XATTR_MAGIC);
Theodore Ts'o19f5fb72010-01-24 14:34:07 -05001112 ext4_set_inode_state(inode, EXT4_STATE_XATTR);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001113 } else {
1114 header->h_magic = cpu_to_le32(0);
Theodore Ts'o19f5fb72010-01-24 14:34:07 -05001115 ext4_clear_inode_state(inode, EXT4_STATE_XATTR);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001116 }
1117 return 0;
1118}
1119
Jan Kara3fd16462016-02-22 22:43:04 -05001120static int ext4_xattr_value_same(struct ext4_xattr_search *s,
1121 struct ext4_xattr_info *i)
1122{
1123 void *value;
1124
1125 if (le32_to_cpu(s->here->e_value_size) != i->value_len)
1126 return 0;
1127 value = ((void *)s->base) + le16_to_cpu(s->here->e_value_offs);
1128 return !memcmp(value, i->value, i->value_len);
1129}
1130
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001131/*
Mingming Cao617ba132006-10-11 01:20:53 -07001132 * ext4_xattr_set_handle()
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001133 *
Wang Sheng-Hui6e9510b2011-01-10 12:10:30 -05001134 * Create, replace or remove an extended attribute for this inode. Value
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001135 * is NULL to remove an existing extended attribute, and non-NULL to
1136 * either replace an existing extended attribute, or create a new extended
1137 * attribute. The flags XATTR_REPLACE and XATTR_CREATE
1138 * specify that an extended attribute must exist and must not exist
1139 * previous to the call, respectively.
1140 *
1141 * Returns 0, or a negative error number on failure.
1142 */
1143int
Mingming Cao617ba132006-10-11 01:20:53 -07001144ext4_xattr_set_handle(handle_t *handle, struct inode *inode, int name_index,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001145 const char *name, const void *value, size_t value_len,
1146 int flags)
1147{
Mingming Cao617ba132006-10-11 01:20:53 -07001148 struct ext4_xattr_info i = {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001149 .name_index = name_index,
1150 .name = name,
1151 .value = value,
1152 .value_len = value_len,
1153
1154 };
Mingming Cao617ba132006-10-11 01:20:53 -07001155 struct ext4_xattr_ibody_find is = {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001156 .s = { .not_found = -ENODATA, },
1157 };
Mingming Cao617ba132006-10-11 01:20:53 -07001158 struct ext4_xattr_block_find bs = {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001159 .s = { .not_found = -ENODATA, },
1160 };
Kalpak Shah4d20c682008-10-08 23:21:54 -04001161 unsigned long no_expand;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001162 int error;
1163
1164 if (!name)
1165 return -EINVAL;
1166 if (strlen(name) > 255)
1167 return -ERANGE;
Mingming Cao617ba132006-10-11 01:20:53 -07001168 down_write(&EXT4_I(inode)->xattr_sem);
Theodore Ts'o19f5fb72010-01-24 14:34:07 -05001169 no_expand = ext4_test_inode_state(inode, EXT4_STATE_NO_EXPAND);
1170 ext4_set_inode_state(inode, EXT4_STATE_NO_EXPAND);
Kalpak Shah4d20c682008-10-08 23:21:54 -04001171
Eric Sandeen66543612011-10-26 03:32:07 -04001172 error = ext4_reserve_inode_write(handle, inode, &is.iloc);
Eric Sandeen86ebfd02009-11-15 15:30:52 -05001173 if (error)
1174 goto cleanup;
1175
Theodore Ts'o19f5fb72010-01-24 14:34:07 -05001176 if (ext4_test_inode_state(inode, EXT4_STATE_NEW)) {
Mingming Cao617ba132006-10-11 01:20:53 -07001177 struct ext4_inode *raw_inode = ext4_raw_inode(&is.iloc);
1178 memset(raw_inode, 0, EXT4_SB(inode->i_sb)->s_inode_size);
Theodore Ts'o19f5fb72010-01-24 14:34:07 -05001179 ext4_clear_inode_state(inode, EXT4_STATE_NEW);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001180 }
1181
Mingming Cao617ba132006-10-11 01:20:53 -07001182 error = ext4_xattr_ibody_find(inode, &i, &is);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001183 if (error)
1184 goto cleanup;
1185 if (is.s.not_found)
Mingming Cao617ba132006-10-11 01:20:53 -07001186 error = ext4_xattr_block_find(inode, &i, &bs);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001187 if (error)
1188 goto cleanup;
1189 if (is.s.not_found && bs.s.not_found) {
1190 error = -ENODATA;
1191 if (flags & XATTR_REPLACE)
1192 goto cleanup;
1193 error = 0;
1194 if (!value)
1195 goto cleanup;
1196 } else {
1197 error = -EEXIST;
1198 if (flags & XATTR_CREATE)
1199 goto cleanup;
1200 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001201 if (!value) {
1202 if (!is.s.not_found)
Mingming Cao617ba132006-10-11 01:20:53 -07001203 error = ext4_xattr_ibody_set(handle, inode, &i, &is);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001204 else if (!bs.s.not_found)
Mingming Cao617ba132006-10-11 01:20:53 -07001205 error = ext4_xattr_block_set(handle, inode, &i, &bs);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001206 } else {
Jan Kara3fd16462016-02-22 22:43:04 -05001207 error = 0;
1208 /* Xattr value did not change? Save us some work and bail out */
1209 if (!is.s.not_found && ext4_xattr_value_same(&is.s, &i))
1210 goto cleanup;
1211 if (!bs.s.not_found && ext4_xattr_value_same(&bs.s, &i))
1212 goto cleanup;
1213
Mingming Cao617ba132006-10-11 01:20:53 -07001214 error = ext4_xattr_ibody_set(handle, inode, &i, &is);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001215 if (!error && !bs.s.not_found) {
1216 i.value = NULL;
Mingming Cao617ba132006-10-11 01:20:53 -07001217 error = ext4_xattr_block_set(handle, inode, &i, &bs);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001218 } else if (error == -ENOSPC) {
Tiger Yang7e01c8e2008-05-14 16:05:47 -07001219 if (EXT4_I(inode)->i_file_acl && !bs.s.base) {
1220 error = ext4_xattr_block_find(inode, &i, &bs);
1221 if (error)
1222 goto cleanup;
1223 }
Mingming Cao617ba132006-10-11 01:20:53 -07001224 error = ext4_xattr_block_set(handle, inode, &i, &bs);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001225 if (error)
1226 goto cleanup;
1227 if (!is.s.not_found) {
1228 i.value = NULL;
Mingming Cao617ba132006-10-11 01:20:53 -07001229 error = ext4_xattr_ibody_set(handle, inode, &i,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001230 &is);
1231 }
1232 }
1233 }
1234 if (!error) {
Mingming Cao617ba132006-10-11 01:20:53 -07001235 ext4_xattr_update_super_block(handle, inode->i_sb);
Kalpak Shahef7f3832007-07-18 09:15:20 -04001236 inode->i_ctime = ext4_current_time(inode);
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04001237 if (!value)
Theodore Ts'o19f5fb72010-01-24 14:34:07 -05001238 ext4_clear_inode_state(inode, EXT4_STATE_NO_EXPAND);
Mingming Cao617ba132006-10-11 01:20:53 -07001239 error = ext4_mark_iloc_dirty(handle, inode, &is.iloc);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001240 /*
Mingming Cao617ba132006-10-11 01:20:53 -07001241 * The bh is consumed by ext4_mark_iloc_dirty, even with
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001242 * error != 0.
1243 */
1244 is.iloc.bh = NULL;
1245 if (IS_SYNC(inode))
Frank Mayhar03901312009-01-07 00:06:22 -05001246 ext4_handle_sync(handle);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001247 }
1248
1249cleanup:
1250 brelse(is.iloc.bh);
1251 brelse(bs.bh);
Kalpak Shah4d20c682008-10-08 23:21:54 -04001252 if (no_expand == 0)
Theodore Ts'o19f5fb72010-01-24 14:34:07 -05001253 ext4_clear_inode_state(inode, EXT4_STATE_NO_EXPAND);
Mingming Cao617ba132006-10-11 01:20:53 -07001254 up_write(&EXT4_I(inode)->xattr_sem);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001255 return error;
1256}
1257
1258/*
Mingming Cao617ba132006-10-11 01:20:53 -07001259 * ext4_xattr_set()
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001260 *
Mingming Cao617ba132006-10-11 01:20:53 -07001261 * Like ext4_xattr_set_handle, but start from an inode. This extended
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001262 * attribute modification is a filesystem transaction by itself.
1263 *
1264 * Returns 0, or a negative error number on failure.
1265 */
1266int
Mingming Cao617ba132006-10-11 01:20:53 -07001267ext4_xattr_set(struct inode *inode, int name_index, const char *name,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001268 const void *value, size_t value_len, int flags)
1269{
1270 handle_t *handle;
1271 int error, retries = 0;
Theodore Ts'o95eaefb2013-02-09 15:23:03 -05001272 int credits = ext4_jbd2_credits_xattr(inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001273
1274retry:
Theodore Ts'o9924a922013-02-08 21:59:22 -05001275 handle = ext4_journal_start(inode, EXT4_HT_XATTR, credits);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001276 if (IS_ERR(handle)) {
1277 error = PTR_ERR(handle);
1278 } else {
1279 int error2;
1280
Mingming Cao617ba132006-10-11 01:20:53 -07001281 error = ext4_xattr_set_handle(handle, inode, name_index, name,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001282 value, value_len, flags);
Mingming Cao617ba132006-10-11 01:20:53 -07001283 error2 = ext4_journal_stop(handle);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001284 if (error == -ENOSPC &&
Mingming Cao617ba132006-10-11 01:20:53 -07001285 ext4_should_retry_alloc(inode->i_sb, &retries))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001286 goto retry;
1287 if (error == 0)
1288 error = error2;
1289 }
1290
1291 return error;
1292}
1293
1294/*
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04001295 * Shift the EA entries in the inode to create space for the increased
1296 * i_extra_isize.
1297 */
1298static void ext4_xattr_shift_entries(struct ext4_xattr_entry *entry,
1299 int value_offs_shift, void *to,
1300 void *from, size_t n, int blocksize)
1301{
1302 struct ext4_xattr_entry *last = entry;
1303 int new_offs;
1304
1305 /* Adjust the value offsets of the entries */
1306 for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
1307 if (!last->e_value_block && last->e_value_size) {
1308 new_offs = le16_to_cpu(last->e_value_offs) +
1309 value_offs_shift;
1310 BUG_ON(new_offs + le32_to_cpu(last->e_value_size)
1311 > blocksize);
1312 last->e_value_offs = cpu_to_le16(new_offs);
1313 }
1314 }
1315 /* Shift the entries by n bytes */
1316 memmove(to, from, n);
1317}
1318
1319/*
1320 * Expand an inode by new_extra_isize bytes when EAs are present.
1321 * Returns 0 on success or negative error number on failure.
1322 */
1323int ext4_expand_extra_isize_ea(struct inode *inode, int new_extra_isize,
1324 struct ext4_inode *raw_inode, handle_t *handle)
1325{
1326 struct ext4_xattr_ibody_header *header;
1327 struct ext4_xattr_entry *entry, *last, *first;
1328 struct buffer_head *bh = NULL;
1329 struct ext4_xattr_ibody_find *is = NULL;
1330 struct ext4_xattr_block_find *bs = NULL;
1331 char *buffer = NULL, *b_entry_name = NULL;
1332 size_t min_offs, free;
Theodore Ts'o7b1b2c12014-02-19 20:15:21 -05001333 int total_ino;
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04001334 void *base, *start, *end;
1335 int extra_isize = 0, error = 0, tried_min_extra_isize = 0;
Aneesh Kumar K.Vac398492007-10-16 18:38:25 -04001336 int s_min_extra_isize = le16_to_cpu(EXT4_SB(inode->i_sb)->s_es->s_min_extra_isize);
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04001337
1338 down_write(&EXT4_I(inode)->xattr_sem);
1339retry:
1340 if (EXT4_I(inode)->i_extra_isize >= new_extra_isize) {
1341 up_write(&EXT4_I(inode)->xattr_sem);
1342 return 0;
1343 }
1344
1345 header = IHDR(inode, raw_inode);
1346 entry = IFIRST(header);
1347
1348 /*
1349 * Check if enough free space is available in the inode to shift the
1350 * entries ahead by new_extra_isize.
1351 */
1352
1353 base = start = entry;
1354 end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
1355 min_offs = end - base;
1356 last = entry;
1357 total_ino = sizeof(struct ext4_xattr_ibody_header);
1358
1359 free = ext4_xattr_free_space(last, &min_offs, base, &total_ino);
1360 if (free >= new_extra_isize) {
1361 entry = IFIRST(header);
1362 ext4_xattr_shift_entries(entry, EXT4_I(inode)->i_extra_isize
1363 - new_extra_isize, (void *)raw_inode +
1364 EXT4_GOOD_OLD_INODE_SIZE + new_extra_isize,
1365 (void *)header, total_ino,
1366 inode->i_sb->s_blocksize);
1367 EXT4_I(inode)->i_extra_isize = new_extra_isize;
1368 error = 0;
1369 goto cleanup;
1370 }
1371
1372 /*
1373 * Enough free space isn't available in the inode, check if
1374 * EA block can hold new_extra_isize bytes.
1375 */
1376 if (EXT4_I(inode)->i_file_acl) {
1377 bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl);
1378 error = -EIO;
1379 if (!bh)
1380 goto cleanup;
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -04001381 if (ext4_xattr_check_block(inode, bh)) {
Theodore Ts'o24676da2010-05-16 21:00:00 -04001382 EXT4_ERROR_INODE(inode, "bad block %llu",
1383 EXT4_I(inode)->i_file_acl);
Darrick J. Wong6a797d22015-10-17 16:16:04 -04001384 error = -EFSCORRUPTED;
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04001385 goto cleanup;
1386 }
1387 base = BHDR(bh);
1388 first = BFIRST(bh);
1389 end = bh->b_data + bh->b_size;
1390 min_offs = end - base;
Theodore Ts'o7b1b2c12014-02-19 20:15:21 -05001391 free = ext4_xattr_free_space(first, &min_offs, base, NULL);
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04001392 if (free < new_extra_isize) {
1393 if (!tried_min_extra_isize && s_min_extra_isize) {
1394 tried_min_extra_isize++;
1395 new_extra_isize = s_min_extra_isize;
1396 brelse(bh);
1397 goto retry;
1398 }
1399 error = -1;
1400 goto cleanup;
1401 }
1402 } else {
1403 free = inode->i_sb->s_blocksize;
1404 }
1405
1406 while (new_extra_isize > 0) {
1407 size_t offs, size, entry_size;
1408 struct ext4_xattr_entry *small_entry = NULL;
1409 struct ext4_xattr_info i = {
1410 .value = NULL,
1411 .value_len = 0,
1412 };
1413 unsigned int total_size; /* EA entry size + value size */
1414 unsigned int shift_bytes; /* No. of bytes to shift EAs by? */
1415 unsigned int min_total_size = ~0U;
1416
1417 is = kzalloc(sizeof(struct ext4_xattr_ibody_find), GFP_NOFS);
1418 bs = kzalloc(sizeof(struct ext4_xattr_block_find), GFP_NOFS);
1419 if (!is || !bs) {
1420 error = -ENOMEM;
1421 goto cleanup;
1422 }
1423
1424 is->s.not_found = -ENODATA;
1425 bs->s.not_found = -ENODATA;
1426 is->iloc.bh = NULL;
1427 bs->bh = NULL;
1428
1429 last = IFIRST(header);
1430 /* Find the entry best suited to be pushed into EA block */
1431 entry = NULL;
1432 for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
1433 total_size =
1434 EXT4_XATTR_SIZE(le32_to_cpu(last->e_value_size)) +
1435 EXT4_XATTR_LEN(last->e_name_len);
1436 if (total_size <= free && total_size < min_total_size) {
1437 if (total_size < new_extra_isize) {
1438 small_entry = last;
1439 } else {
1440 entry = last;
1441 min_total_size = total_size;
1442 }
1443 }
1444 }
1445
1446 if (entry == NULL) {
1447 if (small_entry) {
1448 entry = small_entry;
1449 } else {
1450 if (!tried_min_extra_isize &&
1451 s_min_extra_isize) {
1452 tried_min_extra_isize++;
1453 new_extra_isize = s_min_extra_isize;
Dave Jones6e4ea8e2013-10-10 20:05:35 -04001454 kfree(is); is = NULL;
1455 kfree(bs); bs = NULL;
Theodore Ts'odcb99172013-10-31 23:00:24 -04001456 brelse(bh);
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04001457 goto retry;
1458 }
1459 error = -1;
1460 goto cleanup;
1461 }
1462 }
1463 offs = le16_to_cpu(entry->e_value_offs);
1464 size = le32_to_cpu(entry->e_value_size);
1465 entry_size = EXT4_XATTR_LEN(entry->e_name_len);
1466 i.name_index = entry->e_name_index,
1467 buffer = kmalloc(EXT4_XATTR_SIZE(size), GFP_NOFS);
1468 b_entry_name = kmalloc(entry->e_name_len + 1, GFP_NOFS);
1469 if (!buffer || !b_entry_name) {
1470 error = -ENOMEM;
1471 goto cleanup;
1472 }
1473 /* Save the entry name and the entry value */
1474 memcpy(buffer, (void *)IFIRST(header) + offs,
1475 EXT4_XATTR_SIZE(size));
1476 memcpy(b_entry_name, entry->e_name, entry->e_name_len);
1477 b_entry_name[entry->e_name_len] = '\0';
1478 i.name = b_entry_name;
1479
1480 error = ext4_get_inode_loc(inode, &is->iloc);
1481 if (error)
1482 goto cleanup;
1483
1484 error = ext4_xattr_ibody_find(inode, &i, is);
1485 if (error)
1486 goto cleanup;
1487
1488 /* Remove the chosen entry from the inode */
1489 error = ext4_xattr_ibody_set(handle, inode, &i, is);
Roel Kluin9aaab052010-02-15 14:26:16 -05001490 if (error)
1491 goto cleanup;
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04001492
1493 entry = IFIRST(header);
1494 if (entry_size + EXT4_XATTR_SIZE(size) >= new_extra_isize)
1495 shift_bytes = new_extra_isize;
1496 else
1497 shift_bytes = entry_size + size;
1498 /* Adjust the offsets and shift the remaining entries ahead */
1499 ext4_xattr_shift_entries(entry, EXT4_I(inode)->i_extra_isize -
1500 shift_bytes, (void *)raw_inode +
1501 EXT4_GOOD_OLD_INODE_SIZE + extra_isize + shift_bytes,
1502 (void *)header, total_ino - entry_size,
1503 inode->i_sb->s_blocksize);
1504
1505 extra_isize += shift_bytes;
1506 new_extra_isize -= shift_bytes;
1507 EXT4_I(inode)->i_extra_isize = extra_isize;
1508
1509 i.name = b_entry_name;
1510 i.value = buffer;
Aneesh Kumar K.Vac398492007-10-16 18:38:25 -04001511 i.value_len = size;
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04001512 error = ext4_xattr_block_find(inode, &i, bs);
1513 if (error)
1514 goto cleanup;
1515
1516 /* Add entry which was removed from the inode into the block */
1517 error = ext4_xattr_block_set(handle, inode, &i, bs);
1518 if (error)
1519 goto cleanup;
1520 kfree(b_entry_name);
1521 kfree(buffer);
Julia Lawalld3533d72009-12-23 07:52:31 -05001522 b_entry_name = NULL;
1523 buffer = NULL;
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04001524 brelse(is->iloc.bh);
1525 kfree(is);
1526 kfree(bs);
1527 }
1528 brelse(bh);
1529 up_write(&EXT4_I(inode)->xattr_sem);
1530 return 0;
1531
1532cleanup:
1533 kfree(b_entry_name);
1534 kfree(buffer);
1535 if (is)
1536 brelse(is->iloc.bh);
1537 kfree(is);
1538 kfree(bs);
1539 brelse(bh);
1540 up_write(&EXT4_I(inode)->xattr_sem);
1541 return error;
1542}
1543
1544
1545
1546/*
Mingming Cao617ba132006-10-11 01:20:53 -07001547 * ext4_xattr_delete_inode()
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001548 *
1549 * Free extended attribute resources associated with this inode. This
1550 * is called immediately before an inode is freed. We have exclusive
1551 * access to the inode.
1552 */
1553void
Mingming Cao617ba132006-10-11 01:20:53 -07001554ext4_xattr_delete_inode(handle_t *handle, struct inode *inode)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001555{
1556 struct buffer_head *bh = NULL;
1557
Mingming Cao617ba132006-10-11 01:20:53 -07001558 if (!EXT4_I(inode)->i_file_acl)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001559 goto cleanup;
Mingming Cao617ba132006-10-11 01:20:53 -07001560 bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001561 if (!bh) {
Theodore Ts'o24676da2010-05-16 21:00:00 -04001562 EXT4_ERROR_INODE(inode, "block %llu read error",
1563 EXT4_I(inode)->i_file_acl);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001564 goto cleanup;
1565 }
Mingming Cao617ba132006-10-11 01:20:53 -07001566 if (BHDR(bh)->h_magic != cpu_to_le32(EXT4_XATTR_MAGIC) ||
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001567 BHDR(bh)->h_blocks != cpu_to_le32(1)) {
Theodore Ts'o24676da2010-05-16 21:00:00 -04001568 EXT4_ERROR_INODE(inode, "bad block %llu",
1569 EXT4_I(inode)->i_file_acl);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001570 goto cleanup;
1571 }
Mingming Cao617ba132006-10-11 01:20:53 -07001572 ext4_xattr_release_block(handle, inode, bh);
1573 EXT4_I(inode)->i_file_acl = 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001574
1575cleanup:
1576 brelse(bh);
1577}
1578
1579/*
Mingming Cao617ba132006-10-11 01:20:53 -07001580 * ext4_xattr_cache_insert()
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001581 *
1582 * Create a new entry in the extended attribute cache, and insert
1583 * it unless such an entry is already in the cache.
1584 *
1585 * Returns 0, or a negative error number on failure.
1586 */
1587static void
Jan Kara7a2508e2016-02-22 22:35:22 -05001588ext4_xattr_cache_insert(struct mb_cache *ext4_mb_cache, struct buffer_head *bh)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001589{
Andreas Gruenbacher6048c642016-02-22 22:44:04 -05001590 struct ext4_xattr_header *header = BHDR(bh);
1591 __u32 hash = le32_to_cpu(header->h_hash);
1592 int reusable = le32_to_cpu(header->h_refcount) <
1593 EXT4_XATTR_REFCOUNT_MAX;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001594 int error;
1595
Jan Kara7a2508e2016-02-22 22:35:22 -05001596 error = mb_cache_entry_create(ext4_mb_cache, GFP_NOFS, hash,
Andreas Gruenbacher6048c642016-02-22 22:44:04 -05001597 bh->b_blocknr, reusable);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001598 if (error) {
Jan Kara82939d72016-02-22 11:50:13 -05001599 if (error == -EBUSY)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001600 ea_bdebug(bh, "already in cache");
Jan Kara82939d72016-02-22 11:50:13 -05001601 } else
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001602 ea_bdebug(bh, "inserting [%x]", (int)hash);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001603}
1604
1605/*
Mingming Cao617ba132006-10-11 01:20:53 -07001606 * ext4_xattr_cmp()
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001607 *
1608 * Compare two extended attribute blocks for equality.
1609 *
1610 * Returns 0 if the blocks are equal, 1 if they differ, and
1611 * a negative error number on errors.
1612 */
1613static int
Mingming Cao617ba132006-10-11 01:20:53 -07001614ext4_xattr_cmp(struct ext4_xattr_header *header1,
1615 struct ext4_xattr_header *header2)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001616{
Mingming Cao617ba132006-10-11 01:20:53 -07001617 struct ext4_xattr_entry *entry1, *entry2;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001618
1619 entry1 = ENTRY(header1+1);
1620 entry2 = ENTRY(header2+1);
1621 while (!IS_LAST_ENTRY(entry1)) {
1622 if (IS_LAST_ENTRY(entry2))
1623 return 1;
1624 if (entry1->e_hash != entry2->e_hash ||
1625 entry1->e_name_index != entry2->e_name_index ||
1626 entry1->e_name_len != entry2->e_name_len ||
1627 entry1->e_value_size != entry2->e_value_size ||
1628 memcmp(entry1->e_name, entry2->e_name, entry1->e_name_len))
1629 return 1;
1630 if (entry1->e_value_block != 0 || entry2->e_value_block != 0)
Darrick J. Wong6a797d22015-10-17 16:16:04 -04001631 return -EFSCORRUPTED;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001632 if (memcmp((char *)header1 + le16_to_cpu(entry1->e_value_offs),
1633 (char *)header2 + le16_to_cpu(entry2->e_value_offs),
1634 le32_to_cpu(entry1->e_value_size)))
1635 return 1;
1636
Mingming Cao617ba132006-10-11 01:20:53 -07001637 entry1 = EXT4_XATTR_NEXT(entry1);
1638 entry2 = EXT4_XATTR_NEXT(entry2);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001639 }
1640 if (!IS_LAST_ENTRY(entry2))
1641 return 1;
1642 return 0;
1643}
1644
1645/*
Mingming Cao617ba132006-10-11 01:20:53 -07001646 * ext4_xattr_cache_find()
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001647 *
1648 * Find an identical extended attribute block.
1649 *
1650 * Returns a pointer to the block found, or NULL if such a block was
1651 * not found or an error occurred.
1652 */
1653static struct buffer_head *
Mingming Cao617ba132006-10-11 01:20:53 -07001654ext4_xattr_cache_find(struct inode *inode, struct ext4_xattr_header *header,
Jan Kara7a2508e2016-02-22 22:35:22 -05001655 struct mb_cache_entry **pce)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001656{
1657 __u32 hash = le32_to_cpu(header->h_hash);
Jan Kara7a2508e2016-02-22 22:35:22 -05001658 struct mb_cache_entry *ce;
1659 struct mb_cache *ext4_mb_cache = EXT4_GET_MB_CACHE(inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001660
1661 if (!header->h_hash)
1662 return NULL; /* never share */
1663 ea_idebug(inode, "looking for cached blocks [%x]", (int)hash);
Jan Kara7a2508e2016-02-22 22:35:22 -05001664 ce = mb_cache_entry_find_first(ext4_mb_cache, hash);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001665 while (ce) {
1666 struct buffer_head *bh;
1667
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001668 bh = sb_bread(inode->i_sb, ce->e_block);
1669 if (!bh) {
Theodore Ts'o24676da2010-05-16 21:00:00 -04001670 EXT4_ERROR_INODE(inode, "block %lu read error",
1671 (unsigned long) ce->e_block);
Mingming Cao617ba132006-10-11 01:20:53 -07001672 } else if (ext4_xattr_cmp(header, BHDR(bh)) == 0) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001673 *pce = ce;
1674 return bh;
1675 }
1676 brelse(bh);
Jan Kara7a2508e2016-02-22 22:35:22 -05001677 ce = mb_cache_entry_find_next(ext4_mb_cache, ce);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001678 }
1679 return NULL;
1680}
1681
1682#define NAME_HASH_SHIFT 5
1683#define VALUE_HASH_SHIFT 16
1684
1685/*
Mingming Cao617ba132006-10-11 01:20:53 -07001686 * ext4_xattr_hash_entry()
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001687 *
1688 * Compute the hash of an extended attribute.
1689 */
Mingming Cao617ba132006-10-11 01:20:53 -07001690static inline void ext4_xattr_hash_entry(struct ext4_xattr_header *header,
1691 struct ext4_xattr_entry *entry)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001692{
1693 __u32 hash = 0;
1694 char *name = entry->e_name;
1695 int n;
1696
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001697 for (n = 0; n < entry->e_name_len; n++) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001698 hash = (hash << NAME_HASH_SHIFT) ^
1699 (hash >> (8*sizeof(hash) - NAME_HASH_SHIFT)) ^
1700 *name++;
1701 }
1702
1703 if (entry->e_value_block == 0 && entry->e_value_size != 0) {
1704 __le32 *value = (__le32 *)((char *)header +
1705 le16_to_cpu(entry->e_value_offs));
1706 for (n = (le32_to_cpu(entry->e_value_size) +
Mingming Cao617ba132006-10-11 01:20:53 -07001707 EXT4_XATTR_ROUND) >> EXT4_XATTR_PAD_BITS; n; n--) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001708 hash = (hash << VALUE_HASH_SHIFT) ^
1709 (hash >> (8*sizeof(hash) - VALUE_HASH_SHIFT)) ^
1710 le32_to_cpu(*value++);
1711 }
1712 }
1713 entry->e_hash = cpu_to_le32(hash);
1714}
1715
1716#undef NAME_HASH_SHIFT
1717#undef VALUE_HASH_SHIFT
1718
1719#define BLOCK_HASH_SHIFT 16
1720
1721/*
Mingming Cao617ba132006-10-11 01:20:53 -07001722 * ext4_xattr_rehash()
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001723 *
1724 * Re-compute the extended attribute hash value after an entry has changed.
1725 */
Mingming Cao617ba132006-10-11 01:20:53 -07001726static void ext4_xattr_rehash(struct ext4_xattr_header *header,
1727 struct ext4_xattr_entry *entry)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001728{
Mingming Cao617ba132006-10-11 01:20:53 -07001729 struct ext4_xattr_entry *here;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001730 __u32 hash = 0;
1731
Mingming Cao617ba132006-10-11 01:20:53 -07001732 ext4_xattr_hash_entry(header, entry);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001733 here = ENTRY(header+1);
1734 while (!IS_LAST_ENTRY(here)) {
1735 if (!here->e_hash) {
1736 /* Block is not shared if an entry's hash value == 0 */
1737 hash = 0;
1738 break;
1739 }
1740 hash = (hash << BLOCK_HASH_SHIFT) ^
1741 (hash >> (8*sizeof(hash) - BLOCK_HASH_SHIFT)) ^
1742 le32_to_cpu(here->e_hash);
Mingming Cao617ba132006-10-11 01:20:53 -07001743 here = EXT4_XATTR_NEXT(here);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001744 }
1745 header->h_hash = cpu_to_le32(hash);
1746}
1747
1748#undef BLOCK_HASH_SHIFT
1749
T Makphaibulchoke9c191f72014-03-18 19:24:49 -04001750#define HASH_BUCKET_BITS 10
1751
Jan Kara7a2508e2016-02-22 22:35:22 -05001752struct mb_cache *
Jan Kara82939d72016-02-22 11:50:13 -05001753ext4_xattr_create_cache(void)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001754{
Jan Kara7a2508e2016-02-22 22:35:22 -05001755 return mb_cache_create(HASH_BUCKET_BITS);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001756}
1757
Jan Kara7a2508e2016-02-22 22:35:22 -05001758void ext4_xattr_destroy_cache(struct mb_cache *cache)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001759{
T Makphaibulchoke9c191f72014-03-18 19:24:49 -04001760 if (cache)
Jan Kara7a2508e2016-02-22 22:35:22 -05001761 mb_cache_destroy(cache);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001762}
T Makphaibulchoke9c191f72014-03-18 19:24:49 -04001763