| blob | 915039fffe6ed37149a47d1929929f79b0865d5c |
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);
283 }
288 }
293 {
302 }
303 }
306 }
310 {
319 }
323 {
332 blocksize);
333 }
334 }
338 {
348 /*
349 * If the ecc fails, we return the error but otherwise
350 * leave the filesystem running. We know any error is
351 * local to this block.
352 */
357 /*
358 * Errors after here are fatal
359 */
363 "Extended attribute block #%llu has bad "
368 }
372 "Extended attribute block #%llu has an "
377 }
381 "Extended attribute block #%llu has an invalid "
386 }
389 }
393 {
398 ocfs2_validate_xattr_block);
400 /* If ocfs2_read_block() got us a new bh, pass it up. */
405 }
408 {
415 }
420 {
421 /* Get hash value of uuid from super block */
425 /* hash extended attribute name */
430 }
433 }
435 /*
436 * ocfs2_xattr_hash_entry()
437 *
438 * Compute the hash of an extended attribute.
439 */
443 {
451 }
454 {
459 else
464 }
471 {
477 /*
478 * The max space of security xattr taken inline is
479 * 256(name) + 80(value) + 16(entry) = 352 bytes,
480 * So reserve one metadata block for it is ok.
481 */
488 }
490 }
492 /* reserve clusters for xattr value which will be set in B tree*/
498 new_clusters);
500 }
502 }
511 {
522 OCFS2_XATTR_INDEX_POSIX_ACL_DEFAULT,
531 }
532 }
537 /*
538 * The max space of security xattr taken inline is
539 * 256(name) + 80(value) + 16(entry) = 352 bytes,
540 * The max space of acl xattr taken inline is
541 * 80(value) + 16(entry) * 2(if directory) = 192 bytes,
542 * when blocksize = 512, may reserve one more cluser for
543 * xattr bucket, otherwise reserve one metadata block
544 * for them is ok.
545 */
552 }
554 }
560 }
562 /*
563 * reserve credits and clusters for xattrs which has large value
564 * and have to be set outside
565 */
570 new_clusters);
572 }
575 /* for directory, it has DEFAULT and ACCESS two types of acls */
579 new_clusters);
581 }
584 }
587 u32 clusters_to_add,
590 {
603 OCFS2_JOURNAL_ACCESS_WRITE);
607 }
611 inode,
613 clusters_to_add,
616 handle,
623 }
629 }
633 /*
634 * We should have already allocated enough space before the transaction,
635 * so no need to restart.
636 */
639 leave:
642 }
648 {
657 OCFS2_JOURNAL_ACCESS_WRITE);
661 }
668 }
676 }
682 out:
684 }
687 u32 old_clusters,
688 u32 new_clusters,
691 {
694 u64 block;
708 }
715 ctxt);
719 }
723 alloc_size);
726 }
728 out:
730 }
736 {
748 else
754 }
759 {
766 /* we are just looking for how big our buffer needs to be */
778 }
783 {
802 }
803 }
806 }
812 {
827 }
833 {
846 }
857 }
862 }
867 {
883 }
895 }
900 }
907 }
912 {
929 name_len);
933 }
937 }
943 {
945 u64 blkno;
963 }
966 /* Copy ocfs2_xattr_value */
972 }
983 }
985 }
986 out:
988 }
996 {
1033 }
1034 }
1035 }
1038 }
1046 {
1057 }
1063 }
1068 }
1084 i,
1088 }
1100 }
1101 }
1102 }
1104 cleanup:
1110 }
1118 {
1124 };
1127 };
1147 }
1149 /* ocfs2_xattr_get()
1150 *
1151 * Copy an extended attribute into the buffer provided.
1152 * Buffer is NULL to compute the size of buffer required.
1153 */
1159 {
1167 }
1176 }
1183 {
1189 u64 blkno;
1200 }
1209 }
1212 inode,
1213 bh,
1214 OCFS2_JOURNAL_ACCESS_WRITE);
1218 }
1232 }
1236 /*
1237 * XXX: do we need to empty all the following
1238 * blocks in this cluster?
1239 */
1242 }
1244 }
1245 out:
1249 }
1257 {
1264 OCFS2_JOURNAL_ACCESS_WRITE);
1268 }
1269 /* Decrease xattr count */
1271 /* Remove the xattr entry and tree root which has already be set*/
1278 out:
1280 }
1288 {
1292 OCFS2_JOURNAL_ACCESS_WRITE);
1296 }
1302 else
1309 out:
1311 }
1313 /*
1314 * ocfs2_xattr_set_value_outside()
1315 *
1316 * Set large size value in B tree.
1317 */
1324 {
1346 }
1351 }
1358 }
1360 /*
1361 * ocfs2_xattr_set_entry_local()
1362 *
1363 * Set, replace or remove extended attribute in local.
1364 */
1370 {
1375 /* Insert the new xattr entry. */
1390 OCFS2_XATTR_INLINE_SIZE)
1392 OCFS2_XATTR_ROOT_SIZE;
1393 else
1399 /* The old and the new value have the
1400 same size. Just replace the value. */
1403 /* Clear value bytes. */
1411 }
1412 /* Remove the old name+value. */
1422 /* Adjust all value offsets. */
1430 }
1433 /* Remove the old entry. */
1439 }
1440 }
1442 /* Insert the new name+value. */
1456 }
1459 }
1461 /*
1462 * ocfs2_xattr_set_entry()
1463 *
1464 * Set extended attribute entry into inode or block.
1465 *
1466 * If extended attribute value size > OCFS2_XATTR_INLINE_SIZE,
1467 * We first insert tree root(ocfs2_xattr_value_root) with set_entry_local(),
1468 * then set value in B tree with set_value_outside().
1469 */
1475 {
1488 };
1492 };
1500 /* Compute min_offs, last and free space. */
1508 }
1519 else
1521 OCFS2_XATTR_ROOT_SIZE;
1523 }
1524 /* Check free space in inode or block */
1528 OCFS2_XATTR_ROOT_SIZE) {
1531 }
1541 }
1542 }
1545 /* For existing extended attribute */
1552 /* Replace existing local xattr with tree root */
1559 /* For existing xattr which has value outside */
1564 /*
1565 * If new value need set outside also,
1566 * first truncate old value to new value,
1567 * then set new value with set_value_outside().
1568 */
1572 ctxt);
1576 }
1579 handle,
1580 xi,
1581 xs,
1583 offs);
1587 }
1590 handle,
1598 /*
1599 * If new value need set in local,
1600 * just trucate old value to zero.
1601 */
1605 ctxt);
1608 }
1609 }
1610 }
1613 OCFS2_JOURNAL_ACCESS_WRITE);
1617 }
1621 OCFS2_JOURNAL_ACCESS_WRITE);
1625 }
1626 }
1628 /*
1629 * Set value in local, include set tree root in local.
1630 * This is the first step for value size >INLINE_SIZE.
1631 */
1639 }
1640 }
1647 /*
1648 * Adjust extent record count or inline data size
1649 * to reserve space for extended attribute.
1650 */
1658 }
1660 }
1661 /* Update xattr flag */
1672 /*
1673 * Set value outside in B tree.
1674 * This is the second step for value size > INLINE_SIZE.
1675 */
1683 /*
1684 * If set value outside failed, we have to clean
1685 * the junk tree root we have already set in local.
1686 */
1691 }
1692 }
1693 out:
1695 }
1700 {
1713 }
1729 }
1730 }
1731 }
1736 out:
1738 }
1742 {
1750 };
1759 }
1763 {
1769 };
1779 }
1782 u64 block)
1783 {
1792 u16 bit;
1798 }
1804 }
1812 EXTENT_ALLOC_SYSTEM_INODE,
1818 }
1825 }
1832 }
1840 out_unlock:
1843 out_mutex:
1846 out:
1849 }
1851 /*
1852 * ocfs2_xattr_remove()
1853 *
1854 * Free extended attribute resources associated with this inode.
1855 */
1857 {
1874 }
1875 }
1883 }
1884 }
1887 OCFS2_INODE_UPDATE_CREDITS);
1892 }
1894 OCFS2_JOURNAL_ACCESS_WRITE);
1898 }
1910 out_commit:
1912 out:
1914 }
1918 {
1937 }
1942 }
1944 /*
1945 * ocfs2_xattr_ibody_find()
1946 *
1947 * Find extended attribute in inode block and
1948 * fill search info into struct ocfs2_xattr_search.
1949 */
1954 {
1969 }
1976 else
1982 /* Find the named attribute. */
1988 }
1991 }
1993 /*
1994 * ocfs2_xattr_ibody_set()
1995 *
1996 * Set, replace or remove an extended attribute into inode block.
1997 *
1998 */
2003 {
2016 }
2017 }
2021 out:
2025 }
2027 /*
2028 * ocfs2_xattr_block_find()
2029 *
2030 * Find extended attribute in external block and
2031 * fill search info into struct ocfs2_xattr_search.
2032 */
2037 {
2051 }
2065 name_index,
2071 }
2074 cleanup:
2078 }
2080 /*
2081 * ocfs2_xattr_block_set()
2082 *
2083 * Set, replace or remove an extended attribute into external block.
2084 *
2085 */
2090 {
2096 u16 suballoc_bit_start;
2097 u32 num_got;
2098 u64 first_blkno;
2103 OCFS2_JOURNAL_ACCESS_CREATE);
2107 }
2115 }
2121 OCFS2_JOURNAL_ACCESS_CREATE);
2125 }
2127 /* Initialize ocfs2_xattr_block */
2146 }
2153 /* Set extended attribute into external block */
2155 OCFS2_HAS_XATTR_FL);
2162 }
2166 end:
2169 }
2171 /* Check whether the new xattr can be inserted into the inode. */
2175 {
2176 u64 value_size;
2191 }
2201 else
2209 }
2219 {
2230 u64 value_size;
2232 /*
2233 * Calculate the clusters we need to write.
2234 * No matter whether we replace an old one or add a new one,
2235 * we need this for writing.
2236 */
2248 new_clusters);
2249 }
2252 }
2279 }
2280 }
2282 /*
2283 * delete a xattr doesn't need metadata and cluster allocation.
2284 * so just calculate the credits and return.
2285 *
2286 * The credits for removing the value tree will be extended
2287 * by ocfs2_remove_extent itself.
2288 */
2294 }
2296 /* do cluster allocation guess first. */
2300 /*
2301 * In xattr set, we always try to set the xe in inode first,
2302 * so if it can be inserted into inode successfully, the old
2303 * one will be removed from the xattr block, and this xattr
2304 * will be inserted into inode as a new xattr in inode.
2305 */
2309 OCFS2_INODE_UPDATE_CREDITS;
2314 new_clusters);
2316 }
2317 }
2320 /* the new values will be stored outside. */
2325 value_size);
2340 new_clusters -
2341 old_clusters);
2344 }
2346 /*
2347 * Now the new value will be stored inside. So if the new
2348 * value is smaller than the size of value root or the old
2349 * value, we don't need any allocation, otherwise we have
2350 * to guess metadata allocation.
2351 */
2356 }
2358 meta_guess:
2359 /* calculate metadata allocation. */
2368 }
2374 /*
2375 * If there is already an xattr tree, good, we can calculate
2376 * like other b-trees. Otherwise we may have the chance of
2377 * create a tree, the credit calculation is borrowed from
2378 * ocfs2_calc_extend_credits with root_el = NULL. And the
2379 * new tree will be cluster based, so no meta is needed.
2380 */
2390 /*
2391 * This cluster will be used either for new bucket or for
2392 * new xattr block.
2393 * If the cluster size is the same as the bucket size, one
2394 * more is needed since we may need to extend the bucket
2395 * also.
2396 */
2403 }
2407 }
2408 out:
2417 }
2426 {
2439 }
2450 }
2451 }
2457 }
2458 out:
2463 }
2465 /*
2466 * We cannot have an error and a non null ctxt->data_ac.
2467 */
2468 }
2471 }
2479 {
2483 /* Remove existing extended attribute */
2489 /* We always try to set extended attribute into inode first*/
2492 /*
2493 * If succeed and that extended attribute existing in
2494 * external block, then we will remove it.
2495 */
2502 di,
2503 xi,
2504 xis,
2505 xbs,
2506 NULL,
2507 NULL,
2513 }
2520 }
2533 di,
2534 xi,
2535 xis,
2536 xbs,
2537 NULL,
2538 NULL,
2544 }
2551 }
2552 }
2553 /*
2554 * If no space in inode, we will set extended attribute
2555 * into external block.
2556 */
2561 /*
2562 * If succeed and that extended attribute
2563 * existing in inode, we will remove it.
2564 */
2569 di,
2570 xi,
2571 xis,
2572 xbs,
2573 NULL,
2574 NULL,
2579 }
2586 }
2589 }
2590 }
2591 }
2594 /* Update inode ctime. */
2596 OCFS2_JOURNAL_ACCESS_WRITE);
2600 }
2606 }
2607 out:
2609 }
2611 /*
2612 * This function only called duing creating inode
2613 * for init security/acl xattrs of the new inode.
2614 * All transanction credits have been reserved in mknod.
2615 */
2626 {
2635 };
2639 };
2643 };
2649 };
2654 /*
2655 * In extreme situation, may need xattr bucket when
2656 * block size is too small. And we have already reserved
2657 * the credits for bucket in mknod.
2658 */
2664 }
2665 }
2679 }
2683 cleanup:
2689 }
2691 /*
2692 * ocfs2_xattr_set()
2693 *
2694 * Set, replace or remove an extended attribute for this inode.
2695 * value is NULL to remove an existing extended attribute, else either
2696 * create or replace an extended attribute.
2697 */
2704 {
2717 };
2721 };
2725 };
2730 /*
2731 * Only xbs will be used on indexed trees. xis doesn't need a
2732 * bucket.
2733 */
2738 }
2744 }
2749 /*
2750 * Scan inode and external block to find the same name
2751 * extended attribute and collect search infomation.
2752 */
2760 }
2773 }
2784 }
2785 }
2793 }
2795 /* we need to update inode's ctime field, so add credit for it. */
2802 }
2815 cleanup:
2818 cleanup_nolock:
2824 }
2826 /*
2827 * Find the xattr extent rec which may contains name_hash.
2828 * e_cpos will be the first name hash of the xattr rec.
2829 * el must be the ocfs2_xattr_header.xb_attrs.xb_root.xt_list.
2830 */
2832 u32 name_hash,
2837 {
2849 }
2856 "Inode %lu has non zero tree depth in "
2861 }
2862 }
2870 }
2871 }
2880 }
2886 out:
2889 }
2899 u32 name_hash,
2902 {
2909 /*
2910 * We don't use binary search in the bucket because there
2911 * may be multiple entries with the same name hash.
2912 */
2928 xh,
2929 i,
2935 }
2944 }
2945 }
2948 }
2950 /*
2951 * Find the specified xattr entry in a series of buckets.
2952 * This series start from p_blkno and last for num_clusters.
2953 * The ocfs2_xattr_header.xh_num_buckets of the first bucket contains
2954 * the num of the valid buckets.
2955 *
2956 * Return the buffer_head this xattr should reside in. And if the xattr's
2957 * hash is in the gap of 2 buckets, return the lower bucket.
2958 */
2962 u32 name_hash,
2963 u64 p_blkno,
2964 u32 first_hash,
2965 u32 num_clusters,
2967 {
2975 u32 last_hash;
2983 }
2989 }
3002 }
3009 }
3011 /*
3012 * Check whether the hash of the last entry in our
3013 * bucket is larger than the search one. for an empty
3014 * bucket, the last one is also the first one.
3015 */
3021 /* record lower_blkno which may be the insert place. */
3027 }
3029 /* the searched xattr should reside in this bucket if exists. */
3036 }
3038 }
3040 /*
3041 * Record the bucket we have found.
3042 * When the xattr's hash value is in the gap of 2 buckets, we will
3043 * always set it to the previous bucket.
3044 */
3048 /* This should be in cache - we just read it during the search */
3053 }
3066 out:
3069 }
3076 {
3097 }
3103 first_hash);
3108 out:
3110 }
3113 u64 blkno,
3114 u32 clusters,
3117 {
3127 }
3137 }
3139 /*
3140 * The real bucket num in this series of blocks is stored
3141 * in the 1st bucket.
3142 */
3153 /* Fall through to bucket_relse() */
3154 }
3159 }
3163 }
3169 };
3176 {
3177 u16 name_offset;
3188 }
3193 {
3207 i,
3214 new_offset;
3222 }
3223 }
3226 }
3232 {
3241 };
3252 }
3255 ocfs2_list_xattr_bucket,
3260 }
3266 }
3269 out:
3271 }
3274 {
3284 }
3287 {
3293 }
3295 /*
3296 * When the ocfs2_xattr_block is filled up, new bucket will be created
3297 * and all the xattr entries will be moved to the new bucket.
3298 * The header goes at the start of the bucket, and the names+values are
3299 * filled from the end. This is why *target starts as the last buffer.
3300 * Note: we need to sort the entries since they are not saved in order
3301 * in the ocfs2_xattr_block.
3302 */
3306 {
3326 /*
3327 * Since the xe_name_offset is based on ocfs2_xattr_header,
3328 * there is a offset change corresponding to the change of
3329 * ocfs2_xattr_header's position.
3330 */
3336 /* copy all the names and values. */
3339 /* Init new header now. */
3345 /* copy all the entries. */
3351 /* Change the xe offset for all the xe because of the move. */
3362 }
3364 /*
3365 * After we move xattr from block to index btree, we have to
3366 * update ocfs2_xattr_search to the new xe and base.
3367 *
3368 * When the entry is in xattr block, xattr_bh indicates the storage place.
3369 * While if the entry is in index b-tree, "bucket" indicates the
3370 * real place of the xattr.
3371 */
3375 {
3390 }
3395 {
3398 u64 blkno;
3414 /*
3415 * XXX:
3416 * We can use this lock for now, and maybe move to a dedicated mutex
3417 * if performance becomes a problem later.
3418 */
3422 OCFS2_JOURNAL_ACCESS_WRITE);
3426 }
3433 }
3435 /*
3436 * The bucket may spread in many blocks, and
3437 * we will only touch the 1st block and the last block
3438 * in the whole bucket(one for entry and one for data).
3439 */
3449 }
3452 OCFS2_JOURNAL_ACCESS_CREATE);
3456 }
3463 /* Change from ocfs2_xattr_header to ocfs2_xattr_tree_root */
3482 out:
3486 }
3489 {
3499 }
3501 /*
3502 * defrag a xattr bucket if we find that the bucket has some
3503 * holes beteen name/value pairs.
3504 * We will move all the name/value pairs to the end of the bucket
3505 * so that we can spare some space for insertion.
3506 */
3510 {
3516 u16 xh_free_start;
3520 /*
3521 * In order to make the operation more efficient and generic,
3522 * we copy all the blocks into a contiguous memory and do the
3523 * defragment there, so if anything is error, we will not touch
3524 * the real block.
3525 */
3530 }
3537 OCFS2_JOURNAL_ACCESS_WRITE);
3541 }
3552 /*
3553 * sort all the entries by their offset.
3554 * the largest will be the first, so that we can
3555 * move them to the end one by one.
3556 */
3561 /* Move all name/values to the end of the bucket. */
3569 else
3573 /*
3574 * We must make sure that the name/value pair
3575 * exist in the same block. So adjust end to
3576 * the previous block end if needed.
3577 */
3586 }
3592 }
3603 /* sort the entries by their name_hash. */
3613 out:
3616 }
3618 /*
3619 * prev_blkno points to the start of an existing extent. new_blkno
3620 * points to a newly allocated extent. Because we know each of our
3621 * clusters contains more than bucket, we can easily split one cluster
3622 * at a bucket boundary. So we take the last cluster of the existing
3623 * extent and split it down the middle. We move the last half of the
3624 * buckets in the last cluster of the existing extent over to the new
3625 * extent.
3626 *
3627 * first_bh is the buffer at prev_blkno so we can update the existing
3628 * extent's bucket count. header_bh is the bucket were we were hoping
3629 * to insert our xattr. If the bucket move places the target in the new
3630 * extent, we'll update first_bh and header_bh after modifying the old
3631 * extent.
3632 *
3633 * first_hash will be set as the 1st xe's name_hash in the new extent.
3634 */
3639 u64 new_blkno,
3640 u32 num_clusters,
3642 {
3648 u64 src_blkno;
3664 }
3666 /* This is the first bucket that got moved */
3669 /*
3670 * If the target bucket was part of the moved buckets, we need to
3671 * update first and target.
3672 */
3674 /* Find the block for the new target bucket */
3681 /*
3682 * These shouldn't fail - the buffers are in the
3683 * journal from ocfs2_cp_xattr_bucket().
3684 */
3689 }
3694 }
3696 out:
3698 }
3700 /*
3701 * Find the suitable pos when we divide a bucket into 2.
3702 * We have to make sure the xattrs with the same hash value exist
3703 * in the same bucket.
3704 *
3705 * If this ocfs2_xattr_header covers more than one hash value, find a
3706 * place where the hash value changes. Try to find the most even split.
3707 * The most common case is that all entries have different hash values,
3708 * and the first check we make will find a place to split.
3709 */
3711 {
3716 /*
3717 * We start at the middle. Each step gets farther away in both
3718 * directions. We therefore hit the change in hash value
3719 * nearest to the middle. Note that this loop does not execute for
3720 * count < 2.
3721 */
3723 /* Let's check delta earlier than middle */
3728 /* For even counts, don't walk off the end */
3732 /* Now try delta past middle */
3736 }
3738 /* Every entry had the same hash */
3740 }
3742 /*
3743 * Move some xattrs in old bucket(blk) to new bucket(new_blk).
3744 * first_hash will record the 1st hash of the new bucket.
3745 *
3746 * Normally half of the xattrs will be moved. But we have to make
3747 * sure that the xattrs with the same hash value are stored in the
3748 * same bucket. If all the xattrs in this bucket have the same hash
3749 * value, the new bucket will be initialized as an empty one and the
3750 * first_hash will be initialized as (hash_value+1).
3751 */
3754 u64 blk,
3755 u64 new_blk,
3758 {
3775 }
3781 }
3784 OCFS2_JOURNAL_ACCESS_WRITE);
3788 }
3790 /*
3791 * Even if !new_bucket_head, we're overwriting t_bucket. Thus,
3792 * there's no need to read it.
3793 */
3798 }
3800 /*
3801 * Hey, if we're overwriting t_bucket, what difference does
3802 * ACCESS_CREATE vs ACCESS_WRITE make? See the comment in the
3803 * same part of ocfs2_cp_xattr_bucket().
3804 */
3806 new_bucket_head ?
3807 OCFS2_JOURNAL_ACCESS_CREATE :
3808 OCFS2_JOURNAL_ACCESS_WRITE);
3812 }
3821 /*
3822 * initialized a new empty bucket here.
3823 * The hash value is set as one larger than
3824 * that of the last entry in the previous bucket.
3825 */
3835 }
3837 /* copy the whole bucket to the new first. */
3840 /* update the new bucket. */
3843 /*
3844 * Calculate the total name/value len and xh_free_start for
3845 * the old bucket first.
3846 */
3853 xe_len +=
3855 else
3860 }
3862 /*
3863 * Now begin the modification to the new bucket.
3864 *
3865 * In the new bucket, We just move the xattr entry to the beginning
3866 * and don't touch the name/value. So there will be some holes in the
3867 * bucket, and they will be removed when ocfs2_defrag_xattr_bucket is
3868 * called.
3869 */
3883 /* Calculate xh_free_start for the new bucket. */
3889 xe_len +=
3891 else
3896 }
3898 set_num_buckets:
3899 /* set xh->xh_num_buckets for the new xh. */
3902 else
3907 /* store the first_hash of the new bucket. */
3911 /*
3912 * Now only update the 1st block of the old bucket. If we
3913 * just added a new empty bucket, there is no need to modify
3914 * it.
3915 */
3928 out:
3933 }
3935 /*
3936 * Copy xattr from one bucket to another bucket.
3937 *
3938 * The caller must make sure that the journal transaction
3939 * has enough space for journaling.
3940 */
3943 u64 s_blkno,
3944 u64 t_blkno,
3946 {
3954 t_is_new);
3962 }
3968 /*
3969 * Even if !t_is_new, we're overwriting t_bucket. Thus,
3970 * there's no need to read it.
3971 */
3976 /*
3977 * Hey, if we're overwriting t_bucket, what difference does
3978 * ACCESS_CREATE vs ACCESS_WRITE make? Well, if we allocated a new
3979 * cluster to fill, we came here from
3980 * ocfs2_mv_xattr_buckets(), and it is really new -
3981 * ACCESS_CREATE is required. But we also might have moved data
3982 * out of t_bucket before extending back into it.
3983 * ocfs2_add_new_xattr_bucket() can do this - its call to
3984 * ocfs2_add_new_xattr_cluster() may have created a new extent
3985 * and copied out the end of the old extent. Then it re-extends
3986 * the old extent back to create space for new xattrs. That's
3987 * how we get here, and the bucket isn't really new.
3988 */
3990 t_is_new ?
3991 OCFS2_JOURNAL_ACCESS_CREATE :
3992 OCFS2_JOURNAL_ACCESS_WRITE);
3999 out:
4004 }
4006 /*
4007 * src_blk points to the start of an existing extent. last_blk points to
4008 * last cluster in that extent. to_blk points to a newly allocated
4009 * extent. We copy the buckets from the cluster at last_blk to the new
4010 * extent. If start_bucket is non-zero, we skip that many buckets before
4011 * we start copying. The new extent's xh_num_buckets gets set to the
4012 * number of buckets we copied. The old extent's xh_num_buckets shrinks
4013 * by the same amount.
4014 */
4019 {
4033 }
4035 /* The first bucket of the original extent */
4037 /* The first bucket of the new extent */
4043 }
4049 }
4051 /*
4052 * We need to update the first bucket of the old extent and all
4053 * the buckets going to the new extent.
4054 */
4061 }
4064 OCFS2_JOURNAL_ACCESS_WRITE);
4068 }
4078 }
4079 }
4081 /*
4082 * Get the new bucket ready before we dirty anything
4083 * (This actually shouldn't fail, because we already dirtied
4084 * it once in ocfs2_cp_xattr_bucket()).
4085 */
4090 }
4092 OCFS2_JOURNAL_ACCESS_WRITE);
4096 }
4098 /* Now update the headers */
4108 out:
4112 }
4114 /*
4115 * Move some xattrs in this cluster to the new cluster.
4116 * This function should only be called when bucket size == cluster size.
4117 * Otherwise ocfs2_mv_xattr_bucket_cross_cluster should be used instead.
4118 */
4121 u64 prev_blk,
4122 u64 new_blk,
4124 {
4134 }
4136 /* Move half of the xattr in start_blk to the next bucket. */
4139 }
4141 /*
4142 * Move some xattrs from the old cluster to the new one since they are not
4143 * contiguous in ocfs2 xattr tree.
4144 *
4145 * new_blk starts a new separate cluster, and we will move some xattrs from
4146 * prev_blk to it. v_start will be set as the first name hash value in this
4147 * new cluster so that it can be used as e_cpos during tree insertion and
4148 * don't collide with our original b-tree operations. first_bh and header_bh
4149 * will also be updated since they will be used in ocfs2_extend_xattr_bucket
4150 * to extend the insert bucket.
4151 *
4152 * The problem is how much xattr should we move to the new one and when should
4153 * we update first_bh and header_bh?
4154 * 1. If cluster size > bucket size, that means the previous cluster has more
4155 * than 1 bucket, so just move half nums of bucket into the new cluster and
4156 * update the first_bh and header_bh if the insert bucket has been moved
4157 * to the new cluster.
4158 * 2. If cluster_size == bucket_size:
4159 * a) If the previous extent rec has more than one cluster and the insert
4160 * place isn't in the last cluster, copy the entire last cluster to the
4161 * new one. This time, we don't need to upate the first_bh and header_bh
4162 * since they will not be moved into the new cluster.
4163 * b) Otherwise, move the bottom half of the xattrs in the last cluster into
4164 * the new one. And we set the extend flag to zero if the insert place is
4165 * moved into the new allocated cluster since no extend is needed.
4166 */
4171 u64 new_blk,
4172 u32 prev_clusters,
4175 {
4184 handle,
4186 new_blk,
4187 prev_clusters,
4188 v_start);
4192 /* The start of the last cluster in the first extent */
4201 v_start);
4207 v_start);
4213 }
4214 }
4217 }
4219 /*
4220 * Add a new cluster for xattr storage.
4221 *
4222 * If the new cluster is contiguous with the previous one, it will be
4223 * appended to the same extent record, and num_clusters will be updated.
4224 * If not, we will insert a new extent for it and move some xattrs in
4225 * the last cluster into the new allocated one.
4226 * We also need to limit the maximum size of a btree leaf, otherwise we'll
4227 * lose the benefits of hashing because we'll have to search large leaves.
4228 * So now the maximum size is OCFS2_MAX_XATTR_TREE_LEAF_SIZE(or clustersize,
4229 * if it's bigger).
4230 *
4231 * first_bh is the first block of the previous extent rec and header_bh
4232 * indicates the bucket we will insert the new xattrs. They will be updated
4233 * when the header_bh is moved into the new cluster.
4234 */
4240 u32 prev_cpos,
4243 {
4248 u64 block;
4261 OCFS2_JOURNAL_ACCESS_WRITE);
4265 }
4273 }
4283 OCFS2_MAX_XATTR_TREE_LEAF_SIZE) {
4284 /*
4285 * If this cluster is contiguous with the old one and
4286 * adding this new cluster, we don't surpass the limit of
4287 * OCFS2_MAX_XATTR_TREE_LEAF_SIZE, cool. We will let it be
4288 * initialized and used like other buckets in the previous
4289 * cluster.
4290 * So add it as a contiguous one. The caller will handle
4291 * its init process.
4292 */
4296 num_bits);
4299 handle,
4300 first,
4301 target,
4302 block,
4303 prev_clusters,
4305 extend);
4309 }
4310 }
4319 }
4325 leave:
4327 }
4329 /*
4330 * We are given an extent. 'first' is the bucket at the very front of
4331 * the extent. The extent has space for an additional bucket past
4332 * bucket_xh(first)->xh_num_buckets. 'target_blkno' is the block number
4333 * of the target bucket. We wish to shift every bucket past the target
4334 * down one, filling in that additional space. When we get back to the
4335 * target, we split the target between itself and the now-empty bucket
4336 * at target+1 (aka, target_blkno + blks_per_bucket).
4337 */
4341 u64 target_blk,
4342 u32 num_clusters)
4343 {
4347 u64 end_blk;
4354 /* The extent must have room for an additional bucket */
4358 /* end_blk points to the last existing bucket */
4361 /*
4362 * end_blk is the start of the last existing bucket.
4363 * Thus, (end_blk - target_blk) covers the target bucket and
4364 * every bucket after it up to, but not including, the last
4365 * existing bucket. Then we add the last existing bucket, the
4366 * new bucket, and the first bucket (3 * blk_per_bucket).
4367 */
4374 }
4377 OCFS2_JOURNAL_ACCESS_WRITE);
4381 }
4389 }
4391 /* Move half of the xattr in target_blkno to the next bucket. */
4398 out:
4400 }
4402 /*
4403 * Add new xattr bucket in an extent record and adjust the buckets
4404 * accordingly. xb_bh is the ocfs2_xattr_block, and target is the
4405 * bucket we want to insert into.
4406 *
4407 * In the easy case, we will move all the buckets after target down by
4408 * one. Half of target's xattrs will be moved to the next bucket.
4409 *
4410 * If current cluster is full, we'll allocate a new one. This may not
4411 * be contiguous. The underlying calls will make sure that there is
4412 * space for the insert, shifting buckets around if necessary.
4413 * 'target' may be moved by those calls.
4414 */
4419 {
4424 u32 name_hash =
4428 u64 p_blkno;
4430 /* The bucket at the front of the extent */
4436 /* The first bucket of the original extent */
4442 }
4449 }
4455 }
4459 /*
4460 * This can move first+target if the target bucket moves
4461 * to the new extent.
4462 */
4464 xb_bh,
4465 first,
4466 target,
4468 e_cpos,
4470 ctxt);
4474 }
4475 }
4480 first,
4482 num_clusters);
4485 }
4487 out:
4491 }
4496 {
4501 }
4503 /*
4504 * Handle the normal xattr set, including replace, delete and new.
4505 *
4506 * Note: "local" indicates the real data's locality. So we can't
4507 * just its bucket locality by its length.
4508 */
4512 u32 name_hash,
4514 {
4530 else
4534 /*
4535 * If the new value will be stored outside, xi->value has been
4536 * initalized as an empty ocfs2_xattr_value_root, and the same
4537 * goes with xi->value_len, so we can set new_size safely here.
4538 * See ocfs2_xattr_set_in_bucket.
4539 */
4548 /* Now replace the old value with new one. */
4551 else
4566 /*
4567 * Remove the old entry if there is more than one.
4568 * We don't remove the last entry so that we can
4569 * use it to indicate the hash value of the empty
4570 * bucket.
4571 */
4584 }
4586 /* find a new entry for insert. */
4602 }
4603 }
4614 }
4616 set_new_name_value:
4617 /* Insert the new name+value. */
4620 /*
4621 * We must make sure that the name/value pair
4622 * exists in the same block.
4623 */
4631 }
4647 }
4649 /*
4650 * Set the xattr entry in the specified bucket.
4651 * The bucket is indicated by xs->bucket and it should have the enough
4652 * space for the xattr insertion.
4653 */
4658 u32 name_hash,
4660 {
4662 u64 blkno;
4675 }
4676 }
4679 OCFS2_JOURNAL_ACCESS_WRITE);
4683 }
4688 out:
4690 }
4692 /*
4693 * Truncate the specified xe_off entry in xattr bucket.
4694 * bucket is indicated by header_bh and len is the new length.
4695 * Both the ocfs2_xattr_value_root and the entry will be updated here.
4696 *
4697 * Copy the new updated xe and xe_value_root to new_xe and new_xv if needed.
4698 */
4704 {
4706 u64 value_blk;
4712 };
4723 /* We don't allow ocfs2_xattr_value to be stored in different block. */
4732 /*
4733 * From here on out we have to dirty the bucket. The generic
4734 * value calls only modify one of the bucket's bhs, but we need
4735 * to send the bucket at once. So if they error, they *could* have
4736 * modified something. We have to assume they did, and dirty
4737 * the whole bucket. This leaves us in a consistent state.
4738 */
4745 }
4748 OCFS2_JOURNAL_ACCESS_WRITE);
4752 }
4758 out:
4760 }
4766 {
4780 }
4787 {
4801 }
4805 u64 blkno,
4806 u32 cpos,
4807 u32 len)
4808 {
4832 }
4841 }
4842 }
4849 }
4852 OCFS2_JOURNAL_ACCESS_WRITE);
4856 }
4863 }
4871 }
4877 out_commit:
4879 out:
4890 }
4895 {
4902 OCFS2_JOURNAL_ACCESS_WRITE);
4906 }
4908 /* Remove the old entry. */
4915 }
4917 /*
4918 * Set the xattr name/value in the bucket specified in xs.
4919 *
4920 * As the new value in xi may be stored in the bucket or in an outside cluster,
4921 * we divide the whole process into 3 steps:
4922 * 1. insert name/value in the bucket(ocfs2_xattr_set_entry_in_bucket)
4923 * 2. truncate of the outside cluster(ocfs2_xattr_bucket_value_truncate_xs)
4924 * 3. Set the value to the outside cluster(ocfs2_xattr_bucket_set_value_outside)
4925 * 4. If the clusters for the new outside value can't be allocated, we need
4926 * to free the xattr we allocated in set.
4927 */
4932 {
4941 /*
4942 * We need to truncate the xattr storage first.
4943 *
4944 * If both the old and new value are stored to
4945 * outside block, we only need to truncate
4946 * the storage and then set the value outside.
4947 *
4948 * If the new value should be stored within block,
4949 * we should free all the outside block first and
4950 * the modification to the xattr block will be done
4951 * by following steps.
4952 */
4955 else
4959 value_len,
4960 ctxt);
4966 }
4969 /* So we have to handle the inside block change now. */
4971 /*
4972 * If the new value will be stored outside of block,
4973 * initalize a new empty value root and insert it first.
4974 */
4978 }
4985 }
4990 /* allocate the space now for the outside block storage. */
4997 /*
4998 * We can't allocate enough clusters for outside
4999 * storage and we have allocated xattr already,
5000 * so need to remove it.
5001 */
5003 }
5005 }
5007 set_value_outside:
5010 out:
5012 }
5014 /*
5015 * check whether the xattr bucket is filled up with the same hash value.
5016 * If we want to insert the xattr with the same hash, return -ENOSPC.
5017 * If we want to insert a xattr with different hash value, go ahead
5018 * and ocfs2_divide_xattr_bucket will handle this.
5019 */
5023 {
5037 }
5040 }
5046 {
5057 try_again:
5069 header_size);
5082 /*
5083 * We only replace the old value if the new length is smaller
5084 * than the old one. Otherwise we will allocate new space in the
5085 * bucket to store it.
5086 */
5090 else
5095 }
5098 /*
5099 * We need to make sure the new name/value pair
5100 * can exist in the same block.
5101 */
5106 "need = %d, max_free = %d, xh_free_start = %u, xh_name_value_len ="
5117 /*
5118 * We can create the space by defragment. Since only the
5119 * name/value will be moved, the xe shouldn't be changed
5120 * in xs.
5121 */
5127 }
5138 "defragment. Need %u bytes, but we have %d, so "
5140 }
5142 /*
5143 * We have to add new buckets or clusters and one
5144 * allocation should leave us enough space for insert.
5145 */
5148 /*
5149 * We do not allow for overlapping ranges between buckets. And
5150 * the maximum number of collisions we will allow for then is
5151 * one bucket's worth, so check it here whether we need to
5152 * add a new bucket for the insert.
5153 */
5160 }
5165 ctxt);
5169 }
5171 /*
5172 * ocfs2_add_new_xattr_bucket() will have updated
5173 * xs->bucket if it moved, but it will not have updated
5174 * any of the other search fields. Thus, we drop it and
5175 * re-search. Everything should be cached, so it'll be
5176 * quick.
5177 */
5187 }
5189 xattr_set:
5191 out:
5194 }
5199 {
5202 u16 i;
5222 }
5231 }
5232 }
5237 }
5241 {
5247 u64 p_blkno;
5258 }
5261 ocfs2_delete_xattr_in_bucket,
5262 NULL);
5266 }
5273 }
5279 }
5281 out:
5283 }
5285 /*
5286 * 'security' attributes support
5287 */
5291 {
5299 }
5301 }
5305 {
5310 }
5314 {
5320 }
5325 {
5326 /* check whether ocfs2 support feature xattr */
5331 }
5339 {
5341 OCFS2_XATTR_INDEX_SECURITY,
5344 }
5351 };
5353 /*
5354 * 'trusted' attributes support
5355 */
5359 {
5367 }
5369 }
5373 {
5378 }
5382 {
5388 }
5395 };
5397 /*
5398 * 'user' attributes support
5399 */
5403 {
5415 }
5417 }
5421 {
5430 }
5434 {
5444 }
5451 };