Root/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 <linux/rwsem.h>
59#include "ext4_jbd2.h"
60#include "ext4.h"
61#include "xattr.h"
62#include "acl.h"
63
64#define BHDR(bh) ((struct ext4_xattr_header *)((bh)->b_data))
65#define ENTRY(ptr) ((struct ext4_xattr_entry *)(ptr))
66#define BFIRST(bh) ENTRY(BHDR(bh)+1)
67#define IS_LAST_ENTRY(entry) (*(__u32 *)(entry) == 0)
68
69#ifdef EXT4_XATTR_DEBUG
70# define ea_idebug(inode, f...) do { \
71        printk(KERN_DEBUG "inode %s:%lu: ", \
72            inode->i_sb->s_id, inode->i_ino); \
73        printk(f); \
74        printk("\n"); \
75    } while (0)
76# define ea_bdebug(bh, f...) do { \
77        char b[BDEVNAME_SIZE]; \
78        printk(KERN_DEBUG "block %s:%lu: ", \
79            bdevname(bh->b_bdev, b), \
80            (unsigned long) bh->b_blocknr); \
81        printk(f); \
82        printk("\n"); \
83    } while (0)
84#else
85# define ea_idebug(f...)
86# define ea_bdebug(f...)
87#endif
88
89static void ext4_xattr_cache_insert(struct buffer_head *);
90static struct buffer_head *ext4_xattr_cache_find(struct inode *,
91                         struct ext4_xattr_header *,
92                         struct mb_cache_entry **);
93static void ext4_xattr_rehash(struct ext4_xattr_header *,
94                  struct ext4_xattr_entry *);
95static int ext4_xattr_list(struct inode *inode, char *buffer,
96               size_t buffer_size);
97
98static struct mb_cache *ext4_xattr_cache;
99
100static struct xattr_handler *ext4_xattr_handler_map[] = {
101    [EXT4_XATTR_INDEX_USER] = &ext4_xattr_user_handler,
102#ifdef CONFIG_EXT4_FS_POSIX_ACL
103    [EXT4_XATTR_INDEX_POSIX_ACL_ACCESS] = &ext4_xattr_acl_access_handler,
104    [EXT4_XATTR_INDEX_POSIX_ACL_DEFAULT] = &ext4_xattr_acl_default_handler,
105#endif
106    [EXT4_XATTR_INDEX_TRUSTED] = &ext4_xattr_trusted_handler,
107#ifdef CONFIG_EXT4_FS_SECURITY
108    [EXT4_XATTR_INDEX_SECURITY] = &ext4_xattr_security_handler,
109#endif
110};
111
112struct xattr_handler *ext4_xattr_handlers[] = {
113    &ext4_xattr_user_handler,
114    &ext4_xattr_trusted_handler,
115#ifdef CONFIG_EXT4_FS_POSIX_ACL
116    &ext4_xattr_acl_access_handler,
117    &ext4_xattr_acl_default_handler,
118#endif
119#ifdef CONFIG_EXT4_FS_SECURITY
120    &ext4_xattr_security_handler,
121#endif
122    NULL
123};
124
125static inline struct xattr_handler *
126ext4_xattr_handler(int name_index)
127{
128    struct xattr_handler *handler = NULL;
129
130    if (name_index > 0 && name_index < ARRAY_SIZE(ext4_xattr_handler_map))
131        handler = ext4_xattr_handler_map[name_index];
132    return handler;
133}
134
135/*
136 * Inode operation listxattr()
137 *
138 * dentry->d_inode->i_mutex: don't care
139 */
140ssize_t
141ext4_listxattr(struct dentry *dentry, char *buffer, size_t size)
142{
143    return ext4_xattr_list(dentry->d_inode, buffer, size);
144}
145
146static int
147ext4_xattr_check_names(struct ext4_xattr_entry *entry, void *end)
148{
149    while (!IS_LAST_ENTRY(entry)) {
150        struct ext4_xattr_entry *next = EXT4_XATTR_NEXT(entry);
151        if ((void *)next >= end)
152            return -EIO;
153        entry = next;
154    }
155    return 0;
156}
157
158static inline int
159ext4_xattr_check_block(struct buffer_head *bh)
160{
161    int error;
162
163    if (BHDR(bh)->h_magic != cpu_to_le32(EXT4_XATTR_MAGIC) ||
164        BHDR(bh)->h_blocks != cpu_to_le32(1))
165        return -EIO;
166    error = ext4_xattr_check_names(BFIRST(bh), bh->b_data + bh->b_size);
167    return error;
168}
169
170static inline int
171ext4_xattr_check_entry(struct ext4_xattr_entry *entry, size_t size)
172{
173    size_t value_size = le32_to_cpu(entry->e_value_size);
174
175    if (entry->e_value_block != 0 || value_size > size ||
176        le16_to_cpu(entry->e_value_offs) + value_size > size)
177        return -EIO;
178    return 0;
179}
180
181static int
182ext4_xattr_find_entry(struct ext4_xattr_entry **pentry, int name_index,
183              const char *name, size_t size, int sorted)
184{
185    struct ext4_xattr_entry *entry;
186    size_t name_len;
187    int cmp = 1;
188
189    if (name == NULL)
190        return -EINVAL;
191    name_len = strlen(name);
192    entry = *pentry;
193    for (; !IS_LAST_ENTRY(entry); entry = EXT4_XATTR_NEXT(entry)) {
194        cmp = name_index - entry->e_name_index;
195        if (!cmp)
196            cmp = name_len - entry->e_name_len;
197        if (!cmp)
198            cmp = memcmp(name, entry->e_name, name_len);
199        if (cmp <= 0 && (sorted || cmp == 0))
200            break;
201    }
202    *pentry = entry;
203    if (!cmp && ext4_xattr_check_entry(entry, size))
204            return -EIO;
205    return cmp ? -ENODATA : 0;
206}
207
208static int
209ext4_xattr_block_get(struct inode *inode, int name_index, const char *name,
210             void *buffer, size_t buffer_size)
211{
212    struct buffer_head *bh = NULL;
213    struct ext4_xattr_entry *entry;
214    size_t size;
215    int error;
216
217    ea_idebug(inode, "name=%d.%s, buffer=%p, buffer_size=%ld",
218          name_index, name, buffer, (long)buffer_size);
219
220    error = -ENODATA;
221    if (!EXT4_I(inode)->i_file_acl)
222        goto cleanup;
223    ea_idebug(inode, "reading block %u", EXT4_I(inode)->i_file_acl);
224    bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl);
225    if (!bh)
226        goto cleanup;
227    ea_bdebug(bh, "b_count=%d, refcount=%d",
228        atomic_read(&(bh->b_count)), le32_to_cpu(BHDR(bh)->h_refcount));
229    if (ext4_xattr_check_block(bh)) {
230bad_block: ext4_error(inode->i_sb, __func__,
231               "inode %lu: bad block %llu", inode->i_ino,
232               EXT4_I(inode)->i_file_acl);
233        error = -EIO;
234        goto cleanup;
235    }
236    ext4_xattr_cache_insert(bh);
237    entry = BFIRST(bh);
238    error = ext4_xattr_find_entry(&entry, name_index, name, bh->b_size, 1);
239    if (error == -EIO)
240        goto bad_block;
241    if (error)
242        goto cleanup;
243    size = le32_to_cpu(entry->e_value_size);
244    if (buffer) {
245        error = -ERANGE;
246        if (size > buffer_size)
247            goto cleanup;
248        memcpy(buffer, bh->b_data + le16_to_cpu(entry->e_value_offs),
249               size);
250    }
251    error = size;
252
253cleanup:
254    brelse(bh);
255    return error;
256}
257
258static int
259ext4_xattr_ibody_get(struct inode *inode, int name_index, const char *name,
260             void *buffer, size_t buffer_size)
261{
262    struct ext4_xattr_ibody_header *header;
263    struct ext4_xattr_entry *entry;
264    struct ext4_inode *raw_inode;
265    struct ext4_iloc iloc;
266    size_t size;
267    void *end;
268    int error;
269
270    if (!(EXT4_I(inode)->i_state & EXT4_STATE_XATTR))
271        return -ENODATA;
272    error = ext4_get_inode_loc(inode, &iloc);
273    if (error)
274        return error;
275    raw_inode = ext4_raw_inode(&iloc);
276    header = IHDR(inode, raw_inode);
277    entry = IFIRST(header);
278    end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
279    error = ext4_xattr_check_names(entry, end);
280    if (error)
281        goto cleanup;
282    error = ext4_xattr_find_entry(&entry, name_index, name,
283                      end - (void *)entry, 0);
284    if (error)
285        goto cleanup;
286    size = le32_to_cpu(entry->e_value_size);
287    if (buffer) {
288        error = -ERANGE;
289        if (size > buffer_size)
290            goto cleanup;
291        memcpy(buffer, (void *)IFIRST(header) +
292               le16_to_cpu(entry->e_value_offs), size);
293    }
294    error = size;
295
296cleanup:
297    brelse(iloc.bh);
298    return error;
299}
300
301/*
302 * ext4_xattr_get()
303 *
304 * Copy an extended attribute into the buffer
305 * provided, or compute the buffer size required.
306 * Buffer is NULL to compute the size of the buffer required.
307 *
308 * Returns a negative error number on failure, or the number of bytes
309 * used / required on success.
310 */
311int
312ext4_xattr_get(struct inode *inode, int name_index, const char *name,
313           void *buffer, size_t buffer_size)
314{
315    int error;
316
317    down_read(&EXT4_I(inode)->xattr_sem);
318    error = ext4_xattr_ibody_get(inode, name_index, name, buffer,
319                     buffer_size);
320    if (error == -ENODATA)
321        error = ext4_xattr_block_get(inode, name_index, name, buffer,
322                         buffer_size);
323    up_read(&EXT4_I(inode)->xattr_sem);
324    return error;
325}
326
327static int
328ext4_xattr_list_entries(struct inode *inode, struct ext4_xattr_entry *entry,
329            char *buffer, size_t buffer_size)
330{
331    size_t rest = buffer_size;
332
333    for (; !IS_LAST_ENTRY(entry); entry = EXT4_XATTR_NEXT(entry)) {
334        struct xattr_handler *handler =
335            ext4_xattr_handler(entry->e_name_index);
336
337        if (handler) {
338            size_t size = handler->list(inode, buffer, rest,
339                            entry->e_name,
340                            entry->e_name_len);
341            if (buffer) {
342                if (size > rest)
343                    return -ERANGE;
344                buffer += size;
345            }
346            rest -= size;
347        }
348    }
349    return buffer_size - rest;
350}
351
352static int
353ext4_xattr_block_list(struct inode *inode, char *buffer, size_t buffer_size)
354{
355    struct buffer_head *bh = NULL;
356    int error;
357
358    ea_idebug(inode, "buffer=%p, buffer_size=%ld",
359          buffer, (long)buffer_size);
360
361    error = 0;
362    if (!EXT4_I(inode)->i_file_acl)
363        goto cleanup;
364    ea_idebug(inode, "reading block %u", EXT4_I(inode)->i_file_acl);
365    bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl);
366    error = -EIO;
367    if (!bh)
368        goto cleanup;
369    ea_bdebug(bh, "b_count=%d, refcount=%d",
370        atomic_read(&(bh->b_count)), le32_to_cpu(BHDR(bh)->h_refcount));
371    if (ext4_xattr_check_block(bh)) {
372        ext4_error(inode->i_sb, __func__,
373               "inode %lu: bad block %llu", inode->i_ino,
374               EXT4_I(inode)->i_file_acl);
375        error = -EIO;
376        goto cleanup;
377    }
378    ext4_xattr_cache_insert(bh);
379    error = ext4_xattr_list_entries(inode, BFIRST(bh), buffer, buffer_size);
380
381cleanup:
382    brelse(bh);
383
384    return error;
385}
386
387static int
388ext4_xattr_ibody_list(struct inode *inode, char *buffer, size_t buffer_size)
389{
390    struct ext4_xattr_ibody_header *header;
391    struct ext4_inode *raw_inode;
392    struct ext4_iloc iloc;
393    void *end;
394    int error;
395
396    if (!(EXT4_I(inode)->i_state & EXT4_STATE_XATTR))
397        return 0;
398    error = ext4_get_inode_loc(inode, &iloc);
399    if (error)
400        return error;
401    raw_inode = ext4_raw_inode(&iloc);
402    header = IHDR(inode, raw_inode);
403    end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
404    error = ext4_xattr_check_names(IFIRST(header), end);
405    if (error)
406        goto cleanup;
407    error = ext4_xattr_list_entries(inode, IFIRST(header),
408                    buffer, buffer_size);
409
410cleanup:
411    brelse(iloc.bh);
412    return error;
413}
414
415/*
416 * ext4_xattr_list()
417 *
418 * Copy a list of attribute names into the buffer
419 * provided, or compute the buffer size required.
420 * Buffer is NULL to compute the size of the buffer required.
421 *
422 * Returns a negative error number on failure, or the number of bytes
423 * used / required on success.
424 */
425static int
426ext4_xattr_list(struct inode *inode, char *buffer, size_t buffer_size)
427{
428    int i_error, b_error;
429
430    down_read(&EXT4_I(inode)->xattr_sem);
431    i_error = ext4_xattr_ibody_list(inode, buffer, buffer_size);
432    if (i_error < 0) {
433        b_error = 0;
434    } else {
435        if (buffer) {
436            buffer += i_error;
437            buffer_size -= i_error;
438        }
439        b_error = ext4_xattr_block_list(inode, buffer, buffer_size);
440        if (b_error < 0)
441            i_error = 0;
442    }
443    up_read(&EXT4_I(inode)->xattr_sem);
444    return i_error + b_error;
445}
446
447/*
448 * If the EXT4_FEATURE_COMPAT_EXT_ATTR feature of this file system is
449 * not set, set it.
450 */
451static void ext4_xattr_update_super_block(handle_t *handle,
452                      struct super_block *sb)
453{
454    if (EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_EXT_ATTR))
455        return;
456
457    if (ext4_journal_get_write_access(handle, EXT4_SB(sb)->s_sbh) == 0) {
458        EXT4_SET_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_EXT_ATTR);
459        sb->s_dirt = 1;
460        ext4_handle_dirty_metadata(handle, NULL, EXT4_SB(sb)->s_sbh);
461    }
462}
463
464/*
465 * Release the xattr block BH: If the reference count is > 1, decrement
466 * it; otherwise free the block.
467 */
468static void
469ext4_xattr_release_block(handle_t *handle, struct inode *inode,
470             struct buffer_head *bh)
471{
472    struct mb_cache_entry *ce = NULL;
473    int error = 0;
474
475    ce = mb_cache_entry_get(ext4_xattr_cache, bh->b_bdev, bh->b_blocknr);
476    error = ext4_journal_get_write_access(handle, bh);
477    if (error)
478        goto out;
479
480    lock_buffer(bh);
481    if (BHDR(bh)->h_refcount == cpu_to_le32(1)) {
482        ea_bdebug(bh, "refcount now=0; freeing");
483        if (ce)
484            mb_cache_entry_free(ce);
485        ext4_free_blocks(handle, inode, bh->b_blocknr, 1, 1);
486        get_bh(bh);
487        ext4_forget(handle, 1, inode, bh, bh->b_blocknr);
488    } else {
489        le32_add_cpu(&BHDR(bh)->h_refcount, -1);
490        error = ext4_handle_dirty_metadata(handle, inode, bh);
491        if (IS_SYNC(inode))
492            ext4_handle_sync(handle);
493        vfs_dq_free_block(inode, 1);
494        ea_bdebug(bh, "refcount now=%d; releasing",
495              le32_to_cpu(BHDR(bh)->h_refcount));
496        if (ce)
497            mb_cache_entry_release(ce);
498    }
499    unlock_buffer(bh);
500out:
501    ext4_std_error(inode->i_sb, error);
502    return;
503}
504
505/*
506 * Find the available free space for EAs. This also returns the total number of
507 * bytes used by EA entries.
508 */
509static size_t ext4_xattr_free_space(struct ext4_xattr_entry *last,
510                    size_t *min_offs, void *base, int *total)
511{
512    for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
513        *total += EXT4_XATTR_LEN(last->e_name_len);
514        if (!last->e_value_block && last->e_value_size) {
515            size_t offs = le16_to_cpu(last->e_value_offs);
516            if (offs < *min_offs)
517                *min_offs = offs;
518        }
519    }
520    return (*min_offs - ((void *)last - base) - sizeof(__u32));
521}
522
523struct ext4_xattr_info {
524    int name_index;
525    const char *name;
526    const void *value;
527    size_t value_len;
528};
529
530struct ext4_xattr_search {
531    struct ext4_xattr_entry *first;
532    void *base;
533    void *end;
534    struct ext4_xattr_entry *here;
535    int not_found;
536};
537
538static int
539ext4_xattr_set_entry(struct ext4_xattr_info *i, struct ext4_xattr_search *s)
540{
541    struct ext4_xattr_entry *last;
542    size_t free, min_offs = s->end - s->base, name_len = strlen(i->name);
543
544    /* Compute min_offs and last. */
545    last = s->first;
546    for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
547        if (!last->e_value_block && last->e_value_size) {
548            size_t offs = le16_to_cpu(last->e_value_offs);
549            if (offs < min_offs)
550                min_offs = offs;
551        }
552    }
553    free = min_offs - ((void *)last - s->base) - sizeof(__u32);
554    if (!s->not_found) {
555        if (!s->here->e_value_block && s->here->e_value_size) {
556            size_t size = le32_to_cpu(s->here->e_value_size);
557            free += EXT4_XATTR_SIZE(size);
558        }
559        free += EXT4_XATTR_LEN(name_len);
560    }
561    if (i->value) {
562        if (free < EXT4_XATTR_SIZE(i->value_len) ||
563            free < EXT4_XATTR_LEN(name_len) +
564               EXT4_XATTR_SIZE(i->value_len))
565            return -ENOSPC;
566    }
567
568    if (i->value && s->not_found) {
569        /* Insert the new name. */
570        size_t size = EXT4_XATTR_LEN(name_len);
571        size_t rest = (void *)last - (void *)s->here + sizeof(__u32);
572        memmove((void *)s->here + size, s->here, rest);
573        memset(s->here, 0, size);
574        s->here->e_name_index = i->name_index;
575        s->here->e_name_len = name_len;
576        memcpy(s->here->e_name, i->name, name_len);
577    } else {
578        if (!s->here->e_value_block && s->here->e_value_size) {
579            void *first_val = s->base + min_offs;
580            size_t offs = le16_to_cpu(s->here->e_value_offs);
581            void *val = s->base + offs;
582            size_t size = EXT4_XATTR_SIZE(
583                le32_to_cpu(s->here->e_value_size));
584
585            if (i->value && size == EXT4_XATTR_SIZE(i->value_len)) {
586                /* The old and the new value have the same
587                   size. Just replace. */
588                s->here->e_value_size =
589                    cpu_to_le32(i->value_len);
590                memset(val + size - EXT4_XATTR_PAD, 0,
591                       EXT4_XATTR_PAD); /* Clear pad bytes. */
592                memcpy(val, i->value, i->value_len);
593                return 0;
594            }
595
596            /* Remove the old value. */
597            memmove(first_val + size, first_val, val - first_val);
598            memset(first_val, 0, size);
599            s->here->e_value_size = 0;
600            s->here->e_value_offs = 0;
601            min_offs += size;
602
603            /* Adjust all value offsets. */
604            last = s->first;
605            while (!IS_LAST_ENTRY(last)) {
606                size_t o = le16_to_cpu(last->e_value_offs);
607                if (!last->e_value_block &&
608                    last->e_value_size && o < offs)
609                    last->e_value_offs =
610                        cpu_to_le16(o + size);
611                last = EXT4_XATTR_NEXT(last);
612            }
613        }
614        if (!i->value) {
615            /* Remove the old name. */
616            size_t size = EXT4_XATTR_LEN(name_len);
617            last = ENTRY((void *)last - size);
618            memmove(s->here, (void *)s->here + size,
619                (void *)last - (void *)s->here + sizeof(__u32));
620            memset(last, 0, size);
621        }
622    }
623
624    if (i->value) {
625        /* Insert the new value. */
626        s->here->e_value_size = cpu_to_le32(i->value_len);
627        if (i->value_len) {
628            size_t size = EXT4_XATTR_SIZE(i->value_len);
629            void *val = s->base + min_offs - size;
630            s->here->e_value_offs = cpu_to_le16(min_offs - size);
631            memset(val + size - EXT4_XATTR_PAD, 0,
632                   EXT4_XATTR_PAD); /* Clear the pad bytes. */
633            memcpy(val, i->value, i->value_len);
634        }
635    }
636    return 0;
637}
638
639struct ext4_xattr_block_find {
640    struct ext4_xattr_search s;
641    struct buffer_head *bh;
642};
643
644static int
645ext4_xattr_block_find(struct inode *inode, struct ext4_xattr_info *i,
646              struct ext4_xattr_block_find *bs)
647{
648    struct super_block *sb = inode->i_sb;
649    int error;
650
651    ea_idebug(inode, "name=%d.%s, value=%p, value_len=%ld",
652          i->name_index, i->name, i->value, (long)i->value_len);
653
654    if (EXT4_I(inode)->i_file_acl) {
655        /* The inode already has an extended attribute block. */
656        bs->bh = sb_bread(sb, EXT4_I(inode)->i_file_acl);
657        error = -EIO;
658        if (!bs->bh)
659            goto cleanup;
660        ea_bdebug(bs->bh, "b_count=%d, refcount=%d",
661            atomic_read(&(bs->bh->b_count)),
662            le32_to_cpu(BHDR(bs->bh)->h_refcount));
663        if (ext4_xattr_check_block(bs->bh)) {
664            ext4_error(sb, __func__,
665                "inode %lu: bad block %llu", inode->i_ino,
666                EXT4_I(inode)->i_file_acl);
667            error = -EIO;
668            goto cleanup;
669        }
670        /* Find the named attribute. */
671        bs->s.base = BHDR(bs->bh);
672        bs->s.first = BFIRST(bs->bh);
673        bs->s.end = bs->bh->b_data + bs->bh->b_size;
674        bs->s.here = bs->s.first;
675        error = ext4_xattr_find_entry(&bs->s.here, i->name_index,
676                          i->name, bs->bh->b_size, 1);
677        if (error && error != -ENODATA)
678            goto cleanup;
679        bs->s.not_found = error;
680    }
681    error = 0;
682
683cleanup:
684    return error;
685}
686
687static int
688ext4_xattr_block_set(handle_t *handle, struct inode *inode,
689             struct ext4_xattr_info *i,
690             struct ext4_xattr_block_find *bs)
691{
692    struct super_block *sb = inode->i_sb;
693    struct buffer_head *new_bh = NULL;
694    struct ext4_xattr_search *s = &bs->s;
695    struct mb_cache_entry *ce = NULL;
696    int error = 0;
697
698#define header(x) ((struct ext4_xattr_header *)(x))
699
700    if (i->value && i->value_len > sb->s_blocksize)
701        return -ENOSPC;
702    if (s->base) {
703        ce = mb_cache_entry_get(ext4_xattr_cache, bs->bh->b_bdev,
704                    bs->bh->b_blocknr);
705        error = ext4_journal_get_write_access(handle, bs->bh);
706        if (error)
707            goto cleanup;
708        lock_buffer(bs->bh);
709
710        if (header(s->base)->h_refcount == cpu_to_le32(1)) {
711            if (ce) {
712                mb_cache_entry_free(ce);
713                ce = NULL;
714            }
715            ea_bdebug(bs->bh, "modifying in-place");
716            error = ext4_xattr_set_entry(i, s);
717            if (!error) {
718                if (!IS_LAST_ENTRY(s->first))
719                    ext4_xattr_rehash(header(s->base),
720                              s->here);
721                ext4_xattr_cache_insert(bs->bh);
722            }
723            unlock_buffer(bs->bh);
724            if (error == -EIO)
725                goto bad_block;
726            if (!error)
727                error = ext4_handle_dirty_metadata(handle,
728                                   inode,
729                                   bs->bh);
730            if (error)
731                goto cleanup;
732            goto inserted;
733        } else {
734            int offset = (char *)s->here - bs->bh->b_data;
735
736            unlock_buffer(bs->bh);
737            jbd2_journal_release_buffer(handle, bs->bh);
738            if (ce) {
739                mb_cache_entry_release(ce);
740                ce = NULL;
741            }
742            ea_bdebug(bs->bh, "cloning");
743            s->base = kmalloc(bs->bh->b_size, GFP_NOFS);
744            error = -ENOMEM;
745            if (s->base == NULL)
746                goto cleanup;
747            memcpy(s->base, BHDR(bs->bh), bs->bh->b_size);
748            s->first = ENTRY(header(s->base)+1);
749            header(s->base)->h_refcount = cpu_to_le32(1);
750            s->here = ENTRY(s->base + offset);
751            s->end = s->base + bs->bh->b_size;
752        }
753    } else {
754        /* Allocate a buffer where we construct the new block. */
755        s->base = kzalloc(sb->s_blocksize, GFP_NOFS);
756        /* assert(header == s->base) */
757        error = -ENOMEM;
758        if (s->base == NULL)
759            goto cleanup;
760        header(s->base)->h_magic = cpu_to_le32(EXT4_XATTR_MAGIC);
761        header(s->base)->h_blocks = cpu_to_le32(1);
762        header(s->base)->h_refcount = cpu_to_le32(1);
763        s->first = ENTRY(header(s->base)+1);
764        s->here = ENTRY(header(s->base)+1);
765        s->end = s->base + sb->s_blocksize;
766    }
767
768    error = ext4_xattr_set_entry(i, s);
769    if (error == -EIO)
770        goto bad_block;
771    if (error)
772        goto cleanup;
773    if (!IS_LAST_ENTRY(s->first))
774        ext4_xattr_rehash(header(s->base), s->here);
775
776inserted:
777    if (!IS_LAST_ENTRY(s->first)) {
778        new_bh = ext4_xattr_cache_find(inode, header(s->base), &ce);
779        if (new_bh) {
780            /* We found an identical block in the cache. */
781            if (new_bh == bs->bh)
782                ea_bdebug(new_bh, "keeping");
783            else {
784                /* The old block is released after updating
785                   the inode. */
786                error = -EDQUOT;
787                if (vfs_dq_alloc_block(inode, 1))
788                    goto cleanup;
789                error = ext4_journal_get_write_access(handle,
790                                      new_bh);
791                if (error)
792                    goto cleanup_dquot;
793                lock_buffer(new_bh);
794                le32_add_cpu(&BHDR(new_bh)->h_refcount, 1);
795                ea_bdebug(new_bh, "reusing; refcount now=%d",
796                    le32_to_cpu(BHDR(new_bh)->h_refcount));
797                unlock_buffer(new_bh);
798                error = ext4_handle_dirty_metadata(handle,
799                                   inode,
800                                   new_bh);
801                if (error)
802                    goto cleanup_dquot;
803            }
804            mb_cache_entry_release(ce);
805            ce = NULL;
806        } else if (bs->bh && s->base == bs->bh->b_data) {
807            /* We were modifying this block in-place. */
808            ea_bdebug(bs->bh, "keeping this block");
809            new_bh = bs->bh;
810            get_bh(new_bh);
811        } else {
812            /* We need to allocate a new block */
813            ext4_fsblk_t goal = ext4_group_first_block_no(sb,
814                        EXT4_I(inode)->i_block_group);
815            ext4_fsblk_t block = ext4_new_meta_blocks(handle, inode,
816                          goal, NULL, &error);
817            if (error)
818                goto cleanup;
819            ea_idebug(inode, "creating block %d", block);
820
821            new_bh = sb_getblk(sb, block);
822            if (!new_bh) {
823getblk_failed:
824                ext4_free_blocks(handle, inode, block, 1, 1);
825                error = -EIO;
826                goto cleanup;
827            }
828            lock_buffer(new_bh);
829            error = ext4_journal_get_create_access(handle, new_bh);
830            if (error) {
831                unlock_buffer(new_bh);
832                goto getblk_failed;
833            }
834            memcpy(new_bh->b_data, s->base, new_bh->b_size);
835            set_buffer_uptodate(new_bh);
836            unlock_buffer(new_bh);
837            ext4_xattr_cache_insert(new_bh);
838            error = ext4_handle_dirty_metadata(handle,
839                               inode, new_bh);
840            if (error)
841                goto cleanup;
842        }
843    }
844
845    /* Update the inode. */
846    EXT4_I(inode)->i_file_acl = new_bh ? new_bh->b_blocknr : 0;
847
848    /* Drop the previous xattr block. */
849    if (bs->bh && bs->bh != new_bh)
850        ext4_xattr_release_block(handle, inode, bs->bh);
851    error = 0;
852
853cleanup:
854    if (ce)
855        mb_cache_entry_release(ce);
856    brelse(new_bh);
857    if (!(bs->bh && s->base == bs->bh->b_data))
858        kfree(s->base);
859
860    return error;
861
862cleanup_dquot:
863    vfs_dq_free_block(inode, 1);
864    goto cleanup;
865
866bad_block:
867    ext4_error(inode->i_sb, __func__,
868           "inode %lu: bad block %llu", inode->i_ino,
869           EXT4_I(inode)->i_file_acl);
870    goto cleanup;
871
872#undef header
873}
874
875struct ext4_xattr_ibody_find {
876    struct ext4_xattr_search s;
877    struct ext4_iloc iloc;
878};
879
880static int
881ext4_xattr_ibody_find(struct inode *inode, struct ext4_xattr_info *i,
882              struct ext4_xattr_ibody_find *is)
883{
884    struct ext4_xattr_ibody_header *header;
885    struct ext4_inode *raw_inode;
886    int error;
887
888    if (EXT4_I(inode)->i_extra_isize == 0)
889        return 0;
890    raw_inode = ext4_raw_inode(&is->iloc);
891    header = IHDR(inode, raw_inode);
892    is->s.base = is->s.first = IFIRST(header);
893    is->s.here = is->s.first;
894    is->s.end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
895    if (EXT4_I(inode)->i_state & EXT4_STATE_XATTR) {
896        error = ext4_xattr_check_names(IFIRST(header), is->s.end);
897        if (error)
898            return error;
899        /* Find the named attribute. */
900        error = ext4_xattr_find_entry(&is->s.here, i->name_index,
901                          i->name, is->s.end -
902                          (void *)is->s.base, 0);
903        if (error && error != -ENODATA)
904            return error;
905        is->s.not_found = error;
906    }
907    return 0;
908}
909
910static int
911ext4_xattr_ibody_set(handle_t *handle, struct inode *inode,
912             struct ext4_xattr_info *i,
913             struct ext4_xattr_ibody_find *is)
914{
915    struct ext4_xattr_ibody_header *header;
916    struct ext4_xattr_search *s = &is->s;
917    int error;
918
919    if (EXT4_I(inode)->i_extra_isize == 0)
920        return -ENOSPC;
921    error = ext4_xattr_set_entry(i, s);
922    if (error)
923        return error;
924    header = IHDR(inode, ext4_raw_inode(&is->iloc));
925    if (!IS_LAST_ENTRY(s->first)) {
926        header->h_magic = cpu_to_le32(EXT4_XATTR_MAGIC);
927        EXT4_I(inode)->i_state |= EXT4_STATE_XATTR;
928    } else {
929        header->h_magic = cpu_to_le32(0);
930        EXT4_I(inode)->i_state &= ~EXT4_STATE_XATTR;
931    }
932    return 0;
933}
934
935/*
936 * ext4_xattr_set_handle()
937 *
938 * Create, replace or remove an extended attribute for this inode. Buffer
939 * is NULL to remove an existing extended attribute, and non-NULL to
940 * either replace an existing extended attribute, or create a new extended
941 * attribute. The flags XATTR_REPLACE and XATTR_CREATE
942 * specify that an extended attribute must exist and must not exist
943 * previous to the call, respectively.
944 *
945 * Returns 0, or a negative error number on failure.
946 */
947int
948ext4_xattr_set_handle(handle_t *handle, struct inode *inode, int name_index,
949              const char *name, const void *value, size_t value_len,
950              int flags)
951{
952    struct ext4_xattr_info i = {
953        .name_index = name_index,
954        .name = name,
955        .value = value,
956        .value_len = value_len,
957
958    };
959    struct ext4_xattr_ibody_find is = {
960        .s = { .not_found = -ENODATA, },
961    };
962    struct ext4_xattr_block_find bs = {
963        .s = { .not_found = -ENODATA, },
964    };
965    unsigned long no_expand;
966    int error;
967
968    if (!name)
969        return -EINVAL;
970    if (strlen(name) > 255)
971        return -ERANGE;
972    down_write(&EXT4_I(inode)->xattr_sem);
973    no_expand = EXT4_I(inode)->i_state & EXT4_STATE_NO_EXPAND;
974    EXT4_I(inode)->i_state |= EXT4_STATE_NO_EXPAND;
975
976    error = ext4_get_inode_loc(inode, &is.iloc);
977    if (error)
978        goto cleanup;
979
980    if (EXT4_I(inode)->i_state & EXT4_STATE_NEW) {
981        struct ext4_inode *raw_inode = ext4_raw_inode(&is.iloc);
982        memset(raw_inode, 0, EXT4_SB(inode->i_sb)->s_inode_size);
983        EXT4_I(inode)->i_state &= ~EXT4_STATE_NEW;
984    }
985
986    error = ext4_xattr_ibody_find(inode, &i, &is);
987    if (error)
988        goto cleanup;
989    if (is.s.not_found)
990        error = ext4_xattr_block_find(inode, &i, &bs);
991    if (error)
992        goto cleanup;
993    if (is.s.not_found && bs.s.not_found) {
994        error = -ENODATA;
995        if (flags & XATTR_REPLACE)
996            goto cleanup;
997        error = 0;
998        if (!value)
999            goto cleanup;
1000    } else {
1001        error = -EEXIST;
1002        if (flags & XATTR_CREATE)
1003            goto cleanup;
1004    }
1005    error = ext4_journal_get_write_access(handle, is.iloc.bh);
1006    if (error)
1007        goto cleanup;
1008    if (!value) {
1009        if (!is.s.not_found)
1010            error = ext4_xattr_ibody_set(handle, inode, &i, &is);
1011        else if (!bs.s.not_found)
1012            error = ext4_xattr_block_set(handle, inode, &i, &bs);
1013    } else {
1014        error = ext4_xattr_ibody_set(handle, inode, &i, &is);
1015        if (!error && !bs.s.not_found) {
1016            i.value = NULL;
1017            error = ext4_xattr_block_set(handle, inode, &i, &bs);
1018        } else if (error == -ENOSPC) {
1019            if (EXT4_I(inode)->i_file_acl && !bs.s.base) {
1020                error = ext4_xattr_block_find(inode, &i, &bs);
1021                if (error)
1022                    goto cleanup;
1023            }
1024            error = ext4_xattr_block_set(handle, inode, &i, &bs);
1025            if (error)
1026                goto cleanup;
1027            if (!is.s.not_found) {
1028                i.value = NULL;
1029                error = ext4_xattr_ibody_set(handle, inode, &i,
1030                                 &is);
1031            }
1032        }
1033    }
1034    if (!error) {
1035        ext4_xattr_update_super_block(handle, inode->i_sb);
1036        inode->i_ctime = ext4_current_time(inode);
1037        if (!value)
1038            EXT4_I(inode)->i_state &= ~EXT4_STATE_NO_EXPAND;
1039        error = ext4_mark_iloc_dirty(handle, inode, &is.iloc);
1040        /*
1041         * The bh is consumed by ext4_mark_iloc_dirty, even with
1042         * error != 0.
1043         */
1044        is.iloc.bh = NULL;
1045        if (IS_SYNC(inode))
1046            ext4_handle_sync(handle);
1047    }
1048
1049cleanup:
1050    brelse(is.iloc.bh);
1051    brelse(bs.bh);
1052    if (no_expand == 0)
1053        EXT4_I(inode)->i_state &= ~EXT4_STATE_NO_EXPAND;
1054    up_write(&EXT4_I(inode)->xattr_sem);
1055    return error;
1056}
1057
1058/*
1059 * ext4_xattr_set()
1060 *
1061 * Like ext4_xattr_set_handle, but start from an inode. This extended
1062 * attribute modification is a filesystem transaction by itself.
1063 *
1064 * Returns 0, or a negative error number on failure.
1065 */
1066int
1067ext4_xattr_set(struct inode *inode, int name_index, const char *name,
1068           const void *value, size_t value_len, int flags)
1069{
1070    handle_t *handle;
1071    int error, retries = 0;
1072
1073retry:
1074    handle = ext4_journal_start(inode, EXT4_DATA_TRANS_BLOCKS(inode->i_sb));
1075    if (IS_ERR(handle)) {
1076        error = PTR_ERR(handle);
1077    } else {
1078        int error2;
1079
1080        error = ext4_xattr_set_handle(handle, inode, name_index, name,
1081                          value, value_len, flags);
1082        error2 = ext4_journal_stop(handle);
1083        if (error == -ENOSPC &&
1084            ext4_should_retry_alloc(inode->i_sb, &retries))
1085            goto retry;
1086        if (error == 0)
1087            error = error2;
1088    }
1089
1090    return error;
1091}
1092
1093/*
1094 * Shift the EA entries in the inode to create space for the increased
1095 * i_extra_isize.
1096 */
1097static void ext4_xattr_shift_entries(struct ext4_xattr_entry *entry,
1098                     int value_offs_shift, void *to,
1099                     void *from, size_t n, int blocksize)
1100{
1101    struct ext4_xattr_entry *last = entry;
1102    int new_offs;
1103
1104    /* Adjust the value offsets of the entries */
1105    for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
1106        if (!last->e_value_block && last->e_value_size) {
1107            new_offs = le16_to_cpu(last->e_value_offs) +
1108                            value_offs_shift;
1109            BUG_ON(new_offs + le32_to_cpu(last->e_value_size)
1110                 > blocksize);
1111            last->e_value_offs = cpu_to_le16(new_offs);
1112        }
1113    }
1114    /* Shift the entries by n bytes */
1115    memmove(to, from, n);
1116}
1117
1118/*
1119 * Expand an inode by new_extra_isize bytes when EAs are present.
1120 * Returns 0 on success or negative error number on failure.
1121 */
1122int ext4_expand_extra_isize_ea(struct inode *inode, int new_extra_isize,
1123                   struct ext4_inode *raw_inode, handle_t *handle)
1124{
1125    struct ext4_xattr_ibody_header *header;
1126    struct ext4_xattr_entry *entry, *last, *first;
1127    struct buffer_head *bh = NULL;
1128    struct ext4_xattr_ibody_find *is = NULL;
1129    struct ext4_xattr_block_find *bs = NULL;
1130    char *buffer = NULL, *b_entry_name = NULL;
1131    size_t min_offs, free;
1132    int total_ino, total_blk;
1133    void *base, *start, *end;
1134    int extra_isize = 0, error = 0, tried_min_extra_isize = 0;
1135    int s_min_extra_isize = le16_to_cpu(EXT4_SB(inode->i_sb)->s_es->s_min_extra_isize);
1136
1137    down_write(&EXT4_I(inode)->xattr_sem);
1138retry:
1139    if (EXT4_I(inode)->i_extra_isize >= new_extra_isize) {
1140        up_write(&EXT4_I(inode)->xattr_sem);
1141        return 0;
1142    }
1143
1144    header = IHDR(inode, raw_inode);
1145    entry = IFIRST(header);
1146
1147    /*
1148     * Check if enough free space is available in the inode to shift the
1149     * entries ahead by new_extra_isize.
1150     */
1151
1152    base = start = entry;
1153    end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
1154    min_offs = end - base;
1155    last = entry;
1156    total_ino = sizeof(struct ext4_xattr_ibody_header);
1157
1158    free = ext4_xattr_free_space(last, &min_offs, base, &total_ino);
1159    if (free >= new_extra_isize) {
1160        entry = IFIRST(header);
1161        ext4_xattr_shift_entries(entry, EXT4_I(inode)->i_extra_isize
1162                - new_extra_isize, (void *)raw_inode +
1163                EXT4_GOOD_OLD_INODE_SIZE + new_extra_isize,
1164                (void *)header, total_ino,
1165                inode->i_sb->s_blocksize);
1166        EXT4_I(inode)->i_extra_isize = new_extra_isize;
1167        error = 0;
1168        goto cleanup;
1169    }
1170
1171    /*
1172     * Enough free space isn't available in the inode, check if
1173     * EA block can hold new_extra_isize bytes.
1174     */
1175    if (EXT4_I(inode)->i_file_acl) {
1176        bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl);
1177        error = -EIO;
1178        if (!bh)
1179            goto cleanup;
1180        if (ext4_xattr_check_block(bh)) {
1181            ext4_error(inode->i_sb, __func__,
1182                "inode %lu: bad block %llu", inode->i_ino,
1183                EXT4_I(inode)->i_file_acl);
1184            error = -EIO;
1185            goto cleanup;
1186        }
1187        base = BHDR(bh);
1188        first = BFIRST(bh);
1189        end = bh->b_data + bh->b_size;
1190        min_offs = end - base;
1191        free = ext4_xattr_free_space(first, &min_offs, base,
1192                         &total_blk);
1193        if (free < new_extra_isize) {
1194            if (!tried_min_extra_isize && s_min_extra_isize) {
1195                tried_min_extra_isize++;
1196                new_extra_isize = s_min_extra_isize;
1197                brelse(bh);
1198                goto retry;
1199            }
1200            error = -1;
1201            goto cleanup;
1202        }
1203    } else {
1204        free = inode->i_sb->s_blocksize;
1205    }
1206
1207    while (new_extra_isize > 0) {
1208        size_t offs, size, entry_size;
1209        struct ext4_xattr_entry *small_entry = NULL;
1210        struct ext4_xattr_info i = {
1211            .value = NULL,
1212            .value_len = 0,
1213        };
1214        unsigned int total_size; /* EA entry size + value size */
1215        unsigned int shift_bytes; /* No. of bytes to shift EAs by? */
1216        unsigned int min_total_size = ~0U;
1217
1218        is = kzalloc(sizeof(struct ext4_xattr_ibody_find), GFP_NOFS);
1219        bs = kzalloc(sizeof(struct ext4_xattr_block_find), GFP_NOFS);
1220        if (!is || !bs) {
1221            error = -ENOMEM;
1222            goto cleanup;
1223        }
1224
1225        is->s.not_found = -ENODATA;
1226        bs->s.not_found = -ENODATA;
1227        is->iloc.bh = NULL;
1228        bs->bh = NULL;
1229
1230        last = IFIRST(header);
1231        /* Find the entry best suited to be pushed into EA block */
1232        entry = NULL;
1233        for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
1234            total_size =
1235            EXT4_XATTR_SIZE(le32_to_cpu(last->e_value_size)) +
1236                    EXT4_XATTR_LEN(last->e_name_len);
1237            if (total_size <= free && total_size < min_total_size) {
1238                if (total_size < new_extra_isize) {
1239                    small_entry = last;
1240                } else {
1241                    entry = last;
1242                    min_total_size = total_size;
1243                }
1244            }
1245        }
1246
1247        if (entry == NULL) {
1248            if (small_entry) {
1249                entry = small_entry;
1250            } else {
1251                if (!tried_min_extra_isize &&
1252                    s_min_extra_isize) {
1253                    tried_min_extra_isize++;
1254                    new_extra_isize = s_min_extra_isize;
1255                    goto retry;
1256                }
1257                error = -1;
1258                goto cleanup;
1259            }
1260        }
1261        offs = le16_to_cpu(entry->e_value_offs);
1262        size = le32_to_cpu(entry->e_value_size);
1263        entry_size = EXT4_XATTR_LEN(entry->e_name_len);
1264        i.name_index = entry->e_name_index,
1265        buffer = kmalloc(EXT4_XATTR_SIZE(size), GFP_NOFS);
1266        b_entry_name = kmalloc(entry->e_name_len + 1, GFP_NOFS);
1267        if (!buffer || !b_entry_name) {
1268            error = -ENOMEM;
1269            goto cleanup;
1270        }
1271        /* Save the entry name and the entry value */
1272        memcpy(buffer, (void *)IFIRST(header) + offs,
1273               EXT4_XATTR_SIZE(size));
1274        memcpy(b_entry_name, entry->e_name, entry->e_name_len);
1275        b_entry_name[entry->e_name_len] = '\0';
1276        i.name = b_entry_name;
1277
1278        error = ext4_get_inode_loc(inode, &is->iloc);
1279        if (error)
1280            goto cleanup;
1281
1282        error = ext4_xattr_ibody_find(inode, &i, is);
1283        if (error)
1284            goto cleanup;
1285
1286        /* Remove the chosen entry from the inode */
1287        error = ext4_xattr_ibody_set(handle, inode, &i, is);
1288
1289        entry = IFIRST(header);
1290        if (entry_size + EXT4_XATTR_SIZE(size) >= new_extra_isize)
1291            shift_bytes = new_extra_isize;
1292        else
1293            shift_bytes = entry_size + size;
1294        /* Adjust the offsets and shift the remaining entries ahead */
1295        ext4_xattr_shift_entries(entry, EXT4_I(inode)->i_extra_isize -
1296            shift_bytes, (void *)raw_inode +
1297            EXT4_GOOD_OLD_INODE_SIZE + extra_isize + shift_bytes,
1298            (void *)header, total_ino - entry_size,
1299            inode->i_sb->s_blocksize);
1300
1301        extra_isize += shift_bytes;
1302        new_extra_isize -= shift_bytes;
1303        EXT4_I(inode)->i_extra_isize = extra_isize;
1304
1305        i.name = b_entry_name;
1306        i.value = buffer;
1307        i.value_len = size;
1308        error = ext4_xattr_block_find(inode, &i, bs);
1309        if (error)
1310            goto cleanup;
1311
1312        /* Add entry which was removed from the inode into the block */
1313        error = ext4_xattr_block_set(handle, inode, &i, bs);
1314        if (error)
1315            goto cleanup;
1316        kfree(b_entry_name);
1317        kfree(buffer);
1318        brelse(is->iloc.bh);
1319        kfree(is);
1320        kfree(bs);
1321    }
1322    brelse(bh);
1323    up_write(&EXT4_I(inode)->xattr_sem);
1324    return 0;
1325
1326cleanup:
1327    kfree(b_entry_name);
1328    kfree(buffer);
1329    if (is)
1330        brelse(is->iloc.bh);
1331    kfree(is);
1332    kfree(bs);
1333    brelse(bh);
1334    up_write(&EXT4_I(inode)->xattr_sem);
1335    return error;
1336}
1337
1338
1339
1340/*
1341 * ext4_xattr_delete_inode()
1342 *
1343 * Free extended attribute resources associated with this inode. This
1344 * is called immediately before an inode is freed. We have exclusive
1345 * access to the inode.
1346 */
1347void
1348ext4_xattr_delete_inode(handle_t *handle, struct inode *inode)
1349{
1350    struct buffer_head *bh = NULL;
1351
1352    if (!EXT4_I(inode)->i_file_acl)
1353        goto cleanup;
1354    bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl);
1355    if (!bh) {
1356        ext4_error(inode->i_sb, __func__,
1357            "inode %lu: block %llu read error", inode->i_ino,
1358            EXT4_I(inode)->i_file_acl);
1359        goto cleanup;
1360    }
1361    if (BHDR(bh)->h_magic != cpu_to_le32(EXT4_XATTR_MAGIC) ||
1362        BHDR(bh)->h_blocks != cpu_to_le32(1)) {
1363        ext4_error(inode->i_sb, __func__,
1364            "inode %lu: bad block %llu", inode->i_ino,
1365            EXT4_I(inode)->i_file_acl);
1366        goto cleanup;
1367    }
1368    ext4_xattr_release_block(handle, inode, bh);
1369    EXT4_I(inode)->i_file_acl = 0;
1370
1371cleanup:
1372    brelse(bh);
1373}
1374
1375/*
1376 * ext4_xattr_put_super()
1377 *
1378 * This is called when a file system is unmounted.
1379 */
1380void
1381ext4_xattr_put_super(struct super_block *sb)
1382{
1383    mb_cache_shrink(sb->s_bdev);
1384}
1385
1386/*
1387 * ext4_xattr_cache_insert()
1388 *
1389 * Create a new entry in the extended attribute cache, and insert
1390 * it unless such an entry is already in the cache.
1391 *
1392 * Returns 0, or a negative error number on failure.
1393 */
1394static void
1395ext4_xattr_cache_insert(struct buffer_head *bh)
1396{
1397    __u32 hash = le32_to_cpu(BHDR(bh)->h_hash);
1398    struct mb_cache_entry *ce;
1399    int error;
1400
1401    ce = mb_cache_entry_alloc(ext4_xattr_cache, GFP_NOFS);
1402    if (!ce) {
1403        ea_bdebug(bh, "out of memory");
1404        return;
1405    }
1406    error = mb_cache_entry_insert(ce, bh->b_bdev, bh->b_blocknr, &hash);
1407    if (error) {
1408        mb_cache_entry_free(ce);
1409        if (error == -EBUSY) {
1410            ea_bdebug(bh, "already in cache");
1411            error = 0;
1412        }
1413    } else {
1414        ea_bdebug(bh, "inserting [%x]", (int)hash);
1415        mb_cache_entry_release(ce);
1416    }
1417}
1418
1419/*
1420 * ext4_xattr_cmp()
1421 *
1422 * Compare two extended attribute blocks for equality.
1423 *
1424 * Returns 0 if the blocks are equal, 1 if they differ, and
1425 * a negative error number on errors.
1426 */
1427static int
1428ext4_xattr_cmp(struct ext4_xattr_header *header1,
1429           struct ext4_xattr_header *header2)
1430{
1431    struct ext4_xattr_entry *entry1, *entry2;
1432
1433    entry1 = ENTRY(header1+1);
1434    entry2 = ENTRY(header2+1);
1435    while (!IS_LAST_ENTRY(entry1)) {
1436        if (IS_LAST_ENTRY(entry2))
1437            return 1;
1438        if (entry1->e_hash != entry2->e_hash ||
1439            entry1->e_name_index != entry2->e_name_index ||
1440            entry1->e_name_len != entry2->e_name_len ||
1441            entry1->e_value_size != entry2->e_value_size ||
1442            memcmp(entry1->e_name, entry2->e_name, entry1->e_name_len))
1443            return 1;
1444        if (entry1->e_value_block != 0 || entry2->e_value_block != 0)
1445            return -EIO;
1446        if (memcmp((char *)header1 + le16_to_cpu(entry1->e_value_offs),
1447               (char *)header2 + le16_to_cpu(entry2->e_value_offs),
1448               le32_to_cpu(entry1->e_value_size)))
1449            return 1;
1450
1451        entry1 = EXT4_XATTR_NEXT(entry1);
1452        entry2 = EXT4_XATTR_NEXT(entry2);
1453    }
1454    if (!IS_LAST_ENTRY(entry2))
1455        return 1;
1456    return 0;
1457}
1458
1459/*
1460 * ext4_xattr_cache_find()
1461 *
1462 * Find an identical extended attribute block.
1463 *
1464 * Returns a pointer to the block found, or NULL if such a block was
1465 * not found or an error occurred.
1466 */
1467static struct buffer_head *
1468ext4_xattr_cache_find(struct inode *inode, struct ext4_xattr_header *header,
1469              struct mb_cache_entry **pce)
1470{
1471    __u32 hash = le32_to_cpu(header->h_hash);
1472    struct mb_cache_entry *ce;
1473
1474    if (!header->h_hash)
1475        return NULL; /* never share */
1476    ea_idebug(inode, "looking for cached blocks [%x]", (int)hash);
1477again:
1478    ce = mb_cache_entry_find_first(ext4_xattr_cache, 0,
1479                       inode->i_sb->s_bdev, hash);
1480    while (ce) {
1481        struct buffer_head *bh;
1482
1483        if (IS_ERR(ce)) {
1484            if (PTR_ERR(ce) == -EAGAIN)
1485                goto again;
1486            break;
1487        }
1488        bh = sb_bread(inode->i_sb, ce->e_block);
1489        if (!bh) {
1490            ext4_error(inode->i_sb, __func__,
1491                "inode %lu: block %lu read error",
1492                inode->i_ino, (unsigned long) ce->e_block);
1493        } else if (le32_to_cpu(BHDR(bh)->h_refcount) >=
1494                EXT4_XATTR_REFCOUNT_MAX) {
1495            ea_idebug(inode, "block %lu refcount %d>=%d",
1496                  (unsigned long) ce->e_block,
1497                  le32_to_cpu(BHDR(bh)->h_refcount),
1498                      EXT4_XATTR_REFCOUNT_MAX);
1499        } else if (ext4_xattr_cmp(header, BHDR(bh)) == 0) {
1500            *pce = ce;
1501            return bh;
1502        }
1503        brelse(bh);
1504        ce = mb_cache_entry_find_next(ce, 0, inode->i_sb->s_bdev, hash);
1505    }
1506    return NULL;
1507}
1508
1509#define NAME_HASH_SHIFT 5
1510#define VALUE_HASH_SHIFT 16
1511
1512/*
1513 * ext4_xattr_hash_entry()
1514 *
1515 * Compute the hash of an extended attribute.
1516 */
1517static inline void ext4_xattr_hash_entry(struct ext4_xattr_header *header,
1518                     struct ext4_xattr_entry *entry)
1519{
1520    __u32 hash = 0;
1521    char *name = entry->e_name;
1522    int n;
1523
1524    for (n = 0; n < entry->e_name_len; n++) {
1525        hash = (hash << NAME_HASH_SHIFT) ^
1526               (hash >> (8*sizeof(hash) - NAME_HASH_SHIFT)) ^
1527               *name++;
1528    }
1529
1530    if (entry->e_value_block == 0 && entry->e_value_size != 0) {
1531        __le32 *value = (__le32 *)((char *)header +
1532            le16_to_cpu(entry->e_value_offs));
1533        for (n = (le32_to_cpu(entry->e_value_size) +
1534             EXT4_XATTR_ROUND) >> EXT4_XATTR_PAD_BITS; n; n--) {
1535            hash = (hash << VALUE_HASH_SHIFT) ^
1536                   (hash >> (8*sizeof(hash) - VALUE_HASH_SHIFT)) ^
1537                   le32_to_cpu(*value++);
1538        }
1539    }
1540    entry->e_hash = cpu_to_le32(hash);
1541}
1542
1543#undef NAME_HASH_SHIFT
1544#undef VALUE_HASH_SHIFT
1545
1546#define BLOCK_HASH_SHIFT 16
1547
1548/*
1549 * ext4_xattr_rehash()
1550 *
1551 * Re-compute the extended attribute hash value after an entry has changed.
1552 */
1553static void ext4_xattr_rehash(struct ext4_xattr_header *header,
1554                  struct ext4_xattr_entry *entry)
1555{
1556    struct ext4_xattr_entry *here;
1557    __u32 hash = 0;
1558
1559    ext4_xattr_hash_entry(header, entry);
1560    here = ENTRY(header+1);
1561    while (!IS_LAST_ENTRY(here)) {
1562        if (!here->e_hash) {
1563            /* Block is not shared if an entry's hash value == 0 */
1564            hash = 0;
1565            break;
1566        }
1567        hash = (hash << BLOCK_HASH_SHIFT) ^
1568               (hash >> (8*sizeof(hash) - BLOCK_HASH_SHIFT)) ^
1569               le32_to_cpu(here->e_hash);
1570        here = EXT4_XATTR_NEXT(here);
1571    }
1572    header->h_hash = cpu_to_le32(hash);
1573}
1574
1575#undef BLOCK_HASH_SHIFT
1576
1577int __init
1578init_ext4_xattr(void)
1579{
1580    ext4_xattr_cache = mb_cache_create("ext4_xattr", NULL,
1581        sizeof(struct mb_cache_entry) +
1582        sizeof(((struct mb_cache_entry *) 0)->e_indexes[0]), 1, 6);
1583    if (!ext4_xattr_cache)
1584        return -ENOMEM;
1585    return 0;
1586}
1587
1588void
1589exit_ext4_xattr(void)
1590{
1591    if (ext4_xattr_cache)
1592        mb_cache_destroy(ext4_xattr_cache);
1593    ext4_xattr_cache = NULL;
1594}
1595

Archive Download this file



interactive