1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54#include <linux/init.h>
55#include <linux/fs.h>
56#include <linux/slab.h>
57#include <linux/mbcache.h>
58#include <linux/quotaops.h>
59#include <linux/iversion.h>
60#include "ext4_jbd2.h"
61#include "ext4.h"
62#include "xattr.h"
63#include "acl.h"
64
65#ifdef EXT4_XATTR_DEBUG
66# define ea_idebug(inode, fmt, ...) \
67 printk(KERN_DEBUG "inode %s:%lu: " fmt "\n", \
68 inode->i_sb->s_id, inode->i_ino, ##__VA_ARGS__)
69# define ea_bdebug(bh, fmt, ...) \
70 printk(KERN_DEBUG "block %pg:%lu: " fmt "\n", \
71 bh->b_bdev, (unsigned long)bh->b_blocknr, ##__VA_ARGS__)
72#else
73# define ea_idebug(inode, fmt, ...) no_printk(fmt, ##__VA_ARGS__)
74# define ea_bdebug(bh, fmt, ...) no_printk(fmt, ##__VA_ARGS__)
75#endif
76
77static void ext4_xattr_block_cache_insert(struct mb_cache *,
78 struct buffer_head *);
79static struct buffer_head *
80ext4_xattr_block_cache_find(struct inode *, struct ext4_xattr_header *,
81 struct mb_cache_entry **);
82static __le32 ext4_xattr_hash_entry(char *name, size_t name_len, __le32 *value,
83 size_t value_count);
84static void ext4_xattr_rehash(struct ext4_xattr_header *);
85
86static const struct xattr_handler * const ext4_xattr_handler_map[] = {
87 [EXT4_XATTR_INDEX_USER] = &ext4_xattr_user_handler,
88#ifdef CONFIG_EXT4_FS_POSIX_ACL
89 [EXT4_XATTR_INDEX_POSIX_ACL_ACCESS] = &posix_acl_access_xattr_handler,
90 [EXT4_XATTR_INDEX_POSIX_ACL_DEFAULT] = &posix_acl_default_xattr_handler,
91#endif
92 [EXT4_XATTR_INDEX_TRUSTED] = &ext4_xattr_trusted_handler,
93#ifdef CONFIG_EXT4_FS_SECURITY
94 [EXT4_XATTR_INDEX_SECURITY] = &ext4_xattr_security_handler,
95#endif
96 [EXT4_XATTR_INDEX_HURD] = &ext4_xattr_hurd_handler,
97};
98
99const struct xattr_handler *ext4_xattr_handlers[] = {
100 &ext4_xattr_user_handler,
101 &ext4_xattr_trusted_handler,
102#ifdef CONFIG_EXT4_FS_POSIX_ACL
103 &posix_acl_access_xattr_handler,
104 &posix_acl_default_xattr_handler,
105#endif
106#ifdef CONFIG_EXT4_FS_SECURITY
107 &ext4_xattr_security_handler,
108#endif
109 &ext4_xattr_hurd_handler,
110 NULL
111};
112
113#define EA_BLOCK_CACHE(inode) (((struct ext4_sb_info *) \
114 inode->i_sb->s_fs_info)->s_ea_block_cache)
115
116#define EA_INODE_CACHE(inode) (((struct ext4_sb_info *) \
117 inode->i_sb->s_fs_info)->s_ea_inode_cache)
118
119static int
120ext4_expand_inode_array(struct ext4_xattr_inode_array **ea_inode_array,
121 struct inode *inode);
122
123#ifdef CONFIG_LOCKDEP
124void ext4_xattr_inode_set_class(struct inode *ea_inode)
125{
126 lockdep_set_subclass(&ea_inode->i_rwsem, 1);
127}
128#endif
129
130static __le32 ext4_xattr_block_csum(struct inode *inode,
131 sector_t block_nr,
132 struct ext4_xattr_header *hdr)
133{
134 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
135 __u32 csum;
136 __le64 dsk_block_nr = cpu_to_le64(block_nr);
137 __u32 dummy_csum = 0;
138 int offset = offsetof(struct ext4_xattr_header, h_checksum);
139
140 csum = ext4_chksum(sbi, sbi->s_csum_seed, (__u8 *)&dsk_block_nr,
141 sizeof(dsk_block_nr));
142 csum = ext4_chksum(sbi, csum, (__u8 *)hdr, offset);
143 csum = ext4_chksum(sbi, csum, (__u8 *)&dummy_csum, sizeof(dummy_csum));
144 offset += sizeof(dummy_csum);
145 csum = ext4_chksum(sbi, csum, (__u8 *)hdr + offset,
146 EXT4_BLOCK_SIZE(inode->i_sb) - offset);
147
148 return cpu_to_le32(csum);
149}
150
151static int ext4_xattr_block_csum_verify(struct inode *inode,
152 struct buffer_head *bh)
153{
154 struct ext4_xattr_header *hdr = BHDR(bh);
155 int ret = 1;
156
157 if (ext4_has_metadata_csum(inode->i_sb)) {
158 lock_buffer(bh);
159 ret = (hdr->h_checksum == ext4_xattr_block_csum(inode,
160 bh->b_blocknr, hdr));
161 unlock_buffer(bh);
162 }
163 return ret;
164}
165
166static void ext4_xattr_block_csum_set(struct inode *inode,
167 struct buffer_head *bh)
168{
169 if (ext4_has_metadata_csum(inode->i_sb))
170 BHDR(bh)->h_checksum = ext4_xattr_block_csum(inode,
171 bh->b_blocknr, BHDR(bh));
172}
173
174static inline const struct xattr_handler *
175ext4_xattr_handler(int name_index)
176{
177 const struct xattr_handler *handler = NULL;
178
179 if (name_index > 0 && name_index < ARRAY_SIZE(ext4_xattr_handler_map))
180 handler = ext4_xattr_handler_map[name_index];
181 return handler;
182}
183
184static int
185ext4_xattr_check_entries(struct ext4_xattr_entry *entry, void *end,
186 void *value_start)
187{
188 struct ext4_xattr_entry *e = entry;
189
190
191 while (!IS_LAST_ENTRY(e)) {
192 struct ext4_xattr_entry *next = EXT4_XATTR_NEXT(e);
193 if ((void *)next >= end)
194 return -EFSCORRUPTED;
195 if (strnlen(e->e_name, e->e_name_len) != e->e_name_len)
196 return -EFSCORRUPTED;
197 e = next;
198 }
199
200
201 while (!IS_LAST_ENTRY(entry)) {
202 u32 size = le32_to_cpu(entry->e_value_size);
203
204 if (size > EXT4_XATTR_SIZE_MAX)
205 return -EFSCORRUPTED;
206
207 if (size != 0 && entry->e_value_inum == 0) {
208 u16 offs = le16_to_cpu(entry->e_value_offs);
209 void *value;
210
211
212
213
214
215
216
217 if (offs > end - value_start)
218 return -EFSCORRUPTED;
219 value = value_start + offs;
220 if (value < (void *)e + sizeof(u32) ||
221 size > end - value ||
222 EXT4_XATTR_SIZE(size) > end - value)
223 return -EFSCORRUPTED;
224 }
225 entry = EXT4_XATTR_NEXT(entry);
226 }
227
228 return 0;
229}
230
231static inline int
232__ext4_xattr_check_block(struct inode *inode, struct buffer_head *bh,
233 const char *function, unsigned int line)
234{
235 int error = -EFSCORRUPTED;
236
237 if (BHDR(bh)->h_magic != cpu_to_le32(EXT4_XATTR_MAGIC) ||
238 BHDR(bh)->h_blocks != cpu_to_le32(1))
239 goto errout;
240 if (buffer_verified(bh))
241 return 0;
242
243 error = -EFSBADCRC;
244 if (!ext4_xattr_block_csum_verify(inode, bh))
245 goto errout;
246 error = ext4_xattr_check_entries(BFIRST(bh), bh->b_data + bh->b_size,
247 bh->b_data);
248errout:
249 if (error)
250 __ext4_error_inode(inode, function, line, 0, -error,
251 "corrupted xattr block %llu",
252 (unsigned long long) bh->b_blocknr);
253 else
254 set_buffer_verified(bh);
255 return error;
256}
257
258#define ext4_xattr_check_block(inode, bh) \
259 __ext4_xattr_check_block((inode), (bh), __func__, __LINE__)
260
261
262static int
263__xattr_check_inode(struct inode *inode, struct ext4_xattr_ibody_header *header,
264 void *end, const char *function, unsigned int line)
265{
266 int error = -EFSCORRUPTED;
267
268 if (end - (void *)header < sizeof(*header) + sizeof(u32) ||
269 (header->h_magic != cpu_to_le32(EXT4_XATTR_MAGIC)))
270 goto errout;
271 error = ext4_xattr_check_entries(IFIRST(header), end, IFIRST(header));
272errout:
273 if (error)
274 __ext4_error_inode(inode, function, line, 0, -error,
275 "corrupted in-inode xattr");
276 return error;
277}
278
279#define xattr_check_inode(inode, header, end) \
280 __xattr_check_inode((inode), (header), (end), __func__, __LINE__)
281
282static int
283xattr_find_entry(struct inode *inode, struct ext4_xattr_entry **pentry,
284 void *end, int name_index, const char *name, int sorted)
285{
286 struct ext4_xattr_entry *entry, *next;
287 size_t name_len;
288 int cmp = 1;
289
290 if (name == NULL)
291 return -EINVAL;
292 name_len = strlen(name);
293 for (entry = *pentry; !IS_LAST_ENTRY(entry); entry = next) {
294 next = EXT4_XATTR_NEXT(entry);
295 if ((void *) next >= end) {
296 EXT4_ERROR_INODE(inode, "corrupted xattr entries");
297 return -EFSCORRUPTED;
298 }
299 cmp = name_index - entry->e_name_index;
300 if (!cmp)
301 cmp = name_len - entry->e_name_len;
302 if (!cmp)
303 cmp = memcmp(name, entry->e_name, name_len);
304 if (cmp <= 0 && (sorted || cmp == 0))
305 break;
306 }
307 *pentry = entry;
308 return cmp ? -ENODATA : 0;
309}
310
311static u32
312ext4_xattr_inode_hash(struct ext4_sb_info *sbi, const void *buffer, size_t size)
313{
314 return ext4_chksum(sbi, sbi->s_csum_seed, buffer, size);
315}
316
317static u64 ext4_xattr_inode_get_ref(struct inode *ea_inode)
318{
319 return ((u64)ea_inode->i_ctime.tv_sec << 32) |
320 (u32) inode_peek_iversion_raw(ea_inode);
321}
322
323static void ext4_xattr_inode_set_ref(struct inode *ea_inode, u64 ref_count)
324{
325 ea_inode->i_ctime.tv_sec = (u32)(ref_count >> 32);
326 inode_set_iversion_raw(ea_inode, ref_count & 0xffffffff);
327}
328
329static u32 ext4_xattr_inode_get_hash(struct inode *ea_inode)
330{
331 return (u32)ea_inode->i_atime.tv_sec;
332}
333
334static void ext4_xattr_inode_set_hash(struct inode *ea_inode, u32 hash)
335{
336 ea_inode->i_atime.tv_sec = hash;
337}
338
339
340
341
342static int ext4_xattr_inode_read(struct inode *ea_inode, void *buf, size_t size)
343{
344 int blocksize = 1 << ea_inode->i_blkbits;
345 int bh_count = (size + blocksize - 1) >> ea_inode->i_blkbits;
346 int tail_size = (size % blocksize) ?: blocksize;
347 struct buffer_head *bhs_inline[8];
348 struct buffer_head **bhs = bhs_inline;
349 int i, ret;
350
351 if (bh_count > ARRAY_SIZE(bhs_inline)) {
352 bhs = kmalloc_array(bh_count, sizeof(*bhs), GFP_NOFS);
353 if (!bhs)
354 return -ENOMEM;
355 }
356
357 ret = ext4_bread_batch(ea_inode, 0 , bh_count,
358 true , bhs);
359 if (ret)
360 goto free_bhs;
361
362 for (i = 0; i < bh_count; i++) {
363
364 if (!bhs[i]) {
365 ret = -EFSCORRUPTED;
366 goto put_bhs;
367 }
368 memcpy((char *)buf + blocksize * i, bhs[i]->b_data,
369 i < bh_count - 1 ? blocksize : tail_size);
370 }
371 ret = 0;
372put_bhs:
373 for (i = 0; i < bh_count; i++)
374 brelse(bhs[i]);
375free_bhs:
376 if (bhs != bhs_inline)
377 kfree(bhs);
378 return ret;
379}
380
381#define EXT4_XATTR_INODE_GET_PARENT(inode) ((__u32)(inode)->i_mtime.tv_sec)
382
383static int ext4_xattr_inode_iget(struct inode *parent, unsigned long ea_ino,
384 u32 ea_inode_hash, struct inode **ea_inode)
385{
386 struct inode *inode;
387 int err;
388
389 inode = ext4_iget(parent->i_sb, ea_ino, EXT4_IGET_NORMAL);
390 if (IS_ERR(inode)) {
391 err = PTR_ERR(inode);
392 ext4_error(parent->i_sb,
393 "error while reading EA inode %lu err=%d", ea_ino,
394 err);
395 return err;
396 }
397
398 if (is_bad_inode(inode)) {
399 ext4_error(parent->i_sb,
400 "error while reading EA inode %lu is_bad_inode",
401 ea_ino);
402 err = -EIO;
403 goto error;
404 }
405
406 if (!(EXT4_I(inode)->i_flags & EXT4_EA_INODE_FL)) {
407 ext4_error(parent->i_sb,
408 "EA inode %lu does not have EXT4_EA_INODE_FL flag",
409 ea_ino);
410 err = -EINVAL;
411 goto error;
412 }
413
414 ext4_xattr_inode_set_class(inode);
415
416
417
418
419
420
421 if (ea_inode_hash != ext4_xattr_inode_get_hash(inode) &&
422 EXT4_XATTR_INODE_GET_PARENT(inode) == parent->i_ino &&
423 inode->i_generation == parent->i_generation) {
424 ext4_set_inode_state(inode, EXT4_STATE_LUSTRE_EA_INODE);
425 ext4_xattr_inode_set_ref(inode, 1);
426 } else {
427 inode_lock(inode);
428 inode->i_flags |= S_NOQUOTA;
429 inode_unlock(inode);
430 }
431
432 *ea_inode = inode;
433 return 0;
434error:
435 iput(inode);
436 return err;
437}
438
439static int
440ext4_xattr_inode_verify_hashes(struct inode *ea_inode,
441 struct ext4_xattr_entry *entry, void *buffer,
442 size_t size)
443{
444 u32 hash;
445
446
447 hash = ext4_xattr_inode_hash(EXT4_SB(ea_inode->i_sb), buffer, size);
448 if (hash != ext4_xattr_inode_get_hash(ea_inode))
449 return -EFSCORRUPTED;
450
451 if (entry) {
452 __le32 e_hash, tmp_data;
453
454
455 tmp_data = cpu_to_le32(hash);
456 e_hash = ext4_xattr_hash_entry(entry->e_name, entry->e_name_len,
457 &tmp_data, 1);
458 if (e_hash != entry->e_hash)
459 return -EFSCORRUPTED;
460 }
461 return 0;
462}
463
464
465
466
467static int
468ext4_xattr_inode_get(struct inode *inode, struct ext4_xattr_entry *entry,
469 void *buffer, size_t size)
470{
471 struct mb_cache *ea_inode_cache = EA_INODE_CACHE(inode);
472 struct inode *ea_inode;
473 int err;
474
475 err = ext4_xattr_inode_iget(inode, le32_to_cpu(entry->e_value_inum),
476 le32_to_cpu(entry->e_hash), &ea_inode);
477 if (err) {
478 ea_inode = NULL;
479 goto out;
480 }
481
482 if (i_size_read(ea_inode) != size) {
483 ext4_warning_inode(ea_inode,
484 "ea_inode file size=%llu entry size=%zu",
485 i_size_read(ea_inode), size);
486 err = -EFSCORRUPTED;
487 goto out;
488 }
489
490 err = ext4_xattr_inode_read(ea_inode, buffer, size);
491 if (err)
492 goto out;
493
494 if (!ext4_test_inode_state(ea_inode, EXT4_STATE_LUSTRE_EA_INODE)) {
495 err = ext4_xattr_inode_verify_hashes(ea_inode, entry, buffer,
496 size);
497 if (err) {
498 ext4_warning_inode(ea_inode,
499 "EA inode hash validation failed");
500 goto out;
501 }
502
503 if (ea_inode_cache)
504 mb_cache_entry_create(ea_inode_cache, GFP_NOFS,
505 ext4_xattr_inode_get_hash(ea_inode),
506 ea_inode->i_ino, true );
507 }
508out:
509 iput(ea_inode);
510 return err;
511}
512
513static int
514ext4_xattr_block_get(struct inode *inode, int name_index, const char *name,
515 void *buffer, size_t buffer_size)
516{
517 struct buffer_head *bh = NULL;
518 struct ext4_xattr_entry *entry;
519 size_t size;
520 void *end;
521 int error;
522 struct mb_cache *ea_block_cache = EA_BLOCK_CACHE(inode);
523
524 ea_idebug(inode, "name=%d.%s, buffer=%p, buffer_size=%ld",
525 name_index, name, buffer, (long)buffer_size);
526
527 if (!EXT4_I(inode)->i_file_acl)
528 return -ENODATA;
529 ea_idebug(inode, "reading block %llu",
530 (unsigned long long)EXT4_I(inode)->i_file_acl);
531 bh = ext4_sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl, REQ_PRIO);
532 if (IS_ERR(bh))
533 return PTR_ERR(bh);
534 ea_bdebug(bh, "b_count=%d, refcount=%d",
535 atomic_read(&(bh->b_count)), le32_to_cpu(BHDR(bh)->h_refcount));
536 error = ext4_xattr_check_block(inode, bh);
537 if (error)
538 goto cleanup;
539 ext4_xattr_block_cache_insert(ea_block_cache, bh);
540 entry = BFIRST(bh);
541 end = bh->b_data + bh->b_size;
542 error = xattr_find_entry(inode, &entry, end, name_index, name, 1);
543 if (error)
544 goto cleanup;
545 size = le32_to_cpu(entry->e_value_size);
546 error = -ERANGE;
547 if (unlikely(size > EXT4_XATTR_SIZE_MAX))
548 goto cleanup;
549 if (buffer) {
550 if (size > buffer_size)
551 goto cleanup;
552 if (entry->e_value_inum) {
553 error = ext4_xattr_inode_get(inode, entry, buffer,
554 size);
555 if (error)
556 goto cleanup;
557 } else {
558 u16 offset = le16_to_cpu(entry->e_value_offs);
559 void *p = bh->b_data + offset;
560
561 if (unlikely(p + size > end))
562 goto cleanup;
563 memcpy(buffer, p, size);
564 }
565 }
566 error = size;
567
568cleanup:
569 brelse(bh);
570 return error;
571}
572
573int
574ext4_xattr_ibody_get(struct inode *inode, int name_index, const char *name,
575 void *buffer, size_t buffer_size)
576{
577 struct ext4_xattr_ibody_header *header;
578 struct ext4_xattr_entry *entry;
579 struct ext4_inode *raw_inode;
580 struct ext4_iloc iloc;
581 size_t size;
582 void *end;
583 int error;
584
585 if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR))
586 return -ENODATA;
587 error = ext4_get_inode_loc(inode, &iloc);
588 if (error)
589 return error;
590 raw_inode = ext4_raw_inode(&iloc);
591 header = IHDR(inode, raw_inode);
592 end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
593 error = xattr_check_inode(inode, header, end);
594 if (error)
595 goto cleanup;
596 entry = IFIRST(header);
597 error = xattr_find_entry(inode, &entry, end, name_index, name, 0);
598 if (error)
599 goto cleanup;
600 size = le32_to_cpu(entry->e_value_size);
601 error = -ERANGE;
602 if (unlikely(size > EXT4_XATTR_SIZE_MAX))
603 goto cleanup;
604 if (buffer) {
605 if (size > buffer_size)
606 goto cleanup;
607 if (entry->e_value_inum) {
608 error = ext4_xattr_inode_get(inode, entry, buffer,
609 size);
610 if (error)
611 goto cleanup;
612 } else {
613 u16 offset = le16_to_cpu(entry->e_value_offs);
614 void *p = (void *)IFIRST(header) + offset;
615
616 if (unlikely(p + size > end))
617 goto cleanup;
618 memcpy(buffer, p, size);
619 }
620 }
621 error = size;
622
623cleanup:
624 brelse(iloc.bh);
625 return error;
626}
627
628
629
630
631
632
633
634
635
636
637
638int
639ext4_xattr_get(struct inode *inode, int name_index, const char *name,
640 void *buffer, size_t buffer_size)
641{
642 int error;
643
644 if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb))))
645 return -EIO;
646
647 if (strlen(name) > 255)
648 return -ERANGE;
649
650 down_read(&EXT4_I(inode)->xattr_sem);
651 error = ext4_xattr_ibody_get(inode, name_index, name, buffer,
652 buffer_size);
653 if (error == -ENODATA)
654 error = ext4_xattr_block_get(inode, name_index, name, buffer,
655 buffer_size);
656 up_read(&EXT4_I(inode)->xattr_sem);
657 return error;
658}
659
660static int
661ext4_xattr_list_entries(struct dentry *dentry, struct ext4_xattr_entry *entry,
662 char *buffer, size_t buffer_size)
663{
664 size_t rest = buffer_size;
665
666 for (; !IS_LAST_ENTRY(entry); entry = EXT4_XATTR_NEXT(entry)) {
667 const struct xattr_handler *handler =
668 ext4_xattr_handler(entry->e_name_index);
669
670 if (handler && (!handler->list || handler->list(dentry))) {
671 const char *prefix = handler->prefix ?: handler->name;
672 size_t prefix_len = strlen(prefix);
673 size_t size = prefix_len + entry->e_name_len + 1;
674
675 if (buffer) {
676 if (size > rest)
677 return -ERANGE;
678 memcpy(buffer, prefix, prefix_len);
679 buffer += prefix_len;
680 memcpy(buffer, entry->e_name, entry->e_name_len);
681 buffer += entry->e_name_len;
682 *buffer++ = 0;
683 }
684 rest -= size;
685 }
686 }
687 return buffer_size - rest;
688}
689
690static int
691ext4_xattr_block_list(struct dentry *dentry, char *buffer, size_t buffer_size)
692{
693 struct inode *inode = d_inode(dentry);
694 struct buffer_head *bh = NULL;
695 int error;
696
697 ea_idebug(inode, "buffer=%p, buffer_size=%ld",
698 buffer, (long)buffer_size);
699
700 if (!EXT4_I(inode)->i_file_acl)
701 return 0;
702 ea_idebug(inode, "reading block %llu",
703 (unsigned long long)EXT4_I(inode)->i_file_acl);
704 bh = ext4_sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl, REQ_PRIO);
705 if (IS_ERR(bh))
706 return PTR_ERR(bh);
707 ea_bdebug(bh, "b_count=%d, refcount=%d",
708 atomic_read(&(bh->b_count)), le32_to_cpu(BHDR(bh)->h_refcount));
709 error = ext4_xattr_check_block(inode, bh);
710 if (error)
711 goto cleanup;
712 ext4_xattr_block_cache_insert(EA_BLOCK_CACHE(inode), bh);
713 error = ext4_xattr_list_entries(dentry, BFIRST(bh), buffer,
714 buffer_size);
715cleanup:
716 brelse(bh);
717 return error;
718}
719
720static int
721ext4_xattr_ibody_list(struct dentry *dentry, char *buffer, size_t buffer_size)
722{
723 struct inode *inode = d_inode(dentry);
724 struct ext4_xattr_ibody_header *header;
725 struct ext4_inode *raw_inode;
726 struct ext4_iloc iloc;
727 void *end;
728 int error;
729
730 if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR))
731 return 0;
732 error = ext4_get_inode_loc(inode, &iloc);
733 if (error)
734 return error;
735 raw_inode = ext4_raw_inode(&iloc);
736 header = IHDR(inode, raw_inode);
737 end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
738 error = xattr_check_inode(inode, header, end);
739 if (error)
740 goto cleanup;
741 error = ext4_xattr_list_entries(dentry, IFIRST(header),
742 buffer, buffer_size);
743
744cleanup:
745 brelse(iloc.bh);
746 return error;
747}
748
749
750
751
752
753
754
755
756
757
758
759
760
761ssize_t
762ext4_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size)
763{
764 int ret, ret2;
765
766 down_read(&EXT4_I(d_inode(dentry))->xattr_sem);
767 ret = ret2 = ext4_xattr_ibody_list(dentry, buffer, buffer_size);
768 if (ret < 0)
769 goto errout;
770 if (buffer) {
771 buffer += ret;
772 buffer_size -= ret;
773 }
774 ret = ext4_xattr_block_list(dentry, buffer, buffer_size);
775 if (ret < 0)
776 goto errout;
777 ret += ret2;
778errout:
779 up_read(&EXT4_I(d_inode(dentry))->xattr_sem);
780 return ret;
781}
782
783
784
785
786
787static void ext4_xattr_update_super_block(handle_t *handle,
788 struct super_block *sb)
789{
790 if (ext4_has_feature_xattr(sb))
791 return;
792
793 BUFFER_TRACE(EXT4_SB(sb)->s_sbh, "get_write_access");
794 if (ext4_journal_get_write_access(handle, sb, EXT4_SB(sb)->s_sbh,
795 EXT4_JTR_NONE) == 0) {
796 lock_buffer(EXT4_SB(sb)->s_sbh);
797 ext4_set_feature_xattr(sb);
798 ext4_superblock_csum_set(sb);
799 unlock_buffer(EXT4_SB(sb)->s_sbh);
800 ext4_handle_dirty_metadata(handle, NULL, EXT4_SB(sb)->s_sbh);
801 }
802}
803
804int ext4_get_inode_usage(struct inode *inode, qsize_t *usage)
805{
806 struct ext4_iloc iloc = { .bh = NULL };
807 struct buffer_head *bh = NULL;
808 struct ext4_inode *raw_inode;
809 struct ext4_xattr_ibody_header *header;
810 struct ext4_xattr_entry *entry;
811 qsize_t ea_inode_refs = 0;
812 void *end;
813 int ret;
814
815 lockdep_assert_held_read(&EXT4_I(inode)->xattr_sem);
816
817 if (ext4_test_inode_state(inode, EXT4_STATE_XATTR)) {
818 ret = ext4_get_inode_loc(inode, &iloc);
819 if (ret)
820 goto out;
821 raw_inode = ext4_raw_inode(&iloc);
822 header = IHDR(inode, raw_inode);
823 end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
824 ret = xattr_check_inode(inode, header, end);
825 if (ret)
826 goto out;
827
828 for (entry = IFIRST(header); !IS_LAST_ENTRY(entry);
829 entry = EXT4_XATTR_NEXT(entry))
830 if (entry->e_value_inum)
831 ea_inode_refs++;
832 }
833
834 if (EXT4_I(inode)->i_file_acl) {
835 bh = ext4_sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl, REQ_PRIO);
836 if (IS_ERR(bh)) {
837 ret = PTR_ERR(bh);
838 bh = NULL;
839 goto out;
840 }
841
842 ret = ext4_xattr_check_block(inode, bh);
843 if (ret)
844 goto out;
845
846 for (entry = BFIRST(bh); !IS_LAST_ENTRY(entry);
847 entry = EXT4_XATTR_NEXT(entry))
848 if (entry->e_value_inum)
849 ea_inode_refs++;
850 }
851 *usage = ea_inode_refs + 1;
852 ret = 0;
853out:
854 brelse(iloc.bh);
855 brelse(bh);
856 return ret;
857}
858
859static inline size_t round_up_cluster(struct inode *inode, size_t length)
860{
861 struct super_block *sb = inode->i_sb;
862 size_t cluster_size = 1 << (EXT4_SB(sb)->s_cluster_bits +
863 inode->i_blkbits);
864 size_t mask = ~(cluster_size - 1);
865
866 return (length + cluster_size - 1) & mask;
867}
868
869static int ext4_xattr_inode_alloc_quota(struct inode *inode, size_t len)
870{
871 int err;
872
873 err = dquot_alloc_inode(inode);
874 if (err)
875 return err;
876 err = dquot_alloc_space_nodirty(inode, round_up_cluster(inode, len));
877 if (err)
878 dquot_free_inode(inode);
879 return err;
880}
881
882static void ext4_xattr_inode_free_quota(struct inode *parent,
883 struct inode *ea_inode,
884 size_t len)
885{
886 if (ea_inode &&
887 ext4_test_inode_state(ea_inode, EXT4_STATE_LUSTRE_EA_INODE))
888 return;
889 dquot_free_space_nodirty(parent, round_up_cluster(parent, len));
890 dquot_free_inode(parent);
891}
892
893int __ext4_xattr_set_credits(struct super_block *sb, struct inode *inode,
894 struct buffer_head *block_bh, size_t value_len,
895 bool is_create)
896{
897 int credits;
898 int blocks;
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913 credits = 7;
914
915
916 credits += EXT4_MAXQUOTAS_TRANS_BLOCKS(sb);
917
918
919
920
921
922 if (inode && ext4_has_inline_data(inode))
923 credits += ext4_writepage_trans_blocks(inode) + 1;
924
925
926 if (!ext4_has_feature_ea_inode(sb))
927 return credits;
928
929
930 credits += 4;
931
932
933 blocks = (value_len + sb->s_blocksize - 1) >> sb->s_blocksize_bits;
934
935
936 blocks += 1;
937
938
939 credits += blocks * 2;
940
941
942 credits += blocks;
943
944 if (!is_create) {
945
946
947
948 credits += 4;
949
950
951 blocks = XATTR_SIZE_MAX >> sb->s_blocksize_bits;
952
953
954
955
956 blocks += 1;
957
958
959 credits += blocks * 2;
960 }
961
962
963
964
965 if (block_bh) {
966 struct ext4_xattr_entry *entry = BFIRST(block_bh);
967
968 for (; !IS_LAST_ENTRY(entry); entry = EXT4_XATTR_NEXT(entry))
969 if (entry->e_value_inum)
970
971 credits += 1;
972 }
973 return credits;
974}
975
976static int ext4_xattr_inode_update_ref(handle_t *handle, struct inode *ea_inode,
977 int ref_change)
978{
979 struct mb_cache *ea_inode_cache = EA_INODE_CACHE(ea_inode);
980 struct ext4_iloc iloc;
981 s64 ref_count;
982 u32 hash;
983 int ret;
984
985 inode_lock(ea_inode);
986
987 ret = ext4_reserve_inode_write(handle, ea_inode, &iloc);
988 if (ret)
989 goto out;
990
991 ref_count = ext4_xattr_inode_get_ref(ea_inode);
992 ref_count += ref_change;
993 ext4_xattr_inode_set_ref(ea_inode, ref_count);
994
995 if (ref_change > 0) {
996 WARN_ONCE(ref_count <= 0, "EA inode %lu ref_count=%lld",
997 ea_inode->i_ino, ref_count);
998
999 if (ref_count == 1) {
1000 WARN_ONCE(ea_inode->i_nlink, "EA inode %lu i_nlink=%u",
1001 ea_inode->i_ino, ea_inode->i_nlink);
1002
1003 set_nlink(ea_inode, 1);
1004 ext4_orphan_del(handle, ea_inode);
1005
1006 if (ea_inode_cache) {
1007 hash = ext4_xattr_inode_get_hash(ea_inode);
1008 mb_cache_entry_create(ea_inode_cache,
1009 GFP_NOFS, hash,
1010 ea_inode->i_ino,
1011 true );
1012 }
1013 }
1014 } else {
1015 WARN_ONCE(ref_count < 0, "EA inode %lu ref_count=%lld",
1016 ea_inode->i_ino, ref_count);
1017
1018 if (ref_count == 0) {
1019 WARN_ONCE(ea_inode->i_nlink != 1,
1020 "EA inode %lu i_nlink=%u",
1021 ea_inode->i_ino, ea_inode->i_nlink);
1022
1023 clear_nlink(ea_inode);
1024 ext4_orphan_add(handle, ea_inode);
1025
1026 if (ea_inode_cache) {
1027 hash = ext4_xattr_inode_get_hash(ea_inode);
1028 mb_cache_entry_delete(ea_inode_cache, hash,
1029 ea_inode->i_ino);
1030 }
1031 }
1032 }
1033
1034 ret = ext4_mark_iloc_dirty(handle, ea_inode, &iloc);
1035 if (ret)
1036 ext4_warning_inode(ea_inode,
1037 "ext4_mark_iloc_dirty() failed ret=%d", ret);
1038out:
1039 inode_unlock(ea_inode);
1040 return ret;
1041}
1042
1043static int ext4_xattr_inode_inc_ref(handle_t *handle, struct inode *ea_inode)
1044{
1045 return ext4_xattr_inode_update_ref(handle, ea_inode, 1);
1046}
1047
1048static int ext4_xattr_inode_dec_ref(handle_t *handle, struct inode *ea_inode)
1049{
1050 return ext4_xattr_inode_update_ref(handle, ea_inode, -1);
1051}
1052
1053static int ext4_xattr_inode_inc_ref_all(handle_t *handle, struct inode *parent,
1054 struct ext4_xattr_entry *first)
1055{
1056 struct inode *ea_inode;
1057 struct ext4_xattr_entry *entry;
1058 struct ext4_xattr_entry *failed_entry;
1059 unsigned int ea_ino;
1060 int err, saved_err;
1061
1062 for (entry = first; !IS_LAST_ENTRY(entry);
1063 entry = EXT4_XATTR_NEXT(entry)) {
1064 if (!entry->e_value_inum)
1065 continue;
1066 ea_ino = le32_to_cpu(entry->e_value_inum);
1067 err = ext4_xattr_inode_iget(parent, ea_ino,
1068 le32_to_cpu(entry->e_hash),
1069 &ea_inode);
1070 if (err)
1071 goto cleanup;
1072 err = ext4_xattr_inode_inc_ref(handle, ea_inode);
1073 if (err) {
1074 ext4_warning_inode(ea_inode, "inc ref error %d", err);
1075 iput(ea_inode);
1076 goto cleanup;
1077 }
1078 iput(ea_inode);
1079 }
1080 return 0;
1081
1082cleanup:
1083 saved_err = err;
1084 failed_entry = entry;
1085
1086 for (entry = first; entry != failed_entry;
1087 entry = EXT4_XATTR_NEXT(entry)) {
1088 if (!entry->e_value_inum)
1089 continue;
1090 ea_ino = le32_to_cpu(entry->e_value_inum);
1091 err = ext4_xattr_inode_iget(parent, ea_ino,
1092 le32_to_cpu(entry->e_hash),
1093 &ea_inode);
1094 if (err) {
1095 ext4_warning(parent->i_sb,
1096 "cleanup ea_ino %u iget error %d", ea_ino,
1097 err);
1098 continue;
1099 }
1100 err = ext4_xattr_inode_dec_ref(handle, ea_inode);
1101 if (err)
1102 ext4_warning_inode(ea_inode, "cleanup dec ref error %d",
1103 err);
1104 iput(ea_inode);
1105 }
1106 return saved_err;
1107}
1108
1109static int ext4_xattr_restart_fn(handle_t *handle, struct inode *inode,
1110 struct buffer_head *bh, bool block_csum, bool dirty)
1111{
1112 int error;
1113
1114 if (bh && dirty) {
1115 if (block_csum)
1116 ext4_xattr_block_csum_set(inode, bh);
1117 error = ext4_handle_dirty_metadata(handle, NULL, bh);
1118 if (error) {
1119 ext4_warning(inode->i_sb, "Handle metadata (error %d)",
1120 error);
1121 return error;
1122 }
1123 }
1124 return 0;
1125}
1126
1127static void
1128ext4_xattr_inode_dec_ref_all(handle_t *handle, struct inode *parent,
1129 struct buffer_head *bh,
1130 struct ext4_xattr_entry *first, bool block_csum,
1131 struct ext4_xattr_inode_array **ea_inode_array,
1132 int extra_credits, bool skip_quota)
1133{
1134 struct inode *ea_inode;
1135 struct ext4_xattr_entry *entry;
1136 bool dirty = false;
1137 unsigned int ea_ino;
1138 int err;
1139 int credits;
1140
1141
1142 credits = 2 + extra_credits;
1143
1144 for (entry = first; !IS_LAST_ENTRY(entry);
1145 entry = EXT4_XATTR_NEXT(entry)) {
1146 if (!entry->e_value_inum)
1147 continue;
1148 ea_ino = le32_to_cpu(entry->e_value_inum);
1149 err = ext4_xattr_inode_iget(parent, ea_ino,
1150 le32_to_cpu(entry->e_hash),
1151 &ea_inode);
1152 if (err)
1153 continue;
1154
1155 err = ext4_expand_inode_array(ea_inode_array, ea_inode);
1156 if (err) {
1157 ext4_warning_inode(ea_inode,
1158 "Expand inode array err=%d", err);
1159 iput(ea_inode);
1160 continue;
1161 }
1162
1163 err = ext4_journal_ensure_credits_fn(handle, credits, credits,
1164 ext4_free_metadata_revoke_credits(parent->i_sb, 1),
1165 ext4_xattr_restart_fn(handle, parent, bh, block_csum,
1166 dirty));
1167 if (err < 0) {
1168 ext4_warning_inode(ea_inode, "Ensure credits err=%d",
1169 err);
1170 continue;
1171 }
1172 if (err > 0) {
1173 err = ext4_journal_get_write_access(handle,
1174 parent->i_sb, bh, EXT4_JTR_NONE);
1175 if (err) {
1176 ext4_warning_inode(ea_inode,
1177 "Re-get write access err=%d",
1178 err);
1179 continue;
1180 }
1181 }
1182
1183 err = ext4_xattr_inode_dec_ref(handle, ea_inode);
1184 if (err) {
1185 ext4_warning_inode(ea_inode, "ea_inode dec ref err=%d",
1186 err);
1187 continue;
1188 }
1189
1190 if (!skip_quota)
1191 ext4_xattr_inode_free_quota(parent, ea_inode,
1192 le32_to_cpu(entry->e_value_size));
1193
1194
1195
1196
1197
1198
1199
1200 entry->e_value_inum = 0;
1201 entry->e_value_size = 0;
1202
1203 dirty = true;
1204 }
1205
1206 if (dirty) {
1207
1208
1209
1210
1211
1212
1213 err = ext4_handle_dirty_metadata(handle, NULL, bh);
1214 if (err)
1215 ext4_warning_inode(parent,
1216 "handle dirty metadata err=%d", err);
1217 }
1218}
1219
1220
1221
1222
1223
1224static void
1225ext4_xattr_release_block(handle_t *handle, struct inode *inode,
1226 struct buffer_head *bh,
1227 struct ext4_xattr_inode_array **ea_inode_array,
1228 int extra_credits)
1229{
1230 struct mb_cache *ea_block_cache = EA_BLOCK_CACHE(inode);
1231 u32 hash, ref;
1232 int error = 0;
1233
1234 BUFFER_TRACE(bh, "get_write_access");
1235 error = ext4_journal_get_write_access(handle, inode->i_sb, bh,
1236 EXT4_JTR_NONE);
1237 if (error)
1238 goto out;
1239
1240 lock_buffer(bh);
1241 hash = le32_to_cpu(BHDR(bh)->h_hash);
1242 ref = le32_to_cpu(BHDR(bh)->h_refcount);
1243 if (ref == 1) {
1244 ea_bdebug(bh, "refcount now=0; freeing");
1245
1246
1247
1248
1249 if (ea_block_cache)
1250 mb_cache_entry_delete(ea_block_cache, hash,
1251 bh->b_blocknr);
1252 get_bh(bh);
1253 unlock_buffer(bh);
1254
1255 if (ext4_has_feature_ea_inode(inode->i_sb))
1256 ext4_xattr_inode_dec_ref_all(handle, inode, bh,
1257 BFIRST(bh),
1258 true ,
1259 ea_inode_array,
1260 extra_credits,
1261 true );
1262 ext4_free_blocks(handle, inode, bh, 0, 1,
1263 EXT4_FREE_BLOCKS_METADATA |
1264 EXT4_FREE_BLOCKS_FORGET);
1265 } else {
1266 ref--;
1267 BHDR(bh)->h_refcount = cpu_to_le32(ref);
1268 if (ref == EXT4_XATTR_REFCOUNT_MAX - 1) {
1269 struct mb_cache_entry *ce;
1270
1271 if (ea_block_cache) {
1272 ce = mb_cache_entry_get(ea_block_cache, hash,
1273 bh->b_blocknr);
1274 if (ce) {
1275 ce->e_reusable = 1;
1276 mb_cache_entry_put(ea_block_cache, ce);
1277 }
1278 }
1279 }
1280
1281 ext4_xattr_block_csum_set(inode, bh);
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292 if (ext4_handle_valid(handle))
1293 error = ext4_handle_dirty_metadata(handle, inode, bh);
1294 unlock_buffer(bh);
1295 if (!ext4_handle_valid(handle))
1296 error = ext4_handle_dirty_metadata(handle, inode, bh);
1297 if (IS_SYNC(inode))
1298 ext4_handle_sync(handle);
1299 dquot_free_block(inode, EXT4_C2B(EXT4_SB(inode->i_sb), 1));
1300 ea_bdebug(bh, "refcount now=%d; releasing",
1301 le32_to_cpu(BHDR(bh)->h_refcount));
1302 }
1303out:
1304 ext4_std_error(inode->i_sb, error);
1305 return;
1306}
1307
1308
1309
1310
1311
1312static size_t ext4_xattr_free_space(struct ext4_xattr_entry *last,
1313 size_t *min_offs, void *base, int *total)
1314{
1315 for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
1316 if (!last->e_value_inum && last->e_value_size) {
1317 size_t offs = le16_to_cpu(last->e_value_offs);
1318 if (offs < *min_offs)
1319 *min_offs = offs;
1320 }
1321 if (total)
1322 *total += EXT4_XATTR_LEN(last->e_name_len);
1323 }
1324 return (*min_offs - ((void *)last - base) - sizeof(__u32));
1325}
1326
1327
1328
1329
1330static int ext4_xattr_inode_write(handle_t *handle, struct inode *ea_inode,
1331 const void *buf, int bufsize)
1332{
1333 struct buffer_head *bh = NULL;
1334 unsigned long block = 0;
1335 int blocksize = ea_inode->i_sb->s_blocksize;
1336 int max_blocks = (bufsize + blocksize - 1) >> ea_inode->i_blkbits;
1337 int csize, wsize = 0;
1338 int ret = 0, ret2 = 0;
1339 int retries = 0;
1340
1341retry:
1342 while (ret >= 0 && ret < max_blocks) {
1343 struct ext4_map_blocks map;
1344 map.m_lblk = block += ret;
1345 map.m_len = max_blocks -= ret;
1346
1347 ret = ext4_map_blocks(handle, ea_inode, &map,
1348 EXT4_GET_BLOCKS_CREATE);
1349 if (ret <= 0) {
1350 ext4_mark_inode_dirty(handle, ea_inode);
1351 if (ret == -ENOSPC &&
1352 ext4_should_retry_alloc(ea_inode->i_sb, &retries)) {
1353 ret = 0;
1354 goto retry;
1355 }
1356 break;
1357 }
1358 }
1359
1360 if (ret < 0)
1361 return ret;
1362
1363 block = 0;
1364 while (wsize < bufsize) {
1365 brelse(bh);
1366 csize = (bufsize - wsize) > blocksize ? blocksize :
1367 bufsize - wsize;
1368 bh = ext4_getblk(handle, ea_inode, block, 0);
1369 if (IS_ERR(bh))
1370 return PTR_ERR(bh);
1371 if (!bh) {
1372 WARN_ON_ONCE(1);
1373 EXT4_ERROR_INODE(ea_inode,
1374 "ext4_getblk() return bh = NULL");
1375 return -EFSCORRUPTED;
1376 }
1377 ret = ext4_journal_get_write_access(handle, ea_inode->i_sb, bh,
1378 EXT4_JTR_NONE);
1379 if (ret)
1380 goto out;
1381
1382 memcpy(bh->b_data, buf, csize);
1383 set_buffer_uptodate(bh);
1384 ext4_handle_dirty_metadata(handle, ea_inode, bh);
1385
1386 buf += csize;
1387 wsize += csize;
1388 block += 1;
1389 }
1390
1391 inode_lock(ea_inode);
1392 i_size_write(ea_inode, wsize);
1393 ext4_update_i_disksize(ea_inode, wsize);
1394 inode_unlock(ea_inode);
1395
1396 ret2 = ext4_mark_inode_dirty(handle, ea_inode);
1397 if (unlikely(ret2 && !ret))
1398 ret = ret2;
1399
1400out:
1401 brelse(bh);
1402
1403 return ret;
1404}
1405
1406
1407
1408
1409static struct inode *ext4_xattr_inode_create(handle_t *handle,
1410 struct inode *inode, u32 hash)
1411{
1412 struct inode *ea_inode = NULL;
1413 uid_t owner[2] = { i_uid_read(inode), i_gid_read(inode) };
1414 int err;
1415
1416
1417
1418
1419
1420 ea_inode = ext4_new_inode(handle, inode->i_sb->s_root->d_inode,
1421 S_IFREG | 0600, NULL, inode->i_ino + 1, owner,
1422 EXT4_EA_INODE_FL);
1423 if (!IS_ERR(ea_inode)) {
1424 ea_inode->i_op = &ext4_file_inode_operations;
1425 ea_inode->i_fop = &ext4_file_operations;
1426 ext4_set_aops(ea_inode);
1427 ext4_xattr_inode_set_class(ea_inode);
1428 unlock_new_inode(ea_inode);
1429 ext4_xattr_inode_set_ref(ea_inode, 1);
1430 ext4_xattr_inode_set_hash(ea_inode, hash);
1431 err = ext4_mark_inode_dirty(handle, ea_inode);
1432 if (!err)
1433 err = ext4_inode_attach_jinode(ea_inode);
1434 if (err) {
1435 iput(ea_inode);
1436 return ERR_PTR(err);
1437 }
1438
1439
1440
1441
1442
1443 dquot_free_inode(ea_inode);
1444 dquot_drop(ea_inode);
1445 inode_lock(ea_inode);
1446 ea_inode->i_flags |= S_NOQUOTA;
1447 inode_unlock(ea_inode);
1448 }
1449
1450 return ea_inode;
1451}
1452
1453static struct inode *
1454ext4_xattr_inode_cache_find(struct inode *inode, const void *value,
1455 size_t value_len, u32 hash)
1456{
1457 struct inode *ea_inode;
1458 struct mb_cache_entry *ce;
1459 struct mb_cache *ea_inode_cache = EA_INODE_CACHE(inode);
1460 void *ea_data;
1461
1462 if (!ea_inode_cache)
1463 return NULL;
1464
1465 ce = mb_cache_entry_find_first(ea_inode_cache, hash);
1466 if (!ce)
1467 return NULL;
1468
1469 WARN_ON_ONCE(ext4_handle_valid(journal_current_handle()) &&
1470 !(current->flags & PF_MEMALLOC_NOFS));
1471
1472 ea_data = kvmalloc(value_len, GFP_KERNEL);
1473 if (!ea_data) {
1474 mb_cache_entry_put(ea_inode_cache, ce);
1475 return NULL;
1476 }
1477
1478 while (ce) {
1479 ea_inode = ext4_iget(inode->i_sb, ce->e_value,
1480 EXT4_IGET_NORMAL);
1481 if (!IS_ERR(ea_inode) &&
1482 !is_bad_inode(ea_inode) &&
1483 (EXT4_I(ea_inode)->i_flags & EXT4_EA_INODE_FL) &&
1484 i_size_read(ea_inode) == value_len &&
1485 !ext4_xattr_inode_read(ea_inode, ea_data, value_len) &&
1486 !ext4_xattr_inode_verify_hashes(ea_inode, NULL, ea_data,
1487 value_len) &&
1488 !memcmp(value, ea_data, value_len)) {
1489 mb_cache_entry_touch(ea_inode_cache, ce);
1490 mb_cache_entry_put(ea_inode_cache, ce);
1491 kvfree(ea_data);
1492 return ea_inode;
1493 }
1494
1495 if (!IS_ERR(ea_inode))
1496 iput(ea_inode);
1497 ce = mb_cache_entry_find_next(ea_inode_cache, ce);
1498 }
1499 kvfree(ea_data);
1500 return NULL;
1501}
1502
1503
1504
1505
1506static int ext4_xattr_inode_lookup_create(handle_t *handle, struct inode *inode,
1507 const void *value, size_t value_len,
1508 struct inode **ret_inode)
1509{
1510 struct inode *ea_inode;
1511 u32 hash;
1512 int err;
1513
1514 hash = ext4_xattr_inode_hash(EXT4_SB(inode->i_sb), value, value_len);
1515 ea_inode = ext4_xattr_inode_cache_find(inode, value, value_len, hash);
1516 if (ea_inode) {
1517 err = ext4_xattr_inode_inc_ref(handle, ea_inode);
1518 if (err) {
1519 iput(ea_inode);
1520 return err;
1521 }
1522
1523 *ret_inode = ea_inode;
1524 return 0;
1525 }
1526
1527
1528 ea_inode = ext4_xattr_inode_create(handle, inode, hash);
1529 if (IS_ERR(ea_inode))
1530 return PTR_ERR(ea_inode);
1531
1532 err = ext4_xattr_inode_write(handle, ea_inode, value, value_len);
1533 if (err) {
1534 ext4_xattr_inode_dec_ref(handle, ea_inode);
1535 iput(ea_inode);
1536 return err;
1537 }
1538
1539 if (EA_INODE_CACHE(inode))
1540 mb_cache_entry_create(EA_INODE_CACHE(inode), GFP_NOFS, hash,
1541 ea_inode->i_ino, true );
1542
1543 *ret_inode = ea_inode;
1544 return 0;
1545}
1546
1547
1548
1549
1550
1551#define EXT4_XATTR_BLOCK_RESERVE(inode) min(i_blocksize(inode)/8, 1024U)
1552
1553static int ext4_xattr_set_entry(struct ext4_xattr_info *i,
1554 struct ext4_xattr_search *s,
1555 handle_t *handle, struct inode *inode,
1556 bool is_block)
1557{
1558 struct ext4_xattr_entry *last, *next;
1559 struct ext4_xattr_entry *here = s->here;
1560 size_t min_offs = s->end - s->base, name_len = strlen(i->name);
1561 int in_inode = i->in_inode;
1562 struct inode *old_ea_inode = NULL;
1563 struct inode *new_ea_inode = NULL;
1564 size_t old_size, new_size;
1565 int ret;
1566
1567
1568 old_size = (!s->not_found && !here->e_value_inum) ?
1569 EXT4_XATTR_SIZE(le32_to_cpu(here->e_value_size)) : 0;
1570 new_size = (i->value && !in_inode) ? EXT4_XATTR_SIZE(i->value_len) : 0;
1571
1572
1573
1574
1575
1576 if (new_size && new_size == old_size) {
1577 size_t offs = le16_to_cpu(here->e_value_offs);
1578 void *val = s->base + offs;
1579
1580 here->e_value_size = cpu_to_le32(i->value_len);
1581 if (i->value == EXT4_ZERO_XATTR_VALUE) {
1582 memset(val, 0, new_size);
1583 } else {
1584 memcpy(val, i->value, i->value_len);
1585
1586 memset(val + i->value_len, 0, new_size - i->value_len);
1587 }
1588 goto update_hash;
1589 }
1590
1591
1592 last = s->first;
1593 for (; !IS_LAST_ENTRY(last); last = next) {
1594 next = EXT4_XATTR_NEXT(last);
1595 if ((void *)next >= s->end) {
1596 EXT4_ERROR_INODE(inode, "corrupted xattr entries");
1597 ret = -EFSCORRUPTED;
1598 goto out;
1599 }
1600 if (!last->e_value_inum && last->e_value_size) {
1601 size_t offs = le16_to_cpu(last->e_value_offs);
1602 if (offs < min_offs)
1603 min_offs = offs;
1604 }
1605 }
1606
1607
1608 if (i->value) {
1609 size_t free;
1610
1611 free = min_offs - ((void *)last - s->base) - sizeof(__u32);
1612 if (!s->not_found)
1613 free += EXT4_XATTR_LEN(name_len) + old_size;
1614
1615 if (free < EXT4_XATTR_LEN(name_len) + new_size) {
1616 ret = -ENOSPC;
1617 goto out;
1618 }
1619
1620
1621
1622
1623
1624
1625
1626 if (ext4_has_feature_ea_inode(inode->i_sb) &&
1627 new_size && is_block &&
1628 (min_offs + old_size - new_size) <
1629 EXT4_XATTR_BLOCK_RESERVE(inode)) {
1630 ret = -ENOSPC;
1631 goto out;
1632 }
1633 }
1634
1635
1636
1637
1638
1639 if (!s->not_found && here->e_value_inum) {
1640 ret = ext4_xattr_inode_iget(inode,
1641 le32_to_cpu(here->e_value_inum),
1642 le32_to_cpu(here->e_hash),
1643 &old_ea_inode);
1644 if (ret) {
1645 old_ea_inode = NULL;
1646 goto out;
1647 }
1648 }
1649 if (i->value && in_inode) {
1650 WARN_ON_ONCE(!i->value_len);
1651
1652 ret = ext4_xattr_inode_alloc_quota(inode, i->value_len);
1653 if (ret)
1654 goto out;
1655
1656 ret = ext4_xattr_inode_lookup_create(handle, inode, i->value,
1657 i->value_len,
1658 &new_ea_inode);
1659 if (ret) {
1660 new_ea_inode = NULL;
1661 ext4_xattr_inode_free_quota(inode, NULL, i->value_len);
1662 goto out;
1663 }
1664 }
1665
1666 if (old_ea_inode) {
1667
1668 ret = ext4_xattr_inode_dec_ref(handle, old_ea_inode);
1669 if (ret) {
1670
1671 if (new_ea_inode) {
1672 int err;
1673
1674 err = ext4_xattr_inode_dec_ref(handle,
1675 new_ea_inode);
1676 if (err)
1677 ext4_warning_inode(new_ea_inode,
1678 "dec ref new_ea_inode err=%d",
1679 err);
1680 ext4_xattr_inode_free_quota(inode, new_ea_inode,
1681 i->value_len);
1682 }
1683 goto out;
1684 }
1685
1686 ext4_xattr_inode_free_quota(inode, old_ea_inode,
1687 le32_to_cpu(here->e_value_size));
1688 }
1689
1690
1691
1692 if (!s->not_found && here->e_value_size && !here->e_value_inum) {
1693
1694 void *first_val = s->base + min_offs;
1695 size_t offs = le16_to_cpu(here->e_value_offs);
1696 void *val = s->base + offs;
1697
1698 memmove(first_val + old_size, first_val, val - first_val);
1699 memset(first_val, 0, old_size);
1700 min_offs += old_size;
1701
1702
1703 last = s->first;
1704 while (!IS_LAST_ENTRY(last)) {
1705 size_t o = le16_to_cpu(last->e_value_offs);
1706
1707 if (!last->e_value_inum &&
1708 last->e_value_size && o < offs)
1709 last->e_value_offs = cpu_to_le16(o + old_size);
1710 last = EXT4_XATTR_NEXT(last);
1711 }
1712 }
1713
1714 if (!i->value) {
1715
1716 size_t size = EXT4_XATTR_LEN(name_len);
1717
1718 last = ENTRY((void *)last - size);
1719 memmove(here, (void *)here + size,
1720 (void *)last - (void *)here + sizeof(__u32));
1721 memset(last, 0, size);
1722 } else if (s->not_found) {
1723
1724 size_t size = EXT4_XATTR_LEN(name_len);
1725 size_t rest = (void *)last - (void *)here + sizeof(__u32);
1726
1727 memmove((void *)here + size, here, rest);
1728 memset(here, 0, size);
1729 here->e_name_index = i->name_index;
1730 here->e_name_len = name_len;
1731 memcpy(here->e_name, i->name, name_len);
1732 } else {
1733
1734 here->e_value_inum = 0;
1735 here->e_value_offs = 0;
1736 here->e_value_size = 0;
1737 }
1738
1739 if (i->value) {
1740
1741 if (in_inode) {
1742 here->e_value_inum = cpu_to_le32(new_ea_inode->i_ino);
1743 } else if (i->value_len) {
1744 void *val = s->base + min_offs - new_size;
1745
1746 here->e_value_offs = cpu_to_le16(min_offs - new_size);
1747 if (i->value == EXT4_ZERO_XATTR_VALUE) {
1748 memset(val, 0, new_size);
1749 } else {
1750 memcpy(val, i->value, i->value_len);
1751
1752 memset(val + i->value_len, 0,
1753 new_size - i->value_len);
1754 }
1755 }
1756 here->e_value_size = cpu_to_le32(i->value_len);
1757 }
1758
1759update_hash:
1760 if (i->value) {
1761 __le32 hash = 0;
1762
1763
1764 if (in_inode) {
1765 __le32 crc32c_hash;
1766
1767
1768
1769
1770
1771
1772 crc32c_hash = cpu_to_le32(
1773 ext4_xattr_inode_get_hash(new_ea_inode));
1774 hash = ext4_xattr_hash_entry(here->e_name,
1775 here->e_name_len,
1776 &crc32c_hash, 1);
1777 } else if (is_block) {
1778 __le32 *value = s->base + le16_to_cpu(
1779 here->e_value_offs);
1780
1781 hash = ext4_xattr_hash_entry(here->e_name,
1782 here->e_name_len, value,
1783 new_size >> 2);
1784 }
1785 here->e_hash = hash;
1786 }
1787
1788 if (is_block)
1789 ext4_xattr_rehash((struct ext4_xattr_header *)s->base);
1790
1791 ret = 0;
1792out:
1793 iput(old_ea_inode);
1794 iput(new_ea_inode);
1795 return ret;
1796}
1797
1798struct ext4_xattr_block_find {
1799 struct ext4_xattr_search s;
1800 struct buffer_head *bh;
1801};
1802
1803static int
1804ext4_xattr_block_find(struct inode *inode, struct ext4_xattr_info *i,
1805 struct ext4_xattr_block_find *bs)
1806{
1807 struct super_block *sb = inode->i_sb;
1808 int error;
1809
1810 ea_idebug(inode, "name=%d.%s, value=%p, value_len=%ld",
1811 i->name_index, i->name, i->value, (long)i->value_len);
1812
1813 if (EXT4_I(inode)->i_file_acl) {
1814
1815 bs->bh = ext4_sb_bread(sb, EXT4_I(inode)->i_file_acl, REQ_PRIO);
1816 if (IS_ERR(bs->bh)) {
1817 error = PTR_ERR(bs->bh);
1818 bs->bh = NULL;
1819 return error;
1820 }
1821 ea_bdebug(bs->bh, "b_count=%d, refcount=%d",
1822 atomic_read(&(bs->bh->b_count)),
1823 le32_to_cpu(BHDR(bs->bh)->h_refcount));
1824 error = ext4_xattr_check_block(inode, bs->bh);
1825 if (error)
1826 return error;
1827
1828 bs->s.base = BHDR(bs->bh);
1829 bs->s.first = BFIRST(bs->bh);
1830 bs->s.end = bs->bh->b_data + bs->bh->b_size;
1831 bs->s.here = bs->s.first;
1832 error = xattr_find_entry(inode, &bs->s.here, bs->s.end,
1833 i->name_index, i->name, 1);
1834 if (error && error != -ENODATA)
1835 return error;
1836 bs->s.not_found = error;
1837 }
1838 return 0;
1839}
1840
1841static int
1842ext4_xattr_block_set(handle_t *handle, struct inode *inode,
1843 struct ext4_xattr_info *i,
1844 struct ext4_xattr_block_find *bs)
1845{
1846 struct super_block *sb = inode->i_sb;
1847 struct buffer_head *new_bh = NULL;
1848 struct ext4_xattr_search s_copy = bs->s;
1849 struct ext4_xattr_search *s = &s_copy;
1850 struct mb_cache_entry *ce = NULL;
1851 int error = 0;
1852 struct mb_cache *ea_block_cache = EA_BLOCK_CACHE(inode);
1853 struct inode *ea_inode = NULL, *tmp_inode;
1854 size_t old_ea_inode_quota = 0;
1855 unsigned int ea_ino;
1856
1857
1858#define header(x) ((struct ext4_xattr_header *)(x))
1859
1860 if (s->base) {
1861 BUFFER_TRACE(bs->bh, "get_write_access");
1862 error = ext4_journal_get_write_access(handle, sb, bs->bh,
1863 EXT4_JTR_NONE);
1864 if (error)
1865 goto cleanup;
1866 lock_buffer(bs->bh);
1867
1868 if (header(s->base)->h_refcount == cpu_to_le32(1)) {
1869 __u32 hash = le32_to_cpu(BHDR(bs->bh)->h_hash);
1870
1871
1872
1873
1874
1875
1876 if (ea_block_cache)
1877 mb_cache_entry_delete(ea_block_cache, hash,
1878 bs->bh->b_blocknr);
1879 ea_bdebug(bs->bh, "modifying in-place");
1880 error = ext4_xattr_set_entry(i, s, handle, inode,
1881 true );
1882 ext4_xattr_block_csum_set(inode, bs->bh);
1883 unlock_buffer(bs->bh);
1884 if (error == -EFSCORRUPTED)
1885 goto bad_block;
1886 if (!error)
1887 error = ext4_handle_dirty_metadata(handle,
1888 inode,
1889 bs->bh);
1890 if (error)
1891 goto cleanup;
1892 goto inserted;
1893 } else {
1894 int offset = (char *)s->here - bs->bh->b_data;
1895
1896 unlock_buffer(bs->bh);
1897 ea_bdebug(bs->bh, "cloning");
1898 s->base = kmalloc(bs->bh->b_size, GFP_NOFS);
1899 error = -ENOMEM;
1900 if (s->base == NULL)
1901 goto cleanup;
1902 memcpy(s->base, BHDR(bs->bh), bs->bh->b_size);
1903 s->first = ENTRY(header(s->base)+1);
1904 header(s->base)->h_refcount = cpu_to_le32(1);
1905 s->here = ENTRY(s->base + offset);
1906 s->end = s->base + bs->bh->b_size;
1907
1908
1909
1910
1911
1912
1913
1914
1915 if (!s->not_found && s->here->e_value_inum) {
1916 ea_ino = le32_to_cpu(s->here->e_value_inum);
1917 error = ext4_xattr_inode_iget(inode, ea_ino,
1918 le32_to_cpu(s->here->e_hash),
1919 &tmp_inode);
1920 if (error)
1921 goto cleanup;
1922
1923 if (!ext4_test_inode_state(tmp_inode,
1924 EXT4_STATE_LUSTRE_EA_INODE)) {
1925
1926
1927
1928
1929 old_ea_inode_quota = le32_to_cpu(
1930 s->here->e_value_size);
1931 }
1932 iput(tmp_inode);
1933
1934 s->here->e_value_inum = 0;
1935 s->here->e_value_size = 0;
1936 }
1937 }
1938 } else {
1939
1940 s->base = kzalloc(sb->s_blocksize, GFP_NOFS);
1941 error = -ENOMEM;
1942 if (s->base == NULL)
1943 goto cleanup;
1944 header(s->base)->h_magic = cpu_to_le32(EXT4_XATTR_MAGIC);
1945 header(s->base)->h_blocks = cpu_to_le32(1);
1946 header(s->base)->h_refcount = cpu_to_le32(1);
1947 s->first = ENTRY(header(s->base)+1);
1948 s->here = ENTRY(header(s->base)+1);
1949 s->end = s->base + sb->s_blocksize;
1950 }
1951
1952 error = ext4_xattr_set_entry(i, s, handle, inode, true );
1953 if (error == -EFSCORRUPTED)
1954 goto bad_block;
1955 if (error)
1956 goto cleanup;
1957
1958 if (i->value && s->here->e_value_inum) {
1959
1960
1961
1962
1963
1964
1965 ea_ino = le32_to_cpu(s->here->e_value_inum);
1966 error = ext4_xattr_inode_iget(inode, ea_ino,
1967 le32_to_cpu(s->here->e_hash),
1968 &ea_inode);
1969 if (error) {
1970 ea_inode = NULL;
1971 goto cleanup;
1972 }
1973 }
1974
1975inserted:
1976 if (!IS_LAST_ENTRY(s->first)) {
1977 new_bh = ext4_xattr_block_cache_find(inode, header(s->base),
1978 &ce);
1979 if (new_bh) {
1980
1981 if (new_bh == bs->bh)
1982 ea_bdebug(new_bh, "keeping");
1983 else {
1984 u32 ref;
1985
1986 WARN_ON_ONCE(dquot_initialize_needed(inode));
1987
1988
1989
1990 error = dquot_alloc_block(inode,
1991 EXT4_C2B(EXT4_SB(sb), 1));
1992 if (error)
1993 goto cleanup;
1994 BUFFER_TRACE(new_bh, "get_write_access");
1995 error = ext4_journal_get_write_access(
1996 handle, sb, new_bh,
1997 EXT4_JTR_NONE);
1998 if (error)
1999 goto cleanup_dquot;
2000 lock_buffer(new_bh);
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013 if (hlist_bl_unhashed(&ce->e_hash_list) ||
2014 !ce->e_reusable) {
2015
2016
2017
2018
2019 unlock_buffer(new_bh);
2020 dquot_free_block(inode,
2021 EXT4_C2B(EXT4_SB(sb),
2022 1));
2023 brelse(new_bh);
2024 mb_cache_entry_put(ea_block_cache, ce);
2025 ce = NULL;
2026 new_bh = NULL;
2027 goto inserted;
2028 }
2029 ref = le32_to_cpu(BHDR(new_bh)->h_refcount) + 1;
2030 BHDR(new_bh)->h_refcount = cpu_to_le32(ref);
2031 if (ref >= EXT4_XATTR_REFCOUNT_MAX)
2032 ce->e_reusable = 0;
2033 ea_bdebug(new_bh, "reusing; refcount now=%d",
2034 ref);
2035 ext4_xattr_block_csum_set(inode, new_bh);
2036 unlock_buffer(new_bh);
2037 error = ext4_handle_dirty_metadata(handle,
2038 inode,
2039 new_bh);
2040 if (error)
2041 goto cleanup_dquot;
2042 }
2043 mb_cache_entry_touch(ea_block_cache, ce);
2044 mb_cache_entry_put(ea_block_cache, ce);
2045 ce = NULL;
2046 } else if (bs->bh && s->base == bs->bh->b_data) {
2047
2048 ea_bdebug(bs->bh, "keeping this block");
2049 ext4_xattr_block_cache_insert(ea_block_cache, bs->bh);
2050 new_bh = bs->bh;
2051 get_bh(new_bh);
2052 } else {
2053
2054 ext4_fsblk_t goal, block;
2055
2056 WARN_ON_ONCE(dquot_initialize_needed(inode));
2057
2058 goal = ext4_group_first_block_no(sb,
2059 EXT4_I(inode)->i_block_group);
2060
2061
2062 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
2063 goal = goal & EXT4_MAX_BLOCK_FILE_PHYS;
2064
2065 block = ext4_new_meta_blocks(handle, inode, goal, 0,
2066 NULL, &error);
2067 if (error)
2068 goto cleanup;
2069
2070 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
2071 BUG_ON(block > EXT4_MAX_BLOCK_FILE_PHYS);
2072
2073 ea_idebug(inode, "creating block %llu",
2074 (unsigned long long)block);
2075
2076 new_bh = sb_getblk(sb, block);
2077 if (unlikely(!new_bh)) {
2078 error = -ENOMEM;
2079getblk_failed:
2080 ext4_free_blocks(handle, inode, NULL, block, 1,
2081 EXT4_FREE_BLOCKS_METADATA);
2082 goto cleanup;
2083 }
2084 error = ext4_xattr_inode_inc_ref_all(handle, inode,
2085 ENTRY(header(s->base)+1));
2086 if (error)
2087 goto getblk_failed;
2088 if (ea_inode) {
2089
2090 error = ext4_xattr_inode_dec_ref(handle,
2091 ea_inode);
2092 if (error)
2093 ext4_warning_inode(ea_inode,
2094 "dec ref error=%d",
2095 error);
2096 iput(ea_inode);
2097 ea_inode = NULL;
2098 }
2099
2100 lock_buffer(new_bh);
2101 error = ext4_journal_get_create_access(handle, sb,
2102 new_bh, EXT4_JTR_NONE);
2103 if (error) {
2104 unlock_buffer(new_bh);
2105 error = -EIO;
2106 goto getblk_failed;
2107 }
2108 memcpy(new_bh->b_data, s->base, new_bh->b_size);
2109 ext4_xattr_block_csum_set(inode, new_bh);
2110 set_buffer_uptodate(new_bh);
2111 unlock_buffer(new_bh);
2112 ext4_xattr_block_cache_insert(ea_block_cache, new_bh);
2113 error = ext4_handle_dirty_metadata(handle, inode,
2114 new_bh);
2115 if (error)
2116 goto cleanup;
2117 }
2118 }
2119
2120 if (old_ea_inode_quota)
2121 ext4_xattr_inode_free_quota(inode, NULL, old_ea_inode_quota);
2122
2123
2124 EXT4_I(inode)->i_file_acl = new_bh ? new_bh->b_blocknr : 0;
2125
2126
2127 if (bs->bh && bs->bh != new_bh) {
2128 struct ext4_xattr_inode_array *ea_inode_array = NULL;
2129
2130 ext4_xattr_release_block(handle, inode, bs->bh,
2131 &ea_inode_array,
2132 0 );
2133 ext4_xattr_inode_array_free(ea_inode_array);
2134 }
2135 error = 0;
2136
2137cleanup:
2138 if (ea_inode) {
2139 int error2;
2140
2141 error2 = ext4_xattr_inode_dec_ref(handle, ea_inode);
2142 if (error2)
2143 ext4_warning_inode(ea_inode, "dec ref error=%d",
2144 error2);
2145
2146
2147 if (error)
2148 ext4_xattr_inode_free_quota(inode, ea_inode,
2149 i_size_read(ea_inode));
2150 iput(ea_inode);
2151 }
2152 if (ce)
2153 mb_cache_entry_put(ea_block_cache, ce);
2154 brelse(new_bh);
2155 if (!(bs->bh && s->base == bs->bh->b_data))
2156 kfree(s->base);
2157
2158 return error;
2159
2160cleanup_dquot:
2161 dquot_free_block(inode, EXT4_C2B(EXT4_SB(sb), 1));
2162 goto cleanup;
2163
2164bad_block:
2165 EXT4_ERROR_INODE(inode, "bad block %llu",
2166 EXT4_I(inode)->i_file_acl);
2167 goto cleanup;
2168
2169#undef header
2170}
2171
2172int ext4_xattr_ibody_find(struct inode *inode, struct ext4_xattr_info *i,
2173 struct ext4_xattr_ibody_find *is)
2174{
2175 struct ext4_xattr_ibody_header *header;
2176 struct ext4_inode *raw_inode;
2177 int error;
2178
2179 if (EXT4_I(inode)->i_extra_isize == 0)
2180 return 0;
2181 raw_inode = ext4_raw_inode(&is->iloc);
2182 header = IHDR(inode, raw_inode);
2183 is->s.base = is->s.first = IFIRST(header);
2184 is->s.here = is->s.first;
2185 is->s.end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
2186 if (ext4_test_inode_state(inode, EXT4_STATE_XATTR)) {
2187 error = xattr_check_inode(inode, header, is->s.end);
2188 if (error)
2189 return error;
2190
2191 error = xattr_find_entry(inode, &is->s.here, is->s.end,
2192 i->name_index, i->name, 0);
2193 if (error && error != -ENODATA)
2194 return error;
2195 is->s.not_found = error;
2196 }
2197 return 0;
2198}
2199
2200int ext4_xattr_ibody_set(handle_t *handle, struct inode *inode,
2201 struct ext4_xattr_info *i,
2202 struct ext4_xattr_ibody_find *is)
2203{
2204 struct ext4_xattr_ibody_header *header;
2205 struct ext4_xattr_search *s = &is->s;
2206 int error;
2207
2208 if (EXT4_I(inode)->i_extra_isize == 0)
2209 return -ENOSPC;
2210 error = ext4_xattr_set_entry(i, s, handle, inode, false );
2211 if (error)
2212 return error;
2213 header = IHDR(inode, ext4_raw_inode(&is->iloc));
2214 if (!IS_LAST_ENTRY(s->first)) {
2215 header->h_magic = cpu_to_le32(EXT4_XATTR_MAGIC);
2216 ext4_set_inode_state(inode, EXT4_STATE_XATTR);
2217 } else {
2218 header->h_magic = cpu_to_le32(0);
2219 ext4_clear_inode_state(inode, EXT4_STATE_XATTR);
2220 }
2221 return 0;
2222}
2223
2224static int ext4_xattr_value_same(struct ext4_xattr_search *s,
2225 struct ext4_xattr_info *i)
2226{
2227 void *value;
2228
2229
2230 if (s->here->e_value_inum)
2231 return 0;
2232 if (le32_to_cpu(s->here->e_value_size) != i->value_len)
2233 return 0;
2234 value = ((void *)s->base) + le16_to_cpu(s->here->e_value_offs);
2235 return !memcmp(value, i->value, i->value_len);
2236}
2237
2238static struct buffer_head *ext4_xattr_get_block(struct inode *inode)
2239{
2240 struct buffer_head *bh;
2241 int error;
2242
2243 if (!EXT4_I(inode)->i_file_acl)
2244 return NULL;
2245 bh = ext4_sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl, REQ_PRIO);
2246 if (IS_ERR(bh))
2247 return bh;
2248 error = ext4_xattr_check_block(inode, bh);
2249 if (error) {
2250 brelse(bh);
2251 return ERR_PTR(error);
2252 }
2253 return bh;
2254}
2255
2256
2257
2258
2259
2260
2261
2262
2263
2264
2265
2266
2267
2268int
2269ext4_xattr_set_handle(handle_t *handle, struct inode *inode, int name_index,
2270 const char *name, const void *value, size_t value_len,
2271 int flags)
2272{
2273 struct ext4_xattr_info i = {
2274 .name_index = name_index,
2275 .name = name,
2276 .value = value,
2277 .value_len = value_len,
2278 .in_inode = 0,
2279 };
2280 struct ext4_xattr_ibody_find is = {
2281 .s = { .not_found = -ENODATA, },
2282 };
2283 struct ext4_xattr_block_find bs = {
2284 .s = { .not_found = -ENODATA, },
2285 };
2286 int no_expand;
2287 int error;
2288
2289 if (!name)
2290 return -EINVAL;
2291 if (strlen(name) > 255)
2292 return -ERANGE;
2293
2294 ext4_write_lock_xattr(inode, &no_expand);
2295
2296
2297 if (ext4_handle_valid(handle)) {
2298 struct buffer_head *bh;
2299 int credits;
2300
2301 bh = ext4_xattr_get_block(inode);
2302 if (IS_ERR(bh)) {
2303 error = PTR_ERR(bh);
2304 goto cleanup;
2305 }
2306
2307 credits = __ext4_xattr_set_credits(inode->i_sb, inode, bh,
2308 value_len,
2309 flags & XATTR_CREATE);
2310 brelse(bh);
2311
2312 if (jbd2_handle_buffer_credits(handle) < credits) {
2313 error = -ENOSPC;
2314 goto cleanup;
2315 }
2316 WARN_ON_ONCE(!(current->flags & PF_MEMALLOC_NOFS));
2317 }
2318
2319 error = ext4_reserve_inode_write(handle, inode, &is.iloc);
2320 if (error)
2321 goto cleanup;
2322
2323 if (ext4_test_inode_state(inode, EXT4_STATE_NEW)) {
2324 struct ext4_inode *raw_inode = ext4_raw_inode(&is.iloc);
2325 memset(raw_inode, 0, EXT4_SB(inode->i_sb)->s_inode_size);
2326 ext4_clear_inode_state(inode, EXT4_STATE_NEW);
2327 }
2328
2329 error = ext4_xattr_ibody_find(inode, &i, &is);
2330 if (error)
2331 goto cleanup;
2332 if (is.s.not_found)
2333 error = ext4_xattr_block_find(inode, &i, &bs);
2334 if (error)
2335 goto cleanup;
2336 if (is.s.not_found && bs.s.not_found) {
2337 error = -ENODATA;
2338 if (flags & XATTR_REPLACE)
2339 goto cleanup;
2340 error = 0;
2341 if (!value)
2342 goto cleanup;
2343 } else {
2344 error = -EEXIST;
2345 if (flags & XATTR_CREATE)
2346 goto cleanup;
2347 }
2348
2349 if (!value) {
2350 if (!is.s.not_found)
2351 error = ext4_xattr_ibody_set(handle, inode, &i, &is);
2352 else if (!bs.s.not_found)
2353 error = ext4_xattr_block_set(handle, inode, &i, &bs);
2354 } else {
2355 error = 0;
2356
2357 if (!is.s.not_found && ext4_xattr_value_same(&is.s, &i))
2358 goto cleanup;
2359 if (!bs.s.not_found && ext4_xattr_value_same(&bs.s, &i))
2360 goto cleanup;
2361
2362 if (ext4_has_feature_ea_inode(inode->i_sb) &&
2363 (EXT4_XATTR_SIZE(i.value_len) >
2364 EXT4_XATTR_MIN_LARGE_EA_SIZE(inode->i_sb->s_blocksize)))
2365 i.in_inode = 1;
2366retry_inode:
2367 error = ext4_xattr_ibody_set(handle, inode, &i, &is);
2368 if (!error && !bs.s.not_found) {
2369 i.value = NULL;
2370 error = ext4_xattr_block_set(handle, inode, &i, &bs);
2371 } else if (error == -ENOSPC) {
2372 if (EXT4_I(inode)->i_file_acl && !bs.s.base) {
2373 brelse(bs.bh);
2374 bs.bh = NULL;
2375 error = ext4_xattr_block_find(inode, &i, &bs);
2376 if (error)
2377 goto cleanup;
2378 }
2379 error = ext4_xattr_block_set(handle, inode, &i, &bs);
2380 if (!error && !is.s.not_found) {
2381 i.value = NULL;
2382 error = ext4_xattr_ibody_set(handle, inode, &i,
2383 &is);
2384 } else if (error == -ENOSPC) {
2385
2386
2387
2388
2389 if (ext4_has_feature_ea_inode(inode->i_sb) &&
2390 i.value_len && !i.in_inode) {
2391 i.in_inode = 1;
2392 goto retry_inode;
2393 }
2394 }
2395 }
2396 }
2397 if (!error) {
2398 ext4_xattr_update_super_block(handle, inode->i_sb);
2399 inode->i_ctime = current_time(inode);
2400 if (!value)
2401 no_expand = 0;
2402 error = ext4_mark_iloc_dirty(handle, inode, &is.iloc);
2403
2404
2405
2406
2407 is.iloc.bh = NULL;
2408 if (IS_SYNC(inode))
2409 ext4_handle_sync(handle);
2410 }
2411 ext4_fc_mark_ineligible(inode->i_sb, EXT4_FC_REASON_XATTR);
2412
2413cleanup:
2414 brelse(is.iloc.bh);
2415 brelse(bs.bh);
2416 ext4_write_unlock_xattr(inode, &no_expand);
2417 return error;
2418}
2419
2420int ext4_xattr_set_credits(struct inode *inode, size_t value_len,
2421 bool is_create, int *credits)
2422{
2423 struct buffer_head *bh;
2424 int err;
2425
2426 *credits = 0;
2427
2428 if (!EXT4_SB(inode->i_sb)->s_journal)
2429 return 0;
2430
2431 down_read(&EXT4_I(inode)->xattr_sem);
2432
2433 bh = ext4_xattr_get_block(inode);
2434 if (IS_ERR(bh)) {
2435 err = PTR_ERR(bh);
2436 } else {
2437 *credits = __ext4_xattr_set_credits(inode->i_sb, inode, bh,
2438 value_len, is_create);
2439 brelse(bh);
2440 err = 0;
2441 }
2442
2443 up_read(&EXT4_I(inode)->xattr_sem);
2444 return err;
2445}
2446
2447
2448
2449
2450
2451
2452
2453
2454
2455int
2456ext4_xattr_set(struct inode *inode, int name_index, const char *name,
2457 const void *value, size_t value_len, int flags)
2458{
2459 handle_t *handle;
2460 struct super_block *sb = inode->i_sb;
2461 int error, retries = 0;
2462 int credits;
2463
2464 error = dquot_initialize(inode);
2465 if (error)
2466 return error;
2467
2468retry:
2469 error = ext4_xattr_set_credits(inode, value_len, flags & XATTR_CREATE,
2470 &credits);
2471 if (error)
2472 return error;
2473
2474 handle = ext4_journal_start(inode, EXT4_HT_XATTR, credits);
2475 if (IS_ERR(handle)) {
2476 error = PTR_ERR(handle);
2477 } else {
2478 int error2;
2479
2480 error = ext4_xattr_set_handle(handle, inode, name_index, name,
2481 value, value_len, flags);
2482 error2 = ext4_journal_stop(handle);
2483 if (error == -ENOSPC &&
2484 ext4_should_retry_alloc(sb, &retries))
2485 goto retry;
2486 if (error == 0)
2487 error = error2;
2488 }
2489 ext4_fc_mark_ineligible(inode->i_sb, EXT4_FC_REASON_XATTR);
2490
2491 return error;
2492}
2493
2494
2495
2496
2497
2498static void ext4_xattr_shift_entries(struct ext4_xattr_entry *entry,
2499 int value_offs_shift, void *to,
2500 void *from, size_t n)
2501{
2502 struct ext4_xattr_entry *last = entry;
2503 int new_offs;
2504
2505
2506 BUG_ON(value_offs_shift > 0);
2507
2508
2509 for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
2510 if (!last->e_value_inum && last->e_value_size) {
2511 new_offs = le16_to_cpu(last->e_value_offs) +
2512 value_offs_shift;
2513 last->e_value_offs = cpu_to_le16(new_offs);
2514 }
2515 }
2516
2517 memmove(to, from, n);
2518}
2519
2520
2521
2522
2523static int ext4_xattr_move_to_block(handle_t *handle, struct inode *inode,
2524 struct ext4_inode *raw_inode,
2525 struct ext4_xattr_entry *entry)
2526{
2527 struct ext4_xattr_ibody_find *is = NULL;
2528 struct ext4_xattr_block_find *bs = NULL;
2529 char *buffer = NULL, *b_entry_name = NULL;
2530 size_t value_size = le32_to_cpu(entry->e_value_size);
2531 struct ext4_xattr_info i = {
2532 .value = NULL,
2533 .value_len = 0,
2534 .name_index = entry->e_name_index,
2535 .in_inode = !!entry->e_value_inum,
2536 };
2537 struct ext4_xattr_ibody_header *header = IHDR(inode, raw_inode);
2538 int error;
2539
2540 is = kzalloc(sizeof(struct ext4_xattr_ibody_find), GFP_NOFS);
2541 bs = kzalloc(sizeof(struct ext4_xattr_block_find), GFP_NOFS);
2542 buffer = kmalloc(value_size, GFP_NOFS);
2543 b_entry_name = kmalloc(entry->e_name_len + 1, GFP_NOFS);
2544 if (!is || !bs || !buffer || !b_entry_name) {
2545 error = -ENOMEM;
2546 goto out;
2547 }
2548
2549 is->s.not_found = -ENODATA;
2550 bs->s.not_found = -ENODATA;
2551 is->iloc.bh = NULL;
2552 bs->bh = NULL;
2553
2554
2555 if (entry->e_value_inum) {
2556 error = ext4_xattr_inode_get(inode, entry, buffer, value_size);
2557 if (error)
2558 goto out;
2559 } else {
2560 size_t value_offs = le16_to_cpu(entry->e_value_offs);
2561 memcpy(buffer, (void *)IFIRST(header) + value_offs, value_size);
2562 }
2563
2564 memcpy(b_entry_name, entry->e_name, entry->e_name_len);
2565 b_entry_name[entry->e_name_len] = '\0';
2566 i.name = b_entry_name;
2567
2568 error = ext4_get_inode_loc(inode, &is->iloc);
2569 if (error)
2570 goto out;
2571
2572 error = ext4_xattr_ibody_find(inode, &i, is);
2573 if (error)
2574 goto out;
2575
2576
2577 error = ext4_xattr_ibody_set(handle, inode, &i, is);
2578 if (error)
2579 goto out;
2580
2581 i.value = buffer;
2582 i.value_len = value_size;
2583 error = ext4_xattr_block_find(inode, &i, bs);
2584 if (error)
2585 goto out;
2586
2587
2588 error = ext4_xattr_block_set(handle, inode, &i, bs);
2589 if (error)
2590 goto out;
2591 error = 0;
2592out:
2593 kfree(b_entry_name);
2594 kfree(buffer);
2595 if (is)
2596 brelse(is->iloc.bh);
2597 if (bs)
2598 brelse(bs->bh);
2599 kfree(is);
2600 kfree(bs);
2601
2602 return error;
2603}
2604
2605static int ext4_xattr_make_inode_space(handle_t *handle, struct inode *inode,
2606 struct ext4_inode *raw_inode,
2607 int isize_diff, size_t ifree,
2608 size_t bfree, int *total_ino)
2609{
2610 struct ext4_xattr_ibody_header *header = IHDR(inode, raw_inode);
2611 struct ext4_xattr_entry *small_entry;
2612 struct ext4_xattr_entry *entry;
2613 struct ext4_xattr_entry *last;
2614 unsigned int entry_size;
2615 unsigned int total_size;
2616 unsigned int min_total_size;
2617 int error;
2618
2619 while (isize_diff > ifree) {
2620 entry = NULL;
2621 small_entry = NULL;
2622 min_total_size = ~0U;
2623 last = IFIRST(header);
2624
2625 for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
2626
2627 if ((last->e_name_len == 4) &&
2628 (last->e_name_index == EXT4_XATTR_INDEX_SYSTEM) &&
2629 !memcmp(last->e_name, "data", 4))
2630 continue;
2631 total_size = EXT4_XATTR_LEN(last->e_name_len);
2632 if (!last->e_value_inum)
2633 total_size += EXT4_XATTR_SIZE(
2634 le32_to_cpu(last->e_value_size));
2635 if (total_size <= bfree &&
2636 total_size < min_total_size) {
2637 if (total_size + ifree < isize_diff) {
2638 small_entry = last;
2639 } else {
2640 entry = last;
2641 min_total_size = total_size;
2642 }
2643 }
2644 }
2645
2646 if (entry == NULL) {
2647 if (small_entry == NULL)
2648 return -ENOSPC;
2649 entry = small_entry;
2650 }
2651
2652 entry_size = EXT4_XATTR_LEN(entry->e_name_len);
2653 total_size = entry_size;
2654 if (!entry->e_value_inum)
2655 total_size += EXT4_XATTR_SIZE(
2656 le32_to_cpu(entry->e_value_size));
2657 error = ext4_xattr_move_to_block(handle, inode, raw_inode,
2658 entry);
2659 if (error)
2660 return error;
2661
2662 *total_ino -= entry_size;
2663 ifree += total_size;
2664 bfree -= total_size;
2665 }
2666
2667 return 0;
2668}
2669
2670
2671
2672
2673
2674int ext4_expand_extra_isize_ea(struct inode *inode, int new_extra_isize,
2675 struct ext4_inode *raw_inode, handle_t *handle)
2676{
2677 struct ext4_xattr_ibody_header *header;
2678 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
2679 static unsigned int mnt_count;
2680 size_t min_offs;
2681 size_t ifree, bfree;
2682 int total_ino;
2683 void *base, *end;
2684 int error = 0, tried_min_extra_isize = 0;
2685 int s_min_extra_isize = le16_to_cpu(sbi->s_es->s_min_extra_isize);
2686 int isize_diff;
2687
2688retry:
2689 isize_diff = new_extra_isize - EXT4_I(inode)->i_extra_isize;
2690 if (EXT4_I(inode)->i_extra_isize >= new_extra_isize)
2691 return 0;
2692
2693 header = IHDR(inode, raw_inode);
2694
2695
2696
2697
2698
2699
2700 base = IFIRST(header);
2701 end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
2702 min_offs = end - base;
2703 total_ino = sizeof(struct ext4_xattr_ibody_header) + sizeof(u32);
2704
2705 error = xattr_check_inode(inode, header, end);
2706 if (error)
2707 goto cleanup;
2708
2709 ifree = ext4_xattr_free_space(base, &min_offs, base, &total_ino);
2710 if (ifree >= isize_diff)
2711 goto shift;
2712
2713
2714
2715
2716
2717 if (EXT4_I(inode)->i_file_acl) {
2718 struct buffer_head *bh;
2719
2720 bh = ext4_sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl, REQ_PRIO);
2721 if (IS_ERR(bh)) {
2722 error = PTR_ERR(bh);
2723 goto cleanup;
2724 }
2725 error = ext4_xattr_check_block(inode, bh);
2726 if (error) {
2727 brelse(bh);
2728 goto cleanup;
2729 }
2730 base = BHDR(bh);
2731 end = bh->b_data + bh->b_size;
2732 min_offs = end - base;
2733 bfree = ext4_xattr_free_space(BFIRST(bh), &min_offs, base,
2734 NULL);
2735 brelse(bh);
2736 if (bfree + ifree < isize_diff) {
2737 if (!tried_min_extra_isize && s_min_extra_isize) {
2738 tried_min_extra_isize++;
2739 new_extra_isize = s_min_extra_isize;
2740 goto retry;
2741 }
2742 error = -ENOSPC;
2743 goto cleanup;
2744 }
2745 } else {
2746 bfree = inode->i_sb->s_blocksize;
2747 }
2748
2749 error = ext4_xattr_make_inode_space(handle, inode, raw_inode,
2750 isize_diff, ifree, bfree,
2751 &total_ino);
2752 if (error) {
2753 if (error == -ENOSPC && !tried_min_extra_isize &&
2754 s_min_extra_isize) {
2755 tried_min_extra_isize++;
2756 new_extra_isize = s_min_extra_isize;
2757 goto retry;
2758 }
2759 goto cleanup;
2760 }
2761shift:
2762
2763 ext4_xattr_shift_entries(IFIRST(header), EXT4_I(inode)->i_extra_isize
2764 - new_extra_isize, (void *)raw_inode +
2765 EXT4_GOOD_OLD_INODE_SIZE + new_extra_isize,
2766 (void *)header, total_ino);
2767 EXT4_I(inode)->i_extra_isize = new_extra_isize;
2768
2769cleanup:
2770 if (error && (mnt_count != le16_to_cpu(sbi->s_es->s_mnt_count))) {
2771 ext4_warning(inode->i_sb, "Unable to expand inode %lu. Delete some EAs or run e2fsck.",
2772 inode->i_ino);
2773 mnt_count = le16_to_cpu(sbi->s_es->s_mnt_count);
2774 }
2775 return error;
2776}
2777
2778#define EIA_INCR 16
2779#define EIA_MASK (EIA_INCR - 1)
2780
2781
2782
2783
2784
2785static int
2786ext4_expand_inode_array(struct ext4_xattr_inode_array **ea_inode_array,
2787 struct inode *inode)
2788{
2789 if (*ea_inode_array == NULL) {
2790
2791
2792
2793
2794 (*ea_inode_array) =
2795 kmalloc(offsetof(struct ext4_xattr_inode_array,
2796 inodes[EIA_MASK]),
2797 GFP_NOFS);
2798 if (*ea_inode_array == NULL)
2799 return -ENOMEM;
2800 (*ea_inode_array)->count = 0;
2801 } else if (((*ea_inode_array)->count & EIA_MASK) == EIA_MASK) {
2802
2803 struct ext4_xattr_inode_array *new_array = NULL;
2804 int count = (*ea_inode_array)->count;
2805
2806
2807 new_array = kmalloc(
2808 offsetof(struct ext4_xattr_inode_array,
2809 inodes[count + EIA_INCR]),
2810 GFP_NOFS);
2811 if (new_array == NULL)
2812 return -ENOMEM;
2813 memcpy(new_array, *ea_inode_array,
2814 offsetof(struct ext4_xattr_inode_array, inodes[count]));
2815 kfree(*ea_inode_array);
2816 *ea_inode_array = new_array;
2817 }
2818 (*ea_inode_array)->inodes[(*ea_inode_array)->count++] = inode;
2819 return 0;
2820}
2821
2822
2823
2824
2825
2826
2827
2828
2829
2830
2831int ext4_xattr_delete_inode(handle_t *handle, struct inode *inode,
2832 struct ext4_xattr_inode_array **ea_inode_array,
2833 int extra_credits)
2834{
2835 struct buffer_head *bh = NULL;
2836 struct ext4_xattr_ibody_header *header;
2837 struct ext4_iloc iloc = { .bh = NULL };
2838 struct ext4_xattr_entry *entry;
2839 struct inode *ea_inode;
2840 int error;
2841
2842 error = ext4_journal_ensure_credits(handle, extra_credits,
2843 ext4_free_metadata_revoke_credits(inode->i_sb, 1));
2844 if (error < 0) {
2845 EXT4_ERROR_INODE(inode, "ensure credits (error %d)", error);
2846 goto cleanup;
2847 }
2848
2849 if (ext4_has_feature_ea_inode(inode->i_sb) &&
2850 ext4_test_inode_state(inode, EXT4_STATE_XATTR)) {
2851
2852 error = ext4_get_inode_loc(inode, &iloc);
2853 if (error) {
2854 EXT4_ERROR_INODE(inode, "inode loc (error %d)", error);
2855 goto cleanup;
2856 }
2857
2858 error = ext4_journal_get_write_access(handle, inode->i_sb,
2859 iloc.bh, EXT4_JTR_NONE);
2860 if (error) {
2861 EXT4_ERROR_INODE(inode, "write access (error %d)",
2862 error);
2863 goto cleanup;
2864 }
2865
2866 header = IHDR(inode, ext4_raw_inode(&iloc));
2867 if (header->h_magic == cpu_to_le32(EXT4_XATTR_MAGIC))
2868 ext4_xattr_inode_dec_ref_all(handle, inode, iloc.bh,
2869 IFIRST(header),
2870 false ,
2871 ea_inode_array,
2872 extra_credits,
2873 false );
2874 }
2875
2876 if (EXT4_I(inode)->i_file_acl) {
2877 bh = ext4_sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl, REQ_PRIO);
2878 if (IS_ERR(bh)) {
2879 error = PTR_ERR(bh);
2880 if (error == -EIO) {
2881 EXT4_ERROR_INODE_ERR(inode, EIO,
2882 "block %llu read error",
2883 EXT4_I(inode)->i_file_acl);
2884 }
2885 bh = NULL;
2886 goto cleanup;
2887 }
2888 error = ext4_xattr_check_block(inode, bh);
2889 if (error)
2890 goto cleanup;
2891
2892 if (ext4_has_feature_ea_inode(inode->i_sb)) {
2893 for (entry = BFIRST(bh); !IS_LAST_ENTRY(entry);
2894 entry = EXT4_XATTR_NEXT(entry)) {
2895 if (!entry->e_value_inum)
2896 continue;
2897 error = ext4_xattr_inode_iget(inode,
2898 le32_to_cpu(entry->e_value_inum),
2899 le32_to_cpu(entry->e_hash),
2900 &ea_inode);
2901 if (error)
2902 continue;
2903 ext4_xattr_inode_free_quota(inode, ea_inode,
2904 le32_to_cpu(entry->e_value_size));
2905 iput(ea_inode);
2906 }
2907
2908 }
2909
2910 ext4_xattr_release_block(handle, inode, bh, ea_inode_array,
2911 extra_credits);
2912
2913
2914
2915
2916 EXT4_I(inode)->i_file_acl = 0;
2917 error = ext4_mark_inode_dirty(handle, inode);
2918 if (error) {
2919 EXT4_ERROR_INODE(inode, "mark inode dirty (error %d)",
2920 error);
2921 goto cleanup;
2922 }
2923 ext4_fc_mark_ineligible(inode->i_sb, EXT4_FC_REASON_XATTR);
2924 }
2925 error = 0;
2926cleanup:
2927 brelse(iloc.bh);
2928 brelse(bh);
2929 return error;
2930}
2931
2932void ext4_xattr_inode_array_free(struct ext4_xattr_inode_array *ea_inode_array)
2933{
2934 int idx;
2935
2936 if (ea_inode_array == NULL)
2937 return;
2938
2939 for (idx = 0; idx < ea_inode_array->count; ++idx)
2940 iput(ea_inode_array->inodes[idx]);
2941 kfree(ea_inode_array);
2942}
2943
2944
2945
2946
2947
2948
2949
2950
2951
2952static void
2953ext4_xattr_block_cache_insert(struct mb_cache *ea_block_cache,
2954 struct buffer_head *bh)
2955{
2956 struct ext4_xattr_header *header = BHDR(bh);
2957 __u32 hash = le32_to_cpu(header->h_hash);
2958 int reusable = le32_to_cpu(header->h_refcount) <
2959 EXT4_XATTR_REFCOUNT_MAX;
2960 int error;
2961
2962 if (!ea_block_cache)
2963 return;
2964 error = mb_cache_entry_create(ea_block_cache, GFP_NOFS, hash,
2965 bh->b_blocknr, reusable);
2966 if (error) {
2967 if (error == -EBUSY)
2968 ea_bdebug(bh, "already in cache");
2969 } else
2970 ea_bdebug(bh, "inserting [%x]", (int)hash);
2971}
2972
2973
2974
2975
2976
2977
2978
2979
2980
2981static int
2982ext4_xattr_cmp(struct ext4_xattr_header *header1,
2983 struct ext4_xattr_header *header2)
2984{
2985 struct ext4_xattr_entry *entry1, *entry2;
2986
2987 entry1 = ENTRY(header1+1);
2988 entry2 = ENTRY(header2+1);
2989 while (!IS_LAST_ENTRY(entry1)) {
2990 if (IS_LAST_ENTRY(entry2))
2991 return 1;
2992 if (entry1->e_hash != entry2->e_hash ||
2993 entry1->e_name_index != entry2->e_name_index ||
2994 entry1->e_name_len != entry2->e_name_len ||
2995 entry1->e_value_size != entry2->e_value_size ||
2996 entry1->e_value_inum != entry2->e_value_inum ||
2997 memcmp(entry1->e_name, entry2->e_name, entry1->e_name_len))
2998 return 1;
2999 if (!entry1->e_value_inum &&
3000 memcmp((char *)header1 + le16_to_cpu(entry1->e_value_offs),
3001 (char *)header2 + le16_to_cpu(entry2->e_value_offs),
3002 le32_to_cpu(entry1->e_value_size)))
3003 return 1;
3004
3005 entry1 = EXT4_XATTR_NEXT(entry1);
3006 entry2 = EXT4_XATTR_NEXT(entry2);
3007 }
3008 if (!IS_LAST_ENTRY(entry2))
3009 return 1;
3010 return 0;
3011}
3012
3013
3014
3015
3016
3017
3018
3019
3020
3021static struct buffer_head *
3022ext4_xattr_block_cache_find(struct inode *inode,
3023 struct ext4_xattr_header *header,
3024 struct mb_cache_entry **pce)
3025{
3026 __u32 hash = le32_to_cpu(header->h_hash);
3027 struct mb_cache_entry *ce;
3028 struct mb_cache *ea_block_cache = EA_BLOCK_CACHE(inode);
3029
3030 if (!ea_block_cache)
3031 return NULL;
3032 if (!header->h_hash)
3033 return NULL;
3034 ea_idebug(inode, "looking for cached blocks [%x]", (int)hash);
3035 ce = mb_cache_entry_find_first(ea_block_cache, hash);
3036 while (ce) {
3037 struct buffer_head *bh;
3038
3039 bh = ext4_sb_bread(inode->i_sb, ce->e_value, REQ_PRIO);
3040 if (IS_ERR(bh)) {
3041 if (PTR_ERR(bh) == -ENOMEM)
3042 return NULL;
3043 bh = NULL;
3044 EXT4_ERROR_INODE(inode, "block %lu read error",
3045 (unsigned long)ce->e_value);
3046 } else if (ext4_xattr_cmp(header, BHDR(bh)) == 0) {
3047 *pce = ce;
3048 return bh;
3049 }
3050 brelse(bh);
3051 ce = mb_cache_entry_find_next(ea_block_cache, ce);
3052 }
3053 return NULL;
3054}
3055
3056#define NAME_HASH_SHIFT 5
3057#define VALUE_HASH_SHIFT 16
3058
3059
3060
3061
3062
3063
3064static __le32 ext4_xattr_hash_entry(char *name, size_t name_len, __le32 *value,
3065 size_t value_count)
3066{
3067 __u32 hash = 0;
3068
3069 while (name_len--) {
3070 hash = (hash << NAME_HASH_SHIFT) ^
3071 (hash >> (8*sizeof(hash) - NAME_HASH_SHIFT)) ^
3072 *name++;
3073 }
3074 while (value_count--) {
3075 hash = (hash << VALUE_HASH_SHIFT) ^
3076 (hash >> (8*sizeof(hash) - VALUE_HASH_SHIFT)) ^
3077 le32_to_cpu(*value++);
3078 }
3079 return cpu_to_le32(hash);
3080}
3081
3082#undef NAME_HASH_SHIFT
3083#undef VALUE_HASH_SHIFT
3084
3085#define BLOCK_HASH_SHIFT 16
3086
3087
3088
3089
3090
3091
3092static void ext4_xattr_rehash(struct ext4_xattr_header *header)
3093{
3094 struct ext4_xattr_entry *here;
3095 __u32 hash = 0;
3096
3097 here = ENTRY(header+1);
3098 while (!IS_LAST_ENTRY(here)) {
3099 if (!here->e_hash) {
3100
3101 hash = 0;
3102 break;
3103 }
3104 hash = (hash << BLOCK_HASH_SHIFT) ^
3105 (hash >> (8*sizeof(hash) - BLOCK_HASH_SHIFT)) ^
3106 le32_to_cpu(here->e_hash);
3107 here = EXT4_XATTR_NEXT(here);
3108 }
3109 header->h_hash = cpu_to_le32(hash);
3110}
3111
3112#undef BLOCK_HASH_SHIFT
3113
3114#define HASH_BUCKET_BITS 10
3115
3116struct mb_cache *
3117ext4_xattr_create_cache(void)
3118{
3119 return mb_cache_create(HASH_BUCKET_BITS);
3120}
3121
3122void ext4_xattr_destroy_cache(struct mb_cache *cache)
3123{
3124 if (cache)
3125 mb_cache_destroy(cache);
3126}
3127
3128