8c29ae15129ed06bacb04727d4e2d6da17700960
[linux-2.6.git] / fs / ext2 / xattr.c
1 /*
2  * linux/fs/ext2/xattr.c
3  *
4  * Copyright (C) 2001-2003 Andreas Gruenbacher <agruen@suse.de>
5  *
6  * Fix by Harrison Xing <harrison@mountainviewdata.com>.
7  * Extended attributes for symlinks and special files added per
8  *  suggestion of Luka Renko <luka.renko@hermes.si>.
9  * xattr consolidation Copyright (c) 2004 James Morris <jmorris@redhat.com>,
10  *  Red Hat Inc.
11  *
12  */
13
14 /*
15  * Extended attributes are stored on disk blocks allocated outside of
16  * any inode. The i_file_acl field is then made to point to this allocated
17  * block. If all extended attributes of an inode are identical, these
18  * inodes may share the same extended attribute block. Such situations
19  * are automatically detected by keeping a cache of recent attribute block
20  * numbers and hashes over the block's contents in memory.
21  *
22  *
23  * Extended attribute block layout:
24  *
25  *   +------------------+
26  *   | header           |
27  *   | entry 1          | |
28  *   | entry 2          | | growing downwards
29  *   | entry 3          | v
30  *   | four null bytes  |
31  *   | . . .            |
32  *   | value 1          | ^
33  *   | value 3          | | growing upwards
34  *   | value 2          | |
35  *   +------------------+
36  *
37  * The block header is followed by multiple entry descriptors. These entry
38  * descriptors are variable in size, and alligned to EXT2_XATTR_PAD
39  * byte boundaries. The entry descriptors are sorted by attribute name,
40  * so that two extended attribute blocks can be compared efficiently.
41  *
42  * Attribute values are aligned to the end of the block, stored in
43  * no specific order. They are also padded to EXT2_XATTR_PAD byte
44  * boundaries. No additional gaps are left between them.
45  *
46  * Locking strategy
47  * ----------------
48  * EXT2_I(inode)->i_file_acl is protected by EXT2_I(inode)->xattr_sem.
49  * EA blocks are only changed if they are exclusive to an inode, so
50  * holding xattr_sem also means that nothing but the EA block's reference
51  * count will change. Multiple writers to an EA block are synchronized
52  * by the bh lock. No more than a single bh lock is held at any time
53  * to avoid deadlocks.
54  */
55
56 #include <linux/buffer_head.h>
57 #include <linux/module.h>
58 #include <linux/init.h>
59 #include <linux/slab.h>
60 #include <linux/mbcache.h>
61 #include <linux/quotaops.h>
62 #include <linux/rwsem.h>
63 #include <linux/security.h>
64 #include "ext2.h"
65 #include "xattr.h"
66 #include "acl.h"
67
68 #define HDR(bh) ((struct ext2_xattr_header *)((bh)->b_data))
69 #define ENTRY(ptr) ((struct ext2_xattr_entry *)(ptr))
70 #define FIRST_ENTRY(bh) ENTRY(HDR(bh)+1)
71 #define IS_LAST_ENTRY(entry) (*(__u32 *)(entry) == 0)
72
73 #ifdef EXT2_XATTR_DEBUG
74 # define ea_idebug(inode, f...) do { \
75                 printk(KERN_DEBUG "inode %s:%ld: ", \
76                         inode->i_sb->s_id, inode->i_ino); \
77                 printk(f); \
78                 printk("\n"); \
79         } while (0)
80 # define ea_bdebug(bh, f...) do { \
81                 char b[BDEVNAME_SIZE]; \
82                 printk(KERN_DEBUG "block %s:%lu: ", \
83                         bdevname(bh->b_bdev, b), \
84                         (unsigned long) bh->b_blocknr); \
85                 printk(f); \
86                 printk("\n"); \
87         } while (0)
88 #else
89 # define ea_idebug(f...)
90 # define ea_bdebug(f...)
91 #endif
92
93 static int ext2_xattr_set2(struct inode *, struct buffer_head *,
94                            struct ext2_xattr_header *);
95
96 static int ext2_xattr_cache_insert(struct buffer_head *);
97 static struct buffer_head *ext2_xattr_cache_find(struct inode *,
98                                                  struct ext2_xattr_header *);
99 static void ext2_xattr_rehash(struct ext2_xattr_header *,
100                               struct ext2_xattr_entry *);
101
102 static struct mb_cache *ext2_xattr_cache;
103
104 static const struct xattr_handler *ext2_xattr_handler_map[] = {
105         [EXT2_XATTR_INDEX_USER]              = &ext2_xattr_user_handler,
106 #ifdef CONFIG_EXT2_FS_POSIX_ACL
107         [EXT2_XATTR_INDEX_POSIX_ACL_ACCESS]  = &ext2_xattr_acl_access_handler,
108         [EXT2_XATTR_INDEX_POSIX_ACL_DEFAULT] = &ext2_xattr_acl_default_handler,
109 #endif
110         [EXT2_XATTR_INDEX_TRUSTED]           = &ext2_xattr_trusted_handler,
111 #ifdef CONFIG_EXT2_FS_SECURITY
112         [EXT2_XATTR_INDEX_SECURITY]          = &ext2_xattr_security_handler,
113 #endif
114 };
115
116 const struct xattr_handler *ext2_xattr_handlers[] = {
117         &ext2_xattr_user_handler,
118         &ext2_xattr_trusted_handler,
119 #ifdef CONFIG_EXT2_FS_POSIX_ACL
120         &ext2_xattr_acl_access_handler,
121         &ext2_xattr_acl_default_handler,
122 #endif
123 #ifdef CONFIG_EXT2_FS_SECURITY
124         &ext2_xattr_security_handler,
125 #endif
126         NULL
127 };
128
129 static inline const struct xattr_handler *
130 ext2_xattr_handler(int name_index)
131 {
132         const struct xattr_handler *handler = NULL;
133
134         if (name_index > 0 && name_index < ARRAY_SIZE(ext2_xattr_handler_map))
135                 handler = ext2_xattr_handler_map[name_index];
136         return handler;
137 }
138
139 /*
140  * ext2_xattr_get()
141  *
142  * Copy an extended attribute into the buffer
143  * provided, or compute the buffer size required.
144  * Buffer is NULL to compute the size of the buffer required.
145  *
146  * Returns a negative error number on failure, or the number of bytes
147  * used / required on success.
148  */
149 int
150 ext2_xattr_get(struct inode *inode, int name_index, const char *name,
151                void *buffer, size_t buffer_size)
152 {
153         struct buffer_head *bh = NULL;
154         struct ext2_xattr_entry *entry;
155         size_t name_len, size;
156         char *end;
157         int error;
158
159         ea_idebug(inode, "name=%d.%s, buffer=%p, buffer_size=%ld",
160                   name_index, name, buffer, (long)buffer_size);
161
162         if (name == NULL)
163                 return -EINVAL;
164         down_read(&EXT2_I(inode)->xattr_sem);
165         error = -ENODATA;
166         if (!EXT2_I(inode)->i_file_acl)
167                 goto cleanup;
168         ea_idebug(inode, "reading block %d", EXT2_I(inode)->i_file_acl);
169         bh = sb_bread(inode->i_sb, EXT2_I(inode)->i_file_acl);
170         error = -EIO;
171         if (!bh)
172                 goto cleanup;
173         ea_bdebug(bh, "b_count=%d, refcount=%d",
174                 atomic_read(&(bh->b_count)), le32_to_cpu(HDR(bh)->h_refcount));
175         end = bh->b_data + bh->b_size;
176         if (HDR(bh)->h_magic != cpu_to_le32(EXT2_XATTR_MAGIC) ||
177             HDR(bh)->h_blocks != cpu_to_le32(1)) {
178 bad_block:      ext2_error(inode->i_sb, "ext2_xattr_get",
179                         "inode %ld: bad block %d", inode->i_ino,
180                         EXT2_I(inode)->i_file_acl);
181                 error = -EIO;
182                 goto cleanup;
183         }
184         /* find named attribute */
185         name_len = strlen(name);
186
187         error = -ERANGE;
188         if (name_len > 255)
189                 goto cleanup;
190         entry = FIRST_ENTRY(bh);
191         while (!IS_LAST_ENTRY(entry)) {
192                 struct ext2_xattr_entry *next =
193                         EXT2_XATTR_NEXT(entry);
194                 if ((char *)next >= end)
195                         goto bad_block;
196                 if (name_index == entry->e_name_index &&
197                     name_len == entry->e_name_len &&
198                     memcmp(name, entry->e_name, name_len) == 0)
199                         goto found;
200                 entry = next;
201         }
202         /* Check the remaining name entries */
203         while (!IS_LAST_ENTRY(entry)) {
204                 struct ext2_xattr_entry *next =
205                         EXT2_XATTR_NEXT(entry);
206                 if ((char *)next >= end)
207                         goto bad_block;
208                 entry = next;
209         }
210         if (ext2_xattr_cache_insert(bh))
211                 ea_idebug(inode, "cache insert failed");
212         error = -ENODATA;
213         goto cleanup;
214 found:
215         /* check the buffer size */
216         if (entry->e_value_block != 0)
217                 goto bad_block;
218         size = le32_to_cpu(entry->e_value_size);
219         if (size > inode->i_sb->s_blocksize ||
220             le16_to_cpu(entry->e_value_offs) + size > inode->i_sb->s_blocksize)
221                 goto bad_block;
222
223         if (ext2_xattr_cache_insert(bh))
224                 ea_idebug(inode, "cache insert failed");
225         if (buffer) {
226                 error = -ERANGE;
227                 if (size > buffer_size)
228                         goto cleanup;
229                 /* return value of attribute */
230                 memcpy(buffer, bh->b_data + le16_to_cpu(entry->e_value_offs),
231                         size);
232         }
233         error = size;
234
235 cleanup:
236         brelse(bh);
237         up_read(&EXT2_I(inode)->xattr_sem);
238
239         return error;
240 }
241
242 /*
243  * ext2_xattr_list()
244  *
245  * Copy a list of attribute names into the buffer
246  * provided, or compute the buffer size required.
247  * Buffer is NULL to compute the size of the buffer required.
248  *
249  * Returns a negative error number on failure, or the number of bytes
250  * used / required on success.
251  */
252 static int
253 ext2_xattr_list(struct dentry *dentry, char *buffer, size_t buffer_size)
254 {
255         struct inode *inode = dentry->d_inode;
256         struct buffer_head *bh = NULL;
257         struct ext2_xattr_entry *entry;
258         char *end;
259         size_t rest = buffer_size;
260         int error;
261
262         ea_idebug(inode, "buffer=%p, buffer_size=%ld",
263                   buffer, (long)buffer_size);
264
265         down_read(&EXT2_I(inode)->xattr_sem);
266         error = 0;
267         if (!EXT2_I(inode)->i_file_acl)
268                 goto cleanup;
269         ea_idebug(inode, "reading block %d", EXT2_I(inode)->i_file_acl);
270         bh = sb_bread(inode->i_sb, EXT2_I(inode)->i_file_acl);
271         error = -EIO;
272         if (!bh)
273                 goto cleanup;
274         ea_bdebug(bh, "b_count=%d, refcount=%d",
275                 atomic_read(&(bh->b_count)), le32_to_cpu(HDR(bh)->h_refcount));
276         end = bh->b_data + bh->b_size;
277         if (HDR(bh)->h_magic != cpu_to_le32(EXT2_XATTR_MAGIC) ||
278             HDR(bh)->h_blocks != cpu_to_le32(1)) {
279 bad_block:      ext2_error(inode->i_sb, "ext2_xattr_list",
280                         "inode %ld: bad block %d", inode->i_ino,
281                         EXT2_I(inode)->i_file_acl);
282                 error = -EIO;
283                 goto cleanup;
284         }
285
286         /* check the on-disk data structure */
287         entry = FIRST_ENTRY(bh);
288         while (!IS_LAST_ENTRY(entry)) {
289                 struct ext2_xattr_entry *next = EXT2_XATTR_NEXT(entry);
290
291                 if ((char *)next >= end)
292                         goto bad_block;
293                 entry = next;
294         }
295         if (ext2_xattr_cache_insert(bh))
296                 ea_idebug(inode, "cache insert failed");
297
298         /* list the attribute names */
299         for (entry = FIRST_ENTRY(bh); !IS_LAST_ENTRY(entry);
300              entry = EXT2_XATTR_NEXT(entry)) {
301                 const struct xattr_handler *handler =
302                         ext2_xattr_handler(entry->e_name_index);
303
304                 if (handler) {
305                         size_t size = handler->list(dentry, buffer, rest,
306                                                     entry->e_name,
307                                                     entry->e_name_len,
308                                                     handler->flags);
309                         if (buffer) {
310                                 if (size > rest) {
311                                         error = -ERANGE;
312                                         goto cleanup;
313                                 }
314                                 buffer += size;
315                         }
316                         rest -= size;
317                 }
318         }
319         error = buffer_size - rest;  /* total size */
320
321 cleanup:
322         brelse(bh);
323         up_read(&EXT2_I(inode)->xattr_sem);
324
325         return error;
326 }
327
328 /*
329  * Inode operation listxattr()
330  *
331  * dentry->d_inode->i_mutex: don't care
332  */
333 ssize_t
334 ext2_listxattr(struct dentry *dentry, char *buffer, size_t size)
335 {
336         return ext2_xattr_list(dentry, buffer, size);
337 }
338
339 /*
340  * If the EXT2_FEATURE_COMPAT_EXT_ATTR feature of this file system is
341  * not set, set it.
342  */
343 static void ext2_xattr_update_super_block(struct super_block *sb)
344 {
345         if (EXT2_HAS_COMPAT_FEATURE(sb, EXT2_FEATURE_COMPAT_EXT_ATTR))
346                 return;
347
348         spin_lock(&EXT2_SB(sb)->s_lock);
349         EXT2_SET_COMPAT_FEATURE(sb, EXT2_FEATURE_COMPAT_EXT_ATTR);
350         spin_unlock(&EXT2_SB(sb)->s_lock);
351         sb->s_dirt = 1;
352         mark_buffer_dirty(EXT2_SB(sb)->s_sbh);
353 }
354
355 /*
356  * ext2_xattr_set()
357  *
358  * Create, replace or remove an extended attribute for this inode. Buffer
359  * is NULL to remove an existing extended attribute, and non-NULL to
360  * either replace an existing extended attribute, or create a new extended
361  * attribute. The flags XATTR_REPLACE and XATTR_CREATE
362  * specify that an extended attribute must exist and must not exist
363  * previous to the call, respectively.
364  *
365  * Returns 0, or a negative error number on failure.
366  */
367 int
368 ext2_xattr_set(struct inode *inode, int name_index, const char *name,
369                const void *value, size_t value_len, int flags)
370 {
371         struct super_block *sb = inode->i_sb;
372         struct buffer_head *bh = NULL;
373         struct ext2_xattr_header *header = NULL;
374         struct ext2_xattr_entry *here, *last;
375         size_t name_len, free, min_offs = sb->s_blocksize;
376         int not_found = 1, error;
377         char *end;
378         
379         /*
380          * header -- Points either into bh, or to a temporarily
381          *           allocated buffer.
382          * here -- The named entry found, or the place for inserting, within
383          *         the block pointed to by header.
384          * last -- Points right after the last named entry within the block
385          *         pointed to by header.
386          * min_offs -- The offset of the first value (values are aligned
387          *             towards the end of the block).
388          * end -- Points right after the block pointed to by header.
389          */
390         
391         ea_idebug(inode, "name=%d.%s, value=%p, value_len=%ld",
392                   name_index, name, value, (long)value_len);
393
394         if (value == NULL)
395                 value_len = 0;
396         if (name == NULL)
397                 return -EINVAL;
398         name_len = strlen(name);
399         if (name_len > 255 || value_len > sb->s_blocksize)
400                 return -ERANGE;
401         down_write(&EXT2_I(inode)->xattr_sem);
402         if (EXT2_I(inode)->i_file_acl) {
403                 /* The inode already has an extended attribute block. */
404                 bh = sb_bread(sb, EXT2_I(inode)->i_file_acl);
405                 error = -EIO;
406                 if (!bh)
407                         goto cleanup;
408                 ea_bdebug(bh, "b_count=%d, refcount=%d",
409                         atomic_read(&(bh->b_count)),
410                         le32_to_cpu(HDR(bh)->h_refcount));
411                 header = HDR(bh);
412                 end = bh->b_data + bh->b_size;
413                 if (header->h_magic != cpu_to_le32(EXT2_XATTR_MAGIC) ||
414                     header->h_blocks != cpu_to_le32(1)) {
415 bad_block:              ext2_error(sb, "ext2_xattr_set",
416                                 "inode %ld: bad block %d", inode->i_ino, 
417                                    EXT2_I(inode)->i_file_acl);
418                         error = -EIO;
419                         goto cleanup;
420                 }
421                 /* Find the named attribute. */
422                 here = FIRST_ENTRY(bh);
423                 while (!IS_LAST_ENTRY(here)) {
424                         struct ext2_xattr_entry *next = EXT2_XATTR_NEXT(here);
425                         if ((char *)next >= end)
426                                 goto bad_block;
427                         if (!here->e_value_block && here->e_value_size) {
428                                 size_t offs = le16_to_cpu(here->e_value_offs);
429                                 if (offs < min_offs)
430                                         min_offs = offs;
431                         }
432                         not_found = name_index - here->e_name_index;
433                         if (!not_found)
434                                 not_found = name_len - here->e_name_len;
435                         if (!not_found)
436                                 not_found = memcmp(name, here->e_name,name_len);
437                         if (not_found <= 0)
438                                 break;
439                         here = next;
440                 }
441                 last = here;
442                 /* We still need to compute min_offs and last. */
443                 while (!IS_LAST_ENTRY(last)) {
444                         struct ext2_xattr_entry *next = EXT2_XATTR_NEXT(last);
445                         if ((char *)next >= end)
446                                 goto bad_block;
447                         if (!last->e_value_block && last->e_value_size) {
448                                 size_t offs = le16_to_cpu(last->e_value_offs);
449                                 if (offs < min_offs)
450                                         min_offs = offs;
451                         }
452                         last = next;
453                 }
454
455                 /* Check whether we have enough space left. */
456                 free = min_offs - ((char*)last - (char*)header) - sizeof(__u32);
457         } else {
458                 /* We will use a new extended attribute block. */
459                 free = sb->s_blocksize -
460                         sizeof(struct ext2_xattr_header) - sizeof(__u32);
461                 here = last = NULL;  /* avoid gcc uninitialized warning. */
462         }
463
464         if (not_found) {
465                 /* Request to remove a nonexistent attribute? */
466                 error = -ENODATA;
467                 if (flags & XATTR_REPLACE)
468                         goto cleanup;
469                 error = 0;
470                 if (value == NULL)
471                         goto cleanup;
472         } else {
473                 /* Request to create an existing attribute? */
474                 error = -EEXIST;
475                 if (flags & XATTR_CREATE)
476                         goto cleanup;
477                 if (!here->e_value_block && here->e_value_size) {
478                         size_t size = le32_to_cpu(here->e_value_size);
479
480                         if (le16_to_cpu(here->e_value_offs) + size > 
481                             sb->s_blocksize || size > sb->s_blocksize)
482                                 goto bad_block;
483                         free += EXT2_XATTR_SIZE(size);
484                 }
485                 free += EXT2_XATTR_LEN(name_len);
486         }
487         error = -ENOSPC;
488         if (free < EXT2_XATTR_LEN(name_len) + EXT2_XATTR_SIZE(value_len))
489                 goto cleanup;
490
491         /* Here we know that we can set the new attribute. */
492
493         if (header) {
494                 struct mb_cache_entry *ce;
495
496                 /* assert(header == HDR(bh)); */
497                 ce = mb_cache_entry_get(ext2_xattr_cache, bh->b_bdev,
498                                         bh->b_blocknr);
499                 lock_buffer(bh);
500                 if (header->h_refcount == cpu_to_le32(1)) {
501                         ea_bdebug(bh, "modifying in-place");
502                         if (ce)
503                                 mb_cache_entry_free(ce);
504                         /* keep the buffer locked while modifying it. */
505                 } else {
506                         int offset;
507
508                         if (ce)
509                                 mb_cache_entry_release(ce);
510                         unlock_buffer(bh);
511                         ea_bdebug(bh, "cloning");
512                         header = kmalloc(bh->b_size, GFP_KERNEL);
513                         error = -ENOMEM;
514                         if (header == NULL)
515                                 goto cleanup;
516                         memcpy(header, HDR(bh), bh->b_size);
517                         header->h_refcount = cpu_to_le32(1);
518
519                         offset = (char *)here - bh->b_data;
520                         here = ENTRY((char *)header + offset);
521                         offset = (char *)last - bh->b_data;
522                         last = ENTRY((char *)header + offset);
523                 }
524         } else {
525                 /* Allocate a buffer where we construct the new block. */
526                 header = kzalloc(sb->s_blocksize, GFP_KERNEL);
527                 error = -ENOMEM;
528                 if (header == NULL)
529                         goto cleanup;
530                 end = (char *)header + sb->s_blocksize;
531                 header->h_magic = cpu_to_le32(EXT2_XATTR_MAGIC);
532                 header->h_blocks = header->h_refcount = cpu_to_le32(1);
533                 last = here = ENTRY(header+1);
534         }
535
536         /* Iff we are modifying the block in-place, bh is locked here. */
537
538         if (not_found) {
539                 /* Insert the new name. */
540                 size_t size = EXT2_XATTR_LEN(name_len);
541                 size_t rest = (char *)last - (char *)here;
542                 memmove((char *)here + size, here, rest);
543                 memset(here, 0, size);
544                 here->e_name_index = name_index;
545                 here->e_name_len = name_len;
546                 memcpy(here->e_name, name, name_len);
547         } else {
548                 if (!here->e_value_block && here->e_value_size) {
549                         char *first_val = (char *)header + min_offs;
550                         size_t offs = le16_to_cpu(here->e_value_offs);
551                         char *val = (char *)header + offs;
552                         size_t size = EXT2_XATTR_SIZE(
553                                 le32_to_cpu(here->e_value_size));
554
555                         if (size == EXT2_XATTR_SIZE(value_len)) {
556                                 /* The old and the new value have the same
557                                    size. Just replace. */
558                                 here->e_value_size = cpu_to_le32(value_len);
559                                 memset(val + size - EXT2_XATTR_PAD, 0,
560                                        EXT2_XATTR_PAD); /* Clear pad bytes. */
561                                 memcpy(val, value, value_len);
562                                 goto skip_replace;
563                         }
564
565                         /* Remove the old value. */
566                         memmove(first_val + size, first_val, val - first_val);
567                         memset(first_val, 0, size);
568                         here->e_value_offs = 0;
569                         min_offs += size;
570
571                         /* Adjust all value offsets. */
572                         last = ENTRY(header+1);
573                         while (!IS_LAST_ENTRY(last)) {
574                                 size_t o = le16_to_cpu(last->e_value_offs);
575                                 if (!last->e_value_block && o < offs)
576                                         last->e_value_offs =
577                                                 cpu_to_le16(o + size);
578                                 last = EXT2_XATTR_NEXT(last);
579                         }
580                 }
581                 if (value == NULL) {
582                         /* Remove the old name. */
583                         size_t size = EXT2_XATTR_LEN(name_len);
584                         last = ENTRY((char *)last - size);
585                         memmove(here, (char*)here + size,
586                                 (char*)last - (char*)here);
587                         memset(last, 0, size);
588                 }
589         }
590
591         if (value != NULL) {
592                 /* Insert the new value. */
593                 here->e_value_size = cpu_to_le32(value_len);
594                 if (value_len) {
595                         size_t size = EXT2_XATTR_SIZE(value_len);
596                         char *val = (char *)header + min_offs - size;
597                         here->e_value_offs =
598                                 cpu_to_le16((char *)val - (char *)header);
599                         memset(val + size - EXT2_XATTR_PAD, 0,
600                                EXT2_XATTR_PAD); /* Clear the pad bytes. */
601                         memcpy(val, value, value_len);
602                 }
603         }
604
605 skip_replace:
606         if (IS_LAST_ENTRY(ENTRY(header+1))) {
607                 /* This block is now empty. */
608                 if (bh && header == HDR(bh))
609                         unlock_buffer(bh);  /* we were modifying in-place. */
610                 error = ext2_xattr_set2(inode, bh, NULL);
611         } else {
612                 ext2_xattr_rehash(header, here);
613                 if (bh && header == HDR(bh))
614                         unlock_buffer(bh);  /* we were modifying in-place. */
615                 error = ext2_xattr_set2(inode, bh, header);
616         }
617
618 cleanup:
619         brelse(bh);
620         if (!(bh && header == HDR(bh)))
621                 kfree(header);
622         up_write(&EXT2_I(inode)->xattr_sem);
623
624         return error;
625 }
626
627 /*
628  * Second half of ext2_xattr_set(): Update the file system.
629  */
630 static int
631 ext2_xattr_set2(struct inode *inode, struct buffer_head *old_bh,
632                 struct ext2_xattr_header *header)
633 {
634         struct super_block *sb = inode->i_sb;
635         struct buffer_head *new_bh = NULL;
636         int error;
637
638         if (header) {
639                 new_bh = ext2_xattr_cache_find(inode, header);
640                 if (new_bh) {
641                         /* We found an identical block in the cache. */
642                         if (new_bh == old_bh) {
643                                 ea_bdebug(new_bh, "keeping this block");
644                         } else {
645                                 /* The old block is released after updating
646                                    the inode.  */
647                                 ea_bdebug(new_bh, "reusing block");
648
649                                 error = dquot_alloc_block(inode, 1);
650                                 if (error) {
651                                         unlock_buffer(new_bh);
652                                         goto cleanup;
653                                 }
654                                 le32_add_cpu(&HDR(new_bh)->h_refcount, 1);
655                                 ea_bdebug(new_bh, "refcount now=%d",
656                                         le32_to_cpu(HDR(new_bh)->h_refcount));
657                         }
658                         unlock_buffer(new_bh);
659                 } else if (old_bh && header == HDR(old_bh)) {
660                         /* Keep this block. No need to lock the block as we
661                            don't need to change the reference count. */
662                         new_bh = old_bh;
663                         get_bh(new_bh);
664                         ext2_xattr_cache_insert(new_bh);
665                 } else {
666                         /* We need to allocate a new block */
667                         ext2_fsblk_t goal = ext2_group_first_block_no(sb,
668                                                 EXT2_I(inode)->i_block_group);
669                         int block = ext2_new_block(inode, goal, &error);
670                         if (error)
671                                 goto cleanup;
672                         ea_idebug(inode, "creating block %d", block);
673
674                         new_bh = sb_getblk(sb, block);
675                         if (!new_bh) {
676                                 ext2_free_blocks(inode, block, 1);
677                                 mark_inode_dirty(inode);
678                                 error = -EIO;
679                                 goto cleanup;
680                         }
681                         lock_buffer(new_bh);
682                         memcpy(new_bh->b_data, header, new_bh->b_size);
683                         set_buffer_uptodate(new_bh);
684                         unlock_buffer(new_bh);
685                         ext2_xattr_cache_insert(new_bh);
686                         
687                         ext2_xattr_update_super_block(sb);
688                 }
689                 mark_buffer_dirty(new_bh);
690                 if (IS_SYNC(inode)) {
691                         sync_dirty_buffer(new_bh);
692                         error = -EIO;
693                         if (buffer_req(new_bh) && !buffer_uptodate(new_bh))
694                                 goto cleanup;
695                 }
696         }
697
698         /* Update the inode. */
699         EXT2_I(inode)->i_file_acl = new_bh ? new_bh->b_blocknr : 0;
700         inode->i_ctime = CURRENT_TIME_SEC;
701         if (IS_SYNC(inode)) {
702                 error = ext2_sync_inode (inode);
703                 /* In case sync failed due to ENOSPC the inode was actually
704                  * written (only some dirty data were not) so we just proceed
705                  * as if nothing happened and cleanup the unused block */
706                 if (error && error != -ENOSPC) {
707                         if (new_bh && new_bh != old_bh) {
708                                 dquot_free_block_nodirty(inode, 1);
709                                 mark_inode_dirty(inode);
710                         }
711                         goto cleanup;
712                 }
713         } else
714                 mark_inode_dirty(inode);
715
716         error = 0;
717         if (old_bh && old_bh != new_bh) {
718                 struct mb_cache_entry *ce;
719
720                 /*
721                  * If there was an old block and we are no longer using it,
722                  * release the old block.
723                  */
724                 ce = mb_cache_entry_get(ext2_xattr_cache, old_bh->b_bdev,
725                                         old_bh->b_blocknr);
726                 lock_buffer(old_bh);
727                 if (HDR(old_bh)->h_refcount == cpu_to_le32(1)) {
728                         /* Free the old block. */
729                         if (ce)
730                                 mb_cache_entry_free(ce);
731                         ea_bdebug(old_bh, "freeing");
732                         ext2_free_blocks(inode, old_bh->b_blocknr, 1);
733                         mark_inode_dirty(inode);
734                         /* We let our caller release old_bh, so we
735                          * need to duplicate the buffer before. */
736                         get_bh(old_bh);
737                         bforget(old_bh);
738                 } else {
739                         /* Decrement the refcount only. */
740                         le32_add_cpu(&HDR(old_bh)->h_refcount, -1);
741                         if (ce)
742                                 mb_cache_entry_release(ce);
743                         dquot_free_block_nodirty(inode, 1);
744                         mark_inode_dirty(inode);
745                         mark_buffer_dirty(old_bh);
746                         ea_bdebug(old_bh, "refcount now=%d",
747                                 le32_to_cpu(HDR(old_bh)->h_refcount));
748                 }
749                 unlock_buffer(old_bh);
750         }
751
752 cleanup:
753         brelse(new_bh);
754
755         return error;
756 }
757
758 /*
759  * ext2_xattr_delete_inode()
760  *
761  * Free extended attribute resources associated with this inode. This
762  * is called immediately before an inode is freed.
763  */
764 void
765 ext2_xattr_delete_inode(struct inode *inode)
766 {
767         struct buffer_head *bh = NULL;
768         struct mb_cache_entry *ce;
769
770         down_write(&EXT2_I(inode)->xattr_sem);
771         if (!EXT2_I(inode)->i_file_acl)
772                 goto cleanup;
773         bh = sb_bread(inode->i_sb, EXT2_I(inode)->i_file_acl);
774         if (!bh) {
775                 ext2_error(inode->i_sb, "ext2_xattr_delete_inode",
776                         "inode %ld: block %d read error", inode->i_ino,
777                         EXT2_I(inode)->i_file_acl);
778                 goto cleanup;
779         }
780         ea_bdebug(bh, "b_count=%d", atomic_read(&(bh->b_count)));
781         if (HDR(bh)->h_magic != cpu_to_le32(EXT2_XATTR_MAGIC) ||
782             HDR(bh)->h_blocks != cpu_to_le32(1)) {
783                 ext2_error(inode->i_sb, "ext2_xattr_delete_inode",
784                         "inode %ld: bad block %d", inode->i_ino,
785                         EXT2_I(inode)->i_file_acl);
786                 goto cleanup;
787         }
788         ce = mb_cache_entry_get(ext2_xattr_cache, bh->b_bdev, bh->b_blocknr);
789         lock_buffer(bh);
790         if (HDR(bh)->h_refcount == cpu_to_le32(1)) {
791                 if (ce)
792                         mb_cache_entry_free(ce);
793                 ext2_free_blocks(inode, EXT2_I(inode)->i_file_acl, 1);
794                 get_bh(bh);
795                 bforget(bh);
796                 unlock_buffer(bh);
797         } else {
798                 le32_add_cpu(&HDR(bh)->h_refcount, -1);
799                 if (ce)
800                         mb_cache_entry_release(ce);
801                 ea_bdebug(bh, "refcount now=%d",
802                         le32_to_cpu(HDR(bh)->h_refcount));
803                 unlock_buffer(bh);
804                 mark_buffer_dirty(bh);
805                 if (IS_SYNC(inode))
806                         sync_dirty_buffer(bh);
807                 dquot_free_block_nodirty(inode, 1);
808         }
809         EXT2_I(inode)->i_file_acl = 0;
810
811 cleanup:
812         brelse(bh);
813         up_write(&EXT2_I(inode)->xattr_sem);
814 }
815
816 /*
817  * ext2_xattr_put_super()
818  *
819  * This is called when a file system is unmounted.
820  */
821 void
822 ext2_xattr_put_super(struct super_block *sb)
823 {
824         mb_cache_shrink(sb->s_bdev);
825 }
826
827
828 /*
829  * ext2_xattr_cache_insert()
830  *
831  * Create a new entry in the extended attribute cache, and insert
832  * it unless such an entry is already in the cache.
833  *
834  * Returns 0, or a negative error number on failure.
835  */
836 static int
837 ext2_xattr_cache_insert(struct buffer_head *bh)
838 {
839         __u32 hash = le32_to_cpu(HDR(bh)->h_hash);
840         struct mb_cache_entry *ce;
841         int error;
842
843         ce = mb_cache_entry_alloc(ext2_xattr_cache, GFP_NOFS);
844         if (!ce)
845                 return -ENOMEM;
846         error = mb_cache_entry_insert(ce, bh->b_bdev, bh->b_blocknr, hash);
847         if (error) {
848                 mb_cache_entry_free(ce);
849                 if (error == -EBUSY) {
850                         ea_bdebug(bh, "already in cache (%d cache entries)",
851                                 atomic_read(&ext2_xattr_cache->c_entry_count));
852                         error = 0;
853                 }
854         } else {
855                 ea_bdebug(bh, "inserting [%x] (%d cache entries)", (int)hash,
856                           atomic_read(&ext2_xattr_cache->c_entry_count));
857                 mb_cache_entry_release(ce);
858         }
859         return error;
860 }
861
862 /*
863  * ext2_xattr_cmp()
864  *
865  * Compare two extended attribute blocks for equality.
866  *
867  * Returns 0 if the blocks are equal, 1 if they differ, and
868  * a negative error number on errors.
869  */
870 static int
871 ext2_xattr_cmp(struct ext2_xattr_header *header1,
872                struct ext2_xattr_header *header2)
873 {
874         struct ext2_xattr_entry *entry1, *entry2;
875
876         entry1 = ENTRY(header1+1);
877         entry2 = ENTRY(header2+1);
878         while (!IS_LAST_ENTRY(entry1)) {
879                 if (IS_LAST_ENTRY(entry2))
880                         return 1;
881                 if (entry1->e_hash != entry2->e_hash ||
882                     entry1->e_name_index != entry2->e_name_index ||
883                     entry1->e_name_len != entry2->e_name_len ||
884                     entry1->e_value_size != entry2->e_value_size ||
885                     memcmp(entry1->e_name, entry2->e_name, entry1->e_name_len))
886                         return 1;
887                 if (entry1->e_value_block != 0 || entry2->e_value_block != 0)
888                         return -EIO;
889                 if (memcmp((char *)header1 + le16_to_cpu(entry1->e_value_offs),
890                            (char *)header2 + le16_to_cpu(entry2->e_value_offs),
891                            le32_to_cpu(entry1->e_value_size)))
892                         return 1;
893
894                 entry1 = EXT2_XATTR_NEXT(entry1);
895                 entry2 = EXT2_XATTR_NEXT(entry2);
896         }
897         if (!IS_LAST_ENTRY(entry2))
898                 return 1;
899         return 0;
900 }
901
902 /*
903  * ext2_xattr_cache_find()
904  *
905  * Find an identical extended attribute block.
906  *
907  * Returns a locked buffer head to the block found, or NULL if such
908  * a block was not found or an error occurred.
909  */
910 static struct buffer_head *
911 ext2_xattr_cache_find(struct inode *inode, struct ext2_xattr_header *header)
912 {
913         __u32 hash = le32_to_cpu(header->h_hash);
914         struct mb_cache_entry *ce;
915
916         if (!header->h_hash)
917                 return NULL;  /* never share */
918         ea_idebug(inode, "looking for cached blocks [%x]", (int)hash);
919 again:
920         ce = mb_cache_entry_find_first(ext2_xattr_cache, inode->i_sb->s_bdev,
921                                        hash);
922         while (ce) {
923                 struct buffer_head *bh;
924
925                 if (IS_ERR(ce)) {
926                         if (PTR_ERR(ce) == -EAGAIN)
927                                 goto again;
928                         break;
929                 }
930
931                 bh = sb_bread(inode->i_sb, ce->e_block);
932                 if (!bh) {
933                         ext2_error(inode->i_sb, "ext2_xattr_cache_find",
934                                 "inode %ld: block %ld read error",
935                                 inode->i_ino, (unsigned long) ce->e_block);
936                 } else {
937                         lock_buffer(bh);
938                         if (le32_to_cpu(HDR(bh)->h_refcount) >
939                                    EXT2_XATTR_REFCOUNT_MAX) {
940                                 ea_idebug(inode, "block %ld refcount %d>%d",
941                                           (unsigned long) ce->e_block,
942                                           le32_to_cpu(HDR(bh)->h_refcount),
943                                           EXT2_XATTR_REFCOUNT_MAX);
944                         } else if (!ext2_xattr_cmp(header, HDR(bh))) {
945                                 ea_bdebug(bh, "b_count=%d",
946                                           atomic_read(&(bh->b_count)));
947                                 mb_cache_entry_release(ce);
948                                 return bh;
949                         }
950                         unlock_buffer(bh);
951                         brelse(bh);
952                 }
953                 ce = mb_cache_entry_find_next(ce, inode->i_sb->s_bdev, hash);
954         }
955         return NULL;
956 }
957
958 #define NAME_HASH_SHIFT 5
959 #define VALUE_HASH_SHIFT 16
960
961 /*
962  * ext2_xattr_hash_entry()
963  *
964  * Compute the hash of an extended attribute.
965  */
966 static inline void ext2_xattr_hash_entry(struct ext2_xattr_header *header,
967                                          struct ext2_xattr_entry *entry)
968 {
969         __u32 hash = 0;
970         char *name = entry->e_name;
971         int n;
972
973         for (n=0; n < entry->e_name_len; n++) {
974                 hash = (hash << NAME_HASH_SHIFT) ^
975                        (hash >> (8*sizeof(hash) - NAME_HASH_SHIFT)) ^
976                        *name++;
977         }
978
979         if (entry->e_value_block == 0 && entry->e_value_size != 0) {
980                 __le32 *value = (__le32 *)((char *)header +
981                         le16_to_cpu(entry->e_value_offs));
982                 for (n = (le32_to_cpu(entry->e_value_size) +
983                      EXT2_XATTR_ROUND) >> EXT2_XATTR_PAD_BITS; n; n--) {
984                         hash = (hash << VALUE_HASH_SHIFT) ^
985                                (hash >> (8*sizeof(hash) - VALUE_HASH_SHIFT)) ^
986                                le32_to_cpu(*value++);
987                 }
988         }
989         entry->e_hash = cpu_to_le32(hash);
990 }
991
992 #undef NAME_HASH_SHIFT
993 #undef VALUE_HASH_SHIFT
994
995 #define BLOCK_HASH_SHIFT 16
996
997 /*
998  * ext2_xattr_rehash()
999  *
1000  * Re-compute the extended attribute hash value after an entry has changed.
1001  */
1002 static void ext2_xattr_rehash(struct ext2_xattr_header *header,
1003                               struct ext2_xattr_entry *entry)
1004 {
1005         struct ext2_xattr_entry *here;
1006         __u32 hash = 0;
1007         
1008         ext2_xattr_hash_entry(header, entry);
1009         here = ENTRY(header+1);
1010         while (!IS_LAST_ENTRY(here)) {
1011                 if (!here->e_hash) {
1012                         /* Block is not shared if an entry's hash value == 0 */
1013                         hash = 0;
1014                         break;
1015                 }
1016                 hash = (hash << BLOCK_HASH_SHIFT) ^
1017                        (hash >> (8*sizeof(hash) - BLOCK_HASH_SHIFT)) ^
1018                        le32_to_cpu(here->e_hash);
1019                 here = EXT2_XATTR_NEXT(here);
1020         }
1021         header->h_hash = cpu_to_le32(hash);
1022 }
1023
1024 #undef BLOCK_HASH_SHIFT
1025
1026 int __init
1027 init_ext2_xattr(void)
1028 {
1029         ext2_xattr_cache = mb_cache_create("ext2_xattr", 6);
1030         if (!ext2_xattr_cache)
1031                 return -ENOMEM;
1032         return 0;
1033 }
1034
1035 void
1036 exit_ext2_xattr(void)
1037 {
1038         mb_cache_destroy(ext2_xattr_cache);
1039 }