| blob | 4ce8019f0ef163a03e74441b3f56333b67c00435 |
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*/
497 }
506 {
519 OCFS2_XATTR_INDEX_POSIX_ACL_DEFAULT,
528 }
529 }
534 /*
535 * The max space of security xattr taken inline is
536 * 256(name) + 80(value) + 16(entry) = 352 bytes,
537 * The max space of acl xattr taken inline is
538 * 80(value) + 16(entry) * 2(if directory) = 192 bytes,
539 * when blocksize = 512, may reserve one more cluser for
540 * xattr bucket, otherwise reserve one metadata block
541 * for them is ok.
542 */
549 }
551 }
557 }
559 /* reserve clusters for xattr value which will be set in B tree*/
568 acl_len);
569 }
572 }
575 u32 clusters_to_add,
578 {
591 OCFS2_JOURNAL_ACCESS_WRITE);
595 }
599 inode,
601 clusters_to_add,
604 handle,
611 }
617 }
621 /*
622 * We should have already allocated enough space before the transaction,
623 * so no need to restart.
624 */
627 leave:
630 }
636 {
645 OCFS2_JOURNAL_ACCESS_WRITE);
649 }
656 }
664 }
670 out:
672 }
675 u32 old_clusters,
676 u32 new_clusters,
679 {
682 u64 block;
696 }
703 ctxt);
707 }
711 alloc_size);
714 }
716 out:
718 }
725 {
733 };
742 else
748 }
753 {
760 /* we are just looking for how big our buffer needs to be */
772 }
777 {
796 }
797 }
800 }
806 {
821 }
827 {
840 }
851 }
856 }
861 {
877 }
889 }
894 }
901 }
906 {
923 name_len);
927 }
931 }
937 {
939 u64 blkno;
957 }
960 /* Copy ocfs2_xattr_value */
966 }
977 }
979 }
980 out:
982 }
990 {
1027 }
1028 }
1029 }
1032 }
1040 {
1051 }
1057 }
1062 }
1078 i,
1082 }
1094 }
1095 }
1096 }
1098 cleanup:
1104 }
1112 {
1118 };
1121 };
1141 }
1143 /* ocfs2_xattr_get()
1144 *
1145 * Copy an extended attribute into the buffer provided.
1146 * Buffer is NULL to compute the size of buffer required.
1147 */
1153 {
1161 }
1170 }
1177 {
1183 u64 blkno;
1188 /*
1189 * In __ocfs2_xattr_set_value_outside has already been dirtied,
1190 * so we don't need to worry about whether ocfs2_extend_trans
1191 * will create a new transactio for us or not.
1192 */
1198 }
1206 }
1215 }
1218 inode,
1219 bh,
1220 OCFS2_JOURNAL_ACCESS_WRITE);
1224 }
1238 }
1242 /*
1243 * XXX: do we need to empty all the following
1244 * blocks in this cluster?
1245 */
1248 }
1250 }
1251 out:
1255 }
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 }
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 */
1327 {
1349 }
1354 }
1361 }
1363 /*
1364 * ocfs2_xattr_set_entry_local()
1365 *
1366 * Set, replace or remove extended attribute in local.
1367 */
1373 {
1378 /* Insert the new xattr entry. */
1393 OCFS2_XATTR_INLINE_SIZE)
1395 OCFS2_XATTR_ROOT_SIZE;
1396 else
1402 /* The old and the new value have the
1403 same size. Just replace the value. */
1406 /* Clear value bytes. */
1414 }
1415 /* Remove the old name+value. */
1425 /* Adjust all value offsets. */
1433 }
1436 /* Remove the old entry. */
1442 }
1443 }
1445 /* Insert the new name+value. */
1459 }
1462 }
1464 /*
1465 * ocfs2_xattr_set_entry()
1466 *
1467 * Set extended attribute entry into inode or block.
1468 *
1469 * If extended attribute value size > OCFS2_XATTR_INLINE_SIZE,
1470 * We first insert tree root(ocfs2_xattr_value_root) with set_entry_local(),
1471 * then set value in B tree with set_value_outside().
1472 */
1478 {
1491 };
1493 /* Compute min_offs, last and free space. */
1501 }
1512 else
1514 OCFS2_XATTR_ROOT_SIZE;
1516 }
1517 /* Check free space in inode or block */
1521 OCFS2_XATTR_ROOT_SIZE) {
1524 }
1534 }
1535 }
1538 /* For existing extended attribute */
1545 /* Replace existing local xattr with tree root */
1552 /* For existing xattr which has value outside */
1558 /*
1559 * If new value need set outside also,
1560 * first truncate old value to new value,
1561 * then set new value with set_value_outside().
1562 */
1565 xv,
1567 ctxt);
1571 }
1574 handle,
1575 xi,
1576 xs,
1577 offs);
1581 }
1584 handle,
1585 xv,
1592 /*
1593 * If new value need set in local,
1594 * just trucate old value to zero.
1595 */
1598 xv,
1600 ctxt);
1603 }
1604 }
1605 }
1608 OCFS2_JOURNAL_ACCESS_WRITE);
1612 }
1616 OCFS2_JOURNAL_ACCESS_WRITE);
1620 }
1621 }
1623 /*
1624 * Set value in local, include set tree root in local.
1625 * This is the first step for value size >INLINE_SIZE.
1626 */
1634 }
1635 }
1642 /*
1643 * Adjust extent record count or inline data size
1644 * to reserve space for extended attribute.
1645 */
1653 }
1655 }
1656 /* Update xattr flag */
1661 /* Update inode ctime */
1671 /*
1672 * Set value outside in B tree.
1673 * This is the second step for value size > INLINE_SIZE.
1674 */
1681 /*
1682 * If set value outside failed, we have to clean
1683 * the junk tree root we have already set in local.
1684 */
1689 }
1690 }
1691 out:
1693 }
1698 {
1711 }
1729 }
1730 }
1731 }
1736 out:
1738 }
1742 {
1755 }
1759 {
1771 }
1774 u64 block)
1775 {
1784 u16 bit;
1790 }
1796 }
1804 EXTENT_ALLOC_SYSTEM_INODE,
1810 }
1817 }
1824 }
1832 out_unlock:
1835 out_mutex:
1838 out:
1841 }
1843 /*
1844 * ocfs2_xattr_remove()
1845 *
1846 * Free extended attribute resources associated with this inode.
1847 */
1849 {
1866 }
1867 }
1875 }
1876 }
1879 OCFS2_INODE_UPDATE_CREDITS);
1884 }
1886 OCFS2_JOURNAL_ACCESS_WRITE);
1890 }
1902 out_commit:
1904 out:
1906 }
1910 {
1929 }
1934 }
1936 /*
1937 * ocfs2_xattr_ibody_find()
1938 *
1939 * Find extended attribute in inode block and
1940 * fill search info into struct ocfs2_xattr_search.
1941 */
1946 {
1961 }
1968 else
1974 /* Find the named attribute. */
1980 }
1983 }
1985 /*
1986 * ocfs2_xattr_ibody_set()
1987 *
1988 * Set, replace or remove an extended attribute into inode block.
1989 *
1990 */
1995 {
2008 }
2009 }
2013 out:
2017 }
2019 /*
2020 * ocfs2_xattr_block_find()
2021 *
2022 * Find extended attribute in external block and
2023 * fill search info into struct ocfs2_xattr_search.
2024 */
2029 {
2043 }
2057 name_index,
2063 }
2066 cleanup:
2070 }
2072 /*
2073 * ocfs2_xattr_block_set()
2074 *
2075 * Set, replace or remove an extended attribute into external block.
2076 *
2077 */
2082 {
2088 u16 suballoc_bit_start;
2089 u32 num_got;
2090 u64 first_blkno;
2095 OCFS2_JOURNAL_ACCESS_CREATE);
2099 }
2107 }
2113 OCFS2_JOURNAL_ACCESS_CREATE);
2117 }
2119 /* Initialize ocfs2_xattr_block */
2138 }
2145 /* Set extended attribute into external block */
2147 OCFS2_HAS_XATTR_FL);
2154 }
2158 end:
2161 }
2163 /* Check whether the new xattr can be inserted into the inode. */
2167 {
2168 u64 value_size;
2183 }
2193 else
2201 }
2211 {
2222 u64 value_size;
2231 new_clusters);
2232 }
2235 }
2262 }
2263 }
2265 /*
2266 * delete a xattr doesn't need metadata and cluster allocation.
2267 * so just calculate the credits and return.
2268 *
2269 * The credits for removing the value tree will be extended
2270 * by ocfs2_remove_extent itself.
2271 */
2277 }
2279 /* do cluster allocation guess first. */
2283 /*
2284 * In xattr set, we always try to set the xe in inode first,
2285 * so if it can be inserted into inode successfully, the old
2286 * one will be removed from the xattr block, and this xattr
2287 * will be inserted into inode as a new xattr in inode.
2288 */
2292 OCFS2_INODE_UPDATE_CREDITS;
2297 new_clusters);
2299 }
2300 }
2303 /* the new values will be stored outside. */
2308 value_size);
2323 new_clusters -
2324 old_clusters);
2327 }
2329 /*
2330 * Now the new value will be stored inside. So if the new
2331 * value is smaller than the size of value root or the old
2332 * value, we don't need any allocation, otherwise we have
2333 * to guess metadata allocation.
2334 */
2339 }
2341 meta_guess:
2342 /* calculate metadata allocation. */
2351 }
2363 }
2365 /*
2366 * This cluster will be used either for new bucket or for
2367 * new xattr block.
2368 * If the cluster size is the same as the bucket size, one
2369 * more is needed since we may need to extend the bucket
2370 * also.
2371 */
2378 }
2382 }
2383 out:
2392 }
2401 {
2414 }
2425 }
2426 }
2432 }
2433 out:
2438 }
2440 /*
2441 * We cannot have an error and a non null ctxt->data_ac.
2442 */
2443 }
2446 }
2454 {
2458 /* Remove existing extended attribute */
2464 /* We always try to set extended attribute into inode first*/
2467 /*
2468 * If succeed and that extended attribute existing in
2469 * external block, then we will remove it.
2470 */
2477 di,
2478 xi,
2479 xis,
2480 xbs,
2481 NULL,
2482 NULL,
2488 }
2495 }
2508 di,
2509 xi,
2510 xis,
2511 xbs,
2512 NULL,
2513 NULL,
2519 }
2526 }
2527 }
2528 /*
2529 * If no space in inode, we will set extended attribute
2530 * into external block.
2531 */
2536 /*
2537 * If succeed and that extended attribute
2538 * existing in inode, we will remove it.
2539 */
2544 di,
2545 xi,
2546 xis,
2547 xbs,
2548 NULL,
2549 NULL,
2554 }
2561 }
2564 }
2565 }
2566 }
2568 out:
2570 }
2572 /*
2573 * This function only called duing creating inode
2574 * for init security/acl xattrs of the new inode.
2575 * The xattrs could be put into ibody or extent block,
2576 * xattr bucket would not be use in this case.
2577 * transanction credits also be reserved in here.
2578 */
2589 {
2598 };
2602 };
2606 };
2612 };
2629 }
2633 cleanup:
2638 }
2640 /*
2641 * ocfs2_xattr_set()
2642 *
2643 * Set, replace or remove an extended attribute for this inode.
2644 * value is NULL to remove an existing extended attribute, else either
2645 * create or replace an extended attribute.
2646 */
2653 {
2666 };
2670 };
2674 };
2679 /*
2680 * Only xbs will be used on indexed trees. xis doesn't need a
2681 * bucket.
2682 */
2687 }
2693 }
2698 /*
2699 * Scan inode and external block to find the same name
2700 * extended attribute and collect search infomation.
2701 */
2709 }
2722 }
2733 }
2734 }
2742 }
2749 }
2762 cleanup:
2765 cleanup_nolock:
2771 }
2773 /*
2774 * Find the xattr extent rec which may contains name_hash.
2775 * e_cpos will be the first name hash of the xattr rec.
2776 * el must be the ocfs2_xattr_header.xb_attrs.xb_root.xt_list.
2777 */
2779 u32 name_hash,
2784 {
2796 }
2803 "Inode %lu has non zero tree depth in "
2808 }
2809 }
2817 }
2818 }
2827 }
2833 out:
2836 }
2846 u32 name_hash,
2849 {
2856 /*
2857 * We don't use binary search in the bucket because there
2858 * may be multiple entries with the same name hash.
2859 */
2875 xh,
2876 i,
2882 }
2891 }
2892 }
2895 }
2897 /*
2898 * Find the specified xattr entry in a series of buckets.
2899 * This series start from p_blkno and last for num_clusters.
2900 * The ocfs2_xattr_header.xh_num_buckets of the first bucket contains
2901 * the num of the valid buckets.
2902 *
2903 * Return the buffer_head this xattr should reside in. And if the xattr's
2904 * hash is in the gap of 2 buckets, return the lower bucket.
2905 */
2909 u32 name_hash,
2910 u64 p_blkno,
2911 u32 first_hash,
2912 u32 num_clusters,
2914 {
2922 u32 last_hash;
2930 }
2936 }
2949 }
2956 }
2958 /*
2959 * Check whether the hash of the last entry in our
2960 * bucket is larger than the search one. for an empty
2961 * bucket, the last one is also the first one.
2962 */
2968 /* record lower_blkno which may be the insert place. */
2974 }
2976 /* the searched xattr should reside in this bucket if exists. */
2983 }
2985 }
2987 /*
2988 * Record the bucket we have found.
2989 * When the xattr's hash value is in the gap of 2 buckets, we will
2990 * always set it to the previous bucket.
2991 */
2995 /* This should be in cache - we just read it during the search */
3000 }
3013 out:
3016 }
3023 {
3044 }
3050 first_hash);
3055 out:
3057 }
3060 u64 blkno,
3061 u32 clusters,
3064 {
3074 }
3084 }
3086 /*
3087 * The real bucket num in this series of blocks is stored
3088 * in the 1st bucket.
3089 */
3100 /* Fall through to bucket_relse() */
3101 }
3106 }
3110 }
3116 };
3123 {
3124 u16 name_offset;
3135 }
3140 {
3154 i,
3161 new_offset;
3169 }
3170 }
3173 }
3179 {
3188 };
3199 }
3202 ocfs2_list_xattr_bucket,
3207 }
3213 }
3216 out:
3218 }
3221 {
3231 }
3234 {
3240 }
3242 /*
3243 * When the ocfs2_xattr_block is filled up, new bucket will be created
3244 * and all the xattr entries will be moved to the new bucket.
3245 * The header goes at the start of the bucket, and the names+values are
3246 * filled from the end. This is why *target starts as the last buffer.
3247 * Note: we need to sort the entries since they are not saved in order
3248 * in the ocfs2_xattr_block.
3249 */
3253 {
3273 /*
3274 * Since the xe_name_offset is based on ocfs2_xattr_header,
3275 * there is a offset change corresponding to the change of
3276 * ocfs2_xattr_header's position.
3277 */
3283 /* copy all the names and values. */
3286 /* Init new header now. */
3292 /* copy all the entries. */
3298 /* Change the xe offset for all the xe because of the move. */
3309 }
3311 /*
3312 * After we move xattr from block to index btree, we have to
3313 * update ocfs2_xattr_search to the new xe and base.
3314 *
3315 * When the entry is in xattr block, xattr_bh indicates the storage place.
3316 * While if the entry is in index b-tree, "bucket" indicates the
3317 * real place of the xattr.
3318 */
3322 {
3337 }
3342 {
3345 u64 blkno;
3361 /*
3362 * XXX:
3363 * We can use this lock for now, and maybe move to a dedicated mutex
3364 * if performance becomes a problem later.
3365 */
3369 OCFS2_JOURNAL_ACCESS_WRITE);
3373 }
3380 }
3382 /*
3383 * The bucket may spread in many blocks, and
3384 * we will only touch the 1st block and the last block
3385 * in the whole bucket(one for entry and one for data).
3386 */
3396 }
3399 OCFS2_JOURNAL_ACCESS_CREATE);
3403 }
3410 /* Change from ocfs2_xattr_header to ocfs2_xattr_tree_root */
3429 out:
3433 }
3436 {
3446 }
3448 /*
3449 * defrag a xattr bucket if we find that the bucket has some
3450 * holes beteen name/value pairs.
3451 * We will move all the name/value pairs to the end of the bucket
3452 * so that we can spare some space for insertion.
3453 */
3457 {
3463 u16 xh_free_start;
3467 /*
3468 * In order to make the operation more efficient and generic,
3469 * we copy all the blocks into a contiguous memory and do the
3470 * defragment there, so if anything is error, we will not touch
3471 * the real block.
3472 */
3477 }
3484 OCFS2_JOURNAL_ACCESS_WRITE);
3488 }
3499 /*
3500 * sort all the entries by their offset.
3501 * the largest will be the first, so that we can
3502 * move them to the end one by one.
3503 */
3508 /* Move all name/values to the end of the bucket. */
3516 else
3520 /*
3521 * We must make sure that the name/value pair
3522 * exist in the same block. So adjust end to
3523 * the previous block end if needed.
3524 */
3533 }
3539 }
3550 /* sort the entries by their name_hash. */
3560 out:
3563 }
3565 /*
3566 * prev_blkno points to the start of an existing extent. new_blkno
3567 * points to a newly allocated extent. Because we know each of our
3568 * clusters contains more than bucket, we can easily split one cluster
3569 * at a bucket boundary. So we take the last cluster of the existing
3570 * extent and split it down the middle. We move the last half of the
3571 * buckets in the last cluster of the existing extent over to the new
3572 * extent.
3573 *
3574 * first_bh is the buffer at prev_blkno so we can update the existing
3575 * extent's bucket count. header_bh is the bucket were we were hoping
3576 * to insert our xattr. If the bucket move places the target in the new
3577 * extent, we'll update first_bh and header_bh after modifying the old
3578 * extent.
3579 *
3580 * first_hash will be set as the 1st xe's name_hash in the new extent.
3581 */
3586 u64 new_blkno,
3587 u32 num_clusters,
3589 {
3595 u64 src_blkno;
3611 }
3613 /* This is the first bucket that got moved */
3616 /*
3617 * If the target bucket was part of the moved buckets, we need to
3618 * update first and target.
3619 */
3621 /* Find the block for the new target bucket */
3628 /*
3629 * These shouldn't fail - the buffers are in the
3630 * journal from ocfs2_cp_xattr_bucket().
3631 */
3636 }
3641 }
3643 out:
3645 }
3647 /*
3648 * Find the suitable pos when we divide a bucket into 2.
3649 * We have to make sure the xattrs with the same hash value exist
3650 * in the same bucket.
3651 *
3652 * If this ocfs2_xattr_header covers more than one hash value, find a
3653 * place where the hash value changes. Try to find the most even split.
3654 * The most common case is that all entries have different hash values,
3655 * and the first check we make will find a place to split.
3656 */
3658 {
3663 /*
3664 * We start at the middle. Each step gets farther away in both
3665 * directions. We therefore hit the change in hash value
3666 * nearest to the middle. Note that this loop does not execute for
3667 * count < 2.
3668 */
3670 /* Let's check delta earlier than middle */
3675 /* For even counts, don't walk off the end */
3679 /* Now try delta past middle */
3683 }
3685 /* Every entry had the same hash */
3687 }
3689 /*
3690 * Move some xattrs in old bucket(blk) to new bucket(new_blk).
3691 * first_hash will record the 1st hash of the new bucket.
3692 *
3693 * Normally half of the xattrs will be moved. But we have to make
3694 * sure that the xattrs with the same hash value are stored in the
3695 * same bucket. If all the xattrs in this bucket have the same hash
3696 * value, the new bucket will be initialized as an empty one and the
3697 * first_hash will be initialized as (hash_value+1).
3698 */
3701 u64 blk,
3702 u64 new_blk,
3705 {
3722 }
3728 }
3731 OCFS2_JOURNAL_ACCESS_WRITE);
3735 }
3737 /*
3738 * Even if !new_bucket_head, we're overwriting t_bucket. Thus,
3739 * there's no need to read it.
3740 */
3745 }
3747 /*
3748 * Hey, if we're overwriting t_bucket, what difference does
3749 * ACCESS_CREATE vs ACCESS_WRITE make? See the comment in the
3750 * same part of ocfs2_cp_xattr_bucket().
3751 */
3753 new_bucket_head ?
3754 OCFS2_JOURNAL_ACCESS_CREATE :
3755 OCFS2_JOURNAL_ACCESS_WRITE);
3759 }
3768 /*
3769 * initialized a new empty bucket here.
3770 * The hash value is set as one larger than
3771 * that of the last entry in the previous bucket.
3772 */
3782 }
3784 /* copy the whole bucket to the new first. */
3787 /* update the new bucket. */
3790 /*
3791 * Calculate the total name/value len and xh_free_start for
3792 * the old bucket first.
3793 */
3800 xe_len +=
3802 else
3807 }
3809 /*
3810 * Now begin the modification to the new bucket.
3811 *
3812 * In the new bucket, We just move the xattr entry to the beginning
3813 * and don't touch the name/value. So there will be some holes in the
3814 * bucket, and they will be removed when ocfs2_defrag_xattr_bucket is
3815 * called.
3816 */
3830 /* Calculate xh_free_start for the new bucket. */
3836 xe_len +=
3838 else
3843 }
3845 set_num_buckets:
3846 /* set xh->xh_num_buckets for the new xh. */
3849 else
3854 /* store the first_hash of the new bucket. */
3858 /*
3859 * Now only update the 1st block of the old bucket. If we
3860 * just added a new empty bucket, there is no need to modify
3861 * it.
3862 */
3875 out:
3880 }
3882 /*
3883 * Copy xattr from one bucket to another bucket.
3884 *
3885 * The caller must make sure that the journal transaction
3886 * has enough space for journaling.
3887 */
3890 u64 s_blkno,
3891 u64 t_blkno,
3893 {
3901 t_is_new);
3909 }
3915 /*
3916 * Even if !t_is_new, we're overwriting t_bucket. Thus,
3917 * there's no need to read it.
3918 */
3923 /*
3924 * Hey, if we're overwriting t_bucket, what difference does
3925 * ACCESS_CREATE vs ACCESS_WRITE make? Well, if we allocated a new
3926 * cluster to fill, we came here from
3927 * ocfs2_mv_xattr_buckets(), and it is really new -
3928 * ACCESS_CREATE is required. But we also might have moved data
3929 * out of t_bucket before extending back into it.
3930 * ocfs2_add_new_xattr_bucket() can do this - its call to
3931 * ocfs2_add_new_xattr_cluster() may have created a new extent
3932 * and copied out the end of the old extent. Then it re-extends
3933 * the old extent back to create space for new xattrs. That's
3934 * how we get here, and the bucket isn't really new.
3935 */
3937 t_is_new ?
3938 OCFS2_JOURNAL_ACCESS_CREATE :
3939 OCFS2_JOURNAL_ACCESS_WRITE);
3946 out:
3951 }
3953 /*
3954 * src_blk points to the start of an existing extent. last_blk points to
3955 * last cluster in that extent. to_blk points to a newly allocated
3956 * extent. We copy the buckets from the cluster at last_blk to the new
3957 * extent. If start_bucket is non-zero, we skip that many buckets before
3958 * we start copying. The new extent's xh_num_buckets gets set to the
3959 * number of buckets we copied. The old extent's xh_num_buckets shrinks
3960 * by the same amount.
3961 */
3966 {
3980 }
3982 /* The first bucket of the original extent */
3984 /* The first bucket of the new extent */
3990 }
3996 }
3998 /*
3999 * We need to update the first bucket of the old extent and all
4000 * the buckets going to the new extent.
4001 */
4008 }
4011 OCFS2_JOURNAL_ACCESS_WRITE);
4015 }
4025 }
4026 }
4028 /*
4029 * Get the new bucket ready before we dirty anything
4030 * (This actually shouldn't fail, because we already dirtied
4031 * it once in ocfs2_cp_xattr_bucket()).
4032 */
4037 }
4039 OCFS2_JOURNAL_ACCESS_WRITE);
4043 }
4045 /* Now update the headers */
4055 out:
4059 }
4061 /*
4062 * Move some xattrs in this cluster to the new cluster.
4063 * This function should only be called when bucket size == cluster size.
4064 * Otherwise ocfs2_mv_xattr_bucket_cross_cluster should be used instead.
4065 */
4068 u64 prev_blk,
4069 u64 new_blk,
4071 {
4081 }
4083 /* Move half of the xattr in start_blk to the next bucket. */
4086 }
4088 /*
4089 * Move some xattrs from the old cluster to the new one since they are not
4090 * contiguous in ocfs2 xattr tree.
4091 *
4092 * new_blk starts a new separate cluster, and we will move some xattrs from
4093 * prev_blk to it. v_start will be set as the first name hash value in this
4094 * new cluster so that it can be used as e_cpos during tree insertion and
4095 * don't collide with our original b-tree operations. first_bh and header_bh
4096 * will also be updated since they will be used in ocfs2_extend_xattr_bucket
4097 * to extend the insert bucket.
4098 *
4099 * The problem is how much xattr should we move to the new one and when should
4100 * we update first_bh and header_bh?
4101 * 1. If cluster size > bucket size, that means the previous cluster has more
4102 * than 1 bucket, so just move half nums of bucket into the new cluster and
4103 * update the first_bh and header_bh if the insert bucket has been moved
4104 * to the new cluster.
4105 * 2. If cluster_size == bucket_size:
4106 * a) If the previous extent rec has more than one cluster and the insert
4107 * place isn't in the last cluster, copy the entire last cluster to the
4108 * new one. This time, we don't need to upate the first_bh and header_bh
4109 * since they will not be moved into the new cluster.
4110 * b) Otherwise, move the bottom half of the xattrs in the last cluster into
4111 * the new one. And we set the extend flag to zero if the insert place is
4112 * moved into the new allocated cluster since no extend is needed.
4113 */
4118 u64 new_blk,
4119 u32 prev_clusters,
4122 {
4131 handle,
4133 new_blk,
4134 prev_clusters,
4135 v_start);
4139 /* The start of the last cluster in the first extent */
4148 v_start);
4154 v_start);
4160 }
4161 }
4164 }
4166 /*
4167 * Add a new cluster for xattr storage.
4168 *
4169 * If the new cluster is contiguous with the previous one, it will be
4170 * appended to the same extent record, and num_clusters will be updated.
4171 * If not, we will insert a new extent for it and move some xattrs in
4172 * the last cluster into the new allocated one.
4173 * We also need to limit the maximum size of a btree leaf, otherwise we'll
4174 * lose the benefits of hashing because we'll have to search large leaves.
4175 * So now the maximum size is OCFS2_MAX_XATTR_TREE_LEAF_SIZE(or clustersize,
4176 * if it's bigger).
4177 *
4178 * first_bh is the first block of the previous extent rec and header_bh
4179 * indicates the bucket we will insert the new xattrs. They will be updated
4180 * when the header_bh is moved into the new cluster.
4181 */
4187 u32 prev_cpos,
4190 {
4195 u64 block;
4208 OCFS2_JOURNAL_ACCESS_WRITE);
4212 }
4220 }
4230 OCFS2_MAX_XATTR_TREE_LEAF_SIZE) {
4231 /*
4232 * If this cluster is contiguous with the old one and
4233 * adding this new cluster, we don't surpass the limit of
4234 * OCFS2_MAX_XATTR_TREE_LEAF_SIZE, cool. We will let it be
4235 * initialized and used like other buckets in the previous
4236 * cluster.
4237 * So add it as a contiguous one. The caller will handle
4238 * its init process.
4239 */
4243 num_bits);
4246 handle,
4247 first,
4248 target,
4249 block,
4250 prev_clusters,
4252 extend);
4256 }
4257 }
4266 }
4272 leave:
4274 }
4276 /*
4277 * We are given an extent. 'first' is the bucket at the very front of
4278 * the extent. The extent has space for an additional bucket past
4279 * bucket_xh(first)->xh_num_buckets. 'target_blkno' is the block number
4280 * of the target bucket. We wish to shift every bucket past the target
4281 * down one, filling in that additional space. When we get back to the
4282 * target, we split the target between itself and the now-empty bucket
4283 * at target+1 (aka, target_blkno + blks_per_bucket).
4284 */
4288 u64 target_blk,
4289 u32 num_clusters)
4290 {
4294 u64 end_blk;
4301 /* The extent must have room for an additional bucket */
4305 /* end_blk points to the last existing bucket */
4308 /*
4309 * end_blk is the start of the last existing bucket.
4310 * Thus, (end_blk - target_blk) covers the target bucket and
4311 * every bucket after it up to, but not including, the last
4312 * existing bucket. Then we add the last existing bucket, the
4313 * new bucket, and the first bucket (3 * blk_per_bucket).
4314 */
4321 }
4324 OCFS2_JOURNAL_ACCESS_WRITE);
4328 }
4336 }
4338 /* Move half of the xattr in target_blkno to the next bucket. */
4345 out:
4347 }
4349 /*
4350 * Add new xattr bucket in an extent record and adjust the buckets
4351 * accordingly. xb_bh is the ocfs2_xattr_block, and target is the
4352 * bucket we want to insert into.
4353 *
4354 * In the easy case, we will move all the buckets after target down by
4355 * one. Half of target's xattrs will be moved to the next bucket.
4356 *
4357 * If current cluster is full, we'll allocate a new one. This may not
4358 * be contiguous. The underlying calls will make sure that there is
4359 * space for the insert, shifting buckets around if necessary.
4360 * 'target' may be moved by those calls.
4361 */
4366 {
4371 u32 name_hash =
4375 u64 p_blkno;
4377 /* The bucket at the front of the extent */
4383 /* The first bucket of the original extent */
4389 }
4396 }
4402 }
4406 /*
4407 * This can move first+target if the target bucket moves
4408 * to the new extent.
4409 */
4411 xb_bh,
4412 first,
4413 target,
4415 e_cpos,
4417 ctxt);
4421 }
4422 }
4427 first,
4429 num_clusters);
4432 }
4434 out:
4438 }
4443 {
4448 }
4450 /*
4451 * Handle the normal xattr set, including replace, delete and new.
4452 *
4453 * Note: "local" indicates the real data's locality. So we can't
4454 * just its bucket locality by its length.
4455 */
4459 u32 name_hash,
4461 {
4477 else
4481 /*
4482 * If the new value will be stored outside, xi->value has been
4483 * initalized as an empty ocfs2_xattr_value_root, and the same
4484 * goes with xi->value_len, so we can set new_size safely here.
4485 * See ocfs2_xattr_set_in_bucket.
4486 */
4495 /* Now replace the old value with new one. */
4498 else
4513 /*
4514 * Remove the old entry if there is more than one.
4515 * We don't remove the last entry so that we can
4516 * use it to indicate the hash value of the empty
4517 * bucket.
4518 */
4531 }
4533 /* find a new entry for insert. */
4549 }
4550 }
4561 }
4563 set_new_name_value:
4564 /* Insert the new name+value. */
4567 /*
4568 * We must make sure that the name/value pair
4569 * exists in the same block.
4570 */
4578 }
4594 }
4596 /*
4597 * Set the xattr entry in the specified bucket.
4598 * The bucket is indicated by xs->bucket and it should have the enough
4599 * space for the xattr insertion.
4600 */
4605 u32 name_hash,
4607 {
4609 u64 blkno;
4622 }
4623 }
4626 OCFS2_JOURNAL_ACCESS_WRITE);
4630 }
4635 out:
4637 }
4639 /*
4640 * Truncate the specified xe_off entry in xattr bucket.
4641 * bucket is indicated by header_bh and len is the new length.
4642 * Both the ocfs2_xattr_value_root and the entry will be updated here.
4643 *
4644 * Copy the new updated xe and xe_value_root to new_xe and new_xv if needed.
4645 */
4651 {
4653 u64 value_blk;
4669 /* We don't allow ocfs2_xattr_value to be stored in different block. */
4679 OCFS2_JOURNAL_ACCESS_WRITE);
4683 }
4685 /*
4686 * From here on out we have to dirty the bucket. The generic
4687 * value calls only modify one of the bucket's bhs, but we need
4688 * to send the bucket at once. So if they error, they *could* have
4689 * modified something. We have to assume they did, and dirty
4690 * the whole bucket. This leaves us in a consistent state.
4691 */
4698 }
4702 out_dirty:
4705 out:
4707 }
4713 {
4727 }
4734 {
4748 }
4752 u64 blkno,
4753 u32 cpos,
4754 u32 len)
4755 {
4779 }
4788 }
4789 }
4796 }
4799 OCFS2_JOURNAL_ACCESS_WRITE);
4803 }
4810 }
4818 }
4824 out_commit:
4826 out:
4837 }
4842 {
4849 OCFS2_JOURNAL_ACCESS_WRITE);
4853 }
4855 /* Remove the old entry. */
4862 }
4864 /*
4865 * Set the xattr name/value in the bucket specified in xs.
4866 *
4867 * As the new value in xi may be stored in the bucket or in an outside cluster,
4868 * we divide the whole process into 3 steps:
4869 * 1. insert name/value in the bucket(ocfs2_xattr_set_entry_in_bucket)
4870 * 2. truncate of the outside cluster(ocfs2_xattr_bucket_value_truncate_xs)
4871 * 3. Set the value to the outside cluster(ocfs2_xattr_bucket_set_value_outside)
4872 * 4. If the clusters for the new outside value can't be allocated, we need
4873 * to free the xattr we allocated in set.
4874 */
4879 {
4888 /*
4889 * We need to truncate the xattr storage first.
4890 *
4891 * If both the old and new value are stored to
4892 * outside block, we only need to truncate
4893 * the storage and then set the value outside.
4894 *
4895 * If the new value should be stored within block,
4896 * we should free all the outside block first and
4897 * the modification to the xattr block will be done
4898 * by following steps.
4899 */
4902 else
4906 value_len,
4907 ctxt);
4913 }
4916 /* So we have to handle the inside block change now. */
4918 /*
4919 * If the new value will be stored outside of block,
4920 * initalize a new empty value root and insert it first.
4921 */
4925 }
4932 }
4937 /* allocate the space now for the outside block storage. */
4944 /*
4945 * We can't allocate enough clusters for outside
4946 * storage and we have allocated xattr already,
4947 * so need to remove it.
4948 */
4950 }
4952 }
4954 set_value_outside:
4957 out:
4959 }
4961 /*
4962 * check whether the xattr bucket is filled up with the same hash value.
4963 * If we want to insert the xattr with the same hash, return -ENOSPC.
4964 * If we want to insert a xattr with different hash value, go ahead
4965 * and ocfs2_divide_xattr_bucket will handle this.
4966 */
4970 {
4984 }
4987 }
4993 {
5004 try_again:
5016 header_size);
5029 /*
5030 * We only replace the old value if the new length is smaller
5031 * than the old one. Otherwise we will allocate new space in the
5032 * bucket to store it.
5033 */
5037 else
5042 }
5045 /*
5046 * We need to make sure the new name/value pair
5047 * can exist in the same block.
5048 */
5053 "need = %d, max_free = %d, xh_free_start = %u, xh_name_value_len ="
5064 /*
5065 * We can create the space by defragment. Since only the
5066 * name/value will be moved, the xe shouldn't be changed
5067 * in xs.
5068 */
5074 }
5085 "defragment. Need %u bytes, but we have %d, so "
5087 }
5089 /*
5090 * We have to add new buckets or clusters and one
5091 * allocation should leave us enough space for insert.
5092 */
5095 /*
5096 * We do not allow for overlapping ranges between buckets. And
5097 * the maximum number of collisions we will allow for then is
5098 * one bucket's worth, so check it here whether we need to
5099 * add a new bucket for the insert.
5100 */
5107 }
5112 ctxt);
5116 }
5118 /*
5119 * ocfs2_add_new_xattr_bucket() will have updated
5120 * xs->bucket if it moved, but it will not have updated
5121 * any of the other search fields. Thus, we drop it and
5122 * re-search. Everything should be cached, so it'll be
5123 * quick.
5124 */
5134 }
5136 xattr_set:
5138 out:
5141 }
5146 {
5149 u16 i;
5169 }
5178 }
5179 }
5184 }
5188 {
5194 u64 p_blkno;
5205 }
5208 ocfs2_delete_xattr_in_bucket,
5209 NULL);
5213 }
5220 }
5226 }
5228 out:
5230 }
5232 /*
5233 * 'security' attributes support
5234 */
5238 {
5246 }
5248 }
5252 {
5257 }
5261 {
5267 }
5272 {
5275 }
5283 {
5285 OCFS2_XATTR_INDEX_SECURITY,
5288 }
5295 };
5297 /*
5298 * 'trusted' attributes support
5299 */
5303 {
5311 }
5313 }
5317 {
5322 }
5326 {
5332 }
5339 };
5341 /*
5342 * 'user' attributes support
5343 */
5347 {
5359 }
5361 }
5365 {
5374 }
5378 {
5388 }
5395 };