| blob | 15631019dc634561838919310b2566e263f1d8dc |
1 /* -*- mode: c; c-basic-offset: 8; -*-
2 * vim: noexpandtab sw=8 ts=8 sts=0:
3 *
4 * xattr.c
5 *
6 * Copyright (C) 2004, 2008 Oracle. All rights reserved.
7 *
8 * CREDITS:
9 * Lots of code in this file is copy from linux/fs/ext3/xattr.c.
10 * Copyright (C) 2001-2003 Andreas Gruenbacher, <agruen@suse.de>
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public
14 * License version 2 as published by the Free Software Foundation.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * General Public License for more details.
20 */
22 #include <linux/capability.h>
23 #include <linux/fs.h>
24 #include <linux/types.h>
25 #include <linux/slab.h>
26 #include <linux/highmem.h>
27 #include <linux/pagemap.h>
28 #include <linux/uio.h>
29 #include <linux/sched.h>
30 #include <linux/splice.h>
31 #include <linux/mount.h>
32 #include <linux/writeback.h>
33 #include <linux/falloc.h>
34 #include <linux/sort.h>
35 #include <linux/init.h>
36 #include <linux/module.h>
37 #include <linux/string.h>
38 #include <linux/security.h>
40 #define MLOG_MASK_PREFIX ML_XATTR
41 #include <cluster/masklog.h>
63 };
66 /* The inode these xattrs are associated with */
69 /* The actual buffers that make up the bucket */
72 /* How many blocks make up one bucket for this filesystem */
74 };
81 };
83 #define OCFS2_XATTR_ROOT_SIZE (sizeof(struct ocfs2_xattr_def_value_root))
84 #define OCFS2_XATTR_INLINE_SIZE 80
85 #define OCFS2_XATTR_HEADER_GAP 4
86 #define OCFS2_XATTR_FREE_IN_IBODY (OCFS2_MIN_XATTR_INLINE_SIZE \
87 - sizeof(struct ocfs2_xattr_header) \
88 - OCFS2_XATTR_HEADER_GAP)
89 #define OCFS2_XATTR_FREE_IN_BLOCK(ptr) ((ptr)->i_sb->s_blocksize \
90 - sizeof(struct ocfs2_xattr_block) \
91 - sizeof(struct ocfs2_xattr_header) \
92 - OCFS2_XATTR_HEADER_GAP)
96 };
100 #ifdef CONFIG_OCFS2_FS_POSIX_ACL
103 #endif
106 NULL
107 };
111 #ifdef CONFIG_OCFS2_FS_POSIX_ACL
116 #endif
119 };
126 };
130 /*
131 * xattr_bh point to the block buffer head which has extended attribute
132 * when extended attribute in inode, xattr_bh is equal to inode_bh.
133 */
141 };
181 {
183 }
186 {
188 }
191 {
196 }
198 #define bucket_blkno(_b) ((_b)->bu_bhs[0]->b_blocknr)
199 #define bucket_block(_b, _n) ((_b)->bu_bhs[(_n)]->b_data)
200 #define bucket_xh(_b) ((struct ocfs2_xattr_header *)bucket_block((_b), 0))
203 {
213 }
216 }
219 {
225 }
226 }
229 {
234 }
235 }
237 /*
238 * A bucket that has never been written to disk doesn't need to be
239 * read. We just need the buffer_heads. Don't call this for
240 * buckets that are already on disk. ocfs2_read_xattr_bucket() initializes
241 * them fully.
242 */
244 u64 xb_blkno)
245 {
255 }
261 }
266 }
268 /* Read the xattr bucket at xb_blkno */
270 u64 xb_blkno)
271 {
276 NULL);
286 }
291 }
296 {
305 }
306 }
309 }
313 {
324 }
328 {
337 blocksize);
338 }
339 }
343 {
353 /*
354 * If the ecc fails, we return the error but otherwise
355 * leave the filesystem running. We know any error is
356 * local to this block.
357 */
362 /*
363 * Errors after here are fatal
364 */
368 "Extended attribute block #%llu has bad "
373 }
377 "Extended attribute block #%llu has an "
382 }
386 "Extended attribute block #%llu has an invalid "
391 }
394 }
398 {
403 ocfs2_validate_xattr_block);
405 /* If ocfs2_read_block() got us a new bh, pass it up. */
410 }
413 {
420 }
425 {
426 /* Get hash value of uuid from super block */
430 /* hash extended attribute name */
435 }
438 }
440 /*
441 * ocfs2_xattr_hash_entry()
442 *
443 * Compute the hash of an extended attribute.
444 */
448 {
456 }
459 {
464 else
469 }
476 {
482 /*
483 * The max space of security xattr taken inline is
484 * 256(name) + 80(value) + 16(entry) = 352 bytes,
485 * So reserve one metadata block for it is ok.
486 */
493 }
495 }
497 /* reserve clusters for xattr value which will be set in B tree*/
503 new_clusters);
505 }
507 }
516 {
527 OCFS2_XATTR_INDEX_POSIX_ACL_DEFAULT,
536 }
537 }
542 /*
543 * The max space of security xattr taken inline is
544 * 256(name) + 80(value) + 16(entry) = 352 bytes,
545 * The max space of acl xattr taken inline is
546 * 80(value) + 16(entry) * 2(if directory) = 192 bytes,
547 * when blocksize = 512, may reserve one more cluser for
548 * xattr bucket, otherwise reserve one metadata block
549 * for them is ok.
550 * If this is a new directory with inline data,
551 * we choose to reserve the entire inline area for
552 * directory contents and force an external xattr block.
553 */
559 }
565 }
567 /*
568 * reserve credits and clusters for xattrs which has large value
569 * and have to be set outside
570 */
575 new_clusters);
577 }
580 /* for directory, it has DEFAULT and ACCESS two types of acls */
584 new_clusters);
586 }
589 }
592 u32 clusters_to_add,
595 {
608 OCFS2_JOURNAL_ACCESS_WRITE);
612 }
616 inode,
618 clusters_to_add,
621 handle,
628 }
634 }
638 /*
639 * We should have already allocated enough space before the transaction,
640 * so no need to restart.
641 */
644 leave:
647 }
653 {
662 OCFS2_JOURNAL_ACCESS_WRITE);
666 }
673 }
681 }
687 out:
689 }
692 u32 old_clusters,
693 u32 new_clusters,
696 {
699 u64 block;
713 }
720 ctxt);
724 }
728 alloc_size);
731 }
733 out:
735 }
741 {
753 else
759 }
764 {
771 /* we are just looking for how big our buffer needs to be */
783 }
788 {
807 }
808 }
811 }
817 {
832 }
838 {
851 }
862 }
867 }
872 {
888 }
900 }
905 }
912 }
917 {
934 name_len);
938 }
942 }
948 {
950 u64 blkno;
968 }
971 /* Copy ocfs2_xattr_value */
977 }
988 }
990 }
991 out:
993 }
1001 {
1038 }
1039 }
1040 }
1043 }
1051 {
1062 }
1068 }
1073 }
1089 i,
1093 }
1105 }
1106 }
1107 }
1109 cleanup:
1115 }
1123 {
1129 };
1132 };
1152 }
1154 /* ocfs2_xattr_get()
1155 *
1156 * Copy an extended attribute into the buffer provided.
1157 * Buffer is NULL to compute the size of buffer required.
1158 */
1164 {
1172 }
1181 }
1188 {
1194 u64 blkno;
1205 }
1214 }
1217 inode,
1218 bh,
1219 OCFS2_JOURNAL_ACCESS_WRITE);
1223 }
1237 }
1241 /*
1242 * XXX: do we need to empty all the following
1243 * blocks in this cluster?
1244 */
1247 }
1249 }
1250 out:
1254 }
1262 {
1269 OCFS2_JOURNAL_ACCESS_WRITE);
1273 }
1274 /* Decrease xattr count */
1276 /* Remove the xattr entry and tree root which has already be set*/
1283 out:
1285 }
1293 {
1297 OCFS2_JOURNAL_ACCESS_WRITE);
1301 }
1307 else
1314 out:
1316 }
1318 /*
1319 * ocfs2_xattr_set_value_outside()
1320 *
1321 * Set large size value in B tree.
1322 */
1329 {
1351 }
1356 }
1363 }
1365 /*
1366 * ocfs2_xattr_set_entry_local()
1367 *
1368 * Set, replace or remove extended attribute in local.
1369 */
1375 {
1380 /* Insert the new xattr entry. */
1395 OCFS2_XATTR_INLINE_SIZE)
1397 OCFS2_XATTR_ROOT_SIZE;
1398 else
1404 /* The old and the new value have the
1405 same size. Just replace the value. */
1408 /* Clear value bytes. */
1416 }
1417 /* Remove the old name+value. */
1427 /* Adjust all value offsets. */
1435 }
1438 /* Remove the old entry. */
1444 }
1445 }
1447 /* Insert the new name+value. */
1461 }
1464 }
1466 /*
1467 * ocfs2_xattr_set_entry()
1468 *
1469 * Set extended attribute entry into inode or block.
1470 *
1471 * If extended attribute value size > OCFS2_XATTR_INLINE_SIZE,
1472 * We first insert tree root(ocfs2_xattr_value_root) with set_entry_local(),
1473 * then set value in B tree with set_value_outside().
1474 */
1480 {
1493 };
1497 };
1505 /* Compute min_offs, last and free space. */
1513 }
1524 else
1526 OCFS2_XATTR_ROOT_SIZE;
1528 }
1529 /* Check free space in inode or block */
1533 OCFS2_XATTR_ROOT_SIZE) {
1536 }
1546 }
1547 }
1550 /* For existing extended attribute */
1557 /* Replace existing local xattr with tree root */
1564 /* For existing xattr which has value outside */
1569 /*
1570 * If new value need set outside also,
1571 * first truncate old value to new value,
1572 * then set new value with set_value_outside().
1573 */
1577 ctxt);
1581 }
1584 handle,
1585 xi,
1586 xs,
1588 offs);
1592 }
1595 handle,
1603 /*
1604 * If new value need set in local,
1605 * just trucate old value to zero.
1606 */
1610 ctxt);
1613 }
1614 }
1615 }
1618 OCFS2_JOURNAL_ACCESS_WRITE);
1622 }
1626 OCFS2_JOURNAL_ACCESS_WRITE);
1630 }
1631 }
1633 /*
1634 * Set value in local, include set tree root in local.
1635 * This is the first step for value size >INLINE_SIZE.
1636 */
1644 }
1645 }
1652 /*
1653 * Adjust extent record count or inline data size
1654 * to reserve space for extended attribute.
1655 */
1663 }
1665 }
1666 /* Update xattr flag */
1677 /*
1678 * Set value outside in B tree.
1679 * This is the second step for value size > INLINE_SIZE.
1680 */
1688 /*
1689 * If set value outside failed, we have to clean
1690 * the junk tree root we have already set in local.
1691 */
1696 }
1697 }
1698 out:
1700 }
1705 {
1718 }
1734 }
1735 }
1736 }
1741 out:
1743 }
1747 {
1755 };
1764 }
1768 {
1774 };
1784 }
1787 u64 block)
1788 {
1797 u16 bit;
1803 }
1809 }
1817 EXTENT_ALLOC_SYSTEM_INODE,
1823 }
1830 }
1837 }
1845 out_unlock:
1848 out_mutex:
1851 out:
1854 }
1856 /*
1857 * ocfs2_xattr_remove()
1858 *
1859 * Free extended attribute resources associated with this inode.
1860 */
1862 {
1879 }
1880 }
1888 }
1889 }
1892 OCFS2_INODE_UPDATE_CREDITS);
1897 }
1899 OCFS2_JOURNAL_ACCESS_WRITE);
1903 }
1915 out_commit:
1917 out:
1919 }
1923 {
1942 }
1947 }
1949 /*
1950 * ocfs2_xattr_ibody_find()
1951 *
1952 * Find extended attribute in inode block and
1953 * fill search info into struct ocfs2_xattr_search.
1954 */
1959 {
1974 }
1981 else
1987 /* Find the named attribute. */
1993 }
1996 }
1998 /*
1999 * ocfs2_xattr_ibody_set()
2000 *
2001 * Set, replace or remove an extended attribute into inode block.
2002 *
2003 */
2008 {
2021 }
2022 }
2026 out:
2030 }
2032 /*
2033 * ocfs2_xattr_block_find()
2034 *
2035 * Find extended attribute in external block and
2036 * fill search info into struct ocfs2_xattr_search.
2037 */
2042 {
2056 }
2070 name_index,
2076 }
2079 cleanup:
2083 }
2085 /*
2086 * ocfs2_xattr_block_set()
2087 *
2088 * Set, replace or remove an extended attribute into external block.
2089 *
2090 */
2095 {
2101 u16 suballoc_bit_start;
2102 u32 num_got;
2103 u64 first_blkno;
2108 OCFS2_JOURNAL_ACCESS_CREATE);
2112 }
2120 }
2126 OCFS2_JOURNAL_ACCESS_CREATE);
2130 }
2132 /* Initialize ocfs2_xattr_block */
2151 }
2158 /* Set extended attribute into external block */
2160 OCFS2_HAS_XATTR_FL);
2167 }
2171 end:
2174 }
2176 /* Check whether the new xattr can be inserted into the inode. */
2180 {
2181 u64 value_size;
2196 }
2206 else
2214 }
2224 {
2235 u64 value_size;
2237 /*
2238 * Calculate the clusters we need to write.
2239 * No matter whether we replace an old one or add a new one,
2240 * we need this for writing.
2241 */
2253 new_clusters);
2254 }
2257 }
2284 }
2285 }
2287 /*
2288 * delete a xattr doesn't need metadata and cluster allocation.
2289 * so just calculate the credits and return.
2290 *
2291 * The credits for removing the value tree will be extended
2292 * by ocfs2_remove_extent itself.
2293 */
2299 }
2301 /* do cluster allocation guess first. */
2305 /*
2306 * In xattr set, we always try to set the xe in inode first,
2307 * so if it can be inserted into inode successfully, the old
2308 * one will be removed from the xattr block, and this xattr
2309 * will be inserted into inode as a new xattr in inode.
2310 */
2314 OCFS2_INODE_UPDATE_CREDITS;
2319 new_clusters);
2321 }
2322 }
2325 /* the new values will be stored outside. */
2330 value_size);
2345 new_clusters -
2346 old_clusters);
2349 }
2351 /*
2352 * Now the new value will be stored inside. So if the new
2353 * value is smaller than the size of value root or the old
2354 * value, we don't need any allocation, otherwise we have
2355 * to guess metadata allocation.
2356 */
2361 }
2363 meta_guess:
2364 /* calculate metadata allocation. */
2373 }
2379 /*
2380 * If there is already an xattr tree, good, we can calculate
2381 * like other b-trees. Otherwise we may have the chance of
2382 * create a tree, the credit calculation is borrowed from
2383 * ocfs2_calc_extend_credits with root_el = NULL. And the
2384 * new tree will be cluster based, so no meta is needed.
2385 */
2395 /*
2396 * This cluster will be used either for new bucket or for
2397 * new xattr block.
2398 * If the cluster size is the same as the bucket size, one
2399 * more is needed since we may need to extend the bucket
2400 * also.
2401 */
2408 }
2412 }
2413 out:
2422 }
2431 {
2444 }
2455 }
2456 }
2462 }
2463 out:
2468 }
2470 /*
2471 * We cannot have an error and a non null ctxt->data_ac.
2472 */
2473 }
2476 }
2484 {
2488 /* Remove existing extended attribute */
2494 /* We always try to set extended attribute into inode first*/
2497 /*
2498 * If succeed and that extended attribute existing in
2499 * external block, then we will remove it.
2500 */
2507 di,
2508 xi,
2509 xis,
2510 xbs,
2511 NULL,
2512 NULL,
2518 }
2525 }
2538 di,
2539 xi,
2540 xis,
2541 xbs,
2542 NULL,
2543 NULL,
2549 }
2556 }
2557 }
2558 /*
2559 * If no space in inode, we will set extended attribute
2560 * into external block.
2561 */
2566 /*
2567 * If succeed and that extended attribute
2568 * existing in inode, we will remove it.
2569 */
2574 di,
2575 xi,
2576 xis,
2577 xbs,
2578 NULL,
2579 NULL,
2584 }
2591 }
2594 }
2595 }
2596 }
2599 /* Update inode ctime. */
2602 OCFS2_JOURNAL_ACCESS_WRITE);
2606 }
2612 }
2613 out:
2615 }
2617 /*
2618 * This function only called duing creating inode
2619 * for init security/acl xattrs of the new inode.
2620 * All transanction credits have been reserved in mknod.
2621 */
2632 {
2641 };
2645 };
2649 };
2655 };
2660 /*
2661 * In extreme situation, may need xattr bucket when
2662 * block size is too small. And we have already reserved
2663 * the credits for bucket in mknod.
2664 */
2670 }
2671 }
2685 }
2689 cleanup:
2695 }
2697 /*
2698 * ocfs2_xattr_set()
2699 *
2700 * Set, replace or remove an extended attribute for this inode.
2701 * value is NULL to remove an existing extended attribute, else either
2702 * create or replace an extended attribute.
2703 */
2710 {
2723 };
2727 };
2731 };
2736 /*
2737 * Only xbs will be used on indexed trees. xis doesn't need a
2738 * bucket.
2739 */
2744 }
2750 }
2755 /*
2756 * Scan inode and external block to find the same name
2757 * extended attribute and collect search infomation.
2758 */
2766 }
2779 }
2790 }
2791 }
2799 }
2801 /* we need to update inode's ctime field, so add credit for it. */
2808 }
2821 cleanup:
2824 cleanup_nolock:
2830 }
2832 /*
2833 * Find the xattr extent rec which may contains name_hash.
2834 * e_cpos will be the first name hash of the xattr rec.
2835 * el must be the ocfs2_xattr_header.xb_attrs.xb_root.xt_list.
2836 */
2838 u32 name_hash,
2843 {
2855 }
2862 "Inode %lu has non zero tree depth in "
2867 }
2868 }
2876 }
2877 }
2886 }
2892 out:
2895 }
2905 u32 name_hash,
2908 {
2915 /*
2916 * We don't use binary search in the bucket because there
2917 * may be multiple entries with the same name hash.
2918 */
2934 xh,
2935 i,
2941 }
2950 }
2951 }
2954 }
2956 /*
2957 * Find the specified xattr entry in a series of buckets.
2958 * This series start from p_blkno and last for num_clusters.
2959 * The ocfs2_xattr_header.xh_num_buckets of the first bucket contains
2960 * the num of the valid buckets.
2961 *
2962 * Return the buffer_head this xattr should reside in. And if the xattr's
2963 * hash is in the gap of 2 buckets, return the lower bucket.
2964 */
2968 u32 name_hash,
2969 u64 p_blkno,
2970 u32 first_hash,
2971 u32 num_clusters,
2973 {
2981 u32 last_hash;
2989 }
2995 }
3008 }
3015 }
3017 /*
3018 * Check whether the hash of the last entry in our
3019 * bucket is larger than the search one. for an empty
3020 * bucket, the last one is also the first one.
3021 */
3027 /* record lower_blkno which may be the insert place. */
3033 }
3035 /* the searched xattr should reside in this bucket if exists. */
3042 }
3044 }
3046 /*
3047 * Record the bucket we have found.
3048 * When the xattr's hash value is in the gap of 2 buckets, we will
3049 * always set it to the previous bucket.
3050 */
3054 /* This should be in cache - we just read it during the search */
3059 }
3072 out:
3075 }
3082 {
3103 }
3109 first_hash);
3114 out:
3116 }
3119 u64 blkno,
3120 u32 clusters,
3123 {
3133 }
3143 }
3145 /*
3146 * The real bucket num in this series of blocks is stored
3147 * in the 1st bucket.
3148 */
3159 /* Fall through to bucket_relse() */
3160 }
3165 }
3169 }
3175 };
3182 {
3183 u16 name_offset;
3194 }
3199 {
3213 i,
3220 new_offset;
3228 }
3229 }
3232 }
3238 {
3247 };
3258 }
3261 ocfs2_list_xattr_bucket,
3266 }
3272 }
3275 out:
3277 }
3280 {
3290 }
3293 {
3299 }
3301 /*
3302 * When the ocfs2_xattr_block is filled up, new bucket will be created
3303 * and all the xattr entries will be moved to the new bucket.
3304 * The header goes at the start of the bucket, and the names+values are
3305 * filled from the end. This is why *target starts as the last buffer.
3306 * Note: we need to sort the entries since they are not saved in order
3307 * in the ocfs2_xattr_block.
3308 */
3312 {
3332 /*
3333 * Since the xe_name_offset is based on ocfs2_xattr_header,
3334 * there is a offset change corresponding to the change of
3335 * ocfs2_xattr_header's position.
3336 */
3342 /* copy all the names and values. */
3345 /* Init new header now. */
3351 /* copy all the entries. */
3357 /* Change the xe offset for all the xe because of the move. */
3368 }
3370 /*
3371 * After we move xattr from block to index btree, we have to
3372 * update ocfs2_xattr_search to the new xe and base.
3373 *
3374 * When the entry is in xattr block, xattr_bh indicates the storage place.
3375 * While if the entry is in index b-tree, "bucket" indicates the
3376 * real place of the xattr.
3377 */
3381 {
3396 }
3401 {
3404 u64 blkno;
3420 /*
3421 * XXX:
3422 * We can use this lock for now, and maybe move to a dedicated mutex
3423 * if performance becomes a problem later.
3424 */
3428 OCFS2_JOURNAL_ACCESS_WRITE);
3432 }
3439 }
3441 /*
3442 * The bucket may spread in many blocks, and
3443 * we will only touch the 1st block and the last block
3444 * in the whole bucket(one for entry and one for data).
3445 */
3455 }
3458 OCFS2_JOURNAL_ACCESS_CREATE);
3462 }
3469 /* Change from ocfs2_xattr_header to ocfs2_xattr_tree_root */
3488 out:
3492 }
3495 {
3505 }
3507 /*
3508 * defrag a xattr bucket if we find that the bucket has some
3509 * holes beteen name/value pairs.
3510 * We will move all the name/value pairs to the end of the bucket
3511 * so that we can spare some space for insertion.
3512 */
3516 {
3522 u16 xh_free_start;
3526 /*
3527 * In order to make the operation more efficient and generic,
3528 * we copy all the blocks into a contiguous memory and do the
3529 * defragment there, so if anything is error, we will not touch
3530 * the real block.
3531 */
3536 }
3543 OCFS2_JOURNAL_ACCESS_WRITE);
3547 }
3558 /*
3559 * sort all the entries by their offset.
3560 * the largest will be the first, so that we can
3561 * move them to the end one by one.
3562 */
3567 /* Move all name/values to the end of the bucket. */
3575 else
3579 /*
3580 * We must make sure that the name/value pair
3581 * exist in the same block. So adjust end to
3582 * the previous block end if needed.
3583 */
3592 }
3598 }
3609 /* sort the entries by their name_hash. */
3619 out:
3622 }
3624 /*
3625 * prev_blkno points to the start of an existing extent. new_blkno
3626 * points to a newly allocated extent. Because we know each of our
3627 * clusters contains more than bucket, we can easily split one cluster
3628 * at a bucket boundary. So we take the last cluster of the existing
3629 * extent and split it down the middle. We move the last half of the
3630 * buckets in the last cluster of the existing extent over to the new
3631 * extent.
3632 *
3633 * first_bh is the buffer at prev_blkno so we can update the existing
3634 * extent's bucket count. header_bh is the bucket were we were hoping
3635 * to insert our xattr. If the bucket move places the target in the new
3636 * extent, we'll update first_bh and header_bh after modifying the old
3637 * extent.
3638 *
3639 * first_hash will be set as the 1st xe's name_hash in the new extent.
3640 */
3645 u64 new_blkno,
3646 u32 num_clusters,
3648 {
3654 u64 src_blkno;
3670 }
3672 /* This is the first bucket that got moved */
3675 /*
3676 * If the target bucket was part of the moved buckets, we need to
3677 * update first and target.
3678 */
3680 /* Find the block for the new target bucket */
3687 /*
3688 * These shouldn't fail - the buffers are in the
3689 * journal from ocfs2_cp_xattr_bucket().
3690 */
3695 }
3700 }
3702 out:
3704 }
3706 /*
3707 * Find the suitable pos when we divide a bucket into 2.
3708 * We have to make sure the xattrs with the same hash value exist
3709 * in the same bucket.
3710 *
3711 * If this ocfs2_xattr_header covers more than one hash value, find a
3712 * place where the hash value changes. Try to find the most even split.
3713 * The most common case is that all entries have different hash values,
3714 * and the first check we make will find a place to split.
3715 */
3717 {
3722 /*
3723 * We start at the middle. Each step gets farther away in both
3724 * directions. We therefore hit the change in hash value
3725 * nearest to the middle. Note that this loop does not execute for
3726 * count < 2.
3727 */
3729 /* Let's check delta earlier than middle */
3734 /* For even counts, don't walk off the end */
3738 /* Now try delta past middle */
3742 }
3744 /* Every entry had the same hash */
3746 }
3748 /*
3749 * Move some xattrs in old bucket(blk) to new bucket(new_blk).
3750 * first_hash will record the 1st hash of the new bucket.
3751 *
3752 * Normally half of the xattrs will be moved. But we have to make
3753 * sure that the xattrs with the same hash value are stored in the
3754 * same bucket. If all the xattrs in this bucket have the same hash
3755 * value, the new bucket will be initialized as an empty one and the
3756 * first_hash will be initialized as (hash_value+1).
3757 */
3760 u64 blk,
3761 u64 new_blk,
3764 {
3781 }
3787 }
3790 OCFS2_JOURNAL_ACCESS_WRITE);
3794 }
3796 /*
3797 * Even if !new_bucket_head, we're overwriting t_bucket. Thus,
3798 * there's no need to read it.
3799 */
3804 }
3806 /*
3807 * Hey, if we're overwriting t_bucket, what difference does
3808 * ACCESS_CREATE vs ACCESS_WRITE make? See the comment in the
3809 * same part of ocfs2_cp_xattr_bucket().
3810 */
3812 new_bucket_head ?
3813 OCFS2_JOURNAL_ACCESS_CREATE :
3814 OCFS2_JOURNAL_ACCESS_WRITE);
3818 }
3827 /*
3828 * initialized a new empty bucket here.
3829 * The hash value is set as one larger than
3830 * that of the last entry in the previous bucket.
3831 */
3841 }
3843 /* copy the whole bucket to the new first. */
3846 /* update the new bucket. */
3849 /*
3850 * Calculate the total name/value len and xh_free_start for
3851 * the old bucket first.
3852 */
3859 xe_len +=
3861 else
3866 }
3868 /*
3869 * Now begin the modification to the new bucket.
3870 *
3871 * In the new bucket, We just move the xattr entry to the beginning
3872 * and don't touch the name/value. So there will be some holes in the
3873 * bucket, and they will be removed when ocfs2_defrag_xattr_bucket is
3874 * called.
3875 */
3889 /* Calculate xh_free_start for the new bucket. */
3895 xe_len +=
3897 else
3902 }
3904 set_num_buckets:
3905 /* set xh->xh_num_buckets for the new xh. */
3908 else
3913 /* store the first_hash of the new bucket. */
3917 /*
3918 * Now only update the 1st block of the old bucket. If we
3919 * just added a new empty bucket, there is no need to modify
3920 * it.
3921 */
3934 out:
3939 }
3941 /*
3942 * Copy xattr from one bucket to another bucket.
3943 *
3944 * The caller must make sure that the journal transaction
3945 * has enough space for journaling.
3946 */
3949 u64 s_blkno,
3950 u64 t_blkno,
3952 {
3960 t_is_new);
3968 }
3974 /*
3975 * Even if !t_is_new, we're overwriting t_bucket. Thus,
3976 * there's no need to read it.
3977 */
3982 /*
3983 * Hey, if we're overwriting t_bucket, what difference does
3984 * ACCESS_CREATE vs ACCESS_WRITE make? Well, if we allocated a new
3985 * cluster to fill, we came here from
3986 * ocfs2_mv_xattr_buckets(), and it is really new -
3987 * ACCESS_CREATE is required. But we also might have moved data
3988 * out of t_bucket before extending back into it.
3989 * ocfs2_add_new_xattr_bucket() can do this - its call to
3990 * ocfs2_add_new_xattr_cluster() may have created a new extent
3991 * and copied out the end of the old extent. Then it re-extends
3992 * the old extent back to create space for new xattrs. That's
3993 * how we get here, and the bucket isn't really new.
3994 */
3996 t_is_new ?
3997 OCFS2_JOURNAL_ACCESS_CREATE :
3998 OCFS2_JOURNAL_ACCESS_WRITE);
4005 out:
4010 }
4012 /*
4013 * src_blk points to the start of an existing extent. last_blk points to
4014 * last cluster in that extent. to_blk points to a newly allocated
4015 * extent. We copy the buckets from the cluster at last_blk to the new
4016 * extent. If start_bucket is non-zero, we skip that many buckets before
4017 * we start copying. The new extent's xh_num_buckets gets set to the
4018 * number of buckets we copied. The old extent's xh_num_buckets shrinks
4019 * by the same amount.
4020 */
4025 {
4039 }
4041 /* The first bucket of the original extent */
4043 /* The first bucket of the new extent */
4049 }
4055 }
4057 /*
4058 * We need to update the first bucket of the old extent and all
4059 * the buckets going to the new extent.
4060 */
4067 }
4070 OCFS2_JOURNAL_ACCESS_WRITE);
4074 }
4084 }
4085 }
4087 /*
4088 * Get the new bucket ready before we dirty anything
4089 * (This actually shouldn't fail, because we already dirtied
4090 * it once in ocfs2_cp_xattr_bucket()).
4091 */
4096 }
4098 OCFS2_JOURNAL_ACCESS_WRITE);
4102 }
4104 /* Now update the headers */
4114 out:
4118 }
4120 /*
4121 * Move some xattrs in this cluster to the new cluster.
4122 * This function should only be called when bucket size == cluster size.
4123 * Otherwise ocfs2_mv_xattr_bucket_cross_cluster should be used instead.
4124 */
4127 u64 prev_blk,
4128 u64 new_blk,
4130 {
4140 }
4142 /* Move half of the xattr in start_blk to the next bucket. */
4145 }
4147 /*
4148 * Move some xattrs from the old cluster to the new one since they are not
4149 * contiguous in ocfs2 xattr tree.
4150 *
4151 * new_blk starts a new separate cluster, and we will move some xattrs from
4152 * prev_blk to it. v_start will be set as the first name hash value in this
4153 * new cluster so that it can be used as e_cpos during tree insertion and
4154 * don't collide with our original b-tree operations. first_bh and header_bh
4155 * will also be updated since they will be used in ocfs2_extend_xattr_bucket
4156 * to extend the insert bucket.
4157 *
4158 * The problem is how much xattr should we move to the new one and when should
4159 * we update first_bh and header_bh?
4160 * 1. If cluster size > bucket size, that means the previous cluster has more
4161 * than 1 bucket, so just move half nums of bucket into the new cluster and
4162 * update the first_bh and header_bh if the insert bucket has been moved
4163 * to the new cluster.
4164 * 2. If cluster_size == bucket_size:
4165 * a) If the previous extent rec has more than one cluster and the insert
4166 * place isn't in the last cluster, copy the entire last cluster to the
4167 * new one. This time, we don't need to upate the first_bh and header_bh
4168 * since they will not be moved into the new cluster.
4169 * b) Otherwise, move the bottom half of the xattrs in the last cluster into
4170 * the new one. And we set the extend flag to zero if the insert place is
4171 * moved into the new allocated cluster since no extend is needed.
4172 */
4177 u64 new_blk,
4178 u32 prev_clusters,
4181 {
4190 handle,
4192 new_blk,
4193 prev_clusters,
4194 v_start);
4198 /* The start of the last cluster in the first extent */
4207 v_start);
4213 v_start);
4219 }
4220 }
4223 }
4225 /*
4226 * Add a new cluster for xattr storage.
4227 *
4228 * If the new cluster is contiguous with the previous one, it will be
4229 * appended to the same extent record, and num_clusters will be updated.
4230 * If not, we will insert a new extent for it and move some xattrs in
4231 * the last cluster into the new allocated one.
4232 * We also need to limit the maximum size of a btree leaf, otherwise we'll
4233 * lose the benefits of hashing because we'll have to search large leaves.
4234 * So now the maximum size is OCFS2_MAX_XATTR_TREE_LEAF_SIZE(or clustersize,
4235 * if it's bigger).
4236 *
4237 * first_bh is the first block of the previous extent rec and header_bh
4238 * indicates the bucket we will insert the new xattrs. They will be updated
4239 * when the header_bh is moved into the new cluster.
4240 */
4246 u32 prev_cpos,
4249 {
4254 u64 block;
4267 OCFS2_JOURNAL_ACCESS_WRITE);
4271 }
4279 }
4289 OCFS2_MAX_XATTR_TREE_LEAF_SIZE) {
4290 /*
4291 * If this cluster is contiguous with the old one and
4292 * adding this new cluster, we don't surpass the limit of
4293 * OCFS2_MAX_XATTR_TREE_LEAF_SIZE, cool. We will let it be
4294 * initialized and used like other buckets in the previous
4295 * cluster.
4296 * So add it as a contiguous one. The caller will handle
4297 * its init process.
4298 */
4302 num_bits);
4305 handle,
4306 first,
4307 target,
4308 block,
4309 prev_clusters,
4311 extend);
4315 }
4316 }
4325 }
4331 leave:
4333 }
4335 /*
4336 * We are given an extent. 'first' is the bucket at the very front of
4337 * the extent. The extent has space for an additional bucket past
4338 * bucket_xh(first)->xh_num_buckets. 'target_blkno' is the block number
4339 * of the target bucket. We wish to shift every bucket past the target
4340 * down one, filling in that additional space. When we get back to the
4341 * target, we split the target between itself and the now-empty bucket
4342 * at target+1 (aka, target_blkno + blks_per_bucket).
4343 */
4347 u64 target_blk,
4348 u32 num_clusters)
4349 {
4353 u64 end_blk;
4360 /* The extent must have room for an additional bucket */
4364 /* end_blk points to the last existing bucket */
4367 /*
4368 * end_blk is the start of the last existing bucket.
4369 * Thus, (end_blk - target_blk) covers the target bucket and
4370 * every bucket after it up to, but not including, the last
4371 * existing bucket. Then we add the last existing bucket, the
4372 * new bucket, and the first bucket (3 * blk_per_bucket).
4373 */
4380 }
4383 OCFS2_JOURNAL_ACCESS_WRITE);
4387 }
4395 }
4397 /* Move half of the xattr in target_blkno to the next bucket. */
4404 out:
4406 }
4408 /*
4409 * Add new xattr bucket in an extent record and adjust the buckets
4410 * accordingly. xb_bh is the ocfs2_xattr_block, and target is the
4411 * bucket we want to insert into.
4412 *
4413 * In the easy case, we will move all the buckets after target down by
4414 * one. Half of target's xattrs will be moved to the next bucket.
4415 *
4416 * If current cluster is full, we'll allocate a new one. This may not
4417 * be contiguous. The underlying calls will make sure that there is
4418 * space for the insert, shifting buckets around if necessary.
4419 * 'target' may be moved by those calls.
4420 */
4425 {
4430 u32 name_hash =
4434 u64 p_blkno;
4436 /* The bucket at the front of the extent */
4442 /* The first bucket of the original extent */
4448 }
4455 }
4461 }
4465 /*
4466 * This can move first+target if the target bucket moves
4467 * to the new extent.
4468 */
4470 xb_bh,
4471 first,
4472 target,
4474 e_cpos,
4476 ctxt);
4480 }
4481 }
4486 first,
4488 num_clusters);
4491 }
4493 out:
4497 }
4502 {
4507 }
4509 /*
4510 * Handle the normal xattr set, including replace, delete and new.
4511 *
4512 * Note: "local" indicates the real data's locality. So we can't
4513 * just its bucket locality by its length.
4514 */
4518 u32 name_hash,
4520 {
4536 else
4540 /*
4541 * If the new value will be stored outside, xi->value has been
4542 * initalized as an empty ocfs2_xattr_value_root, and the same
4543 * goes with xi->value_len, so we can set new_size safely here.
4544 * See ocfs2_xattr_set_in_bucket.
4545 */
4554 /* Now replace the old value with new one. */
4557 else
4572 /*
4573 * Remove the old entry if there is more than one.
4574 * We don't remove the last entry so that we can
4575 * use it to indicate the hash value of the empty
4576 * bucket.
4577 */
4590 }
4592 /* find a new entry for insert. */
4608 }
4609 }
4620 }
4622 set_new_name_value:
4623 /* Insert the new name+value. */
4626 /*
4627 * We must make sure that the name/value pair
4628 * exists in the same block.
4629 */
4637 }
4653 }
4655 /*
4656 * Set the xattr entry in the specified bucket.
4657 * The bucket is indicated by xs->bucket and it should have the enough
4658 * space for the xattr insertion.
4659 */
4664 u32 name_hash,
4666 {
4668 u64 blkno;
4681 }
4682 }
4685 OCFS2_JOURNAL_ACCESS_WRITE);
4689 }
4694 out:
4696 }
4698 /*
4699 * Truncate the specified xe_off entry in xattr bucket.
4700 * bucket is indicated by header_bh and len is the new length.
4701 * Both the ocfs2_xattr_value_root and the entry will be updated here.
4702 *
4703 * Copy the new updated xe and xe_value_root to new_xe and new_xv if needed.
4704 */
4710 {
4712 u64 value_blk;
4718 };
4729 /* We don't allow ocfs2_xattr_value to be stored in different block. */
4738 /*
4739 * From here on out we have to dirty the bucket. The generic
4740 * value calls only modify one of the bucket's bhs, but we need
4741 * to send the bucket at once. So if they error, they *could* have
4742 * modified something. We have to assume they did, and dirty
4743 * the whole bucket. This leaves us in a consistent state.
4744 */
4751 }
4754 OCFS2_JOURNAL_ACCESS_WRITE);
4758 }
4764 out:
4766 }
4772 {
4786 }
4793 {
4809 }
4819 out:
4821 }
4825 u64 blkno,
4826 u32 cpos,
4827 u32 len)
4828 {
4852 }
4861 }
4862 }
4869 }
4872 OCFS2_JOURNAL_ACCESS_WRITE);
4876 }
4883 }
4891 }
4897 out_commit:
4899 out:
4910 }
4915 {
4922 OCFS2_JOURNAL_ACCESS_WRITE);
4926 }
4928 /* Remove the old entry. */
4935 }
4937 /*
4938 * Set the xattr name/value in the bucket specified in xs.
4939 *
4940 * As the new value in xi may be stored in the bucket or in an outside cluster,
4941 * we divide the whole process into 3 steps:
4942 * 1. insert name/value in the bucket(ocfs2_xattr_set_entry_in_bucket)
4943 * 2. truncate of the outside cluster(ocfs2_xattr_bucket_value_truncate_xs)
4944 * 3. Set the value to the outside cluster(ocfs2_xattr_bucket_set_value_outside)
4945 * 4. If the clusters for the new outside value can't be allocated, we need
4946 * to free the xattr we allocated in set.
4947 */
4952 {
4961 /*
4962 * We need to truncate the xattr storage first.
4963 *
4964 * If both the old and new value are stored to
4965 * outside block, we only need to truncate
4966 * the storage and then set the value outside.
4967 *
4968 * If the new value should be stored within block,
4969 * we should free all the outside block first and
4970 * the modification to the xattr block will be done
4971 * by following steps.
4972 */
4975 else
4979 value_len,
4980 ctxt);
4986 }
4989 /* So we have to handle the inside block change now. */
4991 /*
4992 * If the new value will be stored outside of block,
4993 * initalize a new empty value root and insert it first.
4994 */
4998 }
5005 }
5010 /* allocate the space now for the outside block storage. */
5017 /*
5018 * We can't allocate enough clusters for outside
5019 * storage and we have allocated xattr already,
5020 * so need to remove it.
5021 */
5023 }
5025 }
5027 set_value_outside:
5030 out:
5032 }
5034 /*
5035 * check whether the xattr bucket is filled up with the same hash value.
5036 * If we want to insert the xattr with the same hash, return -ENOSPC.
5037 * If we want to insert a xattr with different hash value, go ahead
5038 * and ocfs2_divide_xattr_bucket will handle this.
5039 */
5043 {
5057 }
5060 }
5066 {
5077 try_again:
5089 header_size);
5102 /*
5103 * We only replace the old value if the new length is smaller
5104 * than the old one. Otherwise we will allocate new space in the
5105 * bucket to store it.
5106 */
5110 else
5115 }
5118 /*
5119 * We need to make sure the new name/value pair
5120 * can exist in the same block.
5121 */
5126 "need = %d, max_free = %d, xh_free_start = %u, xh_name_value_len ="
5137 /*
5138 * We can create the space by defragment. Since only the
5139 * name/value will be moved, the xe shouldn't be changed
5140 * in xs.
5141 */
5147 }
5159 "defragment. Need %u bytes, but we have %d, so "
5161 }
5163 /*
5164 * We have to add new buckets or clusters and one
5165 * allocation should leave us enough space for insert.
5166 */
5169 /*
5170 * We do not allow for overlapping ranges between buckets. And
5171 * the maximum number of collisions we will allow for then is
5172 * one bucket's worth, so check it here whether we need to
5173 * add a new bucket for the insert.
5174 */
5181 }
5186 ctxt);
5190 }
5192 /*
5193 * ocfs2_add_new_xattr_bucket() will have updated
5194 * xs->bucket if it moved, but it will not have updated
5195 * any of the other search fields. Thus, we drop it and
5196 * re-search. Everything should be cached, so it'll be
5197 * quick.
5198 */
5208 }
5210 xattr_set:
5212 out:
5215 }
5220 {
5223 u16 i;
5243 }
5252 }
5253 }
5258 }
5262 {
5268 u64 p_blkno;
5279 }
5282 ocfs2_delete_xattr_in_bucket,
5283 NULL);
5287 }
5294 }
5300 }
5302 out:
5304 }
5306 /*
5307 * 'security' attributes support
5308 */
5312 {
5320 }
5322 }
5326 {
5331 }
5335 {
5341 }
5346 {
5347 /* check whether ocfs2 support feature xattr */
5352 }
5360 {
5362 OCFS2_XATTR_INDEX_SECURITY,
5365 }
5372 };
5374 /*
5375 * 'trusted' attributes support
5376 */
5380 {
5388 }
5390 }
5394 {
5399 }
5403 {
5409 }
5416 };
5418 /*
5419 * 'user' attributes support
5420 */
5424 {
5436 }
5438 }
5442 {
5451 }
5455 {
5465 }
5472 };