blob: 16e28c08d1e8cf54eb0c05d15611a6416185b119 [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>
Dave Kleikampac27a0e2006-10-11 01:20:50 -070056#include <linux/mbcache.h>
57#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 { \
71 char b[BDEVNAME_SIZE]; \
72 printk(KERN_DEBUG "block %s:%lu: ", \
73 bdevname(bh->b_bdev, b), \
74 (unsigned long) bh->b_blocknr); \
75 printk(f); \
76 printk("\n"); \
77 } while (0)
78#else
Joe Perchesace36ad2012-03-19 23:11:43 -040079# define ea_idebug(inode, fmt, ...) no_printk(fmt, ##__VA_ARGS__)
80# define ea_bdebug(bh, fmt, ...) no_printk(fmt, ##__VA_ARGS__)
Dave Kleikampac27a0e2006-10-11 01:20:50 -070081#endif
82
T Makphaibulchoke9c191f72014-03-18 19:24:49 -040083static void ext4_xattr_cache_insert(struct mb_cache *, struct buffer_head *);
Mingming Cao617ba132006-10-11 01:20:53 -070084static struct buffer_head *ext4_xattr_cache_find(struct inode *,
85 struct ext4_xattr_header *,
Dave Kleikampac27a0e2006-10-11 01:20:50 -070086 struct mb_cache_entry **);
Mingming Cao617ba132006-10-11 01:20:53 -070087static void ext4_xattr_rehash(struct ext4_xattr_header *,
88 struct ext4_xattr_entry *);
Christoph Hellwig431547b2009-11-13 09:52:56 +000089static int ext4_xattr_list(struct dentry *dentry, char *buffer,
Mingming Caod3a95d42008-04-17 10:38:59 -040090 size_t buffer_size);
Dave Kleikampac27a0e2006-10-11 01:20:50 -070091
Stephen Hemminger11e27522010-05-13 17:53:18 -070092static const struct xattr_handler *ext4_xattr_handler_map[] = {
Mingming Cao617ba132006-10-11 01:20:53 -070093 [EXT4_XATTR_INDEX_USER] = &ext4_xattr_user_handler,
Theodore Ts'o03010a32008-10-10 20:02:48 -040094#ifdef CONFIG_EXT4_FS_POSIX_ACL
Christoph Hellwig64e178a2013-12-20 05:16:44 -080095 [EXT4_XATTR_INDEX_POSIX_ACL_ACCESS] = &posix_acl_access_xattr_handler,
96 [EXT4_XATTR_INDEX_POSIX_ACL_DEFAULT] = &posix_acl_default_xattr_handler,
Dave Kleikampac27a0e2006-10-11 01:20:50 -070097#endif
Mingming Cao617ba132006-10-11 01:20:53 -070098 [EXT4_XATTR_INDEX_TRUSTED] = &ext4_xattr_trusted_handler,
Theodore Ts'o03010a32008-10-10 20:02:48 -040099#ifdef CONFIG_EXT4_FS_SECURITY
Mingming Cao617ba132006-10-11 01:20:53 -0700100 [EXT4_XATTR_INDEX_SECURITY] = &ext4_xattr_security_handler,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700101#endif
102};
103
Stephen Hemminger11e27522010-05-13 17:53:18 -0700104const struct xattr_handler *ext4_xattr_handlers[] = {
Mingming Cao617ba132006-10-11 01:20:53 -0700105 &ext4_xattr_user_handler,
106 &ext4_xattr_trusted_handler,
Theodore Ts'o03010a32008-10-10 20:02:48 -0400107#ifdef CONFIG_EXT4_FS_POSIX_ACL
Christoph Hellwig64e178a2013-12-20 05:16:44 -0800108 &posix_acl_access_xattr_handler,
109 &posix_acl_default_xattr_handler,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700110#endif
Theodore Ts'o03010a32008-10-10 20:02:48 -0400111#ifdef CONFIG_EXT4_FS_SECURITY
Mingming Cao617ba132006-10-11 01:20:53 -0700112 &ext4_xattr_security_handler,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700113#endif
114 NULL
115};
116
T Makphaibulchoke9c191f72014-03-18 19:24:49 -0400117#define EXT4_GET_MB_CACHE(inode) (((struct ext4_sb_info *) \
118 inode->i_sb->s_fs_info)->s_mb_cache)
119
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400120static __le32 ext4_xattr_block_csum(struct inode *inode,
121 sector_t block_nr,
122 struct ext4_xattr_header *hdr)
123{
124 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
Theodore Ts'od6a77102013-04-09 23:59:55 -0400125 __u32 csum;
126 __le32 save_csum;
127 __le64 dsk_block_nr = cpu_to_le64(block_nr);
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400128
Theodore Ts'od6a77102013-04-09 23:59:55 -0400129 save_csum = hdr->h_checksum;
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400130 hdr->h_checksum = 0;
Theodore Ts'od6a77102013-04-09 23:59:55 -0400131 csum = ext4_chksum(sbi, sbi->s_csum_seed, (__u8 *)&dsk_block_nr,
132 sizeof(dsk_block_nr));
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400133 csum = ext4_chksum(sbi, csum, (__u8 *)hdr,
134 EXT4_BLOCK_SIZE(inode->i_sb));
Tao Ma41eb70d2012-07-09 16:29:27 -0400135
Theodore Ts'od6a77102013-04-09 23:59:55 -0400136 hdr->h_checksum = save_csum;
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400137 return cpu_to_le32(csum);
138}
139
140static int ext4_xattr_block_csum_verify(struct inode *inode,
141 sector_t block_nr,
142 struct ext4_xattr_header *hdr)
143{
Dmitry Monakhov9aa5d32b2014-10-13 03:36:16 -0400144 if (ext4_has_metadata_csum(inode->i_sb) &&
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400145 (hdr->h_checksum != ext4_xattr_block_csum(inode, block_nr, hdr)))
146 return 0;
147 return 1;
148}
149
150static void ext4_xattr_block_csum_set(struct inode *inode,
151 sector_t block_nr,
152 struct ext4_xattr_header *hdr)
153{
Dmitry Monakhov9aa5d32b2014-10-13 03:36:16 -0400154 if (!ext4_has_metadata_csum(inode->i_sb))
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400155 return;
156
157 hdr->h_checksum = ext4_xattr_block_csum(inode, block_nr, hdr);
158}
159
160static inline int ext4_handle_dirty_xattr_block(handle_t *handle,
161 struct inode *inode,
162 struct buffer_head *bh)
163{
164 ext4_xattr_block_csum_set(inode, bh->b_blocknr, BHDR(bh));
165 return ext4_handle_dirty_metadata(handle, inode, bh);
166}
167
Stephen Hemminger11e27522010-05-13 17:53:18 -0700168static inline const struct xattr_handler *
Mingming Cao617ba132006-10-11 01:20:53 -0700169ext4_xattr_handler(int name_index)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700170{
Stephen Hemminger11e27522010-05-13 17:53:18 -0700171 const struct xattr_handler *handler = NULL;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700172
Mingming Cao617ba132006-10-11 01:20:53 -0700173 if (name_index > 0 && name_index < ARRAY_SIZE(ext4_xattr_handler_map))
174 handler = ext4_xattr_handler_map[name_index];
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700175 return handler;
176}
177
178/*
179 * Inode operation listxattr()
180 *
David Howells2b0143b2015-03-17 22:25:59 +0000181 * d_inode(dentry)->i_mutex: don't care
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700182 */
183ssize_t
Mingming Cao617ba132006-10-11 01:20:53 -0700184ext4_listxattr(struct dentry *dentry, char *buffer, size_t size)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700185{
Christoph Hellwig431547b2009-11-13 09:52:56 +0000186 return ext4_xattr_list(dentry, buffer, size);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700187}
188
189static int
Darrick J. Wonga0626e752014-09-16 14:34:59 -0400190ext4_xattr_check_names(struct ext4_xattr_entry *entry, void *end,
191 void *value_start)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700192{
Darrick J. Wonga0626e752014-09-16 14:34:59 -0400193 struct ext4_xattr_entry *e = entry;
194
195 while (!IS_LAST_ENTRY(e)) {
196 struct ext4_xattr_entry *next = EXT4_XATTR_NEXT(e);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700197 if ((void *)next >= end)
198 return -EIO;
Darrick J. Wonga0626e752014-09-16 14:34:59 -0400199 e = next;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700200 }
Darrick J. Wonga0626e752014-09-16 14:34:59 -0400201
202 while (!IS_LAST_ENTRY(entry)) {
203 if (entry->e_value_size != 0 &&
204 (value_start + le16_to_cpu(entry->e_value_offs) <
205 (void *)e + sizeof(__u32) ||
206 value_start + le16_to_cpu(entry->e_value_offs) +
207 le32_to_cpu(entry->e_value_size) > end))
208 return -EIO;
209 entry = EXT4_XATTR_NEXT(entry);
210 }
211
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700212 return 0;
213}
214
215static inline int
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400216ext4_xattr_check_block(struct inode *inode, struct buffer_head *bh)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700217{
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400218 int error;
219
220 if (buffer_verified(bh))
221 return 0;
222
Mingming Cao617ba132006-10-11 01:20:53 -0700223 if (BHDR(bh)->h_magic != cpu_to_le32(EXT4_XATTR_MAGIC) ||
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700224 BHDR(bh)->h_blocks != cpu_to_le32(1))
225 return -EIO;
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400226 if (!ext4_xattr_block_csum_verify(inode, bh->b_blocknr, BHDR(bh)))
227 return -EIO;
Darrick J. Wonga0626e752014-09-16 14:34:59 -0400228 error = ext4_xattr_check_names(BFIRST(bh), bh->b_data + bh->b_size,
229 bh->b_data);
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400230 if (!error)
231 set_buffer_verified(bh);
232 return error;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700233}
234
235static inline int
Mingming Cao617ba132006-10-11 01:20:53 -0700236ext4_xattr_check_entry(struct ext4_xattr_entry *entry, size_t size)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700237{
238 size_t value_size = le32_to_cpu(entry->e_value_size);
239
240 if (entry->e_value_block != 0 || value_size > size ||
241 le16_to_cpu(entry->e_value_offs) + value_size > size)
242 return -EIO;
243 return 0;
244}
245
246static int
Mingming Cao617ba132006-10-11 01:20:53 -0700247ext4_xattr_find_entry(struct ext4_xattr_entry **pentry, int name_index,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700248 const char *name, size_t size, int sorted)
249{
Mingming Cao617ba132006-10-11 01:20:53 -0700250 struct ext4_xattr_entry *entry;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700251 size_t name_len;
252 int cmp = 1;
253
254 if (name == NULL)
255 return -EINVAL;
256 name_len = strlen(name);
257 entry = *pentry;
Mingming Cao617ba132006-10-11 01:20:53 -0700258 for (; !IS_LAST_ENTRY(entry); entry = EXT4_XATTR_NEXT(entry)) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700259 cmp = name_index - entry->e_name_index;
260 if (!cmp)
261 cmp = name_len - entry->e_name_len;
262 if (!cmp)
263 cmp = memcmp(name, entry->e_name, name_len);
264 if (cmp <= 0 && (sorted || cmp == 0))
265 break;
266 }
267 *pentry = entry;
Mingming Cao617ba132006-10-11 01:20:53 -0700268 if (!cmp && ext4_xattr_check_entry(entry, size))
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700269 return -EIO;
270 return cmp ? -ENODATA : 0;
271}
272
273static int
Mingming Cao617ba132006-10-11 01:20:53 -0700274ext4_xattr_block_get(struct inode *inode, int name_index, const char *name,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700275 void *buffer, size_t buffer_size)
276{
277 struct buffer_head *bh = NULL;
Mingming Cao617ba132006-10-11 01:20:53 -0700278 struct ext4_xattr_entry *entry;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700279 size_t size;
280 int error;
T Makphaibulchoke9c191f72014-03-18 19:24:49 -0400281 struct mb_cache *ext4_mb_cache = EXT4_GET_MB_CACHE(inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700282
283 ea_idebug(inode, "name=%d.%s, buffer=%p, buffer_size=%ld",
284 name_index, name, buffer, (long)buffer_size);
285
286 error = -ENODATA;
Mingming Cao617ba132006-10-11 01:20:53 -0700287 if (!EXT4_I(inode)->i_file_acl)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700288 goto cleanup;
Joe Perchesace36ad2012-03-19 23:11:43 -0400289 ea_idebug(inode, "reading block %llu",
290 (unsigned long long)EXT4_I(inode)->i_file_acl);
Mingming Cao617ba132006-10-11 01:20:53 -0700291 bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700292 if (!bh)
293 goto cleanup;
294 ea_bdebug(bh, "b_count=%d, refcount=%d",
295 atomic_read(&(bh->b_count)), le32_to_cpu(BHDR(bh)->h_refcount));
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400296 if (ext4_xattr_check_block(inode, bh)) {
Eric Sandeen12062dd2010-02-15 14:19:27 -0500297bad_block:
Theodore Ts'o24676da2010-05-16 21:00:00 -0400298 EXT4_ERROR_INODE(inode, "bad block %llu",
299 EXT4_I(inode)->i_file_acl);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700300 error = -EIO;
301 goto cleanup;
302 }
T Makphaibulchoke9c191f72014-03-18 19:24:49 -0400303 ext4_xattr_cache_insert(ext4_mb_cache, bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700304 entry = BFIRST(bh);
Mingming Cao617ba132006-10-11 01:20:53 -0700305 error = ext4_xattr_find_entry(&entry, name_index, name, bh->b_size, 1);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700306 if (error == -EIO)
307 goto bad_block;
308 if (error)
309 goto cleanup;
310 size = le32_to_cpu(entry->e_value_size);
311 if (buffer) {
312 error = -ERANGE;
313 if (size > buffer_size)
314 goto cleanup;
315 memcpy(buffer, bh->b_data + le16_to_cpu(entry->e_value_offs),
316 size);
317 }
318 error = size;
319
320cleanup:
321 brelse(bh);
322 return error;
323}
324
Tao Ma879b3822012-12-05 10:28:46 -0500325int
Mingming Cao617ba132006-10-11 01:20:53 -0700326ext4_xattr_ibody_get(struct inode *inode, int name_index, const char *name,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700327 void *buffer, size_t buffer_size)
328{
Mingming Cao617ba132006-10-11 01:20:53 -0700329 struct ext4_xattr_ibody_header *header;
330 struct ext4_xattr_entry *entry;
331 struct ext4_inode *raw_inode;
332 struct ext4_iloc iloc;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700333 size_t size;
334 void *end;
335 int error;
336
Theodore Ts'o19f5fb72010-01-24 14:34:07 -0500337 if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR))
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700338 return -ENODATA;
Mingming Cao617ba132006-10-11 01:20:53 -0700339 error = ext4_get_inode_loc(inode, &iloc);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700340 if (error)
341 return error;
Mingming Cao617ba132006-10-11 01:20:53 -0700342 raw_inode = ext4_raw_inode(&iloc);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700343 header = IHDR(inode, raw_inode);
344 entry = IFIRST(header);
Mingming Cao617ba132006-10-11 01:20:53 -0700345 end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
Darrick J. Wonga0626e752014-09-16 14:34:59 -0400346 error = ext4_xattr_check_names(entry, end, entry);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700347 if (error)
348 goto cleanup;
Mingming Cao617ba132006-10-11 01:20:53 -0700349 error = ext4_xattr_find_entry(&entry, name_index, name,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700350 end - (void *)entry, 0);
351 if (error)
352 goto cleanup;
353 size = le32_to_cpu(entry->e_value_size);
354 if (buffer) {
355 error = -ERANGE;
356 if (size > buffer_size)
357 goto cleanup;
358 memcpy(buffer, (void *)IFIRST(header) +
359 le16_to_cpu(entry->e_value_offs), size);
360 }
361 error = size;
362
363cleanup:
364 brelse(iloc.bh);
365 return error;
366}
367
368/*
Mingming Cao617ba132006-10-11 01:20:53 -0700369 * ext4_xattr_get()
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700370 *
371 * Copy an extended attribute into the buffer
372 * provided, or compute the buffer size required.
373 * Buffer is NULL to compute the size of the buffer required.
374 *
375 * Returns a negative error number on failure, or the number of bytes
376 * used / required on success.
377 */
378int
Mingming Cao617ba132006-10-11 01:20:53 -0700379ext4_xattr_get(struct inode *inode, int name_index, const char *name,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700380 void *buffer, size_t buffer_size)
381{
382 int error;
383
Zhang Zhen230b8c1a2014-05-12 09:57:59 -0400384 if (strlen(name) > 255)
385 return -ERANGE;
386
Mingming Cao617ba132006-10-11 01:20:53 -0700387 down_read(&EXT4_I(inode)->xattr_sem);
388 error = ext4_xattr_ibody_get(inode, name_index, name, buffer,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700389 buffer_size);
390 if (error == -ENODATA)
Mingming Cao617ba132006-10-11 01:20:53 -0700391 error = ext4_xattr_block_get(inode, name_index, name, buffer,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700392 buffer_size);
Mingming Cao617ba132006-10-11 01:20:53 -0700393 up_read(&EXT4_I(inode)->xattr_sem);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700394 return error;
395}
396
397static int
Christoph Hellwig431547b2009-11-13 09:52:56 +0000398ext4_xattr_list_entries(struct dentry *dentry, struct ext4_xattr_entry *entry,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700399 char *buffer, size_t buffer_size)
400{
401 size_t rest = buffer_size;
402
Mingming Cao617ba132006-10-11 01:20:53 -0700403 for (; !IS_LAST_ENTRY(entry); entry = EXT4_XATTR_NEXT(entry)) {
Stephen Hemminger11e27522010-05-13 17:53:18 -0700404 const struct xattr_handler *handler =
Mingming Cao617ba132006-10-11 01:20:53 -0700405 ext4_xattr_handler(entry->e_name_index);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700406
407 if (handler) {
Christoph Hellwig431547b2009-11-13 09:52:56 +0000408 size_t size = handler->list(dentry, buffer, rest,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700409 entry->e_name,
Christoph Hellwig431547b2009-11-13 09:52:56 +0000410 entry->e_name_len,
411 handler->flags);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700412 if (buffer) {
413 if (size > rest)
414 return -ERANGE;
415 buffer += size;
416 }
417 rest -= size;
418 }
419 }
420 return buffer_size - rest;
421}
422
423static int
Christoph Hellwig431547b2009-11-13 09:52:56 +0000424ext4_xattr_block_list(struct dentry *dentry, char *buffer, size_t buffer_size)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700425{
David Howells2b0143b2015-03-17 22:25:59 +0000426 struct inode *inode = d_inode(dentry);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700427 struct buffer_head *bh = NULL;
428 int error;
T Makphaibulchoke9c191f72014-03-18 19:24:49 -0400429 struct mb_cache *ext4_mb_cache = EXT4_GET_MB_CACHE(inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700430
431 ea_idebug(inode, "buffer=%p, buffer_size=%ld",
432 buffer, (long)buffer_size);
433
434 error = 0;
Mingming Cao617ba132006-10-11 01:20:53 -0700435 if (!EXT4_I(inode)->i_file_acl)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700436 goto cleanup;
Joe Perchesace36ad2012-03-19 23:11:43 -0400437 ea_idebug(inode, "reading block %llu",
438 (unsigned long long)EXT4_I(inode)->i_file_acl);
Mingming Cao617ba132006-10-11 01:20:53 -0700439 bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700440 error = -EIO;
441 if (!bh)
442 goto cleanup;
443 ea_bdebug(bh, "b_count=%d, refcount=%d",
444 atomic_read(&(bh->b_count)), le32_to_cpu(BHDR(bh)->h_refcount));
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400445 if (ext4_xattr_check_block(inode, bh)) {
Theodore Ts'o24676da2010-05-16 21:00:00 -0400446 EXT4_ERROR_INODE(inode, "bad block %llu",
447 EXT4_I(inode)->i_file_acl);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700448 error = -EIO;
449 goto cleanup;
450 }
T Makphaibulchoke9c191f72014-03-18 19:24:49 -0400451 ext4_xattr_cache_insert(ext4_mb_cache, bh);
Christoph Hellwig431547b2009-11-13 09:52:56 +0000452 error = ext4_xattr_list_entries(dentry, BFIRST(bh), buffer, buffer_size);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700453
454cleanup:
455 brelse(bh);
456
457 return error;
458}
459
460static int
Christoph Hellwig431547b2009-11-13 09:52:56 +0000461ext4_xattr_ibody_list(struct dentry *dentry, char *buffer, size_t buffer_size)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700462{
David Howells2b0143b2015-03-17 22:25:59 +0000463 struct inode *inode = d_inode(dentry);
Mingming Cao617ba132006-10-11 01:20:53 -0700464 struct ext4_xattr_ibody_header *header;
465 struct ext4_inode *raw_inode;
466 struct ext4_iloc iloc;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700467 void *end;
468 int error;
469
Theodore Ts'o19f5fb72010-01-24 14:34:07 -0500470 if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR))
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700471 return 0;
Mingming Cao617ba132006-10-11 01:20:53 -0700472 error = ext4_get_inode_loc(inode, &iloc);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700473 if (error)
474 return error;
Mingming Cao617ba132006-10-11 01:20:53 -0700475 raw_inode = ext4_raw_inode(&iloc);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700476 header = IHDR(inode, raw_inode);
Mingming Cao617ba132006-10-11 01:20:53 -0700477 end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
Darrick J. Wonga0626e752014-09-16 14:34:59 -0400478 error = ext4_xattr_check_names(IFIRST(header), end, IFIRST(header));
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700479 if (error)
480 goto cleanup;
Christoph Hellwig431547b2009-11-13 09:52:56 +0000481 error = ext4_xattr_list_entries(dentry, IFIRST(header),
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700482 buffer, buffer_size);
483
484cleanup:
485 brelse(iloc.bh);
486 return error;
487}
488
489/*
Mingming Cao617ba132006-10-11 01:20:53 -0700490 * ext4_xattr_list()
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700491 *
492 * Copy a list of attribute names into the buffer
493 * provided, or compute the buffer size required.
494 * Buffer is NULL to compute the size of the buffer required.
495 *
496 * Returns a negative error number on failure, or the number of bytes
497 * used / required on success.
498 */
Mingming Caod3a95d42008-04-17 10:38:59 -0400499static int
Christoph Hellwig431547b2009-11-13 09:52:56 +0000500ext4_xattr_list(struct dentry *dentry, char *buffer, size_t buffer_size)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700501{
Theodore Ts'oeaeef862011-01-10 12:10:07 -0500502 int ret, ret2;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700503
David Howells2b0143b2015-03-17 22:25:59 +0000504 down_read(&EXT4_I(d_inode(dentry))->xattr_sem);
Theodore Ts'oeaeef862011-01-10 12:10:07 -0500505 ret = ret2 = ext4_xattr_ibody_list(dentry, buffer, buffer_size);
506 if (ret < 0)
507 goto errout;
508 if (buffer) {
509 buffer += ret;
510 buffer_size -= ret;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700511 }
Theodore Ts'oeaeef862011-01-10 12:10:07 -0500512 ret = ext4_xattr_block_list(dentry, buffer, buffer_size);
513 if (ret < 0)
514 goto errout;
515 ret += ret2;
516errout:
David Howells2b0143b2015-03-17 22:25:59 +0000517 up_read(&EXT4_I(d_inode(dentry))->xattr_sem);
Theodore Ts'oeaeef862011-01-10 12:10:07 -0500518 return ret;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700519}
520
521/*
Mingming Cao617ba132006-10-11 01:20:53 -0700522 * If the EXT4_FEATURE_COMPAT_EXT_ATTR feature of this file system is
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700523 * not set, set it.
524 */
Mingming Cao617ba132006-10-11 01:20:53 -0700525static void ext4_xattr_update_super_block(handle_t *handle,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700526 struct super_block *sb)
527{
Mingming Cao617ba132006-10-11 01:20:53 -0700528 if (EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_EXT_ATTR))
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700529 return;
530
liang xie5d601252014-05-12 22:06:43 -0400531 BUFFER_TRACE(EXT4_SB(sb)->s_sbh, "get_write_access");
Mingming Cao617ba132006-10-11 01:20:53 -0700532 if (ext4_journal_get_write_access(handle, EXT4_SB(sb)->s_sbh) == 0) {
Andreas Gruenbachered2908f2006-12-06 20:36:16 -0800533 EXT4_SET_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_EXT_ATTR);
Theodore Ts'oa0375152010-06-11 23:14:04 -0400534 ext4_handle_dirty_super(handle, sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700535 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700536}
537
538/*
Jan Karaec4cb1a2014-04-07 10:54:21 -0400539 * Release the xattr block BH: If the reference count is > 1, decrement it;
540 * otherwise free the block.
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700541 */
542static void
Mingming Cao617ba132006-10-11 01:20:53 -0700543ext4_xattr_release_block(handle_t *handle, struct inode *inode,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700544 struct buffer_head *bh)
545{
546 struct mb_cache_entry *ce = NULL;
Mingming Cao8a2bfdc2007-02-28 20:13:35 -0800547 int error = 0;
T Makphaibulchoke9c191f72014-03-18 19:24:49 -0400548 struct mb_cache *ext4_mb_cache = EXT4_GET_MB_CACHE(inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700549
T Makphaibulchoke9c191f72014-03-18 19:24:49 -0400550 ce = mb_cache_entry_get(ext4_mb_cache, bh->b_bdev, bh->b_blocknr);
liang xie5d601252014-05-12 22:06:43 -0400551 BUFFER_TRACE(bh, "get_write_access");
Mingming Cao8a2bfdc2007-02-28 20:13:35 -0800552 error = ext4_journal_get_write_access(handle, bh);
553 if (error)
554 goto out;
555
556 lock_buffer(bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700557 if (BHDR(bh)->h_refcount == cpu_to_le32(1)) {
558 ea_bdebug(bh, "refcount now=0; freeing");
559 if (ce)
560 mb_cache_entry_free(ce);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700561 get_bh(bh);
Jan Karaec4cb1a2014-04-07 10:54:21 -0400562 unlock_buffer(bh);
Theodore Ts'oe6362602009-11-23 07:17:05 -0500563 ext4_free_blocks(handle, inode, bh, 0, 1,
564 EXT4_FREE_BLOCKS_METADATA |
565 EXT4_FREE_BLOCKS_FORGET);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700566 } else {
Marcin Slusarze8546d02008-04-17 10:38:59 -0400567 le32_add_cpu(&BHDR(bh)->h_refcount, -1);
Eric Sandeenc1bb05a2012-02-20 23:06:18 -0500568 if (ce)
569 mb_cache_entry_release(ce);
Jan Karaec4cb1a2014-04-07 10:54:21 -0400570 /*
571 * Beware of this ugliness: Releasing of xattr block references
572 * from different inodes can race and so we have to protect
573 * from a race where someone else frees the block (and releases
574 * its journal_head) before we are done dirtying the buffer. In
575 * nojournal mode this race is harmless and we actually cannot
576 * call ext4_handle_dirty_xattr_block() with locked buffer as
577 * that function can call sync_dirty_buffer() so for that case
578 * we handle the dirtying after unlocking the buffer.
579 */
580 if (ext4_handle_valid(handle))
581 error = ext4_handle_dirty_xattr_block(handle, inode,
582 bh);
Eric Sandeenc1bb05a2012-02-20 23:06:18 -0500583 unlock_buffer(bh);
Jan Karaec4cb1a2014-04-07 10:54:21 -0400584 if (!ext4_handle_valid(handle))
585 error = ext4_handle_dirty_xattr_block(handle, inode,
586 bh);
Mingming Cao8a2bfdc2007-02-28 20:13:35 -0800587 if (IS_SYNC(inode))
Frank Mayhar03901312009-01-07 00:06:22 -0500588 ext4_handle_sync(handle);
Lukas Czerner1231b3a2013-02-18 12:12:07 -0500589 dquot_free_block(inode, EXT4_C2B(EXT4_SB(inode->i_sb), 1));
Mingming Cao8a2bfdc2007-02-28 20:13:35 -0800590 ea_bdebug(bh, "refcount now=%d; releasing",
591 le32_to_cpu(BHDR(bh)->h_refcount));
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700592 }
Mingming Cao8a2bfdc2007-02-28 20:13:35 -0800593out:
594 ext4_std_error(inode->i_sb, error);
595 return;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700596}
597
Kalpak Shah6dd4ee72007-07-18 09:19:57 -0400598/*
599 * Find the available free space for EAs. This also returns the total number of
600 * bytes used by EA entries.
601 */
602static size_t ext4_xattr_free_space(struct ext4_xattr_entry *last,
603 size_t *min_offs, void *base, int *total)
604{
605 for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
Kalpak Shah6dd4ee72007-07-18 09:19:57 -0400606 if (!last->e_value_block && last->e_value_size) {
607 size_t offs = le16_to_cpu(last->e_value_offs);
608 if (offs < *min_offs)
609 *min_offs = offs;
610 }
Theodore Ts'o7b1b2c12014-02-19 20:15:21 -0500611 if (total)
612 *total += EXT4_XATTR_LEN(last->e_name_len);
Kalpak Shah6dd4ee72007-07-18 09:19:57 -0400613 }
614 return (*min_offs - ((void *)last - base) - sizeof(__u32));
615}
616
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700617static int
Mingming Cao617ba132006-10-11 01:20:53 -0700618ext4_xattr_set_entry(struct ext4_xattr_info *i, struct ext4_xattr_search *s)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700619{
Mingming Cao617ba132006-10-11 01:20:53 -0700620 struct ext4_xattr_entry *last;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700621 size_t free, min_offs = s->end - s->base, name_len = strlen(i->name);
622
623 /* Compute min_offs and last. */
624 last = s->first;
Mingming Cao617ba132006-10-11 01:20:53 -0700625 for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700626 if (!last->e_value_block && last->e_value_size) {
627 size_t offs = le16_to_cpu(last->e_value_offs);
628 if (offs < min_offs)
629 min_offs = offs;
630 }
631 }
632 free = min_offs - ((void *)last - s->base) - sizeof(__u32);
633 if (!s->not_found) {
634 if (!s->here->e_value_block && s->here->e_value_size) {
635 size_t size = le32_to_cpu(s->here->e_value_size);
Mingming Cao617ba132006-10-11 01:20:53 -0700636 free += EXT4_XATTR_SIZE(size);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700637 }
Mingming Cao617ba132006-10-11 01:20:53 -0700638 free += EXT4_XATTR_LEN(name_len);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700639 }
640 if (i->value) {
Wei Yuan5f80f622015-04-02 23:50:48 -0400641 if (free < EXT4_XATTR_LEN(name_len) +
Mingming Cao617ba132006-10-11 01:20:53 -0700642 EXT4_XATTR_SIZE(i->value_len))
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700643 return -ENOSPC;
644 }
645
646 if (i->value && s->not_found) {
647 /* Insert the new name. */
Mingming Cao617ba132006-10-11 01:20:53 -0700648 size_t size = EXT4_XATTR_LEN(name_len);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700649 size_t rest = (void *)last - (void *)s->here + sizeof(__u32);
650 memmove((void *)s->here + size, s->here, rest);
651 memset(s->here, 0, size);
652 s->here->e_name_index = i->name_index;
653 s->here->e_name_len = name_len;
654 memcpy(s->here->e_name, i->name, name_len);
655 } else {
656 if (!s->here->e_value_block && s->here->e_value_size) {
657 void *first_val = s->base + min_offs;
658 size_t offs = le16_to_cpu(s->here->e_value_offs);
659 void *val = s->base + offs;
Mingming Cao617ba132006-10-11 01:20:53 -0700660 size_t size = EXT4_XATTR_SIZE(
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700661 le32_to_cpu(s->here->e_value_size));
662
Mingming Cao617ba132006-10-11 01:20:53 -0700663 if (i->value && size == EXT4_XATTR_SIZE(i->value_len)) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700664 /* The old and the new value have the same
665 size. Just replace. */
666 s->here->e_value_size =
667 cpu_to_le32(i->value_len);
Theodore Ts'obd9926e2012-12-11 03:31:49 -0500668 if (i->value == EXT4_ZERO_XATTR_VALUE) {
669 memset(val, 0, size);
670 } else {
671 /* Clear pad bytes first. */
672 memset(val + size - EXT4_XATTR_PAD, 0,
673 EXT4_XATTR_PAD);
674 memcpy(val, i->value, i->value_len);
675 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700676 return 0;
677 }
678
679 /* Remove the old value. */
680 memmove(first_val + size, first_val, val - first_val);
681 memset(first_val, 0, size);
682 s->here->e_value_size = 0;
683 s->here->e_value_offs = 0;
684 min_offs += size;
685
686 /* Adjust all value offsets. */
687 last = s->first;
688 while (!IS_LAST_ENTRY(last)) {
689 size_t o = le16_to_cpu(last->e_value_offs);
690 if (!last->e_value_block &&
691 last->e_value_size && o < offs)
692 last->e_value_offs =
693 cpu_to_le16(o + size);
Mingming Cao617ba132006-10-11 01:20:53 -0700694 last = EXT4_XATTR_NEXT(last);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700695 }
696 }
697 if (!i->value) {
698 /* Remove the old name. */
Mingming Cao617ba132006-10-11 01:20:53 -0700699 size_t size = EXT4_XATTR_LEN(name_len);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700700 last = ENTRY((void *)last - size);
701 memmove(s->here, (void *)s->here + size,
702 (void *)last - (void *)s->here + sizeof(__u32));
703 memset(last, 0, size);
704 }
705 }
706
707 if (i->value) {
708 /* Insert the new value. */
709 s->here->e_value_size = cpu_to_le32(i->value_len);
710 if (i->value_len) {
Mingming Cao617ba132006-10-11 01:20:53 -0700711 size_t size = EXT4_XATTR_SIZE(i->value_len);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700712 void *val = s->base + min_offs - size;
713 s->here->e_value_offs = cpu_to_le16(min_offs - size);
Theodore Ts'obd9926e2012-12-11 03:31:49 -0500714 if (i->value == EXT4_ZERO_XATTR_VALUE) {
715 memset(val, 0, size);
716 } else {
717 /* Clear the pad bytes first. */
718 memset(val + size - EXT4_XATTR_PAD, 0,
719 EXT4_XATTR_PAD);
720 memcpy(val, i->value, i->value_len);
721 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700722 }
723 }
724 return 0;
725}
726
Mingming Cao617ba132006-10-11 01:20:53 -0700727struct ext4_xattr_block_find {
728 struct ext4_xattr_search s;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700729 struct buffer_head *bh;
730};
731
732static int
Mingming Cao617ba132006-10-11 01:20:53 -0700733ext4_xattr_block_find(struct inode *inode, struct ext4_xattr_info *i,
734 struct ext4_xattr_block_find *bs)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700735{
736 struct super_block *sb = inode->i_sb;
737 int error;
738
739 ea_idebug(inode, "name=%d.%s, value=%p, value_len=%ld",
740 i->name_index, i->name, i->value, (long)i->value_len);
741
Mingming Cao617ba132006-10-11 01:20:53 -0700742 if (EXT4_I(inode)->i_file_acl) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700743 /* The inode already has an extended attribute block. */
Mingming Cao617ba132006-10-11 01:20:53 -0700744 bs->bh = sb_bread(sb, EXT4_I(inode)->i_file_acl);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700745 error = -EIO;
746 if (!bs->bh)
747 goto cleanup;
748 ea_bdebug(bs->bh, "b_count=%d, refcount=%d",
749 atomic_read(&(bs->bh->b_count)),
750 le32_to_cpu(BHDR(bs->bh)->h_refcount));
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400751 if (ext4_xattr_check_block(inode, bs->bh)) {
Theodore Ts'o24676da2010-05-16 21:00:00 -0400752 EXT4_ERROR_INODE(inode, "bad block %llu",
753 EXT4_I(inode)->i_file_acl);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700754 error = -EIO;
755 goto cleanup;
756 }
757 /* Find the named attribute. */
758 bs->s.base = BHDR(bs->bh);
759 bs->s.first = BFIRST(bs->bh);
760 bs->s.end = bs->bh->b_data + bs->bh->b_size;
761 bs->s.here = bs->s.first;
Mingming Cao617ba132006-10-11 01:20:53 -0700762 error = ext4_xattr_find_entry(&bs->s.here, i->name_index,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700763 i->name, bs->bh->b_size, 1);
764 if (error && error != -ENODATA)
765 goto cleanup;
766 bs->s.not_found = error;
767 }
768 error = 0;
769
770cleanup:
771 return error;
772}
773
774static int
Mingming Cao617ba132006-10-11 01:20:53 -0700775ext4_xattr_block_set(handle_t *handle, struct inode *inode,
776 struct ext4_xattr_info *i,
777 struct ext4_xattr_block_find *bs)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700778{
779 struct super_block *sb = inode->i_sb;
780 struct buffer_head *new_bh = NULL;
Mingming Cao617ba132006-10-11 01:20:53 -0700781 struct ext4_xattr_search *s = &bs->s;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700782 struct mb_cache_entry *ce = NULL;
Mingming Cao8a2bfdc2007-02-28 20:13:35 -0800783 int error = 0;
T Makphaibulchoke9c191f72014-03-18 19:24:49 -0400784 struct mb_cache *ext4_mb_cache = EXT4_GET_MB_CACHE(inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700785
Mingming Cao617ba132006-10-11 01:20:53 -0700786#define header(x) ((struct ext4_xattr_header *)(x))
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700787
788 if (i->value && i->value_len > sb->s_blocksize)
789 return -ENOSPC;
790 if (s->base) {
T Makphaibulchoke9c191f72014-03-18 19:24:49 -0400791 ce = mb_cache_entry_get(ext4_mb_cache, bs->bh->b_bdev,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700792 bs->bh->b_blocknr);
liang xie5d601252014-05-12 22:06:43 -0400793 BUFFER_TRACE(bs->bh, "get_write_access");
Mingming Cao8a2bfdc2007-02-28 20:13:35 -0800794 error = ext4_journal_get_write_access(handle, bs->bh);
795 if (error)
796 goto cleanup;
797 lock_buffer(bs->bh);
798
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700799 if (header(s->base)->h_refcount == cpu_to_le32(1)) {
800 if (ce) {
801 mb_cache_entry_free(ce);
802 ce = NULL;
803 }
804 ea_bdebug(bs->bh, "modifying in-place");
Mingming Cao617ba132006-10-11 01:20:53 -0700805 error = ext4_xattr_set_entry(i, s);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700806 if (!error) {
807 if (!IS_LAST_ENTRY(s->first))
Mingming Cao617ba132006-10-11 01:20:53 -0700808 ext4_xattr_rehash(header(s->base),
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700809 s->here);
T Makphaibulchoke9c191f72014-03-18 19:24:49 -0400810 ext4_xattr_cache_insert(ext4_mb_cache,
811 bs->bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700812 }
813 unlock_buffer(bs->bh);
814 if (error == -EIO)
815 goto bad_block;
816 if (!error)
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400817 error = ext4_handle_dirty_xattr_block(handle,
818 inode,
819 bs->bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700820 if (error)
821 goto cleanup;
822 goto inserted;
823 } else {
824 int offset = (char *)s->here - bs->bh->b_data;
825
Mingming Cao8a2bfdc2007-02-28 20:13:35 -0800826 unlock_buffer(bs->bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700827 if (ce) {
828 mb_cache_entry_release(ce);
829 ce = NULL;
830 }
831 ea_bdebug(bs->bh, "cloning");
Josef Bacik216553c2008-04-29 22:02:02 -0400832 s->base = kmalloc(bs->bh->b_size, GFP_NOFS);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700833 error = -ENOMEM;
834 if (s->base == NULL)
835 goto cleanup;
836 memcpy(s->base, BHDR(bs->bh), bs->bh->b_size);
837 s->first = ENTRY(header(s->base)+1);
838 header(s->base)->h_refcount = cpu_to_le32(1);
839 s->here = ENTRY(s->base + offset);
840 s->end = s->base + bs->bh->b_size;
841 }
842 } else {
843 /* Allocate a buffer where we construct the new block. */
Josef Bacik216553c2008-04-29 22:02:02 -0400844 s->base = kzalloc(sb->s_blocksize, GFP_NOFS);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700845 /* assert(header == s->base) */
846 error = -ENOMEM;
847 if (s->base == NULL)
848 goto cleanup;
Mingming Cao617ba132006-10-11 01:20:53 -0700849 header(s->base)->h_magic = cpu_to_le32(EXT4_XATTR_MAGIC);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700850 header(s->base)->h_blocks = cpu_to_le32(1);
851 header(s->base)->h_refcount = cpu_to_le32(1);
852 s->first = ENTRY(header(s->base)+1);
853 s->here = ENTRY(header(s->base)+1);
854 s->end = s->base + sb->s_blocksize;
855 }
856
Mingming Cao617ba132006-10-11 01:20:53 -0700857 error = ext4_xattr_set_entry(i, s);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700858 if (error == -EIO)
859 goto bad_block;
860 if (error)
861 goto cleanup;
862 if (!IS_LAST_ENTRY(s->first))
Mingming Cao617ba132006-10-11 01:20:53 -0700863 ext4_xattr_rehash(header(s->base), s->here);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700864
865inserted:
866 if (!IS_LAST_ENTRY(s->first)) {
Mingming Cao617ba132006-10-11 01:20:53 -0700867 new_bh = ext4_xattr_cache_find(inode, header(s->base), &ce);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700868 if (new_bh) {
869 /* We found an identical block in the cache. */
870 if (new_bh == bs->bh)
871 ea_bdebug(new_bh, "keeping");
872 else {
873 /* The old block is released after updating
874 the inode. */
Lukas Czerner1231b3a2013-02-18 12:12:07 -0500875 error = dquot_alloc_block(inode,
876 EXT4_C2B(EXT4_SB(sb), 1));
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500877 if (error)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700878 goto cleanup;
liang xie5d601252014-05-12 22:06:43 -0400879 BUFFER_TRACE(new_bh, "get_write_access");
Mingming Cao617ba132006-10-11 01:20:53 -0700880 error = ext4_journal_get_write_access(handle,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700881 new_bh);
882 if (error)
883 goto cleanup_dquot;
884 lock_buffer(new_bh);
Marcin Slusarze8546d02008-04-17 10:38:59 -0400885 le32_add_cpu(&BHDR(new_bh)->h_refcount, 1);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700886 ea_bdebug(new_bh, "reusing; refcount now=%d",
887 le32_to_cpu(BHDR(new_bh)->h_refcount));
888 unlock_buffer(new_bh);
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400889 error = ext4_handle_dirty_xattr_block(handle,
890 inode,
891 new_bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700892 if (error)
893 goto cleanup_dquot;
894 }
895 mb_cache_entry_release(ce);
896 ce = NULL;
897 } else if (bs->bh && s->base == bs->bh->b_data) {
898 /* We were modifying this block in-place. */
899 ea_bdebug(bs->bh, "keeping this block");
900 new_bh = bs->bh;
901 get_bh(new_bh);
902 } else {
903 /* We need to allocate a new block */
Eric Sandeenfb0a3872009-09-16 14:45:10 -0400904 ext4_fsblk_t goal, block;
905
906 goal = ext4_group_first_block_no(sb,
Akinobu Mitad00a6d72008-04-17 10:38:59 -0400907 EXT4_I(inode)->i_block_group);
Eric Sandeenfb0a3872009-09-16 14:45:10 -0400908
909 /* non-extent files can't have physical blocks past 2^32 */
Dmitry Monakhov12e9b892010-05-16 22:00:00 -0400910 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
Eric Sandeenfb0a3872009-09-16 14:45:10 -0400911 goal = goal & EXT4_MAX_BLOCK_FILE_PHYS;
912
Allison Henderson55f020d2011-05-25 07:41:26 -0400913 block = ext4_new_meta_blocks(handle, inode, goal, 0,
914 NULL, &error);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700915 if (error)
916 goto cleanup;
Eric Sandeenfb0a3872009-09-16 14:45:10 -0400917
Dmitry Monakhov12e9b892010-05-16 22:00:00 -0400918 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
Eric Sandeenfb0a3872009-09-16 14:45:10 -0400919 BUG_ON(block > EXT4_MAX_BLOCK_FILE_PHYS);
920
Joe Perchesace36ad2012-03-19 23:11:43 -0400921 ea_idebug(inode, "creating block %llu",
922 (unsigned long long)block);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700923
924 new_bh = sb_getblk(sb, block);
Wang Shilongaebf0242013-01-12 16:28:47 -0500925 if (unlikely(!new_bh)) {
Theodore Ts'o860d21e2013-01-12 16:19:36 -0500926 error = -ENOMEM;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700927getblk_failed:
Peter Huewe7dc57612011-02-21 21:01:42 -0500928 ext4_free_blocks(handle, inode, NULL, block, 1,
Theodore Ts'oe6362602009-11-23 07:17:05 -0500929 EXT4_FREE_BLOCKS_METADATA);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700930 goto cleanup;
931 }
932 lock_buffer(new_bh);
Mingming Cao617ba132006-10-11 01:20:53 -0700933 error = ext4_journal_get_create_access(handle, new_bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700934 if (error) {
935 unlock_buffer(new_bh);
Theodore Ts'o860d21e2013-01-12 16:19:36 -0500936 error = -EIO;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700937 goto getblk_failed;
938 }
939 memcpy(new_bh->b_data, s->base, new_bh->b_size);
940 set_buffer_uptodate(new_bh);
941 unlock_buffer(new_bh);
T Makphaibulchoke9c191f72014-03-18 19:24:49 -0400942 ext4_xattr_cache_insert(ext4_mb_cache, new_bh);
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -0400943 error = ext4_handle_dirty_xattr_block(handle,
944 inode, new_bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700945 if (error)
946 goto cleanup;
947 }
948 }
949
950 /* Update the inode. */
Mingming Cao617ba132006-10-11 01:20:53 -0700951 EXT4_I(inode)->i_file_acl = new_bh ? new_bh->b_blocknr : 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700952
953 /* Drop the previous xattr block. */
954 if (bs->bh && bs->bh != new_bh)
Mingming Cao617ba132006-10-11 01:20:53 -0700955 ext4_xattr_release_block(handle, inode, bs->bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700956 error = 0;
957
958cleanup:
959 if (ce)
960 mb_cache_entry_release(ce);
961 brelse(new_bh);
962 if (!(bs->bh && s->base == bs->bh->b_data))
963 kfree(s->base);
964
965 return error;
966
967cleanup_dquot:
Lukas Czerner1231b3a2013-02-18 12:12:07 -0500968 dquot_free_block(inode, EXT4_C2B(EXT4_SB(sb), 1));
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700969 goto cleanup;
970
971bad_block:
Theodore Ts'o24676da2010-05-16 21:00:00 -0400972 EXT4_ERROR_INODE(inode, "bad block %llu",
973 EXT4_I(inode)->i_file_acl);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700974 goto cleanup;
975
976#undef header
977}
978
Tao Ma879b3822012-12-05 10:28:46 -0500979int ext4_xattr_ibody_find(struct inode *inode, struct ext4_xattr_info *i,
980 struct ext4_xattr_ibody_find *is)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700981{
Mingming Cao617ba132006-10-11 01:20:53 -0700982 struct ext4_xattr_ibody_header *header;
983 struct ext4_inode *raw_inode;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700984 int error;
985
Mingming Cao617ba132006-10-11 01:20:53 -0700986 if (EXT4_I(inode)->i_extra_isize == 0)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700987 return 0;
Mingming Cao617ba132006-10-11 01:20:53 -0700988 raw_inode = ext4_raw_inode(&is->iloc);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700989 header = IHDR(inode, raw_inode);
990 is->s.base = is->s.first = IFIRST(header);
991 is->s.here = is->s.first;
Mingming Cao617ba132006-10-11 01:20:53 -0700992 is->s.end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
Theodore Ts'o19f5fb72010-01-24 14:34:07 -0500993 if (ext4_test_inode_state(inode, EXT4_STATE_XATTR)) {
Darrick J. Wonga0626e752014-09-16 14:34:59 -0400994 error = ext4_xattr_check_names(IFIRST(header), is->s.end,
995 IFIRST(header));
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700996 if (error)
997 return error;
998 /* Find the named attribute. */
Mingming Cao617ba132006-10-11 01:20:53 -0700999 error = ext4_xattr_find_entry(&is->s.here, i->name_index,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001000 i->name, is->s.end -
1001 (void *)is->s.base, 0);
1002 if (error && error != -ENODATA)
1003 return error;
1004 is->s.not_found = error;
1005 }
1006 return 0;
1007}
1008
Tao Ma0d812f72012-12-10 14:06:02 -05001009int ext4_xattr_ibody_inline_set(handle_t *handle, struct inode *inode,
1010 struct ext4_xattr_info *i,
1011 struct ext4_xattr_ibody_find *is)
1012{
1013 struct ext4_xattr_ibody_header *header;
1014 struct ext4_xattr_search *s = &is->s;
1015 int error;
1016
1017 if (EXT4_I(inode)->i_extra_isize == 0)
1018 return -ENOSPC;
1019 error = ext4_xattr_set_entry(i, s);
1020 if (error) {
1021 if (error == -ENOSPC &&
1022 ext4_has_inline_data(inode)) {
1023 error = ext4_try_to_evict_inline_data(handle, inode,
1024 EXT4_XATTR_LEN(strlen(i->name) +
1025 EXT4_XATTR_SIZE(i->value_len)));
1026 if (error)
1027 return error;
1028 error = ext4_xattr_ibody_find(inode, i, is);
1029 if (error)
1030 return error;
1031 error = ext4_xattr_set_entry(i, s);
1032 }
1033 if (error)
1034 return error;
1035 }
1036 header = IHDR(inode, ext4_raw_inode(&is->iloc));
1037 if (!IS_LAST_ENTRY(s->first)) {
1038 header->h_magic = cpu_to_le32(EXT4_XATTR_MAGIC);
1039 ext4_set_inode_state(inode, EXT4_STATE_XATTR);
1040 } else {
1041 header->h_magic = cpu_to_le32(0);
1042 ext4_clear_inode_state(inode, EXT4_STATE_XATTR);
1043 }
1044 return 0;
1045}
1046
1047static int ext4_xattr_ibody_set(handle_t *handle, struct inode *inode,
1048 struct ext4_xattr_info *i,
1049 struct ext4_xattr_ibody_find *is)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001050{
Mingming Cao617ba132006-10-11 01:20:53 -07001051 struct ext4_xattr_ibody_header *header;
1052 struct ext4_xattr_search *s = &is->s;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001053 int error;
1054
Mingming Cao617ba132006-10-11 01:20:53 -07001055 if (EXT4_I(inode)->i_extra_isize == 0)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001056 return -ENOSPC;
Mingming Cao617ba132006-10-11 01:20:53 -07001057 error = ext4_xattr_set_entry(i, s);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001058 if (error)
1059 return error;
Mingming Cao617ba132006-10-11 01:20:53 -07001060 header = IHDR(inode, ext4_raw_inode(&is->iloc));
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001061 if (!IS_LAST_ENTRY(s->first)) {
Mingming Cao617ba132006-10-11 01:20:53 -07001062 header->h_magic = cpu_to_le32(EXT4_XATTR_MAGIC);
Theodore Ts'o19f5fb72010-01-24 14:34:07 -05001063 ext4_set_inode_state(inode, EXT4_STATE_XATTR);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001064 } else {
1065 header->h_magic = cpu_to_le32(0);
Theodore Ts'o19f5fb72010-01-24 14:34:07 -05001066 ext4_clear_inode_state(inode, EXT4_STATE_XATTR);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001067 }
1068 return 0;
1069}
1070
1071/*
Mingming Cao617ba132006-10-11 01:20:53 -07001072 * ext4_xattr_set_handle()
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001073 *
Wang Sheng-Hui6e9510b2011-01-10 12:10:30 -05001074 * Create, replace or remove an extended attribute for this inode. Value
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001075 * is NULL to remove an existing extended attribute, and non-NULL to
1076 * either replace an existing extended attribute, or create a new extended
1077 * attribute. The flags XATTR_REPLACE and XATTR_CREATE
1078 * specify that an extended attribute must exist and must not exist
1079 * previous to the call, respectively.
1080 *
1081 * Returns 0, or a negative error number on failure.
1082 */
1083int
Mingming Cao617ba132006-10-11 01:20:53 -07001084ext4_xattr_set_handle(handle_t *handle, struct inode *inode, int name_index,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001085 const char *name, const void *value, size_t value_len,
1086 int flags)
1087{
Mingming Cao617ba132006-10-11 01:20:53 -07001088 struct ext4_xattr_info i = {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001089 .name_index = name_index,
1090 .name = name,
1091 .value = value,
1092 .value_len = value_len,
1093
1094 };
Mingming Cao617ba132006-10-11 01:20:53 -07001095 struct ext4_xattr_ibody_find is = {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001096 .s = { .not_found = -ENODATA, },
1097 };
Mingming Cao617ba132006-10-11 01:20:53 -07001098 struct ext4_xattr_block_find bs = {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001099 .s = { .not_found = -ENODATA, },
1100 };
Kalpak Shah4d20c682008-10-08 23:21:54 -04001101 unsigned long no_expand;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001102 int error;
1103
1104 if (!name)
1105 return -EINVAL;
1106 if (strlen(name) > 255)
1107 return -ERANGE;
Mingming Cao617ba132006-10-11 01:20:53 -07001108 down_write(&EXT4_I(inode)->xattr_sem);
Theodore Ts'o19f5fb72010-01-24 14:34:07 -05001109 no_expand = ext4_test_inode_state(inode, EXT4_STATE_NO_EXPAND);
1110 ext4_set_inode_state(inode, EXT4_STATE_NO_EXPAND);
Kalpak Shah4d20c682008-10-08 23:21:54 -04001111
Eric Sandeen66543612011-10-26 03:32:07 -04001112 error = ext4_reserve_inode_write(handle, inode, &is.iloc);
Eric Sandeen86ebfd02009-11-15 15:30:52 -05001113 if (error)
1114 goto cleanup;
1115
Theodore Ts'o19f5fb72010-01-24 14:34:07 -05001116 if (ext4_test_inode_state(inode, EXT4_STATE_NEW)) {
Mingming Cao617ba132006-10-11 01:20:53 -07001117 struct ext4_inode *raw_inode = ext4_raw_inode(&is.iloc);
1118 memset(raw_inode, 0, EXT4_SB(inode->i_sb)->s_inode_size);
Theodore Ts'o19f5fb72010-01-24 14:34:07 -05001119 ext4_clear_inode_state(inode, EXT4_STATE_NEW);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001120 }
1121
Mingming Cao617ba132006-10-11 01:20:53 -07001122 error = ext4_xattr_ibody_find(inode, &i, &is);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001123 if (error)
1124 goto cleanup;
1125 if (is.s.not_found)
Mingming Cao617ba132006-10-11 01:20:53 -07001126 error = ext4_xattr_block_find(inode, &i, &bs);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001127 if (error)
1128 goto cleanup;
1129 if (is.s.not_found && bs.s.not_found) {
1130 error = -ENODATA;
1131 if (flags & XATTR_REPLACE)
1132 goto cleanup;
1133 error = 0;
1134 if (!value)
1135 goto cleanup;
1136 } else {
1137 error = -EEXIST;
1138 if (flags & XATTR_CREATE)
1139 goto cleanup;
1140 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001141 if (!value) {
1142 if (!is.s.not_found)
Mingming Cao617ba132006-10-11 01:20:53 -07001143 error = ext4_xattr_ibody_set(handle, inode, &i, &is);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001144 else if (!bs.s.not_found)
Mingming Cao617ba132006-10-11 01:20:53 -07001145 error = ext4_xattr_block_set(handle, inode, &i, &bs);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001146 } else {
Mingming Cao617ba132006-10-11 01:20:53 -07001147 error = ext4_xattr_ibody_set(handle, inode, &i, &is);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001148 if (!error && !bs.s.not_found) {
1149 i.value = NULL;
Mingming Cao617ba132006-10-11 01:20:53 -07001150 error = ext4_xattr_block_set(handle, inode, &i, &bs);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001151 } else if (error == -ENOSPC) {
Tiger Yang7e01c8e2008-05-14 16:05:47 -07001152 if (EXT4_I(inode)->i_file_acl && !bs.s.base) {
1153 error = ext4_xattr_block_find(inode, &i, &bs);
1154 if (error)
1155 goto cleanup;
1156 }
Mingming Cao617ba132006-10-11 01:20:53 -07001157 error = ext4_xattr_block_set(handle, inode, &i, &bs);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001158 if (error)
1159 goto cleanup;
1160 if (!is.s.not_found) {
1161 i.value = NULL;
Mingming Cao617ba132006-10-11 01:20:53 -07001162 error = ext4_xattr_ibody_set(handle, inode, &i,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001163 &is);
1164 }
1165 }
1166 }
1167 if (!error) {
Mingming Cao617ba132006-10-11 01:20:53 -07001168 ext4_xattr_update_super_block(handle, inode->i_sb);
Kalpak Shahef7f3832007-07-18 09:15:20 -04001169 inode->i_ctime = ext4_current_time(inode);
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04001170 if (!value)
Theodore Ts'o19f5fb72010-01-24 14:34:07 -05001171 ext4_clear_inode_state(inode, EXT4_STATE_NO_EXPAND);
Mingming Cao617ba132006-10-11 01:20:53 -07001172 error = ext4_mark_iloc_dirty(handle, inode, &is.iloc);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001173 /*
Mingming Cao617ba132006-10-11 01:20:53 -07001174 * The bh is consumed by ext4_mark_iloc_dirty, even with
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001175 * error != 0.
1176 */
1177 is.iloc.bh = NULL;
1178 if (IS_SYNC(inode))
Frank Mayhar03901312009-01-07 00:06:22 -05001179 ext4_handle_sync(handle);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001180 }
1181
1182cleanup:
1183 brelse(is.iloc.bh);
1184 brelse(bs.bh);
Kalpak Shah4d20c682008-10-08 23:21:54 -04001185 if (no_expand == 0)
Theodore Ts'o19f5fb72010-01-24 14:34:07 -05001186 ext4_clear_inode_state(inode, EXT4_STATE_NO_EXPAND);
Mingming Cao617ba132006-10-11 01:20:53 -07001187 up_write(&EXT4_I(inode)->xattr_sem);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001188 return error;
1189}
1190
1191/*
Mingming Cao617ba132006-10-11 01:20:53 -07001192 * ext4_xattr_set()
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001193 *
Mingming Cao617ba132006-10-11 01:20:53 -07001194 * Like ext4_xattr_set_handle, but start from an inode. This extended
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001195 * attribute modification is a filesystem transaction by itself.
1196 *
1197 * Returns 0, or a negative error number on failure.
1198 */
1199int
Mingming Cao617ba132006-10-11 01:20:53 -07001200ext4_xattr_set(struct inode *inode, int name_index, const char *name,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001201 const void *value, size_t value_len, int flags)
1202{
1203 handle_t *handle;
1204 int error, retries = 0;
Theodore Ts'o95eaefb2013-02-09 15:23:03 -05001205 int credits = ext4_jbd2_credits_xattr(inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001206
1207retry:
Theodore Ts'o9924a922013-02-08 21:59:22 -05001208 handle = ext4_journal_start(inode, EXT4_HT_XATTR, credits);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001209 if (IS_ERR(handle)) {
1210 error = PTR_ERR(handle);
1211 } else {
1212 int error2;
1213
Mingming Cao617ba132006-10-11 01:20:53 -07001214 error = ext4_xattr_set_handle(handle, inode, name_index, name,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001215 value, value_len, flags);
Mingming Cao617ba132006-10-11 01:20:53 -07001216 error2 = ext4_journal_stop(handle);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001217 if (error == -ENOSPC &&
Mingming Cao617ba132006-10-11 01:20:53 -07001218 ext4_should_retry_alloc(inode->i_sb, &retries))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001219 goto retry;
1220 if (error == 0)
1221 error = error2;
1222 }
1223
1224 return error;
1225}
1226
1227/*
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04001228 * Shift the EA entries in the inode to create space for the increased
1229 * i_extra_isize.
1230 */
1231static void ext4_xattr_shift_entries(struct ext4_xattr_entry *entry,
1232 int value_offs_shift, void *to,
1233 void *from, size_t n, int blocksize)
1234{
1235 struct ext4_xattr_entry *last = entry;
1236 int new_offs;
1237
1238 /* Adjust the value offsets of the entries */
1239 for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
1240 if (!last->e_value_block && last->e_value_size) {
1241 new_offs = le16_to_cpu(last->e_value_offs) +
1242 value_offs_shift;
1243 BUG_ON(new_offs + le32_to_cpu(last->e_value_size)
1244 > blocksize);
1245 last->e_value_offs = cpu_to_le16(new_offs);
1246 }
1247 }
1248 /* Shift the entries by n bytes */
1249 memmove(to, from, n);
1250}
1251
1252/*
1253 * Expand an inode by new_extra_isize bytes when EAs are present.
1254 * Returns 0 on success or negative error number on failure.
1255 */
1256int ext4_expand_extra_isize_ea(struct inode *inode, int new_extra_isize,
1257 struct ext4_inode *raw_inode, handle_t *handle)
1258{
1259 struct ext4_xattr_ibody_header *header;
1260 struct ext4_xattr_entry *entry, *last, *first;
1261 struct buffer_head *bh = NULL;
1262 struct ext4_xattr_ibody_find *is = NULL;
1263 struct ext4_xattr_block_find *bs = NULL;
1264 char *buffer = NULL, *b_entry_name = NULL;
1265 size_t min_offs, free;
Theodore Ts'o7b1b2c12014-02-19 20:15:21 -05001266 int total_ino;
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04001267 void *base, *start, *end;
1268 int extra_isize = 0, error = 0, tried_min_extra_isize = 0;
Aneesh Kumar K.Vac398492007-10-16 18:38:25 -04001269 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 -04001270
1271 down_write(&EXT4_I(inode)->xattr_sem);
1272retry:
1273 if (EXT4_I(inode)->i_extra_isize >= new_extra_isize) {
1274 up_write(&EXT4_I(inode)->xattr_sem);
1275 return 0;
1276 }
1277
1278 header = IHDR(inode, raw_inode);
1279 entry = IFIRST(header);
1280
1281 /*
1282 * Check if enough free space is available in the inode to shift the
1283 * entries ahead by new_extra_isize.
1284 */
1285
1286 base = start = entry;
1287 end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
1288 min_offs = end - base;
1289 last = entry;
1290 total_ino = sizeof(struct ext4_xattr_ibody_header);
1291
1292 free = ext4_xattr_free_space(last, &min_offs, base, &total_ino);
1293 if (free >= new_extra_isize) {
1294 entry = IFIRST(header);
1295 ext4_xattr_shift_entries(entry, EXT4_I(inode)->i_extra_isize
1296 - new_extra_isize, (void *)raw_inode +
1297 EXT4_GOOD_OLD_INODE_SIZE + new_extra_isize,
1298 (void *)header, total_ino,
1299 inode->i_sb->s_blocksize);
1300 EXT4_I(inode)->i_extra_isize = new_extra_isize;
1301 error = 0;
1302 goto cleanup;
1303 }
1304
1305 /*
1306 * Enough free space isn't available in the inode, check if
1307 * EA block can hold new_extra_isize bytes.
1308 */
1309 if (EXT4_I(inode)->i_file_acl) {
1310 bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl);
1311 error = -EIO;
1312 if (!bh)
1313 goto cleanup;
Darrick J. Wongcc8e94f2012-04-29 18:43:10 -04001314 if (ext4_xattr_check_block(inode, bh)) {
Theodore Ts'o24676da2010-05-16 21:00:00 -04001315 EXT4_ERROR_INODE(inode, "bad block %llu",
1316 EXT4_I(inode)->i_file_acl);
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04001317 error = -EIO;
1318 goto cleanup;
1319 }
1320 base = BHDR(bh);
1321 first = BFIRST(bh);
1322 end = bh->b_data + bh->b_size;
1323 min_offs = end - base;
Theodore Ts'o7b1b2c12014-02-19 20:15:21 -05001324 free = ext4_xattr_free_space(first, &min_offs, base, NULL);
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04001325 if (free < new_extra_isize) {
1326 if (!tried_min_extra_isize && s_min_extra_isize) {
1327 tried_min_extra_isize++;
1328 new_extra_isize = s_min_extra_isize;
1329 brelse(bh);
1330 goto retry;
1331 }
1332 error = -1;
1333 goto cleanup;
1334 }
1335 } else {
1336 free = inode->i_sb->s_blocksize;
1337 }
1338
1339 while (new_extra_isize > 0) {
1340 size_t offs, size, entry_size;
1341 struct ext4_xattr_entry *small_entry = NULL;
1342 struct ext4_xattr_info i = {
1343 .value = NULL,
1344 .value_len = 0,
1345 };
1346 unsigned int total_size; /* EA entry size + value size */
1347 unsigned int shift_bytes; /* No. of bytes to shift EAs by? */
1348 unsigned int min_total_size = ~0U;
1349
1350 is = kzalloc(sizeof(struct ext4_xattr_ibody_find), GFP_NOFS);
1351 bs = kzalloc(sizeof(struct ext4_xattr_block_find), GFP_NOFS);
1352 if (!is || !bs) {
1353 error = -ENOMEM;
1354 goto cleanup;
1355 }
1356
1357 is->s.not_found = -ENODATA;
1358 bs->s.not_found = -ENODATA;
1359 is->iloc.bh = NULL;
1360 bs->bh = NULL;
1361
1362 last = IFIRST(header);
1363 /* Find the entry best suited to be pushed into EA block */
1364 entry = NULL;
1365 for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
1366 total_size =
1367 EXT4_XATTR_SIZE(le32_to_cpu(last->e_value_size)) +
1368 EXT4_XATTR_LEN(last->e_name_len);
1369 if (total_size <= free && total_size < min_total_size) {
1370 if (total_size < new_extra_isize) {
1371 small_entry = last;
1372 } else {
1373 entry = last;
1374 min_total_size = total_size;
1375 }
1376 }
1377 }
1378
1379 if (entry == NULL) {
1380 if (small_entry) {
1381 entry = small_entry;
1382 } else {
1383 if (!tried_min_extra_isize &&
1384 s_min_extra_isize) {
1385 tried_min_extra_isize++;
1386 new_extra_isize = s_min_extra_isize;
Dave Jones6e4ea8e2013-10-10 20:05:35 -04001387 kfree(is); is = NULL;
1388 kfree(bs); bs = NULL;
Theodore Ts'odcb99172013-10-31 23:00:24 -04001389 brelse(bh);
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04001390 goto retry;
1391 }
1392 error = -1;
1393 goto cleanup;
1394 }
1395 }
1396 offs = le16_to_cpu(entry->e_value_offs);
1397 size = le32_to_cpu(entry->e_value_size);
1398 entry_size = EXT4_XATTR_LEN(entry->e_name_len);
1399 i.name_index = entry->e_name_index,
1400 buffer = kmalloc(EXT4_XATTR_SIZE(size), GFP_NOFS);
1401 b_entry_name = kmalloc(entry->e_name_len + 1, GFP_NOFS);
1402 if (!buffer || !b_entry_name) {
1403 error = -ENOMEM;
1404 goto cleanup;
1405 }
1406 /* Save the entry name and the entry value */
1407 memcpy(buffer, (void *)IFIRST(header) + offs,
1408 EXT4_XATTR_SIZE(size));
1409 memcpy(b_entry_name, entry->e_name, entry->e_name_len);
1410 b_entry_name[entry->e_name_len] = '\0';
1411 i.name = b_entry_name;
1412
1413 error = ext4_get_inode_loc(inode, &is->iloc);
1414 if (error)
1415 goto cleanup;
1416
1417 error = ext4_xattr_ibody_find(inode, &i, is);
1418 if (error)
1419 goto cleanup;
1420
1421 /* Remove the chosen entry from the inode */
1422 error = ext4_xattr_ibody_set(handle, inode, &i, is);
Roel Kluin9aaab052010-02-15 14:26:16 -05001423 if (error)
1424 goto cleanup;
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04001425
1426 entry = IFIRST(header);
1427 if (entry_size + EXT4_XATTR_SIZE(size) >= new_extra_isize)
1428 shift_bytes = new_extra_isize;
1429 else
1430 shift_bytes = entry_size + size;
1431 /* Adjust the offsets and shift the remaining entries ahead */
1432 ext4_xattr_shift_entries(entry, EXT4_I(inode)->i_extra_isize -
1433 shift_bytes, (void *)raw_inode +
1434 EXT4_GOOD_OLD_INODE_SIZE + extra_isize + shift_bytes,
1435 (void *)header, total_ino - entry_size,
1436 inode->i_sb->s_blocksize);
1437
1438 extra_isize += shift_bytes;
1439 new_extra_isize -= shift_bytes;
1440 EXT4_I(inode)->i_extra_isize = extra_isize;
1441
1442 i.name = b_entry_name;
1443 i.value = buffer;
Aneesh Kumar K.Vac398492007-10-16 18:38:25 -04001444 i.value_len = size;
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04001445 error = ext4_xattr_block_find(inode, &i, bs);
1446 if (error)
1447 goto cleanup;
1448
1449 /* Add entry which was removed from the inode into the block */
1450 error = ext4_xattr_block_set(handle, inode, &i, bs);
1451 if (error)
1452 goto cleanup;
1453 kfree(b_entry_name);
1454 kfree(buffer);
Julia Lawalld3533d72009-12-23 07:52:31 -05001455 b_entry_name = NULL;
1456 buffer = NULL;
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04001457 brelse(is->iloc.bh);
1458 kfree(is);
1459 kfree(bs);
1460 }
1461 brelse(bh);
1462 up_write(&EXT4_I(inode)->xattr_sem);
1463 return 0;
1464
1465cleanup:
1466 kfree(b_entry_name);
1467 kfree(buffer);
1468 if (is)
1469 brelse(is->iloc.bh);
1470 kfree(is);
1471 kfree(bs);
1472 brelse(bh);
1473 up_write(&EXT4_I(inode)->xattr_sem);
1474 return error;
1475}
1476
1477
1478
1479/*
Mingming Cao617ba132006-10-11 01:20:53 -07001480 * ext4_xattr_delete_inode()
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001481 *
1482 * Free extended attribute resources associated with this inode. This
1483 * is called immediately before an inode is freed. We have exclusive
1484 * access to the inode.
1485 */
1486void
Mingming Cao617ba132006-10-11 01:20:53 -07001487ext4_xattr_delete_inode(handle_t *handle, struct inode *inode)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001488{
1489 struct buffer_head *bh = NULL;
1490
Mingming Cao617ba132006-10-11 01:20:53 -07001491 if (!EXT4_I(inode)->i_file_acl)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001492 goto cleanup;
Mingming Cao617ba132006-10-11 01:20:53 -07001493 bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001494 if (!bh) {
Theodore Ts'o24676da2010-05-16 21:00:00 -04001495 EXT4_ERROR_INODE(inode, "block %llu read error",
1496 EXT4_I(inode)->i_file_acl);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001497 goto cleanup;
1498 }
Mingming Cao617ba132006-10-11 01:20:53 -07001499 if (BHDR(bh)->h_magic != cpu_to_le32(EXT4_XATTR_MAGIC) ||
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001500 BHDR(bh)->h_blocks != cpu_to_le32(1)) {
Theodore Ts'o24676da2010-05-16 21:00:00 -04001501 EXT4_ERROR_INODE(inode, "bad block %llu",
1502 EXT4_I(inode)->i_file_acl);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001503 goto cleanup;
1504 }
Mingming Cao617ba132006-10-11 01:20:53 -07001505 ext4_xattr_release_block(handle, inode, bh);
1506 EXT4_I(inode)->i_file_acl = 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001507
1508cleanup:
1509 brelse(bh);
1510}
1511
1512/*
Mingming Cao617ba132006-10-11 01:20:53 -07001513 * ext4_xattr_put_super()
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001514 *
1515 * This is called when a file system is unmounted.
1516 */
1517void
Mingming Cao617ba132006-10-11 01:20:53 -07001518ext4_xattr_put_super(struct super_block *sb)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001519{
1520 mb_cache_shrink(sb->s_bdev);
1521}
1522
1523/*
Mingming Cao617ba132006-10-11 01:20:53 -07001524 * ext4_xattr_cache_insert()
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001525 *
1526 * Create a new entry in the extended attribute cache, and insert
1527 * it unless such an entry is already in the cache.
1528 *
1529 * Returns 0, or a negative error number on failure.
1530 */
1531static void
T Makphaibulchoke9c191f72014-03-18 19:24:49 -04001532ext4_xattr_cache_insert(struct mb_cache *ext4_mb_cache, struct buffer_head *bh)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001533{
1534 __u32 hash = le32_to_cpu(BHDR(bh)->h_hash);
1535 struct mb_cache_entry *ce;
1536 int error;
1537
T Makphaibulchoke9c191f72014-03-18 19:24:49 -04001538 ce = mb_cache_entry_alloc(ext4_mb_cache, GFP_NOFS);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001539 if (!ce) {
1540 ea_bdebug(bh, "out of memory");
1541 return;
1542 }
Andreas Gruenbacher2aec7c52010-07-19 18:19:41 +02001543 error = mb_cache_entry_insert(ce, bh->b_bdev, bh->b_blocknr, hash);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001544 if (error) {
1545 mb_cache_entry_free(ce);
1546 if (error == -EBUSY) {
1547 ea_bdebug(bh, "already in cache");
1548 error = 0;
1549 }
1550 } else {
1551 ea_bdebug(bh, "inserting [%x]", (int)hash);
1552 mb_cache_entry_release(ce);
1553 }
1554}
1555
1556/*
Mingming Cao617ba132006-10-11 01:20:53 -07001557 * ext4_xattr_cmp()
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001558 *
1559 * Compare two extended attribute blocks for equality.
1560 *
1561 * Returns 0 if the blocks are equal, 1 if they differ, and
1562 * a negative error number on errors.
1563 */
1564static int
Mingming Cao617ba132006-10-11 01:20:53 -07001565ext4_xattr_cmp(struct ext4_xattr_header *header1,
1566 struct ext4_xattr_header *header2)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001567{
Mingming Cao617ba132006-10-11 01:20:53 -07001568 struct ext4_xattr_entry *entry1, *entry2;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001569
1570 entry1 = ENTRY(header1+1);
1571 entry2 = ENTRY(header2+1);
1572 while (!IS_LAST_ENTRY(entry1)) {
1573 if (IS_LAST_ENTRY(entry2))
1574 return 1;
1575 if (entry1->e_hash != entry2->e_hash ||
1576 entry1->e_name_index != entry2->e_name_index ||
1577 entry1->e_name_len != entry2->e_name_len ||
1578 entry1->e_value_size != entry2->e_value_size ||
1579 memcmp(entry1->e_name, entry2->e_name, entry1->e_name_len))
1580 return 1;
1581 if (entry1->e_value_block != 0 || entry2->e_value_block != 0)
1582 return -EIO;
1583 if (memcmp((char *)header1 + le16_to_cpu(entry1->e_value_offs),
1584 (char *)header2 + le16_to_cpu(entry2->e_value_offs),
1585 le32_to_cpu(entry1->e_value_size)))
1586 return 1;
1587
Mingming Cao617ba132006-10-11 01:20:53 -07001588 entry1 = EXT4_XATTR_NEXT(entry1);
1589 entry2 = EXT4_XATTR_NEXT(entry2);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001590 }
1591 if (!IS_LAST_ENTRY(entry2))
1592 return 1;
1593 return 0;
1594}
1595
1596/*
Mingming Cao617ba132006-10-11 01:20:53 -07001597 * ext4_xattr_cache_find()
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001598 *
1599 * Find an identical extended attribute block.
1600 *
1601 * Returns a pointer to the block found, or NULL if such a block was
1602 * not found or an error occurred.
1603 */
1604static struct buffer_head *
Mingming Cao617ba132006-10-11 01:20:53 -07001605ext4_xattr_cache_find(struct inode *inode, struct ext4_xattr_header *header,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001606 struct mb_cache_entry **pce)
1607{
1608 __u32 hash = le32_to_cpu(header->h_hash);
1609 struct mb_cache_entry *ce;
T Makphaibulchoke9c191f72014-03-18 19:24:49 -04001610 struct mb_cache *ext4_mb_cache = EXT4_GET_MB_CACHE(inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001611
1612 if (!header->h_hash)
1613 return NULL; /* never share */
1614 ea_idebug(inode, "looking for cached blocks [%x]", (int)hash);
1615again:
T Makphaibulchoke9c191f72014-03-18 19:24:49 -04001616 ce = mb_cache_entry_find_first(ext4_mb_cache, inode->i_sb->s_bdev,
Andreas Gruenbacher2aec7c52010-07-19 18:19:41 +02001617 hash);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001618 while (ce) {
1619 struct buffer_head *bh;
1620
1621 if (IS_ERR(ce)) {
1622 if (PTR_ERR(ce) == -EAGAIN)
1623 goto again;
1624 break;
1625 }
1626 bh = sb_bread(inode->i_sb, ce->e_block);
1627 if (!bh) {
Theodore Ts'o24676da2010-05-16 21:00:00 -04001628 EXT4_ERROR_INODE(inode, "block %lu read error",
1629 (unsigned long) ce->e_block);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001630 } else if (le32_to_cpu(BHDR(bh)->h_refcount) >=
Mingming Cao617ba132006-10-11 01:20:53 -07001631 EXT4_XATTR_REFCOUNT_MAX) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001632 ea_idebug(inode, "block %lu refcount %d>=%d",
1633 (unsigned long) ce->e_block,
1634 le32_to_cpu(BHDR(bh)->h_refcount),
Mingming Cao617ba132006-10-11 01:20:53 -07001635 EXT4_XATTR_REFCOUNT_MAX);
1636 } else if (ext4_xattr_cmp(header, BHDR(bh)) == 0) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001637 *pce = ce;
1638 return bh;
1639 }
1640 brelse(bh);
Andreas Gruenbacher2aec7c52010-07-19 18:19:41 +02001641 ce = mb_cache_entry_find_next(ce, inode->i_sb->s_bdev, hash);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001642 }
1643 return NULL;
1644}
1645
1646#define NAME_HASH_SHIFT 5
1647#define VALUE_HASH_SHIFT 16
1648
1649/*
Mingming Cao617ba132006-10-11 01:20:53 -07001650 * ext4_xattr_hash_entry()
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001651 *
1652 * Compute the hash of an extended attribute.
1653 */
Mingming Cao617ba132006-10-11 01:20:53 -07001654static inline void ext4_xattr_hash_entry(struct ext4_xattr_header *header,
1655 struct ext4_xattr_entry *entry)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001656{
1657 __u32 hash = 0;
1658 char *name = entry->e_name;
1659 int n;
1660
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001661 for (n = 0; n < entry->e_name_len; n++) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001662 hash = (hash << NAME_HASH_SHIFT) ^
1663 (hash >> (8*sizeof(hash) - NAME_HASH_SHIFT)) ^
1664 *name++;
1665 }
1666
1667 if (entry->e_value_block == 0 && entry->e_value_size != 0) {
1668 __le32 *value = (__le32 *)((char *)header +
1669 le16_to_cpu(entry->e_value_offs));
1670 for (n = (le32_to_cpu(entry->e_value_size) +
Mingming Cao617ba132006-10-11 01:20:53 -07001671 EXT4_XATTR_ROUND) >> EXT4_XATTR_PAD_BITS; n; n--) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001672 hash = (hash << VALUE_HASH_SHIFT) ^
1673 (hash >> (8*sizeof(hash) - VALUE_HASH_SHIFT)) ^
1674 le32_to_cpu(*value++);
1675 }
1676 }
1677 entry->e_hash = cpu_to_le32(hash);
1678}
1679
1680#undef NAME_HASH_SHIFT
1681#undef VALUE_HASH_SHIFT
1682
1683#define BLOCK_HASH_SHIFT 16
1684
1685/*
Mingming Cao617ba132006-10-11 01:20:53 -07001686 * ext4_xattr_rehash()
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001687 *
1688 * Re-compute the extended attribute hash value after an entry has changed.
1689 */
Mingming Cao617ba132006-10-11 01:20:53 -07001690static void ext4_xattr_rehash(struct ext4_xattr_header *header,
1691 struct ext4_xattr_entry *entry)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001692{
Mingming Cao617ba132006-10-11 01:20:53 -07001693 struct ext4_xattr_entry *here;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001694 __u32 hash = 0;
1695
Mingming Cao617ba132006-10-11 01:20:53 -07001696 ext4_xattr_hash_entry(header, entry);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001697 here = ENTRY(header+1);
1698 while (!IS_LAST_ENTRY(here)) {
1699 if (!here->e_hash) {
1700 /* Block is not shared if an entry's hash value == 0 */
1701 hash = 0;
1702 break;
1703 }
1704 hash = (hash << BLOCK_HASH_SHIFT) ^
1705 (hash >> (8*sizeof(hash) - BLOCK_HASH_SHIFT)) ^
1706 le32_to_cpu(here->e_hash);
Mingming Cao617ba132006-10-11 01:20:53 -07001707 here = EXT4_XATTR_NEXT(here);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001708 }
1709 header->h_hash = cpu_to_le32(hash);
1710}
1711
1712#undef BLOCK_HASH_SHIFT
1713
T Makphaibulchoke9c191f72014-03-18 19:24:49 -04001714#define HASH_BUCKET_BITS 10
1715
1716struct mb_cache *
1717ext4_xattr_create_cache(char *name)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001718{
T Makphaibulchoke9c191f72014-03-18 19:24:49 -04001719 return mb_cache_create(name, HASH_BUCKET_BITS);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001720}
1721
T Makphaibulchoke9c191f72014-03-18 19:24:49 -04001722void ext4_xattr_destroy_cache(struct mb_cache *cache)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001723{
T Makphaibulchoke9c191f72014-03-18 19:24:49 -04001724 if (cache)
1725 mb_cache_destroy(cache);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001726}
T Makphaibulchoke9c191f72014-03-18 19:24:49 -04001727