// SPDX-License-Identifier: GPL-2.0-or-later /* * alloc.c * * Extent allocs and frees * * Copyright (C) 2002, 2004 Oracle. All rights reserved. */ #include <linux/fs.h> #include <linux/types.h> #include <linux/slab.h> #include <linux/highmem.h> #include <linux/swap.h> #include <linux/quotaops.h> #include <linux/blkdev.h> #include <linux/sched/signal.h> #include <cluster/masklog.h> #include "ocfs2.h" #include "alloc.h" #include "aops.h" #include "blockcheck.h" #include "dlmglue.h" #include "extent_map.h" #include "inode.h" #include "journal.h" #include "localalloc.h" #include "suballoc.h" #include "sysfile.h" #include "file.h" #include "super.h" #include "uptodate.h" #include "xattr.h" #include "refcounttree.h" #include "ocfs2_trace.h" #include "buffer_head_io.h" enum ocfs2_contig_type { … }; static enum ocfs2_contig_type ocfs2_extent_rec_contig(struct super_block *sb, struct ocfs2_extent_rec *ext, struct ocfs2_extent_rec *insert_rec); /* * Operations for a specific extent tree type. * * To implement an on-disk btree (extent tree) type in ocfs2, add * an ocfs2_extent_tree_operations structure and the matching * ocfs2_init_<thingy>_extent_tree() function. That's pretty much it * for the allocation portion of the extent tree. */ struct ocfs2_extent_tree_operations { … }; /* * Pre-declare ocfs2_dinode_et_ops so we can use it as a sanity check * in the methods. */ static u64 ocfs2_dinode_get_last_eb_blk(struct ocfs2_extent_tree *et); static void ocfs2_dinode_set_last_eb_blk(struct ocfs2_extent_tree *et, u64 blkno); static void ocfs2_dinode_update_clusters(struct ocfs2_extent_tree *et, u32 clusters); static void ocfs2_dinode_extent_map_insert(struct ocfs2_extent_tree *et, struct ocfs2_extent_rec *rec); static void ocfs2_dinode_extent_map_truncate(struct ocfs2_extent_tree *et, u32 clusters); static int ocfs2_dinode_insert_check(struct ocfs2_extent_tree *et, struct ocfs2_extent_rec *rec); static int ocfs2_dinode_sanity_check(struct ocfs2_extent_tree *et); static void ocfs2_dinode_fill_root_el(struct ocfs2_extent_tree *et); static int ocfs2_reuse_blk_from_dealloc(handle_t *handle, struct ocfs2_extent_tree *et, struct buffer_head **new_eb_bh, int blk_wanted, int *blk_given); static int ocfs2_is_dealloc_empty(struct ocfs2_extent_tree *et); static const struct ocfs2_extent_tree_operations ocfs2_dinode_et_ops = …; static void ocfs2_dinode_set_last_eb_blk(struct ocfs2_extent_tree *et, u64 blkno) { … } static u64 ocfs2_dinode_get_last_eb_blk(struct ocfs2_extent_tree *et) { … } static void ocfs2_dinode_update_clusters(struct ocfs2_extent_tree *et, u32 clusters) { … } static void ocfs2_dinode_extent_map_insert(struct ocfs2_extent_tree *et, struct ocfs2_extent_rec *rec) { … } static void ocfs2_dinode_extent_map_truncate(struct ocfs2_extent_tree *et, u32 clusters) { … } static int ocfs2_dinode_insert_check(struct ocfs2_extent_tree *et, struct ocfs2_extent_rec *rec) { … } static int ocfs2_dinode_sanity_check(struct ocfs2_extent_tree *et) { … } static void ocfs2_dinode_fill_root_el(struct ocfs2_extent_tree *et) { … } static void ocfs2_xattr_value_fill_root_el(struct ocfs2_extent_tree *et) { … } static void ocfs2_xattr_value_set_last_eb_blk(struct ocfs2_extent_tree *et, u64 blkno) { … } static u64 ocfs2_xattr_value_get_last_eb_blk(struct ocfs2_extent_tree *et) { … } static void ocfs2_xattr_value_update_clusters(struct ocfs2_extent_tree *et, u32 clusters) { … } static const struct ocfs2_extent_tree_operations ocfs2_xattr_value_et_ops = …; static void ocfs2_xattr_tree_fill_root_el(struct ocfs2_extent_tree *et) { … } static void ocfs2_xattr_tree_fill_max_leaf_clusters(struct ocfs2_extent_tree *et) { … } static void ocfs2_xattr_tree_set_last_eb_blk(struct ocfs2_extent_tree *et, u64 blkno) { … } static u64 ocfs2_xattr_tree_get_last_eb_blk(struct ocfs2_extent_tree *et) { … } static void ocfs2_xattr_tree_update_clusters(struct ocfs2_extent_tree *et, u32 clusters) { … } static const struct ocfs2_extent_tree_operations ocfs2_xattr_tree_et_ops = …; static void ocfs2_dx_root_set_last_eb_blk(struct ocfs2_extent_tree *et, u64 blkno) { … } static u64 ocfs2_dx_root_get_last_eb_blk(struct ocfs2_extent_tree *et) { … } static void ocfs2_dx_root_update_clusters(struct ocfs2_extent_tree *et, u32 clusters) { … } static int ocfs2_dx_root_sanity_check(struct ocfs2_extent_tree *et) { … } static void ocfs2_dx_root_fill_root_el(struct ocfs2_extent_tree *et) { … } static const struct ocfs2_extent_tree_operations ocfs2_dx_root_et_ops = …; static void ocfs2_refcount_tree_fill_root_el(struct ocfs2_extent_tree *et) { … } static void ocfs2_refcount_tree_set_last_eb_blk(struct ocfs2_extent_tree *et, u64 blkno) { … } static u64 ocfs2_refcount_tree_get_last_eb_blk(struct ocfs2_extent_tree *et) { … } static void ocfs2_refcount_tree_update_clusters(struct ocfs2_extent_tree *et, u32 clusters) { … } static enum ocfs2_contig_type ocfs2_refcount_tree_extent_contig(struct ocfs2_extent_tree *et, struct ocfs2_extent_rec *ext, struct ocfs2_extent_rec *insert_rec) { … } static const struct ocfs2_extent_tree_operations ocfs2_refcount_tree_et_ops = …; static void __ocfs2_init_extent_tree(struct ocfs2_extent_tree *et, struct ocfs2_caching_info *ci, struct buffer_head *bh, ocfs2_journal_access_func access, void *obj, const struct ocfs2_extent_tree_operations *ops) { … } void ocfs2_init_dinode_extent_tree(struct ocfs2_extent_tree *et, struct ocfs2_caching_info *ci, struct buffer_head *bh) { … } void ocfs2_init_xattr_tree_extent_tree(struct ocfs2_extent_tree *et, struct ocfs2_caching_info *ci, struct buffer_head *bh) { … } void ocfs2_init_xattr_value_extent_tree(struct ocfs2_extent_tree *et, struct ocfs2_caching_info *ci, struct ocfs2_xattr_value_buf *vb) { … } void ocfs2_init_dx_root_extent_tree(struct ocfs2_extent_tree *et, struct ocfs2_caching_info *ci, struct buffer_head *bh) { … } void ocfs2_init_refcount_extent_tree(struct ocfs2_extent_tree *et, struct ocfs2_caching_info *ci, struct buffer_head *bh) { … } static inline void ocfs2_et_set_last_eb_blk(struct ocfs2_extent_tree *et, u64 new_last_eb_blk) { … } static inline u64 ocfs2_et_get_last_eb_blk(struct ocfs2_extent_tree *et) { … } static inline void ocfs2_et_update_clusters(struct ocfs2_extent_tree *et, u32 clusters) { … } static inline void ocfs2_et_extent_map_insert(struct ocfs2_extent_tree *et, struct ocfs2_extent_rec *rec) { … } static inline void ocfs2_et_extent_map_truncate(struct ocfs2_extent_tree *et, u32 clusters) { … } static inline int ocfs2_et_root_journal_access(handle_t *handle, struct ocfs2_extent_tree *et, int type) { … } static inline enum ocfs2_contig_type ocfs2_et_extent_contig(struct ocfs2_extent_tree *et, struct ocfs2_extent_rec *rec, struct ocfs2_extent_rec *insert_rec) { … } static inline int ocfs2_et_insert_check(struct ocfs2_extent_tree *et, struct ocfs2_extent_rec *rec) { … } static inline int ocfs2_et_sanity_check(struct ocfs2_extent_tree *et) { … } static int ocfs2_cache_extent_block_free(struct ocfs2_cached_dealloc_ctxt *ctxt, struct ocfs2_extent_block *eb); static void ocfs2_adjust_rightmost_records(handle_t *handle, struct ocfs2_extent_tree *et, struct ocfs2_path *path, struct ocfs2_extent_rec *insert_rec); /* * Reset the actual path elements so that we can re-use the structure * to build another path. Generally, this involves freeing the buffer * heads. */ void ocfs2_reinit_path(struct ocfs2_path *path, int keep_root) { … } void ocfs2_free_path(struct ocfs2_path *path) { … } /* * All the elements of src into dest. After this call, src could be freed * without affecting dest. * * Both paths should have the same root. Any non-root elements of dest * will be freed. */ static void ocfs2_cp_path(struct ocfs2_path *dest, struct ocfs2_path *src) { … } /* * Make the *dest path the same as src and re-initialize src path to * have a root only. */ static void ocfs2_mv_path(struct ocfs2_path *dest, struct ocfs2_path *src) { … } /* * Insert an extent block at given index. * * This will not take an additional reference on eb_bh. */ static inline void ocfs2_path_insert_eb(struct ocfs2_path *path, int index, struct buffer_head *eb_bh) { … } static struct ocfs2_path *ocfs2_new_path(struct buffer_head *root_bh, struct ocfs2_extent_list *root_el, ocfs2_journal_access_func access) { … } struct ocfs2_path *ocfs2_new_path_from_path(struct ocfs2_path *path) { … } struct ocfs2_path *ocfs2_new_path_from_et(struct ocfs2_extent_tree *et) { … } /* * Journal the buffer at depth idx. All idx>0 are extent_blocks, * otherwise it's the root_access function. * * I don't like the way this function's name looks next to * ocfs2_journal_access_path(), but I don't have a better one. */ int ocfs2_path_bh_journal_access(handle_t *handle, struct ocfs2_caching_info *ci, struct ocfs2_path *path, int idx) { … } /* * Convenience function to journal all components in a path. */ int ocfs2_journal_access_path(struct ocfs2_caching_info *ci, handle_t *handle, struct ocfs2_path *path) { … } /* * Return the index of the extent record which contains cluster #v_cluster. * -1 is returned if it was not found. * * Should work fine on interior and exterior nodes. */ int ocfs2_search_extent_list(struct ocfs2_extent_list *el, u32 v_cluster) { … } /* * NOTE: ocfs2_block_extent_contig(), ocfs2_extents_adjacent() and * ocfs2_extent_rec_contig only work properly against leaf nodes! */ static int ocfs2_block_extent_contig(struct super_block *sb, struct ocfs2_extent_rec *ext, u64 blkno) { … } static int ocfs2_extents_adjacent(struct ocfs2_extent_rec *left, struct ocfs2_extent_rec *right) { … } static enum ocfs2_contig_type ocfs2_extent_rec_contig(struct super_block *sb, struct ocfs2_extent_rec *ext, struct ocfs2_extent_rec *insert_rec) { … } /* * NOTE: We can have pretty much any combination of contiguousness and * appending. * * The usefulness of APPEND_TAIL is more in that it lets us know that * we'll have to update the path to that leaf. */ enum ocfs2_append_type { … }; enum ocfs2_split_type { … }; struct ocfs2_insert_type { … }; struct ocfs2_merge_ctxt { … }; static int ocfs2_validate_extent_block(struct super_block *sb, struct buffer_head *bh) { … } int ocfs2_read_extent_block(struct ocfs2_caching_info *ci, u64 eb_blkno, struct buffer_head **bh) { … } /* * How many free extents have we got before we need more meta data? */ int ocfs2_num_free_extents(struct ocfs2_extent_tree *et) { … } /* expects array to already be allocated * * sets h_signature, h_blkno, h_suballoc_bit, h_suballoc_slot, and * l_count for you */ static int ocfs2_create_new_meta_bhs(handle_t *handle, struct ocfs2_extent_tree *et, int wanted, struct ocfs2_alloc_context *meta_ac, struct buffer_head *bhs[]) { … } /* * Helper function for ocfs2_add_branch() and ocfs2_shift_tree_depth(). * * Returns the sum of the rightmost extent rec logical offset and * cluster count. * * ocfs2_add_branch() uses this to determine what logical cluster * value should be populated into the leftmost new branch records. * * ocfs2_shift_tree_depth() uses this to determine the # clusters * value for the new topmost tree record. */ static inline u32 ocfs2_sum_rightmost_rec(struct ocfs2_extent_list *el) { … } /* * Change range of the branches in the right most path according to the leaf * extent block's rightmost record. */ static int ocfs2_adjust_rightmost_branch(handle_t *handle, struct ocfs2_extent_tree *et) { … } /* * Add an entire tree branch to our inode. eb_bh is the extent block * to start at, if we don't want to start the branch at the root * structure. * * last_eb_bh is required as we have to update it's next_leaf pointer * for the new last extent block. * * the new branch will be 'empty' in the sense that every block will * contain a single record with cluster count == 0. */ static int ocfs2_add_branch(handle_t *handle, struct ocfs2_extent_tree *et, struct buffer_head *eb_bh, struct buffer_head **last_eb_bh, struct ocfs2_alloc_context *meta_ac) { … } /* * adds another level to the allocation tree. * returns back the new extent block so you can add a branch to it * after this call. */ static int ocfs2_shift_tree_depth(handle_t *handle, struct ocfs2_extent_tree *et, struct ocfs2_alloc_context *meta_ac, struct buffer_head **ret_new_eb_bh) { … } /* * Should only be called when there is no space left in any of the * leaf nodes. What we want to do is find the lowest tree depth * non-leaf extent block with room for new records. There are three * valid results of this search: * * 1) a lowest extent block is found, then we pass it back in * *lowest_eb_bh and return '0' * * 2) the search fails to find anything, but the root_el has room. We * pass NULL back in *lowest_eb_bh, but still return '0' * * 3) the search fails to find anything AND the root_el is full, in * which case we return > 0 * * return status < 0 indicates an error. */ static int ocfs2_find_branch_target(struct ocfs2_extent_tree *et, struct buffer_head **target_bh) { … } /* * Grow a b-tree so that it has more records. * * We might shift the tree depth in which case existing paths should * be considered invalid. * * Tree depth after the grow is returned via *final_depth. * * *last_eb_bh will be updated by ocfs2_add_branch(). */ static int ocfs2_grow_tree(handle_t *handle, struct ocfs2_extent_tree *et, int *final_depth, struct buffer_head **last_eb_bh, struct ocfs2_alloc_context *meta_ac) { … } /* * This function will discard the rightmost extent record. */ static void ocfs2_shift_records_right(struct ocfs2_extent_list *el) { … } static void ocfs2_rotate_leaf(struct ocfs2_extent_list *el, struct ocfs2_extent_rec *insert_rec) { … } static void ocfs2_remove_empty_extent(struct ocfs2_extent_list *el) { … } /* * Create an empty extent record . * * l_next_free_rec may be updated. * * If an empty extent already exists do nothing. */ static void ocfs2_create_empty_extent(struct ocfs2_extent_list *el) { … } /* * For a rotation which involves two leaf nodes, the "root node" is * the lowest level tree node which contains a path to both leafs. This * resulting set of information can be used to form a complete "subtree" * * This function is passed two full paths from the dinode down to a * pair of adjacent leaves. It's task is to figure out which path * index contains the subtree root - this can be the root index itself * in a worst-case rotation. * * The array index of the subtree root is passed back. */ int ocfs2_find_subtree_root(struct ocfs2_extent_tree *et, struct ocfs2_path *left, struct ocfs2_path *right) { … } path_insert_t; /* * Traverse a btree path in search of cpos, starting at root_el. * * This code can be called with a cpos larger than the tree, in which * case it will return the rightmost path. */ static int __ocfs2_find_path(struct ocfs2_caching_info *ci, struct ocfs2_extent_list *root_el, u32 cpos, path_insert_t *func, void *data) { … } /* * Given an initialized path (that is, it has a valid root extent * list), this function will traverse the btree in search of the path * which would contain cpos. * * The path traveled is recorded in the path structure. * * Note that this will not do any comparisons on leaf node extent * records, so it will work fine in the case that we just added a tree * branch. */ struct find_path_data { … }; static void find_path_ins(void *data, struct buffer_head *bh) { … } int ocfs2_find_path(struct ocfs2_caching_info *ci, struct ocfs2_path *path, u32 cpos) { … } static void find_leaf_ins(void *data, struct buffer_head *bh) { … } /* * Find the leaf block in the tree which would contain cpos. No * checking of the actual leaf is done. * * Some paths want to call this instead of allocating a path structure * and calling ocfs2_find_path(). * * This function doesn't handle non btree extent lists. */ int ocfs2_find_leaf(struct ocfs2_caching_info *ci, struct ocfs2_extent_list *root_el, u32 cpos, struct buffer_head **leaf_bh) { … } /* * Adjust the adjacent records (left_rec, right_rec) involved in a rotation. * * Basically, we've moved stuff around at the bottom of the tree and * we need to fix up the extent records above the changes to reflect * the new changes. * * left_rec: the record on the left. * right_rec: the record to the right of left_rec * right_child_el: is the child list pointed to by right_rec * * By definition, this only works on interior nodes. */ static void ocfs2_adjust_adjacent_records(struct ocfs2_extent_rec *left_rec, struct ocfs2_extent_rec *right_rec, struct ocfs2_extent_list *right_child_el) { … } /* * Adjust the adjacent root node records involved in a * rotation. left_el_blkno is passed in as a key so that we can easily * find it's index in the root list. */ static void ocfs2_adjust_root_records(struct ocfs2_extent_list *root_el, struct ocfs2_extent_list *left_el, struct ocfs2_extent_list *right_el, u64 left_el_blkno) { … } /* * We've changed a leaf block (in right_path) and need to reflect that * change back up the subtree. * * This happens in multiple places: * - When we've moved an extent record from the left path leaf to the right * path leaf to make room for an empty extent in the left path leaf. * - When our insert into the right path leaf is at the leftmost edge * and requires an update of the path immediately to it's left. This * can occur at the end of some types of rotation and appending inserts. * - When we've adjusted the last extent record in the left path leaf and the * 1st extent record in the right path leaf during cross extent block merge. */ static void ocfs2_complete_edge_insert(handle_t *handle, struct ocfs2_path *left_path, struct ocfs2_path *right_path, int subtree_index) { … } static int ocfs2_rotate_subtree_right(handle_t *handle, struct ocfs2_extent_tree *et, struct ocfs2_path *left_path, struct ocfs2_path *right_path, int subtree_index) { … } /* * Given a full path, determine what cpos value would return us a path * containing the leaf immediately to the left of the current one. * * Will return zero if the path passed in is already the leftmost path. */ int ocfs2_find_cpos_for_left_leaf(struct super_block *sb, struct ocfs2_path *path, u32 *cpos) { … } /* * Extend the transaction by enough credits to complete the rotation, * and still leave at least the original number of credits allocated * to this transaction. */ static int ocfs2_extend_rotate_transaction(handle_t *handle, int subtree_depth, int op_credits, struct ocfs2_path *path) { … } /* * Trap the case where we're inserting into the theoretical range past * the _actual_ left leaf range. Otherwise, we'll rotate a record * whose cpos is less than ours into the right leaf. * * It's only necessary to look at the rightmost record of the left * leaf because the logic that calls us should ensure that the * theoretical ranges in the path components above the leaves are * correct. */ static int ocfs2_rotate_requires_path_adjustment(struct ocfs2_path *left_path, u32 insert_cpos) { … } static int ocfs2_leftmost_rec_contains(struct ocfs2_extent_list *el, u32 cpos) { … } /* * Rotate all the records in a btree right one record, starting at insert_cpos. * * The path to the rightmost leaf should be passed in. * * The array is assumed to be large enough to hold an entire path (tree depth). * * Upon successful return from this function: * * - The 'right_path' array will contain a path to the leaf block * whose range contains e_cpos. * - That leaf block will have a single empty extent in list index 0. * - In the case that the rotation requires a post-insert update, * *ret_left_path will contain a valid path which can be passed to * ocfs2_insert_path(). */ static int ocfs2_rotate_tree_right(handle_t *handle, struct ocfs2_extent_tree *et, enum ocfs2_split_type split, u32 insert_cpos, struct ocfs2_path *right_path, struct ocfs2_path **ret_left_path) { … } static int ocfs2_update_edge_lengths(handle_t *handle, struct ocfs2_extent_tree *et, struct ocfs2_path *path) { … } static void ocfs2_unlink_path(handle_t *handle, struct ocfs2_extent_tree *et, struct ocfs2_cached_dealloc_ctxt *dealloc, struct ocfs2_path *path, int unlink_start) { … } static void ocfs2_unlink_subtree(handle_t *handle, struct ocfs2_extent_tree *et, struct ocfs2_path *left_path, struct ocfs2_path *right_path, int subtree_index, struct ocfs2_cached_dealloc_ctxt *dealloc) { … } static int ocfs2_rotate_subtree_left(handle_t *handle, struct ocfs2_extent_tree *et, struct ocfs2_path *left_path, struct ocfs2_path *right_path, int subtree_index, struct ocfs2_cached_dealloc_ctxt *dealloc, int *deleted) { … } /* * Given a full path, determine what cpos value would return us a path * containing the leaf immediately to the right of the current one. * * Will return zero if the path passed in is already the rightmost path. * * This looks similar, but is subtly different to * ocfs2_find_cpos_for_left_leaf(). */ int ocfs2_find_cpos_for_right_leaf(struct super_block *sb, struct ocfs2_path *path, u32 *cpos) { … } static int ocfs2_rotate_rightmost_leaf_left(handle_t *handle, struct ocfs2_extent_tree *et, struct ocfs2_path *path) { … } static int __ocfs2_rotate_tree_left(handle_t *handle, struct ocfs2_extent_tree *et, int orig_credits, struct ocfs2_path *path, struct ocfs2_cached_dealloc_ctxt *dealloc, struct ocfs2_path **empty_extent_path) { … } static int ocfs2_remove_rightmost_path(handle_t *handle, struct ocfs2_extent_tree *et, struct ocfs2_path *path, struct ocfs2_cached_dealloc_ctxt *dealloc) { … } static int ocfs2_remove_rightmost_empty_extent(struct ocfs2_super *osb, struct ocfs2_extent_tree *et, struct ocfs2_path *path, struct ocfs2_cached_dealloc_ctxt *dealloc) { … } /* * Left rotation of btree records. * * In many ways, this is (unsurprisingly) the opposite of right * rotation. We start at some non-rightmost path containing an empty * extent in the leaf block. The code works its way to the rightmost * path by rotating records to the left in every subtree. * * This is used by any code which reduces the number of extent records * in a leaf. After removal, an empty record should be placed in the * leftmost list position. * * This won't handle a length update of the rightmost path records if * the rightmost tree leaf record is removed so the caller is * responsible for detecting and correcting that. */ static int ocfs2_rotate_tree_left(handle_t *handle, struct ocfs2_extent_tree *et, struct ocfs2_path *path, struct ocfs2_cached_dealloc_ctxt *dealloc) { … } static void ocfs2_cleanup_merge(struct ocfs2_extent_list *el, int index) { … } static int ocfs2_get_right_path(struct ocfs2_extent_tree *et, struct ocfs2_path *left_path, struct ocfs2_path **ret_right_path) { … } /* * Remove split_rec clusters from the record at index and merge them * onto the beginning of the record "next" to it. * For index < l_count - 1, the next means the extent rec at index + 1. * For index == l_count - 1, the "next" means the 1st extent rec of the * next extent block. */ static int ocfs2_merge_rec_right(struct ocfs2_path *left_path, handle_t *handle, struct ocfs2_extent_tree *et, struct ocfs2_extent_rec *split_rec, int index) { … } static int ocfs2_get_left_path(struct ocfs2_extent_tree *et, struct ocfs2_path *right_path, struct ocfs2_path **ret_left_path) { … } /* * Remove split_rec clusters from the record at index and merge them * onto the tail of the record "before" it. * For index > 0, the "before" means the extent rec at index - 1. * * For index == 0, the "before" means the last record of the previous * extent block. And there is also a situation that we may need to * remove the rightmost leaf extent block in the right_path and change * the right path to indicate the new rightmost path. */ static int ocfs2_merge_rec_left(struct ocfs2_path *right_path, handle_t *handle, struct ocfs2_extent_tree *et, struct ocfs2_extent_rec *split_rec, struct ocfs2_cached_dealloc_ctxt *dealloc, int index) { … } static int ocfs2_try_to_merge_extent(handle_t *handle, struct ocfs2_extent_tree *et, struct ocfs2_path *path, int split_index, struct ocfs2_extent_rec *split_rec, struct ocfs2_cached_dealloc_ctxt *dealloc, struct ocfs2_merge_ctxt *ctxt) { … } static void ocfs2_subtract_from_rec(struct super_block *sb, enum ocfs2_split_type split, struct ocfs2_extent_rec *rec, struct ocfs2_extent_rec *split_rec) { … } /* * Do the final bits of extent record insertion at the target leaf * list. If this leaf is part of an allocation tree, it is assumed * that the tree above has been prepared. */ static void ocfs2_insert_at_leaf(struct ocfs2_extent_tree *et, struct ocfs2_extent_rec *insert_rec, struct ocfs2_extent_list *el, struct ocfs2_insert_type *insert) { … } static void ocfs2_adjust_rightmost_records(handle_t *handle, struct ocfs2_extent_tree *et, struct ocfs2_path *path, struct ocfs2_extent_rec *insert_rec) { … } static int ocfs2_append_rec_to_path(handle_t *handle, struct ocfs2_extent_tree *et, struct ocfs2_extent_rec *insert_rec, struct ocfs2_path *right_path, struct ocfs2_path **ret_left_path) { … } static void ocfs2_split_record(struct ocfs2_extent_tree *et, struct ocfs2_path *left_path, struct ocfs2_path *right_path, struct ocfs2_extent_rec *split_rec, enum ocfs2_split_type split) { … } /* * This function only does inserts on an allocation b-tree. For tree * depth = 0, ocfs2_insert_at_leaf() is called directly. * * right_path is the path we want to do the actual insert * in. left_path should only be passed in if we need to update that * portion of the tree after an edge insert. */ static int ocfs2_insert_path(handle_t *handle, struct ocfs2_extent_tree *et, struct ocfs2_path *left_path, struct ocfs2_path *right_path, struct ocfs2_extent_rec *insert_rec, struct ocfs2_insert_type *insert) { … } static int ocfs2_do_insert_extent(handle_t *handle, struct ocfs2_extent_tree *et, struct ocfs2_extent_rec *insert_rec, struct ocfs2_insert_type *type) { … } static int ocfs2_figure_merge_contig_type(struct ocfs2_extent_tree *et, struct ocfs2_path *path, struct ocfs2_extent_list *el, int index, struct ocfs2_extent_rec *split_rec, struct ocfs2_merge_ctxt *ctxt) { … } static void ocfs2_figure_contig_type(struct ocfs2_extent_tree *et, struct ocfs2_insert_type *insert, struct ocfs2_extent_list *el, struct ocfs2_extent_rec *insert_rec) { … } /* * This should only be called against the righmost leaf extent list. * * ocfs2_figure_appending_type() will figure out whether we'll have to * insert at the tail of the rightmost leaf. * * This should also work against the root extent list for tree's with 0 * depth. If we consider the root extent list to be the rightmost leaf node * then the logic here makes sense. */ static void ocfs2_figure_appending_type(struct ocfs2_insert_type *insert, struct ocfs2_extent_list *el, struct ocfs2_extent_rec *insert_rec) { … } /* * Helper function called at the beginning of an insert. * * This computes a few things that are commonly used in the process of * inserting into the btree: * - Whether the new extent is contiguous with an existing one. * - The current tree depth. * - Whether the insert is an appending one. * - The total # of free records in the tree. * * All of the information is stored on the ocfs2_insert_type * structure. */ static int ocfs2_figure_insert_type(struct ocfs2_extent_tree *et, struct buffer_head **last_eb_bh, struct ocfs2_extent_rec *insert_rec, int *free_records, struct ocfs2_insert_type *insert) { … } /* * Insert an extent into a btree. * * The caller needs to update the owning btree's cluster count. */ int ocfs2_insert_extent(handle_t *handle, struct ocfs2_extent_tree *et, u32 cpos, u64 start_blk, u32 new_clusters, u8 flags, struct ocfs2_alloc_context *meta_ac) { … } /* * Allcate and add clusters into the extent b-tree. * The new clusters(clusters_to_add) will be inserted at logical_offset. * The extent b-tree's root is specified by et, and * it is not limited to the file storage. Any extent tree can use this * function if it implements the proper ocfs2_extent_tree. */ int ocfs2_add_clusters_in_btree(handle_t *handle, struct ocfs2_extent_tree *et, u32 *logical_offset, u32 clusters_to_add, int mark_unwritten, struct ocfs2_alloc_context *data_ac, struct ocfs2_alloc_context *meta_ac, enum ocfs2_alloc_restarted *reason_ret) { … } static void ocfs2_make_right_split_rec(struct super_block *sb, struct ocfs2_extent_rec *split_rec, u32 cpos, struct ocfs2_extent_rec *rec) { … } static int ocfs2_split_and_insert(handle_t *handle, struct ocfs2_extent_tree *et, struct ocfs2_path *path, struct buffer_head **last_eb_bh, int split_index, struct ocfs2_extent_rec *orig_split_rec, struct ocfs2_alloc_context *meta_ac) { … } static int ocfs2_replace_extent_rec(handle_t *handle, struct ocfs2_extent_tree *et, struct ocfs2_path *path, struct ocfs2_extent_list *el, int split_index, struct ocfs2_extent_rec *split_rec) { … } /* * Split part or all of the extent record at split_index in the leaf * pointed to by path. Merge with the contiguous extent record if needed. * * Care is taken to handle contiguousness so as to not grow the tree. * * meta_ac is not strictly necessary - we only truly need it if growth * of the tree is required. All other cases will degrade into a less * optimal tree layout. * * last_eb_bh should be the rightmost leaf block for any extent * btree. Since a split may grow the tree or a merge might shrink it, * the caller cannot trust the contents of that buffer after this call. * * This code is optimized for readability - several passes might be * made over certain portions of the tree. All of those blocks will * have been brought into cache (and pinned via the journal), so the * extra overhead is not expressed in terms of disk reads. */ int ocfs2_split_extent(handle_t *handle, struct ocfs2_extent_tree *et, struct ocfs2_path *path, int split_index, struct ocfs2_extent_rec *split_rec, struct ocfs2_alloc_context *meta_ac, struct ocfs2_cached_dealloc_ctxt *dealloc) { … } /* * Change the flags of the already-existing extent at cpos for len clusters. * * new_flags: the flags we want to set. * clear_flags: the flags we want to clear. * phys: the new physical offset we want this new extent starts from. * * If the existing extent is larger than the request, initiate a * split. An attempt will be made at merging with adjacent extents. * * The caller is responsible for passing down meta_ac if we'll need it. */ int ocfs2_change_extent_flag(handle_t *handle, struct ocfs2_extent_tree *et, u32 cpos, u32 len, u32 phys, struct ocfs2_alloc_context *meta_ac, struct ocfs2_cached_dealloc_ctxt *dealloc, int new_flags, int clear_flags) { … } /* * Mark the already-existing extent at cpos as written for len clusters. * This removes the unwritten extent flag. * * If the existing extent is larger than the request, initiate a * split. An attempt will be made at merging with adjacent extents. * * The caller is responsible for passing down meta_ac if we'll need it. */ int ocfs2_mark_extent_written(struct inode *inode, struct ocfs2_extent_tree *et, handle_t *handle, u32 cpos, u32 len, u32 phys, struct ocfs2_alloc_context *meta_ac, struct ocfs2_cached_dealloc_ctxt *dealloc) { … } static int ocfs2_split_tree(handle_t *handle, struct ocfs2_extent_tree *et, struct ocfs2_path *path, int index, u32 new_range, struct ocfs2_alloc_context *meta_ac) { … } static int ocfs2_truncate_rec(handle_t *handle, struct ocfs2_extent_tree *et, struct ocfs2_path *path, int index, struct ocfs2_cached_dealloc_ctxt *dealloc, u32 cpos, u32 len) { … } int ocfs2_remove_extent(handle_t *handle, struct ocfs2_extent_tree *et, u32 cpos, u32 len, struct ocfs2_alloc_context *meta_ac, struct ocfs2_cached_dealloc_ctxt *dealloc) { … } /* * ocfs2_reserve_blocks_for_rec_trunc() would look basically the * same as ocfs2_lock_alloctors(), except for it accepts a blocks * number to reserve some extra blocks, and it only handles meta * data allocations. * * Currently, only ocfs2_remove_btree_range() uses it for truncating * and punching holes. */ static int ocfs2_reserve_blocks_for_rec_trunc(struct inode *inode, struct ocfs2_extent_tree *et, u32 extents_to_split, struct ocfs2_alloc_context **ac, int extra_blocks) { … } int ocfs2_remove_btree_range(struct inode *inode, struct ocfs2_extent_tree *et, u32 cpos, u32 phys_cpos, u32 len, int flags, struct ocfs2_cached_dealloc_ctxt *dealloc, u64 refcount_loc, bool refcount_tree_locked) { … } int ocfs2_truncate_log_needs_flush(struct ocfs2_super *osb) { … } static int ocfs2_truncate_log_can_coalesce(struct ocfs2_truncate_log *tl, unsigned int new_start) { … } int ocfs2_truncate_log_append(struct ocfs2_super *osb, handle_t *handle, u64 start_blk, unsigned int num_clusters) { … } static int ocfs2_replay_truncate_records(struct ocfs2_super *osb, struct inode *data_alloc_inode, struct buffer_head *data_alloc_bh) { … } /* Expects you to already be holding tl_inode->i_rwsem */ int __ocfs2_flush_truncate_log(struct ocfs2_super *osb) { … } int ocfs2_flush_truncate_log(struct ocfs2_super *osb) { … } static void ocfs2_truncate_log_worker(struct work_struct *work) { … } #define OCFS2_TRUNCATE_LOG_FLUSH_INTERVAL … void ocfs2_schedule_truncate_log_flush(struct ocfs2_super *osb, int cancel) { … } /* * Try to flush truncate logs if we can free enough clusters from it. * As for return value, "< 0" means error, "0" no space and "1" means * we have freed enough spaces and let the caller try to allocate again. */ int ocfs2_try_to_free_truncate_log(struct ocfs2_super *osb, unsigned int needed) { … } static int ocfs2_get_truncate_log_info(struct ocfs2_super *osb, int slot_num, struct inode **tl_inode, struct buffer_head **tl_bh) { … } /* called during the 1st stage of node recovery. we stamp a clean * truncate log and pass back a copy for processing later. if the * truncate log does not require processing, a *tl_copy is set to * NULL. */ int ocfs2_begin_truncate_log_recovery(struct ocfs2_super *osb, int slot_num, struct ocfs2_dinode **tl_copy) { … } int ocfs2_complete_truncate_log_recovery(struct ocfs2_super *osb, struct ocfs2_dinode *tl_copy) { … } void ocfs2_truncate_log_shutdown(struct ocfs2_super *osb) { … } int ocfs2_truncate_log_init(struct ocfs2_super *osb) { … } /* * Delayed de-allocation of suballocator blocks. * * Some sets of block de-allocations might involve multiple suballocator inodes. * * The locking for this can get extremely complicated, especially when * the suballocator inodes to delete from aren't known until deep * within an unrelated codepath. * * ocfs2_extent_block structures are a good example of this - an inode * btree could have been grown by any number of nodes each allocating * out of their own suballoc inode. * * These structures allow the delay of block de-allocation until a * later time, when locking of multiple cluster inodes won't cause * deadlock. */ /* * Describe a single bit freed from a suballocator. For the block * suballocators, it represents one block. For the global cluster * allocator, it represents some clusters and free_bit indicates * clusters number. */ struct ocfs2_cached_block_free { … }; struct ocfs2_per_slot_free_list { … }; static int ocfs2_free_cached_blocks(struct ocfs2_super *osb, int sysfile_type, int slot, struct ocfs2_cached_block_free *head) { … } int ocfs2_cache_cluster_dealloc(struct ocfs2_cached_dealloc_ctxt *ctxt, u64 blkno, unsigned int bit) { … } static int ocfs2_free_cached_clusters(struct ocfs2_super *osb, struct ocfs2_cached_block_free *head) { … } int ocfs2_run_deallocs(struct ocfs2_super *osb, struct ocfs2_cached_dealloc_ctxt *ctxt) { … } static struct ocfs2_per_slot_free_list * ocfs2_find_per_slot_free_list(int type, int slot, struct ocfs2_cached_dealloc_ctxt *ctxt) { … } static struct ocfs2_per_slot_free_list * ocfs2_find_preferred_free_list(int type, int preferred_slot, int *real_slot, struct ocfs2_cached_dealloc_ctxt *ctxt) { … } /* Return Value 1 indicates empty */ static int ocfs2_is_dealloc_empty(struct ocfs2_extent_tree *et) { … } /* If extent was deleted from tree due to extent rotation and merging, and * no metadata is reserved ahead of time. Try to reuse some extents * just deleted. This is only used to reuse extent blocks. * It is supposed to find enough extent blocks in dealloc if our estimation * on metadata is accurate. */ static int ocfs2_reuse_blk_from_dealloc(handle_t *handle, struct ocfs2_extent_tree *et, struct buffer_head **new_eb_bh, int blk_wanted, int *blk_given) { … } int ocfs2_cache_block_dealloc(struct ocfs2_cached_dealloc_ctxt *ctxt, int type, int slot, u64 suballoc, u64 blkno, unsigned int bit) { … } static int ocfs2_cache_extent_block_free(struct ocfs2_cached_dealloc_ctxt *ctxt, struct ocfs2_extent_block *eb) { … } static int ocfs2_zero_func(handle_t *handle, struct buffer_head *bh) { … } void ocfs2_map_and_dirty_page(struct inode *inode, handle_t *handle, unsigned int from, unsigned int to, struct page *page, int zero, u64 *phys) { … } static void ocfs2_zero_cluster_pages(struct inode *inode, loff_t start, loff_t end, struct page **pages, int numpages, u64 phys, handle_t *handle) { … } int ocfs2_grab_pages(struct inode *inode, loff_t start, loff_t end, struct page **pages, int *num) { … } static int ocfs2_grab_eof_pages(struct inode *inode, loff_t start, loff_t end, struct page **pages, int *num) { … } /* * Zero partial cluster for a hole punch or truncate. This avoids exposing * nonzero data on subsequent file extends. * * We need to call this before i_size is updated on the inode because * otherwise block_write_full_folio() will skip writeout of pages past * i_size. */ int ocfs2_zero_range_for_truncate(struct inode *inode, handle_t *handle, u64 range_start, u64 range_end) { … } static void ocfs2_zero_dinode_id2_with_xattr(struct inode *inode, struct ocfs2_dinode *di) { … } void ocfs2_dinode_new_extent_list(struct inode *inode, struct ocfs2_dinode *di) { … } void ocfs2_set_inode_data_inline(struct inode *inode, struct ocfs2_dinode *di) { … } int ocfs2_convert_inline_data_to_extents(struct inode *inode, struct buffer_head *di_bh) { … } /* * It is expected, that by the time you call this function, * inode->i_size and fe->i_size have been adjusted. * * WARNING: This will kfree the truncate context */ int ocfs2_commit_truncate(struct ocfs2_super *osb, struct inode *inode, struct buffer_head *di_bh) { … } /* * 'start' is inclusive, 'end' is not. */ int ocfs2_truncate_inline(struct inode *inode, struct buffer_head *di_bh, unsigned int start, unsigned int end, int trunc) { … } static int ocfs2_trim_extent(struct super_block *sb, struct ocfs2_group_desc *gd, u64 group, u32 start, u32 count) { … } static int ocfs2_trim_group(struct super_block *sb, struct ocfs2_group_desc *gd, u64 group, u32 start, u32 max, u32 minbits) { … } static int ocfs2_trim_mainbm(struct super_block *sb, struct fstrim_range *range) { … } int ocfs2_trim_fs(struct super_block *sb, struct fstrim_range *range) { … }
Codebase Browser
linux