Line data Source code
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 1 : static struct mb_cache *ext2_xattr_cache;
103 :
104 1 : static 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 1 : 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 struct xattr_handler *
130 : ext2_xattr_handler(int name_index)
131 : {
132 8 : struct xattr_handler *handler = NULL;
133 :
134 8 : if (name_index > 0 && name_index < ARRAY_SIZE(ext2_xattr_handler_map))
135 4 : handler = ext2_xattr_handler_map[name_index];
136 4 : 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 8 : struct buffer_head *bh = NULL;
154 4 : struct ext2_xattr_entry *entry;
155 4 : size_t name_len, size;
156 4 : char *end;
157 4 : int error;
158 4 :
159 4 : ea_idebug(inode, "name=%d.%s, buffer=%p, buffer_size=%ld",
160 4 : name_index, name, buffer, (long)buffer_size);
161 4 :
162 12 : if (name == NULL)
163 8 : return -EINVAL;
164 16 : down_read(&EXT2_I(inode)->xattr_sem);
165 8 : error = -ENODATA;
166 20 : if (!EXT2_I(inode)->i_file_acl)
167 8 : goto cleanup;
168 4 : ea_idebug(inode, "reading block %d", EXT2_I(inode)->i_file_acl);
169 20 : bh = sb_bread(inode->i_sb, EXT2_I(inode)->i_file_acl);
170 4 : error = -EIO;
171 8 : if (!bh)
172 4 : 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 4 : end = bh->b_data + bh->b_size;
176 24 : if (HDR(bh)->h_magic != cpu_to_le32(EXT2_XATTR_MAGIC) ||
177 4 : HDR(bh)->h_blocks != cpu_to_le32(1)) {
178 36 : 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 4 : error = -EIO;
182 4 : goto cleanup;
183 : }
184 : /* find named attribute */
185 4 : name_len = strlen(name);
186 :
187 4 : error = -ERANGE;
188 8 : if (name_len > 255)
189 4 : goto cleanup;
190 4 : entry = FIRST_ENTRY(bh);
191 12 : while (!IS_LAST_ENTRY(entry)) {
192 12 : struct ext2_xattr_entry *next =
193 4 : EXT2_XATTR_NEXT(entry);
194 8 : if ((char *)next >= end)
195 4 : goto bad_block;
196 36 : if (name_index == entry->e_name_index &&
197 : name_len == entry->e_name_len &&
198 : memcmp(name, entry->e_name, name_len) == 0)
199 4 : goto found;
200 4 : entry = next;
201 4 : }
202 : /* Check the remaining name entries */
203 12 : while (!IS_LAST_ENTRY(entry)) {
204 12 : struct ext2_xattr_entry *next =
205 4 : EXT2_XATTR_NEXT(entry);
206 8 : if ((char *)next >= end)
207 4 : goto bad_block;
208 4 : entry = next;
209 4 : }
210 8 : if (ext2_xattr_cache_insert(bh))
211 : ea_idebug(inode, "cache insert failed");
212 4 : error = -ENODATA;
213 4 : goto cleanup;
214 4 : found:
215 : /* check the buffer size */
216 8 : if (entry->e_value_block != 0)
217 4 : goto bad_block;
218 8 : size = le32_to_cpu(entry->e_value_size);
219 20 : if (size > inode->i_sb->s_blocksize ||
220 : le16_to_cpu(entry->e_value_offs) + size > inode->i_sb->s_blocksize)
221 4 : goto bad_block;
222 :
223 8 : if (ext2_xattr_cache_insert(bh))
224 : ea_idebug(inode, "cache insert failed");
225 8 : if (buffer) {
226 4 : error = -ERANGE;
227 8 : if (size > buffer_size)
228 4 : goto cleanup;
229 : /* return value of attribute */
230 8 : memcpy(buffer, bh->b_data + le16_to_cpu(entry->e_value_offs),
231 : size);
232 : }
233 4 : error = size;
234 4 :
235 : cleanup:
236 40 : brelse(bh);
237 12 : up_read(&EXT2_I(inode)->xattr_sem);
238 :
239 4 : 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 8 : struct inode *inode = dentry->d_inode;
256 8 : struct buffer_head *bh = NULL;
257 4 : struct ext2_xattr_entry *entry;
258 4 : char *end;
259 8 : size_t rest = buffer_size;
260 4 : int error;
261 4 :
262 4 : ea_idebug(inode, "buffer=%p, buffer_size=%ld",
263 4 : buffer, (long)buffer_size);
264 4 :
265 16 : down_read(&EXT2_I(inode)->xattr_sem);
266 8 : error = 0;
267 20 : if (!EXT2_I(inode)->i_file_acl)
268 8 : goto cleanup;
269 4 : ea_idebug(inode, "reading block %d", EXT2_I(inode)->i_file_acl);
270 24 : bh = sb_bread(inode->i_sb, EXT2_I(inode)->i_file_acl);
271 8 : error = -EIO;
272 8 : if (!bh)
273 4 : 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 4 : end = bh->b_data + bh->b_size;
277 24 : if (HDR(bh)->h_magic != cpu_to_le32(EXT2_XATTR_MAGIC) ||
278 4 : HDR(bh)->h_blocks != cpu_to_le32(1)) {
279 28 : 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 4 : error = -EIO;
283 4 : goto cleanup;
284 : }
285 :
286 : /* check the on-disk data structure */
287 4 : entry = FIRST_ENTRY(bh);
288 12 : while (!IS_LAST_ENTRY(entry)) {
289 12 : struct ext2_xattr_entry *next = EXT2_XATTR_NEXT(entry);
290 4 :
291 8 : if ((char *)next >= end)
292 4 : goto bad_block;
293 4 : entry = next;
294 4 : }
295 8 : if (ext2_xattr_cache_insert(bh))
296 : ea_idebug(inode, "cache insert failed");
297 :
298 : /* list the attribute names */
299 16 : for (entry = FIRST_ENTRY(bh); !IS_LAST_ENTRY(entry);
300 12 : entry = EXT2_XATTR_NEXT(entry)) {
301 24 : struct xattr_handler *handler =
302 : ext2_xattr_handler(entry->e_name_index);
303 :
304 8 : if (handler) {
305 24 : size_t size = handler->list(dentry, buffer, rest,
306 : entry->e_name,
307 : entry->e_name_len,
308 : handler->flags);
309 8 : if (buffer) {
310 8 : if (size > rest) {
311 4 : error = -ERANGE;
312 4 : goto cleanup;
313 : }
314 4 : buffer += size;
315 : }
316 4 : rest -= size;
317 : }
318 : }
319 4 : error = buffer_size - rest; /* total size */
320 4 :
321 : cleanup:
322 40 : brelse(bh);
323 12 : up_read(&EXT2_I(inode)->xattr_sem);
324 :
325 4 : 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 16 : 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 500 : if (EXT2_HAS_COMPAT_FEATURE(sb, EXT2_FEATURE_COMPAT_EXT_ATTR))
346 200 : return;
347 100 :
348 300 : EXT2_SET_COMPAT_FEATURE(sb, EXT2_FEATURE_COMPAT_EXT_ATTR);
349 100 : sb->s_dirt = 1;
350 300 : mark_buffer_dirty(EXT2_SB(sb)->s_sbh);
351 100 : }
352 :
353 : /*
354 : * ext2_xattr_set()
355 : *
356 : * Create, replace or remove an extended attribute for this inode. Buffer
357 : * is NULL to remove an existing extended attribute, and non-NULL to
358 : * either replace an existing extended attribute, or create a new extended
359 : * attribute. The flags XATTR_REPLACE and XATTR_CREATE
360 : * specify that an extended attribute must exist and must not exist
361 : * previous to the call, respectively.
362 : *
363 : * Returns 0, or a negative error number on failure.
364 : */
365 : int
366 : ext2_xattr_set(struct inode *inode, int name_index, const char *name,
367 : const void *value, size_t value_len, int flags)
368 : {
369 40 : struct super_block *sb = inode->i_sb;
370 40 : struct buffer_head *bh = NULL;
371 40 : struct ext2_xattr_header *header = NULL;
372 20 : struct ext2_xattr_entry *here, *last;
373 40 : size_t name_len, free, min_offs = sb->s_blocksize;
374 40 : int not_found = 1, error;
375 20 : char *end;
376 20 :
377 20 : /*
378 20 : * header -- Points either into bh, or to a temporarily
379 20 : * allocated buffer.
380 20 : * here -- The named entry found, or the place for inserting, within
381 20 : * the block pointed to by header.
382 20 : * last -- Points right after the last named entry within the block
383 20 : * pointed to by header.
384 20 : * min_offs -- The offset of the first value (values are aligned
385 20 : * towards the end of the block).
386 20 : * end -- Points right after the block pointed to by header.
387 20 : */
388 20 :
389 20 : ea_idebug(inode, "name=%d.%s, value=%p, value_len=%ld",
390 20 : name_index, name, value, (long)value_len);
391 20 :
392 60 : if (value == NULL)
393 40 : value_len = 0;
394 60 : if (name == NULL)
395 40 : return -EINVAL;
396 40 : name_len = strlen(name);
397 100 : if (name_len > 255 || value_len > sb->s_blocksize)
398 40 : return -ERANGE;
399 80 : down_write(&EXT2_I(inode)->xattr_sem);
400 100 : if (EXT2_I(inode)->i_file_acl) {
401 20 : /* The inode already has an extended attribute block. */
402 120 : bh = sb_bread(sb, EXT2_I(inode)->i_file_acl);
403 40 : error = -EIO;
404 60 : if (!bh)
405 20 : goto cleanup;
406 : ea_bdebug(bh, "b_count=%d, refcount=%d",
407 : atomic_read(&(bh->b_count)),
408 : le32_to_cpu(HDR(bh)->h_refcount));
409 40 : header = HDR(bh);
410 20 : end = bh->b_data + bh->b_size;
411 80 : if (header->h_magic != cpu_to_le32(EXT2_XATTR_MAGIC) ||
412 20 : header->h_blocks != cpu_to_le32(1)) {
413 220 : bad_block: ext2_error(sb, "ext2_xattr_set",
414 : "inode %ld: bad block %d", inode->i_ino,
415 : EXT2_I(inode)->i_file_acl);
416 20 : error = -EIO;
417 20 : goto cleanup;
418 : }
419 : /* Find the named attribute. */
420 20 : here = FIRST_ENTRY(bh);
421 60 : while (!IS_LAST_ENTRY(here)) {
422 60 : struct ext2_xattr_entry *next = EXT2_XATTR_NEXT(here);
423 60 : if ((char *)next >= end)
424 20 : goto bad_block;
425 80 : if (!here->e_value_block && here->e_value_size) {
426 40 : size_t offs = le16_to_cpu(here->e_value_offs);
427 60 : if (offs < min_offs)
428 20 : min_offs = offs;
429 : }
430 40 : not_found = name_index - here->e_name_index;
431 40 : if (!not_found)
432 40 : not_found = name_len - here->e_name_len;
433 40 : if (!not_found)
434 20 : not_found = memcmp(name, here->e_name,name_len);
435 40 : if (not_found <= 0)
436 20 : break;
437 20 : here = next;
438 20 : }
439 20 : last = here;
440 : /* We still need to compute min_offs and last. */
441 60 : while (!IS_LAST_ENTRY(last)) {
442 60 : struct ext2_xattr_entry *next = EXT2_XATTR_NEXT(last);
443 60 : if ((char *)next >= end)
444 20 : goto bad_block;
445 80 : if (!last->e_value_block && last->e_value_size) {
446 40 : size_t offs = le16_to_cpu(last->e_value_offs);
447 40 : if (offs < min_offs)
448 20 : min_offs = offs;
449 : }
450 20 : last = next;
451 20 : }
452 :
453 : /* Check whether we have enough space left. */
454 20 : free = min_offs - ((char*)last - (char*)header) - sizeof(__u32);
455 : } else {
456 : /* We will use a new extended attribute block. */
457 20 : free = sb->s_blocksize -
458 : sizeof(struct ext2_xattr_header) - sizeof(__u32);
459 40 : here = last = NULL; /* avoid gcc uninitialized warning. */
460 : }
461 :
462 80 : if (not_found) {
463 : /* Request to remove a nonexistent attribute? */
464 40 : error = -ENODATA;
465 80 : if (flags & XATTR_REPLACE)
466 40 : goto cleanup;
467 40 : error = 0;
468 80 : if (value == NULL)
469 40 : goto cleanup;
470 : } else {
471 : /* Request to create an existing attribute? */
472 40 : error = -EEXIST;
473 80 : if (flags & XATTR_CREATE)
474 40 : goto cleanup;
475 160 : if (!here->e_value_block && here->e_value_size) {
476 80 : size_t size = le32_to_cpu(here->e_value_size);
477 :
478 200 : if (le16_to_cpu(here->e_value_offs) + size >
479 : sb->s_blocksize || size > sb->s_blocksize)
480 40 : goto bad_block;
481 40 : free += EXT2_XATTR_SIZE(size);
482 : }
483 40 : free += EXT2_XATTR_LEN(name_len);
484 : }
485 40 : error = -ENOSPC;
486 80 : if (free < EXT2_XATTR_LEN(name_len) + EXT2_XATTR_SIZE(value_len))
487 40 : goto cleanup;
488 :
489 : /* Here we know that we can set the new attribute. */
490 :
491 80 : if (header) {
492 : struct mb_cache_entry *ce;
493 :
494 : /* assert(header == HDR(bh)); */
495 40 : ce = mb_cache_entry_get(ext2_xattr_cache, bh->b_bdev,
496 : bh->b_blocknr);
497 80 : lock_buffer(bh);
498 40 : if (header->h_refcount == cpu_to_le32(1)) {
499 : ea_bdebug(bh, "modifying in-place");
500 40 : if (ce)
501 20 : mb_cache_entry_free(ce);
502 : /* keep the buffer locked while modifying it. */
503 : } else {
504 : int offset;
505 :
506 40 : if (ce)
507 20 : mb_cache_entry_release(ce);
508 20 : unlock_buffer(bh);
509 : ea_bdebug(bh, "cloning");
510 60 : header = kmalloc(bh->b_size, GFP_KERNEL);
511 20 : error = -ENOMEM;
512 40 : if (header == NULL)
513 20 : goto cleanup;
514 40 : memcpy(header, HDR(bh), bh->b_size);
515 20 : header->h_refcount = cpu_to_le32(1);
516 :
517 40 : offset = (char *)here - bh->b_data;
518 20 : here = ENTRY((char *)header + offset);
519 40 : offset = (char *)last - bh->b_data;
520 20 : last = ENTRY((char *)header + offset);
521 : }
522 : } else {
523 : /* Allocate a buffer where we construct the new block. */
524 100 : header = kzalloc(sb->s_blocksize, GFP_KERNEL);
525 20 : error = -ENOMEM;
526 40 : if (header == NULL)
527 20 : goto cleanup;
528 20 : end = (char *)header + sb->s_blocksize;
529 20 : header->h_magic = cpu_to_le32(EXT2_XATTR_MAGIC);
530 60 : header->h_blocks = header->h_refcount = cpu_to_le32(1);
531 40 : last = here = ENTRY(header+1);
532 : }
533 :
534 : /* Iff we are modifying the block in-place, bh is locked here. */
535 :
536 120 : if (not_found) {
537 : /* Insert the new name. */
538 60 : size_t size = EXT2_XATTR_LEN(name_len);
539 60 : size_t rest = (char *)last - (char *)here;
540 60 : memmove((char *)here + size, here, rest);
541 60 : memset(here, 0, size);
542 60 : here->e_name_index = name_index;
543 60 : here->e_name_len = name_len;
544 60 : memcpy(here->e_name, name, name_len);
545 : } else {
546 240 : if (!here->e_value_block && here->e_value_size) {
547 60 : char *first_val = (char *)header + min_offs;
548 120 : size_t offs = le16_to_cpu(here->e_value_offs);
549 60 : char *val = (char *)header + offs;
550 60 : size_t size = EXT2_XATTR_SIZE(
551 : le32_to_cpu(here->e_value_size));
552 :
553 120 : if (size == EXT2_XATTR_SIZE(value_len)) {
554 : /* The old and the new value have the same
555 : size. Just replace. */
556 60 : here->e_value_size = cpu_to_le32(value_len);
557 60 : memset(val + size - EXT2_XATTR_PAD, 0,
558 : EXT2_XATTR_PAD); /* Clear pad bytes. */
559 60 : memcpy(val, value, value_len);
560 60 : goto skip_replace;
561 : }
562 :
563 : /* Remove the old value. */
564 60 : memmove(first_val + size, first_val, val - first_val);
565 60 : memset(first_val, 0, size);
566 60 : here->e_value_offs = 0;
567 60 : min_offs += size;
568 :
569 : /* Adjust all value offsets. */
570 60 : last = ENTRY(header+1);
571 100 : while (!IS_LAST_ENTRY(last)) {
572 60 : size_t o = le16_to_cpu(last->e_value_offs);
573 100 : if (!last->e_value_block && o < offs)
574 20 : last->e_value_offs =
575 : cpu_to_le16(o + size);
576 40 : last = EXT2_XATTR_NEXT(last);
577 20 : }
578 : }
579 160 : if (value == NULL) {
580 : /* Remove the old name. */
581 80 : size_t size = EXT2_XATTR_LEN(name_len);
582 80 : last = ENTRY((char *)last - size);
583 80 : memmove(here, (char*)here + size,
584 : (char*)last - (char*)here);
585 80 : memset(last, 0, size);
586 : }
587 : }
588 :
589 160 : if (value != NULL) {
590 : /* Insert the new value. */
591 80 : here->e_value_size = cpu_to_le32(value_len);
592 160 : if (value_len) {
593 80 : size_t size = EXT2_XATTR_SIZE(value_len);
594 80 : char *val = (char *)header + min_offs - size;
595 80 : here->e_value_offs =
596 : cpu_to_le16((char *)val - (char *)header);
597 80 : memset(val + size - EXT2_XATTR_PAD, 0,
598 : EXT2_XATTR_PAD); /* Clear the pad bytes. */
599 80 : memcpy(val, value, value_len);
600 : }
601 : }
602 :
603 : skip_replace:
604 160 : if (IS_LAST_ENTRY(ENTRY(header+1))) {
605 : /* This block is now empty. */
606 400 : if (bh && header == HDR(bh))
607 160 : unlock_buffer(bh); /* we were modifying in-place. */
608 160 : error = ext2_xattr_set2(inode, bh, NULL);
609 : } else {
610 160 : ext2_xattr_rehash(header, here);
611 100 : if (bh && header == HDR(bh))
612 20 : unlock_buffer(bh); /* we were modifying in-place. */
613 40 : error = ext2_xattr_set2(inode, bh, header);
614 : }
615 :
616 40 : cleanup:
617 320 : brelse(bh);
618 100 : if (!(bh && header == HDR(bh)))
619 20 : kfree(header);
620 60 : up_write(&EXT2_I(inode)->xattr_sem);
621 :
622 20 : return error;
623 : }
624 :
625 : /*
626 : * Second half of ext2_xattr_set(): Update the file system.
627 : */
628 : static int
629 : ext2_xattr_set2(struct inode *inode, struct buffer_head *old_bh,
630 : struct ext2_xattr_header *header)
631 100 : {
632 200 : struct super_block *sb = inode->i_sb;
633 200 : struct buffer_head *new_bh = NULL;
634 100 : int error;
635 100 :
636 300 : if (header) {
637 600 : new_bh = ext2_xattr_cache_find(inode, header);
638 300 : if (new_bh) {
639 100 : /* We found an identical block in the cache. */
640 300 : if (new_bh == old_bh) {
641 100 : ea_bdebug(new_bh, "keeping this block");
642 100 : } else {
643 100 : /* The old block is released after updating
644 100 : the inode. */
645 100 : ea_bdebug(new_bh, "reusing block");
646 :
647 100 : error = -EDQUOT;
648 400 : if (vfs_dq_alloc_block(inode, 1)) {
649 100 : unlock_buffer(new_bh);
650 100 : goto cleanup;
651 : }
652 300 : le32_add_cpu(&HDR(new_bh)->h_refcount, 1);
653 : ea_bdebug(new_bh, "refcount now=%d",
654 : le32_to_cpu(HDR(new_bh)->h_refcount));
655 : }
656 200 : unlock_buffer(new_bh);
657 500 : } else if (old_bh && header == HDR(old_bh)) {
658 : /* Keep this block. No need to lock the block as we
659 : don't need to change the reference count. */
660 100 : new_bh = old_bh;
661 200 : get_bh(new_bh);
662 200 : ext2_xattr_cache_insert(new_bh);
663 : } else {
664 : /* We need to allocate a new block */
665 600 : ext2_fsblk_t goal = ext2_group_first_block_no(sb,
666 : EXT2_I(inode)->i_block_group);
667 300 : int block = ext2_new_block(inode, goal, &error);
668 200 : if (error)
669 100 : goto cleanup;
670 : ea_idebug(inode, "creating block %d", block);
671 :
672 200 : new_bh = sb_getblk(sb, block);
673 200 : if (!new_bh) {
674 200 : ext2_free_blocks(inode, block, 1);
675 100 : error = -EIO;
676 100 : goto cleanup;
677 : }
678 200 : lock_buffer(new_bh);
679 200 : memcpy(new_bh->b_data, header, new_bh->b_size);
680 200 : set_buffer_uptodate(new_bh);
681 100 : unlock_buffer(new_bh);
682 200 : ext2_xattr_cache_insert(new_bh);
683 :
684 300 : ext2_xattr_update_super_block(sb);
685 : }
686 400 : mark_buffer_dirty(new_bh);
687 2000 : if (IS_SYNC(inode)) {
688 400 : sync_dirty_buffer(new_bh);
689 400 : error = -EIO;
690 1400 : if (buffer_req(new_bh) && !buffer_uptodate(new_bh))
691 100 : goto cleanup;
692 : }
693 : }
694 :
695 : /* Update the inode. */
696 2100 : EXT2_I(inode)->i_file_acl = new_bh ? new_bh->b_blocknr : 0;
697 400 : inode->i_ctime = CURRENT_TIME_SEC;
698 500 : if (IS_SYNC(inode)) {
699 200 : error = ext2_sync_inode (inode);
700 : /* In case sync failed due to ENOSPC the inode was actually
701 : * written (only some dirty data were not) so we just proceed
702 : * as if nothing happened and cleanup the unused block */
703 400 : if (error && error != -ENOSPC) {
704 400 : if (new_bh && new_bh != old_bh)
705 200 : vfs_dq_free_block(inode, 1);
706 200 : goto cleanup;
707 : }
708 : } else
709 200 : mark_inode_dirty(inode);
710 :
711 200 : error = 0;
712 800 : if (old_bh && old_bh != new_bh) {
713 : struct mb_cache_entry *ce;
714 :
715 : /*
716 : * If there was an old block and we are no longer using it,
717 : * release the old block.
718 : */
719 200 : ce = mb_cache_entry_get(ext2_xattr_cache, old_bh->b_bdev,
720 : old_bh->b_blocknr);
721 400 : lock_buffer(old_bh);
722 300 : if (HDR(old_bh)->h_refcount == cpu_to_le32(1)) {
723 : /* Free the old block. */
724 200 : if (ce)
725 100 : mb_cache_entry_free(ce);
726 : ea_bdebug(old_bh, "freeing");
727 200 : ext2_free_blocks(inode, old_bh->b_blocknr, 1);
728 : /* We let our caller release old_bh, so we
729 : * need to duplicate the buffer before. */
730 200 : get_bh(old_bh);
731 200 : bforget(old_bh);
732 : } else {
733 : /* Decrement the refcount only. */
734 300 : le32_add_cpu(&HDR(old_bh)->h_refcount, -1);
735 200 : if (ce)
736 100 : mb_cache_entry_release(ce);
737 200 : vfs_dq_free_block(inode, 1);
738 100 : mark_buffer_dirty(old_bh);
739 : ea_bdebug(old_bh, "refcount now=%d",
740 : le32_to_cpu(HDR(old_bh)->h_refcount));
741 : }
742 200 : unlock_buffer(old_bh);
743 : }
744 :
745 : cleanup:
746 1800 : brelse(new_bh);
747 400 :
748 100 : return error;
749 : }
750 :
751 : /*
752 : * ext2_xattr_delete_inode()
753 : *
754 : * Free extended attribute resources associated with this inode. This
755 : * is called immediately before an inode is freed.
756 : */
757 : void
758 : ext2_xattr_delete_inode(struct inode *inode)
759 : {
760 4 : struct buffer_head *bh = NULL;
761 2 : struct mb_cache_entry *ce;
762 2 :
763 8 : down_write(&EXT2_I(inode)->xattr_sem);
764 10 : if (!EXT2_I(inode)->i_file_acl)
765 4 : goto cleanup;
766 12 : bh = sb_bread(inode->i_sb, EXT2_I(inode)->i_file_acl);
767 6 : if (!bh) {
768 12 : ext2_error(inode->i_sb, "ext2_xattr_delete_inode",
769 2 : "inode %ld: block %d read error", inode->i_ino,
770 : EXT2_I(inode)->i_file_acl);
771 2 : goto cleanup;
772 : }
773 : ea_bdebug(bh, "b_count=%d", atomic_read(&(bh->b_count)));
774 12 : if (HDR(bh)->h_magic != cpu_to_le32(EXT2_XATTR_MAGIC) ||
775 : HDR(bh)->h_blocks != cpu_to_le32(1)) {
776 10 : ext2_error(inode->i_sb, "ext2_xattr_delete_inode",
777 : "inode %ld: bad block %d", inode->i_ino,
778 : EXT2_I(inode)->i_file_acl);
779 2 : goto cleanup;
780 : }
781 2 : ce = mb_cache_entry_get(ext2_xattr_cache, bh->b_bdev, bh->b_blocknr);
782 4 : lock_buffer(bh);
783 6 : if (HDR(bh)->h_refcount == cpu_to_le32(1)) {
784 4 : if (ce)
785 2 : mb_cache_entry_free(ce);
786 10 : ext2_free_blocks(inode, EXT2_I(inode)->i_file_acl, 1);
787 4 : get_bh(bh);
788 4 : bforget(bh);
789 2 : unlock_buffer(bh);
790 : } else {
791 6 : le32_add_cpu(&HDR(bh)->h_refcount, -1);
792 4 : if (ce)
793 2 : mb_cache_entry_release(ce);
794 : ea_bdebug(bh, "refcount now=%d",
795 : le32_to_cpu(HDR(bh)->h_refcount));
796 2 : unlock_buffer(bh);
797 2 : mark_buffer_dirty(bh);
798 10 : if (IS_SYNC(inode))
799 2 : sync_dirty_buffer(bh);
800 4 : vfs_dq_free_block(inode, 1);
801 : }
802 10 : EXT2_I(inode)->i_file_acl = 0;
803 :
804 2 : cleanup:
805 16 : brelse(bh);
806 6 : up_write(&EXT2_I(inode)->xattr_sem);
807 2 : }
808 :
809 : /*
810 : * ext2_xattr_put_super()
811 : *
812 : * This is called when a file system is unmounted.
813 : */
814 : void
815 : ext2_xattr_put_super(struct super_block *sb)
816 : {
817 2 : mb_cache_shrink(sb->s_bdev);
818 2 : }
819 :
820 :
821 : /*
822 : * ext2_xattr_cache_insert()
823 : *
824 : * Create a new entry in the extended attribute cache, and insert
825 : * it unless such an entry is already in the cache.
826 : *
827 : * Returns 0, or a negative error number on failure.
828 : */
829 : static int
830 : ext2_xattr_cache_insert(struct buffer_head *bh)
831 : {
832 636 : __u32 hash = le32_to_cpu(HDR(bh)->h_hash);
833 212 : struct mb_cache_entry *ce;
834 212 : int error;
835 :
836 212 : ce = mb_cache_entry_alloc(ext2_xattr_cache, GFP_NOFS);
837 424 : if (!ce)
838 212 : return -ENOMEM;
839 212 : error = mb_cache_entry_insert(ce, bh->b_bdev, bh->b_blocknr, &hash);
840 424 : if (error) {
841 212 : mb_cache_entry_free(ce);
842 424 : if (error == -EBUSY) {
843 : ea_bdebug(bh, "already in cache (%d cache entries)",
844 : atomic_read(&ext2_xattr_cache->c_entry_count));
845 212 : error = 0;
846 : }
847 : } else {
848 : ea_bdebug(bh, "inserting [%x] (%d cache entries)", (int)hash,
849 : atomic_read(&ext2_xattr_cache->c_entry_count));
850 212 : mb_cache_entry_release(ce);
851 : }
852 212 : return error;
853 : }
854 :
855 : /*
856 : * ext2_xattr_cmp()
857 : *
858 : * Compare two extended attribute blocks for equality.
859 : *
860 : * Returns 0 if the blocks are equal, 1 if they differ, and
861 : * a negative error number on errors.
862 : */
863 : static int
864 : ext2_xattr_cmp(struct ext2_xattr_header *header1,
865 : struct ext2_xattr_header *header2)
866 100 : {
867 100 : struct ext2_xattr_entry *entry1, *entry2;
868 100 :
869 200 : entry1 = ENTRY(header1+1);
870 100 : entry2 = ENTRY(header2+1);
871 300 : while (!IS_LAST_ENTRY(entry1)) {
872 300 : if (IS_LAST_ENTRY(entry2))
873 200 : return 1;
874 1000 : if (entry1->e_hash != entry2->e_hash ||
875 : entry1->e_name_index != entry2->e_name_index ||
876 : entry1->e_name_len != entry2->e_name_len ||
877 : entry1->e_value_size != entry2->e_value_size ||
878 : memcmp(entry1->e_name, entry2->e_name, entry1->e_name_len))
879 200 : return 1;
880 400 : if (entry1->e_value_block != 0 || entry2->e_value_block != 0)
881 100 : return -EIO;
882 600 : if (memcmp((char *)header1 + le16_to_cpu(entry1->e_value_offs),
883 : (char *)header2 + le16_to_cpu(entry2->e_value_offs),
884 : le32_to_cpu(entry1->e_value_size)))
885 100 : return 1;
886 :
887 200 : entry1 = EXT2_XATTR_NEXT(entry1);
888 200 : entry2 = EXT2_XATTR_NEXT(entry2);
889 100 : }
890 200 : if (!IS_LAST_ENTRY(entry2))
891 100 : return 1;
892 100 : return 0;
893 : }
894 :
895 : /*
896 : * ext2_xattr_cache_find()
897 : *
898 : * Find an identical extended attribute block.
899 : *
900 : * Returns a locked buffer head to the block found, or NULL if such
901 : * a block was not found or an error occurred.
902 : */
903 : static struct buffer_head *
904 : ext2_xattr_cache_find(struct inode *inode, struct ext2_xattr_header *header)
905 : {
906 200 : __u32 hash = le32_to_cpu(header->h_hash);
907 100 : struct mb_cache_entry *ce;
908 100 :
909 300 : if (!header->h_hash)
910 200 : return NULL; /* never share */
911 100 : ea_idebug(inode, "looking for cached blocks [%x]", (int)hash);
912 : again:
913 100 : ce = mb_cache_entry_find_first(ext2_xattr_cache, 0,
914 100 : inode->i_sb->s_bdev, hash);
915 300 : while (ce) {
916 100 : struct buffer_head *bh;
917 100 :
918 400 : if (IS_ERR(ce)) {
919 400 : if (PTR_ERR(ce) == -EAGAIN)
920 100 : goto again;
921 200 : break;
922 : }
923 :
924 200 : bh = sb_bread(inode->i_sb, ce->e_block);
925 200 : if (!bh) {
926 300 : ext2_error(inode->i_sb, "ext2_xattr_cache_find",
927 : "inode %ld: block %ld read error",
928 : inode->i_ino, (unsigned long) ce->e_block);
929 : } else {
930 200 : lock_buffer(bh);
931 300 : if (le32_to_cpu(HDR(bh)->h_refcount) >
932 : EXT2_XATTR_REFCOUNT_MAX) {
933 : ea_idebug(inode, "block %ld refcount %d>%d",
934 : (unsigned long) ce->e_block,
935 : le32_to_cpu(HDR(bh)->h_refcount),
936 : EXT2_XATTR_REFCOUNT_MAX);
937 500 : } else if (!ext2_xattr_cmp(header, HDR(bh))) {
938 : ea_bdebug(bh, "b_count=%d",
939 : atomic_read(&(bh->b_count)));
940 100 : mb_cache_entry_release(ce);
941 100 : return bh;
942 : }
943 200 : unlock_buffer(bh);
944 400 : brelse(bh);
945 : }
946 200 : ce = mb_cache_entry_find_next(ce, 0, inode->i_sb->s_bdev, hash);
947 : }
948 400 : return NULL;
949 : }
950 :
951 : #define NAME_HASH_SHIFT 5
952 : #define VALUE_HASH_SHIFT 16
953 :
954 : /*
955 : * ext2_xattr_hash_entry()
956 : *
957 : * Compute the hash of an extended attribute.
958 : */
959 : static inline void ext2_xattr_hash_entry(struct ext2_xattr_header *header,
960 : struct ext2_xattr_entry *entry)
961 80 : {
962 160 : __u32 hash = 0;
963 160 : char *name = entry->e_name;
964 80 : int n;
965 80 :
966 560 : for (n=0; n < entry->e_name_len; n++) {
967 400 : hash = (hash << NAME_HASH_SHIFT) ^
968 80 : (hash >> (8*sizeof(hash) - NAME_HASH_SHIFT)) ^
969 : *name++;
970 : }
971 :
972 320 : if (entry->e_value_block == 0 && entry->e_value_size != 0) {
973 160 : __le32 *value = (__le32 *)((char *)header +
974 : le16_to_cpu(entry->e_value_offs));
975 320 : for (n = (le32_to_cpu(entry->e_value_size) +
976 160 : EXT2_XATTR_ROUND) >> EXT2_XATTR_PAD_BITS; n; n--) {
977 320 : hash = (hash << VALUE_HASH_SHIFT) ^
978 80 : (hash >> (8*sizeof(hash) - VALUE_HASH_SHIFT)) ^
979 : le32_to_cpu(*value++);
980 : }
981 : }
982 160 : entry->e_hash = cpu_to_le32(hash);
983 160 : }
984 :
985 : #undef NAME_HASH_SHIFT
986 : #undef VALUE_HASH_SHIFT
987 :
988 : #define BLOCK_HASH_SHIFT 16
989 :
990 : /*
991 : * ext2_xattr_rehash()
992 : *
993 : * Re-compute the extended attribute hash value after an entry has changed.
994 : */
995 : static void ext2_xattr_rehash(struct ext2_xattr_header *header,
996 : struct ext2_xattr_entry *entry)
997 80 : {
998 80 : struct ext2_xattr_entry *here;
999 80 : __u32 hash = 0;
1000 :
1001 240 : ext2_xattr_hash_entry(header, entry);
1002 80 : here = ENTRY(header+1);
1003 240 : while (!IS_LAST_ENTRY(here)) {
1004 240 : if (!here->e_hash) {
1005 80 : /* Block is not shared if an entry's hash value == 0 */
1006 80 : hash = 0;
1007 80 : break;
1008 : }
1009 160 : hash = (hash << BLOCK_HASH_SHIFT) ^
1010 : (hash >> (8*sizeof(hash) - BLOCK_HASH_SHIFT)) ^
1011 : le32_to_cpu(here->e_hash);
1012 160 : here = EXT2_XATTR_NEXT(here);
1013 80 : }
1014 80 : header->h_hash = cpu_to_le32(hash);
1015 80 : }
1016 :
1017 : #undef BLOCK_HASH_SHIFT
1018 :
1019 : int __init
1020 : init_ext2_xattr(void)
1021 : {
1022 1 : ext2_xattr_cache = mb_cache_create("ext2_xattr", NULL,
1023 : sizeof(struct mb_cache_entry) +
1024 : sizeof(((struct mb_cache_entry *) 0)->e_indexes[0]), 1, 6);
1025 2 : if (!ext2_xattr_cache)
1026 1 : return -ENOMEM;
1027 1 : return 0;
1028 : }
1029 :
1030 : void
1031 : exit_ext2_xattr(void)
1032 : {
1033 4 : mb_cache_destroy(ext2_xattr_cache);
1034 4 : }
|