projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'linux-4.6' of git://github.com/skeggsb/linux into drm-fixes
[deliverable/linux.git] / fs / ext4 / xattr.c
1 /*
2 * linux/fs/ext4/xattr.c
3 *
4 * Copyright (C) 2001-2003 Andreas Gruenbacher, <agruen@suse.de>
5 *
6 * Fix by Harrison Xing <harrison@mountainviewdata.com>.
7 * Ext4 code with a lot of help from Eric Jarman <ejarman@acm.org>.
8 * 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 * ----------------
46 * EXT4_I(inode)->i_file_acl is protected by EXT4_I(inode)->xattr_sem.
47 * 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>
56 #include <linux/mbcache.h>
57 #include <linux/quotaops.h>
58 #include "ext4_jbd2.h"
59 #include "ext4.h"
60 #include "xattr.h"
61 #include "acl.h"
62
63 #ifdef EXT4_XATTR_DEBUG
64 # 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 printk(KERN_DEBUG "block %pg:%lu: ", \
72 bh->b_bdev, (unsigned long) bh->b_blocknr); \
73 printk(f); \
74 printk("\n"); \
75 } while (0)
76 #else
77 # define ea_idebug(inode, fmt, ...) no_printk(fmt, ##__VA_ARGS__)
78 # define ea_bdebug(bh, fmt, ...) no_printk(fmt, ##__VA_ARGS__)
79 #endif
80
81 static void ext4_xattr_cache_insert(struct mb_cache *, struct buffer_head *);
82 static struct buffer_head *ext4_xattr_cache_find(struct inode *,
83 struct ext4_xattr_header *,
84 struct mb_cache_entry **);
85 static void ext4_xattr_rehash(struct ext4_xattr_header *,
86 struct ext4_xattr_entry *);
87 static int ext4_xattr_list(struct dentry *dentry, char *buffer,
88 size_t buffer_size);
89
90 static const struct xattr_handler *ext4_xattr_handler_map[] = {
91 [EXT4_XATTR_INDEX_USER] = &ext4_xattr_user_handler,
92 #ifdef CONFIG_EXT4_FS_POSIX_ACL
93 [EXT4_XATTR_INDEX_POSIX_ACL_ACCESS] = &posix_acl_access_xattr_handler,
94 [EXT4_XATTR_INDEX_POSIX_ACL_DEFAULT] = &posix_acl_default_xattr_handler,
95 #endif
96 [EXT4_XATTR_INDEX_TRUSTED] = &ext4_xattr_trusted_handler,
97 #ifdef CONFIG_EXT4_FS_SECURITY
98 [EXT4_XATTR_INDEX_SECURITY] = &ext4_xattr_security_handler,
99 #endif
100 };
101
102 const struct xattr_handler *ext4_xattr_handlers[] = {
103 &ext4_xattr_user_handler,
104 &ext4_xattr_trusted_handler,
105 #ifdef CONFIG_EXT4_FS_POSIX_ACL
106 &posix_acl_access_xattr_handler,
107 &posix_acl_default_xattr_handler,
108 #endif
109 #ifdef CONFIG_EXT4_FS_SECURITY
110 &ext4_xattr_security_handler,
111 #endif
112 NULL
113 };
114
115 #define EXT4_GET_MB_CACHE(inode) (((struct ext4_sb_info *) \
116 inode->i_sb->s_fs_info)->s_mb_cache)
117
118 static __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);
123 __u32 csum;
124 __le32 save_csum;
125 __le64 dsk_block_nr = cpu_to_le64(block_nr);
126
127 save_csum = hdr->h_checksum;
128 hdr->h_checksum = 0;
129 csum = ext4_chksum(sbi, sbi->s_csum_seed, (__u8 *)&dsk_block_nr,
130 sizeof(dsk_block_nr));
131 csum = ext4_chksum(sbi, csum, (__u8 *)hdr,
132 EXT4_BLOCK_SIZE(inode->i_sb));
133
134 hdr->h_checksum = save_csum;
135 return cpu_to_le32(csum);
136 }
137
138 static int ext4_xattr_block_csum_verify(struct inode *inode,
139 sector_t block_nr,
140 struct ext4_xattr_header *hdr)
141 {
142 if (ext4_has_metadata_csum(inode->i_sb) &&
143 (hdr->h_checksum != ext4_xattr_block_csum(inode, block_nr, hdr)))
144 return 0;
145 return 1;
146 }
147
148 static void ext4_xattr_block_csum_set(struct inode *inode,
149 sector_t block_nr,
150 struct ext4_xattr_header *hdr)
151 {
152 if (!ext4_has_metadata_csum(inode->i_sb))
153 return;
154
155 hdr->h_checksum = ext4_xattr_block_csum(inode, block_nr, hdr);
156 }
157
158 static 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
166 static inline const struct xattr_handler *
167 ext4_xattr_handler(int name_index)
168 {
169 const struct xattr_handler *handler = NULL;
170
171 if (name_index > 0 && name_index < ARRAY_SIZE(ext4_xattr_handler_map))
172 handler = ext4_xattr_handler_map[name_index];
173 return handler;
174 }
175
176 /*
177 * Inode operation listxattr()
178 *
179 * d_inode(dentry)->i_mutex: don't care
180 */
181 ssize_t
182 ext4_listxattr(struct dentry *dentry, char *buffer, size_t size)
183 {
184 return ext4_xattr_list(dentry, buffer, size);
185 }
186
187 static int
188 ext4_xattr_check_names(struct ext4_xattr_entry *entry, void *end,
189 void *value_start)
190 {
191 struct ext4_xattr_entry *e = entry;
192
193 while (!IS_LAST_ENTRY(e)) {
194 struct ext4_xattr_entry *next = EXT4_XATTR_NEXT(e);
195 if ((void *)next >= end)
196 return -EFSCORRUPTED;
197 e = next;
198 }
199
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))
206 return -EFSCORRUPTED;
207 entry = EXT4_XATTR_NEXT(entry);
208 }
209
210 return 0;
211 }
212
213 static inline int
214 ext4_xattr_check_block(struct inode *inode, struct buffer_head *bh)
215 {
216 int error;
217
218 if (buffer_verified(bh))
219 return 0;
220
221 if (BHDR(bh)->h_magic != cpu_to_le32(EXT4_XATTR_MAGIC) ||
222 BHDR(bh)->h_blocks != cpu_to_le32(1))
223 return -EFSCORRUPTED;
224 if (!ext4_xattr_block_csum_verify(inode, bh->b_blocknr, BHDR(bh)))
225 return -EFSBADCRC;
226 error = ext4_xattr_check_names(BFIRST(bh), bh->b_data + bh->b_size,
227 bh->b_data);
228 if (!error)
229 set_buffer_verified(bh);
230 return error;
231 }
232
233 static inline int
234 ext4_xattr_check_entry(struct ext4_xattr_entry *entry, size_t size)
235 {
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)
240 return -EFSCORRUPTED;
241 return 0;
242 }
243
244 static int
245 ext4_xattr_find_entry(struct ext4_xattr_entry **pentry, int name_index,
246 const char *name, size_t size, int sorted)
247 {
248 struct ext4_xattr_entry *entry;
249 size_t name_len;
250 int cmp = 1;
251
252 if (name == NULL)
253 return -EINVAL;
254 name_len = strlen(name);
255 entry = *pentry;
256 for (; !IS_LAST_ENTRY(entry); entry = EXT4_XATTR_NEXT(entry)) {
257 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;
266 if (!cmp && ext4_xattr_check_entry(entry, size))
267 return -EFSCORRUPTED;
268 return cmp ? -ENODATA : 0;
269 }
270
271 static int
272 ext4_xattr_block_get(struct inode *inode, int name_index, const char *name,
273 void *buffer, size_t buffer_size)
274 {
275 struct buffer_head *bh = NULL;
276 struct ext4_xattr_entry *entry;
277 size_t size;
278 int error;
279 struct mb_cache *ext4_mb_cache = EXT4_GET_MB_CACHE(inode);
280
281 ea_idebug(inode, "name=%d.%s, buffer=%p, buffer_size=%ld",
282 name_index, name, buffer, (long)buffer_size);
283
284 error = -ENODATA;
285 if (!EXT4_I(inode)->i_file_acl)
286 goto cleanup;
287 ea_idebug(inode, "reading block %llu",
288 (unsigned long long)EXT4_I(inode)->i_file_acl);
289 bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl);
290 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));
294 if (ext4_xattr_check_block(inode, bh)) {
295 bad_block:
296 EXT4_ERROR_INODE(inode, "bad block %llu",
297 EXT4_I(inode)->i_file_acl);
298 error = -EFSCORRUPTED;
299 goto cleanup;
300 }
301 ext4_xattr_cache_insert(ext4_mb_cache, bh);
302 entry = BFIRST(bh);
303 error = ext4_xattr_find_entry(&entry, name_index, name, bh->b_size, 1);
304 if (error == -EFSCORRUPTED)
305 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
318 cleanup:
319 brelse(bh);
320 return error;
321 }
322
323 int
324 ext4_xattr_ibody_get(struct inode *inode, int name_index, const char *name,
325 void *buffer, size_t buffer_size)
326 {
327 struct ext4_xattr_ibody_header *header;
328 struct ext4_xattr_entry *entry;
329 struct ext4_inode *raw_inode;
330 struct ext4_iloc iloc;
331 size_t size;
332 void *end;
333 int error;
334
335 if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR))
336 return -ENODATA;
337 error = ext4_get_inode_loc(inode, &iloc);
338 if (error)
339 return error;
340 raw_inode = ext4_raw_inode(&iloc);
341 header = IHDR(inode, raw_inode);
342 entry = IFIRST(header);
343 end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
344 error = ext4_xattr_check_names(entry, end, entry);
345 if (error)
346 goto cleanup;
347 error = ext4_xattr_find_entry(&entry, name_index, name,
348 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
361 cleanup:
362 brelse(iloc.bh);
363 return error;
364 }
365
366 /*
367 * ext4_xattr_get()
368 *
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 */
376 int
377 ext4_xattr_get(struct inode *inode, int name_index, const char *name,
378 void *buffer, size_t buffer_size)
379 {
380 int error;
381
382 if (strlen(name) > 255)
383 return -ERANGE;
384
385 down_read(&EXT4_I(inode)->xattr_sem);
386 error = ext4_xattr_ibody_get(inode, name_index, name, buffer,
387 buffer_size);
388 if (error == -ENODATA)
389 error = ext4_xattr_block_get(inode, name_index, name, buffer,
390 buffer_size);
391 up_read(&EXT4_I(inode)->xattr_sem);
392 return error;
393 }
394
395 static int
396 ext4_xattr_list_entries(struct dentry *dentry, struct ext4_xattr_entry *entry,
397 char *buffer, size_t buffer_size)
398 {
399 size_t rest = buffer_size;
400
401 for (; !IS_LAST_ENTRY(entry); entry = EXT4_XATTR_NEXT(entry)) {
402 const struct xattr_handler *handler =
403 ext4_xattr_handler(entry->e_name_index);
404
405 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
410 if (buffer) {
411 if (size > rest)
412 return -ERANGE;
413 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;
418 }
419 rest -= size;
420 }
421 }
422 return buffer_size - rest; /* total size */
423 }
424
425 static int
426 ext4_xattr_block_list(struct dentry *dentry, char *buffer, size_t buffer_size)
427 {
428 struct inode *inode = d_inode(dentry);
429 struct buffer_head *bh = NULL;
430 int error;
431 struct mb_cache *ext4_mb_cache = EXT4_GET_MB_CACHE(inode);
432
433 ea_idebug(inode, "buffer=%p, buffer_size=%ld",
434 buffer, (long)buffer_size);
435
436 error = 0;
437 if (!EXT4_I(inode)->i_file_acl)
438 goto cleanup;
439 ea_idebug(inode, "reading block %llu",
440 (unsigned long long)EXT4_I(inode)->i_file_acl);
441 bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl);
442 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));
447 if (ext4_xattr_check_block(inode, bh)) {
448 EXT4_ERROR_INODE(inode, "bad block %llu",
449 EXT4_I(inode)->i_file_acl);
450 error = -EFSCORRUPTED;
451 goto cleanup;
452 }
453 ext4_xattr_cache_insert(ext4_mb_cache, bh);
454 error = ext4_xattr_list_entries(dentry, BFIRST(bh), buffer, buffer_size);
455
456 cleanup:
457 brelse(bh);
458
459 return error;
460 }
461
462 static int
463 ext4_xattr_ibody_list(struct dentry *dentry, char *buffer, size_t buffer_size)
464 {
465 struct inode *inode = d_inode(dentry);
466 struct ext4_xattr_ibody_header *header;
467 struct ext4_inode *raw_inode;
468 struct ext4_iloc iloc;
469 void *end;
470 int error;
471
472 if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR))
473 return 0;
474 error = ext4_get_inode_loc(inode, &iloc);
475 if (error)
476 return error;
477 raw_inode = ext4_raw_inode(&iloc);
478 header = IHDR(inode, raw_inode);
479 end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
480 error = ext4_xattr_check_names(IFIRST(header), end, IFIRST(header));
481 if (error)
482 goto cleanup;
483 error = ext4_xattr_list_entries(dentry, IFIRST(header),
484 buffer, buffer_size);
485
486 cleanup:
487 brelse(iloc.bh);
488 return error;
489 }
490
491 /*
492 * ext4_xattr_list()
493 *
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 */
501 static int
502 ext4_xattr_list(struct dentry *dentry, char *buffer, size_t buffer_size)
503 {
504 int ret, ret2;
505
506 down_read(&EXT4_I(d_inode(dentry))->xattr_sem);
507 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;
513 }
514 ret = ext4_xattr_block_list(dentry, buffer, buffer_size);
515 if (ret < 0)
516 goto errout;
517 ret += ret2;
518 errout:
519 up_read(&EXT4_I(d_inode(dentry))->xattr_sem);
520 return ret;
521 }
522
523 /*
524 * If the EXT4_FEATURE_COMPAT_EXT_ATTR feature of this file system is
525 * not set, set it.
526 */
527 static void ext4_xattr_update_super_block(handle_t *handle,
528 struct super_block *sb)
529 {
530 if (ext4_has_feature_xattr(sb))
531 return;
532
533 BUFFER_TRACE(EXT4_SB(sb)->s_sbh, "get_write_access");
534 if (ext4_journal_get_write_access(handle, EXT4_SB(sb)->s_sbh) == 0) {
535 ext4_set_feature_xattr(sb);
536 ext4_handle_dirty_super(handle, sb);
537 }
538 }
539
540 /*
541 * Release the xattr block BH: If the reference count is > 1, decrement it;
542 * otherwise free the block.
543 */
544 static void
545 ext4_xattr_release_block(handle_t *handle, struct inode *inode,
546 struct buffer_head *bh)
547 {
548 struct mb_cache *ext4_mb_cache = EXT4_GET_MB_CACHE(inode);
549 u32 hash, ref;
550 int error = 0;
551
552 BUFFER_TRACE(bh, "get_write_access");
553 error = ext4_journal_get_write_access(handle, bh);
554 if (error)
555 goto out;
556
557 lock_buffer(bh);
558 hash = le32_to_cpu(BHDR(bh)->h_hash);
559 ref = le32_to_cpu(BHDR(bh)->h_refcount);
560 if (ref == 1) {
561 ea_bdebug(bh, "refcount now=0; freeing");
562 /*
563 * This must happen under buffer lock for
564 * ext4_xattr_block_set() to reliably detect freed block
565 */
566 mb_cache_entry_delete_block(ext4_mb_cache, hash, bh->b_blocknr);
567 get_bh(bh);
568 unlock_buffer(bh);
569 ext4_free_blocks(handle, inode, bh, 0, 1,
570 EXT4_FREE_BLOCKS_METADATA |
571 EXT4_FREE_BLOCKS_FORGET);
572 } else {
573 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
586 /*
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);
599 unlock_buffer(bh);
600 if (!ext4_handle_valid(handle))
601 error = ext4_handle_dirty_xattr_block(handle, inode,
602 bh);
603 if (IS_SYNC(inode))
604 ext4_handle_sync(handle);
605 dquot_free_block(inode, EXT4_C2B(EXT4_SB(inode->i_sb), 1));
606 ea_bdebug(bh, "refcount now=%d; releasing",
607 le32_to_cpu(BHDR(bh)->h_refcount));
608 }
609 out:
610 ext4_std_error(inode->i_sb, error);
611 return;
612 }
613
614 /*
615 * Find the available free space for EAs. This also returns the total number of
616 * bytes used by EA entries.
617 */
618 static 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)) {
622 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 }
627 if (total)
628 *total += EXT4_XATTR_LEN(last->e_name_len);
629 }
630 return (*min_offs - ((void *)last - base) - sizeof(__u32));
631 }
632
633 static int
634 ext4_xattr_set_entry(struct ext4_xattr_info *i, struct ext4_xattr_search *s)
635 {
636 struct ext4_xattr_entry *last;
637 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;
641 for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
642 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);
652 free += EXT4_XATTR_SIZE(size);
653 }
654 free += EXT4_XATTR_LEN(name_len);
655 }
656 if (i->value) {
657 if (free < EXT4_XATTR_LEN(name_len) +
658 EXT4_XATTR_SIZE(i->value_len))
659 return -ENOSPC;
660 }
661
662 if (i->value && s->not_found) {
663 /* Insert the new name. */
664 size_t size = EXT4_XATTR_LEN(name_len);
665 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;
676 size_t size = EXT4_XATTR_SIZE(
677 le32_to_cpu(s->here->e_value_size));
678
679 if (i->value && size == EXT4_XATTR_SIZE(i->value_len)) {
680 /* 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);
684 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 }
692 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);
710 last = EXT4_XATTR_NEXT(last);
711 }
712 }
713 if (!i->value) {
714 /* Remove the old name. */
715 size_t size = EXT4_XATTR_LEN(name_len);
716 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) {
727 size_t size = EXT4_XATTR_SIZE(i->value_len);
728 void *val = s->base + min_offs - size;
729 s->here->e_value_offs = cpu_to_le16(min_offs - size);
730 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 }
738 }
739 }
740 return 0;
741 }
742
743 struct ext4_xattr_block_find {
744 struct ext4_xattr_search s;
745 struct buffer_head *bh;
746 };
747
748 static int
749 ext4_xattr_block_find(struct inode *inode, struct ext4_xattr_info *i,
750 struct ext4_xattr_block_find *bs)
751 {
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
758 if (EXT4_I(inode)->i_file_acl) {
759 /* The inode already has an extended attribute block. */
760 bs->bh = sb_bread(sb, EXT4_I(inode)->i_file_acl);
761 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));
767 if (ext4_xattr_check_block(inode, bs->bh)) {
768 EXT4_ERROR_INODE(inode, "bad block %llu",
769 EXT4_I(inode)->i_file_acl);
770 error = -EFSCORRUPTED;
771 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;
778 error = ext4_xattr_find_entry(&bs->s.here, i->name_index,
779 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
786 cleanup:
787 return error;
788 }
789
790 static int
791 ext4_xattr_block_set(handle_t *handle, struct inode *inode,
792 struct ext4_xattr_info *i,
793 struct ext4_xattr_block_find *bs)
794 {
795 struct super_block *sb = inode->i_sb;
796 struct buffer_head *new_bh = NULL;
797 struct ext4_xattr_search *s = &bs->s;
798 struct mb_cache_entry *ce = NULL;
799 int error = 0;
800 struct mb_cache *ext4_mb_cache = EXT4_GET_MB_CACHE(inode);
801
802 #define header(x) ((struct ext4_xattr_header *)(x))
803
804 if (i->value && i->value_len > sb->s_blocksize)
805 return -ENOSPC;
806 if (s->base) {
807 BUFFER_TRACE(bs->bh, "get_write_access");
808 error = ext4_journal_get_write_access(handle, bs->bh);
809 if (error)
810 goto cleanup;
811 lock_buffer(bs->bh);
812
813 if (header(s->base)->h_refcount == cpu_to_le32(1)) {
814 __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 */
821 mb_cache_entry_delete_block(ext4_mb_cache, hash,
822 bs->bh->b_blocknr);
823 ea_bdebug(bs->bh, "modifying in-place");
824 error = ext4_xattr_set_entry(i, s);
825 if (!error) {
826 if (!IS_LAST_ENTRY(s->first))
827 ext4_xattr_rehash(header(s->base),
828 s->here);
829 ext4_xattr_cache_insert(ext4_mb_cache,
830 bs->bh);
831 }
832 unlock_buffer(bs->bh);
833 if (error == -EFSCORRUPTED)
834 goto bad_block;
835 if (!error)
836 error = ext4_handle_dirty_xattr_block(handle,
837 inode,
838 bs->bh);
839 if (error)
840 goto cleanup;
841 goto inserted;
842 } else {
843 int offset = (char *)s->here - bs->bh->b_data;
844
845 unlock_buffer(bs->bh);
846 ea_bdebug(bs->bh, "cloning");
847 s->base = kmalloc(bs->bh->b_size, GFP_NOFS);
848 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. */
859 s->base = kzalloc(sb->s_blocksize, GFP_NOFS);
860 /* assert(header == s->base) */
861 error = -ENOMEM;
862 if (s->base == NULL)
863 goto cleanup;
864 header(s->base)->h_magic = cpu_to_le32(EXT4_XATTR_MAGIC);
865 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
872 error = ext4_xattr_set_entry(i, s);
873 if (error == -EFSCORRUPTED)
874 goto bad_block;
875 if (error)
876 goto cleanup;
877 if (!IS_LAST_ENTRY(s->first))
878 ext4_xattr_rehash(header(s->base), s->here);
879
880 inserted:
881 if (!IS_LAST_ENTRY(s->first)) {
882 new_bh = ext4_xattr_cache_find(inode, header(s->base), &ce);
883 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 {
888 u32 ref;
889
890 /* The old block is released after updating
891 the inode. */
892 error = dquot_alloc_block(inode,
893 EXT4_C2B(EXT4_SB(sb), 1));
894 if (error)
895 goto cleanup;
896 BUFFER_TRACE(new_bh, "get_write_access");
897 error = ext4_journal_get_write_access(handle,
898 new_bh);
899 if (error)
900 goto cleanup_dquot;
901 lock_buffer(new_bh);
902 /*
903 * We have to be careful about races with
904 * 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.
913 */
914 if (hlist_bl_unhashed(&ce->e_hash_list) ||
915 !ce->e_reusable) {
916 /*
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);
925 mb_cache_entry_put(ext4_mb_cache, ce);
926 ce = NULL;
927 new_bh = NULL;
928 goto inserted;
929 }
930 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;
934 ea_bdebug(new_bh, "reusing; refcount now=%d",
935 ref);
936 unlock_buffer(new_bh);
937 error = ext4_handle_dirty_xattr_block(handle,
938 inode,
939 new_bh);
940 if (error)
941 goto cleanup_dquot;
942 }
943 mb_cache_entry_touch(ext4_mb_cache, ce);
944 mb_cache_entry_put(ext4_mb_cache, ce);
945 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 */
953 ext4_fsblk_t goal, block;
954
955 goal = ext4_group_first_block_no(sb,
956 EXT4_I(inode)->i_block_group);
957
958 /* non-extent files can't have physical blocks past 2^32 */
959 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
960 goal = goal & EXT4_MAX_BLOCK_FILE_PHYS;
961
962 block = ext4_new_meta_blocks(handle, inode, goal, 0,
963 NULL, &error);
964 if (error)
965 goto cleanup;
966
967 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
968 BUG_ON(block > EXT4_MAX_BLOCK_FILE_PHYS);
969
970 ea_idebug(inode, "creating block %llu",
971 (unsigned long long)block);
972
973 new_bh = sb_getblk(sb, block);
974 if (unlikely(!new_bh)) {
975 error = -ENOMEM;
976 getblk_failed:
977 ext4_free_blocks(handle, inode, NULL, block, 1,
978 EXT4_FREE_BLOCKS_METADATA);
979 goto cleanup;
980 }
981 lock_buffer(new_bh);
982 error = ext4_journal_get_create_access(handle, new_bh);
983 if (error) {
984 unlock_buffer(new_bh);
985 error = -EIO;
986 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);
991 ext4_xattr_cache_insert(ext4_mb_cache, new_bh);
992 error = ext4_handle_dirty_xattr_block(handle,
993 inode, new_bh);
994 if (error)
995 goto cleanup;
996 }
997 }
998
999 /* Update the inode. */
1000 EXT4_I(inode)->i_file_acl = new_bh ? new_bh->b_blocknr : 0;
1001
1002 /* Drop the previous xattr block. */
1003 if (bs->bh && bs->bh != new_bh)
1004 ext4_xattr_release_block(handle, inode, bs->bh);
1005 error = 0;
1006
1007 cleanup:
1008 if (ce)
1009 mb_cache_entry_put(ext4_mb_cache, ce);
1010 brelse(new_bh);
1011 if (!(bs->bh && s->base == bs->bh->b_data))
1012 kfree(s->base);
1013
1014 return error;
1015
1016 cleanup_dquot:
1017 dquot_free_block(inode, EXT4_C2B(EXT4_SB(sb), 1));
1018 goto cleanup;
1019
1020 bad_block:
1021 EXT4_ERROR_INODE(inode, "bad block %llu",
1022 EXT4_I(inode)->i_file_acl);
1023 goto cleanup;
1024
1025 #undef header
1026 }
1027
1028 int ext4_xattr_ibody_find(struct inode *inode, struct ext4_xattr_info *i,
1029 struct ext4_xattr_ibody_find *is)
1030 {
1031 struct ext4_xattr_ibody_header *header;
1032 struct ext4_inode *raw_inode;
1033 int error;
1034
1035 if (EXT4_I(inode)->i_extra_isize == 0)
1036 return 0;
1037 raw_inode = ext4_raw_inode(&is->iloc);
1038 header = IHDR(inode, raw_inode);
1039 is->s.base = is->s.first = IFIRST(header);
1040 is->s.here = is->s.first;
1041 is->s.end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
1042 if (ext4_test_inode_state(inode, EXT4_STATE_XATTR)) {
1043 error = ext4_xattr_check_names(IFIRST(header), is->s.end,
1044 IFIRST(header));
1045 if (error)
1046 return error;
1047 /* Find the named attribute. */
1048 error = ext4_xattr_find_entry(&is->s.here, i->name_index,
1049 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
1058 int 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
1096 static int ext4_xattr_ibody_set(handle_t *handle, struct inode *inode,
1097 struct ext4_xattr_info *i,
1098 struct ext4_xattr_ibody_find *is)
1099 {
1100 struct ext4_xattr_ibody_header *header;
1101 struct ext4_xattr_search *s = &is->s;
1102 int error;
1103
1104 if (EXT4_I(inode)->i_extra_isize == 0)
1105 return -ENOSPC;
1106 error = ext4_xattr_set_entry(i, s);
1107 if (error)
1108 return error;
1109 header = IHDR(inode, ext4_raw_inode(&is->iloc));
1110 if (!IS_LAST_ENTRY(s->first)) {
1111 header->h_magic = cpu_to_le32(EXT4_XATTR_MAGIC);
1112 ext4_set_inode_state(inode, EXT4_STATE_XATTR);
1113 } else {
1114 header->h_magic = cpu_to_le32(0);
1115 ext4_clear_inode_state(inode, EXT4_STATE_XATTR);
1116 }
1117 return 0;
1118 }
1119
1120 static 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
1131 /*
1132 * ext4_xattr_set_handle()
1133 *
1134 * Create, replace or remove an extended attribute for this inode. Value
1135 * 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 */
1143 int
1144 ext4_xattr_set_handle(handle_t *handle, struct inode *inode, int name_index,
1145 const char *name, const void *value, size_t value_len,
1146 int flags)
1147 {
1148 struct ext4_xattr_info i = {
1149 .name_index = name_index,
1150 .name = name,
1151 .value = value,
1152 .value_len = value_len,
1153
1154 };
1155 struct ext4_xattr_ibody_find is = {
1156 .s = { .not_found = -ENODATA, },
1157 };
1158 struct ext4_xattr_block_find bs = {
1159 .s = { .not_found = -ENODATA, },
1160 };
1161 unsigned long no_expand;
1162 int error;
1163
1164 if (!name)
1165 return -EINVAL;
1166 if (strlen(name) > 255)
1167 return -ERANGE;
1168 down_write(&EXT4_I(inode)->xattr_sem);
1169 no_expand = ext4_test_inode_state(inode, EXT4_STATE_NO_EXPAND);
1170 ext4_set_inode_state(inode, EXT4_STATE_NO_EXPAND);
1171
1172 error = ext4_reserve_inode_write(handle, inode, &is.iloc);
1173 if (error)
1174 goto cleanup;
1175
1176 if (ext4_test_inode_state(inode, EXT4_STATE_NEW)) {
1177 struct ext4_inode *raw_inode = ext4_raw_inode(&is.iloc);
1178 memset(raw_inode, 0, EXT4_SB(inode->i_sb)->s_inode_size);
1179 ext4_clear_inode_state(inode, EXT4_STATE_NEW);
1180 }
1181
1182 error = ext4_xattr_ibody_find(inode, &i, &is);
1183 if (error)
1184 goto cleanup;
1185 if (is.s.not_found)
1186 error = ext4_xattr_block_find(inode, &i, &bs);
1187 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 }
1201 if (!value) {
1202 if (!is.s.not_found)
1203 error = ext4_xattr_ibody_set(handle, inode, &i, &is);
1204 else if (!bs.s.not_found)
1205 error = ext4_xattr_block_set(handle, inode, &i, &bs);
1206 } else {
1207 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
1214 error = ext4_xattr_ibody_set(handle, inode, &i, &is);
1215 if (!error && !bs.s.not_found) {
1216 i.value = NULL;
1217 error = ext4_xattr_block_set(handle, inode, &i, &bs);
1218 } else if (error == -ENOSPC) {
1219 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 }
1224 error = ext4_xattr_block_set(handle, inode, &i, &bs);
1225 if (error)
1226 goto cleanup;
1227 if (!is.s.not_found) {
1228 i.value = NULL;
1229 error = ext4_xattr_ibody_set(handle, inode, &i,
1230 &is);
1231 }
1232 }
1233 }
1234 if (!error) {
1235 ext4_xattr_update_super_block(handle, inode->i_sb);
1236 inode->i_ctime = ext4_current_time(inode);
1237 if (!value)
1238 ext4_clear_inode_state(inode, EXT4_STATE_NO_EXPAND);
1239 error = ext4_mark_iloc_dirty(handle, inode, &is.iloc);
1240 /*
1241 * The bh is consumed by ext4_mark_iloc_dirty, even with
1242 * error != 0.
1243 */
1244 is.iloc.bh = NULL;
1245 if (IS_SYNC(inode))
1246 ext4_handle_sync(handle);
1247 }
1248
1249 cleanup:
1250 brelse(is.iloc.bh);
1251 brelse(bs.bh);
1252 if (no_expand == 0)
1253 ext4_clear_inode_state(inode, EXT4_STATE_NO_EXPAND);
1254 up_write(&EXT4_I(inode)->xattr_sem);
1255 return error;
1256 }
1257
1258 /*
1259 * ext4_xattr_set()
1260 *
1261 * Like ext4_xattr_set_handle, but start from an inode. This extended
1262 * attribute modification is a filesystem transaction by itself.
1263 *
1264 * Returns 0, or a negative error number on failure.
1265 */
1266 int
1267 ext4_xattr_set(struct inode *inode, int name_index, const char *name,
1268 const void *value, size_t value_len, int flags)
1269 {
1270 handle_t *handle;
1271 int error, retries = 0;
1272 int credits = ext4_jbd2_credits_xattr(inode);
1273
1274 retry:
1275 handle = ext4_journal_start(inode, EXT4_HT_XATTR, credits);
1276 if (IS_ERR(handle)) {
1277 error = PTR_ERR(handle);
1278 } else {
1279 int error2;
1280
1281 error = ext4_xattr_set_handle(handle, inode, name_index, name,
1282 value, value_len, flags);
1283 error2 = ext4_journal_stop(handle);
1284 if (error == -ENOSPC &&
1285 ext4_should_retry_alloc(inode->i_sb, &retries))
1286 goto retry;
1287 if (error == 0)
1288 error = error2;
1289 }
1290
1291 return error;
1292 }
1293
1294 /*
1295 * Shift the EA entries in the inode to create space for the increased
1296 * i_extra_isize.
1297 */
1298 static 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 */
1323 int 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;
1333 int total_ino;
1334 void *base, *start, *end;
1335 int extra_isize = 0, error = 0, tried_min_extra_isize = 0;
1336 int s_min_extra_isize = le16_to_cpu(EXT4_SB(inode->i_sb)->s_es->s_min_extra_isize);
1337
1338 down_write(&EXT4_I(inode)->xattr_sem);
1339 retry:
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;
1381 if (ext4_xattr_check_block(inode, bh)) {
1382 EXT4_ERROR_INODE(inode, "bad block %llu",
1383 EXT4_I(inode)->i_file_acl);
1384 error = -EFSCORRUPTED;
1385 goto cleanup;
1386 }
1387 base = BHDR(bh);
1388 first = BFIRST(bh);
1389 end = bh->b_data + bh->b_size;
1390 min_offs = end - base;
1391 free = ext4_xattr_free_space(first, &min_offs, base, NULL);
1392 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;
1454 kfree(is); is = NULL;
1455 kfree(bs); bs = NULL;
1456 brelse(bh);
1457 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);
1490 if (error)
1491 goto cleanup;
1492
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;
1511 i.value_len = size;
1512 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);
1522 b_entry_name = NULL;
1523 buffer = NULL;
1524 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
1532 cleanup:
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 /*
1547 * ext4_xattr_delete_inode()
1548 *
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 */
1553 void
1554 ext4_xattr_delete_inode(handle_t *handle, struct inode *inode)
1555 {
1556 struct buffer_head *bh = NULL;
1557
1558 if (!EXT4_I(inode)->i_file_acl)
1559 goto cleanup;
1560 bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl);
1561 if (!bh) {
1562 EXT4_ERROR_INODE(inode, "block %llu read error",
1563 EXT4_I(inode)->i_file_acl);
1564 goto cleanup;
1565 }
1566 if (BHDR(bh)->h_magic != cpu_to_le32(EXT4_XATTR_MAGIC) ||
1567 BHDR(bh)->h_blocks != cpu_to_le32(1)) {
1568 EXT4_ERROR_INODE(inode, "bad block %llu",
1569 EXT4_I(inode)->i_file_acl);
1570 goto cleanup;
1571 }
1572 ext4_xattr_release_block(handle, inode, bh);
1573 EXT4_I(inode)->i_file_acl = 0;
1574
1575 cleanup:
1576 brelse(bh);
1577 }
1578
1579 /*
1580 * ext4_xattr_cache_insert()
1581 *
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 */
1587 static void
1588 ext4_xattr_cache_insert(struct mb_cache *ext4_mb_cache, struct buffer_head *bh)
1589 {
1590 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;
1594 int error;
1595
1596 error = mb_cache_entry_create(ext4_mb_cache, GFP_NOFS, hash,
1597 bh->b_blocknr, reusable);
1598 if (error) {
1599 if (error == -EBUSY)
1600 ea_bdebug(bh, "already in cache");
1601 } else
1602 ea_bdebug(bh, "inserting [%x]", (int)hash);
1603 }
1604
1605 /*
1606 * ext4_xattr_cmp()
1607 *
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 */
1613 static int
1614 ext4_xattr_cmp(struct ext4_xattr_header *header1,
1615 struct ext4_xattr_header *header2)
1616 {
1617 struct ext4_xattr_entry *entry1, *entry2;
1618
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)
1631 return -EFSCORRUPTED;
1632 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
1637 entry1 = EXT4_XATTR_NEXT(entry1);
1638 entry2 = EXT4_XATTR_NEXT(entry2);
1639 }
1640 if (!IS_LAST_ENTRY(entry2))
1641 return 1;
1642 return 0;
1643 }
1644
1645 /*
1646 * ext4_xattr_cache_find()
1647 *
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 */
1653 static struct buffer_head *
1654 ext4_xattr_cache_find(struct inode *inode, struct ext4_xattr_header *header,
1655 struct mb_cache_entry **pce)
1656 {
1657 __u32 hash = le32_to_cpu(header->h_hash);
1658 struct mb_cache_entry *ce;
1659 struct mb_cache *ext4_mb_cache = EXT4_GET_MB_CACHE(inode);
1660
1661 if (!header->h_hash)
1662 return NULL; /* never share */
1663 ea_idebug(inode, "looking for cached blocks [%x]", (int)hash);
1664 ce = mb_cache_entry_find_first(ext4_mb_cache, hash);
1665 while (ce) {
1666 struct buffer_head *bh;
1667
1668 bh = sb_bread(inode->i_sb, ce->e_block);
1669 if (!bh) {
1670 EXT4_ERROR_INODE(inode, "block %lu read error",
1671 (unsigned long) ce->e_block);
1672 } else if (ext4_xattr_cmp(header, BHDR(bh)) == 0) {
1673 *pce = ce;
1674 return bh;
1675 }
1676 brelse(bh);
1677 ce = mb_cache_entry_find_next(ext4_mb_cache, ce);
1678 }
1679 return NULL;
1680 }
1681
1682 #define NAME_HASH_SHIFT 5
1683 #define VALUE_HASH_SHIFT 16
1684
1685 /*
1686 * ext4_xattr_hash_entry()
1687 *
1688 * Compute the hash of an extended attribute.
1689 */
1690 static inline void ext4_xattr_hash_entry(struct ext4_xattr_header *header,
1691 struct ext4_xattr_entry *entry)
1692 {
1693 __u32 hash = 0;
1694 char *name = entry->e_name;
1695 int n;
1696
1697 for (n = 0; n < entry->e_name_len; n++) {
1698 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) +
1707 EXT4_XATTR_ROUND) >> EXT4_XATTR_PAD_BITS; n; n--) {
1708 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 /*
1722 * ext4_xattr_rehash()
1723 *
1724 * Re-compute the extended attribute hash value after an entry has changed.
1725 */
1726 static void ext4_xattr_rehash(struct ext4_xattr_header *header,
1727 struct ext4_xattr_entry *entry)
1728 {
1729 struct ext4_xattr_entry *here;
1730 __u32 hash = 0;
1731
1732 ext4_xattr_hash_entry(header, entry);
1733 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);
1743 here = EXT4_XATTR_NEXT(here);
1744 }
1745 header->h_hash = cpu_to_le32(hash);
1746 }
1747
1748 #undef BLOCK_HASH_SHIFT
1749
1750 #define HASH_BUCKET_BITS 10
1751
1752 struct mb_cache *
1753 ext4_xattr_create_cache(void)
1754 {
1755 return mb_cache_create(HASH_BUCKET_BITS);
1756 }
1757
1758 void ext4_xattr_destroy_cache(struct mb_cache *cache)
1759 {
1760 if (cache)
1761 mb_cache_destroy(cache);
1762 }
1763
Linux kernel - Deliverables
This page took 0.063883 seconds and 6 git commands to generate.