| blob | a7c167905c56daf62fa08a81861c0bb2837a7794 |
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_FREE_IN_IBODY (OCFS2_MIN_XATTR_INLINE_SIZE \
86 - sizeof(struct ocfs2_xattr_header) \
87 - sizeof(__u32))
88 #define OCFS2_XATTR_FREE_IN_BLOCK(ptr) ((ptr)->i_sb->s_blocksize \
89 - sizeof(struct ocfs2_xattr_block) \
90 - sizeof(struct ocfs2_xattr_header) \
91 - sizeof(__u32))
95 };
99 #ifdef CONFIG_OCFS2_FS_POSIX_ACL
102 #endif
105 NULL
106 };
110 #ifdef CONFIG_OCFS2_FS_POSIX_ACL
115 #endif
118 };
125 };
129 /*
130 * xattr_bh point to the block buffer head which has extended attribute
131 * when extended attribute in inode, xattr_bh is equal to inode_bh.
132 */
140 };
180 {
182 }
185 {
187 }
190 {
195 }
197 #define bucket_blkno(_b) ((_b)->bu_bhs[0]->b_blocknr)
198 #define bucket_block(_b, _n) ((_b)->bu_bhs[(_n)]->b_data)
199 #define bucket_xh(_b) ((struct ocfs2_xattr_header *)bucket_block((_b), 0))
202 {
212 }
215 }
218 {
224 }
225 }
228 {
233 }
234 }
236 /*
237 * A bucket that has never been written to disk doesn't need to be
238 * read. We just need the buffer_heads. Don't call this for
239 * buckets that are already on disk. ocfs2_read_xattr_bucket() initializes
240 * them fully.
241 */
243 u64 xb_blkno)
244 {
254 }
260 }
265 }
267 /* Read the xattr bucket at xb_blkno */
269 u64 xb_blkno)
270 {
275 NULL);
285 }
290 }
295 {
304 }
305 }
308 }
312 {
323 }
327 {
336 blocksize);
337 }
338 }
342 {
352 /*
353 * If the ecc fails, we return the error but otherwise
354 * leave the filesystem running. We know any error is
355 * local to this block.
356 */
361 /*
362 * Errors after here are fatal
363 */
367 "Extended attribute block #%llu has bad "
372 }
376 "Extended attribute block #%llu has an "
381 }
385 "Extended attribute block #%llu has an invalid "
390 }
393 }
397 {
402 ocfs2_validate_xattr_block);
404 /* If ocfs2_read_block() got us a new bh, pass it up. */
409 }
412 {
419 }
424 {
425 /* Get hash value of uuid from super block */
429 /* hash extended attribute name */
434 }
437 }
439 /*
440 * ocfs2_xattr_hash_entry()
441 *
442 * Compute the hash of an extended attribute.
443 */
447 {
455 }
458 {
463 else
468 }
475 {
481 /*
482 * The max space of security xattr taken inline is
483 * 256(name) + 80(value) + 16(entry) = 352 bytes,
484 * So reserve one metadata block for it is ok.
485 */
492 }
494 }
496 /* reserve clusters for xattr value which will be set in B tree*/
502 new_clusters);
504 }
506 }
515 {
526 OCFS2_XATTR_INDEX_POSIX_ACL_DEFAULT,
535 }
536 }
541 /*
542 * The max space of security xattr taken inline is
543 * 256(name) + 80(value) + 16(entry) = 352 bytes,
544 * The max space of acl xattr taken inline is
545 * 80(value) + 16(entry) * 2(if directory) = 192 bytes,
546 * when blocksize = 512, may reserve one more cluser for
547 * xattr bucket, otherwise reserve one metadata block
548 * for them is ok.
549 */
556 }
558 }
564 }
566 /*
567 * reserve credits and clusters for xattrs which has large value
568 * and have to be set outside
569 */
574 new_clusters);
576 }
579 /* for directory, it has DEFAULT and ACCESS two types of acls */
583 new_clusters);
585 }
588 }
591 u32 clusters_to_add,
594 {
607 OCFS2_JOURNAL_ACCESS_WRITE);
611 }
615 inode,
617 clusters_to_add,
620 handle,
627 }
633 }
637 /*
638 * We should have already allocated enough space before the transaction,
639 * so no need to restart.
640 */
643 leave:
646 }
652 {
661 OCFS2_JOURNAL_ACCESS_WRITE);
665 }
672 }
680 }
686 out:
688 }
691 u32 old_clusters,
692 u32 new_clusters,
695 {
698 u64 block;
712 }
719 ctxt);
723 }
727 alloc_size);
730 }
732 out:
734 }
740 {
752 else
758 }
763 {
770 /* we are just looking for how big our buffer needs to be */
782 }
787 {
806 }
807 }
810 }
816 {
831 }
837 {
850 }
861 }
866 }
871 {
887 }
899 }
904 }
911 }
916 {
933 name_len);
937 }
941 }
947 {
949 u64 blkno;
967 }
970 /* Copy ocfs2_xattr_value */
976 }
987 }
989 }
990 out:
992 }
1000 {
1037 }
1038 }
1039 }
1042 }
1050 {
1061 }
1067 }
1072 }
1088 i,
1092 }
1104 }
1105 }
1106 }
1108 cleanup:
1114 }
1122 {
1128 };
1131 };
1151 }
1153 /* ocfs2_xattr_get()
1154 *
1155 * Copy an extended attribute into the buffer provided.
1156 * Buffer is NULL to compute the size of buffer required.
1157 */
1163 {
1171 }
1180 }
1187 {
1193 u64 blkno;
1204 }
1213 }
1216 inode,
1217 bh,
1218 OCFS2_JOURNAL_ACCESS_WRITE);
1222 }
1236 }
1240 /*
1241 * XXX: do we need to empty all the following
1242 * blocks in this cluster?
1243 */
1246 }
1248 }
1249 out:
1253 }
1261 {
1268 OCFS2_JOURNAL_ACCESS_WRITE);
1272 }
1273 /* Decrease xattr count */
1275 /* Remove the xattr entry and tree root which has already be set*/
1282 out:
1284 }
1292 {
1296 OCFS2_JOURNAL_ACCESS_WRITE);
1300 }
1306 else
1313 out:
1315 }
1317 /*
1318 * ocfs2_xattr_set_value_outside()
1319 *
1320 * Set large size value in B tree.
1321 */
1328 {
1350 }
1355 }
1362 }
1364 /*
1365 * ocfs2_xattr_set_entry_local()
1366 *
1367 * Set, replace or remove extended attribute in local.
1368 */
1374 {
1379 /* Insert the new xattr entry. */
1394 OCFS2_XATTR_INLINE_SIZE)
1396 OCFS2_XATTR_ROOT_SIZE;
1397 else
1403 /* The old and the new value have the
1404 same size. Just replace the value. */
1407 /* Clear value bytes. */
1415 }
1416 /* Remove the old name+value. */
1426 /* Adjust all value offsets. */
1434 }
1437 /* Remove the old entry. */
1443 }
1444 }
1446 /* Insert the new name+value. */
1460 }
1463 }
1465 /*
1466 * ocfs2_xattr_set_entry()
1467 *
1468 * Set extended attribute entry into inode or block.
1469 *
1470 * If extended attribute value size > OCFS2_XATTR_INLINE_SIZE,
1471 * We first insert tree root(ocfs2_xattr_value_root) with set_entry_local(),
1472 * then set value in B tree with set_value_outside().
1473 */
1479 {
1492 };
1496 };
1504 /* Compute min_offs, last and free space. */
1512 }
1523 else
1525 OCFS2_XATTR_ROOT_SIZE;
1527 }
1528 /* Check free space in inode or block */
1532 OCFS2_XATTR_ROOT_SIZE) {
1535 }
1545 }
1546 }
1549 /* For existing extended attribute */
1556 /* Replace existing local xattr with tree root */
1563 /* For existing xattr which has value outside */
1568 /*
1569 * If new value need set outside also,
1570 * first truncate old value to new value,
1571 * then set new value with set_value_outside().
1572 */
1576 ctxt);
1580 }
1583 handle,
1584 xi,
1585 xs,
1587 offs);
1591 }
1594 handle,
1602 /*
1603 * If new value need set in local,
1604 * just trucate old value to zero.
1605 */
1609 ctxt);
1612 }
1613 }
1614 }
1617 OCFS2_JOURNAL_ACCESS_WRITE);
1621 }
1625 OCFS2_JOURNAL_ACCESS_WRITE);
1629 }
1630 }
1632 /*
1633 * Set value in local, include set tree root in local.
1634 * This is the first step for value size >INLINE_SIZE.
1635 */
1643 }
1644 }
1651 /*
1652 * Adjust extent record count or inline data size
1653 * to reserve space for extended attribute.
1654 */
1662 }
1664 }
1665 /* Update xattr flag */
1676 /*
1677 * Set value outside in B tree.
1678 * This is the second step for value size > INLINE_SIZE.
1679 */
1687 /*
1688 * If set value outside failed, we have to clean
1689 * the junk tree root we have already set in local.
1690 */
1695 }
1696 }
1697 out:
1699 }
1704 {
1717 }
1733 }
1734 }
1735 }
1740 out:
1742 }
1746 {
1754 };
1763 }
1767 {
1773 };
1783 }
1786 u64 block)
1787 {
1796 u16 bit;
1802 }
1808 }
1816 EXTENT_ALLOC_SYSTEM_INODE,
1822 }
1829 }
1836 }
1844 out_unlock:
1847 out_mutex:
1850 out:
1853 }
1855 /*
1856 * ocfs2_xattr_remove()
1857 *
1858 * Free extended attribute resources associated with this inode.
1859 */
1861 {
1878 }
1879 }
1887 }
1888 }
1891 OCFS2_INODE_UPDATE_CREDITS);
1896 }
1898 OCFS2_JOURNAL_ACCESS_WRITE);
1902 }
1914 out_commit:
1916 out:
1918 }
1922 {
1941 }
1946 }
1948 /*
1949 * ocfs2_xattr_ibody_find()
1950 *
1951 * Find extended attribute in inode block and
1952 * fill search info into struct ocfs2_xattr_search.
1953 */
1958 {
1973 }
1980 else
1986 /* Find the named attribute. */
1992 }
1995 }
1997 /*
1998 * ocfs2_xattr_ibody_set()
1999 *
2000 * Set, replace or remove an extended attribute into inode block.
2001 *
2002 */
2007 {
2020 }
2021 }
2025 out:
2029 }
2031 /*
2032 * ocfs2_xattr_block_find()
2033 *
2034 * Find extended attribute in external block and
2035 * fill search info into struct ocfs2_xattr_search.
2036 */
2041 {
2055 }
2069 name_index,
2075 }
2078 cleanup:
2082 }
2084 /*
2085 * ocfs2_xattr_block_set()
2086 *
2087 * Set, replace or remove an extended attribute into external block.
2088 *
2089 */
2094 {
2100 u16 suballoc_bit_start;
2101 u32 num_got;
2102 u64 first_blkno;
2107 OCFS2_JOURNAL_ACCESS_CREATE);
2111 }
2119 }
2125 OCFS2_JOURNAL_ACCESS_CREATE);
2129 }
2131 /* Initialize ocfs2_xattr_block */
2150 }
2157 /* Set extended attribute into external block */
2159 OCFS2_HAS_XATTR_FL);
2166 }
2170 end:
2173 }
2175 /* Check whether the new xattr can be inserted into the inode. */
2179 {
2180 u64 value_size;
2195 }
2205 else
2213 }
2223 {
2234 u64 value_size;
2236 /*
2237 * Calculate the clusters we need to write.
2238 * No matter whether we replace an old one or add a new one,
2239 * we need this for writing.
2240 */
2252 new_clusters);
2253 }
2256 }
2283 }
2284 }
2286 /*
2287 * delete a xattr doesn't need metadata and cluster allocation.
2288 * so just calculate the credits and return.
2289 *
2290 * The credits for removing the value tree will be extended
2291 * by ocfs2_remove_extent itself.
2292 */
2298 }
2300 /* do cluster allocation guess first. */
2304 /*
2305 * In xattr set, we always try to set the xe in inode first,
2306 * so if it can be inserted into inode successfully, the old
2307 * one will be removed from the xattr block, and this xattr
2308 * will be inserted into inode as a new xattr in inode.
2309 */
2313 OCFS2_INODE_UPDATE_CREDITS;
2318 new_clusters);
2320 }
2321 }
2324 /* the new values will be stored outside. */
2329 value_size);
2344 new_clusters -
2345 old_clusters);
2348 }
2350 /*
2351 * Now the new value will be stored inside. So if the new
2352 * value is smaller than the size of value root or the old
2353 * value, we don't need any allocation, otherwise we have
2354 * to guess metadata allocation.
2355 */
2360 }
2362 meta_guess:
2363 /* calculate metadata allocation. */
2372 }
2378 /*
2379 * If there is already an xattr tree, good, we can calculate
2380 * like other b-trees. Otherwise we may have the chance of
2381 * create a tree, the credit calculation is borrowed from
2382 * ocfs2_calc_extend_credits with root_el = NULL. And the
2383 * new tree will be cluster based, so no meta is needed.
2384 */
2394 /*
2395 * This cluster will be used either for new bucket or for
2396 * new xattr block.
2397 * If the cluster size is the same as the bucket size, one
2398 * more is needed since we may need to extend the bucket
2399 * also.
2400 */
2407 }
2411 }
2412 out:
2421 }
2430 {
2443 }
2454 }
2455 }
2461 }
2462 out:
2467 }
2469 /*
2470 * We cannot have an error and a non null ctxt->data_ac.
2471 */
2472 }
2475 }
2483 {
2487 /* Remove existing extended attribute */
2493 /* We always try to set extended attribute into inode first*/
2496 /*
2497 * If succeed and that extended attribute existing in
2498 * external block, then we will remove it.
2499 */
2506 di,
2507 xi,
2508 xis,
2509 xbs,
2510 NULL,
2511 NULL,
2517 }
2524 }
2537 di,
2538 xi,
2539 xis,
2540 xbs,
2541 NULL,
2542 NULL,
2548 }
2555 }
2556 }
2557 /*
2558 * If no space in inode, we will set extended attribute
2559 * into external block.
2560 */
2565 /*
2566 * If succeed and that extended attribute
2567 * existing in inode, we will remove it.
2568 */
2573 di,
2574 xi,
2575 xis,
2576 xbs,
2577 NULL,
2578 NULL,
2583 }
2590 }
2593 }
2594 }
2595 }
2598 /* Update inode ctime. */
2601 OCFS2_JOURNAL_ACCESS_WRITE);
2605 }
2611 }
2612 out:
2614 }
2616 /*
2617 * This function only called duing creating inode
2618 * for init security/acl xattrs of the new inode.
2619 * All transanction credits have been reserved in mknod.
2620 */
2631 {
2640 };
2644 };
2648 };
2654 };
2659 /*
2660 * In extreme situation, may need xattr bucket when
2661 * block size is too small. And we have already reserved
2662 * the credits for bucket in mknod.
2663 */
2669 }
2670 }
2684 }
2688 cleanup:
2694 }
2696 /*
2697 * ocfs2_xattr_set()
2698 *
2699 * Set, replace or remove an extended attribute for this inode.
2700 * value is NULL to remove an existing extended attribute, else either
2701 * create or replace an extended attribute.
2702 */
2709 {
2722 };
2726 };
2730 };
2735 /*
2736 * Only xbs will be used on indexed trees. xis doesn't need a
2737 * bucket.
2738 */
2743 }
2749 }
2754 /*
2755 * Scan inode and external block to find the same name
2756 * extended attribute and collect search infomation.
2757 */
2765 }
2778 }
2789 }
2790 }
2798 }
2800 /* we need to update inode's ctime field, so add credit for it. */
2807 }
2820 cleanup:
2823 cleanup_nolock:
2829 }
2831 /*
2832 * Find the xattr extent rec which may contains name_hash.
2833 * e_cpos will be the first name hash of the xattr rec.
2834 * el must be the ocfs2_xattr_header.xb_attrs.xb_root.xt_list.
2835 */
2837 u32 name_hash,
2842 {
2854 }
2861 "Inode %lu has non zero tree depth in "
2866 }
2867 }
2875 }
2876 }
2885 }
2891 out:
2894 }
2904 u32 name_hash,
2907 {
2914 /*
2915 * We don't use binary search in the bucket because there
2916 * may be multiple entries with the same name hash.
2917 */
2933 xh,
2934 i,
2940 }
2949 }
2950 }
2953 }
2955 /*
2956 * Find the specified xattr entry in a series of buckets.
2957 * This series start from p_blkno and last for num_clusters.
2958 * The ocfs2_xattr_header.xh_num_buckets of the first bucket contains
2959 * the num of the valid buckets.
2960 *
2961 * Return the buffer_head this xattr should reside in. And if the xattr's
2962 * hash is in the gap of 2 buckets, return the lower bucket.
2963 */
2967 u32 name_hash,
2968 u64 p_blkno,
2969 u32 first_hash,
2970 u32 num_clusters,
2972 {
2980 u32 last_hash;
2988 }
2994 }
3007 }
3014 }
3016 /*
3017 * Check whether the hash of the last entry in our
3018 * bucket is larger than the search one. for an empty
3019 * bucket, the last one is also the first one.
3020 */
3026 /* record lower_blkno which may be the insert place. */
3032 }
3034 /* the searched xattr should reside in this bucket if exists. */
3041 }
3043 }
3045 /*
3046 * Record the bucket we have found.
3047 * When the xattr's hash value is in the gap of 2 buckets, we will
3048 * always set it to the previous bucket.
3049 */
3053 /* This should be in cache - we just read it during the search */
3058 }
3071 out:
3074 }
3081 {
3102 }
3108 first_hash);
3113 out:
3115 }
3118 u64 blkno,
3119 u32 clusters,
3122 {
3132 }
3142 }
3144 /*
3145 * The real bucket num in this series of blocks is stored
3146 * in the 1st bucket.
3147 */
3158 /* Fall through to bucket_relse() */
3159 }
3164 }
3168 }
3174 };
3181 {
3182 u16 name_offset;
3193 }
3198 {
3212 i,
3219 new_offset;
3227 }
3228 }
3231 }
3237 {
3246 };
3257 }
3260 ocfs2_list_xattr_bucket,
3265 }
3271 }
3274 out:
3276 }
3279 {
3289 }
3292 {
3298 }
3300 /*
3301 * When the ocfs2_xattr_block is filled up, new bucket will be created
3302 * and all the xattr entries will be moved to the new bucket.
3303 * The header goes at the start of the bucket, and the names+values are
3304 * filled from the end. This is why *target starts as the last buffer.
3305 * Note: we need to sort the entries since they are not saved in order
3306 * in the ocfs2_xattr_block.
3307 */
3311 {
3331 /*
3332 * Since the xe_name_offset is based on ocfs2_xattr_header,
3333 * there is a offset change corresponding to the change of
3334 * ocfs2_xattr_header's position.
3335 */
3341 /* copy all the names and values. */
3344 /* Init new header now. */
3350 /* copy all the entries. */
3356 /* Change the xe offset for all the xe because of the move. */
3367 }
3369 /*
3370 * After we move xattr from block to index btree, we have to
3371 * update ocfs2_xattr_search to the new xe and base.
3372 *
3373 * When the entry is in xattr block, xattr_bh indicates the storage place.
3374 * While if the entry is in index b-tree, "bucket" indicates the
3375 * real place of the xattr.
3376 */
3380 {
3395 }
3400 {
3403 u64 blkno;
3419 /*
3420 * XXX:
3421 * We can use this lock for now, and maybe move to a dedicated mutex
3422 * if performance becomes a problem later.
3423 */
3427 OCFS2_JOURNAL_ACCESS_WRITE);
3431 }
3438 }
3440 /*
3441 * The bucket may spread in many blocks, and
3442 * we will only touch the 1st block and the last block
3443 * in the whole bucket(one for entry and one for data).
3444 */
3454 }
3457 OCFS2_JOURNAL_ACCESS_CREATE);
3461 }
3468 /* Change from ocfs2_xattr_header to ocfs2_xattr_tree_root */
3487 out:
3491 }
3494 {
3504 }
3506 /*
3507 * defrag a xattr bucket if we find that the bucket has some
3508 * holes beteen name/value pairs.
3509 * We will move all the name/value pairs to the end of the bucket
3510 * so that we can spare some space for insertion.
3511 */
3515 {
3521 u16 xh_free_start;
3525 /*
3526 * In order to make the operation more efficient and generic,
3527 * we copy all the blocks into a contiguous memory and do the
3528 * defragment there, so if anything is error, we will not touch
3529 * the real block.
3530 */
3535 }
3542 OCFS2_JOURNAL_ACCESS_WRITE);
3546 }
3557 /*
3558 * sort all the entries by their offset.
3559 * the largest will be the first, so that we can
3560 * move them to the end one by one.
3561 */
3566 /* Move all name/values to the end of the bucket. */
3574 else
3578 /*
3579 * We must make sure that the name/value pair
3580 * exist in the same block. So adjust end to
3581 * the previous block end if needed.
3582 */
3591 }
3597 }
3608 /* sort the entries by their name_hash. */
3618 out:
3621 }
3623 /*
3624 * prev_blkno points to the start of an existing extent. new_blkno
3625 * points to a newly allocated extent. Because we know each of our
3626 * clusters contains more than bucket, we can easily split one cluster
3627 * at a bucket boundary. So we take the last cluster of the existing
3628 * extent and split it down the middle. We move the last half of the
3629 * buckets in the last cluster of the existing extent over to the new
3630 * extent.
3631 *
3632 * first_bh is the buffer at prev_blkno so we can update the existing
3633 * extent's bucket count. header_bh is the bucket were we were hoping
3634 * to insert our xattr. If the bucket move places the target in the new
3635 * extent, we'll update first_bh and header_bh after modifying the old
3636 * extent.
3637 *
3638 * first_hash will be set as the 1st xe's name_hash in the new extent.
3639 */
3644 u64 new_blkno,
3645 u32 num_clusters,
3647 {
3653 u64 src_blkno;
3669 }
3671 /* This is the first bucket that got moved */
3674 /*
3675 * If the target bucket was part of the moved buckets, we need to
3676 * update first and target.
3677 */
3679 /* Find the block for the new target bucket */
3686 /*
3687 * These shouldn't fail - the buffers are in the
3688 * journal from ocfs2_cp_xattr_bucket().
3689 */
3694 }
3699 }
3701 out:
3703 }
3705 /*
3706 * Find the suitable pos when we divide a bucket into 2.
3707 * We have to make sure the xattrs with the same hash value exist
3708 * in the same bucket.
3709 *
3710 * If this ocfs2_xattr_header covers more than one hash value, find a
3711 * place where the hash value changes. Try to find the most even split.
3712 * The most common case is that all entries have different hash values,
3713 * and the first check we make will find a place to split.
3714 */
3716 {
3721 /*
3722 * We start at the middle. Each step gets farther away in both
3723 * directions. We therefore hit the change in hash value
3724 * nearest to the middle. Note that this loop does not execute for
3725 * count < 2.
3726 */
3728 /* Let's check delta earlier than middle */
3733 /* For even counts, don't walk off the end */
3737 /* Now try delta past middle */
3741 }
3743 /* Every entry had the same hash */
3745 }
3747 /*
3748 * Move some xattrs in old bucket(blk) to new bucket(new_blk).
3749 * first_hash will record the 1st hash of the new bucket.
3750 *
3751 * Normally half of the xattrs will be moved. But we have to make
3752 * sure that the xattrs with the same hash value are stored in the
3753 * same bucket. If all the xattrs in this bucket have the same hash
3754 * value, the new bucket will be initialized as an empty one and the
3755 * first_hash will be initialized as (hash_value+1).
3756 */
3759 u64 blk,
3760 u64 new_blk,
3763 {
3780 }
3786 }
3789 OCFS2_JOURNAL_ACCESS_WRITE);
3793 }
3795 /*
3796 * Even if !new_bucket_head, we're overwriting t_bucket. Thus,
3797 * there's no need to read it.
3798 */
3803 }
3805 /*
3806 * Hey, if we're overwriting t_bucket, what difference does
3807 * ACCESS_CREATE vs ACCESS_WRITE make? See the comment in the
3808 * same part of ocfs2_cp_xattr_bucket().
3809 */
3811 new_bucket_head ?
3812 OCFS2_JOURNAL_ACCESS_CREATE :
3813 OCFS2_JOURNAL_ACCESS_WRITE);
3817 }
3826 /*
3827 * initialized a new empty bucket here.
3828 * The hash value is set as one larger than
3829 * that of the last entry in the previous bucket.
3830 */
3840 }
3842 /* copy the whole bucket to the new first. */
3845 /* update the new bucket. */
3848 /*
3849 * Calculate the total name/value len and xh_free_start for
3850 * the old bucket first.
3851 */
3858 xe_len +=
3860 else
3865 }
3867 /*
3868 * Now begin the modification to the new bucket.
3869 *
3870 * In the new bucket, We just move the xattr entry to the beginning
3871 * and don't touch the name/value. So there will be some holes in the
3872 * bucket, and they will be removed when ocfs2_defrag_xattr_bucket is
3873 * called.
3874 */
3888 /* Calculate xh_free_start for the new bucket. */
3894 xe_len +=
3896 else
3901 }
3903 set_num_buckets:
3904 /* set xh->xh_num_buckets for the new xh. */
3907 else
3912 /* store the first_hash of the new bucket. */
3916 /*
3917 * Now only update the 1st block of the old bucket. If we
3918 * just added a new empty bucket, there is no need to modify
3919 * it.
3920 */
3933 out:
3938 }
3940 /*
3941 * Copy xattr from one bucket to another bucket.
3942 *
3943 * The caller must make sure that the journal transaction
3944 * has enough space for journaling.
3945 */
3948 u64 s_blkno,
3949 u64 t_blkno,
3951 {
3959 t_is_new);
3967 }
3973 /*
3974 * Even if !t_is_new, we're overwriting t_bucket. Thus,
3975 * there's no need to read it.
3976 */
3981 /*
3982 * Hey, if we're overwriting t_bucket, what difference does
3983 * ACCESS_CREATE vs ACCESS_WRITE make? Well, if we allocated a new
3984 * cluster to fill, we came here from
3985 * ocfs2_mv_xattr_buckets(), and it is really new -
3986 * ACCESS_CREATE is required. But we also might have moved data
3987 * out of t_bucket before extending back into it.
3988 * ocfs2_add_new_xattr_bucket() can do this - its call to
3989 * ocfs2_add_new_xattr_cluster() may have created a new extent
3990 * and copied out the end of the old extent. Then it re-extends
3991 * the old extent back to create space for new xattrs. That's
3992 * how we get here, and the bucket isn't really new.
3993 */
3995 t_is_new ?
3996 OCFS2_JOURNAL_ACCESS_CREATE :
3997 OCFS2_JOURNAL_ACCESS_WRITE);
4004 out:
4009 }
4011 /*
4012 * src_blk points to the start of an existing extent. last_blk points to
4013 * last cluster in that extent. to_blk points to a newly allocated
4014 * extent. We copy the buckets from the cluster at last_blk to the new
4015 * extent. If start_bucket is non-zero, we skip that many buckets before
4016 * we start copying. The new extent's xh_num_buckets gets set to the
4017 * number of buckets we copied. The old extent's xh_num_buckets shrinks
4018 * by the same amount.
4019 */
4024 {
4038 }
4040 /* The first bucket of the original extent */
4042 /* The first bucket of the new extent */
4048 }
4054 }
4056 /*
4057 * We need to update the first bucket of the old extent and all
4058 * the buckets going to the new extent.
4059 */
4066 }
4069 OCFS2_JOURNAL_ACCESS_WRITE);
4073 }
4083 }
4084 }
4086 /*
4087 * Get the new bucket ready before we dirty anything
4088 * (This actually shouldn't fail, because we already dirtied
4089 * it once in ocfs2_cp_xattr_bucket()).
4090 */
4095 }
4097 OCFS2_JOURNAL_ACCESS_WRITE);
4101 }
4103 /* Now update the headers */
4113 out:
4117 }
4119 /*
4120 * Move some xattrs in this cluster to the new cluster.
4121 * This function should only be called when bucket size == cluster size.
4122 * Otherwise ocfs2_mv_xattr_bucket_cross_cluster should be used instead.
4123 */
4126 u64 prev_blk,
4127 u64 new_blk,
4129 {
4139 }
4141 /* Move half of the xattr in start_blk to the next bucket. */
4144 }
4146 /*
4147 * Move some xattrs from the old cluster to the new one since they are not
4148 * contiguous in ocfs2 xattr tree.
4149 *
4150 * new_blk starts a new separate cluster, and we will move some xattrs from
4151 * prev_blk to it. v_start will be set as the first name hash value in this
4152 * new cluster so that it can be used as e_cpos during tree insertion and
4153 * don't collide with our original b-tree operations. first_bh and header_bh
4154 * will also be updated since they will be used in ocfs2_extend_xattr_bucket
4155 * to extend the insert bucket.
4156 *
4157 * The problem is how much xattr should we move to the new one and when should
4158 * we update first_bh and header_bh?
4159 * 1. If cluster size > bucket size, that means the previous cluster has more
4160 * than 1 bucket, so just move half nums of bucket into the new cluster and
4161 * update the first_bh and header_bh if the insert bucket has been moved
4162 * to the new cluster.
4163 * 2. If cluster_size == bucket_size:
4164 * a) If the previous extent rec has more than one cluster and the insert
4165 * place isn't in the last cluster, copy the entire last cluster to the
4166 * new one. This time, we don't need to upate the first_bh and header_bh
4167 * since they will not be moved into the new cluster.
4168 * b) Otherwise, move the bottom half of the xattrs in the last cluster into
4169 * the new one. And we set the extend flag to zero if the insert place is
4170 * moved into the new allocated cluster since no extend is needed.
4171 */
4176 u64 new_blk,
4177 u32 prev_clusters,
4180 {
4189 handle,
4191 new_blk,
4192 prev_clusters,
4193 v_start);
4197 /* The start of the last cluster in the first extent */
4206 v_start);
4212 v_start);
4218 }
4219 }
4222 }
4224 /*
4225 * Add a new cluster for xattr storage.
4226 *
4227 * If the new cluster is contiguous with the previous one, it will be
4228 * appended to the same extent record, and num_clusters will be updated.
4229 * If not, we will insert a new extent for it and move some xattrs in
4230 * the last cluster into the new allocated one.
4231 * We also need to limit the maximum size of a btree leaf, otherwise we'll
4232 * lose the benefits of hashing because we'll have to search large leaves.
4233 * So now the maximum size is OCFS2_MAX_XATTR_TREE_LEAF_SIZE(or clustersize,
4234 * if it's bigger).
4235 *
4236 * first_bh is the first block of the previous extent rec and header_bh
4237 * indicates the bucket we will insert the new xattrs. They will be updated
4238 * when the header_bh is moved into the new cluster.
4239 */
4245 u32 prev_cpos,
4248 {
4253 u64 block;
4266 OCFS2_JOURNAL_ACCESS_WRITE);
4270 }
4278 }
4288 OCFS2_MAX_XATTR_TREE_LEAF_SIZE) {
4289 /*
4290 * If this cluster is contiguous with the old one and
4291 * adding this new cluster, we don't surpass the limit of
4292 * OCFS2_MAX_XATTR_TREE_LEAF_SIZE, cool. We will let it be
4293 * initialized and used like other buckets in the previous
4294 * cluster.
4295 * So add it as a contiguous one. The caller will handle
4296 * its init process.
4297 */
4301 num_bits);
4304 handle,
4305 first,
4306 target,
4307 block,
4308 prev_clusters,
4310 extend);
4314 }
4315 }
4324 }
4330 leave:
4332 }
4334 /*
4335 * We are given an extent. 'first' is the bucket at the very front of
4336 * the extent. The extent has space for an additional bucket past
4337 * bucket_xh(first)->xh_num_buckets. 'target_blkno' is the block number
4338 * of the target bucket. We wish to shift every bucket past the target
4339 * down one, filling in that additional space. When we get back to the
4340 * target, we split the target between itself and the now-empty bucket
4341 * at target+1 (aka, target_blkno + blks_per_bucket).
4342 */
4346 u64 target_blk,
4347 u32 num_clusters)
4348 {
4352 u64 end_blk;
4359 /* The extent must have room for an additional bucket */
4363 /* end_blk points to the last existing bucket */
4366 /*
4367 * end_blk is the start of the last existing bucket.
4368 * Thus, (end_blk - target_blk) covers the target bucket and
4369 * every bucket after it up to, but not including, the last
4370 * existing bucket. Then we add the last existing bucket, the
4371 * new bucket, and the first bucket (3 * blk_per_bucket).
4372 */
4379 }
4382 OCFS2_JOURNAL_ACCESS_WRITE);
4386 }
4394 }
4396 /* Move half of the xattr in target_blkno to the next bucket. */
4403 out:
4405 }
4407 /*
4408 * Add new xattr bucket in an extent record and adjust the buckets
4409 * accordingly. xb_bh is the ocfs2_xattr_block, and target is the
4410 * bucket we want to insert into.
4411 *
4412 * In the easy case, we will move all the buckets after target down by
4413 * one. Half of target's xattrs will be moved to the next bucket.
4414 *
4415 * If current cluster is full, we'll allocate a new one. This may not
4416 * be contiguous. The underlying calls will make sure that there is
4417 * space for the insert, shifting buckets around if necessary.
4418 * 'target' may be moved by those calls.
4419 */
4424 {
4429 u32 name_hash =
4433 u64 p_blkno;
4435 /* The bucket at the front of the extent */
4441 /* The first bucket of the original extent */
4447 }
4454 }
4460 }
4464 /*
4465 * This can move first+target if the target bucket moves
4466 * to the new extent.
4467 */
4469 xb_bh,
4470 first,
4471 target,
4473 e_cpos,
4475 ctxt);
4479 }
4480 }
4485 first,
4487 num_clusters);
4490 }
4492 out:
4496 }
4501 {
4506 }
4508 /*
4509 * Handle the normal xattr set, including replace, delete and new.
4510 *
4511 * Note: "local" indicates the real data's locality. So we can't
4512 * just its bucket locality by its length.
4513 */
4517 u32 name_hash,
4519 {
4535 else
4539 /*
4540 * If the new value will be stored outside, xi->value has been
4541 * initalized as an empty ocfs2_xattr_value_root, and the same
4542 * goes with xi->value_len, so we can set new_size safely here.
4543 * See ocfs2_xattr_set_in_bucket.
4544 */
4553 /* Now replace the old value with new one. */
4556 else
4571 /*
4572 * Remove the old entry if there is more than one.
4573 * We don't remove the last entry so that we can
4574 * use it to indicate the hash value of the empty
4575 * bucket.
4576 */
4589 }
4591 /* find a new entry for insert. */
4607 }
4608 }
4619 }
4621 set_new_name_value:
4622 /* Insert the new name+value. */
4625 /*
4626 * We must make sure that the name/value pair
4627 * exists in the same block.
4628 */
4636 }
4652 }
4654 /*
4655 * Set the xattr entry in the specified bucket.
4656 * The bucket is indicated by xs->bucket and it should have the enough
4657 * space for the xattr insertion.
4658 */
4663 u32 name_hash,
4665 {
4667 u64 blkno;
4680 }
4681 }
4684 OCFS2_JOURNAL_ACCESS_WRITE);
4688 }
4693 out:
4695 }
4697 /*
4698 * Truncate the specified xe_off entry in xattr bucket.
4699 * bucket is indicated by header_bh and len is the new length.
4700 * Both the ocfs2_xattr_value_root and the entry will be updated here.
4701 *
4702 * Copy the new updated xe and xe_value_root to new_xe and new_xv if needed.
4703 */
4709 {
4711 u64 value_blk;
4717 };
4728 /* We don't allow ocfs2_xattr_value to be stored in different block. */
4737 /*
4738 * From here on out we have to dirty the bucket. The generic
4739 * value calls only modify one of the bucket's bhs, but we need
4740 * to send the bucket at once. So if they error, they *could* have
4741 * modified something. We have to assume they did, and dirty
4742 * the whole bucket. This leaves us in a consistent state.
4743 */
4750 }
4753 OCFS2_JOURNAL_ACCESS_WRITE);
4757 }
4763 out:
4765 }
4771 {
4785 }
4792 {
4806 }
4810 u64 blkno,
4811 u32 cpos,
4812 u32 len)
4813 {
4837 }
4846 }
4847 }
4854 }
4857 OCFS2_JOURNAL_ACCESS_WRITE);
4861 }
4868 }
4876 }
4882 out_commit:
4884 out:
4895 }
4900 {
4907 OCFS2_JOURNAL_ACCESS_WRITE);
4911 }
4913 /* Remove the old entry. */
4920 }
4922 /*
4923 * Set the xattr name/value in the bucket specified in xs.
4924 *
4925 * As the new value in xi may be stored in the bucket or in an outside cluster,
4926 * we divide the whole process into 3 steps:
4927 * 1. insert name/value in the bucket(ocfs2_xattr_set_entry_in_bucket)
4928 * 2. truncate of the outside cluster(ocfs2_xattr_bucket_value_truncate_xs)
4929 * 3. Set the value to the outside cluster(ocfs2_xattr_bucket_set_value_outside)
4930 * 4. If the clusters for the new outside value can't be allocated, we need
4931 * to free the xattr we allocated in set.
4932 */
4937 {
4946 /*
4947 * We need to truncate the xattr storage first.
4948 *
4949 * If both the old and new value are stored to
4950 * outside block, we only need to truncate
4951 * the storage and then set the value outside.
4952 *
4953 * If the new value should be stored within block,
4954 * we should free all the outside block first and
4955 * the modification to the xattr block will be done
4956 * by following steps.
4957 */
4960 else
4964 value_len,
4965 ctxt);
4971 }
4974 /* So we have to handle the inside block change now. */
4976 /*
4977 * If the new value will be stored outside of block,
4978 * initalize a new empty value root and insert it first.
4979 */
4983 }
4990 }
4995 /* allocate the space now for the outside block storage. */
5002 /*
5003 * We can't allocate enough clusters for outside
5004 * storage and we have allocated xattr already,
5005 * so need to remove it.
5006 */
5008 }
5010 }
5012 set_value_outside:
5015 out:
5017 }
5019 /*
5020 * check whether the xattr bucket is filled up with the same hash value.
5021 * If we want to insert the xattr with the same hash, return -ENOSPC.
5022 * If we want to insert a xattr with different hash value, go ahead
5023 * and ocfs2_divide_xattr_bucket will handle this.
5024 */
5028 {
5042 }
5045 }
5051 {
5062 try_again:
5074 header_size);
5087 /*
5088 * We only replace the old value if the new length is smaller
5089 * than the old one. Otherwise we will allocate new space in the
5090 * bucket to store it.
5091 */
5095 else
5100 }
5103 /*
5104 * We need to make sure the new name/value pair
5105 * can exist in the same block.
5106 */
5111 "need = %d, max_free = %d, xh_free_start = %u, xh_name_value_len ="
5122 /*
5123 * We can create the space by defragment. Since only the
5124 * name/value will be moved, the xe shouldn't be changed
5125 * in xs.
5126 */
5132 }
5143 "defragment. Need %u bytes, but we have %d, so "
5145 }
5147 /*
5148 * We have to add new buckets or clusters and one
5149 * allocation should leave us enough space for insert.
5150 */
5153 /*
5154 * We do not allow for overlapping ranges between buckets. And
5155 * the maximum number of collisions we will allow for then is
5156 * one bucket's worth, so check it here whether we need to
5157 * add a new bucket for the insert.
5158 */
5165 }
5170 ctxt);
5174 }
5176 /*
5177 * ocfs2_add_new_xattr_bucket() will have updated
5178 * xs->bucket if it moved, but it will not have updated
5179 * any of the other search fields. Thus, we drop it and
5180 * re-search. Everything should be cached, so it'll be
5181 * quick.
5182 */
5192 }
5194 xattr_set:
5196 out:
5199 }
5204 {
5207 u16 i;
5227 }
5236 }
5237 }
5242 }
5246 {
5252 u64 p_blkno;
5263 }
5266 ocfs2_delete_xattr_in_bucket,
5267 NULL);
5271 }
5278 }
5284 }
5286 out:
5288 }
5290 /*
5291 * 'security' attributes support
5292 */
5296 {
5304 }
5306 }
5310 {
5315 }
5319 {
5325 }
5330 {
5331 /* check whether ocfs2 support feature xattr */
5336 }
5344 {
5346 OCFS2_XATTR_INDEX_SECURITY,
5349 }
5356 };
5358 /*
5359 * 'trusted' attributes support
5360 */
5364 {
5372 }
5374 }
5378 {
5383 }
5387 {
5393 }
5400 };
5402 /*
5403 * 'user' attributes support
5404 */
5408 {
5420 }
5422 }
5426 {
5435 }
5439 {
5449 }
5456 };