// SPDX-License-Identifier: GPL-2.0-or-later/* * localalloc.c * * Node local data allocation * * 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/bitops.h> #include <cluster/masklog.h> #include "ocfs2.h" #include "alloc.h"#include "blockcheck.h"#include "dlmglue.h"#include "inode.h"#include "journal.h"#include "localalloc.h"#include "suballoc.h"#include "super.h"#include "sysfile.h"#include "ocfs2_trace.h" #include "buffer_head_io.h" #define OCFS2_LOCAL_ALLOC(dinode)	(&((dinode)->id2.i_lab)) static u32 ocfs2_local_alloc_count_bits(struct ocfs2_dinode *alloc); static int ocfs2_local_alloc_find_clear_bits(struct ocfs2_super *osb,					     struct ocfs2_dinode *alloc,					     u32 *numbits,					     struct ocfs2_alloc_reservation *resv); static void ocfs2_clear_local_alloc(struct ocfs2_dinode *alloc); static int ocfs2_sync_local_to_main(struct ocfs2_super *osb,				    handle_t *handle,				    struct ocfs2_dinode *alloc,				    struct inode *main_bm_inode,				    struct buffer_head *main_bm_bh); static int ocfs2_local_alloc_reserve_for_window(struct ocfs2_super *osb,						struct ocfs2_alloc_context **ac,						struct inode **bitmap_inode,						struct buffer_head **bitmap_bh); static int ocfs2_local_alloc_new_window(struct ocfs2_super *osb,					handle_t *handle,					struct ocfs2_alloc_context *ac); static int ocfs2_local_alloc_slide_window(struct ocfs2_super *osb,					  struct inode *local_alloc_inode); /* * ocfs2_la_default_mb() - determine a default size, in megabytes of * the local alloc. * * Generally, we'd like to pick as large a local alloc as * possible. Performance on large workloads tends to scale * proportionally to la size. In addition to that, the reservations * code functions more efficiently as it can reserve more windows for * write. * * Some things work against us when trying to choose a large local alloc: * * - We need to ensure our sizing is picked to leave enough space in *   group descriptors for other allocations (such as block groups, *   etc). Picking default sizes which are a multiple of 4 could help *   - block groups are allocated in 2mb and 4mb chunks. * * - Likewise, we don't want to starve other nodes of bits on small *   file systems. This can easily be taken care of by limiting our *   default to a reasonable size (256M) on larger cluster sizes. * * - Some file systems can't support very large sizes - 4k and 8k in *   particular are limited to less than 128 and 256 megabytes respectively. * * The following reference table shows group descriptor and local * alloc maximums at various cluster sizes (4k blocksize) * * csize: 4K	group: 126M	la: 121M * csize: 8K	group: 252M	la: 243M * csize: 16K	group: 504M	la: 486M * csize: 32K	group: 1008M	la: 972M * csize: 64K	group: 2016M	la: 1944M * csize: 128K	group: 4032M	la: 3888M * csize: 256K	group: 8064M	la: 7776M * csize: 512K	group: 16128M	la: 15552M * csize: 1024K	group: 32256M	la: 31104M */#define	OCFS2_LA_MAX_DEFAULT_MB	256#define	OCFS2_LA_OLD_DEFAULT	8unsigned int ocfs2_la_default_mb(struct ocfs2_super *osb){	unsigned int la_mb;	unsigned int gd_mb;	unsigned int la_max_mb;	unsigned int megs_per_slot;	struct super_block *sb = osb->sb; 	gd_mb = ocfs2_clusters_to_megabytes(osb->sb,		8 * ocfs2_group_bitmap_size(sb, 0, osb->s_feature_incompat)); 	/*	 * This takes care of files systems with very small group	 * descriptors - 512 byte blocksize at cluster sizes lower	 * than 16K and also 1k blocksize with 4k cluster size.	 */	if ((sb->s_blocksize == 512 && osb->s_clustersize <= 8192)	    || (sb->s_blocksize == 1024 && osb->s_clustersize == 4096))		return OCFS2_LA_OLD_DEFAULT; 	/*	 * Leave enough room for some block groups and make the final	 * value we work from a multiple of 4.	 */	gd_mb -= 16;	gd_mb &= 0xFFFFFFFB; 	la_mb = gd_mb; 	/*	 * Keep window sizes down to a reasonable default	 */	if (la_mb > OCFS2_LA_MAX_DEFAULT_MB) {		/*		 * Some clustersize / blocksize combinations will have		 * given us a larger than OCFS2_LA_MAX_DEFAULT_MB		 * default size, but get poor distribution when		 * limited to exactly 256 megabytes.		 *		 * As an example, 16K clustersize at 4K blocksize		 * gives us a cluster group size of 504M. Paring the		 * local alloc size down to 256 however, would give us		 * only one window and around 200MB left in the		 * cluster group. Instead, find the first size below		 * 256 which would give us an even distribution.		 *		 * Larger cluster group sizes actually work out pretty		 * well when pared to 256, so we don't have to do this		 * for any group that fits more than two		 * OCFS2_LA_MAX_DEFAULT_MB windows.		 */		if (gd_mb > (2 * OCFS2_LA_MAX_DEFAULT_MB))			la_mb = 256;		else {			unsigned int gd_mult = gd_mb; 			while (gd_mult > 256)				gd_mult = gd_mult >> 1; 			la_mb = gd_mult;		}	} 	megs_per_slot = osb->osb_clusters_at_boot / osb->max_slots;	megs_per_slot = ocfs2_clusters_to_megabytes(osb->sb, megs_per_slot);	/* Too many nodes, too few disk clusters. */	if (megs_per_slot < la_mb)		la_mb = megs_per_slot; 	/* We can't store more bits than we can in a block. */	la_max_mb = ocfs2_clusters_to_megabytes(osb->sb,						ocfs2_local_alloc_size(sb) * 8);	if (la_mb > la_max_mb)		la_mb = la_max_mb; 	return la_mb;} void ocfs2_la_set_sizes(struct ocfs2_super *osb, int requested_mb){	struct super_block *sb = osb->sb;	unsigned int la_default_mb = ocfs2_la_default_mb(osb);	unsigned int la_max_mb; 	la_max_mb = ocfs2_clusters_to_megabytes(sb,						ocfs2_local_alloc_size(sb) * 8); 	trace_ocfs2_la_set_sizes(requested_mb, la_max_mb, la_default_mb); 	if (requested_mb == -1) {		/* No user request - use defaults */		osb->local_alloc_default_bits =			ocfs2_megabytes_to_clusters(sb, la_default_mb);	} else if (requested_mb > la_max_mb) {		/* Request is too big, we give the maximum available */		osb->local_alloc_default_bits =			ocfs2_megabytes_to_clusters(sb, la_max_mb);	} else {		osb->local_alloc_default_bits =			ocfs2_megabytes_to_clusters(sb, requested_mb);	} 	osb->local_alloc_bits = osb->local_alloc_default_bits;} static inline int ocfs2_la_state_enabled(struct ocfs2_super *osb){	return (osb->local_alloc_state == OCFS2_LA_THROTTLED ||		osb->local_alloc_state == OCFS2_LA_ENABLED);} void ocfs2_local_alloc_seen_free_bits(struct ocfs2_super *osb,				      unsigned int num_clusters){	if (num_clusters >= osb->local_alloc_default_bits) {		spin_lock(&osb->osb_lock);		if (osb->local_alloc_state == OCFS2_LA_DISABLED ||		    osb->local_alloc_state == OCFS2_LA_THROTTLED) {			cancel_delayed_work(&osb->la_enable_wq);			osb->local_alloc_state = OCFS2_LA_ENABLED;		}		spin_unlock(&osb->osb_lock);	}} void ocfs2_la_enable_worker(struct work_struct *work){	struct ocfs2_super *osb =		container_of(work, struct ocfs2_super,			     la_enable_wq.work);	spin_lock(&osb->osb_lock);	osb->local_alloc_state = OCFS2_LA_ENABLED;	spin_unlock(&osb->osb_lock);} /* * Tell us whether a given allocation should use the local alloc * file. Otherwise, it has to go to the main bitmap. * * This function does semi-dirty reads of local alloc size and state! * This is ok however, as the values are re-checked once under mutex. */int ocfs2_alloc_should_use_local(struct ocfs2_super *osb, u64 bits){	int ret = 0;	int la_bits; 	spin_lock(&osb->osb_lock);	la_bits = osb->local_alloc_bits; 	if (!ocfs2_la_state_enabled(osb))		goto bail; 	/* la_bits should be at least twice the size (in clusters) of	 * a new block group. We want to be sure block group	 * allocations go through the local alloc, so allow an	 * allocation to take up to half the bitmap. */	if (bits > (la_bits / 2))		goto bail; 	ret = 1;bail:	trace_ocfs2_alloc_should_use_local(	     (unsigned long long)bits, osb->local_alloc_state, la_bits, ret);	spin_unlock(&osb->osb_lock);	return ret;} int ocfs2_load_local_alloc(struct ocfs2_super *osb){	int status = 0;	struct ocfs2_dinode *alloc = NULL;	struct buffer_head *alloc_bh = NULL;	u32 num_used;	struct inode *inode = NULL;	struct ocfs2_local_alloc *la; 	if (osb->local_alloc_bits == 0)		goto bail; 	if (osb->local_alloc_bits >= osb->bitmap_cpg) {		mlog(ML_NOTICE, "Requested local alloc window %d is larger "		     "than max possible %u. Using defaults.\n",		     osb->local_alloc_bits, (osb->bitmap_cpg - 1));		osb->local_alloc_bits =			ocfs2_megabytes_to_clusters(osb->sb,						    ocfs2_la_default_mb(osb));	} 	/* read the alloc off disk */	inode = ocfs2_get_system_file_inode(osb, LOCAL_ALLOC_SYSTEM_INODE,					    osb->slot_num);	if (!inode) {		status = -EINVAL;		mlog_errno(status);		goto bail;	} 	status = ocfs2_read_inode_block_full(inode, &alloc_bh,					     OCFS2_BH_IGNORE_CACHE);	if (status < 0) {		mlog_errno(status);		goto bail;	} 	alloc = (struct ocfs2_dinode *) alloc_bh->b_data;	la = OCFS2_LOCAL_ALLOC(alloc); 	if (!(le32_to_cpu(alloc->i_flags) &	    (OCFS2_LOCAL_ALLOC_FL|OCFS2_BITMAP_FL))) {		mlog(ML_ERROR, "Invalid local alloc inode, %llu\n",		     (unsigned long long)OCFS2_I(inode)->ip_blkno);		status = -EINVAL;		goto bail;	} 	if ((la->la_size == 0) ||	    (le16_to_cpu(la->la_size) > ocfs2_local_alloc_size(inode->i_sb))) {		mlog(ML_ERROR, "Local alloc size is invalid (la_size = %u)\n",		     le16_to_cpu(la->la_size));		status = -EINVAL;		goto bail;	} 	/* do a little verification. */	num_used = ocfs2_local_alloc_count_bits(alloc); 	/* hopefully the local alloc has always been recovered before	 * we load it. */	if (num_used	    || alloc->id1.bitmap1.i_used	    || alloc->id1.bitmap1.i_total	    || la->la_bm_off) {		mlog(ML_ERROR, "inconsistent detected, clean journal with"		     " unrecovered local alloc, please run fsck.ocfs2!\n"		     "found = %u, set = %u, taken = %u, off = %u\n",		     num_used, le32_to_cpu(alloc->id1.bitmap1.i_used),		     le32_to_cpu(alloc->id1.bitmap1.i_total),		     le32_to_cpu(OCFS2_LOCAL_ALLOC(alloc)->la_bm_off)); 		status = -EINVAL;		goto bail;	} 	osb->local_alloc_bh = alloc_bh;	osb->local_alloc_state = OCFS2_LA_ENABLED; bail:	if (status < 0)		brelse(alloc_bh);	iput(inode); 	trace_ocfs2_load_local_alloc(osb->local_alloc_bits); 	if (status)		mlog_errno(status);	return status;} /* * return any unused bits to the bitmap and write out a clean * local_alloc. * * local_alloc_bh is optional. If not passed, we will simply use the * one off osb. If you do pass it however, be warned that it *will* be * returned brelse'd and NULL'd out.*/void ocfs2_shutdown_local_alloc(struct ocfs2_super *osb){	int status;	handle_t *handle;	struct inode *local_alloc_inode = NULL;	struct buffer_head *bh = NULL;	struct buffer_head *main_bm_bh = NULL;	struct inode *main_bm_inode = NULL;	struct ocfs2_dinode *alloc_copy = NULL;	struct ocfs2_dinode *alloc = NULL; 	cancel_delayed_work(&osb->la_enable_wq);	if (osb->ocfs2_wq)		flush_workqueue(osb->ocfs2_wq); 	if (osb->local_alloc_state == OCFS2_LA_UNUSED)		goto out; 	local_alloc_inode =		ocfs2_get_system_file_inode(osb,					    LOCAL_ALLOC_SYSTEM_INODE,					    osb->slot_num);	if (!local_alloc_inode) {		status = -ENOENT;		mlog_errno(status);		goto out;	} 	osb->local_alloc_state = OCFS2_LA_DISABLED; 	ocfs2_resmap_uninit(&osb->osb_la_resmap); 	main_bm_inode = ocfs2_get_system_file_inode(osb,						    GLOBAL_BITMAP_SYSTEM_INODE,						    OCFS2_INVALID_SLOT);	if (!main_bm_inode) {		status = -EINVAL;		mlog_errno(status);		goto out;	} 	inode_lock(main_bm_inode); 	status = ocfs2_inode_lock(main_bm_inode, &main_bm_bh, 1);	if (status < 0) {		mlog_errno(status);		goto out_mutex;	} 	/* WINDOW_MOVE_CREDITS is a bit heavy... */	handle = ocfs2_start_trans(osb, OCFS2_WINDOW_MOVE_CREDITS);	if (IS_ERR(handle)) {		mlog_errno(PTR_ERR(handle));		handle = NULL;		goto out_unlock;	} 	bh = osb->local_alloc_bh;	alloc = (struct ocfs2_dinode *) bh->b_data; 	alloc_copy = kmemdup(alloc, bh->b_size, GFP_NOFS);	if (!alloc_copy) {		status = -ENOMEM;		goto out_commit;	} 	status = ocfs2_journal_access_di(handle, INODE_CACHE(local_alloc_inode),					 bh, OCFS2_JOURNAL_ACCESS_WRITE);	if (status < 0) {		mlog_errno(status);		goto out_commit;	} 	ocfs2_clear_local_alloc(alloc);	ocfs2_journal_dirty(handle, bh); 	brelse(bh);	osb->local_alloc_bh = NULL;	osb->local_alloc_state = OCFS2_LA_UNUSED; 	status = ocfs2_sync_local_to_main(osb, handle, alloc_copy,					  main_bm_inode, main_bm_bh);	if (status < 0)		mlog_errno(status); out_commit:	ocfs2_commit_trans(osb, handle); out_unlock:	brelse(main_bm_bh); 	ocfs2_inode_unlock(main_bm_inode, 1); out_mutex:	inode_unlock(main_bm_inode);	iput(main_bm_inode); out:	iput(local_alloc_inode); 	kfree(alloc_copy);} /* * We want to free the bitmap bits outside of any recovery context as * we'll need a cluster lock to do so, but we must clear the local * alloc before giving up the recovered nodes journal. To solve this, * we kmalloc a copy of the local alloc before it's change for the * caller to process with ocfs2_complete_local_alloc_recovery */int ocfs2_begin_local_alloc_recovery(struct ocfs2_super *osb,				     int slot_num,				     struct ocfs2_dinode **alloc_copy){	int status = 0;	struct buffer_head *alloc_bh = NULL;	struct inode *inode = NULL;	struct ocfs2_dinode *alloc; 	trace_ocfs2_begin_local_alloc_recovery(slot_num); 	*alloc_copy = NULL; 	inode = ocfs2_get_system_file_inode(osb,					    LOCAL_ALLOC_SYSTEM_INODE,					    slot_num);	if (!inode) {		status = -EINVAL;		mlog_errno(status);		goto bail;	} 	inode_lock(inode); 

Lines 1–500 of 1318. Load more