2008-01-29 06:19:52 +01:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2003-2006, Cluster File Systems, Inc, info@clusterfs.com
|
|
|
|
* Written by Alex Tomas <alex@clusterfs.com>
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
|
|
* published by the Free Software Foundation.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public Licens
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* mballoc.c contains the multiblocks allocation routines
|
|
|
|
*/
|
|
|
|
|
2012-02-20 23:53:02 +01:00
|
|
|
#include "ext4_jbd2.h"
|
2008-04-30 04:01:31 +02:00
|
|
|
#include "mballoc.h"
|
2012-09-05 07:31:50 +02:00
|
|
|
#include <linux/log2.h>
|
2013-02-09 22:28:20 +01:00
|
|
|
#include <linux/module.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 09:04:11 +01:00
|
|
|
#include <linux/slab.h>
|
2009-06-17 17:48:11 +02:00
|
|
|
#include <trace/events/ext4.h>
|
|
|
|
|
2013-02-09 22:28:20 +01:00
|
|
|
#ifdef CONFIG_EXT4_DEBUG
|
|
|
|
ushort ext4_mballoc_debug __read_mostly;
|
|
|
|
|
|
|
|
module_param_named(mballoc_debug, ext4_mballoc_debug, ushort, 0644);
|
|
|
|
MODULE_PARM_DESC(mballoc_debug, "Debugging level for ext4's mballoc");
|
|
|
|
#endif
|
|
|
|
|
2008-01-29 06:19:52 +01:00
|
|
|
/*
|
|
|
|
* MUSTDO:
|
|
|
|
* - test ext4_ext_search_left() and ext4_ext_search_right()
|
|
|
|
* - search for metadata in few groups
|
|
|
|
*
|
|
|
|
* TODO v4:
|
|
|
|
* - normalization should take into account whether file is still open
|
|
|
|
* - discard preallocations if no free space left (policy?)
|
|
|
|
* - don't normalize tails
|
|
|
|
* - quota
|
|
|
|
* - reservation for superuser
|
|
|
|
*
|
|
|
|
* TODO v3:
|
|
|
|
* - bitmap read-ahead (proposed by Oleg Drokin aka green)
|
|
|
|
* - track min/max extents in each group for better group selection
|
|
|
|
* - mb_mark_used() may allocate chunk right after splitting buddy
|
|
|
|
* - tree of groups sorted by number of free blocks
|
|
|
|
* - error handling
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The allocation request involve request for multiple number of blocks
|
|
|
|
* near to the goal(block) value specified.
|
|
|
|
*
|
2009-03-31 15:11:14 +02:00
|
|
|
* During initialization phase of the allocator we decide to use the
|
|
|
|
* group preallocation or inode preallocation depending on the size of
|
|
|
|
* the file. The size of the file could be the resulting file size we
|
|
|
|
* would have after allocation, or the current file size, which ever
|
|
|
|
* is larger. If the size is less than sbi->s_mb_stream_request we
|
|
|
|
* select to use the group preallocation. The default value of
|
|
|
|
* s_mb_stream_request is 16 blocks. This can also be tuned via
|
|
|
|
* /sys/fs/ext4/<partition>/mb_stream_req. The value is represented in
|
|
|
|
* terms of number of blocks.
|
2008-01-29 06:19:52 +01:00
|
|
|
*
|
|
|
|
* The main motivation for having small file use group preallocation is to
|
2009-03-31 15:11:14 +02:00
|
|
|
* ensure that we have small files closer together on the disk.
|
2008-01-29 06:19:52 +01:00
|
|
|
*
|
2009-03-31 15:11:14 +02:00
|
|
|
* First stage the allocator looks at the inode prealloc list,
|
|
|
|
* ext4_inode_info->i_prealloc_list, which contains list of prealloc
|
|
|
|
* spaces for this particular inode. The inode prealloc space is
|
|
|
|
* represented as:
|
2008-01-29 06:19:52 +01:00
|
|
|
*
|
|
|
|
* pa_lstart -> the logical start block for this prealloc space
|
|
|
|
* pa_pstart -> the physical start block for this prealloc space
|
2011-09-10 00:48:51 +02:00
|
|
|
* pa_len -> length for this prealloc space (in clusters)
|
|
|
|
* pa_free -> free space available in this prealloc space (in clusters)
|
2008-01-29 06:19:52 +01:00
|
|
|
*
|
|
|
|
* The inode preallocation space is used looking at the _logical_ start
|
|
|
|
* block. If only the logical file block falls within the range of prealloc
|
2011-07-12 00:42:42 +02:00
|
|
|
* space we will consume the particular prealloc space. This makes sure that
|
|
|
|
* we have contiguous physical blocks representing the file blocks
|
2008-01-29 06:19:52 +01:00
|
|
|
*
|
|
|
|
* The important thing to be noted in case of inode prealloc space is that
|
|
|
|
* we don't modify the values associated to inode prealloc space except
|
|
|
|
* pa_free.
|
|
|
|
*
|
|
|
|
* If we are not able to find blocks in the inode prealloc space and if we
|
|
|
|
* have the group allocation flag set then we look at the locality group
|
2011-07-12 00:42:42 +02:00
|
|
|
* prealloc space. These are per CPU prealloc list represented as
|
2008-01-29 06:19:52 +01:00
|
|
|
*
|
|
|
|
* ext4_sb_info.s_locality_groups[smp_processor_id()]
|
|
|
|
*
|
|
|
|
* The reason for having a per cpu locality group is to reduce the contention
|
|
|
|
* between CPUs. It is possible to get scheduled at this point.
|
|
|
|
*
|
|
|
|
* The locality group prealloc space is used looking at whether we have
|
2011-03-31 03:57:33 +02:00
|
|
|
* enough free space (pa_free) within the prealloc space.
|
2008-01-29 06:19:52 +01:00
|
|
|
*
|
|
|
|
* If we can't allocate blocks via inode prealloc or/and locality group
|
|
|
|
* prealloc then we look at the buddy cache. The buddy cache is represented
|
|
|
|
* by ext4_sb_info.s_buddy_cache (struct inode) whose file offset gets
|
|
|
|
* mapped to the buddy and bitmap information regarding different
|
|
|
|
* groups. The buddy information is attached to buddy cache inode so that
|
|
|
|
* we can access them through the page cache. The information regarding
|
|
|
|
* each group is loaded via ext4_mb_load_buddy. The information involve
|
|
|
|
* block bitmap and buddy information. The information are stored in the
|
|
|
|
* inode as:
|
|
|
|
*
|
|
|
|
* { page }
|
2008-11-25 21:11:52 +01:00
|
|
|
* [ group 0 bitmap][ group 0 buddy] [group 1][ group 1]...
|
2008-01-29 06:19:52 +01:00
|
|
|
*
|
|
|
|
*
|
|
|
|
* one block each for bitmap and buddy information. So for each group we
|
|
|
|
* take up 2 blocks. A page can contain blocks_per_page (PAGE_CACHE_SIZE /
|
|
|
|
* blocksize) blocks. So it can have information regarding groups_per_page
|
|
|
|
* which is blocks_per_page/2
|
|
|
|
*
|
|
|
|
* The buddy cache inode is not stored on disk. The inode is thrown
|
|
|
|
* away when the filesystem is unmounted.
|
|
|
|
*
|
|
|
|
* We look for count number of blocks in the buddy cache. If we were able
|
|
|
|
* to locate that many free blocks we return with additional information
|
|
|
|
* regarding rest of the contiguous physical block available
|
|
|
|
*
|
|
|
|
* Before allocating blocks via buddy cache we normalize the request
|
|
|
|
* blocks. This ensure we ask for more blocks that we needed. The extra
|
|
|
|
* blocks that we get after allocation is added to the respective prealloc
|
|
|
|
* list. In case of inode preallocation we follow a list of heuristics
|
|
|
|
* based on file size. This can be found in ext4_mb_normalize_request. If
|
|
|
|
* we are doing a group prealloc we try to normalize the request to
|
2011-09-10 01:02:51 +02:00
|
|
|
* sbi->s_mb_group_prealloc. The default value of s_mb_group_prealloc is
|
|
|
|
* dependent on the cluster size; for non-bigalloc file systems, it is
|
2008-01-29 06:19:52 +01:00
|
|
|
* 512 blocks. This can be tuned via
|
2011-07-18 03:11:30 +02:00
|
|
|
* /sys/fs/ext4/<partition>/mb_group_prealloc. The value is represented in
|
2008-01-29 06:19:52 +01:00
|
|
|
* terms of number of blocks. If we have mounted the file system with -O
|
|
|
|
* stripe=<value> option the group prealloc request is normalized to the
|
2011-07-18 03:11:30 +02:00
|
|
|
* the smallest multiple of the stripe value (sbi->s_stripe) which is
|
|
|
|
* greater than the default mb_group_prealloc.
|
2008-01-29 06:19:52 +01:00
|
|
|
*
|
2011-07-18 03:11:30 +02:00
|
|
|
* The regular allocator (using the buddy cache) supports a few tunables.
|
2008-01-29 06:19:52 +01:00
|
|
|
*
|
2009-03-31 15:11:14 +02:00
|
|
|
* /sys/fs/ext4/<partition>/mb_min_to_scan
|
|
|
|
* /sys/fs/ext4/<partition>/mb_max_to_scan
|
|
|
|
* /sys/fs/ext4/<partition>/mb_order2_req
|
2008-01-29 06:19:52 +01:00
|
|
|
*
|
2009-03-31 15:11:14 +02:00
|
|
|
* The regular allocator uses buddy scan only if the request len is power of
|
2008-01-29 06:19:52 +01:00
|
|
|
* 2 blocks and the order of allocation is >= sbi->s_mb_order2_reqs. The
|
|
|
|
* value of s_mb_order2_reqs can be tuned via
|
2009-03-31 15:11:14 +02:00
|
|
|
* /sys/fs/ext4/<partition>/mb_order2_req. If the request len is equal to
|
tree-wide: fix assorted typos all over the place
That is "success", "unknown", "through", "performance", "[re|un]mapping"
, "access", "default", "reasonable", "[con]currently", "temperature"
, "channel", "[un]used", "application", "example","hierarchy", "therefore"
, "[over|under]flow", "contiguous", "threshold", "enough" and others.
Signed-off-by: André Goddard Rosa <andre.goddard@gmail.com>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2009-11-14 16:09:05 +01:00
|
|
|
* stripe size (sbi->s_stripe), we try to search for contiguous block in
|
2009-03-31 15:11:14 +02:00
|
|
|
* stripe size. This should result in better allocation on RAID setups. If
|
|
|
|
* not, we search in the specific group using bitmap for best extents. The
|
|
|
|
* tunable min_to_scan and max_to_scan control the behaviour here.
|
2008-01-29 06:19:52 +01:00
|
|
|
* min_to_scan indicate how long the mballoc __must__ look for a best
|
2009-03-31 15:11:14 +02:00
|
|
|
* extent and max_to_scan indicates how long the mballoc __can__ look for a
|
2008-01-29 06:19:52 +01:00
|
|
|
* best extent in the found extents. Searching for the blocks starts with
|
|
|
|
* the group specified as the goal value in allocation context via
|
|
|
|
* ac_g_ex. Each group is first checked based on the criteria whether it
|
2011-07-12 00:42:42 +02:00
|
|
|
* can be used for allocation. ext4_mb_good_group explains how the groups are
|
2008-01-29 06:19:52 +01:00
|
|
|
* checked.
|
|
|
|
*
|
|
|
|
* Both the prealloc space are getting populated as above. So for the first
|
|
|
|
* request we will hit the buddy cache which will result in this prealloc
|
|
|
|
* space getting filled. The prealloc space is then later used for the
|
|
|
|
* subsequent request.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* mballoc operates on the following data:
|
|
|
|
* - on-disk bitmap
|
|
|
|
* - in-core buddy (actually includes buddy and bitmap)
|
|
|
|
* - preallocation descriptors (PAs)
|
|
|
|
*
|
|
|
|
* there are two types of preallocations:
|
|
|
|
* - inode
|
|
|
|
* assiged to specific inode and can be used for this inode only.
|
|
|
|
* it describes part of inode's space preallocated to specific
|
|
|
|
* physical blocks. any block from that preallocated can be used
|
|
|
|
* independent. the descriptor just tracks number of blocks left
|
|
|
|
* unused. so, before taking some block from descriptor, one must
|
|
|
|
* make sure corresponded logical block isn't allocated yet. this
|
|
|
|
* also means that freeing any block within descriptor's range
|
|
|
|
* must discard all preallocated blocks.
|
|
|
|
* - locality group
|
|
|
|
* assigned to specific locality group which does not translate to
|
|
|
|
* permanent set of inodes: inode can join and leave group. space
|
|
|
|
* from this type of preallocation can be used for any inode. thus
|
|
|
|
* it's consumed from the beginning to the end.
|
|
|
|
*
|
|
|
|
* relation between them can be expressed as:
|
|
|
|
* in-core buddy = on-disk bitmap + preallocation descriptors
|
|
|
|
*
|
|
|
|
* this mean blocks mballoc considers used are:
|
|
|
|
* - allocated blocks (persistent)
|
|
|
|
* - preallocated blocks (non-persistent)
|
|
|
|
*
|
|
|
|
* consistency in mballoc world means that at any time a block is either
|
|
|
|
* free or used in ALL structures. notice: "any time" should not be read
|
|
|
|
* literally -- time is discrete and delimited by locks.
|
|
|
|
*
|
|
|
|
* to keep it simple, we don't use block numbers, instead we count number of
|
|
|
|
* blocks: how many blocks marked used/free in on-disk bitmap, buddy and PA.
|
|
|
|
*
|
|
|
|
* all operations can be expressed as:
|
|
|
|
* - init buddy: buddy = on-disk + PAs
|
|
|
|
* - new PA: buddy += N; PA = N
|
|
|
|
* - use inode PA: on-disk += N; PA -= N
|
|
|
|
* - discard inode PA buddy -= on-disk - PA; PA = 0
|
|
|
|
* - use locality group PA on-disk += N; PA -= N
|
|
|
|
* - discard locality group PA buddy -= PA; PA = 0
|
|
|
|
* note: 'buddy -= on-disk - PA' is used to show that on-disk bitmap
|
|
|
|
* is used in real operation because we can't know actual used
|
|
|
|
* bits from PA, only from on-disk bitmap
|
|
|
|
*
|
|
|
|
* if we follow this strict logic, then all operations above should be atomic.
|
|
|
|
* given some of them can block, we'd have to use something like semaphores
|
|
|
|
* killing performance on high-end SMP hardware. let's try to relax it using
|
|
|
|
* the following knowledge:
|
|
|
|
* 1) if buddy is referenced, it's already initialized
|
|
|
|
* 2) while block is used in buddy and the buddy is referenced,
|
|
|
|
* nobody can re-allocate that block
|
|
|
|
* 3) we work on bitmaps and '+' actually means 'set bits'. if on-disk has
|
|
|
|
* bit set and PA claims same block, it's OK. IOW, one can set bit in
|
|
|
|
* on-disk bitmap if buddy has same bit set or/and PA covers corresponded
|
|
|
|
* block
|
|
|
|
*
|
|
|
|
* so, now we're building a concurrency table:
|
|
|
|
* - init buddy vs.
|
|
|
|
* - new PA
|
|
|
|
* blocks for PA are allocated in the buddy, buddy must be referenced
|
|
|
|
* until PA is linked to allocation group to avoid concurrent buddy init
|
|
|
|
* - use inode PA
|
|
|
|
* we need to make sure that either on-disk bitmap or PA has uptodate data
|
|
|
|
* given (3) we care that PA-=N operation doesn't interfere with init
|
|
|
|
* - discard inode PA
|
|
|
|
* the simplest way would be to have buddy initialized by the discard
|
|
|
|
* - use locality group PA
|
|
|
|
* again PA-=N must be serialized with init
|
|
|
|
* - discard locality group PA
|
|
|
|
* the simplest way would be to have buddy initialized by the discard
|
|
|
|
* - new PA vs.
|
|
|
|
* - use inode PA
|
|
|
|
* i_data_sem serializes them
|
|
|
|
* - discard inode PA
|
|
|
|
* discard process must wait until PA isn't used by another process
|
|
|
|
* - use locality group PA
|
|
|
|
* some mutex should serialize them
|
|
|
|
* - discard locality group PA
|
|
|
|
* discard process must wait until PA isn't used by another process
|
|
|
|
* - use inode PA
|
|
|
|
* - use inode PA
|
|
|
|
* i_data_sem or another mutex should serializes them
|
|
|
|
* - discard inode PA
|
|
|
|
* discard process must wait until PA isn't used by another process
|
|
|
|
* - use locality group PA
|
|
|
|
* nothing wrong here -- they're different PAs covering different blocks
|
|
|
|
* - discard locality group PA
|
|
|
|
* discard process must wait until PA isn't used by another process
|
|
|
|
*
|
|
|
|
* now we're ready to make few consequences:
|
|
|
|
* - PA is referenced and while it is no discard is possible
|
|
|
|
* - PA is referenced until block isn't marked in on-disk bitmap
|
|
|
|
* - PA changes only after on-disk bitmap
|
|
|
|
* - discard must not compete with init. either init is done before
|
|
|
|
* any discard or they're serialized somehow
|
|
|
|
* - buddy init as sum of on-disk bitmap and PAs is done atomically
|
|
|
|
*
|
|
|
|
* a special case when we've used PA to emptiness. no need to modify buddy
|
|
|
|
* in this case, but we should care about concurrent init
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Logic in few words:
|
|
|
|
*
|
|
|
|
* - allocation:
|
|
|
|
* load group
|
|
|
|
* find blocks
|
|
|
|
* mark bits in on-disk bitmap
|
|
|
|
* release group
|
|
|
|
*
|
|
|
|
* - use preallocation:
|
|
|
|
* find proper PA (per-inode or group)
|
|
|
|
* load group
|
|
|
|
* mark bits in on-disk bitmap
|
|
|
|
* release group
|
|
|
|
* release PA
|
|
|
|
*
|
|
|
|
* - free:
|
|
|
|
* load group
|
|
|
|
* mark bits in on-disk bitmap
|
|
|
|
* release group
|
|
|
|
*
|
|
|
|
* - discard preallocations in group:
|
|
|
|
* mark PAs deleted
|
|
|
|
* move them onto local list
|
|
|
|
* load on-disk bitmap
|
|
|
|
* load group
|
|
|
|
* remove PA from object (inode or locality group)
|
|
|
|
* mark free blocks in-core
|
|
|
|
*
|
|
|
|
* - discard inode's preallocations:
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Locking rules
|
|
|
|
*
|
|
|
|
* Locks:
|
|
|
|
* - bitlock on a group (group)
|
|
|
|
* - object (inode/locality) (object)
|
|
|
|
* - per-pa lock (pa)
|
|
|
|
*
|
|
|
|
* Paths:
|
|
|
|
* - new pa
|
|
|
|
* object
|
|
|
|
* group
|
|
|
|
*
|
|
|
|
* - find and use pa:
|
|
|
|
* pa
|
|
|
|
*
|
|
|
|
* - release consumed pa:
|
|
|
|
* pa
|
|
|
|
* group
|
|
|
|
* object
|
|
|
|
*
|
|
|
|
* - generate in-core bitmap:
|
|
|
|
* group
|
|
|
|
* pa
|
|
|
|
*
|
|
|
|
* - discard all for given object (inode, locality group):
|
|
|
|
* object
|
|
|
|
* pa
|
|
|
|
* group
|
|
|
|
*
|
|
|
|
* - discard all for given group:
|
|
|
|
* group
|
|
|
|
* pa
|
|
|
|
* group
|
|
|
|
* object
|
|
|
|
*
|
|
|
|
*/
|
2008-11-25 21:11:52 +01:00
|
|
|
static struct kmem_cache *ext4_pspace_cachep;
|
|
|
|
static struct kmem_cache *ext4_ac_cachep;
|
2012-02-20 23:53:02 +01:00
|
|
|
static struct kmem_cache *ext4_free_data_cachep;
|
2010-10-28 03:29:12 +02:00
|
|
|
|
|
|
|
/* We create slab caches for groupinfo data structures based on the
|
|
|
|
* superblock block size. There will be one per mounted filesystem for
|
|
|
|
* each unique s_blocksize_bits */
|
2011-02-12 14:12:18 +01:00
|
|
|
#define NR_GRPINFO_CACHES 8
|
2010-10-28 03:29:12 +02:00
|
|
|
static struct kmem_cache *ext4_groupinfo_caches[NR_GRPINFO_CACHES];
|
|
|
|
|
2011-02-12 14:12:18 +01:00
|
|
|
static const char *ext4_groupinfo_slab_names[NR_GRPINFO_CACHES] = {
|
|
|
|
"ext4_groupinfo_1k", "ext4_groupinfo_2k", "ext4_groupinfo_4k",
|
|
|
|
"ext4_groupinfo_8k", "ext4_groupinfo_16k", "ext4_groupinfo_32k",
|
|
|
|
"ext4_groupinfo_64k", "ext4_groupinfo_128k"
|
|
|
|
};
|
|
|
|
|
2008-11-25 21:11:52 +01:00
|
|
|
static void ext4_mb_generate_from_pa(struct super_block *sb, void *bitmap,
|
|
|
|
ext4_group_t group);
|
2009-01-06 03:36:55 +01:00
|
|
|
static void ext4_mb_generate_from_freelist(struct super_block *sb, void *bitmap,
|
|
|
|
ext4_group_t group);
|
2012-02-20 23:53:02 +01:00
|
|
|
static void ext4_free_data_callback(struct super_block *sb,
|
|
|
|
struct ext4_journal_cb_entry *jce, int rc);
|
2008-11-25 21:11:52 +01:00
|
|
|
|
2008-02-23 07:38:34 +01:00
|
|
|
static inline void *mb_correct_addr_and_bit(int *bit, void *addr)
|
|
|
|
{
|
2008-01-29 06:19:52 +01:00
|
|
|
#if BITS_PER_LONG == 64
|
2008-02-23 07:38:34 +01:00
|
|
|
*bit += ((unsigned long) addr & 7UL) << 3;
|
|
|
|
addr = (void *) ((unsigned long) addr & ~7UL);
|
2008-01-29 06:19:52 +01:00
|
|
|
#elif BITS_PER_LONG == 32
|
2008-02-23 07:38:34 +01:00
|
|
|
*bit += ((unsigned long) addr & 3UL) << 3;
|
|
|
|
addr = (void *) ((unsigned long) addr & ~3UL);
|
2008-01-29 06:19:52 +01:00
|
|
|
#else
|
|
|
|
#error "how many bits you are?!"
|
|
|
|
#endif
|
2008-02-23 07:38:34 +01:00
|
|
|
return addr;
|
|
|
|
}
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
static inline int mb_test_bit(int bit, void *addr)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* ext4_test_bit on architecture like powerpc
|
|
|
|
* needs unsigned long aligned address
|
|
|
|
*/
|
2008-02-23 07:38:34 +01:00
|
|
|
addr = mb_correct_addr_and_bit(&bit, addr);
|
2008-01-29 06:19:52 +01:00
|
|
|
return ext4_test_bit(bit, addr);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void mb_set_bit(int bit, void *addr)
|
|
|
|
{
|
2008-02-23 07:38:34 +01:00
|
|
|
addr = mb_correct_addr_and_bit(&bit, addr);
|
2008-01-29 06:19:52 +01:00
|
|
|
ext4_set_bit(bit, addr);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void mb_clear_bit(int bit, void *addr)
|
|
|
|
{
|
2008-02-23 07:38:34 +01:00
|
|
|
addr = mb_correct_addr_and_bit(&bit, addr);
|
2008-01-29 06:19:52 +01:00
|
|
|
ext4_clear_bit(bit, addr);
|
|
|
|
}
|
|
|
|
|
2013-04-09 18:22:29 +02:00
|
|
|
static inline int mb_test_and_clear_bit(int bit, void *addr)
|
|
|
|
{
|
|
|
|
addr = mb_correct_addr_and_bit(&bit, addr);
|
|
|
|
return ext4_test_and_clear_bit(bit, addr);
|
|
|
|
}
|
|
|
|
|
2008-02-23 07:38:34 +01:00
|
|
|
static inline int mb_find_next_zero_bit(void *addr, int max, int start)
|
|
|
|
{
|
2008-07-12 01:27:31 +02:00
|
|
|
int fix = 0, ret, tmpmax;
|
2008-02-23 07:38:34 +01:00
|
|
|
addr = mb_correct_addr_and_bit(&fix, addr);
|
2008-07-12 01:27:31 +02:00
|
|
|
tmpmax = max + fix;
|
2008-02-23 07:38:34 +01:00
|
|
|
start += fix;
|
|
|
|
|
2008-07-12 01:27:31 +02:00
|
|
|
ret = ext4_find_next_zero_bit(addr, tmpmax, start) - fix;
|
|
|
|
if (ret > max)
|
|
|
|
return max;
|
|
|
|
return ret;
|
2008-02-23 07:38:34 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline int mb_find_next_bit(void *addr, int max, int start)
|
|
|
|
{
|
2008-07-12 01:27:31 +02:00
|
|
|
int fix = 0, ret, tmpmax;
|
2008-02-23 07:38:34 +01:00
|
|
|
addr = mb_correct_addr_and_bit(&fix, addr);
|
2008-07-12 01:27:31 +02:00
|
|
|
tmpmax = max + fix;
|
2008-02-23 07:38:34 +01:00
|
|
|
start += fix;
|
|
|
|
|
2008-07-12 01:27:31 +02:00
|
|
|
ret = ext4_find_next_bit(addr, tmpmax, start) - fix;
|
|
|
|
if (ret > max)
|
|
|
|
return max;
|
|
|
|
return ret;
|
2008-02-23 07:38:34 +01:00
|
|
|
}
|
|
|
|
|
2008-01-29 06:19:52 +01:00
|
|
|
static void *mb_find_buddy(struct ext4_buddy *e4b, int order, int *max)
|
|
|
|
{
|
|
|
|
char *bb;
|
|
|
|
|
2012-02-20 23:54:06 +01:00
|
|
|
BUG_ON(e4b->bd_bitmap == e4b->bd_buddy);
|
2008-01-29 06:19:52 +01:00
|
|
|
BUG_ON(max == NULL);
|
|
|
|
|
|
|
|
if (order > e4b->bd_blkbits + 1) {
|
|
|
|
*max = 0;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* at order 0 we see each particular block */
|
2011-02-24 18:51:59 +01:00
|
|
|
if (order == 0) {
|
|
|
|
*max = 1 << (e4b->bd_blkbits + 3);
|
2012-02-20 23:54:06 +01:00
|
|
|
return e4b->bd_bitmap;
|
2011-02-24 18:51:59 +01:00
|
|
|
}
|
2008-01-29 06:19:52 +01:00
|
|
|
|
2012-02-20 23:54:06 +01:00
|
|
|
bb = e4b->bd_buddy + EXT4_SB(e4b->bd_sb)->s_mb_offsets[order];
|
2008-01-29 06:19:52 +01:00
|
|
|
*max = EXT4_SB(e4b->bd_sb)->s_mb_maxs[order];
|
|
|
|
|
|
|
|
return bb;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef DOUBLE_CHECK
|
|
|
|
static void mb_free_blocks_double(struct inode *inode, struct ext4_buddy *e4b,
|
|
|
|
int first, int count)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct super_block *sb = e4b->bd_sb;
|
|
|
|
|
|
|
|
if (unlikely(e4b->bd_info->bb_bitmap == NULL))
|
|
|
|
return;
|
2009-05-15 14:33:18 +02:00
|
|
|
assert_spin_locked(ext4_group_lock_ptr(sb, e4b->bd_group));
|
2008-01-29 06:19:52 +01:00
|
|
|
for (i = 0; i < count; i++) {
|
|
|
|
if (!mb_test_bit(first + i, e4b->bd_info->bb_bitmap)) {
|
|
|
|
ext4_fsblk_t blocknr;
|
2010-03-04 05:53:39 +01:00
|
|
|
|
|
|
|
blocknr = ext4_group_first_block_no(sb, e4b->bd_group);
|
2011-09-10 00:48:51 +02:00
|
|
|
blocknr += EXT4_C2B(EXT4_SB(sb), first + i);
|
2009-01-06 04:19:52 +01:00
|
|
|
ext4_grp_locked_error(sb, e4b->bd_group,
|
2010-06-29 18:54:28 +02:00
|
|
|
inode ? inode->i_ino : 0,
|
|
|
|
blocknr,
|
|
|
|
"freeing block already freed "
|
|
|
|
"(bit %u)",
|
|
|
|
first + i);
|
2008-01-29 06:19:52 +01:00
|
|
|
}
|
|
|
|
mb_clear_bit(first + i, e4b->bd_info->bb_bitmap);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mb_mark_used_double(struct ext4_buddy *e4b, int first, int count)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (unlikely(e4b->bd_info->bb_bitmap == NULL))
|
|
|
|
return;
|
2009-05-15 14:33:18 +02:00
|
|
|
assert_spin_locked(ext4_group_lock_ptr(e4b->bd_sb, e4b->bd_group));
|
2008-01-29 06:19:52 +01:00
|
|
|
for (i = 0; i < count; i++) {
|
|
|
|
BUG_ON(mb_test_bit(first + i, e4b->bd_info->bb_bitmap));
|
|
|
|
mb_set_bit(first + i, e4b->bd_info->bb_bitmap);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mb_cmp_bitmaps(struct ext4_buddy *e4b, void *bitmap)
|
|
|
|
{
|
|
|
|
if (memcmp(e4b->bd_info->bb_bitmap, bitmap, e4b->bd_sb->s_blocksize)) {
|
|
|
|
unsigned char *b1, *b2;
|
|
|
|
int i;
|
|
|
|
b1 = (unsigned char *) e4b->bd_info->bb_bitmap;
|
|
|
|
b2 = (unsigned char *) bitmap;
|
|
|
|
for (i = 0; i < e4b->bd_sb->s_blocksize; i++) {
|
|
|
|
if (b1[i] != b2[i]) {
|
2011-08-01 23:41:35 +02:00
|
|
|
ext4_msg(e4b->bd_sb, KERN_ERR,
|
|
|
|
"corruption in group %u "
|
|
|
|
"at byte %u(%u): %x in copy != %x "
|
|
|
|
"on disk/prealloc",
|
|
|
|
e4b->bd_group, i, i * 8, b1[i], b2[i]);
|
2008-01-29 06:19:52 +01:00
|
|
|
BUG();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
|
|
|
static inline void mb_free_blocks_double(struct inode *inode,
|
|
|
|
struct ext4_buddy *e4b, int first, int count)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
static inline void mb_mark_used_double(struct ext4_buddy *e4b,
|
|
|
|
int first, int count)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
static inline void mb_cmp_bitmaps(struct ext4_buddy *e4b, void *bitmap)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef AGGRESSIVE_CHECK
|
|
|
|
|
|
|
|
#define MB_CHECK_ASSERT(assert) \
|
|
|
|
do { \
|
|
|
|
if (!(assert)) { \
|
|
|
|
printk(KERN_EMERG \
|
|
|
|
"Assertion failure in %s() at %s:%d: \"%s\"\n", \
|
|
|
|
function, file, line, # assert); \
|
|
|
|
BUG(); \
|
|
|
|
} \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
static int __mb_check_buddy(struct ext4_buddy *e4b, char *file,
|
|
|
|
const char *function, int line)
|
|
|
|
{
|
|
|
|
struct super_block *sb = e4b->bd_sb;
|
|
|
|
int order = e4b->bd_blkbits + 1;
|
|
|
|
int max;
|
|
|
|
int max2;
|
|
|
|
int i;
|
|
|
|
int j;
|
|
|
|
int k;
|
|
|
|
int count;
|
|
|
|
struct ext4_group_info *grp;
|
|
|
|
int fragments = 0;
|
|
|
|
int fstart;
|
|
|
|
struct list_head *cur;
|
|
|
|
void *buddy;
|
|
|
|
void *buddy2;
|
|
|
|
|
|
|
|
{
|
|
|
|
static int mb_check_counter;
|
|
|
|
if (mb_check_counter++ % 100 != 0)
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
while (order > 1) {
|
|
|
|
buddy = mb_find_buddy(e4b, order, &max);
|
|
|
|
MB_CHECK_ASSERT(buddy);
|
|
|
|
buddy2 = mb_find_buddy(e4b, order - 1, &max2);
|
|
|
|
MB_CHECK_ASSERT(buddy2);
|
|
|
|
MB_CHECK_ASSERT(buddy != buddy2);
|
|
|
|
MB_CHECK_ASSERT(max * 2 == max2);
|
|
|
|
|
|
|
|
count = 0;
|
|
|
|
for (i = 0; i < max; i++) {
|
|
|
|
|
|
|
|
if (mb_test_bit(i, buddy)) {
|
|
|
|
/* only single bit in buddy2 may be 1 */
|
|
|
|
if (!mb_test_bit(i << 1, buddy2)) {
|
|
|
|
MB_CHECK_ASSERT(
|
|
|
|
mb_test_bit((i<<1)+1, buddy2));
|
|
|
|
} else if (!mb_test_bit((i << 1) + 1, buddy2)) {
|
|
|
|
MB_CHECK_ASSERT(
|
|
|
|
mb_test_bit(i << 1, buddy2));
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2011-10-26 14:48:54 +02:00
|
|
|
/* both bits in buddy2 must be 1 */
|
2008-01-29 06:19:52 +01:00
|
|
|
MB_CHECK_ASSERT(mb_test_bit(i << 1, buddy2));
|
|
|
|
MB_CHECK_ASSERT(mb_test_bit((i << 1) + 1, buddy2));
|
|
|
|
|
|
|
|
for (j = 0; j < (1 << order); j++) {
|
|
|
|
k = (i * (1 << order)) + j;
|
|
|
|
MB_CHECK_ASSERT(
|
2012-02-20 23:54:06 +01:00
|
|
|
!mb_test_bit(k, e4b->bd_bitmap));
|
2008-01-29 06:19:52 +01:00
|
|
|
}
|
|
|
|
count++;
|
|
|
|
}
|
|
|
|
MB_CHECK_ASSERT(e4b->bd_info->bb_counters[order] == count);
|
|
|
|
order--;
|
|
|
|
}
|
|
|
|
|
|
|
|
fstart = -1;
|
|
|
|
buddy = mb_find_buddy(e4b, 0, &max);
|
|
|
|
for (i = 0; i < max; i++) {
|
|
|
|
if (!mb_test_bit(i, buddy)) {
|
|
|
|
MB_CHECK_ASSERT(i >= e4b->bd_info->bb_first_free);
|
|
|
|
if (fstart == -1) {
|
|
|
|
fragments++;
|
|
|
|
fstart = i;
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
fstart = -1;
|
|
|
|
/* check used bits only */
|
|
|
|
for (j = 0; j < e4b->bd_blkbits + 1; j++) {
|
|
|
|
buddy2 = mb_find_buddy(e4b, j, &max2);
|
|
|
|
k = i >> j;
|
|
|
|
MB_CHECK_ASSERT(k < max2);
|
|
|
|
MB_CHECK_ASSERT(mb_test_bit(k, buddy2));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
MB_CHECK_ASSERT(!EXT4_MB_GRP_NEED_INIT(e4b->bd_info));
|
|
|
|
MB_CHECK_ASSERT(e4b->bd_info->bb_fragments == fragments);
|
|
|
|
|
|
|
|
grp = ext4_get_group_info(sb, e4b->bd_group);
|
|
|
|
list_for_each(cur, &grp->bb_prealloc_list) {
|
|
|
|
ext4_group_t groupnr;
|
|
|
|
struct ext4_prealloc_space *pa;
|
2008-04-30 03:59:59 +02:00
|
|
|
pa = list_entry(cur, struct ext4_prealloc_space, pa_group_list);
|
|
|
|
ext4_get_group_no_and_offset(sb, pa->pa_pstart, &groupnr, &k);
|
2008-01-29 06:19:52 +01:00
|
|
|
MB_CHECK_ASSERT(groupnr == e4b->bd_group);
|
2008-04-30 03:59:59 +02:00
|
|
|
for (i = 0; i < pa->pa_len; i++)
|
2008-01-29 06:19:52 +01:00
|
|
|
MB_CHECK_ASSERT(mb_test_bit(k + i, buddy));
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#undef MB_CHECK_ASSERT
|
|
|
|
#define mb_check_buddy(e4b) __mb_check_buddy(e4b, \
|
2008-04-17 16:38:59 +02:00
|
|
|
__FILE__, __func__, __LINE__)
|
2008-01-29 06:19:52 +01:00
|
|
|
#else
|
|
|
|
#define mb_check_buddy(e4b)
|
|
|
|
#endif
|
|
|
|
|
2011-02-24 19:24:25 +01:00
|
|
|
/*
|
|
|
|
* Divide blocks started from @first with length @len into
|
|
|
|
* smaller chunks with power of 2 blocks.
|
|
|
|
* Clear the bits in bitmap which the blocks of the chunk(s) covered,
|
|
|
|
* then increase bb_counters[] for corresponded chunk size.
|
|
|
|
*/
|
2008-01-29 06:19:52 +01:00
|
|
|
static void ext4_mb_mark_free_simple(struct super_block *sb,
|
2009-08-26 04:36:45 +02:00
|
|
|
void *buddy, ext4_grpblk_t first, ext4_grpblk_t len,
|
2008-01-29 06:19:52 +01:00
|
|
|
struct ext4_group_info *grp)
|
|
|
|
{
|
|
|
|
struct ext4_sb_info *sbi = EXT4_SB(sb);
|
2009-08-26 04:36:45 +02:00
|
|
|
ext4_grpblk_t min;
|
|
|
|
ext4_grpblk_t max;
|
|
|
|
ext4_grpblk_t chunk;
|
2008-01-29 06:19:52 +01:00
|
|
|
unsigned short border;
|
|
|
|
|
2011-09-10 00:38:51 +02:00
|
|
|
BUG_ON(len > EXT4_CLUSTERS_PER_GROUP(sb));
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
border = 2 << sb->s_blocksize_bits;
|
|
|
|
|
|
|
|
while (len > 0) {
|
|
|
|
/* find how many blocks can be covered since this position */
|
|
|
|
max = ffs(first | border) - 1;
|
|
|
|
|
|
|
|
/* find how many blocks of power 2 we need to mark */
|
|
|
|
min = fls(len) - 1;
|
|
|
|
|
|
|
|
if (max < min)
|
|
|
|
min = max;
|
|
|
|
chunk = 1 << min;
|
|
|
|
|
|
|
|
/* mark multiblock chunks only */
|
|
|
|
grp->bb_counters[min]++;
|
|
|
|
if (min > 0)
|
|
|
|
mb_clear_bit(first >> min,
|
|
|
|
buddy + sbi->s_mb_offsets[min]);
|
|
|
|
|
|
|
|
len -= chunk;
|
|
|
|
first += chunk;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-05-16 21:00:00 +02:00
|
|
|
/*
|
|
|
|
* Cache the order of the largest free extent we have available in this block
|
|
|
|
* group.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
mb_set_largest_free_order(struct super_block *sb, struct ext4_group_info *grp)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int bits;
|
|
|
|
|
|
|
|
grp->bb_largest_free_order = -1; /* uninit */
|
|
|
|
|
|
|
|
bits = sb->s_blocksize_bits + 1;
|
|
|
|
for (i = bits; i >= 0; i--) {
|
|
|
|
if (grp->bb_counters[i] > 0) {
|
|
|
|
grp->bb_largest_free_order = i;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-07-06 04:17:31 +02:00
|
|
|
static noinline_for_stack
|
|
|
|
void ext4_mb_generate_buddy(struct super_block *sb,
|
2008-01-29 06:19:52 +01:00
|
|
|
void *buddy, void *bitmap, ext4_group_t group)
|
|
|
|
{
|
|
|
|
struct ext4_group_info *grp = ext4_get_group_info(sb, group);
|
2011-09-10 00:38:51 +02:00
|
|
|
ext4_grpblk_t max = EXT4_CLUSTERS_PER_GROUP(sb);
|
2009-08-26 04:36:45 +02:00
|
|
|
ext4_grpblk_t i = 0;
|
|
|
|
ext4_grpblk_t first;
|
|
|
|
ext4_grpblk_t len;
|
2008-01-29 06:19:52 +01:00
|
|
|
unsigned free = 0;
|
|
|
|
unsigned fragments = 0;
|
|
|
|
unsigned long long period = get_cycles();
|
|
|
|
|
|
|
|
/* initialize buddy from bitmap which is aggregation
|
|
|
|
* of on-disk bitmap and preallocations */
|
2008-02-23 07:38:34 +01:00
|
|
|
i = mb_find_next_zero_bit(bitmap, max, 0);
|
2008-01-29 06:19:52 +01:00
|
|
|
grp->bb_first_free = i;
|
|
|
|
while (i < max) {
|
|
|
|
fragments++;
|
|
|
|
first = i;
|
2008-02-23 07:38:34 +01:00
|
|
|
i = mb_find_next_bit(bitmap, max, i);
|
2008-01-29 06:19:52 +01:00
|
|
|
len = i - first;
|
|
|
|
free += len;
|
|
|
|
if (len > 1)
|
|
|
|
ext4_mb_mark_free_simple(sb, buddy, first, len, grp);
|
|
|
|
else
|
|
|
|
grp->bb_counters[0]++;
|
|
|
|
if (i < max)
|
2008-02-23 07:38:34 +01:00
|
|
|
i = mb_find_next_zero_bit(bitmap, max, i);
|
2008-01-29 06:19:52 +01:00
|
|
|
}
|
|
|
|
grp->bb_fragments = fragments;
|
|
|
|
|
|
|
|
if (free != grp->bb_free) {
|
2010-06-29 18:54:28 +02:00
|
|
|
ext4_grp_locked_error(sb, group, 0, 0,
|
ext4: mark block group as corrupt on block bitmap error
When we notice a block-bitmap corruption (because of device failure or
something else), we should mark this group as corrupt and prevent
further block allocations/deallocations from it. Currently, we end up
generating one error message for every block in the bitmap. This
potentially could make the system unstable as noticed in some
bugs. With this patch, the error will be printed only the first time
and mark the entire block group as corrupted. This prevents future
access allocations/deallocations from it.
Also tested by corrupting the block
bitmap and forcefully introducing the mb_free_blocks error:
(1) create a largefile (2Gb)
$ dd if=/dev/zero of=largefile oflag=direct bs=10485760 count=200
(2) umount filesystem. use dumpe2fs to see which block-bitmaps
are in use by largefile and note their block numbers
(3) use dd to zero-out the used block bitmaps
$ dd if=/dev/zero of=/dev/hdc4 bs=4096 seek=14 count=8 oflag=direct
(4) mount the FS and delete the largefile.
(5) recreate the largefile. verify that the new largefile does not
get any blocks from the groups marked as bad.
Without the patch, we will see mb_free_blocks error for each bit in
each zero'ed out bitmap at (4). With the patch, we only see the error
once per blockgroup:
[ 309.706803] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 15: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
[ 309.720824] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 14: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
[ 309.732858] EXT4-fs error (device sdb4) in ext4_free_blocks:4802: IO failure
[ 309.748321] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 13: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
[ 309.760331] EXT4-fs error (device sdb4) in ext4_free_blocks:4802: IO failure
[ 309.769695] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 12: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
[ 309.781721] EXT4-fs error (device sdb4) in ext4_free_blocks:4802: IO failure
[ 309.798166] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 11: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
[ 309.810184] EXT4-fs error (device sdb4) in ext4_free_blocks:4802: IO failure
[ 309.819532] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 10: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
Google-Bug-Id: 7258357
[darrick.wong@oracle.com]
Further modifications (by Darrick) to make more obvious that this corruption
bit applies to blocks only. Set the corruption flag if the block group bitmap
verification fails.
Original-author: Aditya Kali <adityakali@google.com>
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2013-08-28 23:35:51 +02:00
|
|
|
"%u clusters in bitmap, %u in gd; "
|
|
|
|
"block bitmap corrupt.",
|
2010-06-29 18:54:28 +02:00
|
|
|
free, grp->bb_free);
|
2008-02-15 19:48:21 +01:00
|
|
|
/*
|
ext4: mark block group as corrupt on block bitmap error
When we notice a block-bitmap corruption (because of device failure or
something else), we should mark this group as corrupt and prevent
further block allocations/deallocations from it. Currently, we end up
generating one error message for every block in the bitmap. This
potentially could make the system unstable as noticed in some
bugs. With this patch, the error will be printed only the first time
and mark the entire block group as corrupted. This prevents future
access allocations/deallocations from it.
Also tested by corrupting the block
bitmap and forcefully introducing the mb_free_blocks error:
(1) create a largefile (2Gb)
$ dd if=/dev/zero of=largefile oflag=direct bs=10485760 count=200
(2) umount filesystem. use dumpe2fs to see which block-bitmaps
are in use by largefile and note their block numbers
(3) use dd to zero-out the used block bitmaps
$ dd if=/dev/zero of=/dev/hdc4 bs=4096 seek=14 count=8 oflag=direct
(4) mount the FS and delete the largefile.
(5) recreate the largefile. verify that the new largefile does not
get any blocks from the groups marked as bad.
Without the patch, we will see mb_free_blocks error for each bit in
each zero'ed out bitmap at (4). With the patch, we only see the error
once per blockgroup:
[ 309.706803] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 15: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
[ 309.720824] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 14: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
[ 309.732858] EXT4-fs error (device sdb4) in ext4_free_blocks:4802: IO failure
[ 309.748321] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 13: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
[ 309.760331] EXT4-fs error (device sdb4) in ext4_free_blocks:4802: IO failure
[ 309.769695] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 12: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
[ 309.781721] EXT4-fs error (device sdb4) in ext4_free_blocks:4802: IO failure
[ 309.798166] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 11: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
[ 309.810184] EXT4-fs error (device sdb4) in ext4_free_blocks:4802: IO failure
[ 309.819532] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 10: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
Google-Bug-Id: 7258357
[darrick.wong@oracle.com]
Further modifications (by Darrick) to make more obvious that this corruption
bit applies to blocks only. Set the corruption flag if the block group bitmap
verification fails.
Original-author: Aditya Kali <adityakali@google.com>
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2013-08-28 23:35:51 +02:00
|
|
|
* If we intend to continue, we consider group descriptor
|
2008-02-15 19:48:21 +01:00
|
|
|
* corrupt and update bb_free using bitmap value
|
|
|
|
*/
|
2008-01-29 06:19:52 +01:00
|
|
|
grp->bb_free = free;
|
ext4: mark block group as corrupt on block bitmap error
When we notice a block-bitmap corruption (because of device failure or
something else), we should mark this group as corrupt and prevent
further block allocations/deallocations from it. Currently, we end up
generating one error message for every block in the bitmap. This
potentially could make the system unstable as noticed in some
bugs. With this patch, the error will be printed only the first time
and mark the entire block group as corrupted. This prevents future
access allocations/deallocations from it.
Also tested by corrupting the block
bitmap and forcefully introducing the mb_free_blocks error:
(1) create a largefile (2Gb)
$ dd if=/dev/zero of=largefile oflag=direct bs=10485760 count=200
(2) umount filesystem. use dumpe2fs to see which block-bitmaps
are in use by largefile and note their block numbers
(3) use dd to zero-out the used block bitmaps
$ dd if=/dev/zero of=/dev/hdc4 bs=4096 seek=14 count=8 oflag=direct
(4) mount the FS and delete the largefile.
(5) recreate the largefile. verify that the new largefile does not
get any blocks from the groups marked as bad.
Without the patch, we will see mb_free_blocks error for each bit in
each zero'ed out bitmap at (4). With the patch, we only see the error
once per blockgroup:
[ 309.706803] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 15: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
[ 309.720824] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 14: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
[ 309.732858] EXT4-fs error (device sdb4) in ext4_free_blocks:4802: IO failure
[ 309.748321] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 13: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
[ 309.760331] EXT4-fs error (device sdb4) in ext4_free_blocks:4802: IO failure
[ 309.769695] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 12: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
[ 309.781721] EXT4-fs error (device sdb4) in ext4_free_blocks:4802: IO failure
[ 309.798166] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 11: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
[ 309.810184] EXT4-fs error (device sdb4) in ext4_free_blocks:4802: IO failure
[ 309.819532] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 10: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
Google-Bug-Id: 7258357
[darrick.wong@oracle.com]
Further modifications (by Darrick) to make more obvious that this corruption
bit applies to blocks only. Set the corruption flag if the block group bitmap
verification fails.
Original-author: Aditya Kali <adityakali@google.com>
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2013-08-28 23:35:51 +02:00
|
|
|
set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT, &grp->bb_state);
|
2008-01-29 06:19:52 +01:00
|
|
|
}
|
2010-05-16 21:00:00 +02:00
|
|
|
mb_set_largest_free_order(sb, grp);
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
clear_bit(EXT4_GROUP_INFO_NEED_INIT_BIT, &(grp->bb_state));
|
|
|
|
|
|
|
|
period = get_cycles() - period;
|
|
|
|
spin_lock(&EXT4_SB(sb)->s_bal_lock);
|
|
|
|
EXT4_SB(sb)->s_mb_buddies_generated++;
|
|
|
|
EXT4_SB(sb)->s_mb_generation_time += period;
|
|
|
|
spin_unlock(&EXT4_SB(sb)->s_bal_lock);
|
|
|
|
}
|
|
|
|
|
2013-04-09 18:22:29 +02:00
|
|
|
static void mb_regenerate_buddy(struct ext4_buddy *e4b)
|
|
|
|
{
|
|
|
|
int count;
|
|
|
|
int order = 1;
|
|
|
|
void *buddy;
|
|
|
|
|
|
|
|
while ((buddy = mb_find_buddy(e4b, order++, &count))) {
|
|
|
|
ext4_set_bits(buddy, 0, count);
|
|
|
|
}
|
|
|
|
e4b->bd_info->bb_fragments = 0;
|
|
|
|
memset(e4b->bd_info->bb_counters, 0,
|
|
|
|
sizeof(*e4b->bd_info->bb_counters) *
|
|
|
|
(e4b->bd_sb->s_blocksize_bits + 2));
|
|
|
|
|
|
|
|
ext4_mb_generate_buddy(e4b->bd_sb, e4b->bd_buddy,
|
|
|
|
e4b->bd_bitmap, e4b->bd_group);
|
|
|
|
}
|
|
|
|
|
2008-01-29 06:19:52 +01:00
|
|
|
/* The buddy information is attached the buddy cache inode
|
|
|
|
* for convenience. The information regarding each group
|
|
|
|
* is loaded via ext4_mb_load_buddy. The information involve
|
|
|
|
* block bitmap and buddy information. The information are
|
|
|
|
* stored in the inode as
|
|
|
|
*
|
|
|
|
* { page }
|
2008-11-25 21:11:52 +01:00
|
|
|
* [ group 0 bitmap][ group 0 buddy] [group 1][ group 1]...
|
2008-01-29 06:19:52 +01:00
|
|
|
*
|
|
|
|
*
|
|
|
|
* one block each for bitmap and buddy information.
|
|
|
|
* So for each group we take up 2 blocks. A page can
|
|
|
|
* contain blocks_per_page (PAGE_CACHE_SIZE / blocksize) blocks.
|
|
|
|
* So it can have information regarding groups_per_page which
|
|
|
|
* is blocks_per_page/2
|
2010-05-16 21:00:00 +02:00
|
|
|
*
|
|
|
|
* Locking note: This routine takes the block group lock of all groups
|
|
|
|
* for this page; do not hold this lock when calling this routine!
|
2008-01-29 06:19:52 +01:00
|
|
|
*/
|
|
|
|
|
|
|
|
static int ext4_mb_init_cache(struct page *page, char *incore)
|
|
|
|
{
|
2009-05-01 14:50:38 +02:00
|
|
|
ext4_group_t ngroups;
|
2008-01-29 06:19:52 +01:00
|
|
|
int blocksize;
|
|
|
|
int blocks_per_page;
|
|
|
|
int groups_per_page;
|
|
|
|
int err = 0;
|
|
|
|
int i;
|
2012-02-20 23:52:46 +01:00
|
|
|
ext4_group_t first_group, group;
|
2008-01-29 06:19:52 +01:00
|
|
|
int first_block;
|
|
|
|
struct super_block *sb;
|
|
|
|
struct buffer_head *bhs;
|
2012-04-30 00:35:10 +02:00
|
|
|
struct buffer_head **bh = NULL;
|
2008-01-29 06:19:52 +01:00
|
|
|
struct inode *inode;
|
|
|
|
char *data;
|
|
|
|
char *bitmap;
|
2011-05-10 03:49:42 +02:00
|
|
|
struct ext4_group_info *grinfo;
|
2008-01-29 06:19:52 +01:00
|
|
|
|
2009-09-18 19:38:55 +02:00
|
|
|
mb_debug(1, "init page %lu\n", page->index);
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
inode = page->mapping->host;
|
|
|
|
sb = inode->i_sb;
|
2009-05-01 14:50:38 +02:00
|
|
|
ngroups = ext4_get_groups_count(sb);
|
2008-01-29 06:19:52 +01:00
|
|
|
blocksize = 1 << inode->i_blkbits;
|
|
|
|
blocks_per_page = PAGE_CACHE_SIZE / blocksize;
|
|
|
|
|
|
|
|
groups_per_page = blocks_per_page >> 1;
|
|
|
|
if (groups_per_page == 0)
|
|
|
|
groups_per_page = 1;
|
|
|
|
|
|
|
|
/* allocate buffer_heads to read bitmaps */
|
|
|
|
if (groups_per_page > 1) {
|
|
|
|
i = sizeof(struct buffer_head *) * groups_per_page;
|
|
|
|
bh = kzalloc(i, GFP_NOFS);
|
2012-02-20 23:52:46 +01:00
|
|
|
if (bh == NULL) {
|
|
|
|
err = -ENOMEM;
|
2008-01-29 06:19:52 +01:00
|
|
|
goto out;
|
2012-02-20 23:52:46 +01:00
|
|
|
}
|
2008-01-29 06:19:52 +01:00
|
|
|
} else
|
|
|
|
bh = &bhs;
|
|
|
|
|
|
|
|
first_group = page->index * blocks_per_page / 2;
|
|
|
|
|
|
|
|
/* read all groups the page covers into the cache */
|
2012-02-20 23:52:46 +01:00
|
|
|
for (i = 0, group = first_group; i < groups_per_page; i++, group++) {
|
|
|
|
if (group >= ngroups)
|
2008-01-29 06:19:52 +01:00
|
|
|
break;
|
|
|
|
|
2012-02-20 23:52:46 +01:00
|
|
|
grinfo = ext4_get_group_info(sb, group);
|
2011-05-10 03:49:42 +02:00
|
|
|
/*
|
|
|
|
* If page is uptodate then we came here after online resize
|
|
|
|
* which added some new uninitialized group info structs, so
|
|
|
|
* we must skip all initialized uptodate buddies on the page,
|
|
|
|
* which may be currently in use by an allocating task.
|
|
|
|
*/
|
|
|
|
if (PageUptodate(page) && !EXT4_MB_GRP_NEED_INIT(grinfo)) {
|
|
|
|
bh[i] = NULL;
|
|
|
|
continue;
|
|
|
|
}
|
2012-02-20 23:52:46 +01:00
|
|
|
if (!(bh[i] = ext4_read_block_bitmap_nowait(sb, group))) {
|
|
|
|
err = -ENOMEM;
|
2008-01-29 06:19:52 +01:00
|
|
|
goto out;
|
2009-01-06 03:49:55 +01:00
|
|
|
}
|
2012-02-20 23:52:46 +01:00
|
|
|
mb_debug(1, "read bitmap for group %u\n", group);
|
2008-01-29 06:19:52 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* wait for I/O completion */
|
2012-02-20 23:52:46 +01:00
|
|
|
for (i = 0, group = first_group; i < groups_per_page; i++, group++) {
|
|
|
|
if (bh[i] && ext4_wait_block_bitmap(sb, group, bh[i])) {
|
|
|
|
err = -EIO;
|
2008-01-29 06:19:52 +01:00
|
|
|
goto out;
|
2012-02-20 23:52:46 +01:00
|
|
|
}
|
|
|
|
}
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
first_block = page->index * blocks_per_page;
|
|
|
|
for (i = 0; i < blocks_per_page; i++) {
|
|
|
|
group = (first_block + i) >> 1;
|
2009-05-01 14:50:38 +02:00
|
|
|
if (group >= ngroups)
|
2008-01-29 06:19:52 +01:00
|
|
|
break;
|
|
|
|
|
2011-05-10 03:49:42 +02:00
|
|
|
if (!bh[group - first_group])
|
|
|
|
/* skip initialized uptodate buddy */
|
|
|
|
continue;
|
|
|
|
|
2008-01-29 06:19:52 +01:00
|
|
|
/*
|
|
|
|
* data carry information regarding this
|
|
|
|
* particular group in the format specified
|
|
|
|
* above
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
data = page_address(page) + (i * blocksize);
|
|
|
|
bitmap = bh[group - first_group]->b_data;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We place the buddy block and bitmap block
|
|
|
|
* close together
|
|
|
|
*/
|
|
|
|
if ((first_block + i) & 1) {
|
|
|
|
/* this is block of buddy */
|
|
|
|
BUG_ON(incore == NULL);
|
2009-09-18 19:38:55 +02:00
|
|
|
mb_debug(1, "put buddy for group %u in page %lu/%x\n",
|
2008-01-29 06:19:52 +01:00
|
|
|
group, page->index, i * blocksize);
|
2010-05-17 09:00:00 +02:00
|
|
|
trace_ext4_mb_buddy_bitmap_load(sb, group);
|
2008-01-29 06:19:52 +01:00
|
|
|
grinfo = ext4_get_group_info(sb, group);
|
|
|
|
grinfo->bb_fragments = 0;
|
|
|
|
memset(grinfo->bb_counters, 0,
|
2009-08-26 04:36:25 +02:00
|
|
|
sizeof(*grinfo->bb_counters) *
|
|
|
|
(sb->s_blocksize_bits+2));
|
2008-01-29 06:19:52 +01:00
|
|
|
/*
|
|
|
|
* incore got set to the group block bitmap below
|
|
|
|
*/
|
2009-01-06 03:36:55 +01:00
|
|
|
ext4_lock_group(sb, group);
|
2011-05-10 03:49:42 +02:00
|
|
|
/* init the buddy */
|
|
|
|
memset(data, 0xff, blocksize);
|
2008-01-29 06:19:52 +01:00
|
|
|
ext4_mb_generate_buddy(sb, data, incore, group);
|
2009-01-06 03:36:55 +01:00
|
|
|
ext4_unlock_group(sb, group);
|
2008-01-29 06:19:52 +01:00
|
|
|
incore = NULL;
|
|
|
|
} else {
|
|
|
|
/* this is block of bitmap */
|
|
|
|
BUG_ON(incore != NULL);
|
2009-09-18 19:38:55 +02:00
|
|
|
mb_debug(1, "put bitmap for group %u in page %lu/%x\n",
|
2008-01-29 06:19:52 +01:00
|
|
|
group, page->index, i * blocksize);
|
2010-05-17 09:00:00 +02:00
|
|
|
trace_ext4_mb_bitmap_load(sb, group);
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
/* see comments in ext4_mb_put_pa() */
|
|
|
|
ext4_lock_group(sb, group);
|
|
|
|
memcpy(data, bitmap, blocksize);
|
|
|
|
|
|
|
|
/* mark all preallocated blks used in in-core bitmap */
|
|
|
|
ext4_mb_generate_from_pa(sb, data, group);
|
2009-01-06 03:36:55 +01:00
|
|
|
ext4_mb_generate_from_freelist(sb, data, group);
|
2008-01-29 06:19:52 +01:00
|
|
|
ext4_unlock_group(sb, group);
|
|
|
|
|
|
|
|
/* set incore so that the buddy information can be
|
|
|
|
* generated using this
|
|
|
|
*/
|
|
|
|
incore = data;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
SetPageUptodate(page);
|
|
|
|
|
|
|
|
out:
|
|
|
|
if (bh) {
|
2011-05-10 03:49:42 +02:00
|
|
|
for (i = 0; i < groups_per_page; i++)
|
2008-01-29 06:19:52 +01:00
|
|
|
brelse(bh[i]);
|
|
|
|
if (bh != &bhs)
|
|
|
|
kfree(bh);
|
|
|
|
}
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2010-10-28 03:30:15 +02:00
|
|
|
/*
|
2011-05-10 03:48:13 +02:00
|
|
|
* Lock the buddy and bitmap pages. This make sure other parallel init_group
|
|
|
|
* on the same buddy page doesn't happen whild holding the buddy page lock.
|
|
|
|
* Return locked buddy and bitmap pages on e4b struct. If buddy and bitmap
|
|
|
|
* are on the same page e4b->bd_buddy_page is NULL and return value is 0.
|
2010-10-28 03:30:15 +02:00
|
|
|
*/
|
2011-05-10 03:48:13 +02:00
|
|
|
static int ext4_mb_get_buddy_page_lock(struct super_block *sb,
|
|
|
|
ext4_group_t group, struct ext4_buddy *e4b)
|
2010-10-28 03:30:15 +02:00
|
|
|
{
|
2011-05-10 03:48:13 +02:00
|
|
|
struct inode *inode = EXT4_SB(sb)->s_buddy_cache;
|
|
|
|
int block, pnum, poff;
|
2010-10-28 03:30:15 +02:00
|
|
|
int blocks_per_page;
|
2011-05-10 03:48:13 +02:00
|
|
|
struct page *page;
|
|
|
|
|
|
|
|
e4b->bd_buddy_page = NULL;
|
|
|
|
e4b->bd_bitmap_page = NULL;
|
2010-10-28 03:30:15 +02:00
|
|
|
|
|
|
|
blocks_per_page = PAGE_CACHE_SIZE / sb->s_blocksize;
|
|
|
|
/*
|
|
|
|
* the buddy cache inode stores the block bitmap
|
|
|
|
* and buddy information in consecutive blocks.
|
|
|
|
* So for each group we need two blocks.
|
|
|
|
*/
|
|
|
|
block = group * 2;
|
|
|
|
pnum = block / blocks_per_page;
|
2011-05-10 03:48:13 +02:00
|
|
|
poff = block % blocks_per_page;
|
|
|
|
page = find_or_create_page(inode->i_mapping, pnum, GFP_NOFS);
|
|
|
|
if (!page)
|
|
|
|
return -EIO;
|
|
|
|
BUG_ON(page->mapping != inode->i_mapping);
|
|
|
|
e4b->bd_bitmap_page = page;
|
|
|
|
e4b->bd_bitmap = page_address(page) + (poff * sb->s_blocksize);
|
|
|
|
|
|
|
|
if (blocks_per_page >= 2) {
|
|
|
|
/* buddy and bitmap are on the same page */
|
|
|
|
return 0;
|
2010-10-28 03:30:15 +02:00
|
|
|
}
|
2011-05-10 03:48:13 +02:00
|
|
|
|
|
|
|
block++;
|
|
|
|
pnum = block / blocks_per_page;
|
|
|
|
page = find_or_create_page(inode->i_mapping, pnum, GFP_NOFS);
|
|
|
|
if (!page)
|
|
|
|
return -EIO;
|
|
|
|
BUG_ON(page->mapping != inode->i_mapping);
|
|
|
|
e4b->bd_buddy_page = page;
|
|
|
|
return 0;
|
2010-10-28 03:30:15 +02:00
|
|
|
}
|
|
|
|
|
2011-05-10 03:48:13 +02:00
|
|
|
static void ext4_mb_put_buddy_page_lock(struct ext4_buddy *e4b)
|
2010-10-28 03:30:15 +02:00
|
|
|
{
|
2011-05-10 03:48:13 +02:00
|
|
|
if (e4b->bd_bitmap_page) {
|
|
|
|
unlock_page(e4b->bd_bitmap_page);
|
|
|
|
page_cache_release(e4b->bd_bitmap_page);
|
|
|
|
}
|
|
|
|
if (e4b->bd_buddy_page) {
|
|
|
|
unlock_page(e4b->bd_buddy_page);
|
|
|
|
page_cache_release(e4b->bd_buddy_page);
|
2010-10-28 03:30:15 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-05-16 21:00:00 +02:00
|
|
|
/*
|
|
|
|
* Locking note: This routine calls ext4_mb_init_cache(), which takes the
|
|
|
|
* block group lock of all groups for this page; do not hold the BG lock when
|
|
|
|
* calling this routine!
|
|
|
|
*/
|
2009-09-10 05:47:46 +02:00
|
|
|
static noinline_for_stack
|
|
|
|
int ext4_mb_init_group(struct super_block *sb, ext4_group_t group)
|
|
|
|
{
|
|
|
|
|
|
|
|
struct ext4_group_info *this_grp;
|
2011-05-10 03:48:13 +02:00
|
|
|
struct ext4_buddy e4b;
|
|
|
|
struct page *page;
|
|
|
|
int ret = 0;
|
2009-09-10 05:47:46 +02:00
|
|
|
|
2013-04-04 04:00:52 +02:00
|
|
|
might_sleep();
|
2009-09-10 05:47:46 +02:00
|
|
|
mb_debug(1, "init group %u\n", group);
|
|
|
|
this_grp = ext4_get_group_info(sb, group);
|
|
|
|
/*
|
2009-09-10 05:50:17 +02:00
|
|
|
* This ensures that we don't reinit the buddy cache
|
|
|
|
* page which map to the group from which we are already
|
|
|
|
* allocating. If we are looking at the buddy cache we would
|
|
|
|
* have taken a reference using ext4_mb_load_buddy and that
|
2011-05-10 03:48:13 +02:00
|
|
|
* would have pinned buddy page to page cache.
|
2009-09-10 05:47:46 +02:00
|
|
|
*/
|
2011-05-10 03:48:13 +02:00
|
|
|
ret = ext4_mb_get_buddy_page_lock(sb, group, &e4b);
|
|
|
|
if (ret || !EXT4_MB_GRP_NEED_INIT(this_grp)) {
|
2009-09-10 05:47:46 +02:00
|
|
|
/*
|
|
|
|
* somebody initialized the group
|
|
|
|
* return without doing anything
|
|
|
|
*/
|
|
|
|
goto err;
|
|
|
|
}
|
2011-05-10 03:48:13 +02:00
|
|
|
|
|
|
|
page = e4b.bd_bitmap_page;
|
|
|
|
ret = ext4_mb_init_cache(page, NULL);
|
|
|
|
if (ret)
|
|
|
|
goto err;
|
|
|
|
if (!PageUptodate(page)) {
|
2009-09-10 05:47:46 +02:00
|
|
|
ret = -EIO;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
mark_page_accessed(page);
|
|
|
|
|
2011-05-10 03:48:13 +02:00
|
|
|
if (e4b.bd_buddy_page == NULL) {
|
2009-09-10 05:47:46 +02:00
|
|
|
/*
|
|
|
|
* If both the bitmap and buddy are in
|
|
|
|
* the same page we don't need to force
|
|
|
|
* init the buddy
|
|
|
|
*/
|
2011-05-10 03:48:13 +02:00
|
|
|
ret = 0;
|
|
|
|
goto err;
|
2009-09-10 05:47:46 +02:00
|
|
|
}
|
2011-05-10 03:48:13 +02:00
|
|
|
/* init buddy cache */
|
|
|
|
page = e4b.bd_buddy_page;
|
|
|
|
ret = ext4_mb_init_cache(page, e4b.bd_bitmap);
|
|
|
|
if (ret)
|
|
|
|
goto err;
|
|
|
|
if (!PageUptodate(page)) {
|
2009-09-10 05:47:46 +02:00
|
|
|
ret = -EIO;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
mark_page_accessed(page);
|
|
|
|
err:
|
2011-05-10 03:48:13 +02:00
|
|
|
ext4_mb_put_buddy_page_lock(&e4b);
|
2009-09-10 05:47:46 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-05-16 21:00:00 +02:00
|
|
|
/*
|
|
|
|
* Locking note: This routine calls ext4_mb_init_cache(), which takes the
|
|
|
|
* block group lock of all groups for this page; do not hold the BG lock when
|
|
|
|
* calling this routine!
|
|
|
|
*/
|
2008-04-29 14:11:12 +02:00
|
|
|
static noinline_for_stack int
|
|
|
|
ext4_mb_load_buddy(struct super_block *sb, ext4_group_t group,
|
|
|
|
struct ext4_buddy *e4b)
|
2008-01-29 06:19:52 +01:00
|
|
|
{
|
|
|
|
int blocks_per_page;
|
|
|
|
int block;
|
|
|
|
int pnum;
|
|
|
|
int poff;
|
|
|
|
struct page *page;
|
2008-07-12 01:27:31 +02:00
|
|
|
int ret;
|
2009-01-06 03:36:19 +01:00
|
|
|
struct ext4_group_info *grp;
|
|
|
|
struct ext4_sb_info *sbi = EXT4_SB(sb);
|
|
|
|
struct inode *inode = sbi->s_buddy_cache;
|
2008-01-29 06:19:52 +01:00
|
|
|
|
2013-04-04 04:00:52 +02:00
|
|
|
might_sleep();
|
2009-09-18 19:38:55 +02:00
|
|
|
mb_debug(1, "load group %u\n", group);
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
blocks_per_page = PAGE_CACHE_SIZE / sb->s_blocksize;
|
2009-01-06 03:36:19 +01:00
|
|
|
grp = ext4_get_group_info(sb, group);
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
e4b->bd_blkbits = sb->s_blocksize_bits;
|
2011-07-23 22:07:26 +02:00
|
|
|
e4b->bd_info = grp;
|
2008-01-29 06:19:52 +01:00
|
|
|
e4b->bd_sb = sb;
|
|
|
|
e4b->bd_group = group;
|
|
|
|
e4b->bd_buddy_page = NULL;
|
|
|
|
e4b->bd_bitmap_page = NULL;
|
|
|
|
|
2009-09-10 05:34:50 +02:00
|
|
|
if (unlikely(EXT4_MB_GRP_NEED_INIT(grp))) {
|
|
|
|
/*
|
|
|
|
* we need full data about the group
|
|
|
|
* to make a good selection
|
|
|
|
*/
|
|
|
|
ret = ext4_mb_init_group(sb, group);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-01-29 06:19:52 +01:00
|
|
|
/*
|
|
|
|
* the buddy cache inode stores the block bitmap
|
|
|
|
* and buddy information in consecutive blocks.
|
|
|
|
* So for each group we need two blocks.
|
|
|
|
*/
|
|
|
|
block = group * 2;
|
|
|
|
pnum = block / blocks_per_page;
|
|
|
|
poff = block % blocks_per_page;
|
|
|
|
|
|
|
|
/* we could use find_or_create_page(), but it locks page
|
|
|
|
* what we'd like to avoid in fast path ... */
|
|
|
|
page = find_get_page(inode->i_mapping, pnum);
|
|
|
|
if (page == NULL || !PageUptodate(page)) {
|
|
|
|
if (page)
|
2009-01-06 03:36:19 +01:00
|
|
|
/*
|
|
|
|
* drop the page reference and try
|
|
|
|
* to get the page with lock. If we
|
|
|
|
* are not uptodate that implies
|
|
|
|
* somebody just created the page but
|
|
|
|
* is yet to initialize the same. So
|
|
|
|
* wait for it to initialize.
|
|
|
|
*/
|
2008-01-29 06:19:52 +01:00
|
|
|
page_cache_release(page);
|
|
|
|
page = find_or_create_page(inode->i_mapping, pnum, GFP_NOFS);
|
|
|
|
if (page) {
|
|
|
|
BUG_ON(page->mapping != inode->i_mapping);
|
|
|
|
if (!PageUptodate(page)) {
|
2008-07-12 01:27:31 +02:00
|
|
|
ret = ext4_mb_init_cache(page, NULL);
|
|
|
|
if (ret) {
|
|
|
|
unlock_page(page);
|
|
|
|
goto err;
|
|
|
|
}
|
2008-01-29 06:19:52 +01:00
|
|
|
mb_cmp_bitmaps(e4b, page_address(page) +
|
|
|
|
(poff * sb->s_blocksize));
|
|
|
|
}
|
|
|
|
unlock_page(page);
|
|
|
|
}
|
|
|
|
}
|
2008-07-12 01:27:31 +02:00
|
|
|
if (page == NULL || !PageUptodate(page)) {
|
|
|
|
ret = -EIO;
|
2008-01-29 06:19:52 +01:00
|
|
|
goto err;
|
2008-07-12 01:27:31 +02:00
|
|
|
}
|
2008-01-29 06:19:52 +01:00
|
|
|
e4b->bd_bitmap_page = page;
|
|
|
|
e4b->bd_bitmap = page_address(page) + (poff * sb->s_blocksize);
|
|
|
|
mark_page_accessed(page);
|
|
|
|
|
|
|
|
block++;
|
|
|
|
pnum = block / blocks_per_page;
|
|
|
|
poff = block % blocks_per_page;
|
|
|
|
|
|
|
|
page = find_get_page(inode->i_mapping, pnum);
|
|
|
|
if (page == NULL || !PageUptodate(page)) {
|
|
|
|
if (page)
|
|
|
|
page_cache_release(page);
|
|
|
|
page = find_or_create_page(inode->i_mapping, pnum, GFP_NOFS);
|
|
|
|
if (page) {
|
|
|
|
BUG_ON(page->mapping != inode->i_mapping);
|
2008-07-12 01:27:31 +02:00
|
|
|
if (!PageUptodate(page)) {
|
|
|
|
ret = ext4_mb_init_cache(page, e4b->bd_bitmap);
|
|
|
|
if (ret) {
|
|
|
|
unlock_page(page);
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
}
|
2008-01-29 06:19:52 +01:00
|
|
|
unlock_page(page);
|
|
|
|
}
|
|
|
|
}
|
2008-07-12 01:27:31 +02:00
|
|
|
if (page == NULL || !PageUptodate(page)) {
|
|
|
|
ret = -EIO;
|
2008-01-29 06:19:52 +01:00
|
|
|
goto err;
|
2008-07-12 01:27:31 +02:00
|
|
|
}
|
2008-01-29 06:19:52 +01:00
|
|
|
e4b->bd_buddy_page = page;
|
|
|
|
e4b->bd_buddy = page_address(page) + (poff * sb->s_blocksize);
|
|
|
|
mark_page_accessed(page);
|
|
|
|
|
|
|
|
BUG_ON(e4b->bd_bitmap_page == NULL);
|
|
|
|
BUG_ON(e4b->bd_buddy_page == NULL);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err:
|
2011-04-17 01:17:48 +02:00
|
|
|
if (page)
|
|
|
|
page_cache_release(page);
|
2008-01-29 06:19:52 +01:00
|
|
|
if (e4b->bd_bitmap_page)
|
|
|
|
page_cache_release(e4b->bd_bitmap_page);
|
|
|
|
if (e4b->bd_buddy_page)
|
|
|
|
page_cache_release(e4b->bd_buddy_page);
|
|
|
|
e4b->bd_buddy = NULL;
|
|
|
|
e4b->bd_bitmap = NULL;
|
2008-07-12 01:27:31 +02:00
|
|
|
return ret;
|
2008-01-29 06:19:52 +01:00
|
|
|
}
|
|
|
|
|
2010-05-14 06:00:00 +02:00
|
|
|
static void ext4_mb_unload_buddy(struct ext4_buddy *e4b)
|
2008-01-29 06:19:52 +01:00
|
|
|
{
|
|
|
|
if (e4b->bd_bitmap_page)
|
|
|
|
page_cache_release(e4b->bd_bitmap_page);
|
|
|
|
if (e4b->bd_buddy_page)
|
|
|
|
page_cache_release(e4b->bd_buddy_page);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int mb_find_order_for_block(struct ext4_buddy *e4b, int block)
|
|
|
|
{
|
|
|
|
int order = 1;
|
|
|
|
void *bb;
|
|
|
|
|
2012-02-20 23:54:06 +01:00
|
|
|
BUG_ON(e4b->bd_bitmap == e4b->bd_buddy);
|
2008-01-29 06:19:52 +01:00
|
|
|
BUG_ON(block >= (1 << (e4b->bd_blkbits + 3)));
|
|
|
|
|
2012-02-20 23:54:06 +01:00
|
|
|
bb = e4b->bd_buddy;
|
2008-01-29 06:19:52 +01:00
|
|
|
while (order <= e4b->bd_blkbits + 1) {
|
|
|
|
block = block >> 1;
|
|
|
|
if (!mb_test_bit(block, bb)) {
|
|
|
|
/* this block is part of buddy of order 'order' */
|
|
|
|
return order;
|
|
|
|
}
|
|
|
|
bb += 1 << (e4b->bd_blkbits - order);
|
|
|
|
order++;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-05-03 02:35:09 +02:00
|
|
|
static void mb_clear_bits(void *bm, int cur, int len)
|
2008-01-29 06:19:52 +01:00
|
|
|
{
|
|
|
|
__u32 *addr;
|
|
|
|
|
|
|
|
len = cur + len;
|
|
|
|
while (cur < len) {
|
|
|
|
if ((cur & 31) == 0 && (len - cur) >= 32) {
|
|
|
|
/* fast path: clear whole word at once */
|
|
|
|
addr = bm + (cur >> 3);
|
|
|
|
*addr = 0;
|
|
|
|
cur += 32;
|
|
|
|
continue;
|
|
|
|
}
|
2009-05-03 02:35:09 +02:00
|
|
|
mb_clear_bit(cur, bm);
|
2008-01-29 06:19:52 +01:00
|
|
|
cur++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-09 18:22:29 +02:00
|
|
|
/* clear bits in given range
|
|
|
|
* will return first found zero bit if any, -1 otherwise
|
|
|
|
*/
|
|
|
|
static int mb_test_and_clear_bits(void *bm, int cur, int len)
|
|
|
|
{
|
|
|
|
__u32 *addr;
|
|
|
|
int zero_bit = -1;
|
|
|
|
|
|
|
|
len = cur + len;
|
|
|
|
while (cur < len) {
|
|
|
|
if ((cur & 31) == 0 && (len - cur) >= 32) {
|
|
|
|
/* fast path: clear whole word at once */
|
|
|
|
addr = bm + (cur >> 3);
|
|
|
|
if (*addr != (__u32)(-1) && zero_bit == -1)
|
|
|
|
zero_bit = cur + mb_find_next_zero_bit(addr, 32, 0);
|
|
|
|
*addr = 0;
|
|
|
|
cur += 32;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!mb_test_and_clear_bit(cur, bm) && zero_bit == -1)
|
|
|
|
zero_bit = cur;
|
|
|
|
cur++;
|
|
|
|
}
|
|
|
|
|
|
|
|
return zero_bit;
|
|
|
|
}
|
|
|
|
|
2011-07-27 04:05:53 +02:00
|
|
|
void ext4_set_bits(void *bm, int cur, int len)
|
2008-01-29 06:19:52 +01:00
|
|
|
{
|
|
|
|
__u32 *addr;
|
|
|
|
|
|
|
|
len = cur + len;
|
|
|
|
while (cur < len) {
|
|
|
|
if ((cur & 31) == 0 && (len - cur) >= 32) {
|
|
|
|
/* fast path: set whole word at once */
|
|
|
|
addr = bm + (cur >> 3);
|
|
|
|
*addr = 0xffffffff;
|
|
|
|
cur += 32;
|
|
|
|
continue;
|
|
|
|
}
|
2009-05-03 02:35:09 +02:00
|
|
|
mb_set_bit(cur, bm);
|
2008-01-29 06:19:52 +01:00
|
|
|
cur++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-09 18:22:29 +02:00
|
|
|
/*
|
|
|
|
* _________________________________________________________________ */
|
|
|
|
|
|
|
|
static inline int mb_buddy_adjust_border(int* bit, void* bitmap, int side)
|
|
|
|
{
|
|
|
|
if (mb_test_bit(*bit + side, bitmap)) {
|
|
|
|
mb_clear_bit(*bit, bitmap);
|
|
|
|
(*bit) -= side;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
(*bit) += side;
|
|
|
|
mb_set_bit(*bit, bitmap);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mb_buddy_mark_free(struct ext4_buddy *e4b, int first, int last)
|
|
|
|
{
|
|
|
|
int max;
|
|
|
|
int order = 1;
|
|
|
|
void *buddy = mb_find_buddy(e4b, order, &max);
|
|
|
|
|
|
|
|
while (buddy) {
|
|
|
|
void *buddy2;
|
|
|
|
|
|
|
|
/* Bits in range [first; last] are known to be set since
|
|
|
|
* corresponding blocks were allocated. Bits in range
|
|
|
|
* (first; last) will stay set because they form buddies on
|
|
|
|
* upper layer. We just deal with borders if they don't
|
|
|
|
* align with upper layer and then go up.
|
|
|
|
* Releasing entire group is all about clearing
|
|
|
|
* single bit of highest order buddy.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Example:
|
|
|
|
* ---------------------------------
|
|
|
|
* | 1 | 1 | 1 | 1 |
|
|
|
|
* ---------------------------------
|
|
|
|
* | 0 | 1 | 1 | 1 | 1 | 1 | 1 | 1 |
|
|
|
|
* ---------------------------------
|
|
|
|
* 0 1 2 3 4 5 6 7
|
|
|
|
* \_____________________/
|
|
|
|
*
|
|
|
|
* Neither [1] nor [6] is aligned to above layer.
|
|
|
|
* Left neighbour [0] is free, so mark it busy,
|
|
|
|
* decrease bb_counters and extend range to
|
|
|
|
* [0; 6]
|
|
|
|
* Right neighbour [7] is busy. It can't be coaleasced with [6], so
|
|
|
|
* mark [6] free, increase bb_counters and shrink range to
|
|
|
|
* [0; 5].
|
|
|
|
* Then shift range to [0; 2], go up and do the same.
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
if (first & 1)
|
|
|
|
e4b->bd_info->bb_counters[order] += mb_buddy_adjust_border(&first, buddy, -1);
|
|
|
|
if (!(last & 1))
|
|
|
|
e4b->bd_info->bb_counters[order] += mb_buddy_adjust_border(&last, buddy, 1);
|
|
|
|
if (first > last)
|
|
|
|
break;
|
|
|
|
order++;
|
|
|
|
|
|
|
|
if (first == last || !(buddy2 = mb_find_buddy(e4b, order, &max))) {
|
|
|
|
mb_clear_bits(buddy, first, last - first + 1);
|
|
|
|
e4b->bd_info->bb_counters[order - 1] += last - first + 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
first >>= 1;
|
|
|
|
last >>= 1;
|
|
|
|
buddy = buddy2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-07-14 03:03:31 +02:00
|
|
|
static void mb_free_blocks(struct inode *inode, struct ext4_buddy *e4b,
|
2013-04-09 18:22:29 +02:00
|
|
|
int first, int count)
|
2008-01-29 06:19:52 +01:00
|
|
|
{
|
2013-04-09 18:22:29 +02:00
|
|
|
int left_is_free = 0;
|
|
|
|
int right_is_free = 0;
|
|
|
|
int block;
|
|
|
|
int last = first + count - 1;
|
2008-01-29 06:19:52 +01:00
|
|
|
struct super_block *sb = e4b->bd_sb;
|
|
|
|
|
2013-04-09 18:22:29 +02:00
|
|
|
BUG_ON(last >= (sb->s_blocksize << 3));
|
2009-05-15 14:33:18 +02:00
|
|
|
assert_spin_locked(ext4_group_lock_ptr(sb, e4b->bd_group));
|
ext4: mark block group as corrupt on block bitmap error
When we notice a block-bitmap corruption (because of device failure or
something else), we should mark this group as corrupt and prevent
further block allocations/deallocations from it. Currently, we end up
generating one error message for every block in the bitmap. This
potentially could make the system unstable as noticed in some
bugs. With this patch, the error will be printed only the first time
and mark the entire block group as corrupted. This prevents future
access allocations/deallocations from it.
Also tested by corrupting the block
bitmap and forcefully introducing the mb_free_blocks error:
(1) create a largefile (2Gb)
$ dd if=/dev/zero of=largefile oflag=direct bs=10485760 count=200
(2) umount filesystem. use dumpe2fs to see which block-bitmaps
are in use by largefile and note their block numbers
(3) use dd to zero-out the used block bitmaps
$ dd if=/dev/zero of=/dev/hdc4 bs=4096 seek=14 count=8 oflag=direct
(4) mount the FS and delete the largefile.
(5) recreate the largefile. verify that the new largefile does not
get any blocks from the groups marked as bad.
Without the patch, we will see mb_free_blocks error for each bit in
each zero'ed out bitmap at (4). With the patch, we only see the error
once per blockgroup:
[ 309.706803] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 15: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
[ 309.720824] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 14: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
[ 309.732858] EXT4-fs error (device sdb4) in ext4_free_blocks:4802: IO failure
[ 309.748321] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 13: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
[ 309.760331] EXT4-fs error (device sdb4) in ext4_free_blocks:4802: IO failure
[ 309.769695] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 12: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
[ 309.781721] EXT4-fs error (device sdb4) in ext4_free_blocks:4802: IO failure
[ 309.798166] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 11: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
[ 309.810184] EXT4-fs error (device sdb4) in ext4_free_blocks:4802: IO failure
[ 309.819532] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 10: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
Google-Bug-Id: 7258357
[darrick.wong@oracle.com]
Further modifications (by Darrick) to make more obvious that this corruption
bit applies to blocks only. Set the corruption flag if the block group bitmap
verification fails.
Original-author: Aditya Kali <adityakali@google.com>
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2013-08-28 23:35:51 +02:00
|
|
|
/* Don't bother if the block group is corrupt. */
|
|
|
|
if (unlikely(EXT4_MB_GRP_BBITMAP_CORRUPT(e4b->bd_info)))
|
|
|
|
return;
|
|
|
|
|
2008-01-29 06:19:52 +01:00
|
|
|
mb_check_buddy(e4b);
|
|
|
|
mb_free_blocks_double(inode, e4b, first, count);
|
|
|
|
|
|
|
|
e4b->bd_info->bb_free += count;
|
|
|
|
if (first < e4b->bd_info->bb_first_free)
|
|
|
|
e4b->bd_info->bb_first_free = first;
|
|
|
|
|
2013-04-09 18:22:29 +02:00
|
|
|
/* access memory sequentially: check left neighbour,
|
|
|
|
* clear range and then check right neighbour
|
|
|
|
*/
|
2008-01-29 06:19:52 +01:00
|
|
|
if (first != 0)
|
2013-04-09 18:22:29 +02:00
|
|
|
left_is_free = !mb_test_bit(first - 1, e4b->bd_bitmap);
|
|
|
|
block = mb_test_and_clear_bits(e4b->bd_bitmap, first, count);
|
|
|
|
if (last + 1 < EXT4_SB(sb)->s_mb_maxs[0])
|
|
|
|
right_is_free = !mb_test_bit(last + 1, e4b->bd_bitmap);
|
|
|
|
|
|
|
|
if (unlikely(block != -1)) {
|
|
|
|
ext4_fsblk_t blocknr;
|
|
|
|
|
|
|
|
blocknr = ext4_group_first_block_no(sb, e4b->bd_group);
|
|
|
|
blocknr += EXT4_C2B(EXT4_SB(sb), block);
|
|
|
|
ext4_grp_locked_error(sb, e4b->bd_group,
|
|
|
|
inode ? inode->i_ino : 0,
|
|
|
|
blocknr,
|
|
|
|
"freeing already freed block "
|
ext4: mark block group as corrupt on block bitmap error
When we notice a block-bitmap corruption (because of device failure or
something else), we should mark this group as corrupt and prevent
further block allocations/deallocations from it. Currently, we end up
generating one error message for every block in the bitmap. This
potentially could make the system unstable as noticed in some
bugs. With this patch, the error will be printed only the first time
and mark the entire block group as corrupted. This prevents future
access allocations/deallocations from it.
Also tested by corrupting the block
bitmap and forcefully introducing the mb_free_blocks error:
(1) create a largefile (2Gb)
$ dd if=/dev/zero of=largefile oflag=direct bs=10485760 count=200
(2) umount filesystem. use dumpe2fs to see which block-bitmaps
are in use by largefile and note their block numbers
(3) use dd to zero-out the used block bitmaps
$ dd if=/dev/zero of=/dev/hdc4 bs=4096 seek=14 count=8 oflag=direct
(4) mount the FS and delete the largefile.
(5) recreate the largefile. verify that the new largefile does not
get any blocks from the groups marked as bad.
Without the patch, we will see mb_free_blocks error for each bit in
each zero'ed out bitmap at (4). With the patch, we only see the error
once per blockgroup:
[ 309.706803] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 15: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
[ 309.720824] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 14: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
[ 309.732858] EXT4-fs error (device sdb4) in ext4_free_blocks:4802: IO failure
[ 309.748321] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 13: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
[ 309.760331] EXT4-fs error (device sdb4) in ext4_free_blocks:4802: IO failure
[ 309.769695] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 12: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
[ 309.781721] EXT4-fs error (device sdb4) in ext4_free_blocks:4802: IO failure
[ 309.798166] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 11: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
[ 309.810184] EXT4-fs error (device sdb4) in ext4_free_blocks:4802: IO failure
[ 309.819532] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 10: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
Google-Bug-Id: 7258357
[darrick.wong@oracle.com]
Further modifications (by Darrick) to make more obvious that this corruption
bit applies to blocks only. Set the corruption flag if the block group bitmap
verification fails.
Original-author: Aditya Kali <adityakali@google.com>
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2013-08-28 23:35:51 +02:00
|
|
|
"(bit %u); block bitmap corrupt.",
|
|
|
|
block);
|
|
|
|
/* Mark the block group as corrupt. */
|
|
|
|
set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT,
|
|
|
|
&e4b->bd_info->bb_state);
|
2013-04-09 18:22:29 +02:00
|
|
|
mb_regenerate_buddy(e4b);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* let's maintain fragments counter */
|
|
|
|
if (left_is_free && right_is_free)
|
2008-01-29 06:19:52 +01:00
|
|
|
e4b->bd_info->bb_fragments--;
|
2013-04-09 18:22:29 +02:00
|
|
|
else if (!left_is_free && !right_is_free)
|
2008-01-29 06:19:52 +01:00
|
|
|
e4b->bd_info->bb_fragments++;
|
|
|
|
|
2013-04-09 18:22:29 +02:00
|
|
|
/* buddy[0] == bd_bitmap is a special case, so handle
|
|
|
|
* it right away and let mb_buddy_mark_free stay free of
|
|
|
|
* zero order checks.
|
|
|
|
* Check if neighbours are to be coaleasced,
|
|
|
|
* adjust bitmap bb_counters and borders appropriately.
|
|
|
|
*/
|
|
|
|
if (first & 1) {
|
|
|
|
first += !left_is_free;
|
|
|
|
e4b->bd_info->bb_counters[0] += left_is_free ? -1 : 1;
|
|
|
|
}
|
|
|
|
if (!(last & 1)) {
|
|
|
|
last -= !right_is_free;
|
|
|
|
e4b->bd_info->bb_counters[0] += right_is_free ? -1 : 1;
|
|
|
|
}
|
2008-01-29 06:19:52 +01:00
|
|
|
|
2013-04-09 18:22:29 +02:00
|
|
|
if (first <= last)
|
|
|
|
mb_buddy_mark_free(e4b, first >> 1, last >> 1);
|
2008-01-29 06:19:52 +01:00
|
|
|
|
2013-04-09 18:22:29 +02:00
|
|
|
done:
|
2010-05-16 21:00:00 +02:00
|
|
|
mb_set_largest_free_order(sb, e4b->bd_info);
|
2008-01-29 06:19:52 +01:00
|
|
|
mb_check_buddy(e4b);
|
|
|
|
}
|
|
|
|
|
2012-08-17 16:02:17 +02:00
|
|
|
static int mb_find_extent(struct ext4_buddy *e4b, int block,
|
2008-01-29 06:19:52 +01:00
|
|
|
int needed, struct ext4_free_extent *ex)
|
|
|
|
{
|
|
|
|
int next = block;
|
2012-08-17 16:02:17 +02:00
|
|
|
int max, order;
|
2008-01-29 06:19:52 +01:00
|
|
|
void *buddy;
|
|
|
|
|
2009-05-15 14:33:18 +02:00
|
|
|
assert_spin_locked(ext4_group_lock_ptr(e4b->bd_sb, e4b->bd_group));
|
2008-01-29 06:19:52 +01:00
|
|
|
BUG_ON(ex == NULL);
|
|
|
|
|
2012-08-17 16:02:17 +02:00
|
|
|
buddy = mb_find_buddy(e4b, 0, &max);
|
2008-01-29 06:19:52 +01:00
|
|
|
BUG_ON(buddy == NULL);
|
|
|
|
BUG_ON(block >= max);
|
|
|
|
if (mb_test_bit(block, buddy)) {
|
|
|
|
ex->fe_len = 0;
|
|
|
|
ex->fe_start = 0;
|
|
|
|
ex->fe_group = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-08-17 16:02:17 +02:00
|
|
|
/* find actual order */
|
|
|
|
order = mb_find_order_for_block(e4b, block);
|
|
|
|
block = block >> order;
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
ex->fe_len = 1 << order;
|
|
|
|
ex->fe_start = block << order;
|
|
|
|
ex->fe_group = e4b->bd_group;
|
|
|
|
|
|
|
|
/* calc difference from given start */
|
|
|
|
next = next - ex->fe_start;
|
|
|
|
ex->fe_len -= next;
|
|
|
|
ex->fe_start += next;
|
|
|
|
|
|
|
|
while (needed > ex->fe_len &&
|
2012-11-08 18:19:58 +01:00
|
|
|
mb_find_buddy(e4b, order, &max)) {
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
if (block + 1 >= max)
|
|
|
|
break;
|
|
|
|
|
|
|
|
next = (block + 1) * (1 << order);
|
2012-02-20 23:54:06 +01:00
|
|
|
if (mb_test_bit(next, e4b->bd_bitmap))
|
2008-01-29 06:19:52 +01:00
|
|
|
break;
|
|
|
|
|
2011-10-26 11:30:30 +02:00
|
|
|
order = mb_find_order_for_block(e4b, next);
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
block = next >> order;
|
|
|
|
ex->fe_len += 1 << order;
|
|
|
|
}
|
|
|
|
|
|
|
|
BUG_ON(ex->fe_start + ex->fe_len > (1 << (e4b->bd_blkbits + 3)));
|
|
|
|
return ex->fe_len;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int mb_mark_used(struct ext4_buddy *e4b, struct ext4_free_extent *ex)
|
|
|
|
{
|
|
|
|
int ord;
|
|
|
|
int mlen = 0;
|
|
|
|
int max = 0;
|
|
|
|
int cur;
|
|
|
|
int start = ex->fe_start;
|
|
|
|
int len = ex->fe_len;
|
|
|
|
unsigned ret = 0;
|
|
|
|
int len0 = len;
|
|
|
|
void *buddy;
|
|
|
|
|
|
|
|
BUG_ON(start + len > (e4b->bd_sb->s_blocksize << 3));
|
|
|
|
BUG_ON(e4b->bd_group != ex->fe_group);
|
2009-05-15 14:33:18 +02:00
|
|
|
assert_spin_locked(ext4_group_lock_ptr(e4b->bd_sb, e4b->bd_group));
|
2008-01-29 06:19:52 +01:00
|
|
|
mb_check_buddy(e4b);
|
|
|
|
mb_mark_used_double(e4b, start, len);
|
|
|
|
|
|
|
|
e4b->bd_info->bb_free -= len;
|
|
|
|
if (e4b->bd_info->bb_first_free == start)
|
|
|
|
e4b->bd_info->bb_first_free += len;
|
|
|
|
|
|
|
|
/* let's maintain fragments counter */
|
|
|
|
if (start != 0)
|
2012-02-20 23:54:06 +01:00
|
|
|
mlen = !mb_test_bit(start - 1, e4b->bd_bitmap);
|
2008-01-29 06:19:52 +01:00
|
|
|
if (start + len < EXT4_SB(e4b->bd_sb)->s_mb_maxs[0])
|
2012-02-20 23:54:06 +01:00
|
|
|
max = !mb_test_bit(start + len, e4b->bd_bitmap);
|
2008-01-29 06:19:52 +01:00
|
|
|
if (mlen && max)
|
|
|
|
e4b->bd_info->bb_fragments++;
|
|
|
|
else if (!mlen && !max)
|
|
|
|
e4b->bd_info->bb_fragments--;
|
|
|
|
|
|
|
|
/* let's maintain buddy itself */
|
|
|
|
while (len) {
|
|
|
|
ord = mb_find_order_for_block(e4b, start);
|
|
|
|
|
|
|
|
if (((start >> ord) << ord) == start && len >= (1 << ord)) {
|
|
|
|
/* the whole chunk may be allocated at once! */
|
|
|
|
mlen = 1 << ord;
|
|
|
|
buddy = mb_find_buddy(e4b, ord, &max);
|
|
|
|
BUG_ON((start >> ord) >= max);
|
|
|
|
mb_set_bit(start >> ord, buddy);
|
|
|
|
e4b->bd_info->bb_counters[ord]--;
|
|
|
|
start += mlen;
|
|
|
|
len -= mlen;
|
|
|
|
BUG_ON(len < 0);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* store for history */
|
|
|
|
if (ret == 0)
|
|
|
|
ret = len | (ord << 16);
|
|
|
|
|
|
|
|
/* we have to split large buddy */
|
|
|
|
BUG_ON(ord <= 0);
|
|
|
|
buddy = mb_find_buddy(e4b, ord, &max);
|
|
|
|
mb_set_bit(start >> ord, buddy);
|
|
|
|
e4b->bd_info->bb_counters[ord]--;
|
|
|
|
|
|
|
|
ord--;
|
|
|
|
cur = (start >> ord) & ~1U;
|
|
|
|
buddy = mb_find_buddy(e4b, ord, &max);
|
|
|
|
mb_clear_bit(cur, buddy);
|
|
|
|
mb_clear_bit(cur + 1, buddy);
|
|
|
|
e4b->bd_info->bb_counters[ord]++;
|
|
|
|
e4b->bd_info->bb_counters[ord]++;
|
|
|
|
}
|
2010-05-16 21:00:00 +02:00
|
|
|
mb_set_largest_free_order(e4b->bd_sb, e4b->bd_info);
|
2008-01-29 06:19:52 +01:00
|
|
|
|
2012-02-20 23:54:06 +01:00
|
|
|
ext4_set_bits(e4b->bd_bitmap, ex->fe_start, len0);
|
2008-01-29 06:19:52 +01:00
|
|
|
mb_check_buddy(e4b);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Must be called under group lock!
|
|
|
|
*/
|
|
|
|
static void ext4_mb_use_best_found(struct ext4_allocation_context *ac,
|
|
|
|
struct ext4_buddy *e4b)
|
|
|
|
{
|
|
|
|
struct ext4_sb_info *sbi = EXT4_SB(ac->ac_sb);
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
BUG_ON(ac->ac_b_ex.fe_group != e4b->bd_group);
|
|
|
|
BUG_ON(ac->ac_status == AC_STATUS_FOUND);
|
|
|
|
|
|
|
|
ac->ac_b_ex.fe_len = min(ac->ac_b_ex.fe_len, ac->ac_g_ex.fe_len);
|
|
|
|
ac->ac_b_ex.fe_logical = ac->ac_g_ex.fe_logical;
|
|
|
|
ret = mb_mark_used(e4b, &ac->ac_b_ex);
|
|
|
|
|
|
|
|
/* preallocation can change ac_b_ex, thus we store actually
|
|
|
|
* allocated blocks for history */
|
|
|
|
ac->ac_f_ex = ac->ac_b_ex;
|
|
|
|
|
|
|
|
ac->ac_status = AC_STATUS_FOUND;
|
|
|
|
ac->ac_tail = ret & 0xffff;
|
|
|
|
ac->ac_buddy = ret >> 16;
|
|
|
|
|
2008-11-25 21:11:52 +01:00
|
|
|
/*
|
|
|
|
* take the page reference. We want the page to be pinned
|
|
|
|
* so that we don't get a ext4_mb_init_cache_call for this
|
|
|
|
* group until we update the bitmap. That would mean we
|
|
|
|
* double allocate blocks. The reference is dropped
|
|
|
|
* in ext4_mb_release_context
|
|
|
|
*/
|
2008-01-29 06:19:52 +01:00
|
|
|
ac->ac_bitmap_page = e4b->bd_bitmap_page;
|
|
|
|
get_page(ac->ac_bitmap_page);
|
|
|
|
ac->ac_buddy_page = e4b->bd_buddy_page;
|
|
|
|
get_page(ac->ac_buddy_page);
|
|
|
|
/* store last allocated for subsequent stream allocation */
|
2009-08-10 04:01:13 +02:00
|
|
|
if (ac->ac_flags & EXT4_MB_STREAM_ALLOC) {
|
2008-01-29 06:19:52 +01:00
|
|
|
spin_lock(&sbi->s_md_lock);
|
|
|
|
sbi->s_mb_last_group = ac->ac_f_ex.fe_group;
|
|
|
|
sbi->s_mb_last_start = ac->ac_f_ex.fe_start;
|
|
|
|
spin_unlock(&sbi->s_md_lock);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* regular allocator, for general purposes allocation
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void ext4_mb_check_limits(struct ext4_allocation_context *ac,
|
|
|
|
struct ext4_buddy *e4b,
|
|
|
|
int finish_group)
|
|
|
|
{
|
|
|
|
struct ext4_sb_info *sbi = EXT4_SB(ac->ac_sb);
|
|
|
|
struct ext4_free_extent *bex = &ac->ac_b_ex;
|
|
|
|
struct ext4_free_extent *gex = &ac->ac_g_ex;
|
|
|
|
struct ext4_free_extent ex;
|
|
|
|
int max;
|
|
|
|
|
2009-01-06 03:34:30 +01:00
|
|
|
if (ac->ac_status == AC_STATUS_FOUND)
|
|
|
|
return;
|
2008-01-29 06:19:52 +01:00
|
|
|
/*
|
|
|
|
* We don't want to scan for a whole year
|
|
|
|
*/
|
|
|
|
if (ac->ac_found > sbi->s_mb_max_to_scan &&
|
|
|
|
!(ac->ac_flags & EXT4_MB_HINT_FIRST)) {
|
|
|
|
ac->ac_status = AC_STATUS_BREAK;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Haven't found good chunk so far, let's continue
|
|
|
|
*/
|
|
|
|
if (bex->fe_len < gex->fe_len)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if ((finish_group || ac->ac_found > sbi->s_mb_min_to_scan)
|
|
|
|
&& bex->fe_group == e4b->bd_group) {
|
|
|
|
/* recheck chunk's availability - we don't know
|
|
|
|
* when it was found (within this lock-unlock
|
|
|
|
* period or not) */
|
2012-08-17 16:02:17 +02:00
|
|
|
max = mb_find_extent(e4b, bex->fe_start, gex->fe_len, &ex);
|
2008-01-29 06:19:52 +01:00
|
|
|
if (max >= gex->fe_len) {
|
|
|
|
ext4_mb_use_best_found(ac, e4b);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The routine checks whether found extent is good enough. If it is,
|
|
|
|
* then the extent gets marked used and flag is set to the context
|
|
|
|
* to stop scanning. Otherwise, the extent is compared with the
|
|
|
|
* previous found extent and if new one is better, then it's stored
|
|
|
|
* in the context. Later, the best found extent will be used, if
|
|
|
|
* mballoc can't find good enough extent.
|
|
|
|
*
|
|
|
|
* FIXME: real allocation policy is to be designed yet!
|
|
|
|
*/
|
|
|
|
static void ext4_mb_measure_extent(struct ext4_allocation_context *ac,
|
|
|
|
struct ext4_free_extent *ex,
|
|
|
|
struct ext4_buddy *e4b)
|
|
|
|
{
|
|
|
|
struct ext4_free_extent *bex = &ac->ac_b_ex;
|
|
|
|
struct ext4_free_extent *gex = &ac->ac_g_ex;
|
|
|
|
|
|
|
|
BUG_ON(ex->fe_len <= 0);
|
2011-09-10 00:38:51 +02:00
|
|
|
BUG_ON(ex->fe_len > EXT4_CLUSTERS_PER_GROUP(ac->ac_sb));
|
|
|
|
BUG_ON(ex->fe_start >= EXT4_CLUSTERS_PER_GROUP(ac->ac_sb));
|
2008-01-29 06:19:52 +01:00
|
|
|
BUG_ON(ac->ac_status != AC_STATUS_CONTINUE);
|
|
|
|
|
|
|
|
ac->ac_found++;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The special case - take what you catch first
|
|
|
|
*/
|
|
|
|
if (unlikely(ac->ac_flags & EXT4_MB_HINT_FIRST)) {
|
|
|
|
*bex = *ex;
|
|
|
|
ext4_mb_use_best_found(ac, e4b);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Let's check whether the chuck is good enough
|
|
|
|
*/
|
|
|
|
if (ex->fe_len == gex->fe_len) {
|
|
|
|
*bex = *ex;
|
|
|
|
ext4_mb_use_best_found(ac, e4b);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If this is first found extent, just store it in the context
|
|
|
|
*/
|
|
|
|
if (bex->fe_len == 0) {
|
|
|
|
*bex = *ex;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If new found extent is better, store it in the context
|
|
|
|
*/
|
|
|
|
if (bex->fe_len < gex->fe_len) {
|
|
|
|
/* if the request isn't satisfied, any found extent
|
|
|
|
* larger than previous best one is better */
|
|
|
|
if (ex->fe_len > bex->fe_len)
|
|
|
|
*bex = *ex;
|
|
|
|
} else if (ex->fe_len > gex->fe_len) {
|
|
|
|
/* if the request is satisfied, then we try to find
|
|
|
|
* an extent that still satisfy the request, but is
|
|
|
|
* smaller than previous one */
|
|
|
|
if (ex->fe_len < bex->fe_len)
|
|
|
|
*bex = *ex;
|
|
|
|
}
|
|
|
|
|
|
|
|
ext4_mb_check_limits(ac, e4b, 0);
|
|
|
|
}
|
|
|
|
|
2009-07-06 04:17:31 +02:00
|
|
|
static noinline_for_stack
|
|
|
|
int ext4_mb_try_best_found(struct ext4_allocation_context *ac,
|
2008-01-29 06:19:52 +01:00
|
|
|
struct ext4_buddy *e4b)
|
|
|
|
{
|
|
|
|
struct ext4_free_extent ex = ac->ac_b_ex;
|
|
|
|
ext4_group_t group = ex.fe_group;
|
|
|
|
int max;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
BUG_ON(ex.fe_len <= 0);
|
|
|
|
err = ext4_mb_load_buddy(ac->ac_sb, group, e4b);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
ext4_lock_group(ac->ac_sb, group);
|
2012-08-17 16:02:17 +02:00
|
|
|
max = mb_find_extent(e4b, ex.fe_start, ex.fe_len, &ex);
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
if (max > 0) {
|
|
|
|
ac->ac_b_ex = ex;
|
|
|
|
ext4_mb_use_best_found(ac, e4b);
|
|
|
|
}
|
|
|
|
|
|
|
|
ext4_unlock_group(ac->ac_sb, group);
|
2010-05-14 06:00:00 +02:00
|
|
|
ext4_mb_unload_buddy(e4b);
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-07-06 04:17:31 +02:00
|
|
|
static noinline_for_stack
|
|
|
|
int ext4_mb_find_by_goal(struct ext4_allocation_context *ac,
|
2008-01-29 06:19:52 +01:00
|
|
|
struct ext4_buddy *e4b)
|
|
|
|
{
|
|
|
|
ext4_group_t group = ac->ac_g_ex.fe_group;
|
|
|
|
int max;
|
|
|
|
int err;
|
|
|
|
struct ext4_sb_info *sbi = EXT4_SB(ac->ac_sb);
|
2012-09-24 05:10:51 +02:00
|
|
|
struct ext4_group_info *grp = ext4_get_group_info(ac->ac_sb, group);
|
2008-01-29 06:19:52 +01:00
|
|
|
struct ext4_free_extent ex;
|
|
|
|
|
|
|
|
if (!(ac->ac_flags & EXT4_MB_HINT_TRY_GOAL))
|
|
|
|
return 0;
|
2012-09-24 05:10:51 +02:00
|
|
|
if (grp->bb_free == 0)
|
|
|
|
return 0;
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
err = ext4_mb_load_buddy(ac->ac_sb, group, e4b);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
ext4: mark block group as corrupt on block bitmap error
When we notice a block-bitmap corruption (because of device failure or
something else), we should mark this group as corrupt and prevent
further block allocations/deallocations from it. Currently, we end up
generating one error message for every block in the bitmap. This
potentially could make the system unstable as noticed in some
bugs. With this patch, the error will be printed only the first time
and mark the entire block group as corrupted. This prevents future
access allocations/deallocations from it.
Also tested by corrupting the block
bitmap and forcefully introducing the mb_free_blocks error:
(1) create a largefile (2Gb)
$ dd if=/dev/zero of=largefile oflag=direct bs=10485760 count=200
(2) umount filesystem. use dumpe2fs to see which block-bitmaps
are in use by largefile and note their block numbers
(3) use dd to zero-out the used block bitmaps
$ dd if=/dev/zero of=/dev/hdc4 bs=4096 seek=14 count=8 oflag=direct
(4) mount the FS and delete the largefile.
(5) recreate the largefile. verify that the new largefile does not
get any blocks from the groups marked as bad.
Without the patch, we will see mb_free_blocks error for each bit in
each zero'ed out bitmap at (4). With the patch, we only see the error
once per blockgroup:
[ 309.706803] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 15: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
[ 309.720824] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 14: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
[ 309.732858] EXT4-fs error (device sdb4) in ext4_free_blocks:4802: IO failure
[ 309.748321] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 13: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
[ 309.760331] EXT4-fs error (device sdb4) in ext4_free_blocks:4802: IO failure
[ 309.769695] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 12: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
[ 309.781721] EXT4-fs error (device sdb4) in ext4_free_blocks:4802: IO failure
[ 309.798166] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 11: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
[ 309.810184] EXT4-fs error (device sdb4) in ext4_free_blocks:4802: IO failure
[ 309.819532] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 10: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
Google-Bug-Id: 7258357
[darrick.wong@oracle.com]
Further modifications (by Darrick) to make more obvious that this corruption
bit applies to blocks only. Set the corruption flag if the block group bitmap
verification fails.
Original-author: Aditya Kali <adityakali@google.com>
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2013-08-28 23:35:51 +02:00
|
|
|
if (unlikely(EXT4_MB_GRP_BBITMAP_CORRUPT(e4b->bd_info))) {
|
|
|
|
ext4_mb_unload_buddy(e4b);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-01-29 06:19:52 +01:00
|
|
|
ext4_lock_group(ac->ac_sb, group);
|
2012-08-17 16:02:17 +02:00
|
|
|
max = mb_find_extent(e4b, ac->ac_g_ex.fe_start,
|
2008-01-29 06:19:52 +01:00
|
|
|
ac->ac_g_ex.fe_len, &ex);
|
|
|
|
|
|
|
|
if (max >= ac->ac_g_ex.fe_len && ac->ac_g_ex.fe_len == sbi->s_stripe) {
|
|
|
|
ext4_fsblk_t start;
|
|
|
|
|
2010-03-04 05:53:39 +01:00
|
|
|
start = ext4_group_first_block_no(ac->ac_sb, e4b->bd_group) +
|
|
|
|
ex.fe_start;
|
2008-01-29 06:19:52 +01:00
|
|
|
/* use do_div to get remainder (would be 64-bit modulo) */
|
|
|
|
if (do_div(start, sbi->s_stripe) == 0) {
|
|
|
|
ac->ac_found++;
|
|
|
|
ac->ac_b_ex = ex;
|
|
|
|
ext4_mb_use_best_found(ac, e4b);
|
|
|
|
}
|
|
|
|
} else if (max >= ac->ac_g_ex.fe_len) {
|
|
|
|
BUG_ON(ex.fe_len <= 0);
|
|
|
|
BUG_ON(ex.fe_group != ac->ac_g_ex.fe_group);
|
|
|
|
BUG_ON(ex.fe_start != ac->ac_g_ex.fe_start);
|
|
|
|
ac->ac_found++;
|
|
|
|
ac->ac_b_ex = ex;
|
|
|
|
ext4_mb_use_best_found(ac, e4b);
|
|
|
|
} else if (max > 0 && (ac->ac_flags & EXT4_MB_HINT_MERGE)) {
|
|
|
|
/* Sometimes, caller may want to merge even small
|
|
|
|
* number of blocks to an existing extent */
|
|
|
|
BUG_ON(ex.fe_len <= 0);
|
|
|
|
BUG_ON(ex.fe_group != ac->ac_g_ex.fe_group);
|
|
|
|
BUG_ON(ex.fe_start != ac->ac_g_ex.fe_start);
|
|
|
|
ac->ac_found++;
|
|
|
|
ac->ac_b_ex = ex;
|
|
|
|
ext4_mb_use_best_found(ac, e4b);
|
|
|
|
}
|
|
|
|
ext4_unlock_group(ac->ac_sb, group);
|
2010-05-14 06:00:00 +02:00
|
|
|
ext4_mb_unload_buddy(e4b);
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The routine scans buddy structures (not bitmap!) from given order
|
|
|
|
* to max order and tries to find big enough chunk to satisfy the req
|
|
|
|
*/
|
2009-07-06 04:17:31 +02:00
|
|
|
static noinline_for_stack
|
|
|
|
void ext4_mb_simple_scan_group(struct ext4_allocation_context *ac,
|
2008-01-29 06:19:52 +01:00
|
|
|
struct ext4_buddy *e4b)
|
|
|
|
{
|
|
|
|
struct super_block *sb = ac->ac_sb;
|
|
|
|
struct ext4_group_info *grp = e4b->bd_info;
|
|
|
|
void *buddy;
|
|
|
|
int i;
|
|
|
|
int k;
|
|
|
|
int max;
|
|
|
|
|
|
|
|
BUG_ON(ac->ac_2order <= 0);
|
|
|
|
for (i = ac->ac_2order; i <= sb->s_blocksize_bits + 1; i++) {
|
|
|
|
if (grp->bb_counters[i] == 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
buddy = mb_find_buddy(e4b, i, &max);
|
|
|
|
BUG_ON(buddy == NULL);
|
|
|
|
|
2008-02-23 07:38:34 +01:00
|
|
|
k = mb_find_next_zero_bit(buddy, max, 0);
|
2008-01-29 06:19:52 +01:00
|
|
|
BUG_ON(k >= max);
|
|
|
|
|
|
|
|
ac->ac_found++;
|
|
|
|
|
|
|
|
ac->ac_b_ex.fe_len = 1 << i;
|
|
|
|
ac->ac_b_ex.fe_start = k << i;
|
|
|
|
ac->ac_b_ex.fe_group = e4b->bd_group;
|
|
|
|
|
|
|
|
ext4_mb_use_best_found(ac, e4b);
|
|
|
|
|
|
|
|
BUG_ON(ac->ac_b_ex.fe_len != ac->ac_g_ex.fe_len);
|
|
|
|
|
|
|
|
if (EXT4_SB(sb)->s_mb_stats)
|
|
|
|
atomic_inc(&EXT4_SB(sb)->s_bal_2orders);
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The routine scans the group and measures all found extents.
|
|
|
|
* In order to optimize scanning, caller must pass number of
|
|
|
|
* free blocks in the group, so the routine can know upper limit.
|
|
|
|
*/
|
2009-07-06 04:17:31 +02:00
|
|
|
static noinline_for_stack
|
|
|
|
void ext4_mb_complex_scan_group(struct ext4_allocation_context *ac,
|
2008-01-29 06:19:52 +01:00
|
|
|
struct ext4_buddy *e4b)
|
|
|
|
{
|
|
|
|
struct super_block *sb = ac->ac_sb;
|
2012-02-20 23:54:06 +01:00
|
|
|
void *bitmap = e4b->bd_bitmap;
|
2008-01-29 06:19:52 +01:00
|
|
|
struct ext4_free_extent ex;
|
|
|
|
int i;
|
|
|
|
int free;
|
|
|
|
|
|
|
|
free = e4b->bd_info->bb_free;
|
|
|
|
BUG_ON(free <= 0);
|
|
|
|
|
|
|
|
i = e4b->bd_info->bb_first_free;
|
|
|
|
|
|
|
|
while (free && ac->ac_status == AC_STATUS_CONTINUE) {
|
2008-02-23 07:38:34 +01:00
|
|
|
i = mb_find_next_zero_bit(bitmap,
|
2011-09-10 00:38:51 +02:00
|
|
|
EXT4_CLUSTERS_PER_GROUP(sb), i);
|
|
|
|
if (i >= EXT4_CLUSTERS_PER_GROUP(sb)) {
|
2008-02-10 07:10:04 +01:00
|
|
|
/*
|
2008-02-15 19:48:21 +01:00
|
|
|
* IF we have corrupt bitmap, we won't find any
|
2008-02-10 07:10:04 +01:00
|
|
|
* free blocks even though group info says we
|
|
|
|
* we have free blocks
|
|
|
|
*/
|
2010-06-29 18:54:28 +02:00
|
|
|
ext4_grp_locked_error(sb, e4b->bd_group, 0, 0,
|
2011-09-10 00:48:51 +02:00
|
|
|
"%d free clusters as per "
|
2009-01-06 04:17:35 +01:00
|
|
|
"group info. But bitmap says 0",
|
2008-02-10 07:10:04 +01:00
|
|
|
free);
|
2008-01-29 06:19:52 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2012-08-17 16:02:17 +02:00
|
|
|
mb_find_extent(e4b, i, ac->ac_g_ex.fe_len, &ex);
|
2008-01-29 06:19:52 +01:00
|
|
|
BUG_ON(ex.fe_len <= 0);
|
2008-02-10 07:10:04 +01:00
|
|
|
if (free < ex.fe_len) {
|
2010-06-29 18:54:28 +02:00
|
|
|
ext4_grp_locked_error(sb, e4b->bd_group, 0, 0,
|
2011-09-10 00:48:51 +02:00
|
|
|
"%d free clusters as per "
|
2009-01-06 04:17:35 +01:00
|
|
|
"group info. But got %d blocks",
|
2008-02-10 07:10:04 +01:00
|
|
|
free, ex.fe_len);
|
2008-02-15 19:48:21 +01:00
|
|
|
/*
|
|
|
|
* The number of free blocks differs. This mostly
|
|
|
|
* indicate that the bitmap is corrupt. So exit
|
|
|
|
* without claiming the space.
|
|
|
|
*/
|
|
|
|
break;
|
2008-02-10 07:10:04 +01:00
|
|
|
}
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
ext4_mb_measure_extent(ac, &ex, e4b);
|
|
|
|
|
|
|
|
i += ex.fe_len;
|
|
|
|
free -= ex.fe_len;
|
|
|
|
}
|
|
|
|
|
|
|
|
ext4_mb_check_limits(ac, e4b, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is a special case for storages like raid5
|
2010-07-27 17:56:06 +02:00
|
|
|
* we try to find stripe-aligned chunks for stripe-size-multiple requests
|
2008-01-29 06:19:52 +01:00
|
|
|
*/
|
2009-07-06 04:17:31 +02:00
|
|
|
static noinline_for_stack
|
|
|
|
void ext4_mb_scan_aligned(struct ext4_allocation_context *ac,
|
2008-01-29 06:19:52 +01:00
|
|
|
struct ext4_buddy *e4b)
|
|
|
|
{
|
|
|
|
struct super_block *sb = ac->ac_sb;
|
|
|
|
struct ext4_sb_info *sbi = EXT4_SB(sb);
|
2012-02-20 23:54:06 +01:00
|
|
|
void *bitmap = e4b->bd_bitmap;
|
2008-01-29 06:19:52 +01:00
|
|
|
struct ext4_free_extent ex;
|
|
|
|
ext4_fsblk_t first_group_block;
|
|
|
|
ext4_fsblk_t a;
|
|
|
|
ext4_grpblk_t i;
|
|
|
|
int max;
|
|
|
|
|
|
|
|
BUG_ON(sbi->s_stripe == 0);
|
|
|
|
|
|
|
|
/* find first stripe-aligned block in group */
|
2010-03-04 05:53:39 +01:00
|
|
|
first_group_block = ext4_group_first_block_no(sb, e4b->bd_group);
|
|
|
|
|
2008-01-29 06:19:52 +01:00
|
|
|
a = first_group_block + sbi->s_stripe - 1;
|
|
|
|
do_div(a, sbi->s_stripe);
|
|
|
|
i = (a * sbi->s_stripe) - first_group_block;
|
|
|
|
|
2011-09-10 00:38:51 +02:00
|
|
|
while (i < EXT4_CLUSTERS_PER_GROUP(sb)) {
|
2008-01-29 06:19:52 +01:00
|
|
|
if (!mb_test_bit(i, bitmap)) {
|
2012-08-17 16:02:17 +02:00
|
|
|
max = mb_find_extent(e4b, i, sbi->s_stripe, &ex);
|
2008-01-29 06:19:52 +01:00
|
|
|
if (max >= sbi->s_stripe) {
|
|
|
|
ac->ac_found++;
|
|
|
|
ac->ac_b_ex = ex;
|
|
|
|
ext4_mb_use_best_found(ac, e4b);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
i += sbi->s_stripe;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-05-16 21:00:00 +02:00
|
|
|
/* This is now called BEFORE we load the buddy bitmap. */
|
2008-01-29 06:19:52 +01:00
|
|
|
static int ext4_mb_good_group(struct ext4_allocation_context *ac,
|
|
|
|
ext4_group_t group, int cr)
|
|
|
|
{
|
|
|
|
unsigned free, fragments;
|
2009-03-12 17:18:34 +01:00
|
|
|
int flex_size = ext4_flex_bg_size(EXT4_SB(ac->ac_sb));
|
2008-01-29 06:19:52 +01:00
|
|
|
struct ext4_group_info *grp = ext4_get_group_info(ac->ac_sb, group);
|
|
|
|
|
|
|
|
BUG_ON(cr < 0 || cr >= 4);
|
2010-05-16 21:00:00 +02:00
|
|
|
|
2012-08-17 15:46:17 +02:00
|
|
|
free = grp->bb_free;
|
|
|
|
if (free == 0)
|
|
|
|
return 0;
|
|
|
|
if (cr <= 2 && free < ac->ac_g_ex.fe_len)
|
|
|
|
return 0;
|
|
|
|
|
ext4: mark block group as corrupt on block bitmap error
When we notice a block-bitmap corruption (because of device failure or
something else), we should mark this group as corrupt and prevent
further block allocations/deallocations from it. Currently, we end up
generating one error message for every block in the bitmap. This
potentially could make the system unstable as noticed in some
bugs. With this patch, the error will be printed only the first time
and mark the entire block group as corrupted. This prevents future
access allocations/deallocations from it.
Also tested by corrupting the block
bitmap and forcefully introducing the mb_free_blocks error:
(1) create a largefile (2Gb)
$ dd if=/dev/zero of=largefile oflag=direct bs=10485760 count=200
(2) umount filesystem. use dumpe2fs to see which block-bitmaps
are in use by largefile and note their block numbers
(3) use dd to zero-out the used block bitmaps
$ dd if=/dev/zero of=/dev/hdc4 bs=4096 seek=14 count=8 oflag=direct
(4) mount the FS and delete the largefile.
(5) recreate the largefile. verify that the new largefile does not
get any blocks from the groups marked as bad.
Without the patch, we will see mb_free_blocks error for each bit in
each zero'ed out bitmap at (4). With the patch, we only see the error
once per blockgroup:
[ 309.706803] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 15: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
[ 309.720824] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 14: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
[ 309.732858] EXT4-fs error (device sdb4) in ext4_free_blocks:4802: IO failure
[ 309.748321] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 13: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
[ 309.760331] EXT4-fs error (device sdb4) in ext4_free_blocks:4802: IO failure
[ 309.769695] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 12: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
[ 309.781721] EXT4-fs error (device sdb4) in ext4_free_blocks:4802: IO failure
[ 309.798166] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 11: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
[ 309.810184] EXT4-fs error (device sdb4) in ext4_free_blocks:4802: IO failure
[ 309.819532] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 10: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
Google-Bug-Id: 7258357
[darrick.wong@oracle.com]
Further modifications (by Darrick) to make more obvious that this corruption
bit applies to blocks only. Set the corruption flag if the block group bitmap
verification fails.
Original-author: Aditya Kali <adityakali@google.com>
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2013-08-28 23:35:51 +02:00
|
|
|
if (unlikely(EXT4_MB_GRP_BBITMAP_CORRUPT(grp)))
|
|
|
|
return 0;
|
|
|
|
|
2010-05-16 21:00:00 +02:00
|
|
|
/* We only do this if the grp has never been initialized */
|
|
|
|
if (unlikely(EXT4_MB_GRP_NEED_INIT(grp))) {
|
|
|
|
int ret = ext4_mb_init_group(ac->ac_sb, group);
|
|
|
|
if (ret)
|
|
|
|
return 0;
|
|
|
|
}
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
fragments = grp->bb_fragments;
|
|
|
|
if (fragments == 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
switch (cr) {
|
|
|
|
case 0:
|
|
|
|
BUG_ON(ac->ac_2order == 0);
|
|
|
|
|
2009-03-12 17:18:34 +01:00
|
|
|
/* Avoid using the first bg of a flexgroup for data files */
|
|
|
|
if ((ac->ac_flags & EXT4_MB_HINT_DATA) &&
|
|
|
|
(flex_size >= EXT4_FLEX_SIZE_DIR_ALLOC_SCHEME) &&
|
|
|
|
((group % flex_size) == 0))
|
|
|
|
return 0;
|
|
|
|
|
ext4: optimize mballoc for large allocations
The ext4 block allocator only maintains buddy bitmaps for chunks which
are less than or equal to one quarter of a block group. That is, for
a file aystem with a 1k blocksize, and where the number of blocks in a
block group is 8192 blocks, the largest chunk size tracked by buddy
bitmaps is 2048 blocks.
For a file system with a 4k blocksize, and where the number of blocks
in a block group is 32768 blocks, the largest chunk size tracked by
buddy bitmaps is 8192 blocks.
To work around this code, mballoc.c before this commit would truncate
allocation requests to the number of blocks in a block group minus 10.
Why 10? Aside from being a completely arbitrary number, it avoids
block allocation to be a power of two larger than 25% of the block
group. If you try to explicitly fallocate 50% of the block group
size, this will demonstrate the problem; the block allocation code
will scan the all of the blocks in the file system with cr==0 (since
the request is for a natural power of two), but then completely fail
for all blocks groups, since the buddy bitmaps don't track chunk sizes
of 50% of the block group.
To fix this, in these we use ext4_mb_complex_scan_group() instead of
ext4_mb_simple_scan_group().
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
Cc: Andreas Dilger <adilger@dilger.ca>
2013-02-04 21:08:40 +01:00
|
|
|
if ((ac->ac_2order > ac->ac_sb->s_blocksize_bits+1) ||
|
|
|
|
(free / fragments) >= ac->ac_g_ex.fe_len)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
if (grp->bb_largest_free_order < ac->ac_2order)
|
|
|
|
return 0;
|
|
|
|
|
2010-05-16 21:00:00 +02:00
|
|
|
return 1;
|
2008-01-29 06:19:52 +01:00
|
|
|
case 1:
|
|
|
|
if ((free / fragments) >= ac->ac_g_ex.fe_len)
|
|
|
|
return 1;
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
if (free >= ac->ac_g_ex.fe_len)
|
|
|
|
return 1;
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
return 1;
|
|
|
|
default:
|
|
|
|
BUG();
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-04-29 14:11:12 +02:00
|
|
|
static noinline_for_stack int
|
|
|
|
ext4_mb_regular_allocator(struct ext4_allocation_context *ac)
|
2008-01-29 06:19:52 +01:00
|
|
|
{
|
2009-05-01 14:50:38 +02:00
|
|
|
ext4_group_t ngroups, group, i;
|
2008-01-29 06:19:52 +01:00
|
|
|
int cr;
|
|
|
|
int err = 0;
|
|
|
|
struct ext4_sb_info *sbi;
|
|
|
|
struct super_block *sb;
|
|
|
|
struct ext4_buddy e4b;
|
|
|
|
|
|
|
|
sb = ac->ac_sb;
|
|
|
|
sbi = EXT4_SB(sb);
|
2009-05-01 14:50:38 +02:00
|
|
|
ngroups = ext4_get_groups_count(sb);
|
ext4: limit block allocations for indirect-block files to < 2^32
Today, the ext4 allocator will happily allocate blocks past
2^32 for indirect-block files, which results in the block
numbers getting truncated, and corruption ensues.
This patch limits such allocations to < 2^32, and adds
BUG_ONs if we do get blocks larger than that.
This should address RH Bug 519471, ext4 bitmap allocator
must limit blocks to < 2^32
* ext4_find_goal() is modified to choose a goal < UINT_MAX,
so that our starting point is in an acceptable range.
* ext4_xattr_block_set() is modified such that the goal block
is < UINT_MAX, as above.
* ext4_mb_regular_allocator() is modified so that the group
search does not continue into groups which are too high
* ext4_mb_use_preallocated() has a check that we don't use
preallocated space which is too far out
* ext4_alloc_blocks() and ext4_xattr_block_set() add some BUG_ONs
No attempt has been made to limit inode locations to < 2^32,
so we may wind up with blocks far from their inodes. Doing
this much already will lead to some odd ENOSPC issues when the
"lower 32" gets full, and further restricting inodes could
make that even weirder.
For high inodes, choosing a goal of the original, % UINT_MAX,
may be a bit odd, but then we're in an odd situation anyway,
and I don't know of a better heuristic.
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2009-09-16 20:45:10 +02:00
|
|
|
/* non-extent files are limited to low blocks/groups */
|
2010-05-17 04:00:00 +02:00
|
|
|
if (!(ext4_test_inode_flag(ac->ac_inode, EXT4_INODE_EXTENTS)))
|
ext4: limit block allocations for indirect-block files to < 2^32
Today, the ext4 allocator will happily allocate blocks past
2^32 for indirect-block files, which results in the block
numbers getting truncated, and corruption ensues.
This patch limits such allocations to < 2^32, and adds
BUG_ONs if we do get blocks larger than that.
This should address RH Bug 519471, ext4 bitmap allocator
must limit blocks to < 2^32
* ext4_find_goal() is modified to choose a goal < UINT_MAX,
so that our starting point is in an acceptable range.
* ext4_xattr_block_set() is modified such that the goal block
is < UINT_MAX, as above.
* ext4_mb_regular_allocator() is modified so that the group
search does not continue into groups which are too high
* ext4_mb_use_preallocated() has a check that we don't use
preallocated space which is too far out
* ext4_alloc_blocks() and ext4_xattr_block_set() add some BUG_ONs
No attempt has been made to limit inode locations to < 2^32,
so we may wind up with blocks far from their inodes. Doing
this much already will lead to some odd ENOSPC issues when the
"lower 32" gets full, and further restricting inodes could
make that even weirder.
For high inodes, choosing a goal of the original, % UINT_MAX,
may be a bit odd, but then we're in an odd situation anyway,
and I don't know of a better heuristic.
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2009-09-16 20:45:10 +02:00
|
|
|
ngroups = sbi->s_blockfile_groups;
|
|
|
|
|
2008-01-29 06:19:52 +01:00
|
|
|
BUG_ON(ac->ac_status == AC_STATUS_FOUND);
|
|
|
|
|
|
|
|
/* first, try the goal */
|
|
|
|
err = ext4_mb_find_by_goal(ac, &e4b);
|
|
|
|
if (err || ac->ac_status == AC_STATUS_FOUND)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (unlikely(ac->ac_flags & EXT4_MB_HINT_GOAL_ONLY))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ac->ac2_order is set only if the fe_len is a power of 2
|
|
|
|
* if ac2_order is set we also set criteria to 0 so that we
|
|
|
|
* try exact allocation using buddy.
|
|
|
|
*/
|
|
|
|
i = fls(ac->ac_g_ex.fe_len);
|
|
|
|
ac->ac_2order = 0;
|
|
|
|
/*
|
|
|
|
* We search using buddy data only if the order of the request
|
|
|
|
* is greater than equal to the sbi_s_mb_order2_reqs
|
2009-03-31 15:11:14 +02:00
|
|
|
* You can tune it via /sys/fs/ext4/<partition>/mb_order2_req
|
2008-01-29 06:19:52 +01:00
|
|
|
*/
|
|
|
|
if (i >= sbi->s_mb_order2_reqs) {
|
|
|
|
/*
|
|
|
|
* This should tell if fe_len is exactly power of 2
|
|
|
|
*/
|
|
|
|
if ((ac->ac_g_ex.fe_len & (~(1 << (i - 1)))) == 0)
|
|
|
|
ac->ac_2order = i - 1;
|
|
|
|
}
|
|
|
|
|
2009-08-10 04:01:13 +02:00
|
|
|
/* if stream allocation is enabled, use global goal */
|
|
|
|
if (ac->ac_flags & EXT4_MB_STREAM_ALLOC) {
|
2008-01-29 06:19:52 +01:00
|
|
|
/* TBD: may be hot point */
|
|
|
|
spin_lock(&sbi->s_md_lock);
|
|
|
|
ac->ac_g_ex.fe_group = sbi->s_mb_last_group;
|
|
|
|
ac->ac_g_ex.fe_start = sbi->s_mb_last_start;
|
|
|
|
spin_unlock(&sbi->s_md_lock);
|
|
|
|
}
|
2009-08-10 04:01:13 +02:00
|
|
|
|
2008-01-29 06:19:52 +01:00
|
|
|
/* Let's just scan groups to find more-less suitable blocks */
|
|
|
|
cr = ac->ac_2order ? 0 : 1;
|
|
|
|
/*
|
|
|
|
* cr == 0 try to get exact allocation,
|
|
|
|
* cr == 3 try to get anything
|
|
|
|
*/
|
|
|
|
repeat:
|
|
|
|
for (; cr < 4 && ac->ac_status == AC_STATUS_CONTINUE; cr++) {
|
|
|
|
ac->ac_criteria = cr;
|
2008-07-12 01:27:31 +02:00
|
|
|
/*
|
|
|
|
* searching for the right group start
|
|
|
|
* from the goal value specified
|
|
|
|
*/
|
|
|
|
group = ac->ac_g_ex.fe_group;
|
|
|
|
|
2009-05-01 14:50:38 +02:00
|
|
|
for (i = 0; i < ngroups; group++, i++) {
|
2013-06-12 17:43:02 +02:00
|
|
|
cond_resched();
|
2013-05-06 05:10:00 +02:00
|
|
|
/*
|
|
|
|
* Artificially restricted ngroups for non-extent
|
|
|
|
* files makes group > ngroups possible on first loop.
|
|
|
|
*/
|
|
|
|
if (group >= ngroups)
|
2008-01-29 06:19:52 +01:00
|
|
|
group = 0;
|
|
|
|
|
2010-05-16 21:00:00 +02:00
|
|
|
/* This now checks without needing the buddy page */
|
|
|
|
if (!ext4_mb_good_group(ac, group, cr))
|
2008-01-29 06:19:52 +01:00
|
|
|
continue;
|
|
|
|
|
|
|
|
err = ext4_mb_load_buddy(sb, group, &e4b);
|
|
|
|
if (err)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
ext4_lock_group(sb, group);
|
2010-05-16 21:00:00 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We need to check again after locking the
|
|
|
|
* block group
|
|
|
|
*/
|
2008-01-29 06:19:52 +01:00
|
|
|
if (!ext4_mb_good_group(ac, group, cr)) {
|
|
|
|
ext4_unlock_group(sb, group);
|
2010-05-14 06:00:00 +02:00
|
|
|
ext4_mb_unload_buddy(&e4b);
|
2008-01-29 06:19:52 +01:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
ac->ac_groups_scanned++;
|
ext4: optimize mballoc for large allocations
The ext4 block allocator only maintains buddy bitmaps for chunks which
are less than or equal to one quarter of a block group. That is, for
a file aystem with a 1k blocksize, and where the number of blocks in a
block group is 8192 blocks, the largest chunk size tracked by buddy
bitmaps is 2048 blocks.
For a file system with a 4k blocksize, and where the number of blocks
in a block group is 32768 blocks, the largest chunk size tracked by
buddy bitmaps is 8192 blocks.
To work around this code, mballoc.c before this commit would truncate
allocation requests to the number of blocks in a block group minus 10.
Why 10? Aside from being a completely arbitrary number, it avoids
block allocation to be a power of two larger than 25% of the block
group. If you try to explicitly fallocate 50% of the block group
size, this will demonstrate the problem; the block allocation code
will scan the all of the blocks in the file system with cr==0 (since
the request is for a natural power of two), but then completely fail
for all blocks groups, since the buddy bitmaps don't track chunk sizes
of 50% of the block group.
To fix this, in these we use ext4_mb_complex_scan_group() instead of
ext4_mb_simple_scan_group().
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
Cc: Andreas Dilger <adilger@dilger.ca>
2013-02-04 21:08:40 +01:00
|
|
|
if (cr == 0 && ac->ac_2order < sb->s_blocksize_bits+2)
|
2008-01-29 06:19:52 +01:00
|
|
|
ext4_mb_simple_scan_group(ac, &e4b);
|
2010-07-27 17:56:06 +02:00
|
|
|
else if (cr == 1 && sbi->s_stripe &&
|
|
|
|
!(ac->ac_g_ex.fe_len % sbi->s_stripe))
|
2008-01-29 06:19:52 +01:00
|
|
|
ext4_mb_scan_aligned(ac, &e4b);
|
|
|
|
else
|
|
|
|
ext4_mb_complex_scan_group(ac, &e4b);
|
|
|
|
|
|
|
|
ext4_unlock_group(sb, group);
|
2010-05-14 06:00:00 +02:00
|
|
|
ext4_mb_unload_buddy(&e4b);
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
if (ac->ac_status != AC_STATUS_CONTINUE)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ac->ac_b_ex.fe_len > 0 && ac->ac_status != AC_STATUS_FOUND &&
|
|
|
|
!(ac->ac_flags & EXT4_MB_HINT_FIRST)) {
|
|
|
|
/*
|
|
|
|
* We've been searching too long. Let's try to allocate
|
|
|
|
* the best chunk we've found so far
|
|
|
|
*/
|
|
|
|
|
|
|
|
ext4_mb_try_best_found(ac, &e4b);
|
|
|
|
if (ac->ac_status != AC_STATUS_FOUND) {
|
|
|
|
/*
|
|
|
|
* Someone more lucky has already allocated it.
|
|
|
|
* The only thing we can do is just take first
|
|
|
|
* found block(s)
|
|
|
|
printk(KERN_DEBUG "EXT4-fs: someone won our chunk\n");
|
|
|
|
*/
|
|
|
|
ac->ac_b_ex.fe_group = 0;
|
|
|
|
ac->ac_b_ex.fe_start = 0;
|
|
|
|
ac->ac_b_ex.fe_len = 0;
|
|
|
|
ac->ac_status = AC_STATUS_CONTINUE;
|
|
|
|
ac->ac_flags |= EXT4_MB_HINT_FIRST;
|
|
|
|
cr = 3;
|
|
|
|
atomic_inc(&sbi->s_mb_lost_chunks);
|
|
|
|
goto repeat;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *ext4_mb_seq_groups_start(struct seq_file *seq, loff_t *pos)
|
|
|
|
{
|
|
|
|
struct super_block *sb = seq->private;
|
|
|
|
ext4_group_t group;
|
|
|
|
|
2009-05-01 14:50:38 +02:00
|
|
|
if (*pos < 0 || *pos >= ext4_get_groups_count(sb))
|
2008-01-29 06:19:52 +01:00
|
|
|
return NULL;
|
|
|
|
group = *pos + 1;
|
2009-01-06 04:18:16 +01:00
|
|
|
return (void *) ((unsigned long) group);
|
2008-01-29 06:19:52 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void *ext4_mb_seq_groups_next(struct seq_file *seq, void *v, loff_t *pos)
|
|
|
|
{
|
|
|
|
struct super_block *sb = seq->private;
|
|
|
|
ext4_group_t group;
|
|
|
|
|
|
|
|
++*pos;
|
2009-05-01 14:50:38 +02:00
|
|
|
if (*pos < 0 || *pos >= ext4_get_groups_count(sb))
|
2008-01-29 06:19:52 +01:00
|
|
|
return NULL;
|
|
|
|
group = *pos + 1;
|
2009-01-06 04:18:16 +01:00
|
|
|
return (void *) ((unsigned long) group);
|
2008-01-29 06:19:52 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static int ext4_mb_seq_groups_show(struct seq_file *seq, void *v)
|
|
|
|
{
|
|
|
|
struct super_block *sb = seq->private;
|
2009-01-06 04:18:16 +01:00
|
|
|
ext4_group_t group = (ext4_group_t) ((unsigned long) v);
|
2008-01-29 06:19:52 +01:00
|
|
|
int i;
|
2012-07-01 01:10:57 +02:00
|
|
|
int err, buddy_loaded = 0;
|
2008-01-29 06:19:52 +01:00
|
|
|
struct ext4_buddy e4b;
|
2012-07-01 01:10:57 +02:00
|
|
|
struct ext4_group_info *grinfo;
|
2008-01-29 06:19:52 +01:00
|
|
|
struct sg {
|
|
|
|
struct ext4_group_info info;
|
2009-08-26 04:36:45 +02:00
|
|
|
ext4_grpblk_t counters[16];
|
2008-01-29 06:19:52 +01:00
|
|
|
} sg;
|
|
|
|
|
|
|
|
group--;
|
|
|
|
if (group == 0)
|
|
|
|
seq_printf(seq, "#%-5s: %-5s %-5s %-5s "
|
|
|
|
"[ %-5s %-5s %-5s %-5s %-5s %-5s %-5s "
|
|
|
|
"%-5s %-5s %-5s %-5s %-5s %-5s %-5s ]\n",
|
|
|
|
"group", "free", "frags", "first",
|
|
|
|
"2^0", "2^1", "2^2", "2^3", "2^4", "2^5", "2^6",
|
|
|
|
"2^7", "2^8", "2^9", "2^10", "2^11", "2^12", "2^13");
|
|
|
|
|
|
|
|
i = (sb->s_blocksize_bits + 2) * sizeof(sg.info.bb_counters[0]) +
|
|
|
|
sizeof(struct ext4_group_info);
|
2012-07-01 01:10:57 +02:00
|
|
|
grinfo = ext4_get_group_info(sb, group);
|
|
|
|
/* Load the group info in memory only if not already loaded. */
|
|
|
|
if (unlikely(EXT4_MB_GRP_NEED_INIT(grinfo))) {
|
|
|
|
err = ext4_mb_load_buddy(sb, group, &e4b);
|
|
|
|
if (err) {
|
|
|
|
seq_printf(seq, "#%-5u: I/O error\n", group);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
buddy_loaded = 1;
|
2008-01-29 06:19:52 +01:00
|
|
|
}
|
2012-07-01 01:10:57 +02:00
|
|
|
|
2008-01-29 06:19:52 +01:00
|
|
|
memcpy(&sg, ext4_get_group_info(sb, group), i);
|
2012-07-01 01:10:57 +02:00
|
|
|
|
|
|
|
if (buddy_loaded)
|
|
|
|
ext4_mb_unload_buddy(&e4b);
|
2008-01-29 06:19:52 +01:00
|
|
|
|
2009-01-06 04:18:16 +01:00
|
|
|
seq_printf(seq, "#%-5u: %-5u %-5u %-5u [", group, sg.info.bb_free,
|
2008-01-29 06:19:52 +01:00
|
|
|
sg.info.bb_fragments, sg.info.bb_first_free);
|
|
|
|
for (i = 0; i <= 13; i++)
|
|
|
|
seq_printf(seq, " %-5u", i <= sb->s_blocksize_bits + 1 ?
|
|
|
|
sg.info.bb_counters[i] : 0);
|
|
|
|
seq_printf(seq, " ]\n");
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ext4_mb_seq_groups_stop(struct seq_file *seq, void *v)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2009-09-05 15:28:54 +02:00
|
|
|
static const struct seq_operations ext4_mb_seq_groups_ops = {
|
2008-01-29 06:19:52 +01:00
|
|
|
.start = ext4_mb_seq_groups_start,
|
|
|
|
.next = ext4_mb_seq_groups_next,
|
|
|
|
.stop = ext4_mb_seq_groups_stop,
|
|
|
|
.show = ext4_mb_seq_groups_show,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int ext4_mb_seq_groups_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
2013-04-01 00:16:14 +02:00
|
|
|
struct super_block *sb = PDE_DATA(inode);
|
2008-01-29 06:19:52 +01:00
|
|
|
int rc;
|
|
|
|
|
|
|
|
rc = seq_open(file, &ext4_mb_seq_groups_ops);
|
|
|
|
if (rc == 0) {
|
2010-07-27 17:56:04 +02:00
|
|
|
struct seq_file *m = file->private_data;
|
2008-01-29 06:19:52 +01:00
|
|
|
m->private = sb;
|
|
|
|
}
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2009-09-05 15:28:54 +02:00
|
|
|
static const struct file_operations ext4_mb_seq_groups_fops = {
|
2008-01-29 06:19:52 +01:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = ext4_mb_seq_groups_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = seq_release,
|
|
|
|
};
|
|
|
|
|
2010-10-28 03:29:12 +02:00
|
|
|
static struct kmem_cache *get_groupinfo_cache(int blocksize_bits)
|
|
|
|
{
|
|
|
|
int cache_index = blocksize_bits - EXT4_MIN_BLOCK_LOG_SIZE;
|
|
|
|
struct kmem_cache *cachep = ext4_groupinfo_caches[cache_index];
|
|
|
|
|
|
|
|
BUG_ON(!cachep);
|
|
|
|
return cachep;
|
|
|
|
}
|
2008-07-12 01:27:31 +02:00
|
|
|
|
2012-09-05 07:31:50 +02:00
|
|
|
/*
|
|
|
|
* Allocate the top-level s_group_info array for the specified number
|
|
|
|
* of groups
|
|
|
|
*/
|
|
|
|
int ext4_mb_alloc_groupinfo(struct super_block *sb, ext4_group_t ngroups)
|
|
|
|
{
|
|
|
|
struct ext4_sb_info *sbi = EXT4_SB(sb);
|
|
|
|
unsigned size;
|
|
|
|
struct ext4_group_info ***new_groupinfo;
|
|
|
|
|
|
|
|
size = (ngroups + EXT4_DESC_PER_BLOCK(sb) - 1) >>
|
|
|
|
EXT4_DESC_PER_BLOCK_BITS(sb);
|
|
|
|
if (size <= sbi->s_group_info_size)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
size = roundup_pow_of_two(sizeof(*sbi->s_group_info) * size);
|
|
|
|
new_groupinfo = ext4_kvzalloc(size, GFP_KERNEL);
|
|
|
|
if (!new_groupinfo) {
|
|
|
|
ext4_msg(sb, KERN_ERR, "can't allocate buddy meta group");
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
if (sbi->s_group_info) {
|
|
|
|
memcpy(new_groupinfo, sbi->s_group_info,
|
|
|
|
sbi->s_group_info_size * sizeof(*sbi->s_group_info));
|
|
|
|
ext4_kvfree(sbi->s_group_info);
|
|
|
|
}
|
|
|
|
sbi->s_group_info = new_groupinfo;
|
|
|
|
sbi->s_group_info_size = size / sizeof(*sbi->s_group_info);
|
|
|
|
ext4_debug("allocated s_groupinfo array for %d meta_bg's\n",
|
|
|
|
sbi->s_group_info_size);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-07-12 01:27:31 +02:00
|
|
|
/* Create and initialize ext4_group_info data for the given group. */
|
2009-01-06 03:36:19 +01:00
|
|
|
int ext4_mb_add_groupinfo(struct super_block *sb, ext4_group_t group,
|
2008-07-12 01:27:31 +02:00
|
|
|
struct ext4_group_desc *desc)
|
|
|
|
{
|
2010-10-28 03:29:12 +02:00
|
|
|
int i;
|
2008-07-12 01:27:31 +02:00
|
|
|
int metalen = 0;
|
|
|
|
struct ext4_sb_info *sbi = EXT4_SB(sb);
|
|
|
|
struct ext4_group_info **meta_group_info;
|
2010-10-28 03:29:12 +02:00
|
|
|
struct kmem_cache *cachep = get_groupinfo_cache(sb->s_blocksize_bits);
|
2008-07-12 01:27:31 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* First check if this group is the first of a reserved block.
|
|
|
|
* If it's true, we have to allocate a new table of pointers
|
|
|
|
* to ext4_group_info structures
|
|
|
|
*/
|
|
|
|
if (group % EXT4_DESC_PER_BLOCK(sb) == 0) {
|
|
|
|
metalen = sizeof(*meta_group_info) <<
|
|
|
|
EXT4_DESC_PER_BLOCK_BITS(sb);
|
|
|
|
meta_group_info = kmalloc(metalen, GFP_KERNEL);
|
|
|
|
if (meta_group_info == NULL) {
|
2012-03-20 04:09:43 +01:00
|
|
|
ext4_msg(sb, KERN_ERR, "can't allocate mem "
|
2011-08-01 23:41:35 +02:00
|
|
|
"for a buddy group");
|
2008-07-12 01:27:31 +02:00
|
|
|
goto exit_meta_group_info;
|
|
|
|
}
|
|
|
|
sbi->s_group_info[group >> EXT4_DESC_PER_BLOCK_BITS(sb)] =
|
|
|
|
meta_group_info;
|
|
|
|
}
|
|
|
|
|
|
|
|
meta_group_info =
|
|
|
|
sbi->s_group_info[group >> EXT4_DESC_PER_BLOCK_BITS(sb)];
|
|
|
|
i = group & (EXT4_DESC_PER_BLOCK(sb) - 1);
|
|
|
|
|
2012-09-27 02:43:37 +02:00
|
|
|
meta_group_info[i] = kmem_cache_zalloc(cachep, GFP_KERNEL);
|
2008-07-12 01:27:31 +02:00
|
|
|
if (meta_group_info[i] == NULL) {
|
2012-03-20 04:09:43 +01:00
|
|
|
ext4_msg(sb, KERN_ERR, "can't allocate buddy mem");
|
2008-07-12 01:27:31 +02:00
|
|
|
goto exit_group_info;
|
|
|
|
}
|
|
|
|
set_bit(EXT4_GROUP_INFO_NEED_INIT_BIT,
|
|
|
|
&(meta_group_info[i]->bb_state));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* initialize bb_free to be able to skip
|
|
|
|
* empty groups without initialization
|
|
|
|
*/
|
|
|
|
if (desc->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT)) {
|
|
|
|
meta_group_info[i]->bb_free =
|
2011-09-10 01:12:51 +02:00
|
|
|
ext4_free_clusters_after_init(sb, group, desc);
|
2008-07-12 01:27:31 +02:00
|
|
|
} else {
|
|
|
|
meta_group_info[i]->bb_free =
|
2011-09-10 01:08:51 +02:00
|
|
|
ext4_free_group_clusters(sb, desc);
|
2008-07-12 01:27:31 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&meta_group_info[i]->bb_prealloc_list);
|
2009-01-06 03:36:19 +01:00
|
|
|
init_rwsem(&meta_group_info[i]->alloc_sem);
|
2010-03-05 04:25:21 +01:00
|
|
|
meta_group_info[i]->bb_free_root = RB_ROOT;
|
2010-05-16 21:00:00 +02:00
|
|
|
meta_group_info[i]->bb_largest_free_order = -1; /* uninit */
|
2008-07-12 01:27:31 +02:00
|
|
|
|
|
|
|
#ifdef DOUBLE_CHECK
|
|
|
|
{
|
|
|
|
struct buffer_head *bh;
|
|
|
|
meta_group_info[i]->bb_bitmap =
|
|
|
|
kmalloc(sb->s_blocksize, GFP_KERNEL);
|
|
|
|
BUG_ON(meta_group_info[i]->bb_bitmap == NULL);
|
|
|
|
bh = ext4_read_block_bitmap(sb, group);
|
|
|
|
BUG_ON(bh == NULL);
|
|
|
|
memcpy(meta_group_info[i]->bb_bitmap, bh->b_data,
|
|
|
|
sb->s_blocksize);
|
|
|
|
put_bh(bh);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
exit_group_info:
|
|
|
|
/* If a meta_group_info table has been allocated, release it now */
|
2011-07-12 00:42:42 +02:00
|
|
|
if (group % EXT4_DESC_PER_BLOCK(sb) == 0) {
|
2008-07-12 01:27:31 +02:00
|
|
|
kfree(sbi->s_group_info[group >> EXT4_DESC_PER_BLOCK_BITS(sb)]);
|
2011-07-12 00:42:42 +02:00
|
|
|
sbi->s_group_info[group >> EXT4_DESC_PER_BLOCK_BITS(sb)] = NULL;
|
|
|
|
}
|
2008-07-12 01:27:31 +02:00
|
|
|
exit_meta_group_info:
|
|
|
|
return -ENOMEM;
|
|
|
|
} /* ext4_mb_add_groupinfo */
|
|
|
|
|
2008-01-29 06:19:52 +01:00
|
|
|
static int ext4_mb_init_backend(struct super_block *sb)
|
|
|
|
{
|
2009-05-01 14:50:38 +02:00
|
|
|
ext4_group_t ngroups = ext4_get_groups_count(sb);
|
2008-01-29 06:19:52 +01:00
|
|
|
ext4_group_t i;
|
|
|
|
struct ext4_sb_info *sbi = EXT4_SB(sb);
|
2012-09-05 07:31:50 +02:00
|
|
|
int err;
|
2008-07-12 01:27:31 +02:00
|
|
|
struct ext4_group_desc *desc;
|
2010-10-28 03:29:12 +02:00
|
|
|
struct kmem_cache *cachep;
|
2008-07-12 01:27:31 +02:00
|
|
|
|
2012-09-05 07:31:50 +02:00
|
|
|
err = ext4_mb_alloc_groupinfo(sb, ngroups);
|
|
|
|
if (err)
|
|
|
|
return err;
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
sbi->s_buddy_cache = new_inode(sb);
|
|
|
|
if (sbi->s_buddy_cache == NULL) {
|
2011-08-01 23:41:35 +02:00
|
|
|
ext4_msg(sb, KERN_ERR, "can't get new inode");
|
2008-01-29 06:19:52 +01:00
|
|
|
goto err_freesgi;
|
|
|
|
}
|
2011-08-01 23:41:39 +02:00
|
|
|
/* To avoid potentially colliding with an valid on-disk inode number,
|
|
|
|
* use EXT4_BAD_INO for the buddy cache inode number. This inode is
|
|
|
|
* not in the inode hash, so it should never be found by iget(), but
|
|
|
|
* this will avoid confusion if it ever shows up during debugging. */
|
|
|
|
sbi->s_buddy_cache->i_ino = EXT4_BAD_INO;
|
2008-01-29 06:19:52 +01:00
|
|
|
EXT4_I(sbi->s_buddy_cache)->i_disksize = 0;
|
2009-05-01 14:50:38 +02:00
|
|
|
for (i = 0; i < ngroups; i++) {
|
2008-01-29 06:19:52 +01:00
|
|
|
desc = ext4_get_group_desc(sb, i, NULL);
|
|
|
|
if (desc == NULL) {
|
2011-08-01 23:41:35 +02:00
|
|
|
ext4_msg(sb, KERN_ERR, "can't read descriptor %u", i);
|
2008-01-29 06:19:52 +01:00
|
|
|
goto err_freebuddy;
|
|
|
|
}
|
2008-07-12 01:27:31 +02:00
|
|
|
if (ext4_mb_add_groupinfo(sb, i, desc) != 0)
|
|
|
|
goto err_freebuddy;
|
2008-01-29 06:19:52 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_freebuddy:
|
2010-10-28 03:29:12 +02:00
|
|
|
cachep = get_groupinfo_cache(sb->s_blocksize_bits);
|
2008-04-30 04:01:15 +02:00
|
|
|
while (i-- > 0)
|
2010-10-28 03:29:12 +02:00
|
|
|
kmem_cache_free(cachep, ext4_get_group_info(sb, i));
|
2012-09-05 07:31:50 +02:00
|
|
|
i = sbi->s_group_info_size;
|
2008-04-30 04:01:15 +02:00
|
|
|
while (i-- > 0)
|
2008-01-29 06:19:52 +01:00
|
|
|
kfree(sbi->s_group_info[i]);
|
|
|
|
iput(sbi->s_buddy_cache);
|
|
|
|
err_freesgi:
|
2011-08-01 14:45:38 +02:00
|
|
|
ext4_kvfree(sbi->s_group_info);
|
2008-01-29 06:19:52 +01:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2011-02-12 14:12:18 +01:00
|
|
|
static void ext4_groupinfo_destroy_slabs(void)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < NR_GRPINFO_CACHES; i++) {
|
|
|
|
if (ext4_groupinfo_caches[i])
|
|
|
|
kmem_cache_destroy(ext4_groupinfo_caches[i]);
|
|
|
|
ext4_groupinfo_caches[i] = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ext4_groupinfo_create_slab(size_t size)
|
|
|
|
{
|
|
|
|
static DEFINE_MUTEX(ext4_grpinfo_slab_create_mutex);
|
|
|
|
int slab_size;
|
|
|
|
int blocksize_bits = order_base_2(size);
|
|
|
|
int cache_index = blocksize_bits - EXT4_MIN_BLOCK_LOG_SIZE;
|
|
|
|
struct kmem_cache *cachep;
|
|
|
|
|
|
|
|
if (cache_index >= NR_GRPINFO_CACHES)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (unlikely(cache_index < 0))
|
|
|
|
cache_index = 0;
|
|
|
|
|
|
|
|
mutex_lock(&ext4_grpinfo_slab_create_mutex);
|
|
|
|
if (ext4_groupinfo_caches[cache_index]) {
|
|
|
|
mutex_unlock(&ext4_grpinfo_slab_create_mutex);
|
|
|
|
return 0; /* Already created */
|
|
|
|
}
|
|
|
|
|
|
|
|
slab_size = offsetof(struct ext4_group_info,
|
|
|
|
bb_counters[blocksize_bits + 2]);
|
|
|
|
|
|
|
|
cachep = kmem_cache_create(ext4_groupinfo_slab_names[cache_index],
|
|
|
|
slab_size, 0, SLAB_RECLAIM_ACCOUNT,
|
|
|
|
NULL);
|
|
|
|
|
2011-07-12 00:26:01 +02:00
|
|
|
ext4_groupinfo_caches[cache_index] = cachep;
|
|
|
|
|
2011-02-12 14:12:18 +01:00
|
|
|
mutex_unlock(&ext4_grpinfo_slab_create_mutex);
|
|
|
|
if (!cachep) {
|
2011-08-01 23:41:35 +02:00
|
|
|
printk(KERN_EMERG
|
|
|
|
"EXT4-fs: no memory for groupinfo slab cache\n");
|
2011-02-12 14:12:18 +01:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-05-28 20:19:25 +02:00
|
|
|
int ext4_mb_init(struct super_block *sb)
|
2008-01-29 06:19:52 +01:00
|
|
|
{
|
|
|
|
struct ext4_sb_info *sbi = EXT4_SB(sb);
|
2008-07-23 20:14:05 +02:00
|
|
|
unsigned i, j;
|
2008-01-29 06:19:52 +01:00
|
|
|
unsigned offset;
|
|
|
|
unsigned max;
|
2008-07-12 01:27:31 +02:00
|
|
|
int ret;
|
2008-01-29 06:19:52 +01:00
|
|
|
|
2009-08-26 04:36:25 +02:00
|
|
|
i = (sb->s_blocksize_bits + 2) * sizeof(*sbi->s_mb_offsets);
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
sbi->s_mb_offsets = kmalloc(i, GFP_KERNEL);
|
|
|
|
if (sbi->s_mb_offsets == NULL) {
|
2010-10-28 03:29:12 +02:00
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
2008-01-29 06:19:52 +01:00
|
|
|
}
|
2008-12-17 06:48:39 +01:00
|
|
|
|
2009-08-26 04:36:25 +02:00
|
|
|
i = (sb->s_blocksize_bits + 2) * sizeof(*sbi->s_mb_maxs);
|
2008-01-29 06:19:52 +01:00
|
|
|
sbi->s_mb_maxs = kmalloc(i, GFP_KERNEL);
|
|
|
|
if (sbi->s_mb_maxs == NULL) {
|
2010-10-28 03:29:12 +02:00
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2011-02-12 14:12:18 +01:00
|
|
|
ret = ext4_groupinfo_create_slab(sb->s_blocksize);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
/* order 0 is regular bitmap */
|
|
|
|
sbi->s_mb_maxs[0] = sb->s_blocksize << 3;
|
|
|
|
sbi->s_mb_offsets[0] = 0;
|
|
|
|
|
|
|
|
i = 1;
|
|
|
|
offset = 0;
|
|
|
|
max = sb->s_blocksize << 2;
|
|
|
|
do {
|
|
|
|
sbi->s_mb_offsets[i] = offset;
|
|
|
|
sbi->s_mb_maxs[i] = max;
|
|
|
|
offset += 1 << (sb->s_blocksize_bits - i);
|
|
|
|
max = max >> 1;
|
|
|
|
i++;
|
|
|
|
} while (i <= sb->s_blocksize_bits + 1);
|
|
|
|
|
|
|
|
spin_lock_init(&sbi->s_md_lock);
|
|
|
|
spin_lock_init(&sbi->s_bal_lock);
|
|
|
|
|
|
|
|
sbi->s_mb_max_to_scan = MB_DEFAULT_MAX_TO_SCAN;
|
|
|
|
sbi->s_mb_min_to_scan = MB_DEFAULT_MIN_TO_SCAN;
|
|
|
|
sbi->s_mb_stats = MB_DEFAULT_STATS;
|
|
|
|
sbi->s_mb_stream_request = MB_DEFAULT_STREAM_THRESHOLD;
|
|
|
|
sbi->s_mb_order2_reqs = MB_DEFAULT_ORDER2_REQS;
|
2011-09-10 01:02:51 +02:00
|
|
|
/*
|
|
|
|
* The default group preallocation is 512, which for 4k block
|
|
|
|
* sizes translates to 2 megabytes. However for bigalloc file
|
|
|
|
* systems, this is probably too big (i.e, if the cluster size
|
|
|
|
* is 1 megabyte, then group preallocation size becomes half a
|
|
|
|
* gigabyte!). As a default, we will keep a two megabyte
|
|
|
|
* group pralloc size for cluster sizes up to 64k, and after
|
|
|
|
* that, we will force a minimum group preallocation size of
|
|
|
|
* 32 clusters. This translates to 8 megs when the cluster
|
|
|
|
* size is 256k, and 32 megs when the cluster size is 1 meg,
|
|
|
|
* which seems reasonable as a default.
|
|
|
|
*/
|
|
|
|
sbi->s_mb_group_prealloc = max(MB_DEFAULT_GROUP_PREALLOC >>
|
|
|
|
sbi->s_cluster_bits, 32);
|
2011-07-18 03:11:30 +02:00
|
|
|
/*
|
|
|
|
* If there is a s_stripe > 1, then we set the s_mb_group_prealloc
|
|
|
|
* to the lowest multiple of s_stripe which is bigger than
|
|
|
|
* the s_mb_group_prealloc as determined above. We want
|
|
|
|
* the preallocation size to be an exact multiple of the
|
|
|
|
* RAID stripe size so that preallocations don't fragment
|
|
|
|
* the stripes.
|
|
|
|
*/
|
|
|
|
if (sbi->s_stripe > 1) {
|
|
|
|
sbi->s_mb_group_prealloc = roundup(
|
|
|
|
sbi->s_mb_group_prealloc, sbi->s_stripe);
|
|
|
|
}
|
2008-01-29 06:19:52 +01:00
|
|
|
|
2008-09-13 21:23:29 +02:00
|
|
|
sbi->s_locality_groups = alloc_percpu(struct ext4_locality_group);
|
2008-01-29 06:19:52 +01:00
|
|
|
if (sbi->s_locality_groups == NULL) {
|
2010-10-28 03:29:12 +02:00
|
|
|
ret = -ENOMEM;
|
2011-10-06 16:22:28 +02:00
|
|
|
goto out_free_groupinfo_slab;
|
2008-01-29 06:19:52 +01:00
|
|
|
}
|
2008-09-13 21:23:29 +02:00
|
|
|
for_each_possible_cpu(i) {
|
2008-01-29 06:19:52 +01:00
|
|
|
struct ext4_locality_group *lg;
|
2008-09-13 21:23:29 +02:00
|
|
|
lg = per_cpu_ptr(sbi->s_locality_groups, i);
|
2008-01-29 06:19:52 +01:00
|
|
|
mutex_init(&lg->lg_mutex);
|
2008-07-23 20:14:05 +02:00
|
|
|
for (j = 0; j < PREALLOC_TB_SIZE; j++)
|
|
|
|
INIT_LIST_HEAD(&lg->lg_prealloc_list[j]);
|
2008-01-29 06:19:52 +01:00
|
|
|
spin_lock_init(&lg->lg_prealloc_lock);
|
|
|
|
}
|
|
|
|
|
2011-08-01 23:41:46 +02:00
|
|
|
/* init file for buddy data */
|
|
|
|
ret = ext4_mb_init_backend(sb);
|
2011-10-06 16:22:28 +02:00
|
|
|
if (ret != 0)
|
|
|
|
goto out_free_locality_groups;
|
2011-08-01 23:41:46 +02:00
|
|
|
|
2009-09-30 06:32:42 +02:00
|
|
|
if (sbi->s_proc)
|
|
|
|
proc_create_data("mb_groups", S_IRUGO, sbi->s_proc,
|
|
|
|
&ext4_mb_seq_groups_fops, sb);
|
2008-01-29 06:19:52 +01:00
|
|
|
|
2011-10-06 16:22:28 +02:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_free_locality_groups:
|
|
|
|
free_percpu(sbi->s_locality_groups);
|
|
|
|
sbi->s_locality_groups = NULL;
|
|
|
|
out_free_groupinfo_slab:
|
|
|
|
ext4_groupinfo_destroy_slabs();
|
2010-10-28 03:29:12 +02:00
|
|
|
out:
|
2011-10-06 16:22:28 +02:00
|
|
|
kfree(sbi->s_mb_offsets);
|
|
|
|
sbi->s_mb_offsets = NULL;
|
|
|
|
kfree(sbi->s_mb_maxs);
|
|
|
|
sbi->s_mb_maxs = NULL;
|
2010-10-28 03:29:12 +02:00
|
|
|
return ret;
|
2008-01-29 06:19:52 +01:00
|
|
|
}
|
|
|
|
|
2009-05-03 02:35:09 +02:00
|
|
|
/* need to called with the ext4 group lock held */
|
2008-01-29 06:19:52 +01:00
|
|
|
static void ext4_mb_cleanup_pa(struct ext4_group_info *grp)
|
|
|
|
{
|
|
|
|
struct ext4_prealloc_space *pa;
|
|
|
|
struct list_head *cur, *tmp;
|
|
|
|
int count = 0;
|
|
|
|
|
|
|
|
list_for_each_safe(cur, tmp, &grp->bb_prealloc_list) {
|
|
|
|
pa = list_entry(cur, struct ext4_prealloc_space, pa_group_list);
|
|
|
|
list_del(&pa->pa_group_list);
|
|
|
|
count++;
|
2008-10-13 18:14:14 +02:00
|
|
|
kmem_cache_free(ext4_pspace_cachep, pa);
|
2008-01-29 06:19:52 +01:00
|
|
|
}
|
|
|
|
if (count)
|
2009-09-18 19:38:55 +02:00
|
|
|
mb_debug(1, "mballoc: %u PAs left\n", count);
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
int ext4_mb_release(struct super_block *sb)
|
|
|
|
{
|
2009-05-01 14:50:38 +02:00
|
|
|
ext4_group_t ngroups = ext4_get_groups_count(sb);
|
2008-01-29 06:19:52 +01:00
|
|
|
ext4_group_t i;
|
|
|
|
int num_meta_group_infos;
|
|
|
|
struct ext4_group_info *grinfo;
|
|
|
|
struct ext4_sb_info *sbi = EXT4_SB(sb);
|
2010-10-28 03:29:12 +02:00
|
|
|
struct kmem_cache *cachep = get_groupinfo_cache(sb->s_blocksize_bits);
|
2008-01-29 06:19:52 +01:00
|
|
|
|
2012-06-01 05:52:14 +02:00
|
|
|
if (sbi->s_proc)
|
|
|
|
remove_proc_entry("mb_groups", sbi->s_proc);
|
|
|
|
|
2008-01-29 06:19:52 +01:00
|
|
|
if (sbi->s_group_info) {
|
2009-05-01 14:50:38 +02:00
|
|
|
for (i = 0; i < ngroups; i++) {
|
2008-01-29 06:19:52 +01:00
|
|
|
grinfo = ext4_get_group_info(sb, i);
|
|
|
|
#ifdef DOUBLE_CHECK
|
|
|
|
kfree(grinfo->bb_bitmap);
|
|
|
|
#endif
|
|
|
|
ext4_lock_group(sb, i);
|
|
|
|
ext4_mb_cleanup_pa(grinfo);
|
|
|
|
ext4_unlock_group(sb, i);
|
2010-10-28 03:29:12 +02:00
|
|
|
kmem_cache_free(cachep, grinfo);
|
2008-01-29 06:19:52 +01:00
|
|
|
}
|
2009-05-01 14:50:38 +02:00
|
|
|
num_meta_group_infos = (ngroups +
|
2008-01-29 06:19:52 +01:00
|
|
|
EXT4_DESC_PER_BLOCK(sb) - 1) >>
|
|
|
|
EXT4_DESC_PER_BLOCK_BITS(sb);
|
|
|
|
for (i = 0; i < num_meta_group_infos; i++)
|
|
|
|
kfree(sbi->s_group_info[i]);
|
2011-08-01 14:45:38 +02:00
|
|
|
ext4_kvfree(sbi->s_group_info);
|
2008-01-29 06:19:52 +01:00
|
|
|
}
|
|
|
|
kfree(sbi->s_mb_offsets);
|
|
|
|
kfree(sbi->s_mb_maxs);
|
|
|
|
if (sbi->s_buddy_cache)
|
|
|
|
iput(sbi->s_buddy_cache);
|
|
|
|
if (sbi->s_mb_stats) {
|
2011-08-01 23:41:35 +02:00
|
|
|
ext4_msg(sb, KERN_INFO,
|
|
|
|
"mballoc: %u blocks %u reqs (%u success)",
|
2008-01-29 06:19:52 +01:00
|
|
|
atomic_read(&sbi->s_bal_allocated),
|
|
|
|
atomic_read(&sbi->s_bal_reqs),
|
|
|
|
atomic_read(&sbi->s_bal_success));
|
2011-08-01 23:41:35 +02:00
|
|
|
ext4_msg(sb, KERN_INFO,
|
|
|
|
"mballoc: %u extents scanned, %u goal hits, "
|
|
|
|
"%u 2^N hits, %u breaks, %u lost",
|
2008-01-29 06:19:52 +01:00
|
|
|
atomic_read(&sbi->s_bal_ex_scanned),
|
|
|
|
atomic_read(&sbi->s_bal_goals),
|
|
|
|
atomic_read(&sbi->s_bal_2orders),
|
|
|
|
atomic_read(&sbi->s_bal_breaks),
|
|
|
|
atomic_read(&sbi->s_mb_lost_chunks));
|
2011-08-01 23:41:35 +02:00
|
|
|
ext4_msg(sb, KERN_INFO,
|
|
|
|
"mballoc: %lu generated and it took %Lu",
|
2011-07-23 22:18:05 +02:00
|
|
|
sbi->s_mb_buddies_generated,
|
2008-01-29 06:19:52 +01:00
|
|
|
sbi->s_mb_generation_time);
|
2011-08-01 23:41:35 +02:00
|
|
|
ext4_msg(sb, KERN_INFO,
|
|
|
|
"mballoc: %u preallocated, %u discarded",
|
2008-01-29 06:19:52 +01:00
|
|
|
atomic_read(&sbi->s_mb_preallocated),
|
|
|
|
atomic_read(&sbi->s_mb_discarded));
|
|
|
|
}
|
|
|
|
|
2008-09-13 21:23:29 +02:00
|
|
|
free_percpu(sbi->s_locality_groups);
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-10-28 03:30:11 +02:00
|
|
|
static inline int ext4_issue_discard(struct super_block *sb,
|
2011-09-10 00:50:51 +02:00
|
|
|
ext4_group_t block_group, ext4_grpblk_t cluster, int count)
|
2010-07-27 17:56:05 +02:00
|
|
|
{
|
|
|
|
ext4_fsblk_t discard_block;
|
|
|
|
|
2011-09-10 00:50:51 +02:00
|
|
|
discard_block = (EXT4_C2B(EXT4_SB(sb), cluster) +
|
|
|
|
ext4_group_first_block_no(sb, block_group));
|
|
|
|
count = EXT4_C2B(EXT4_SB(sb), count);
|
2010-07-27 17:56:05 +02:00
|
|
|
trace_ext4_discard_blocks(sb,
|
|
|
|
(unsigned long long) discard_block, count);
|
2011-01-10 18:09:59 +01:00
|
|
|
return sb_issue_discard(sb, discard_block, count, GFP_NOFS, 0);
|
2010-07-27 17:56:05 +02:00
|
|
|
}
|
|
|
|
|
2008-10-17 02:00:24 +02:00
|
|
|
/*
|
|
|
|
* This function is called by the jbd2 layer once the commit has finished,
|
|
|
|
* so we know we can free the blocks that were released with that commit.
|
|
|
|
*/
|
2012-02-20 23:53:02 +01:00
|
|
|
static void ext4_free_data_callback(struct super_block *sb,
|
|
|
|
struct ext4_journal_cb_entry *jce,
|
|
|
|
int rc)
|
2008-01-29 06:19:52 +01:00
|
|
|
{
|
2012-02-20 23:53:02 +01:00
|
|
|
struct ext4_free_data *entry = (struct ext4_free_data *)jce;
|
2008-01-29 06:19:52 +01:00
|
|
|
struct ext4_buddy e4b;
|
2008-10-16 16:14:27 +02:00
|
|
|
struct ext4_group_info *db;
|
2011-04-30 19:47:24 +02:00
|
|
|
int err, count = 0, count2 = 0;
|
2008-01-29 06:19:52 +01:00
|
|
|
|
2012-02-20 23:53:02 +01:00
|
|
|
mb_debug(1, "gonna free %u blocks in group %u (0x%p):",
|
|
|
|
entry->efd_count, entry->efd_group, entry);
|
2008-01-29 06:19:52 +01:00
|
|
|
|
2012-11-08 20:04:52 +01:00
|
|
|
if (test_opt(sb, DISCARD)) {
|
|
|
|
err = ext4_issue_discard(sb, entry->efd_group,
|
|
|
|
entry->efd_start_cluster,
|
|
|
|
entry->efd_count);
|
|
|
|
if (err && err != -EOPNOTSUPP)
|
|
|
|
ext4_msg(sb, KERN_WARNING, "discard request in"
|
|
|
|
" group:%d block:%d count:%d failed"
|
|
|
|
" with %d", entry->efd_group,
|
|
|
|
entry->efd_start_cluster,
|
|
|
|
entry->efd_count, err);
|
|
|
|
}
|
2008-01-29 06:19:52 +01:00
|
|
|
|
2012-02-20 23:53:02 +01:00
|
|
|
err = ext4_mb_load_buddy(sb, entry->efd_group, &e4b);
|
|
|
|
/* we expect to find existing buddy because it's pinned */
|
|
|
|
BUG_ON(err != 0);
|
2010-04-20 22:51:59 +02:00
|
|
|
|
2008-01-29 06:19:52 +01:00
|
|
|
|
2012-02-20 23:53:02 +01:00
|
|
|
db = e4b.bd_info;
|
|
|
|
/* there are blocks to put in buddy to make them really free */
|
|
|
|
count += entry->efd_count;
|
|
|
|
count2++;
|
|
|
|
ext4_lock_group(sb, entry->efd_group);
|
|
|
|
/* Take it out of per group rb tree */
|
|
|
|
rb_erase(&entry->efd_node, &(db->bb_free_root));
|
|
|
|
mb_free_blocks(NULL, &e4b, entry->efd_start_cluster, entry->efd_count);
|
2008-10-16 16:14:27 +02:00
|
|
|
|
2012-02-20 23:53:02 +01:00
|
|
|
/*
|
|
|
|
* Clear the trimmed flag for the group so that the next
|
|
|
|
* ext4_trim_fs can trim it.
|
|
|
|
* If the volume is mounted with -o discard, online discard
|
|
|
|
* is supported and the free blocks will be trimmed online.
|
|
|
|
*/
|
|
|
|
if (!test_opt(sb, DISCARD))
|
|
|
|
EXT4_MB_GRP_CLEAR_TRIMMED(db);
|
2011-07-11 06:03:38 +02:00
|
|
|
|
2012-02-20 23:53:02 +01:00
|
|
|
if (!db->bb_free_root.rb_node) {
|
|
|
|
/* No more items in the per group rb tree
|
|
|
|
* balance refcounts from ext4_mb_free_metadata()
|
|
|
|
*/
|
|
|
|
page_cache_release(e4b.bd_buddy_page);
|
|
|
|
page_cache_release(e4b.bd_bitmap_page);
|
2008-10-17 02:00:24 +02:00
|
|
|
}
|
2012-02-20 23:53:02 +01:00
|
|
|
ext4_unlock_group(sb, entry->efd_group);
|
|
|
|
kmem_cache_free(ext4_free_data_cachep, entry);
|
|
|
|
ext4_mb_unload_buddy(&e4b);
|
2008-01-29 06:19:52 +01:00
|
|
|
|
2009-09-18 19:38:55 +02:00
|
|
|
mb_debug(1, "freed %u blocks in %u structures\n", count, count2);
|
2008-01-29 06:19:52 +01:00
|
|
|
}
|
|
|
|
|
2010-10-28 03:30:14 +02:00
|
|
|
int __init ext4_init_mballoc(void)
|
2008-01-29 06:19:52 +01:00
|
|
|
{
|
2010-10-28 03:30:09 +02:00
|
|
|
ext4_pspace_cachep = KMEM_CACHE(ext4_prealloc_space,
|
|
|
|
SLAB_RECLAIM_ACCOUNT);
|
2008-01-29 06:19:52 +01:00
|
|
|
if (ext4_pspace_cachep == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2010-10-28 03:30:09 +02:00
|
|
|
ext4_ac_cachep = KMEM_CACHE(ext4_allocation_context,
|
|
|
|
SLAB_RECLAIM_ACCOUNT);
|
2008-02-10 07:13:33 +01:00
|
|
|
if (ext4_ac_cachep == NULL) {
|
|
|
|
kmem_cache_destroy(ext4_pspace_cachep);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2008-10-16 16:14:27 +02:00
|
|
|
|
2012-02-20 23:53:02 +01:00
|
|
|
ext4_free_data_cachep = KMEM_CACHE(ext4_free_data,
|
|
|
|
SLAB_RECLAIM_ACCOUNT);
|
|
|
|
if (ext4_free_data_cachep == NULL) {
|
2008-10-16 16:14:27 +02:00
|
|
|
kmem_cache_destroy(ext4_pspace_cachep);
|
|
|
|
kmem_cache_destroy(ext4_ac_cachep);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2008-01-29 06:19:52 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-10-28 03:30:14 +02:00
|
|
|
void ext4_exit_mballoc(void)
|
2008-01-29 06:19:52 +01:00
|
|
|
{
|
2010-05-17 13:00:00 +02:00
|
|
|
/*
|
2009-07-06 04:29:27 +02:00
|
|
|
* Wait for completion of call_rcu()'s on ext4_pspace_cachep
|
|
|
|
* before destroying the slab cache.
|
|
|
|
*/
|
|
|
|
rcu_barrier();
|
2008-01-29 06:19:52 +01:00
|
|
|
kmem_cache_destroy(ext4_pspace_cachep);
|
2008-02-10 07:13:33 +01:00
|
|
|
kmem_cache_destroy(ext4_ac_cachep);
|
2012-02-20 23:53:02 +01:00
|
|
|
kmem_cache_destroy(ext4_free_data_cachep);
|
2011-02-12 14:12:18 +01:00
|
|
|
ext4_groupinfo_destroy_slabs();
|
2008-01-29 06:19:52 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
2010-07-30 21:02:47 +02:00
|
|
|
* Check quota and mark chosen space (ac->ac_b_ex) non-free in bitmaps
|
2008-01-29 06:19:52 +01:00
|
|
|
* Returns 0 if success or error code
|
|
|
|
*/
|
2008-04-29 14:11:12 +02:00
|
|
|
static noinline_for_stack int
|
|
|
|
ext4_mb_mark_diskspace_used(struct ext4_allocation_context *ac,
|
2011-09-10 00:48:51 +02:00
|
|
|
handle_t *handle, unsigned int reserv_clstrs)
|
2008-01-29 06:19:52 +01:00
|
|
|
{
|
|
|
|
struct buffer_head *bitmap_bh = NULL;
|
|
|
|
struct ext4_group_desc *gdp;
|
|
|
|
struct buffer_head *gdp_bh;
|
|
|
|
struct ext4_sb_info *sbi;
|
|
|
|
struct super_block *sb;
|
|
|
|
ext4_fsblk_t block;
|
2008-05-15 20:43:20 +02:00
|
|
|
int err, len;
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
BUG_ON(ac->ac_status != AC_STATUS_FOUND);
|
|
|
|
BUG_ON(ac->ac_b_ex.fe_len <= 0);
|
|
|
|
|
|
|
|
sb = ac->ac_sb;
|
|
|
|
sbi = EXT4_SB(sb);
|
|
|
|
|
|
|
|
err = -EIO;
|
2008-07-12 01:27:31 +02:00
|
|
|
bitmap_bh = ext4_read_block_bitmap(sb, ac->ac_b_ex.fe_group);
|
2008-01-29 06:19:52 +01:00
|
|
|
if (!bitmap_bh)
|
|
|
|
goto out_err;
|
|
|
|
|
|
|
|
err = ext4_journal_get_write_access(handle, bitmap_bh);
|
|
|
|
if (err)
|
|
|
|
goto out_err;
|
|
|
|
|
|
|
|
err = -EIO;
|
|
|
|
gdp = ext4_get_group_desc(sb, ac->ac_b_ex.fe_group, &gdp_bh);
|
|
|
|
if (!gdp)
|
|
|
|
goto out_err;
|
|
|
|
|
2009-01-06 04:18:16 +01:00
|
|
|
ext4_debug("using block group %u(%d)\n", ac->ac_b_ex.fe_group,
|
2011-09-10 01:08:51 +02:00
|
|
|
ext4_free_group_clusters(sb, gdp));
|
2008-06-06 02:59:29 +02:00
|
|
|
|
2008-01-29 06:19:52 +01:00
|
|
|
err = ext4_journal_get_write_access(handle, gdp_bh);
|
|
|
|
if (err)
|
|
|
|
goto out_err;
|
|
|
|
|
2010-03-04 05:53:25 +01:00
|
|
|
block = ext4_grp_offs_to_block(sb, &ac->ac_b_ex);
|
2008-01-29 06:19:52 +01:00
|
|
|
|
2011-09-10 00:48:51 +02:00
|
|
|
len = EXT4_C2B(sbi, ac->ac_b_ex.fe_len);
|
2009-05-17 21:38:01 +02:00
|
|
|
if (!ext4_data_block_valid(sbi, block, len)) {
|
2010-02-15 20:19:27 +01:00
|
|
|
ext4_error(sb, "Allocating blocks %llu-%llu which overlap "
|
2012-03-20 04:13:43 +01:00
|
|
|
"fs metadata", block, block+len);
|
2008-05-15 20:43:20 +02:00
|
|
|
/* File system mounted not to panic on error
|
|
|
|
* Fix the bitmap and repeat the block allocation
|
|
|
|
* We leak some of the blocks here.
|
|
|
|
*/
|
2009-05-03 02:35:09 +02:00
|
|
|
ext4_lock_group(sb, ac->ac_b_ex.fe_group);
|
2011-07-27 04:05:53 +02:00
|
|
|
ext4_set_bits(bitmap_bh->b_data, ac->ac_b_ex.fe_start,
|
|
|
|
ac->ac_b_ex.fe_len);
|
2009-05-03 02:35:09 +02:00
|
|
|
ext4_unlock_group(sb, ac->ac_b_ex.fe_group);
|
2009-01-07 06:06:22 +01:00
|
|
|
err = ext4_handle_dirty_metadata(handle, NULL, bitmap_bh);
|
2008-05-15 20:43:20 +02:00
|
|
|
if (!err)
|
|
|
|
err = -EAGAIN;
|
|
|
|
goto out_err;
|
2008-01-29 06:19:52 +01:00
|
|
|
}
|
2009-05-03 02:35:09 +02:00
|
|
|
|
|
|
|
ext4_lock_group(sb, ac->ac_b_ex.fe_group);
|
2008-01-29 06:19:52 +01:00
|
|
|
#ifdef AGGRESSIVE_CHECK
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < ac->ac_b_ex.fe_len; i++) {
|
|
|
|
BUG_ON(mb_test_bit(ac->ac_b_ex.fe_start + i,
|
|
|
|
bitmap_bh->b_data));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
2011-07-27 04:05:53 +02:00
|
|
|
ext4_set_bits(bitmap_bh->b_data, ac->ac_b_ex.fe_start,
|
|
|
|
ac->ac_b_ex.fe_len);
|
2008-01-29 06:19:52 +01:00
|
|
|
if (gdp->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT)) {
|
|
|
|
gdp->bg_flags &= cpu_to_le16(~EXT4_BG_BLOCK_UNINIT);
|
2011-09-10 01:08:51 +02:00
|
|
|
ext4_free_group_clusters_set(sb, gdp,
|
2011-09-10 01:12:51 +02:00
|
|
|
ext4_free_clusters_after_init(sb,
|
2011-09-10 01:08:51 +02:00
|
|
|
ac->ac_b_ex.fe_group, gdp));
|
2008-01-29 06:19:52 +01:00
|
|
|
}
|
2011-09-10 01:08:51 +02:00
|
|
|
len = ext4_free_group_clusters(sb, gdp) - ac->ac_b_ex.fe_len;
|
|
|
|
ext4_free_group_clusters_set(sb, gdp, len);
|
2012-10-22 06:34:32 +02:00
|
|
|
ext4_block_bitmap_csum_set(sb, ac->ac_b_ex.fe_group, gdp, bitmap_bh);
|
2012-04-30 00:45:10 +02:00
|
|
|
ext4_group_desc_csum_set(sb, ac->ac_b_ex.fe_group, gdp);
|
2009-05-03 02:35:09 +02:00
|
|
|
|
|
|
|
ext4_unlock_group(sb, ac->ac_b_ex.fe_group);
|
2011-09-10 00:56:51 +02:00
|
|
|
percpu_counter_sub(&sbi->s_freeclusters_counter, ac->ac_b_ex.fe_len);
|
2008-07-14 23:52:37 +02:00
|
|
|
/*
|
2008-10-10 15:39:00 +02:00
|
|
|
* Now reduce the dirty block count also. Should not go negative
|
2008-07-14 23:52:37 +02:00
|
|
|
*/
|
2008-10-10 15:39:00 +02:00
|
|
|
if (!(ac->ac_flags & EXT4_MB_DELALLOC_RESERVED))
|
|
|
|
/* release all the reserved blocks if non delalloc */
|
2011-09-10 00:56:51 +02:00
|
|
|
percpu_counter_sub(&sbi->s_dirtyclusters_counter,
|
|
|
|
reserv_clstrs);
|
2008-01-29 06:19:52 +01:00
|
|
|
|
2008-07-12 01:27:31 +02:00
|
|
|
if (sbi->s_log_groups_per_flex) {
|
|
|
|
ext4_group_t flex_group = ext4_flex_group(sbi,
|
|
|
|
ac->ac_b_ex.fe_group);
|
2013-03-12 04:39:59 +01:00
|
|
|
atomic64_sub(ac->ac_b_ex.fe_len,
|
|
|
|
&sbi->s_flex_groups[flex_group].free_clusters);
|
2008-07-12 01:27:31 +02:00
|
|
|
}
|
|
|
|
|
2009-01-07 06:06:22 +01:00
|
|
|
err = ext4_handle_dirty_metadata(handle, NULL, bitmap_bh);
|
2008-01-29 06:19:52 +01:00
|
|
|
if (err)
|
|
|
|
goto out_err;
|
2009-01-07 06:06:22 +01:00
|
|
|
err = ext4_handle_dirty_metadata(handle, NULL, gdp_bh);
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
out_err:
|
2008-02-10 07:07:28 +01:00
|
|
|
brelse(bitmap_bh);
|
2008-01-29 06:19:52 +01:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* here we normalize request for locality group
|
2011-07-18 03:11:30 +02:00
|
|
|
* Group request are normalized to s_mb_group_prealloc, which goes to
|
|
|
|
* s_strip if we set the same via mount option.
|
|
|
|
* s_mb_group_prealloc can be configured via
|
2009-03-31 15:11:14 +02:00
|
|
|
* /sys/fs/ext4/<partition>/mb_group_prealloc
|
2008-01-29 06:19:52 +01:00
|
|
|
*
|
|
|
|
* XXX: should we try to preallocate more than the group has now?
|
|
|
|
*/
|
|
|
|
static void ext4_mb_normalize_group_request(struct ext4_allocation_context *ac)
|
|
|
|
{
|
|
|
|
struct super_block *sb = ac->ac_sb;
|
|
|
|
struct ext4_locality_group *lg = ac->ac_lg;
|
|
|
|
|
|
|
|
BUG_ON(lg == NULL);
|
2011-07-18 03:11:30 +02:00
|
|
|
ac->ac_g_ex.fe_len = EXT4_SB(sb)->s_mb_group_prealloc;
|
2009-09-18 19:38:55 +02:00
|
|
|
mb_debug(1, "#%u: goal %u blocks for locality group\n",
|
2008-01-29 06:19:52 +01:00
|
|
|
current->pid, ac->ac_g_ex.fe_len);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Normalization means making request better in terms of
|
|
|
|
* size and alignment
|
|
|
|
*/
|
2008-04-29 14:11:12 +02:00
|
|
|
static noinline_for_stack void
|
|
|
|
ext4_mb_normalize_request(struct ext4_allocation_context *ac,
|
2008-01-29 06:19:52 +01:00
|
|
|
struct ext4_allocation_request *ar)
|
|
|
|
{
|
2011-09-10 00:48:51 +02:00
|
|
|
struct ext4_sb_info *sbi = EXT4_SB(ac->ac_sb);
|
2008-01-29 06:19:52 +01:00
|
|
|
int bsbits, max;
|
|
|
|
ext4_lblk_t end;
|
2012-02-20 23:53:03 +01:00
|
|
|
loff_t size, start_off;
|
|
|
|
loff_t orig_size __maybe_unused;
|
2010-06-14 19:28:03 +02:00
|
|
|
ext4_lblk_t start;
|
2008-01-29 06:19:52 +01:00
|
|
|
struct ext4_inode_info *ei = EXT4_I(ac->ac_inode);
|
2008-04-17 16:38:59 +02:00
|
|
|
struct ext4_prealloc_space *pa;
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
/* do normalize only data requests, metadata requests
|
|
|
|
do not need preallocation */
|
|
|
|
if (!(ac->ac_flags & EXT4_MB_HINT_DATA))
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* sometime caller may want exact blocks */
|
|
|
|
if (unlikely(ac->ac_flags & EXT4_MB_HINT_GOAL_ONLY))
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* caller may indicate that preallocation isn't
|
|
|
|
* required (it's a tail, for example) */
|
|
|
|
if (ac->ac_flags & EXT4_MB_HINT_NOPREALLOC)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (ac->ac_flags & EXT4_MB_HINT_GROUP_ALLOC) {
|
|
|
|
ext4_mb_normalize_group_request(ac);
|
|
|
|
return ;
|
|
|
|
}
|
|
|
|
|
|
|
|
bsbits = ac->ac_sb->s_blocksize_bits;
|
|
|
|
|
|
|
|
/* first, let's learn actual file size
|
|
|
|
* given current request is allocated */
|
2011-09-10 00:48:51 +02:00
|
|
|
size = ac->ac_o_ex.fe_logical + EXT4_C2B(sbi, ac->ac_o_ex.fe_len);
|
2008-01-29 06:19:52 +01:00
|
|
|
size = size << bsbits;
|
|
|
|
if (size < i_size_read(ac->ac_inode))
|
|
|
|
size = i_size_read(ac->ac_inode);
|
2010-06-14 19:28:03 +02:00
|
|
|
orig_size = size;
|
2008-01-29 06:19:52 +01:00
|
|
|
|
ext4: mballoc fix mb_normalize_request algorithm for 1KB block size filesystems
In case of inode preallocation, the number of blocks to allocate depends
on the file size and it is calculated in ext4_mb_normalize_request().
Each group in the filesystem is then checked to find one that can be
used for allocation; this is done in ext4_mb_good_group().
When a file bigger than 4MB is created, the requested number of blocks
to preallocate, calculated by ext4_mb_normalize_request is 4096.
However for a filesystem with 1KB block size, the maximum size of the
block buddies used by the multiblock allocator is 2048, so none of
groups in the filesystem satisfies the search criteria in
ext4_mb_good_group(). Scanning all the filesystem groups impacts
performance.
This was demonstrated by using a freshly created, 70GB, 1k block
filesystem, with caches dropped write before the test via
/proc/sys/vm/drop_caches, and with the filesystem mounted with
nodelalloc and nodealloc,nomballoc. The time to write an 8 megabyte
file using "dd if=/dev/zero of=/mnt/test/fo bs=8k count=1k conv=fsync"
took 35.5091 seconds (236kB/s) with nodellaloc, and 0.233754 seconds
(35.9 MB/s) with the nodelloc,nomballoc options. With a 1TB partition,
it took several minutes to write 8MB!
This patch modifies the algorithm in ext4_mb_normalize_group_request to
calculate the number of blocks to allocate by taking into account the
maximum size of free blocks chunks handled by the multiblock allocator.
It has also been tested for filesystems with 2KB and 4KB block sizes to
ensure that those cases don't regress.
Reviewed-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
Signed-off-by: Valerie Clement <valerie.clement@bull.net>
Signed-off-by: Mingming Cao <cmm@us.ibm.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2008-05-14 01:31:14 +02:00
|
|
|
/* max size of free chunks */
|
|
|
|
max = 2 << bsbits;
|
2008-01-29 06:19:52 +01:00
|
|
|
|
ext4: mballoc fix mb_normalize_request algorithm for 1KB block size filesystems
In case of inode preallocation, the number of blocks to allocate depends
on the file size and it is calculated in ext4_mb_normalize_request().
Each group in the filesystem is then checked to find one that can be
used for allocation; this is done in ext4_mb_good_group().
When a file bigger than 4MB is created, the requested number of blocks
to preallocate, calculated by ext4_mb_normalize_request is 4096.
However for a filesystem with 1KB block size, the maximum size of the
block buddies used by the multiblock allocator is 2048, so none of
groups in the filesystem satisfies the search criteria in
ext4_mb_good_group(). Scanning all the filesystem groups impacts
performance.
This was demonstrated by using a freshly created, 70GB, 1k block
filesystem, with caches dropped write before the test via
/proc/sys/vm/drop_caches, and with the filesystem mounted with
nodelalloc and nodealloc,nomballoc. The time to write an 8 megabyte
file using "dd if=/dev/zero of=/mnt/test/fo bs=8k count=1k conv=fsync"
took 35.5091 seconds (236kB/s) with nodellaloc, and 0.233754 seconds
(35.9 MB/s) with the nodelloc,nomballoc options. With a 1TB partition,
it took several minutes to write 8MB!
This patch modifies the algorithm in ext4_mb_normalize_group_request to
calculate the number of blocks to allocate by taking into account the
maximum size of free blocks chunks handled by the multiblock allocator.
It has also been tested for filesystems with 2KB and 4KB block sizes to
ensure that those cases don't regress.
Reviewed-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
Signed-off-by: Valerie Clement <valerie.clement@bull.net>
Signed-off-by: Mingming Cao <cmm@us.ibm.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2008-05-14 01:31:14 +02:00
|
|
|
#define NRL_CHECK_SIZE(req, size, max, chunk_size) \
|
|
|
|
(req <= (size) || max <= (chunk_size))
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
/* first, try to predict filesize */
|
|
|
|
/* XXX: should this table be tunable? */
|
|
|
|
start_off = 0;
|
|
|
|
if (size <= 16 * 1024) {
|
|
|
|
size = 16 * 1024;
|
|
|
|
} else if (size <= 32 * 1024) {
|
|
|
|
size = 32 * 1024;
|
|
|
|
} else if (size <= 64 * 1024) {
|
|
|
|
size = 64 * 1024;
|
|
|
|
} else if (size <= 128 * 1024) {
|
|
|
|
size = 128 * 1024;
|
|
|
|
} else if (size <= 256 * 1024) {
|
|
|
|
size = 256 * 1024;
|
|
|
|
} else if (size <= 512 * 1024) {
|
|
|
|
size = 512 * 1024;
|
|
|
|
} else if (size <= 1024 * 1024) {
|
|
|
|
size = 1024 * 1024;
|
ext4: mballoc fix mb_normalize_request algorithm for 1KB block size filesystems
In case of inode preallocation, the number of blocks to allocate depends
on the file size and it is calculated in ext4_mb_normalize_request().
Each group in the filesystem is then checked to find one that can be
used for allocation; this is done in ext4_mb_good_group().
When a file bigger than 4MB is created, the requested number of blocks
to preallocate, calculated by ext4_mb_normalize_request is 4096.
However for a filesystem with 1KB block size, the maximum size of the
block buddies used by the multiblock allocator is 2048, so none of
groups in the filesystem satisfies the search criteria in
ext4_mb_good_group(). Scanning all the filesystem groups impacts
performance.
This was demonstrated by using a freshly created, 70GB, 1k block
filesystem, with caches dropped write before the test via
/proc/sys/vm/drop_caches, and with the filesystem mounted with
nodelalloc and nodealloc,nomballoc. The time to write an 8 megabyte
file using "dd if=/dev/zero of=/mnt/test/fo bs=8k count=1k conv=fsync"
took 35.5091 seconds (236kB/s) with nodellaloc, and 0.233754 seconds
(35.9 MB/s) with the nodelloc,nomballoc options. With a 1TB partition,
it took several minutes to write 8MB!
This patch modifies the algorithm in ext4_mb_normalize_group_request to
calculate the number of blocks to allocate by taking into account the
maximum size of free blocks chunks handled by the multiblock allocator.
It has also been tested for filesystems with 2KB and 4KB block sizes to
ensure that those cases don't regress.
Reviewed-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
Signed-off-by: Valerie Clement <valerie.clement@bull.net>
Signed-off-by: Mingming Cao <cmm@us.ibm.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2008-05-14 01:31:14 +02:00
|
|
|
} else if (NRL_CHECK_SIZE(size, 4 * 1024 * 1024, max, 2 * 1024)) {
|
2008-01-29 06:19:52 +01:00
|
|
|
start_off = ((loff_t)ac->ac_o_ex.fe_logical >>
|
ext4: mballoc fix mb_normalize_request algorithm for 1KB block size filesystems
In case of inode preallocation, the number of blocks to allocate depends
on the file size and it is calculated in ext4_mb_normalize_request().
Each group in the filesystem is then checked to find one that can be
used for allocation; this is done in ext4_mb_good_group().
When a file bigger than 4MB is created, the requested number of blocks
to preallocate, calculated by ext4_mb_normalize_request is 4096.
However for a filesystem with 1KB block size, the maximum size of the
block buddies used by the multiblock allocator is 2048, so none of
groups in the filesystem satisfies the search criteria in
ext4_mb_good_group(). Scanning all the filesystem groups impacts
performance.
This was demonstrated by using a freshly created, 70GB, 1k block
filesystem, with caches dropped write before the test via
/proc/sys/vm/drop_caches, and with the filesystem mounted with
nodelalloc and nodealloc,nomballoc. The time to write an 8 megabyte
file using "dd if=/dev/zero of=/mnt/test/fo bs=8k count=1k conv=fsync"
took 35.5091 seconds (236kB/s) with nodellaloc, and 0.233754 seconds
(35.9 MB/s) with the nodelloc,nomballoc options. With a 1TB partition,
it took several minutes to write 8MB!
This patch modifies the algorithm in ext4_mb_normalize_group_request to
calculate the number of blocks to allocate by taking into account the
maximum size of free blocks chunks handled by the multiblock allocator.
It has also been tested for filesystems with 2KB and 4KB block sizes to
ensure that those cases don't regress.
Reviewed-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
Signed-off-by: Valerie Clement <valerie.clement@bull.net>
Signed-off-by: Mingming Cao <cmm@us.ibm.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2008-05-14 01:31:14 +02:00
|
|
|
(21 - bsbits)) << 21;
|
|
|
|
size = 2 * 1024 * 1024;
|
|
|
|
} else if (NRL_CHECK_SIZE(size, 8 * 1024 * 1024, max, 4 * 1024)) {
|
2008-01-29 06:19:52 +01:00
|
|
|
start_off = ((loff_t)ac->ac_o_ex.fe_logical >>
|
|
|
|
(22 - bsbits)) << 22;
|
|
|
|
size = 4 * 1024 * 1024;
|
|
|
|
} else if (NRL_CHECK_SIZE(ac->ac_o_ex.fe_len,
|
ext4: mballoc fix mb_normalize_request algorithm for 1KB block size filesystems
In case of inode preallocation, the number of blocks to allocate depends
on the file size and it is calculated in ext4_mb_normalize_request().
Each group in the filesystem is then checked to find one that can be
used for allocation; this is done in ext4_mb_good_group().
When a file bigger than 4MB is created, the requested number of blocks
to preallocate, calculated by ext4_mb_normalize_request is 4096.
However for a filesystem with 1KB block size, the maximum size of the
block buddies used by the multiblock allocator is 2048, so none of
groups in the filesystem satisfies the search criteria in
ext4_mb_good_group(). Scanning all the filesystem groups impacts
performance.
This was demonstrated by using a freshly created, 70GB, 1k block
filesystem, with caches dropped write before the test via
/proc/sys/vm/drop_caches, and with the filesystem mounted with
nodelalloc and nodealloc,nomballoc. The time to write an 8 megabyte
file using "dd if=/dev/zero of=/mnt/test/fo bs=8k count=1k conv=fsync"
took 35.5091 seconds (236kB/s) with nodellaloc, and 0.233754 seconds
(35.9 MB/s) with the nodelloc,nomballoc options. With a 1TB partition,
it took several minutes to write 8MB!
This patch modifies the algorithm in ext4_mb_normalize_group_request to
calculate the number of blocks to allocate by taking into account the
maximum size of free blocks chunks handled by the multiblock allocator.
It has also been tested for filesystems with 2KB and 4KB block sizes to
ensure that those cases don't regress.
Reviewed-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
Signed-off-by: Valerie Clement <valerie.clement@bull.net>
Signed-off-by: Mingming Cao <cmm@us.ibm.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2008-05-14 01:31:14 +02:00
|
|
|
(8<<20)>>bsbits, max, 8 * 1024)) {
|
2008-01-29 06:19:52 +01:00
|
|
|
start_off = ((loff_t)ac->ac_o_ex.fe_logical >>
|
|
|
|
(23 - bsbits)) << 23;
|
|
|
|
size = 8 * 1024 * 1024;
|
|
|
|
} else {
|
|
|
|
start_off = (loff_t)ac->ac_o_ex.fe_logical << bsbits;
|
|
|
|
size = ac->ac_o_ex.fe_len << bsbits;
|
|
|
|
}
|
2010-06-14 19:28:03 +02:00
|
|
|
size = size >> bsbits;
|
|
|
|
start = start_off >> bsbits;
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
/* don't cover already allocated blocks in selected range */
|
|
|
|
if (ar->pleft && start <= ar->lleft) {
|
|
|
|
size -= ar->lleft + 1 - start;
|
|
|
|
start = ar->lleft + 1;
|
|
|
|
}
|
|
|
|
if (ar->pright && start + size - 1 >= ar->lright)
|
|
|
|
size -= start + size - ar->lright;
|
|
|
|
|
|
|
|
end = start + size;
|
|
|
|
|
|
|
|
/* check we don't cross already preallocated blocks */
|
|
|
|
rcu_read_lock();
|
2008-04-17 16:38:59 +02:00
|
|
|
list_for_each_entry_rcu(pa, &ei->i_prealloc_list, pa_inode_list) {
|
2008-11-05 06:14:04 +01:00
|
|
|
ext4_lblk_t pa_end;
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
if (pa->pa_deleted)
|
|
|
|
continue;
|
|
|
|
spin_lock(&pa->pa_lock);
|
|
|
|
if (pa->pa_deleted) {
|
|
|
|
spin_unlock(&pa->pa_lock);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2011-09-10 00:48:51 +02:00
|
|
|
pa_end = pa->pa_lstart + EXT4_C2B(EXT4_SB(ac->ac_sb),
|
|
|
|
pa->pa_len);
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
/* PA must not overlap original request */
|
|
|
|
BUG_ON(!(ac->ac_o_ex.fe_logical >= pa_end ||
|
|
|
|
ac->ac_o_ex.fe_logical < pa->pa_lstart));
|
|
|
|
|
2009-08-18 05:55:24 +02:00
|
|
|
/* skip PAs this normalized request doesn't overlap with */
|
|
|
|
if (pa->pa_lstart >= end || pa_end <= start) {
|
2008-01-29 06:19:52 +01:00
|
|
|
spin_unlock(&pa->pa_lock);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
BUG_ON(pa->pa_lstart <= start && pa_end >= end);
|
|
|
|
|
2009-08-18 05:55:24 +02:00
|
|
|
/* adjust start or end to be adjacent to this pa */
|
2008-01-29 06:19:52 +01:00
|
|
|
if (pa_end <= ac->ac_o_ex.fe_logical) {
|
|
|
|
BUG_ON(pa_end < start);
|
|
|
|
start = pa_end;
|
2009-08-18 05:55:24 +02:00
|
|
|
} else if (pa->pa_lstart > ac->ac_o_ex.fe_logical) {
|
2008-01-29 06:19:52 +01:00
|
|
|
BUG_ON(pa->pa_lstart > end);
|
|
|
|
end = pa->pa_lstart;
|
|
|
|
}
|
|
|
|
spin_unlock(&pa->pa_lock);
|
|
|
|
}
|
|
|
|
rcu_read_unlock();
|
|
|
|
size = end - start;
|
|
|
|
|
|
|
|
/* XXX: extra loop to check we really don't overlap preallocations */
|
|
|
|
rcu_read_lock();
|
2008-04-17 16:38:59 +02:00
|
|
|
list_for_each_entry_rcu(pa, &ei->i_prealloc_list, pa_inode_list) {
|
2008-11-05 06:14:04 +01:00
|
|
|
ext4_lblk_t pa_end;
|
2011-09-10 00:48:51 +02:00
|
|
|
|
2008-01-29 06:19:52 +01:00
|
|
|
spin_lock(&pa->pa_lock);
|
|
|
|
if (pa->pa_deleted == 0) {
|
2011-09-10 00:48:51 +02:00
|
|
|
pa_end = pa->pa_lstart + EXT4_C2B(EXT4_SB(ac->ac_sb),
|
|
|
|
pa->pa_len);
|
2008-01-29 06:19:52 +01:00
|
|
|
BUG_ON(!(start >= pa_end || end <= pa->pa_lstart));
|
|
|
|
}
|
|
|
|
spin_unlock(&pa->pa_lock);
|
|
|
|
}
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
|
|
|
if (start + size <= ac->ac_o_ex.fe_logical &&
|
|
|
|
start > ac->ac_o_ex.fe_logical) {
|
2011-08-01 23:41:35 +02:00
|
|
|
ext4_msg(ac->ac_sb, KERN_ERR,
|
|
|
|
"start %lu, size %lu, fe_logical %lu",
|
|
|
|
(unsigned long) start, (unsigned long) size,
|
|
|
|
(unsigned long) ac->ac_o_ex.fe_logical);
|
2008-01-29 06:19:52 +01:00
|
|
|
}
|
|
|
|
BUG_ON(start + size <= ac->ac_o_ex.fe_logical &&
|
|
|
|
start > ac->ac_o_ex.fe_logical);
|
2011-09-10 00:38:51 +02:00
|
|
|
BUG_ON(size <= 0 || size > EXT4_CLUSTERS_PER_GROUP(ac->ac_sb));
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
/* now prepare goal request */
|
|
|
|
|
|
|
|
/* XXX: is it better to align blocks WRT to logical
|
|
|
|
* placement or satisfy big request as is */
|
|
|
|
ac->ac_g_ex.fe_logical = start;
|
2011-09-10 00:48:51 +02:00
|
|
|
ac->ac_g_ex.fe_len = EXT4_NUM_B2C(sbi, size);
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
/* define goal start in order to merge */
|
|
|
|
if (ar->pright && (ar->lright == (start + size))) {
|
|
|
|
/* merge to the right */
|
|
|
|
ext4_get_group_no_and_offset(ac->ac_sb, ar->pright - size,
|
|
|
|
&ac->ac_f_ex.fe_group,
|
|
|
|
&ac->ac_f_ex.fe_start);
|
|
|
|
ac->ac_flags |= EXT4_MB_HINT_TRY_GOAL;
|
|
|
|
}
|
|
|
|
if (ar->pleft && (ar->lleft + 1 == start)) {
|
|
|
|
/* merge to the left */
|
|
|
|
ext4_get_group_no_and_offset(ac->ac_sb, ar->pleft + 1,
|
|
|
|
&ac->ac_f_ex.fe_group,
|
|
|
|
&ac->ac_f_ex.fe_start);
|
|
|
|
ac->ac_flags |= EXT4_MB_HINT_TRY_GOAL;
|
|
|
|
}
|
|
|
|
|
2009-09-18 19:38:55 +02:00
|
|
|
mb_debug(1, "goal: %u(was %u) blocks at %u\n", (unsigned) size,
|
2008-01-29 06:19:52 +01:00
|
|
|
(unsigned) orig_size, (unsigned) start);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ext4_mb_collect_stats(struct ext4_allocation_context *ac)
|
|
|
|
{
|
|
|
|
struct ext4_sb_info *sbi = EXT4_SB(ac->ac_sb);
|
|
|
|
|
|
|
|
if (sbi->s_mb_stats && ac->ac_g_ex.fe_len > 1) {
|
|
|
|
atomic_inc(&sbi->s_bal_reqs);
|
|
|
|
atomic_add(ac->ac_b_ex.fe_len, &sbi->s_bal_allocated);
|
2010-05-16 22:00:00 +02:00
|
|
|
if (ac->ac_b_ex.fe_len >= ac->ac_o_ex.fe_len)
|
2008-01-29 06:19:52 +01:00
|
|
|
atomic_inc(&sbi->s_bal_success);
|
|
|
|
atomic_add(ac->ac_found, &sbi->s_bal_ex_scanned);
|
|
|
|
if (ac->ac_g_ex.fe_start == ac->ac_b_ex.fe_start &&
|
|
|
|
ac->ac_g_ex.fe_group == ac->ac_b_ex.fe_group)
|
|
|
|
atomic_inc(&sbi->s_bal_goals);
|
|
|
|
if (ac->ac_found > sbi->s_mb_max_to_scan)
|
|
|
|
atomic_inc(&sbi->s_bal_breaks);
|
|
|
|
}
|
|
|
|
|
2009-09-30 06:32:42 +02:00
|
|
|
if (ac->ac_op == EXT4_MB_HISTORY_ALLOC)
|
|
|
|
trace_ext4_mballoc_alloc(ac);
|
|
|
|
else
|
|
|
|
trace_ext4_mballoc_prealloc(ac);
|
2008-01-29 06:19:52 +01:00
|
|
|
}
|
|
|
|
|
2009-12-09 04:18:25 +01:00
|
|
|
/*
|
|
|
|
* Called on failure; free up any blocks from the inode PA for this
|
|
|
|
* context. We don't need this for MB_GROUP_PA because we only change
|
|
|
|
* pa_free in ext4_mb_release_context(), but on failure, we've already
|
|
|
|
* zeroed out ac->ac_b_ex.fe_len, so group_pa->pa_free is not changed.
|
|
|
|
*/
|
|
|
|
static void ext4_discard_allocated_blocks(struct ext4_allocation_context *ac)
|
|
|
|
{
|
|
|
|
struct ext4_prealloc_space *pa = ac->ac_pa;
|
|
|
|
|
2012-05-28 23:53:53 +02:00
|
|
|
if (pa && pa->pa_type == MB_INODE_PA)
|
|
|
|
pa->pa_free += ac->ac_b_ex.fe_len;
|
2009-12-09 04:18:25 +01:00
|
|
|
}
|
|
|
|
|
2008-01-29 06:19:52 +01:00
|
|
|
/*
|
|
|
|
* use blocks preallocated to inode
|
|
|
|
*/
|
|
|
|
static void ext4_mb_use_inode_pa(struct ext4_allocation_context *ac,
|
|
|
|
struct ext4_prealloc_space *pa)
|
|
|
|
{
|
2011-09-10 00:48:51 +02:00
|
|
|
struct ext4_sb_info *sbi = EXT4_SB(ac->ac_sb);
|
2008-01-29 06:19:52 +01:00
|
|
|
ext4_fsblk_t start;
|
|
|
|
ext4_fsblk_t end;
|
|
|
|
int len;
|
|
|
|
|
|
|
|
/* found preallocated blocks, use them */
|
|
|
|
start = pa->pa_pstart + (ac->ac_o_ex.fe_logical - pa->pa_lstart);
|
2011-09-10 00:48:51 +02:00
|
|
|
end = min(pa->pa_pstart + EXT4_C2B(sbi, pa->pa_len),
|
|
|
|
start + EXT4_C2B(sbi, ac->ac_o_ex.fe_len));
|
|
|
|
len = EXT4_NUM_B2C(sbi, end - start);
|
2008-01-29 06:19:52 +01:00
|
|
|
ext4_get_group_no_and_offset(ac->ac_sb, start, &ac->ac_b_ex.fe_group,
|
|
|
|
&ac->ac_b_ex.fe_start);
|
|
|
|
ac->ac_b_ex.fe_len = len;
|
|
|
|
ac->ac_status = AC_STATUS_FOUND;
|
|
|
|
ac->ac_pa = pa;
|
|
|
|
|
|
|
|
BUG_ON(start < pa->pa_pstart);
|
2011-09-10 00:48:51 +02:00
|
|
|
BUG_ON(end > pa->pa_pstart + EXT4_C2B(sbi, pa->pa_len));
|
2008-01-29 06:19:52 +01:00
|
|
|
BUG_ON(pa->pa_free < len);
|
|
|
|
pa->pa_free -= len;
|
|
|
|
|
2009-09-18 19:38:55 +02:00
|
|
|
mb_debug(1, "use %llu/%u from inode pa %p\n", start, len, pa);
|
2008-01-29 06:19:52 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* use blocks preallocated to locality group
|
|
|
|
*/
|
|
|
|
static void ext4_mb_use_group_pa(struct ext4_allocation_context *ac,
|
|
|
|
struct ext4_prealloc_space *pa)
|
|
|
|
{
|
2008-06-06 02:59:29 +02:00
|
|
|
unsigned int len = ac->ac_o_ex.fe_len;
|
2008-07-23 20:14:05 +02:00
|
|
|
|
2008-01-29 06:19:52 +01:00
|
|
|
ext4_get_group_no_and_offset(ac->ac_sb, pa->pa_pstart,
|
|
|
|
&ac->ac_b_ex.fe_group,
|
|
|
|
&ac->ac_b_ex.fe_start);
|
|
|
|
ac->ac_b_ex.fe_len = len;
|
|
|
|
ac->ac_status = AC_STATUS_FOUND;
|
|
|
|
ac->ac_pa = pa;
|
|
|
|
|
|
|
|
/* we don't correct pa_pstart or pa_plen here to avoid
|
2008-02-10 07:10:04 +01:00
|
|
|
* possible race when the group is being loaded concurrently
|
2008-01-29 06:19:52 +01:00
|
|
|
* instead we correct pa later, after blocks are marked
|
2008-02-10 07:10:04 +01:00
|
|
|
* in on-disk bitmap -- see ext4_mb_release_context()
|
|
|
|
* Other CPUs are prevented from allocating from this pa by lg_mutex
|
2008-01-29 06:19:52 +01:00
|
|
|
*/
|
2009-09-18 19:38:55 +02:00
|
|
|
mb_debug(1, "use %u/%u from group pa %p\n", pa->pa_lstart-len, len, pa);
|
2008-01-29 06:19:52 +01:00
|
|
|
}
|
|
|
|
|
2008-08-19 00:00:57 +02:00
|
|
|
/*
|
|
|
|
* Return the prealloc space that have minimal distance
|
|
|
|
* from the goal block. @cpa is the prealloc
|
|
|
|
* space that is having currently known minimal distance
|
|
|
|
* from the goal block.
|
|
|
|
*/
|
|
|
|
static struct ext4_prealloc_space *
|
|
|
|
ext4_mb_check_group_pa(ext4_fsblk_t goal_block,
|
|
|
|
struct ext4_prealloc_space *pa,
|
|
|
|
struct ext4_prealloc_space *cpa)
|
|
|
|
{
|
|
|
|
ext4_fsblk_t cur_distance, new_distance;
|
|
|
|
|
|
|
|
if (cpa == NULL) {
|
|
|
|
atomic_inc(&pa->pa_count);
|
|
|
|
return pa;
|
|
|
|
}
|
|
|
|
cur_distance = abs(goal_block - cpa->pa_pstart);
|
|
|
|
new_distance = abs(goal_block - pa->pa_pstart);
|
|
|
|
|
2011-02-24 20:10:05 +01:00
|
|
|
if (cur_distance <= new_distance)
|
2008-08-19 00:00:57 +02:00
|
|
|
return cpa;
|
|
|
|
|
|
|
|
/* drop the previous reference */
|
|
|
|
atomic_dec(&cpa->pa_count);
|
|
|
|
atomic_inc(&pa->pa_count);
|
|
|
|
return pa;
|
|
|
|
}
|
|
|
|
|
2008-01-29 06:19:52 +01:00
|
|
|
/*
|
|
|
|
* search goal blocks in preallocated space
|
|
|
|
*/
|
2008-04-29 14:11:12 +02:00
|
|
|
static noinline_for_stack int
|
|
|
|
ext4_mb_use_preallocated(struct ext4_allocation_context *ac)
|
2008-01-29 06:19:52 +01:00
|
|
|
{
|
2011-09-10 00:48:51 +02:00
|
|
|
struct ext4_sb_info *sbi = EXT4_SB(ac->ac_sb);
|
2008-07-23 20:14:05 +02:00
|
|
|
int order, i;
|
2008-01-29 06:19:52 +01:00
|
|
|
struct ext4_inode_info *ei = EXT4_I(ac->ac_inode);
|
|
|
|
struct ext4_locality_group *lg;
|
2008-08-19 00:00:57 +02:00
|
|
|
struct ext4_prealloc_space *pa, *cpa = NULL;
|
|
|
|
ext4_fsblk_t goal_block;
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
/* only data can be preallocated */
|
|
|
|
if (!(ac->ac_flags & EXT4_MB_HINT_DATA))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* first, try per-file preallocation */
|
|
|
|
rcu_read_lock();
|
2008-04-17 16:38:59 +02:00
|
|
|
list_for_each_entry_rcu(pa, &ei->i_prealloc_list, pa_inode_list) {
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
/* all fields in this condition don't change,
|
|
|
|
* so we can skip locking for them */
|
|
|
|
if (ac->ac_o_ex.fe_logical < pa->pa_lstart ||
|
2011-09-10 00:48:51 +02:00
|
|
|
ac->ac_o_ex.fe_logical >= (pa->pa_lstart +
|
|
|
|
EXT4_C2B(sbi, pa->pa_len)))
|
2008-01-29 06:19:52 +01:00
|
|
|
continue;
|
|
|
|
|
ext4: limit block allocations for indirect-block files to < 2^32
Today, the ext4 allocator will happily allocate blocks past
2^32 for indirect-block files, which results in the block
numbers getting truncated, and corruption ensues.
This patch limits such allocations to < 2^32, and adds
BUG_ONs if we do get blocks larger than that.
This should address RH Bug 519471, ext4 bitmap allocator
must limit blocks to < 2^32
* ext4_find_goal() is modified to choose a goal < UINT_MAX,
so that our starting point is in an acceptable range.
* ext4_xattr_block_set() is modified such that the goal block
is < UINT_MAX, as above.
* ext4_mb_regular_allocator() is modified so that the group
search does not continue into groups which are too high
* ext4_mb_use_preallocated() has a check that we don't use
preallocated space which is too far out
* ext4_alloc_blocks() and ext4_xattr_block_set() add some BUG_ONs
No attempt has been made to limit inode locations to < 2^32,
so we may wind up with blocks far from their inodes. Doing
this much already will lead to some odd ENOSPC issues when the
"lower 32" gets full, and further restricting inodes could
make that even weirder.
For high inodes, choosing a goal of the original, % UINT_MAX,
may be a bit odd, but then we're in an odd situation anyway,
and I don't know of a better heuristic.
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2009-09-16 20:45:10 +02:00
|
|
|
/* non-extent files can't have physical blocks past 2^32 */
|
2010-05-17 04:00:00 +02:00
|
|
|
if (!(ext4_test_inode_flag(ac->ac_inode, EXT4_INODE_EXTENTS)) &&
|
2011-09-10 00:48:51 +02:00
|
|
|
(pa->pa_pstart + EXT4_C2B(sbi, pa->pa_len) >
|
|
|
|
EXT4_MAX_BLOCK_FILE_PHYS))
|
ext4: limit block allocations for indirect-block files to < 2^32
Today, the ext4 allocator will happily allocate blocks past
2^32 for indirect-block files, which results in the block
numbers getting truncated, and corruption ensues.
This patch limits such allocations to < 2^32, and adds
BUG_ONs if we do get blocks larger than that.
This should address RH Bug 519471, ext4 bitmap allocator
must limit blocks to < 2^32
* ext4_find_goal() is modified to choose a goal < UINT_MAX,
so that our starting point is in an acceptable range.
* ext4_xattr_block_set() is modified such that the goal block
is < UINT_MAX, as above.
* ext4_mb_regular_allocator() is modified so that the group
search does not continue into groups which are too high
* ext4_mb_use_preallocated() has a check that we don't use
preallocated space which is too far out
* ext4_alloc_blocks() and ext4_xattr_block_set() add some BUG_ONs
No attempt has been made to limit inode locations to < 2^32,
so we may wind up with blocks far from their inodes. Doing
this much already will lead to some odd ENOSPC issues when the
"lower 32" gets full, and further restricting inodes could
make that even weirder.
For high inodes, choosing a goal of the original, % UINT_MAX,
may be a bit odd, but then we're in an odd situation anyway,
and I don't know of a better heuristic.
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2009-09-16 20:45:10 +02:00
|
|
|
continue;
|
|
|
|
|
2008-01-29 06:19:52 +01:00
|
|
|
/* found preallocated blocks, use them */
|
|
|
|
spin_lock(&pa->pa_lock);
|
|
|
|
if (pa->pa_deleted == 0 && pa->pa_free) {
|
|
|
|
atomic_inc(&pa->pa_count);
|
|
|
|
ext4_mb_use_inode_pa(ac, pa);
|
|
|
|
spin_unlock(&pa->pa_lock);
|
|
|
|
ac->ac_criteria = 10;
|
|
|
|
rcu_read_unlock();
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
spin_unlock(&pa->pa_lock);
|
|
|
|
}
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
|
|
|
/* can we use group allocation? */
|
|
|
|
if (!(ac->ac_flags & EXT4_MB_HINT_GROUP_ALLOC))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* inode may have no locality group for some reason */
|
|
|
|
lg = ac->ac_lg;
|
|
|
|
if (lg == NULL)
|
|
|
|
return 0;
|
2008-07-23 20:14:05 +02:00
|
|
|
order = fls(ac->ac_o_ex.fe_len) - 1;
|
|
|
|
if (order > PREALLOC_TB_SIZE - 1)
|
|
|
|
/* The max size of hash table is PREALLOC_TB_SIZE */
|
|
|
|
order = PREALLOC_TB_SIZE - 1;
|
|
|
|
|
2010-03-04 05:53:25 +01:00
|
|
|
goal_block = ext4_grp_offs_to_block(ac->ac_sb, &ac->ac_g_ex);
|
2008-08-19 00:00:57 +02:00
|
|
|
/*
|
|
|
|
* search for the prealloc space that is having
|
|
|
|
* minimal distance from the goal block.
|
|
|
|
*/
|
2008-07-23 20:14:05 +02:00
|
|
|
for (i = order; i < PREALLOC_TB_SIZE; i++) {
|
|
|
|
rcu_read_lock();
|
|
|
|
list_for_each_entry_rcu(pa, &lg->lg_prealloc_list[i],
|
|
|
|
pa_inode_list) {
|
|
|
|
spin_lock(&pa->pa_lock);
|
|
|
|
if (pa->pa_deleted == 0 &&
|
|
|
|
pa->pa_free >= ac->ac_o_ex.fe_len) {
|
2008-08-19 00:00:57 +02:00
|
|
|
|
|
|
|
cpa = ext4_mb_check_group_pa(goal_block,
|
|
|
|
pa, cpa);
|
2008-07-23 20:14:05 +02:00
|
|
|
}
|
2008-01-29 06:19:52 +01:00
|
|
|
spin_unlock(&pa->pa_lock);
|
|
|
|
}
|
2008-07-23 20:14:05 +02:00
|
|
|
rcu_read_unlock();
|
2008-01-29 06:19:52 +01:00
|
|
|
}
|
2008-08-19 00:00:57 +02:00
|
|
|
if (cpa) {
|
|
|
|
ext4_mb_use_group_pa(ac, cpa);
|
|
|
|
ac->ac_criteria = 20;
|
|
|
|
return 1;
|
|
|
|
}
|
2008-01-29 06:19:52 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-01-06 03:36:55 +01:00
|
|
|
/*
|
|
|
|
* the function goes through all block freed in the group
|
|
|
|
* but not yet committed and marks them used in in-core bitmap.
|
|
|
|
* buddy must be generated from this bitmap
|
2009-05-03 02:35:09 +02:00
|
|
|
* Need to be called with the ext4 group lock held
|
2009-01-06 03:36:55 +01:00
|
|
|
*/
|
|
|
|
static void ext4_mb_generate_from_freelist(struct super_block *sb, void *bitmap,
|
|
|
|
ext4_group_t group)
|
|
|
|
{
|
|
|
|
struct rb_node *n;
|
|
|
|
struct ext4_group_info *grp;
|
|
|
|
struct ext4_free_data *entry;
|
|
|
|
|
|
|
|
grp = ext4_get_group_info(sb, group);
|
|
|
|
n = rb_first(&(grp->bb_free_root));
|
|
|
|
|
|
|
|
while (n) {
|
2012-02-20 23:53:02 +01:00
|
|
|
entry = rb_entry(n, struct ext4_free_data, efd_node);
|
|
|
|
ext4_set_bits(bitmap, entry->efd_start_cluster, entry->efd_count);
|
2009-01-06 03:36:55 +01:00
|
|
|
n = rb_next(n);
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-01-29 06:19:52 +01:00
|
|
|
/*
|
|
|
|
* the function goes through all preallocation in this group and marks them
|
|
|
|
* used in in-core bitmap. buddy must be generated from this bitmap
|
2009-05-03 02:35:09 +02:00
|
|
|
* Need to be called with ext4 group lock held
|
2008-01-29 06:19:52 +01:00
|
|
|
*/
|
2009-07-06 04:17:31 +02:00
|
|
|
static noinline_for_stack
|
|
|
|
void ext4_mb_generate_from_pa(struct super_block *sb, void *bitmap,
|
2008-01-29 06:19:52 +01:00
|
|
|
ext4_group_t group)
|
|
|
|
{
|
|
|
|
struct ext4_group_info *grp = ext4_get_group_info(sb, group);
|
|
|
|
struct ext4_prealloc_space *pa;
|
|
|
|
struct list_head *cur;
|
|
|
|
ext4_group_t groupnr;
|
|
|
|
ext4_grpblk_t start;
|
|
|
|
int preallocated = 0;
|
|
|
|
int len;
|
|
|
|
|
|
|
|
/* all form of preallocation discards first load group,
|
|
|
|
* so the only competing code is preallocation use.
|
|
|
|
* we don't need any locking here
|
|
|
|
* notice we do NOT ignore preallocations with pa_deleted
|
|
|
|
* otherwise we could leave used blocks available for
|
|
|
|
* allocation in buddy when concurrent ext4_mb_put_pa()
|
|
|
|
* is dropping preallocation
|
|
|
|
*/
|
|
|
|
list_for_each(cur, &grp->bb_prealloc_list) {
|
|
|
|
pa = list_entry(cur, struct ext4_prealloc_space, pa_group_list);
|
|
|
|
spin_lock(&pa->pa_lock);
|
|
|
|
ext4_get_group_no_and_offset(sb, pa->pa_pstart,
|
|
|
|
&groupnr, &start);
|
|
|
|
len = pa->pa_len;
|
|
|
|
spin_unlock(&pa->pa_lock);
|
|
|
|
if (unlikely(len == 0))
|
|
|
|
continue;
|
|
|
|
BUG_ON(groupnr != group);
|
2011-07-27 04:05:53 +02:00
|
|
|
ext4_set_bits(bitmap, start, len);
|
2008-01-29 06:19:52 +01:00
|
|
|
preallocated += len;
|
|
|
|
}
|
2009-09-18 19:38:55 +02:00
|
|
|
mb_debug(1, "prellocated %u for group %u\n", preallocated, group);
|
2008-01-29 06:19:52 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void ext4_mb_pa_callback(struct rcu_head *head)
|
|
|
|
{
|
|
|
|
struct ext4_prealloc_space *pa;
|
|
|
|
pa = container_of(head, struct ext4_prealloc_space, u.pa_rcu);
|
2013-12-04 00:10:28 +01:00
|
|
|
|
|
|
|
BUG_ON(atomic_read(&pa->pa_count));
|
|
|
|
BUG_ON(pa->pa_deleted == 0);
|
2008-01-29 06:19:52 +01:00
|
|
|
kmem_cache_free(ext4_pspace_cachep, pa);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* drops a reference to preallocated space descriptor
|
|
|
|
* if this was the last reference and the space is consumed
|
|
|
|
*/
|
|
|
|
static void ext4_mb_put_pa(struct ext4_allocation_context *ac,
|
|
|
|
struct super_block *sb, struct ext4_prealloc_space *pa)
|
|
|
|
{
|
2009-01-06 04:18:16 +01:00
|
|
|
ext4_group_t grp;
|
ext4: fix bb_prealloc_list corruption due to wrong group locking
This is for Red Hat bug 490026: EXT4 panic, list corruption in
ext4_mb_new_inode_pa
ext4_lock_group(sb, group) is supposed to protect this list for
each group, and a common code flow to remove an album is like
this:
ext4_get_group_no_and_offset(sb, pa->pa_pstart, &grp, NULL);
ext4_lock_group(sb, grp);
list_del(&pa->pa_group_list);
ext4_unlock_group(sb, grp);
so it's critical that we get the right group number back for
this prealloc context, to lock the right group (the one
associated with this pa) and prevent concurrent list manipulation.
however, ext4_mb_put_pa() passes in (pa->pa_pstart - 1) with a
comment, "-1 is to protect from crossing allocation group".
This makes sense for the group_pa, where pa_pstart is advanced
by the length which has been used (in ext4_mb_release_context()),
and when the entire length has been used, pa_pstart has been
advanced to the first block of the next group.
However, for inode_pa, pa_pstart is never advanced; it's just
set once to the first block in the group and not moved after
that. So in this case, if we subtract one in ext4_mb_put_pa(),
we are actually locking the *previous* group, and opening the
race with the other threads which do not subtract off the extra
block.
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2009-03-17 04:25:40 +01:00
|
|
|
ext4_fsblk_t grp_blk;
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
/* in this short window concurrent discard can set pa_deleted */
|
|
|
|
spin_lock(&pa->pa_lock);
|
2013-12-04 00:10:28 +01:00
|
|
|
if (!atomic_dec_and_test(&pa->pa_count) || pa->pa_free != 0) {
|
|
|
|
spin_unlock(&pa->pa_lock);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-01-29 06:19:52 +01:00
|
|
|
if (pa->pa_deleted == 1) {
|
|
|
|
spin_unlock(&pa->pa_lock);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
pa->pa_deleted = 1;
|
|
|
|
spin_unlock(&pa->pa_lock);
|
|
|
|
|
ext4: fix bb_prealloc_list corruption due to wrong group locking
This is for Red Hat bug 490026: EXT4 panic, list corruption in
ext4_mb_new_inode_pa
ext4_lock_group(sb, group) is supposed to protect this list for
each group, and a common code flow to remove an album is like
this:
ext4_get_group_no_and_offset(sb, pa->pa_pstart, &grp, NULL);
ext4_lock_group(sb, grp);
list_del(&pa->pa_group_list);
ext4_unlock_group(sb, grp);
so it's critical that we get the right group number back for
this prealloc context, to lock the right group (the one
associated with this pa) and prevent concurrent list manipulation.
however, ext4_mb_put_pa() passes in (pa->pa_pstart - 1) with a
comment, "-1 is to protect from crossing allocation group".
This makes sense for the group_pa, where pa_pstart is advanced
by the length which has been used (in ext4_mb_release_context()),
and when the entire length has been used, pa_pstart has been
advanced to the first block of the next group.
However, for inode_pa, pa_pstart is never advanced; it's just
set once to the first block in the group and not moved after
that. So in this case, if we subtract one in ext4_mb_put_pa(),
we are actually locking the *previous* group, and opening the
race with the other threads which do not subtract off the extra
block.
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2009-03-17 04:25:40 +01:00
|
|
|
grp_blk = pa->pa_pstart;
|
2010-05-17 13:00:00 +02:00
|
|
|
/*
|
2009-03-27 22:16:58 +01:00
|
|
|
* If doing group-based preallocation, pa_pstart may be in the
|
|
|
|
* next group when pa is used up
|
|
|
|
*/
|
|
|
|
if (pa->pa_type == MB_GROUP_PA)
|
ext4: fix bb_prealloc_list corruption due to wrong group locking
This is for Red Hat bug 490026: EXT4 panic, list corruption in
ext4_mb_new_inode_pa
ext4_lock_group(sb, group) is supposed to protect this list for
each group, and a common code flow to remove an album is like
this:
ext4_get_group_no_and_offset(sb, pa->pa_pstart, &grp, NULL);
ext4_lock_group(sb, grp);
list_del(&pa->pa_group_list);
ext4_unlock_group(sb, grp);
so it's critical that we get the right group number back for
this prealloc context, to lock the right group (the one
associated with this pa) and prevent concurrent list manipulation.
however, ext4_mb_put_pa() passes in (pa->pa_pstart - 1) with a
comment, "-1 is to protect from crossing allocation group".
This makes sense for the group_pa, where pa_pstart is advanced
by the length which has been used (in ext4_mb_release_context()),
and when the entire length has been used, pa_pstart has been
advanced to the first block of the next group.
However, for inode_pa, pa_pstart is never advanced; it's just
set once to the first block in the group and not moved after
that. So in this case, if we subtract one in ext4_mb_put_pa(),
we are actually locking the *previous* group, and opening the
race with the other threads which do not subtract off the extra
block.
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2009-03-17 04:25:40 +01:00
|
|
|
grp_blk--;
|
|
|
|
|
2013-04-04 05:32:34 +02:00
|
|
|
grp = ext4_get_group_number(sb, grp_blk);
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* possible race:
|
|
|
|
*
|
|
|
|
* P1 (buddy init) P2 (regular allocation)
|
|
|
|
* find block B in PA
|
|
|
|
* copy on-disk bitmap to buddy
|
|
|
|
* mark B in on-disk bitmap
|
|
|
|
* drop PA from group
|
|
|
|
* mark all PAs in buddy
|
|
|
|
*
|
|
|
|
* thus, P1 initializes buddy with B available. to prevent this
|
|
|
|
* we make "copy" and "mark all PAs" atomic and serialize "drop PA"
|
|
|
|
* against that pair
|
|
|
|
*/
|
|
|
|
ext4_lock_group(sb, grp);
|
|
|
|
list_del(&pa->pa_group_list);
|
|
|
|
ext4_unlock_group(sb, grp);
|
|
|
|
|
|
|
|
spin_lock(pa->pa_obj_lock);
|
|
|
|
list_del_rcu(&pa->pa_inode_list);
|
|
|
|
spin_unlock(pa->pa_obj_lock);
|
|
|
|
|
|
|
|
call_rcu(&(pa)->u.pa_rcu, ext4_mb_pa_callback);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* creates new preallocated space for given inode
|
|
|
|
*/
|
2008-04-29 14:11:12 +02:00
|
|
|
static noinline_for_stack int
|
|
|
|
ext4_mb_new_inode_pa(struct ext4_allocation_context *ac)
|
2008-01-29 06:19:52 +01:00
|
|
|
{
|
|
|
|
struct super_block *sb = ac->ac_sb;
|
2011-09-10 00:48:51 +02:00
|
|
|
struct ext4_sb_info *sbi = EXT4_SB(sb);
|
2008-01-29 06:19:52 +01:00
|
|
|
struct ext4_prealloc_space *pa;
|
|
|
|
struct ext4_group_info *grp;
|
|
|
|
struct ext4_inode_info *ei;
|
|
|
|
|
|
|
|
/* preallocate only when found space is larger then requested */
|
|
|
|
BUG_ON(ac->ac_o_ex.fe_len >= ac->ac_b_ex.fe_len);
|
|
|
|
BUG_ON(ac->ac_status != AC_STATUS_FOUND);
|
|
|
|
BUG_ON(!S_ISREG(ac->ac_inode->i_mode));
|
|
|
|
|
|
|
|
pa = kmem_cache_alloc(ext4_pspace_cachep, GFP_NOFS);
|
|
|
|
if (pa == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
if (ac->ac_b_ex.fe_len < ac->ac_g_ex.fe_len) {
|
|
|
|
int winl;
|
|
|
|
int wins;
|
|
|
|
int win;
|
|
|
|
int offs;
|
|
|
|
|
|
|
|
/* we can't allocate as much as normalizer wants.
|
|
|
|
* so, found space must get proper lstart
|
|
|
|
* to cover original request */
|
|
|
|
BUG_ON(ac->ac_g_ex.fe_logical > ac->ac_o_ex.fe_logical);
|
|
|
|
BUG_ON(ac->ac_g_ex.fe_len < ac->ac_o_ex.fe_len);
|
|
|
|
|
|
|
|
/* we're limited by original request in that
|
|
|
|
* logical block must be covered any way
|
|
|
|
* winl is window we can move our chunk within */
|
|
|
|
winl = ac->ac_o_ex.fe_logical - ac->ac_g_ex.fe_logical;
|
|
|
|
|
|
|
|
/* also, we should cover whole original request */
|
2011-09-10 00:48:51 +02:00
|
|
|
wins = EXT4_C2B(sbi, ac->ac_b_ex.fe_len - ac->ac_o_ex.fe_len);
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
/* the smallest one defines real window */
|
|
|
|
win = min(winl, wins);
|
|
|
|
|
2011-09-10 00:48:51 +02:00
|
|
|
offs = ac->ac_o_ex.fe_logical %
|
|
|
|
EXT4_C2B(sbi, ac->ac_b_ex.fe_len);
|
2008-01-29 06:19:52 +01:00
|
|
|
if (offs && offs < win)
|
|
|
|
win = offs;
|
|
|
|
|
2011-09-10 00:48:51 +02:00
|
|
|
ac->ac_b_ex.fe_logical = ac->ac_o_ex.fe_logical -
|
2013-03-02 23:18:58 +01:00
|
|
|
EXT4_NUM_B2C(sbi, win);
|
2008-01-29 06:19:52 +01:00
|
|
|
BUG_ON(ac->ac_o_ex.fe_logical < ac->ac_b_ex.fe_logical);
|
|
|
|
BUG_ON(ac->ac_o_ex.fe_len > ac->ac_b_ex.fe_len);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* preallocation can change ac_b_ex, thus we store actually
|
|
|
|
* allocated blocks for history */
|
|
|
|
ac->ac_f_ex = ac->ac_b_ex;
|
|
|
|
|
|
|
|
pa->pa_lstart = ac->ac_b_ex.fe_logical;
|
|
|
|
pa->pa_pstart = ext4_grp_offs_to_block(sb, &ac->ac_b_ex);
|
|
|
|
pa->pa_len = ac->ac_b_ex.fe_len;
|
|
|
|
pa->pa_free = pa->pa_len;
|
|
|
|
atomic_set(&pa->pa_count, 1);
|
|
|
|
spin_lock_init(&pa->pa_lock);
|
2009-02-14 16:31:16 +01:00
|
|
|
INIT_LIST_HEAD(&pa->pa_inode_list);
|
|
|
|
INIT_LIST_HEAD(&pa->pa_group_list);
|
2008-01-29 06:19:52 +01:00
|
|
|
pa->pa_deleted = 0;
|
2009-03-27 22:16:58 +01:00
|
|
|
pa->pa_type = MB_INODE_PA;
|
2008-01-29 06:19:52 +01:00
|
|
|
|
2009-09-18 19:38:55 +02:00
|
|
|
mb_debug(1, "new inode pa %p: %llu/%u for %u\n", pa,
|
2008-01-29 06:19:52 +01:00
|
|
|
pa->pa_pstart, pa->pa_len, pa->pa_lstart);
|
2009-06-17 17:48:11 +02:00
|
|
|
trace_ext4_mb_new_inode_pa(ac, pa);
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
ext4_mb_use_inode_pa(ac, pa);
|
2011-09-10 00:48:51 +02:00
|
|
|
atomic_add(pa->pa_free, &sbi->s_mb_preallocated);
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
ei = EXT4_I(ac->ac_inode);
|
|
|
|
grp = ext4_get_group_info(sb, ac->ac_b_ex.fe_group);
|
|
|
|
|
|
|
|
pa->pa_obj_lock = &ei->i_prealloc_lock;
|
|
|
|
pa->pa_inode = ac->ac_inode;
|
|
|
|
|
|
|
|
ext4_lock_group(sb, ac->ac_b_ex.fe_group);
|
|
|
|
list_add(&pa->pa_group_list, &grp->bb_prealloc_list);
|
|
|
|
ext4_unlock_group(sb, ac->ac_b_ex.fe_group);
|
|
|
|
|
|
|
|
spin_lock(pa->pa_obj_lock);
|
|
|
|
list_add_rcu(&pa->pa_inode_list, &ei->i_prealloc_list);
|
|
|
|
spin_unlock(pa->pa_obj_lock);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* creates new preallocated space for locality group inodes belongs to
|
|
|
|
*/
|
2008-04-29 14:11:12 +02:00
|
|
|
static noinline_for_stack int
|
|
|
|
ext4_mb_new_group_pa(struct ext4_allocation_context *ac)
|
2008-01-29 06:19:52 +01:00
|
|
|
{
|
|
|
|
struct super_block *sb = ac->ac_sb;
|
|
|
|
struct ext4_locality_group *lg;
|
|
|
|
struct ext4_prealloc_space *pa;
|
|
|
|
struct ext4_group_info *grp;
|
|
|
|
|
|
|
|
/* preallocate only when found space is larger then requested */
|
|
|
|
BUG_ON(ac->ac_o_ex.fe_len >= ac->ac_b_ex.fe_len);
|
|
|
|
BUG_ON(ac->ac_status != AC_STATUS_FOUND);
|
|
|
|
BUG_ON(!S_ISREG(ac->ac_inode->i_mode));
|
|
|
|
|
|
|
|
BUG_ON(ext4_pspace_cachep == NULL);
|
|
|
|
pa = kmem_cache_alloc(ext4_pspace_cachep, GFP_NOFS);
|
|
|
|
if (pa == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
/* preallocation can change ac_b_ex, thus we store actually
|
|
|
|
* allocated blocks for history */
|
|
|
|
ac->ac_f_ex = ac->ac_b_ex;
|
|
|
|
|
|
|
|
pa->pa_pstart = ext4_grp_offs_to_block(sb, &ac->ac_b_ex);
|
|
|
|
pa->pa_lstart = pa->pa_pstart;
|
|
|
|
pa->pa_len = ac->ac_b_ex.fe_len;
|
|
|
|
pa->pa_free = pa->pa_len;
|
|
|
|
atomic_set(&pa->pa_count, 1);
|
|
|
|
spin_lock_init(&pa->pa_lock);
|
2008-07-23 20:14:05 +02:00
|
|
|
INIT_LIST_HEAD(&pa->pa_inode_list);
|
2009-02-14 16:31:16 +01:00
|
|
|
INIT_LIST_HEAD(&pa->pa_group_list);
|
2008-01-29 06:19:52 +01:00
|
|
|
pa->pa_deleted = 0;
|
2009-03-27 22:16:58 +01:00
|
|
|
pa->pa_type = MB_GROUP_PA;
|
2008-01-29 06:19:52 +01:00
|
|
|
|
2009-09-18 19:38:55 +02:00
|
|
|
mb_debug(1, "new group pa %p: %llu/%u for %u\n", pa,
|
2009-06-17 17:48:11 +02:00
|
|
|
pa->pa_pstart, pa->pa_len, pa->pa_lstart);
|
|
|
|
trace_ext4_mb_new_group_pa(ac, pa);
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
ext4_mb_use_group_pa(ac, pa);
|
|
|
|
atomic_add(pa->pa_free, &EXT4_SB(sb)->s_mb_preallocated);
|
|
|
|
|
|
|
|
grp = ext4_get_group_info(sb, ac->ac_b_ex.fe_group);
|
|
|
|
lg = ac->ac_lg;
|
|
|
|
BUG_ON(lg == NULL);
|
|
|
|
|
|
|
|
pa->pa_obj_lock = &lg->lg_prealloc_lock;
|
|
|
|
pa->pa_inode = NULL;
|
|
|
|
|
|
|
|
ext4_lock_group(sb, ac->ac_b_ex.fe_group);
|
|
|
|
list_add(&pa->pa_group_list, &grp->bb_prealloc_list);
|
|
|
|
ext4_unlock_group(sb, ac->ac_b_ex.fe_group);
|
|
|
|
|
2008-07-23 20:14:05 +02:00
|
|
|
/*
|
|
|
|
* We will later add the new pa to the right bucket
|
|
|
|
* after updating the pa_free in ext4_mb_release_context
|
|
|
|
*/
|
2008-01-29 06:19:52 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ext4_mb_new_preallocation(struct ext4_allocation_context *ac)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if (ac->ac_flags & EXT4_MB_HINT_GROUP_ALLOC)
|
|
|
|
err = ext4_mb_new_group_pa(ac);
|
|
|
|
else
|
|
|
|
err = ext4_mb_new_inode_pa(ac);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* finds all unused blocks in on-disk bitmap, frees them in
|
|
|
|
* in-core bitmap and buddy.
|
|
|
|
* @pa must be unlinked from inode and group lists, so that
|
|
|
|
* nobody else can find/use it.
|
|
|
|
* the caller MUST hold group/inode locks.
|
|
|
|
* TODO: optimize the case when there are no in-core structures yet
|
|
|
|
*/
|
2008-04-29 14:11:12 +02:00
|
|
|
static noinline_for_stack int
|
|
|
|
ext4_mb_release_inode_pa(struct ext4_buddy *e4b, struct buffer_head *bitmap_bh,
|
2010-10-28 03:30:07 +02:00
|
|
|
struct ext4_prealloc_space *pa)
|
2008-01-29 06:19:52 +01:00
|
|
|
{
|
|
|
|
struct super_block *sb = e4b->bd_sb;
|
|
|
|
struct ext4_sb_info *sbi = EXT4_SB(sb);
|
2008-11-05 06:14:04 +01:00
|
|
|
unsigned int end;
|
|
|
|
unsigned int next;
|
2008-01-29 06:19:52 +01:00
|
|
|
ext4_group_t group;
|
|
|
|
ext4_grpblk_t bit;
|
2009-01-04 02:03:21 +01:00
|
|
|
unsigned long long grp_blk_start;
|
2008-01-29 06:19:52 +01:00
|
|
|
int err = 0;
|
|
|
|
int free = 0;
|
|
|
|
|
|
|
|
BUG_ON(pa->pa_deleted == 0);
|
|
|
|
ext4_get_group_no_and_offset(sb, pa->pa_pstart, &group, &bit);
|
2011-09-10 00:48:51 +02:00
|
|
|
grp_blk_start = pa->pa_pstart - EXT4_C2B(sbi, bit);
|
2008-01-29 06:19:52 +01:00
|
|
|
BUG_ON(group != e4b->bd_group && pa->pa_len != 0);
|
|
|
|
end = bit + pa->pa_len;
|
|
|
|
|
|
|
|
while (bit < end) {
|
2008-02-23 07:38:34 +01:00
|
|
|
bit = mb_find_next_zero_bit(bitmap_bh->b_data, end, bit);
|
2008-01-29 06:19:52 +01:00
|
|
|
if (bit >= end)
|
|
|
|
break;
|
2008-02-23 07:38:34 +01:00
|
|
|
next = mb_find_next_bit(bitmap_bh->b_data, end, bit);
|
2009-09-18 19:38:55 +02:00
|
|
|
mb_debug(1, " free preallocated %u/%u in group %u\n",
|
2010-06-14 19:28:03 +02:00
|
|
|
(unsigned) ext4_group_first_block_no(sb, group) + bit,
|
|
|
|
(unsigned) next - bit, (unsigned) group);
|
2008-01-29 06:19:52 +01:00
|
|
|
free += next - bit;
|
|
|
|
|
2010-10-28 03:30:07 +02:00
|
|
|
trace_ext4_mballoc_discard(sb, NULL, group, bit, next - bit);
|
2011-09-10 00:48:51 +02:00
|
|
|
trace_ext4_mb_release_inode_pa(pa, (grp_blk_start +
|
|
|
|
EXT4_C2B(sbi, bit)),
|
2011-06-06 15:51:52 +02:00
|
|
|
next - bit);
|
2008-01-29 06:19:52 +01:00
|
|
|
mb_free_blocks(pa->pa_inode, e4b, bit, next - bit);
|
|
|
|
bit = next + 1;
|
|
|
|
}
|
|
|
|
if (free != pa->pa_free) {
|
2011-08-01 23:41:35 +02:00
|
|
|
ext4_msg(e4b->bd_sb, KERN_CRIT,
|
|
|
|
"pa %p: logic %lu, phys. %lu, len %lu",
|
|
|
|
pa, (unsigned long) pa->pa_lstart,
|
|
|
|
(unsigned long) pa->pa_pstart,
|
|
|
|
(unsigned long) pa->pa_len);
|
2010-06-29 18:54:28 +02:00
|
|
|
ext4_grp_locked_error(sb, group, 0, 0, "free %u, pa_free %u",
|
2009-01-06 04:19:52 +01:00
|
|
|
free, pa->pa_free);
|
2008-02-15 19:48:21 +01:00
|
|
|
/*
|
|
|
|
* pa is already deleted so we use the value obtained
|
|
|
|
* from the bitmap and continue.
|
|
|
|
*/
|
2008-01-29 06:19:52 +01:00
|
|
|
}
|
|
|
|
atomic_add(free, &sbi->s_mb_discarded);
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2008-04-29 14:11:12 +02:00
|
|
|
static noinline_for_stack int
|
|
|
|
ext4_mb_release_group_pa(struct ext4_buddy *e4b,
|
2010-10-28 03:30:07 +02:00
|
|
|
struct ext4_prealloc_space *pa)
|
2008-01-29 06:19:52 +01:00
|
|
|
{
|
|
|
|
struct super_block *sb = e4b->bd_sb;
|
|
|
|
ext4_group_t group;
|
|
|
|
ext4_grpblk_t bit;
|
|
|
|
|
2011-12-18 21:49:54 +01:00
|
|
|
trace_ext4_mb_release_group_pa(sb, pa);
|
2008-01-29 06:19:52 +01:00
|
|
|
BUG_ON(pa->pa_deleted == 0);
|
|
|
|
ext4_get_group_no_and_offset(sb, pa->pa_pstart, &group, &bit);
|
|
|
|
BUG_ON(group != e4b->bd_group && pa->pa_len != 0);
|
|
|
|
mb_free_blocks(pa->pa_inode, e4b, bit, pa->pa_len);
|
|
|
|
atomic_add(pa->pa_len, &EXT4_SB(sb)->s_mb_discarded);
|
2010-10-28 03:30:07 +02:00
|
|
|
trace_ext4_mballoc_discard(sb, NULL, group, bit, pa->pa_len);
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* releases all preallocations in given group
|
|
|
|
*
|
|
|
|
* first, we need to decide discard policy:
|
|
|
|
* - when do we discard
|
|
|
|
* 1) ENOSPC
|
|
|
|
* - how many do we discard
|
|
|
|
* 1) how many requested
|
|
|
|
*/
|
2008-04-29 14:11:12 +02:00
|
|
|
static noinline_for_stack int
|
|
|
|
ext4_mb_discard_group_preallocations(struct super_block *sb,
|
2008-01-29 06:19:52 +01:00
|
|
|
ext4_group_t group, int needed)
|
|
|
|
{
|
|
|
|
struct ext4_group_info *grp = ext4_get_group_info(sb, group);
|
|
|
|
struct buffer_head *bitmap_bh = NULL;
|
|
|
|
struct ext4_prealloc_space *pa, *tmp;
|
|
|
|
struct list_head list;
|
|
|
|
struct ext4_buddy e4b;
|
|
|
|
int err;
|
|
|
|
int busy = 0;
|
|
|
|
int free = 0;
|
|
|
|
|
2009-09-18 19:38:55 +02:00
|
|
|
mb_debug(1, "discard preallocation for group %u\n", group);
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
if (list_empty(&grp->bb_prealloc_list))
|
|
|
|
return 0;
|
|
|
|
|
2008-07-12 01:27:31 +02:00
|
|
|
bitmap_bh = ext4_read_block_bitmap(sb, group);
|
2008-01-29 06:19:52 +01:00
|
|
|
if (bitmap_bh == NULL) {
|
2010-02-15 20:19:27 +01:00
|
|
|
ext4_error(sb, "Error reading block bitmap for %u", group);
|
2008-07-23 20:09:29 +02:00
|
|
|
return 0;
|
2008-01-29 06:19:52 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
err = ext4_mb_load_buddy(sb, group, &e4b);
|
2008-07-23 20:09:29 +02:00
|
|
|
if (err) {
|
2010-02-15 20:19:27 +01:00
|
|
|
ext4_error(sb, "Error loading buddy information for %u", group);
|
2008-07-23 20:09:29 +02:00
|
|
|
put_bh(bitmap_bh);
|
|
|
|
return 0;
|
|
|
|
}
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
if (needed == 0)
|
2011-09-10 00:38:51 +02:00
|
|
|
needed = EXT4_CLUSTERS_PER_GROUP(sb) + 1;
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
INIT_LIST_HEAD(&list);
|
|
|
|
repeat:
|
|
|
|
ext4_lock_group(sb, group);
|
|
|
|
list_for_each_entry_safe(pa, tmp,
|
|
|
|
&grp->bb_prealloc_list, pa_group_list) {
|
|
|
|
spin_lock(&pa->pa_lock);
|
|
|
|
if (atomic_read(&pa->pa_count)) {
|
|
|
|
spin_unlock(&pa->pa_lock);
|
|
|
|
busy = 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (pa->pa_deleted) {
|
|
|
|
spin_unlock(&pa->pa_lock);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* seems this one can be freed ... */
|
|
|
|
pa->pa_deleted = 1;
|
|
|
|
|
|
|
|
/* we can trust pa_free ... */
|
|
|
|
free += pa->pa_free;
|
|
|
|
|
|
|
|
spin_unlock(&pa->pa_lock);
|
|
|
|
|
|
|
|
list_del(&pa->pa_group_list);
|
|
|
|
list_add(&pa->u.pa_tmp_list, &list);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* if we still need more blocks and some PAs were used, try again */
|
|
|
|
if (free < needed && busy) {
|
|
|
|
busy = 0;
|
|
|
|
ext4_unlock_group(sb, group);
|
2013-03-11 03:28:09 +01:00
|
|
|
cond_resched();
|
2008-01-29 06:19:52 +01:00
|
|
|
goto repeat;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* found anything to free? */
|
|
|
|
if (list_empty(&list)) {
|
|
|
|
BUG_ON(free != 0);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* now free all selected PAs */
|
|
|
|
list_for_each_entry_safe(pa, tmp, &list, u.pa_tmp_list) {
|
|
|
|
|
|
|
|
/* remove from object (inode or locality group) */
|
|
|
|
spin_lock(pa->pa_obj_lock);
|
|
|
|
list_del_rcu(&pa->pa_inode_list);
|
|
|
|
spin_unlock(pa->pa_obj_lock);
|
|
|
|
|
2009-03-27 22:16:58 +01:00
|
|
|
if (pa->pa_type == MB_GROUP_PA)
|
2010-10-28 03:30:07 +02:00
|
|
|
ext4_mb_release_group_pa(&e4b, pa);
|
2008-01-29 06:19:52 +01:00
|
|
|
else
|
2010-10-28 03:30:07 +02:00
|
|
|
ext4_mb_release_inode_pa(&e4b, bitmap_bh, pa);
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
list_del(&pa->u.pa_tmp_list);
|
|
|
|
call_rcu(&(pa)->u.pa_rcu, ext4_mb_pa_callback);
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
ext4_unlock_group(sb, group);
|
2010-05-14 06:00:00 +02:00
|
|
|
ext4_mb_unload_buddy(&e4b);
|
2008-01-29 06:19:52 +01:00
|
|
|
put_bh(bitmap_bh);
|
|
|
|
return free;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* releases all non-used preallocated blocks for given inode
|
|
|
|
*
|
|
|
|
* It's important to discard preallocations under i_data_sem
|
|
|
|
* We don't want another block to be served from the prealloc
|
|
|
|
* space when we are discarding the inode prealloc space.
|
|
|
|
*
|
|
|
|
* FIXME!! Make sure it is valid at all the call sites
|
|
|
|
*/
|
2008-10-10 15:40:52 +02:00
|
|
|
void ext4_discard_preallocations(struct inode *inode)
|
2008-01-29 06:19:52 +01:00
|
|
|
{
|
|
|
|
struct ext4_inode_info *ei = EXT4_I(inode);
|
|
|
|
struct super_block *sb = inode->i_sb;
|
|
|
|
struct buffer_head *bitmap_bh = NULL;
|
|
|
|
struct ext4_prealloc_space *pa, *tmp;
|
|
|
|
ext4_group_t group = 0;
|
|
|
|
struct list_head list;
|
|
|
|
struct ext4_buddy e4b;
|
|
|
|
int err;
|
|
|
|
|
2008-10-10 15:40:52 +02:00
|
|
|
if (!S_ISREG(inode->i_mode)) {
|
2008-01-29 06:19:52 +01:00
|
|
|
/*BUG_ON(!list_empty(&ei->i_prealloc_list));*/
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-09-18 19:38:55 +02:00
|
|
|
mb_debug(1, "discard preallocation for inode %lu\n", inode->i_ino);
|
2009-06-17 17:48:11 +02:00
|
|
|
trace_ext4_discard_preallocations(inode);
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
INIT_LIST_HEAD(&list);
|
|
|
|
|
|
|
|
repeat:
|
|
|
|
/* first, collect all pa's in the inode */
|
|
|
|
spin_lock(&ei->i_prealloc_lock);
|
|
|
|
while (!list_empty(&ei->i_prealloc_list)) {
|
|
|
|
pa = list_entry(ei->i_prealloc_list.next,
|
|
|
|
struct ext4_prealloc_space, pa_inode_list);
|
|
|
|
BUG_ON(pa->pa_obj_lock != &ei->i_prealloc_lock);
|
|
|
|
spin_lock(&pa->pa_lock);
|
|
|
|
if (atomic_read(&pa->pa_count)) {
|
|
|
|
/* this shouldn't happen often - nobody should
|
|
|
|
* use preallocation while we're discarding it */
|
|
|
|
spin_unlock(&pa->pa_lock);
|
|
|
|
spin_unlock(&ei->i_prealloc_lock);
|
2011-08-01 23:41:35 +02:00
|
|
|
ext4_msg(sb, KERN_ERR,
|
|
|
|
"uh-oh! used pa while discarding");
|
2008-01-29 06:19:52 +01:00
|
|
|
WARN_ON(1);
|
|
|
|
schedule_timeout_uninterruptible(HZ);
|
|
|
|
goto repeat;
|
|
|
|
|
|
|
|
}
|
|
|
|
if (pa->pa_deleted == 0) {
|
|
|
|
pa->pa_deleted = 1;
|
|
|
|
spin_unlock(&pa->pa_lock);
|
|
|
|
list_del_rcu(&pa->pa_inode_list);
|
|
|
|
list_add(&pa->u.pa_tmp_list, &list);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* someone is deleting pa right now */
|
|
|
|
spin_unlock(&pa->pa_lock);
|
|
|
|
spin_unlock(&ei->i_prealloc_lock);
|
|
|
|
|
|
|
|
/* we have to wait here because pa_deleted
|
|
|
|
* doesn't mean pa is already unlinked from
|
|
|
|
* the list. as we might be called from
|
|
|
|
* ->clear_inode() the inode will get freed
|
|
|
|
* and concurrent thread which is unlinking
|
|
|
|
* pa from inode's list may access already
|
|
|
|
* freed memory, bad-bad-bad */
|
|
|
|
|
|
|
|
/* XXX: if this happens too often, we can
|
|
|
|
* add a flag to force wait only in case
|
|
|
|
* of ->clear_inode(), but not in case of
|
|
|
|
* regular truncate */
|
|
|
|
schedule_timeout_uninterruptible(HZ);
|
|
|
|
goto repeat;
|
|
|
|
}
|
|
|
|
spin_unlock(&ei->i_prealloc_lock);
|
|
|
|
|
|
|
|
list_for_each_entry_safe(pa, tmp, &list, u.pa_tmp_list) {
|
2009-03-27 22:16:58 +01:00
|
|
|
BUG_ON(pa->pa_type != MB_INODE_PA);
|
2013-04-04 05:32:34 +02:00
|
|
|
group = ext4_get_group_number(sb, pa->pa_pstart);
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
err = ext4_mb_load_buddy(sb, group, &e4b);
|
2008-07-23 20:09:29 +02:00
|
|
|
if (err) {
|
2010-02-15 20:19:27 +01:00
|
|
|
ext4_error(sb, "Error loading buddy information for %u",
|
|
|
|
group);
|
2008-07-23 20:09:29 +02:00
|
|
|
continue;
|
|
|
|
}
|
2008-01-29 06:19:52 +01:00
|
|
|
|
2008-07-12 01:27:31 +02:00
|
|
|
bitmap_bh = ext4_read_block_bitmap(sb, group);
|
2008-01-29 06:19:52 +01:00
|
|
|
if (bitmap_bh == NULL) {
|
2010-02-15 20:19:27 +01:00
|
|
|
ext4_error(sb, "Error reading block bitmap for %u",
|
|
|
|
group);
|
2010-05-14 06:00:00 +02:00
|
|
|
ext4_mb_unload_buddy(&e4b);
|
2008-07-23 20:09:29 +02:00
|
|
|
continue;
|
2008-01-29 06:19:52 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
ext4_lock_group(sb, group);
|
|
|
|
list_del(&pa->pa_group_list);
|
2010-10-28 03:30:07 +02:00
|
|
|
ext4_mb_release_inode_pa(&e4b, bitmap_bh, pa);
|
2008-01-29 06:19:52 +01:00
|
|
|
ext4_unlock_group(sb, group);
|
|
|
|
|
2010-05-14 06:00:00 +02:00
|
|
|
ext4_mb_unload_buddy(&e4b);
|
2008-01-29 06:19:52 +01:00
|
|
|
put_bh(bitmap_bh);
|
|
|
|
|
|
|
|
list_del(&pa->u.pa_tmp_list);
|
|
|
|
call_rcu(&(pa)->u.pa_rcu, ext4_mb_pa_callback);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-09-18 19:38:55 +02:00
|
|
|
#ifdef CONFIG_EXT4_DEBUG
|
2008-01-29 06:19:52 +01:00
|
|
|
static void ext4_mb_show_ac(struct ext4_allocation_context *ac)
|
|
|
|
{
|
|
|
|
struct super_block *sb = ac->ac_sb;
|
2009-05-01 14:50:38 +02:00
|
|
|
ext4_group_t ngroups, i;
|
2008-01-29 06:19:52 +01:00
|
|
|
|
2013-02-09 22:28:20 +01:00
|
|
|
if (!ext4_mballoc_debug ||
|
2011-02-27 23:23:47 +01:00
|
|
|
(EXT4_SB(sb)->s_mount_flags & EXT4_MF_FS_ABORTED))
|
2010-07-27 17:56:08 +02:00
|
|
|
return;
|
|
|
|
|
2012-03-20 04:09:43 +01:00
|
|
|
ext4_msg(ac->ac_sb, KERN_ERR, "Can't allocate:"
|
2011-08-01 23:41:35 +02:00
|
|
|
" Allocation context details:");
|
2012-03-20 04:09:43 +01:00
|
|
|
ext4_msg(ac->ac_sb, KERN_ERR, "status %d flags %d",
|
2008-01-29 06:19:52 +01:00
|
|
|
ac->ac_status, ac->ac_flags);
|
2012-03-20 04:09:43 +01:00
|
|
|
ext4_msg(ac->ac_sb, KERN_ERR, "orig %lu/%lu/%lu@%lu, "
|
2011-08-01 23:41:35 +02:00
|
|
|
"goal %lu/%lu/%lu@%lu, "
|
|
|
|
"best %lu/%lu/%lu@%lu cr %d",
|
2008-01-29 06:19:52 +01:00
|
|
|
(unsigned long)ac->ac_o_ex.fe_group,
|
|
|
|
(unsigned long)ac->ac_o_ex.fe_start,
|
|
|
|
(unsigned long)ac->ac_o_ex.fe_len,
|
|
|
|
(unsigned long)ac->ac_o_ex.fe_logical,
|
|
|
|
(unsigned long)ac->ac_g_ex.fe_group,
|
|
|
|
(unsigned long)ac->ac_g_ex.fe_start,
|
|
|
|
(unsigned long)ac->ac_g_ex.fe_len,
|
|
|
|
(unsigned long)ac->ac_g_ex.fe_logical,
|
|
|
|
(unsigned long)ac->ac_b_ex.fe_group,
|
|
|
|
(unsigned long)ac->ac_b_ex.fe_start,
|
|
|
|
(unsigned long)ac->ac_b_ex.fe_len,
|
|
|
|
(unsigned long)ac->ac_b_ex.fe_logical,
|
|
|
|
(int)ac->ac_criteria);
|
2012-03-20 04:09:43 +01:00
|
|
|
ext4_msg(ac->ac_sb, KERN_ERR, "%lu scanned, %d found",
|
2011-08-01 23:41:35 +02:00
|
|
|
ac->ac_ex_scanned, ac->ac_found);
|
2012-03-20 04:09:43 +01:00
|
|
|
ext4_msg(ac->ac_sb, KERN_ERR, "groups: ");
|
2009-05-01 14:50:38 +02:00
|
|
|
ngroups = ext4_get_groups_count(sb);
|
|
|
|
for (i = 0; i < ngroups; i++) {
|
2008-01-29 06:19:52 +01:00
|
|
|
struct ext4_group_info *grp = ext4_get_group_info(sb, i);
|
|
|
|
struct ext4_prealloc_space *pa;
|
|
|
|
ext4_grpblk_t start;
|
|
|
|
struct list_head *cur;
|
|
|
|
ext4_lock_group(sb, i);
|
|
|
|
list_for_each(cur, &grp->bb_prealloc_list) {
|
|
|
|
pa = list_entry(cur, struct ext4_prealloc_space,
|
|
|
|
pa_group_list);
|
|
|
|
spin_lock(&pa->pa_lock);
|
|
|
|
ext4_get_group_no_and_offset(sb, pa->pa_pstart,
|
|
|
|
NULL, &start);
|
|
|
|
spin_unlock(&pa->pa_lock);
|
2009-07-06 05:04:36 +02:00
|
|
|
printk(KERN_ERR "PA:%u:%d:%u \n", i,
|
|
|
|
start, pa->pa_len);
|
2008-01-29 06:19:52 +01:00
|
|
|
}
|
2008-04-30 03:59:59 +02:00
|
|
|
ext4_unlock_group(sb, i);
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
if (grp->bb_free == 0)
|
|
|
|
continue;
|
2009-07-06 05:04:36 +02:00
|
|
|
printk(KERN_ERR "%u: %d/%d \n",
|
2008-01-29 06:19:52 +01:00
|
|
|
i, grp->bb_free, grp->bb_fragments);
|
|
|
|
}
|
|
|
|
printk(KERN_ERR "\n");
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static inline void ext4_mb_show_ac(struct ext4_allocation_context *ac)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We use locality group preallocation for small size file. The size of the
|
|
|
|
* file is determined by the current size or the resulting size after
|
|
|
|
* allocation which ever is larger
|
|
|
|
*
|
2009-03-31 15:11:14 +02:00
|
|
|
* One can tune this size via /sys/fs/ext4/<partition>/mb_stream_req
|
2008-01-29 06:19:52 +01:00
|
|
|
*/
|
|
|
|
static void ext4_mb_group_or_file(struct ext4_allocation_context *ac)
|
|
|
|
{
|
|
|
|
struct ext4_sb_info *sbi = EXT4_SB(ac->ac_sb);
|
|
|
|
int bsbits = ac->ac_sb->s_blocksize_bits;
|
|
|
|
loff_t size, isize;
|
|
|
|
|
|
|
|
if (!(ac->ac_flags & EXT4_MB_HINT_DATA))
|
|
|
|
return;
|
|
|
|
|
2009-08-10 04:01:13 +02:00
|
|
|
if (unlikely(ac->ac_flags & EXT4_MB_HINT_GOAL_ONLY))
|
|
|
|
return;
|
|
|
|
|
2011-09-10 00:48:51 +02:00
|
|
|
size = ac->ac_o_ex.fe_logical + EXT4_C2B(sbi, ac->ac_o_ex.fe_len);
|
ext4: Avoid group preallocation for closed files
Currently the group preallocation code tries to find a large (512)
free block from which to do per-cpu group allocation for small files.
The problem with this scheme is that it leaves the filesystem horribly
fragmented. In the worst case, if the filesystem is unmounted and
remounted (after a system shutdown, for example) we forget the fact
that wee were using a particular (now-partially filled) 512 block
extent. So the next time we try to allocate space for a small file,
we will find *another* completely free 512 block chunk to allocate
small files. Given that there are 32,768 blocks in a block group,
after 64 iterations of "mount, write one 4k file in a directory,
unmount", the block group will have 64 files, each separated by 511
blocks, and the block group will no longer have any free 512
completely free chunks of blocks for group preallocation space.
So if we try to allocate blocks for a file that has been closed, such
that we know the final size of the file, and the filesystem is not
busy, avoid using group preallocation.
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2009-09-18 19:34:02 +02:00
|
|
|
isize = (i_size_read(ac->ac_inode) + ac->ac_sb->s_blocksize - 1)
|
|
|
|
>> bsbits;
|
2008-01-29 06:19:52 +01:00
|
|
|
|
ext4: Avoid group preallocation for closed files
Currently the group preallocation code tries to find a large (512)
free block from which to do per-cpu group allocation for small files.
The problem with this scheme is that it leaves the filesystem horribly
fragmented. In the worst case, if the filesystem is unmounted and
remounted (after a system shutdown, for example) we forget the fact
that wee were using a particular (now-partially filled) 512 block
extent. So the next time we try to allocate space for a small file,
we will find *another* completely free 512 block chunk to allocate
small files. Given that there are 32,768 blocks in a block group,
after 64 iterations of "mount, write one 4k file in a directory,
unmount", the block group will have 64 files, each separated by 511
blocks, and the block group will no longer have any free 512
completely free chunks of blocks for group preallocation space.
So if we try to allocate blocks for a file that has been closed, such
that we know the final size of the file, and the filesystem is not
busy, avoid using group preallocation.
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2009-09-18 19:34:02 +02:00
|
|
|
if ((size == isize) &&
|
|
|
|
!ext4_fs_is_busy(sbi) &&
|
|
|
|
(atomic_read(&ac->ac_inode->i_writecount) == 0)) {
|
|
|
|
ac->ac_flags |= EXT4_MB_HINT_NOPREALLOC;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2011-10-26 11:14:27 +02:00
|
|
|
if (sbi->s_mb_group_prealloc <= 0) {
|
|
|
|
ac->ac_flags |= EXT4_MB_STREAM_ALLOC;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-01-29 06:19:52 +01:00
|
|
|
/* don't use group allocation for large files */
|
2009-09-28 06:06:20 +02:00
|
|
|
size = max(size, isize);
|
ext4: Fix fencepost error in chosing choosing group vs file preallocation.
The ext4 multiblock allocator decides whether to use group or file
preallocation based on the file size. When the file size reaches
s_mb_stream_request (default is 16 blocks), it changes to use a
file-specific preallocation. This is cool, but it has a tiny problem.
See a simple script:
mkfs.ext4 -b 1024 /dev/sda8 1000000
mount -t ext4 -o nodelalloc /dev/sda8 /mnt/ext4
for((i=0;i<5;i++))
do
cat /mnt/4096>>/mnt/ext4/a #4096 is a file with 4096 characters.
cat /mnt/4096>>/mnt/ext4/b
done
debuge4fs -R 'stat a' /dev/sda8|grep BLOCKS -A 1
And you get
BLOCKS:
(0-14):8705-8719, (15):2356, (16-19):8465-8468
So there are 3 extents, a bit strange for the lonely 15th logical
block. As we write to the 16 blocks, we choose file preallocation in
ext4_mb_group_or_file, but in ext4_mb_normalize_request, we meet with
the 16*1024 range, so no preallocation will be carried. file b then
reserves the space after '2356', so when when write 16, we start from
another part.
This patch just change the check in ext4_mb_group_or_file, so
that for the lonely 15 we will still use group preallocation.
After the patch, we will get:
debuge4fs -R 'stat a' /dev/sda8|grep BLOCKS -A 1
BLOCKS:
(0-15):8705-8720, (16-19):8465-8468
Looks more sane. Thanks.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2010-03-02 01:06:35 +01:00
|
|
|
if (size > sbi->s_mb_stream_request) {
|
2009-08-10 04:01:13 +02:00
|
|
|
ac->ac_flags |= EXT4_MB_STREAM_ALLOC;
|
2008-01-29 06:19:52 +01:00
|
|
|
return;
|
2009-08-10 04:01:13 +02:00
|
|
|
}
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
BUG_ON(ac->ac_lg != NULL);
|
|
|
|
/*
|
|
|
|
* locality group prealloc space are per cpu. The reason for having
|
|
|
|
* per cpu locality group is to reduce the contention between block
|
|
|
|
* request from multiple CPUs.
|
|
|
|
*/
|
2009-10-03 12:48:22 +02:00
|
|
|
ac->ac_lg = __this_cpu_ptr(sbi->s_locality_groups);
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
/* we're going to use group allocation */
|
|
|
|
ac->ac_flags |= EXT4_MB_HINT_GROUP_ALLOC;
|
|
|
|
|
|
|
|
/* serialize all allocations in the group */
|
|
|
|
mutex_lock(&ac->ac_lg->lg_mutex);
|
|
|
|
}
|
|
|
|
|
2008-04-29 14:11:12 +02:00
|
|
|
static noinline_for_stack int
|
|
|
|
ext4_mb_initialize_context(struct ext4_allocation_context *ac,
|
2008-01-29 06:19:52 +01:00
|
|
|
struct ext4_allocation_request *ar)
|
|
|
|
{
|
|
|
|
struct super_block *sb = ar->inode->i_sb;
|
|
|
|
struct ext4_sb_info *sbi = EXT4_SB(sb);
|
|
|
|
struct ext4_super_block *es = sbi->s_es;
|
|
|
|
ext4_group_t group;
|
2008-11-05 06:14:04 +01:00
|
|
|
unsigned int len;
|
|
|
|
ext4_fsblk_t goal;
|
2008-01-29 06:19:52 +01:00
|
|
|
ext4_grpblk_t block;
|
|
|
|
|
|
|
|
/* we can't allocate > group size */
|
|
|
|
len = ar->len;
|
|
|
|
|
|
|
|
/* just a dirty hack to filter too big requests */
|
ext4: optimize mballoc for large allocations
The ext4 block allocator only maintains buddy bitmaps for chunks which
are less than or equal to one quarter of a block group. That is, for
a file aystem with a 1k blocksize, and where the number of blocks in a
block group is 8192 blocks, the largest chunk size tracked by buddy
bitmaps is 2048 blocks.
For a file system with a 4k blocksize, and where the number of blocks
in a block group is 32768 blocks, the largest chunk size tracked by
buddy bitmaps is 8192 blocks.
To work around this code, mballoc.c before this commit would truncate
allocation requests to the number of blocks in a block group minus 10.
Why 10? Aside from being a completely arbitrary number, it avoids
block allocation to be a power of two larger than 25% of the block
group. If you try to explicitly fallocate 50% of the block group
size, this will demonstrate the problem; the block allocation code
will scan the all of the blocks in the file system with cr==0 (since
the request is for a natural power of two), but then completely fail
for all blocks groups, since the buddy bitmaps don't track chunk sizes
of 50% of the block group.
To fix this, in these we use ext4_mb_complex_scan_group() instead of
ext4_mb_simple_scan_group().
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
Cc: Andreas Dilger <adilger@dilger.ca>
2013-02-04 21:08:40 +01:00
|
|
|
if (len >= EXT4_CLUSTERS_PER_GROUP(sb))
|
|
|
|
len = EXT4_CLUSTERS_PER_GROUP(sb);
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
/* start searching from the goal */
|
|
|
|
goal = ar->goal;
|
|
|
|
if (goal < le32_to_cpu(es->s_first_data_block) ||
|
|
|
|
goal >= ext4_blocks_count(es))
|
|
|
|
goal = le32_to_cpu(es->s_first_data_block);
|
|
|
|
ext4_get_group_no_and_offset(sb, goal, &group, &block);
|
|
|
|
|
|
|
|
/* set up allocation goals */
|
2013-12-20 15:29:35 +01:00
|
|
|
ac->ac_b_ex.fe_logical = EXT4_LBLK_CMASK(sbi, ar->logical);
|
2008-01-29 06:19:52 +01:00
|
|
|
ac->ac_status = AC_STATUS_CONTINUE;
|
|
|
|
ac->ac_sb = sb;
|
|
|
|
ac->ac_inode = ar->inode;
|
2011-09-10 00:48:51 +02:00
|
|
|
ac->ac_o_ex.fe_logical = ac->ac_b_ex.fe_logical;
|
2008-01-29 06:19:52 +01:00
|
|
|
ac->ac_o_ex.fe_group = group;
|
|
|
|
ac->ac_o_ex.fe_start = block;
|
|
|
|
ac->ac_o_ex.fe_len = len;
|
2011-09-10 00:48:51 +02:00
|
|
|
ac->ac_g_ex = ac->ac_o_ex;
|
2008-01-29 06:19:52 +01:00
|
|
|
ac->ac_flags = ar->flags;
|
|
|
|
|
|
|
|
/* we have to define context: we'll we work with a file or
|
|
|
|
* locality group. this is a policy, actually */
|
|
|
|
ext4_mb_group_or_file(ac);
|
|
|
|
|
2009-09-18 19:38:55 +02:00
|
|
|
mb_debug(1, "init ac: %u blocks @ %u, goal %u, flags %x, 2^%d, "
|
2008-01-29 06:19:52 +01:00
|
|
|
"left: %u/%u, right %u/%u to %swritable\n",
|
|
|
|
(unsigned) ar->len, (unsigned) ar->logical,
|
|
|
|
(unsigned) ar->goal, ac->ac_flags, ac->ac_2order,
|
|
|
|
(unsigned) ar->lleft, (unsigned) ar->pleft,
|
|
|
|
(unsigned) ar->lright, (unsigned) ar->pright,
|
|
|
|
atomic_read(&ar->inode->i_writecount) ? "" : "non-");
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2008-07-23 20:14:05 +02:00
|
|
|
static noinline_for_stack void
|
|
|
|
ext4_mb_discard_lg_preallocations(struct super_block *sb,
|
|
|
|
struct ext4_locality_group *lg,
|
|
|
|
int order, int total_entries)
|
|
|
|
{
|
|
|
|
ext4_group_t group = 0;
|
|
|
|
struct ext4_buddy e4b;
|
|
|
|
struct list_head discard_list;
|
|
|
|
struct ext4_prealloc_space *pa, *tmp;
|
|
|
|
|
2009-09-18 19:38:55 +02:00
|
|
|
mb_debug(1, "discard locality group preallocation\n");
|
2008-07-23 20:14:05 +02:00
|
|
|
|
|
|
|
INIT_LIST_HEAD(&discard_list);
|
|
|
|
|
|
|
|
spin_lock(&lg->lg_prealloc_lock);
|
|
|
|
list_for_each_entry_rcu(pa, &lg->lg_prealloc_list[order],
|
|
|
|
pa_inode_list) {
|
|
|
|
spin_lock(&pa->pa_lock);
|
|
|
|
if (atomic_read(&pa->pa_count)) {
|
|
|
|
/*
|
|
|
|
* This is the pa that we just used
|
|
|
|
* for block allocation. So don't
|
|
|
|
* free that
|
|
|
|
*/
|
|
|
|
spin_unlock(&pa->pa_lock);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (pa->pa_deleted) {
|
|
|
|
spin_unlock(&pa->pa_lock);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
/* only lg prealloc space */
|
2009-03-27 22:16:58 +01:00
|
|
|
BUG_ON(pa->pa_type != MB_GROUP_PA);
|
2008-07-23 20:14:05 +02:00
|
|
|
|
|
|
|
/* seems this one can be freed ... */
|
|
|
|
pa->pa_deleted = 1;
|
|
|
|
spin_unlock(&pa->pa_lock);
|
|
|
|
|
|
|
|
list_del_rcu(&pa->pa_inode_list);
|
|
|
|
list_add(&pa->u.pa_tmp_list, &discard_list);
|
|
|
|
|
|
|
|
total_entries--;
|
|
|
|
if (total_entries <= 5) {
|
|
|
|
/*
|
|
|
|
* we want to keep only 5 entries
|
|
|
|
* allowing it to grow to 8. This
|
|
|
|
* mak sure we don't call discard
|
|
|
|
* soon for this list.
|
|
|
|
*/
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
spin_unlock(&lg->lg_prealloc_lock);
|
|
|
|
|
|
|
|
list_for_each_entry_safe(pa, tmp, &discard_list, u.pa_tmp_list) {
|
|
|
|
|
2013-04-04 05:32:34 +02:00
|
|
|
group = ext4_get_group_number(sb, pa->pa_pstart);
|
2008-07-23 20:14:05 +02:00
|
|
|
if (ext4_mb_load_buddy(sb, group, &e4b)) {
|
2010-02-15 20:19:27 +01:00
|
|
|
ext4_error(sb, "Error loading buddy information for %u",
|
|
|
|
group);
|
2008-07-23 20:14:05 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
ext4_lock_group(sb, group);
|
|
|
|
list_del(&pa->pa_group_list);
|
2010-10-28 03:30:07 +02:00
|
|
|
ext4_mb_release_group_pa(&e4b, pa);
|
2008-07-23 20:14:05 +02:00
|
|
|
ext4_unlock_group(sb, group);
|
|
|
|
|
2010-05-14 06:00:00 +02:00
|
|
|
ext4_mb_unload_buddy(&e4b);
|
2008-07-23 20:14:05 +02:00
|
|
|
list_del(&pa->u.pa_tmp_list);
|
|
|
|
call_rcu(&(pa)->u.pa_rcu, ext4_mb_pa_callback);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We have incremented pa_count. So it cannot be freed at this
|
|
|
|
* point. Also we hold lg_mutex. So no parallel allocation is
|
|
|
|
* possible from this lg. That means pa_free cannot be updated.
|
|
|
|
*
|
|
|
|
* A parallel ext4_mb_discard_group_preallocations is possible.
|
|
|
|
* which can cause the lg_prealloc_list to be updated.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void ext4_mb_add_n_trim(struct ext4_allocation_context *ac)
|
|
|
|
{
|
|
|
|
int order, added = 0, lg_prealloc_count = 1;
|
|
|
|
struct super_block *sb = ac->ac_sb;
|
|
|
|
struct ext4_locality_group *lg = ac->ac_lg;
|
|
|
|
struct ext4_prealloc_space *tmp_pa, *pa = ac->ac_pa;
|
|
|
|
|
|
|
|
order = fls(pa->pa_free) - 1;
|
|
|
|
if (order > PREALLOC_TB_SIZE - 1)
|
|
|
|
/* The max size of hash table is PREALLOC_TB_SIZE */
|
|
|
|
order = PREALLOC_TB_SIZE - 1;
|
|
|
|
/* Add the prealloc space to lg */
|
2013-02-02 03:31:27 +01:00
|
|
|
spin_lock(&lg->lg_prealloc_lock);
|
2008-07-23 20:14:05 +02:00
|
|
|
list_for_each_entry_rcu(tmp_pa, &lg->lg_prealloc_list[order],
|
|
|
|
pa_inode_list) {
|
|
|
|
spin_lock(&tmp_pa->pa_lock);
|
|
|
|
if (tmp_pa->pa_deleted) {
|
2009-03-28 00:43:21 +01:00
|
|
|
spin_unlock(&tmp_pa->pa_lock);
|
2008-07-23 20:14:05 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!added && pa->pa_free < tmp_pa->pa_free) {
|
|
|
|
/* Add to the tail of the previous entry */
|
|
|
|
list_add_tail_rcu(&pa->pa_inode_list,
|
|
|
|
&tmp_pa->pa_inode_list);
|
|
|
|
added = 1;
|
|
|
|
/*
|
|
|
|
* we want to count the total
|
|
|
|
* number of entries in the list
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
spin_unlock(&tmp_pa->pa_lock);
|
|
|
|
lg_prealloc_count++;
|
|
|
|
}
|
|
|
|
if (!added)
|
|
|
|
list_add_tail_rcu(&pa->pa_inode_list,
|
|
|
|
&lg->lg_prealloc_list[order]);
|
2013-02-02 03:31:27 +01:00
|
|
|
spin_unlock(&lg->lg_prealloc_lock);
|
2008-07-23 20:14:05 +02:00
|
|
|
|
|
|
|
/* Now trim the list to be not more than 8 elements */
|
|
|
|
if (lg_prealloc_count > 8) {
|
|
|
|
ext4_mb_discard_lg_preallocations(sb, lg,
|
2013-02-02 03:31:27 +01:00
|
|
|
order, lg_prealloc_count);
|
2008-07-23 20:14:05 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
return ;
|
|
|
|
}
|
|
|
|
|
2008-01-29 06:19:52 +01:00
|
|
|
/*
|
|
|
|
* release all resource we used in allocation
|
|
|
|
*/
|
|
|
|
static int ext4_mb_release_context(struct ext4_allocation_context *ac)
|
|
|
|
{
|
2011-09-10 00:48:51 +02:00
|
|
|
struct ext4_sb_info *sbi = EXT4_SB(ac->ac_sb);
|
2008-07-23 20:14:05 +02:00
|
|
|
struct ext4_prealloc_space *pa = ac->ac_pa;
|
|
|
|
if (pa) {
|
2009-03-27 22:16:58 +01:00
|
|
|
if (pa->pa_type == MB_GROUP_PA) {
|
2008-01-29 06:19:52 +01:00
|
|
|
/* see comment in ext4_mb_use_group_pa() */
|
2008-07-23 20:14:05 +02:00
|
|
|
spin_lock(&pa->pa_lock);
|
2011-09-10 00:48:51 +02:00
|
|
|
pa->pa_pstart += EXT4_C2B(sbi, ac->ac_b_ex.fe_len);
|
|
|
|
pa->pa_lstart += EXT4_C2B(sbi, ac->ac_b_ex.fe_len);
|
2008-07-23 20:14:05 +02:00
|
|
|
pa->pa_free -= ac->ac_b_ex.fe_len;
|
|
|
|
pa->pa_len -= ac->ac_b_ex.fe_len;
|
|
|
|
spin_unlock(&pa->pa_lock);
|
2008-01-29 06:19:52 +01:00
|
|
|
}
|
|
|
|
}
|
2009-02-10 17:14:34 +01:00
|
|
|
if (pa) {
|
|
|
|
/*
|
|
|
|
* We want to add the pa to the right bucket.
|
|
|
|
* Remove it from the list and while adding
|
|
|
|
* make sure the list to which we are adding
|
2011-05-10 03:52:36 +02:00
|
|
|
* doesn't grow big.
|
2009-02-10 17:14:34 +01:00
|
|
|
*/
|
2009-03-27 22:16:58 +01:00
|
|
|
if ((pa->pa_type == MB_GROUP_PA) && likely(pa->pa_free)) {
|
2009-02-10 17:14:34 +01:00
|
|
|
spin_lock(pa->pa_obj_lock);
|
|
|
|
list_del_rcu(&pa->pa_inode_list);
|
|
|
|
spin_unlock(pa->pa_obj_lock);
|
|
|
|
ext4_mb_add_n_trim(ac);
|
|
|
|
}
|
|
|
|
ext4_mb_put_pa(ac, ac->ac_sb, pa);
|
|
|
|
}
|
2008-01-29 06:19:52 +01:00
|
|
|
if (ac->ac_bitmap_page)
|
|
|
|
page_cache_release(ac->ac_bitmap_page);
|
|
|
|
if (ac->ac_buddy_page)
|
|
|
|
page_cache_release(ac->ac_buddy_page);
|
|
|
|
if (ac->ac_flags & EXT4_MB_HINT_GROUP_ALLOC)
|
|
|
|
mutex_unlock(&ac->ac_lg->lg_mutex);
|
|
|
|
ext4_mb_collect_stats(ac);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ext4_mb_discard_preallocations(struct super_block *sb, int needed)
|
|
|
|
{
|
2009-05-01 14:50:38 +02:00
|
|
|
ext4_group_t i, ngroups = ext4_get_groups_count(sb);
|
2008-01-29 06:19:52 +01:00
|
|
|
int ret;
|
|
|
|
int freed = 0;
|
|
|
|
|
2009-06-17 17:48:11 +02:00
|
|
|
trace_ext4_mb_discard_preallocations(sb, needed);
|
2009-05-01 14:50:38 +02:00
|
|
|
for (i = 0; i < ngroups && needed > 0; i++) {
|
2008-01-29 06:19:52 +01:00
|
|
|
ret = ext4_mb_discard_group_preallocations(sb, i, needed);
|
|
|
|
freed += ret;
|
|
|
|
needed -= ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return freed;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Main entry point into mballoc to allocate blocks
|
|
|
|
* it tries to use preallocation first, then falls back
|
|
|
|
* to usual allocation
|
|
|
|
*/
|
|
|
|
ext4_fsblk_t ext4_mb_new_blocks(handle_t *handle,
|
2010-08-05 22:22:24 +02:00
|
|
|
struct ext4_allocation_request *ar, int *errp)
|
2008-01-29 06:19:52 +01:00
|
|
|
{
|
2008-10-10 15:39:00 +02:00
|
|
|
int freed;
|
2008-02-10 07:13:33 +01:00
|
|
|
struct ext4_allocation_context *ac = NULL;
|
2008-01-29 06:19:52 +01:00
|
|
|
struct ext4_sb_info *sbi;
|
|
|
|
struct super_block *sb;
|
|
|
|
ext4_fsblk_t block = 0;
|
2009-01-22 18:13:05 +01:00
|
|
|
unsigned int inquota = 0;
|
2011-09-10 00:48:51 +02:00
|
|
|
unsigned int reserv_clstrs = 0;
|
2008-01-29 06:19:52 +01:00
|
|
|
|
2013-04-04 04:00:52 +02:00
|
|
|
might_sleep();
|
2008-01-29 06:19:52 +01:00
|
|
|
sb = ar->inode->i_sb;
|
|
|
|
sbi = EXT4_SB(sb);
|
|
|
|
|
2009-06-17 17:48:11 +02:00
|
|
|
trace_ext4_request_blocks(ar);
|
2009-01-04 02:03:21 +01:00
|
|
|
|
2011-10-21 02:07:23 +02:00
|
|
|
/* Allow to use superuser reservation for quota file */
|
|
|
|
if (IS_NOQUOTA(ar->inode))
|
|
|
|
ar->flags |= EXT4_MB_USE_ROOT_BLOCKS;
|
|
|
|
|
2009-01-22 18:13:05 +01:00
|
|
|
/*
|
|
|
|
* For delayed allocation, we could skip the ENOSPC and
|
|
|
|
* EDQUOT check, as blocks and quotas have been already
|
|
|
|
* reserved when data being copied into pagecache.
|
|
|
|
*/
|
2011-01-10 18:12:36 +01:00
|
|
|
if (ext4_test_inode_state(ar->inode, EXT4_STATE_DELALLOC_RESERVED))
|
2009-01-22 18:13:05 +01:00
|
|
|
ar->flags |= EXT4_MB_DELALLOC_RESERVED;
|
|
|
|
else {
|
|
|
|
/* Without delayed allocation we need to verify
|
|
|
|
* there is enough free blocks to do block allocation
|
|
|
|
* and verify allocation doesn't exceed the quota limits.
|
2008-07-14 23:52:37 +02:00
|
|
|
*/
|
2011-05-25 13:41:26 +02:00
|
|
|
while (ar->len &&
|
2011-09-10 01:14:51 +02:00
|
|
|
ext4_claim_free_clusters(sbi, ar->len, ar->flags)) {
|
2011-05-25 13:41:26 +02:00
|
|
|
|
2008-09-09 05:14:50 +02:00
|
|
|
/* let others to free the space */
|
2013-03-11 03:28:09 +01:00
|
|
|
cond_resched();
|
2008-09-09 05:14:50 +02:00
|
|
|
ar->len = ar->len >> 1;
|
|
|
|
}
|
|
|
|
if (!ar->len) {
|
2008-10-09 16:56:23 +02:00
|
|
|
*errp = -ENOSPC;
|
|
|
|
return 0;
|
|
|
|
}
|
2011-09-10 00:48:51 +02:00
|
|
|
reserv_clstrs = ar->len;
|
2011-05-25 13:41:26 +02:00
|
|
|
if (ar->flags & EXT4_MB_USE_ROOT_BLOCKS) {
|
2011-09-10 00:48:51 +02:00
|
|
|
dquot_alloc_block_nofail(ar->inode,
|
|
|
|
EXT4_C2B(sbi, ar->len));
|
2011-05-25 13:41:26 +02:00
|
|
|
} else {
|
|
|
|
while (ar->len &&
|
2011-09-10 00:48:51 +02:00
|
|
|
dquot_alloc_block(ar->inode,
|
|
|
|
EXT4_C2B(sbi, ar->len))) {
|
2011-05-25 13:41:26 +02:00
|
|
|
|
|
|
|
ar->flags |= EXT4_MB_HINT_NOPREALLOC;
|
|
|
|
ar->len--;
|
|
|
|
}
|
2009-01-22 18:13:05 +01:00
|
|
|
}
|
|
|
|
inquota = ar->len;
|
|
|
|
if (ar->len == 0) {
|
|
|
|
*errp = -EDQUOT;
|
2010-08-05 22:22:24 +02:00
|
|
|
goto out;
|
2009-01-22 18:13:05 +01:00
|
|
|
}
|
2008-07-12 01:27:31 +02:00
|
|
|
}
|
2008-07-14 23:52:37 +02:00
|
|
|
|
2012-09-27 02:43:37 +02:00
|
|
|
ac = kmem_cache_zalloc(ext4_ac_cachep, GFP_NOFS);
|
2009-07-13 15:45:52 +02:00
|
|
|
if (!ac) {
|
2008-07-12 01:27:31 +02:00
|
|
|
ar->len = 0;
|
2008-02-10 07:13:33 +01:00
|
|
|
*errp = -ENOMEM;
|
2010-08-05 22:22:24 +02:00
|
|
|
goto out;
|
2008-02-10 07:13:33 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
*errp = ext4_mb_initialize_context(ac, ar);
|
2008-01-29 06:19:52 +01:00
|
|
|
if (*errp) {
|
|
|
|
ar->len = 0;
|
2010-08-05 22:22:24 +02:00
|
|
|
goto out;
|
2008-01-29 06:19:52 +01:00
|
|
|
}
|
|
|
|
|
2008-02-10 07:13:33 +01:00
|
|
|
ac->ac_op = EXT4_MB_HISTORY_PREALLOC;
|
|
|
|
if (!ext4_mb_use_preallocated(ac)) {
|
|
|
|
ac->ac_op = EXT4_MB_HISTORY_ALLOC;
|
|
|
|
ext4_mb_normalize_request(ac, ar);
|
2008-01-29 06:19:52 +01:00
|
|
|
repeat:
|
|
|
|
/* allocate space in core */
|
2010-08-05 22:22:24 +02:00
|
|
|
*errp = ext4_mb_regular_allocator(ac);
|
2013-07-01 14:12:36 +02:00
|
|
|
if (*errp)
|
|
|
|
goto discard_and_exit;
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
/* as we've just preallocated more space than
|
2013-07-01 14:12:36 +02:00
|
|
|
* user requested originally, we store allocated
|
2008-01-29 06:19:52 +01:00
|
|
|
* space in a special descriptor */
|
2008-02-10 07:13:33 +01:00
|
|
|
if (ac->ac_status == AC_STATUS_FOUND &&
|
2013-07-01 14:12:36 +02:00
|
|
|
ac->ac_o_ex.fe_len < ac->ac_b_ex.fe_len)
|
|
|
|
*errp = ext4_mb_new_preallocation(ac);
|
|
|
|
if (*errp) {
|
|
|
|
discard_and_exit:
|
|
|
|
ext4_discard_allocated_blocks(ac);
|
|
|
|
goto errout;
|
|
|
|
}
|
2008-01-29 06:19:52 +01:00
|
|
|
}
|
2008-02-10 07:13:33 +01:00
|
|
|
if (likely(ac->ac_status == AC_STATUS_FOUND)) {
|
2011-09-10 00:48:51 +02:00
|
|
|
*errp = ext4_mb_mark_diskspace_used(ac, handle, reserv_clstrs);
|
2010-08-05 22:22:24 +02:00
|
|
|
if (*errp == -EAGAIN) {
|
2009-01-06 03:46:55 +01:00
|
|
|
/*
|
|
|
|
* drop the reference that we took
|
|
|
|
* in ext4_mb_use_best_found
|
|
|
|
*/
|
|
|
|
ext4_mb_release_context(ac);
|
2008-05-15 20:43:20 +02:00
|
|
|
ac->ac_b_ex.fe_group = 0;
|
|
|
|
ac->ac_b_ex.fe_start = 0;
|
|
|
|
ac->ac_b_ex.fe_len = 0;
|
|
|
|
ac->ac_status = AC_STATUS_CONTINUE;
|
|
|
|
goto repeat;
|
2012-11-08 17:11:59 +01:00
|
|
|
} else if (*errp) {
|
2009-12-09 04:18:25 +01:00
|
|
|
ext4_discard_allocated_blocks(ac);
|
2012-11-08 17:11:59 +01:00
|
|
|
goto errout;
|
|
|
|
} else {
|
2008-05-15 20:43:20 +02:00
|
|
|
block = ext4_grp_offs_to_block(sb, &ac->ac_b_ex);
|
|
|
|
ar->len = ac->ac_b_ex.fe_len;
|
|
|
|
}
|
2008-01-29 06:19:52 +01:00
|
|
|
} else {
|
2008-02-10 07:13:33 +01:00
|
|
|
freed = ext4_mb_discard_preallocations(sb, ac->ac_o_ex.fe_len);
|
2008-01-29 06:19:52 +01:00
|
|
|
if (freed)
|
|
|
|
goto repeat;
|
|
|
|
*errp = -ENOSPC;
|
2010-08-05 22:22:24 +02:00
|
|
|
}
|
|
|
|
|
2012-11-08 17:11:59 +01:00
|
|
|
errout:
|
2010-08-05 22:22:24 +02:00
|
|
|
if (*errp) {
|
2008-02-10 07:13:33 +01:00
|
|
|
ac->ac_b_ex.fe_len = 0;
|
2008-01-29 06:19:52 +01:00
|
|
|
ar->len = 0;
|
2008-02-10 07:13:33 +01:00
|
|
|
ext4_mb_show_ac(ac);
|
2008-01-29 06:19:52 +01:00
|
|
|
}
|
2008-02-10 07:13:33 +01:00
|
|
|
ext4_mb_release_context(ac);
|
2010-08-05 22:22:24 +02:00
|
|
|
out:
|
|
|
|
if (ac)
|
|
|
|
kmem_cache_free(ext4_ac_cachep, ac);
|
2009-01-22 18:13:05 +01:00
|
|
|
if (inquota && ar->len < inquota)
|
2011-09-10 00:48:51 +02:00
|
|
|
dquot_free_block(ar->inode, EXT4_C2B(sbi, inquota - ar->len));
|
2009-01-06 03:49:12 +01:00
|
|
|
if (!ar->len) {
|
2011-01-10 18:12:36 +01:00
|
|
|
if (!ext4_test_inode_state(ar->inode,
|
|
|
|
EXT4_STATE_DELALLOC_RESERVED))
|
2009-01-06 03:49:12 +01:00
|
|
|
/* release all the reserved blocks if non delalloc */
|
2011-09-10 00:56:51 +02:00
|
|
|
percpu_counter_sub(&sbi->s_dirtyclusters_counter,
|
2011-09-10 00:48:51 +02:00
|
|
|
reserv_clstrs);
|
2009-01-06 03:49:12 +01:00
|
|
|
}
|
2008-01-29 06:19:52 +01:00
|
|
|
|
2009-06-17 17:48:11 +02:00
|
|
|
trace_ext4_allocate_blocks(ar, (unsigned long long)block);
|
2009-01-04 02:03:21 +01:00
|
|
|
|
2008-01-29 06:19:52 +01:00
|
|
|
return block;
|
|
|
|
}
|
|
|
|
|
2008-10-16 16:14:27 +02:00
|
|
|
/*
|
|
|
|
* We can merge two free data extents only if the physical blocks
|
|
|
|
* are contiguous, AND the extents were freed by the same transaction,
|
|
|
|
* AND the blocks are associated with the same group.
|
|
|
|
*/
|
|
|
|
static int can_merge(struct ext4_free_data *entry1,
|
|
|
|
struct ext4_free_data *entry2)
|
|
|
|
{
|
2012-02-20 23:53:02 +01:00
|
|
|
if ((entry1->efd_tid == entry2->efd_tid) &&
|
|
|
|
(entry1->efd_group == entry2->efd_group) &&
|
|
|
|
((entry1->efd_start_cluster + entry1->efd_count) == entry2->efd_start_cluster))
|
2008-10-16 16:14:27 +02:00
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-04-29 14:11:12 +02:00
|
|
|
static noinline_for_stack int
|
|
|
|
ext4_mb_free_metadata(handle_t *handle, struct ext4_buddy *e4b,
|
2009-01-06 03:36:55 +01:00
|
|
|
struct ext4_free_data *new_entry)
|
2008-01-29 06:19:52 +01:00
|
|
|
{
|
2010-06-29 18:54:28 +02:00
|
|
|
ext4_group_t group = e4b->bd_group;
|
2011-09-10 00:50:51 +02:00
|
|
|
ext4_grpblk_t cluster;
|
2009-01-06 03:36:55 +01:00
|
|
|
struct ext4_free_data *entry;
|
2008-01-29 06:19:52 +01:00
|
|
|
struct ext4_group_info *db = e4b->bd_info;
|
|
|
|
struct super_block *sb = e4b->bd_sb;
|
|
|
|
struct ext4_sb_info *sbi = EXT4_SB(sb);
|
2008-10-16 16:14:27 +02:00
|
|
|
struct rb_node **n = &db->bb_free_root.rb_node, *node;
|
|
|
|
struct rb_node *parent = NULL, *new_node;
|
|
|
|
|
2009-01-07 06:06:22 +01:00
|
|
|
BUG_ON(!ext4_handle_valid(handle));
|
2008-01-29 06:19:52 +01:00
|
|
|
BUG_ON(e4b->bd_bitmap_page == NULL);
|
|
|
|
BUG_ON(e4b->bd_buddy_page == NULL);
|
|
|
|
|
2012-02-20 23:53:02 +01:00
|
|
|
new_node = &new_entry->efd_node;
|
|
|
|
cluster = new_entry->efd_start_cluster;
|
2008-10-16 16:14:27 +02:00
|
|
|
|
|
|
|
if (!*n) {
|
|
|
|
/* first free block exent. We need to
|
|
|
|
protect buddy cache from being freed,
|
|
|
|
* otherwise we'll refresh it from
|
|
|
|
* on-disk bitmap and lose not-yet-available
|
|
|
|
* blocks */
|
|
|
|
page_cache_get(e4b->bd_buddy_page);
|
|
|
|
page_cache_get(e4b->bd_bitmap_page);
|
|
|
|
}
|
|
|
|
while (*n) {
|
|
|
|
parent = *n;
|
2012-02-20 23:53:02 +01:00
|
|
|
entry = rb_entry(parent, struct ext4_free_data, efd_node);
|
|
|
|
if (cluster < entry->efd_start_cluster)
|
2008-10-16 16:14:27 +02:00
|
|
|
n = &(*n)->rb_left;
|
2012-02-20 23:53:02 +01:00
|
|
|
else if (cluster >= (entry->efd_start_cluster + entry->efd_count))
|
2008-10-16 16:14:27 +02:00
|
|
|
n = &(*n)->rb_right;
|
|
|
|
else {
|
2010-06-29 18:54:28 +02:00
|
|
|
ext4_grp_locked_error(sb, group, 0,
|
2011-09-10 00:50:51 +02:00
|
|
|
ext4_group_first_block_no(sb, group) +
|
|
|
|
EXT4_C2B(sbi, cluster),
|
2010-06-29 18:54:28 +02:00
|
|
|
"Block already on to-be-freed list");
|
2008-10-16 16:14:27 +02:00
|
|
|
return 0;
|
2008-01-29 06:19:52 +01:00
|
|
|
}
|
2008-10-16 16:14:27 +02:00
|
|
|
}
|
2008-01-29 06:19:52 +01:00
|
|
|
|
2008-10-16 16:14:27 +02:00
|
|
|
rb_link_node(new_node, parent, n);
|
|
|
|
rb_insert_color(new_node, &db->bb_free_root);
|
|
|
|
|
|
|
|
/* Now try to see the extent can be merged to left and right */
|
|
|
|
node = rb_prev(new_node);
|
|
|
|
if (node) {
|
2012-02-20 23:53:02 +01:00
|
|
|
entry = rb_entry(node, struct ext4_free_data, efd_node);
|
2013-04-04 04:08:52 +02:00
|
|
|
if (can_merge(entry, new_entry) &&
|
|
|
|
ext4_journal_callback_try_del(handle, &entry->efd_jce)) {
|
2012-02-20 23:53:02 +01:00
|
|
|
new_entry->efd_start_cluster = entry->efd_start_cluster;
|
|
|
|
new_entry->efd_count += entry->efd_count;
|
2008-10-16 16:14:27 +02:00
|
|
|
rb_erase(node, &(db->bb_free_root));
|
2012-02-20 23:53:02 +01:00
|
|
|
kmem_cache_free(ext4_free_data_cachep, entry);
|
2008-01-29 06:19:52 +01:00
|
|
|
}
|
2008-10-16 16:14:27 +02:00
|
|
|
}
|
2008-01-29 06:19:52 +01:00
|
|
|
|
2008-10-16 16:14:27 +02:00
|
|
|
node = rb_next(new_node);
|
|
|
|
if (node) {
|
2012-02-20 23:53:02 +01:00
|
|
|
entry = rb_entry(node, struct ext4_free_data, efd_node);
|
2013-04-04 04:08:52 +02:00
|
|
|
if (can_merge(new_entry, entry) &&
|
|
|
|
ext4_journal_callback_try_del(handle, &entry->efd_jce)) {
|
2012-02-20 23:53:02 +01:00
|
|
|
new_entry->efd_count += entry->efd_count;
|
2008-10-16 16:14:27 +02:00
|
|
|
rb_erase(node, &(db->bb_free_root));
|
2012-02-20 23:53:02 +01:00
|
|
|
kmem_cache_free(ext4_free_data_cachep, entry);
|
2008-01-29 06:19:52 +01:00
|
|
|
}
|
|
|
|
}
|
2008-10-17 02:00:24 +02:00
|
|
|
/* Add the extent to transaction's private list */
|
2012-02-20 23:53:02 +01:00
|
|
|
ext4_journal_callback_add(handle, ext4_free_data_callback,
|
|
|
|
&new_entry->efd_jce);
|
2008-01-29 06:19:52 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-11-22 13:44:56 +01:00
|
|
|
/**
|
|
|
|
* ext4_free_blocks() -- Free given blocks and update quota
|
|
|
|
* @handle: handle for this transaction
|
|
|
|
* @inode: inode
|
|
|
|
* @block: start physical block to free
|
|
|
|
* @count: number of blocks to count
|
2011-06-06 05:26:40 +02:00
|
|
|
* @flags: flags used by ext4_free_blocks
|
2008-01-29 06:19:52 +01:00
|
|
|
*/
|
2009-11-22 13:44:56 +01:00
|
|
|
void ext4_free_blocks(handle_t *handle, struct inode *inode,
|
2009-11-23 13:17:05 +01:00
|
|
|
struct buffer_head *bh, ext4_fsblk_t block,
|
|
|
|
unsigned long count, int flags)
|
2008-01-29 06:19:52 +01:00
|
|
|
{
|
2008-02-10 07:10:04 +01:00
|
|
|
struct buffer_head *bitmap_bh = NULL;
|
2008-01-29 06:19:52 +01:00
|
|
|
struct super_block *sb = inode->i_sb;
|
|
|
|
struct ext4_group_desc *gdp;
|
2008-11-05 06:14:04 +01:00
|
|
|
unsigned int overflow;
|
2008-01-29 06:19:52 +01:00
|
|
|
ext4_grpblk_t bit;
|
|
|
|
struct buffer_head *gd_bh;
|
|
|
|
ext4_group_t block_group;
|
|
|
|
struct ext4_sb_info *sbi;
|
2013-08-17 15:36:54 +02:00
|
|
|
struct ext4_inode_info *ei = EXT4_I(inode);
|
2008-01-29 06:19:52 +01:00
|
|
|
struct ext4_buddy e4b;
|
2011-09-10 00:50:51 +02:00
|
|
|
unsigned int count_clusters;
|
2008-01-29 06:19:52 +01:00
|
|
|
int err = 0;
|
|
|
|
int ret;
|
|
|
|
|
2013-04-04 04:00:52 +02:00
|
|
|
might_sleep();
|
2009-11-23 13:17:05 +01:00
|
|
|
if (bh) {
|
|
|
|
if (block)
|
|
|
|
BUG_ON(block != bh->b_blocknr);
|
|
|
|
else
|
|
|
|
block = bh->b_blocknr;
|
|
|
|
}
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
sbi = EXT4_SB(sb);
|
ext4: Add block validity check when truncating indirect block mapped inodes
Add checks to ext4_free_branches() to make sure a block number found
in an indirect block are valid before trying to free it. If a bad
block number is found, stop freeing the indirect block immediately,
since the file system is corrupt and we will need to run fsck anyway.
This also avoids spamming the logs, and specifically avoids
driver-level "attempt to access beyond end of device" errors obscure
what is really going on.
If you get *really*, *really*, *really* unlucky, without this patch, a
supposed indirect block containing garbage might contain a reference
to a primary block group descriptor, in which case
ext4_free_branches() could end up zero'ing out a block group
descriptor block, and if then one of the block bitmaps for a block
group described by that bg descriptor block is not in memory, and is
read in by ext4_read_block_bitmap(). This function calls
ext4_valid_block_bitmap(), which assumes that bg_inode_table() was
validated at mount time and hasn't been modified since. Since this
assumption is no longer valid, it's possible for the value
(ext4_inode_table(sb, desc) - group_first_block) to go negative, which
will cause ext4_find_next_zero_bit() to trigger a kernel GPF.
Addresses-Google-Bug: #2220436
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2010-01-22 23:40:42 +01:00
|
|
|
if (!(flags & EXT4_FREE_BLOCKS_VALIDATED) &&
|
|
|
|
!ext4_data_block_valid(sbi, block, count)) {
|
2010-02-15 20:19:27 +01:00
|
|
|
ext4_error(sb, "Freeing blocks not in datazone - "
|
ext4: Add block validity check when truncating indirect block mapped inodes
Add checks to ext4_free_branches() to make sure a block number found
in an indirect block are valid before trying to free it. If a bad
block number is found, stop freeing the indirect block immediately,
since the file system is corrupt and we will need to run fsck anyway.
This also avoids spamming the logs, and specifically avoids
driver-level "attempt to access beyond end of device" errors obscure
what is really going on.
If you get *really*, *really*, *really* unlucky, without this patch, a
supposed indirect block containing garbage might contain a reference
to a primary block group descriptor, in which case
ext4_free_branches() could end up zero'ing out a block group
descriptor block, and if then one of the block bitmaps for a block
group described by that bg descriptor block is not in memory, and is
read in by ext4_read_block_bitmap(). This function calls
ext4_valid_block_bitmap(), which assumes that bg_inode_table() was
validated at mount time and hasn't been modified since. Since this
assumption is no longer valid, it's possible for the value
(ext4_inode_table(sb, desc) - group_first_block) to go negative, which
will cause ext4_find_next_zero_bit() to trigger a kernel GPF.
Addresses-Google-Bug: #2220436
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2010-01-22 23:40:42 +01:00
|
|
|
"block = %llu, count = %lu", block, count);
|
2008-01-29 06:19:52 +01:00
|
|
|
goto error_return;
|
|
|
|
}
|
|
|
|
|
2009-06-15 09:45:05 +02:00
|
|
|
ext4_debug("freeing block %llu\n", block);
|
2009-11-23 13:17:05 +01:00
|
|
|
trace_ext4_free_blocks(inode, block, count, flags);
|
|
|
|
|
|
|
|
if (flags & EXT4_FREE_BLOCKS_FORGET) {
|
|
|
|
struct buffer_head *tbh = bh;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
BUG_ON(bh && (count > 1));
|
|
|
|
|
|
|
|
for (i = 0; i < count; i++) {
|
2013-06-12 17:43:02 +02:00
|
|
|
cond_resched();
|
2009-11-23 13:17:05 +01:00
|
|
|
if (!bh)
|
|
|
|
tbh = sb_find_get_block(inode->i_sb,
|
|
|
|
block + i);
|
2013-06-12 17:43:02 +02:00
|
|
|
if (!tbh)
|
2010-10-28 03:30:11 +02:00
|
|
|
continue;
|
2010-05-17 13:00:00 +02:00
|
|
|
ext4_forget(handle, flags & EXT4_FREE_BLOCKS_METADATA,
|
2009-11-23 13:17:05 +01:00
|
|
|
inode, tbh, block + i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-05-17 13:00:00 +02:00
|
|
|
/*
|
2009-11-23 13:17:05 +01:00
|
|
|
* We need to make sure we don't reuse the freed block until
|
|
|
|
* after the transaction is committed, which we can do by
|
|
|
|
* treating the block as metadata, below. We make an
|
|
|
|
* exception if the inode is to be written in writeback mode
|
|
|
|
* since writeback mode has weak data consistency guarantees.
|
|
|
|
*/
|
|
|
|
if (!ext4_should_writeback_data(inode))
|
|
|
|
flags |= EXT4_FREE_BLOCKS_METADATA;
|
2008-01-29 06:19:52 +01:00
|
|
|
|
2011-09-10 00:50:51 +02:00
|
|
|
/*
|
|
|
|
* If the extent to be freed does not begin on a cluster
|
|
|
|
* boundary, we need to deal with partial clusters at the
|
|
|
|
* beginning and end of the extent. Normally we will free
|
|
|
|
* blocks at the beginning or the end unless we are explicitly
|
|
|
|
* requested to avoid doing so.
|
|
|
|
*/
|
2013-12-20 15:29:35 +01:00
|
|
|
overflow = EXT4_PBLK_COFF(sbi, block);
|
2011-09-10 00:50:51 +02:00
|
|
|
if (overflow) {
|
|
|
|
if (flags & EXT4_FREE_BLOCKS_NOFREE_FIRST_CLUSTER) {
|
|
|
|
overflow = sbi->s_cluster_ratio - overflow;
|
|
|
|
block += overflow;
|
|
|
|
if (count > overflow)
|
|
|
|
count -= overflow;
|
|
|
|
else
|
|
|
|
return;
|
|
|
|
} else {
|
|
|
|
block -= overflow;
|
|
|
|
count += overflow;
|
|
|
|
}
|
|
|
|
}
|
2013-12-20 15:29:35 +01:00
|
|
|
overflow = EXT4_LBLK_COFF(sbi, count);
|
2011-09-10 00:50:51 +02:00
|
|
|
if (overflow) {
|
|
|
|
if (flags & EXT4_FREE_BLOCKS_NOFREE_LAST_CLUSTER) {
|
|
|
|
if (count > overflow)
|
|
|
|
count -= overflow;
|
|
|
|
else
|
|
|
|
return;
|
|
|
|
} else
|
|
|
|
count += sbi->s_cluster_ratio - overflow;
|
|
|
|
}
|
|
|
|
|
2008-01-29 06:19:52 +01:00
|
|
|
do_more:
|
|
|
|
overflow = 0;
|
|
|
|
ext4_get_group_no_and_offset(sb, block, &block_group, &bit);
|
|
|
|
|
ext4: mark block group as corrupt on block bitmap error
When we notice a block-bitmap corruption (because of device failure or
something else), we should mark this group as corrupt and prevent
further block allocations/deallocations from it. Currently, we end up
generating one error message for every block in the bitmap. This
potentially could make the system unstable as noticed in some
bugs. With this patch, the error will be printed only the first time
and mark the entire block group as corrupted. This prevents future
access allocations/deallocations from it.
Also tested by corrupting the block
bitmap and forcefully introducing the mb_free_blocks error:
(1) create a largefile (2Gb)
$ dd if=/dev/zero of=largefile oflag=direct bs=10485760 count=200
(2) umount filesystem. use dumpe2fs to see which block-bitmaps
are in use by largefile and note their block numbers
(3) use dd to zero-out the used block bitmaps
$ dd if=/dev/zero of=/dev/hdc4 bs=4096 seek=14 count=8 oflag=direct
(4) mount the FS and delete the largefile.
(5) recreate the largefile. verify that the new largefile does not
get any blocks from the groups marked as bad.
Without the patch, we will see mb_free_blocks error for each bit in
each zero'ed out bitmap at (4). With the patch, we only see the error
once per blockgroup:
[ 309.706803] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 15: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
[ 309.720824] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 14: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
[ 309.732858] EXT4-fs error (device sdb4) in ext4_free_blocks:4802: IO failure
[ 309.748321] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 13: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
[ 309.760331] EXT4-fs error (device sdb4) in ext4_free_blocks:4802: IO failure
[ 309.769695] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 12: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
[ 309.781721] EXT4-fs error (device sdb4) in ext4_free_blocks:4802: IO failure
[ 309.798166] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 11: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
[ 309.810184] EXT4-fs error (device sdb4) in ext4_free_blocks:4802: IO failure
[ 309.819532] EXT4-fs error (device sdb4): ext4_mb_generate_buddy:735: group 10: 32768 clusters in bitmap, 0 in gd. blk grp corrupted.
Google-Bug-Id: 7258357
[darrick.wong@oracle.com]
Further modifications (by Darrick) to make more obvious that this corruption
bit applies to blocks only. Set the corruption flag if the block group bitmap
verification fails.
Original-author: Aditya Kali <adityakali@google.com>
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2013-08-28 23:35:51 +02:00
|
|
|
if (unlikely(EXT4_MB_GRP_BBITMAP_CORRUPT(
|
|
|
|
ext4_get_group_info(sb, block_group))))
|
|
|
|
return;
|
|
|
|
|
2008-01-29 06:19:52 +01:00
|
|
|
/*
|
|
|
|
* Check to see if we are freeing blocks across a group
|
|
|
|
* boundary.
|
|
|
|
*/
|
2011-09-10 00:50:51 +02:00
|
|
|
if (EXT4_C2B(sbi, bit) + count > EXT4_BLOCKS_PER_GROUP(sb)) {
|
|
|
|
overflow = EXT4_C2B(sbi, bit) + count -
|
|
|
|
EXT4_BLOCKS_PER_GROUP(sb);
|
2008-01-29 06:19:52 +01:00
|
|
|
count -= overflow;
|
|
|
|
}
|
2013-03-02 23:18:58 +01:00
|
|
|
count_clusters = EXT4_NUM_B2C(sbi, count);
|
2008-07-12 01:27:31 +02:00
|
|
|
bitmap_bh = ext4_read_block_bitmap(sb, block_group);
|
2008-07-23 20:09:29 +02:00
|
|
|
if (!bitmap_bh) {
|
|
|
|
err = -EIO;
|
2008-01-29 06:19:52 +01:00
|
|
|
goto error_return;
|
2008-07-23 20:09:29 +02:00
|
|
|
}
|
2008-01-29 06:19:52 +01:00
|
|
|
gdp = ext4_get_group_desc(sb, block_group, &gd_bh);
|
2008-07-23 20:09:29 +02:00
|
|
|
if (!gdp) {
|
|
|
|
err = -EIO;
|
2008-01-29 06:19:52 +01:00
|
|
|
goto error_return;
|
2008-07-23 20:09:29 +02:00
|
|
|
}
|
2008-01-29 06:19:52 +01:00
|
|
|
|
|
|
|
if (in_range(ext4_block_bitmap(sb, gdp), block, count) ||
|
|
|
|
in_range(ext4_inode_bitmap(sb, gdp), block, count) ||
|
|
|
|
in_range(block, ext4_inode_table(sb, gdp),
|
2011-09-10 00:50:51 +02:00
|
|
|
EXT4_SB(sb)->s_itb_per_group) ||
|
2008-01-29 06:19:52 +01:00
|
|
|
in_range(block + count - 1, ext4_inode_table(sb, gdp),
|
2011-09-10 00:50:51 +02:00
|
|
|
EXT4_SB(sb)->s_itb_per_group)) {
|
2008-01-29 06:19:52 +01:00
|
|
|
|
2010-02-15 20:19:27 +01:00
|
|
|
ext4_error(sb, "Freeing blocks in system zone - "
|
2009-06-15 09:45:05 +02:00
|
|
|
"Block = %llu, count = %lu", block, count);
|
2008-05-15 20:43:20 +02:00
|
|
|
/* err = 0. ext4_std_error should be a no op */
|
|
|
|
goto error_return;
|
2008-01-29 06:19:52 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
BUFFER_TRACE(bitmap_bh, "getting write access");
|
|
|
|
err = ext4_journal_get_write_access(handle, bitmap_bh);
|
|
|
|
if (err)
|
|
|
|
goto error_return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We are about to modify some metadata. Call the journal APIs
|
|
|
|
* to unshare ->b_data if a currently-committing transaction is
|
|
|
|
* using it
|
|
|
|
*/
|
|
|
|
BUFFER_TRACE(gd_bh, "get_write_access");
|
|
|
|
err = ext4_journal_get_write_access(handle, gd_bh);
|
|
|
|
if (err)
|
|
|
|
goto error_return;
|
|
|
|
#ifdef AGGRESSIVE_CHECK
|
|
|
|
{
|
|
|
|
int i;
|
2011-09-10 00:50:51 +02:00
|
|
|
for (i = 0; i < count_clusters; i++)
|
2008-01-29 06:19:52 +01:00
|
|
|
BUG_ON(!mb_test_bit(bit + i, bitmap_bh->b_data));
|
|
|
|
}
|
|
|
|
#endif
|
2011-09-10 00:50:51 +02:00
|
|
|
trace_ext4_mballoc_free(sb, inode, block_group, bit, count_clusters);
|
2008-01-29 06:19:52 +01:00
|
|
|
|
2009-01-06 03:36:19 +01:00
|
|
|
err = ext4_mb_load_buddy(sb, block_group, &e4b);
|
|
|
|
if (err)
|
|
|
|
goto error_return;
|
2009-11-23 13:17:05 +01:00
|
|
|
|
|
|
|
if ((flags & EXT4_FREE_BLOCKS_METADATA) && ext4_handle_valid(handle)) {
|
2009-01-06 03:36:55 +01:00
|
|
|
struct ext4_free_data *new_entry;
|
|
|
|
/*
|
|
|
|
* blocks being freed are metadata. these blocks shouldn't
|
|
|
|
* be used until this transaction is committed
|
|
|
|
*/
|
2013-07-13 06:40:35 +02:00
|
|
|
retry:
|
2012-02-20 23:53:02 +01:00
|
|
|
new_entry = kmem_cache_alloc(ext4_free_data_cachep, GFP_NOFS);
|
2010-12-20 13:26:59 +01:00
|
|
|
if (!new_entry) {
|
2013-07-13 06:40:35 +02:00
|
|
|
/*
|
|
|
|
* We use a retry loop because
|
|
|
|
* ext4_free_blocks() is not allowed to fail.
|
|
|
|
*/
|
|
|
|
cond_resched();
|
|
|
|
congestion_wait(BLK_RW_ASYNC, HZ/50);
|
|
|
|
goto retry;
|
2010-12-20 13:26:59 +01:00
|
|
|
}
|
2012-02-20 23:53:02 +01:00
|
|
|
new_entry->efd_start_cluster = bit;
|
|
|
|
new_entry->efd_group = block_group;
|
|
|
|
new_entry->efd_count = count_clusters;
|
|
|
|
new_entry->efd_tid = handle->h_transaction->t_tid;
|
2009-05-03 02:35:09 +02:00
|
|
|
|
2009-01-06 03:36:55 +01:00
|
|
|
ext4_lock_group(sb, block_group);
|
2011-09-10 00:50:51 +02:00
|
|
|
mb_clear_bits(bitmap_bh->b_data, bit, count_clusters);
|
2009-01-06 03:36:55 +01:00
|
|
|
ext4_mb_free_metadata(handle, &e4b, new_entry);
|
2008-01-29 06:19:52 +01:00
|
|
|
} else {
|
2009-01-06 03:36:55 +01:00
|
|
|
/* need to update group_info->bb_free and bitmap
|
|
|
|
* with group lock held. generate_buddy look at
|
|
|
|
* them with group lock_held
|
|
|
|
*/
|
2012-11-08 20:04:52 +01:00
|
|
|
if (test_opt(sb, DISCARD)) {
|
|
|
|
err = ext4_issue_discard(sb, block_group, bit, count);
|
|
|
|
if (err && err != -EOPNOTSUPP)
|
|
|
|
ext4_msg(sb, KERN_WARNING, "discard request in"
|
|
|
|
" group:%d block:%d count:%lu failed"
|
|
|
|
" with %d", block_group, bit, count,
|
|
|
|
err);
|
2013-10-30 16:10:52 +01:00
|
|
|
} else
|
|
|
|
EXT4_MB_GRP_CLEAR_TRIMMED(e4b.bd_info);
|
2012-11-08 20:04:52 +01:00
|
|
|
|
2009-05-03 02:35:09 +02:00
|
|
|
ext4_lock_group(sb, block_group);
|
2011-09-10 00:50:51 +02:00
|
|
|
mb_clear_bits(bitmap_bh->b_data, bit, count_clusters);
|
|
|
|
mb_free_blocks(inode, &e4b, bit, count_clusters);
|
2008-01-29 06:19:52 +01:00
|
|
|
}
|
|
|
|
|
2011-09-10 01:08:51 +02:00
|
|
|
ret = ext4_free_group_clusters(sb, gdp) + count_clusters;
|
|
|
|
ext4_free_group_clusters_set(sb, gdp, ret);
|
2012-10-22 06:34:32 +02:00
|
|
|
ext4_block_bitmap_csum_set(sb, block_group, gdp, bitmap_bh);
|
2012-04-30 00:45:10 +02:00
|
|
|
ext4_group_desc_csum_set(sb, block_group, gdp);
|
2009-05-03 02:35:09 +02:00
|
|
|
ext4_unlock_group(sb, block_group);
|
2008-01-29 06:19:52 +01:00
|
|
|
|
2008-07-12 01:27:31 +02:00
|
|
|
if (sbi->s_log_groups_per_flex) {
|
|
|
|
ext4_group_t flex_group = ext4_flex_group(sbi, block_group);
|
2013-03-12 04:39:59 +01:00
|
|
|
atomic64_add(count_clusters,
|
|
|
|
&sbi->s_flex_groups[flex_group].free_clusters);
|
2008-07-12 01:27:31 +02:00
|
|
|
}
|
|
|
|
|
2013-08-17 15:36:54 +02:00
|
|
|
if (flags & EXT4_FREE_BLOCKS_RESERVE && ei->i_reserved_data_blocks) {
|
|
|
|
percpu_counter_add(&sbi->s_dirtyclusters_counter,
|
|
|
|
count_clusters);
|
|
|
|
spin_lock(&ei->i_block_reservation_lock);
|
|
|
|
if (flags & EXT4_FREE_BLOCKS_METADATA)
|
|
|
|
ei->i_reserved_meta_blocks += count_clusters;
|
|
|
|
else
|
|
|
|
ei->i_reserved_data_blocks += count_clusters;
|
|
|
|
spin_unlock(&ei->i_block_reservation_lock);
|
|
|
|
if (!(flags & EXT4_FREE_BLOCKS_NO_QUOT_UPDATE))
|
|
|
|
dquot_reclaim_block(inode,
|
|
|
|
EXT4_C2B(sbi, count_clusters));
|
|
|
|
} else if (!(flags & EXT4_FREE_BLOCKS_NO_QUOT_UPDATE))
|
2011-09-10 01:04:51 +02:00
|
|
|
dquot_free_block(inode, EXT4_C2B(sbi, count_clusters));
|
2013-08-17 15:36:54 +02:00
|
|
|
percpu_counter_add(&sbi->s_freeclusters_counter, count_clusters);
|
|
|
|
|
|
|
|
ext4_mb_unload_buddy(&e4b);
|
2011-09-10 01:04:51 +02:00
|
|
|
|
2009-01-06 03:36:55 +01:00
|
|
|
/* We dirtied the bitmap block */
|
|
|
|
BUFFER_TRACE(bitmap_bh, "dirtied bitmap block");
|
|
|
|
err = ext4_handle_dirty_metadata(handle, NULL, bitmap_bh);
|
|
|
|
|
2008-01-29 06:19:52 +01:00
|
|
|
/* And the group descriptor block */
|
|
|
|
BUFFER_TRACE(gd_bh, "dirtied group descriptor block");
|
2009-01-07 06:06:22 +01:00
|
|
|
ret = ext4_handle_dirty_metadata(handle, NULL, gd_bh);
|
2008-01-29 06:19:52 +01:00
|
|
|
if (!err)
|
|
|
|
err = ret;
|
|
|
|
|
|
|
|
if (overflow && !err) {
|
|
|
|
block += count;
|
|
|
|
count = overflow;
|
|
|
|
put_bh(bitmap_bh);
|
|
|
|
goto do_more;
|
|
|
|
}
|
|
|
|
error_return:
|
|
|
|
brelse(bitmap_bh);
|
|
|
|
ext4_std_error(sb, err);
|
|
|
|
return;
|
|
|
|
}
|
2010-10-28 03:30:12 +02:00
|
|
|
|
2011-05-09 16:46:41 +02:00
|
|
|
/**
|
2011-07-27 03:43:56 +02:00
|
|
|
* ext4_group_add_blocks() -- Add given blocks to an existing group
|
2011-05-09 16:46:41 +02:00
|
|
|
* @handle: handle to this transaction
|
|
|
|
* @sb: super block
|
2012-09-01 19:31:09 +02:00
|
|
|
* @block: start physical block to add to the block group
|
2011-05-09 16:46:41 +02:00
|
|
|
* @count: number of blocks to free
|
|
|
|
*
|
2011-05-10 03:40:01 +02:00
|
|
|
* This marks the blocks as free in the bitmap and buddy.
|
2011-05-09 16:46:41 +02:00
|
|
|
*/
|
2011-07-27 03:46:07 +02:00
|
|
|
int ext4_group_add_blocks(handle_t *handle, struct super_block *sb,
|
2011-05-09 16:46:41 +02:00
|
|
|
ext4_fsblk_t block, unsigned long count)
|
|
|
|
{
|
|
|
|
struct buffer_head *bitmap_bh = NULL;
|
|
|
|
struct buffer_head *gd_bh;
|
|
|
|
ext4_group_t block_group;
|
|
|
|
ext4_grpblk_t bit;
|
|
|
|
unsigned int i;
|
|
|
|
struct ext4_group_desc *desc;
|
|
|
|
struct ext4_sb_info *sbi = EXT4_SB(sb);
|
2011-05-10 03:40:01 +02:00
|
|
|
struct ext4_buddy e4b;
|
2011-05-09 16:46:41 +02:00
|
|
|
int err = 0, ret, blk_free_count;
|
|
|
|
ext4_grpblk_t blocks_freed;
|
|
|
|
|
|
|
|
ext4_debug("Adding block(s) %llu-%llu\n", block, block + count - 1);
|
|
|
|
|
2011-07-27 03:51:08 +02:00
|
|
|
if (count == 0)
|
|
|
|
return 0;
|
|
|
|
|
2011-05-09 16:46:41 +02:00
|
|
|
ext4_get_group_no_and_offset(sb, block, &block_group, &bit);
|
|
|
|
/*
|
|
|
|
* Check to see if we are freeing blocks across a group
|
|
|
|
* boundary.
|
|
|
|
*/
|
2011-07-27 03:46:07 +02:00
|
|
|
if (bit + count > EXT4_BLOCKS_PER_GROUP(sb)) {
|
|
|
|
ext4_warning(sb, "too much blocks added to group %u\n",
|
|
|
|
block_group);
|
|
|
|
err = -EINVAL;
|
2011-05-09 16:46:41 +02:00
|
|
|
goto error_return;
|
2011-07-27 03:46:07 +02:00
|
|
|
}
|
2011-05-09 16:58:45 +02:00
|
|
|
|
2011-05-09 16:46:41 +02:00
|
|
|
bitmap_bh = ext4_read_block_bitmap(sb, block_group);
|
2011-07-27 03:46:07 +02:00
|
|
|
if (!bitmap_bh) {
|
|
|
|
err = -EIO;
|
2011-05-09 16:46:41 +02:00
|
|
|
goto error_return;
|
2011-07-27 03:46:07 +02:00
|
|
|
}
|
|
|
|
|
2011-05-09 16:46:41 +02:00
|
|
|
desc = ext4_get_group_desc(sb, block_group, &gd_bh);
|
2011-07-27 03:46:07 +02:00
|
|
|
if (!desc) {
|
|
|
|
err = -EIO;
|
2011-05-09 16:46:41 +02:00
|
|
|
goto error_return;
|
2011-07-27 03:46:07 +02:00
|
|
|
}
|
2011-05-09 16:46:41 +02:00
|
|
|
|
|
|
|
if (in_range(ext4_block_bitmap(sb, desc), block, count) ||
|
|
|
|
in_range(ext4_inode_bitmap(sb, desc), block, count) ||
|
|
|
|
in_range(block, ext4_inode_table(sb, desc), sbi->s_itb_per_group) ||
|
|
|
|
in_range(block + count - 1, ext4_inode_table(sb, desc),
|
|
|
|
sbi->s_itb_per_group)) {
|
|
|
|
ext4_error(sb, "Adding blocks in system zones - "
|
|
|
|
"Block = %llu, count = %lu",
|
|
|
|
block, count);
|
2011-07-27 03:46:07 +02:00
|
|
|
err = -EINVAL;
|
2011-05-09 16:46:41 +02:00
|
|
|
goto error_return;
|
|
|
|
}
|
|
|
|
|
2011-05-09 16:58:45 +02:00
|
|
|
BUFFER_TRACE(bitmap_bh, "getting write access");
|
|
|
|
err = ext4_journal_get_write_access(handle, bitmap_bh);
|
2011-05-09 16:46:41 +02:00
|
|
|
if (err)
|
|
|
|
goto error_return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We are about to modify some metadata. Call the journal APIs
|
|
|
|
* to unshare ->b_data if a currently-committing transaction is
|
|
|
|
* using it
|
|
|
|
*/
|
|
|
|
BUFFER_TRACE(gd_bh, "get_write_access");
|
|
|
|
err = ext4_journal_get_write_access(handle, gd_bh);
|
|
|
|
if (err)
|
|
|
|
goto error_return;
|
2011-05-10 03:40:01 +02:00
|
|
|
|
2011-05-09 16:46:41 +02:00
|
|
|
for (i = 0, blocks_freed = 0; i < count; i++) {
|
|
|
|
BUFFER_TRACE(bitmap_bh, "clear bit");
|
2011-05-10 03:40:01 +02:00
|
|
|
if (!mb_test_bit(bit + i, bitmap_bh->b_data)) {
|
2011-05-09 16:46:41 +02:00
|
|
|
ext4_error(sb, "bit already cleared for block %llu",
|
|
|
|
(ext4_fsblk_t)(block + i));
|
|
|
|
BUFFER_TRACE(bitmap_bh, "bit already cleared");
|
|
|
|
} else {
|
|
|
|
blocks_freed++;
|
|
|
|
}
|
|
|
|
}
|
2011-05-10 03:40:01 +02:00
|
|
|
|
|
|
|
err = ext4_mb_load_buddy(sb, block_group, &e4b);
|
|
|
|
if (err)
|
|
|
|
goto error_return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* need to update group_info->bb_free and bitmap
|
|
|
|
* with group lock held. generate_buddy look at
|
|
|
|
* them with group lock_held
|
|
|
|
*/
|
2011-05-09 16:46:41 +02:00
|
|
|
ext4_lock_group(sb, block_group);
|
2011-05-10 03:40:01 +02:00
|
|
|
mb_clear_bits(bitmap_bh->b_data, bit, count);
|
|
|
|
mb_free_blocks(NULL, &e4b, bit, count);
|
2011-09-10 01:08:51 +02:00
|
|
|
blk_free_count = blocks_freed + ext4_free_group_clusters(sb, desc);
|
|
|
|
ext4_free_group_clusters_set(sb, desc, blk_free_count);
|
2012-10-22 06:34:32 +02:00
|
|
|
ext4_block_bitmap_csum_set(sb, block_group, desc, bitmap_bh);
|
2012-04-30 00:45:10 +02:00
|
|
|
ext4_group_desc_csum_set(sb, block_group, desc);
|
2011-05-09 16:46:41 +02:00
|
|
|
ext4_unlock_group(sb, block_group);
|
2011-09-10 00:56:51 +02:00
|
|
|
percpu_counter_add(&sbi->s_freeclusters_counter,
|
2013-03-02 23:18:58 +01:00
|
|
|
EXT4_NUM_B2C(sbi, blocks_freed));
|
2011-05-09 16:46:41 +02:00
|
|
|
|
|
|
|
if (sbi->s_log_groups_per_flex) {
|
|
|
|
ext4_group_t flex_group = ext4_flex_group(sbi, block_group);
|
2013-03-12 04:39:59 +01:00
|
|
|
atomic64_add(EXT4_NUM_B2C(sbi, blocks_freed),
|
|
|
|
&sbi->s_flex_groups[flex_group].free_clusters);
|
2011-05-09 16:46:41 +02:00
|
|
|
}
|
2011-05-10 03:40:01 +02:00
|
|
|
|
|
|
|
ext4_mb_unload_buddy(&e4b);
|
2011-05-09 16:46:41 +02:00
|
|
|
|
|
|
|
/* We dirtied the bitmap block */
|
|
|
|
BUFFER_TRACE(bitmap_bh, "dirtied bitmap block");
|
|
|
|
err = ext4_handle_dirty_metadata(handle, NULL, bitmap_bh);
|
|
|
|
|
|
|
|
/* And the group descriptor block */
|
|
|
|
BUFFER_TRACE(gd_bh, "dirtied group descriptor block");
|
|
|
|
ret = ext4_handle_dirty_metadata(handle, NULL, gd_bh);
|
|
|
|
if (!err)
|
|
|
|
err = ret;
|
|
|
|
|
|
|
|
error_return:
|
|
|
|
brelse(bitmap_bh);
|
|
|
|
ext4_std_error(sb, err);
|
2011-07-27 03:46:07 +02:00
|
|
|
return err;
|
2011-05-09 16:46:41 +02:00
|
|
|
}
|
|
|
|
|
2010-10-28 03:30:12 +02:00
|
|
|
/**
|
|
|
|
* ext4_trim_extent -- function to TRIM one single free extent in the group
|
|
|
|
* @sb: super block for the file system
|
|
|
|
* @start: starting block of the free extent in the alloc. group
|
|
|
|
* @count: number of blocks to TRIM
|
|
|
|
* @group: alloc. group we are working with
|
|
|
|
* @e4b: ext4 buddy for the group
|
|
|
|
*
|
|
|
|
* Trim "count" blocks starting at "start" in the "group". To assure that no
|
|
|
|
* one will allocate those blocks, mark it as used in buddy bitmap. This must
|
|
|
|
* be called with under the group lock.
|
|
|
|
*/
|
2012-11-08 20:04:52 +01:00
|
|
|
static int ext4_trim_extent(struct super_block *sb, int start, int count,
|
2011-04-30 19:47:24 +02:00
|
|
|
ext4_group_t group, struct ext4_buddy *e4b)
|
2010-10-28 03:30:12 +02:00
|
|
|
{
|
|
|
|
struct ext4_free_extent ex;
|
2012-11-08 20:04:52 +01:00
|
|
|
int ret = 0;
|
2010-10-28 03:30:12 +02:00
|
|
|
|
2011-07-11 06:01:52 +02:00
|
|
|
trace_ext4_trim_extent(sb, group, start, count);
|
|
|
|
|
2010-10-28 03:30:12 +02:00
|
|
|
assert_spin_locked(ext4_group_lock_ptr(sb, group));
|
|
|
|
|
|
|
|
ex.fe_start = start;
|
|
|
|
ex.fe_group = group;
|
|
|
|
ex.fe_len = count;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Mark blocks used, so no one can reuse them while
|
|
|
|
* being trimmed.
|
|
|
|
*/
|
|
|
|
mb_mark_used(e4b, &ex);
|
|
|
|
ext4_unlock_group(sb, group);
|
2012-11-08 20:04:52 +01:00
|
|
|
ret = ext4_issue_discard(sb, group, start, count);
|
2010-10-28 03:30:12 +02:00
|
|
|
ext4_lock_group(sb, group);
|
|
|
|
mb_free_blocks(NULL, e4b, start, ex.fe_len);
|
2012-11-08 20:04:52 +01:00
|
|
|
return ret;
|
2010-10-28 03:30:12 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ext4_trim_all_free -- function to trim all free space in alloc. group
|
|
|
|
* @sb: super block for file system
|
2011-07-11 06:04:34 +02:00
|
|
|
* @group: group to be trimmed
|
2010-10-28 03:30:12 +02:00
|
|
|
* @start: first group block to examine
|
|
|
|
* @max: last group block to examine
|
|
|
|
* @minblocks: minimum extent block count
|
|
|
|
*
|
|
|
|
* ext4_trim_all_free walks through group's buddy bitmap searching for free
|
|
|
|
* extents. When the free block is found, ext4_trim_extent is called to TRIM
|
|
|
|
* the extent.
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* ext4_trim_all_free walks through group's block bitmap searching for free
|
|
|
|
* extents. When the free extent is found, mark it as used in group buddy
|
|
|
|
* bitmap. Then issue a TRIM command on this extent and free the extent in
|
|
|
|
* the group buddy bitmap. This is done until whole group is scanned.
|
|
|
|
*/
|
2011-02-23 18:22:49 +01:00
|
|
|
static ext4_grpblk_t
|
2011-05-25 00:16:27 +02:00
|
|
|
ext4_trim_all_free(struct super_block *sb, ext4_group_t group,
|
|
|
|
ext4_grpblk_t start, ext4_grpblk_t max,
|
|
|
|
ext4_grpblk_t minblocks)
|
2010-10-28 03:30:12 +02:00
|
|
|
{
|
|
|
|
void *bitmap;
|
2011-07-11 06:00:07 +02:00
|
|
|
ext4_grpblk_t next, count = 0, free_count = 0;
|
2011-05-25 00:16:27 +02:00
|
|
|
struct ext4_buddy e4b;
|
2012-11-08 20:04:52 +01:00
|
|
|
int ret = 0;
|
2010-10-28 03:30:12 +02:00
|
|
|
|
2011-07-11 06:01:52 +02:00
|
|
|
trace_ext4_trim_all_free(sb, group, start, max);
|
|
|
|
|
2011-05-25 00:16:27 +02:00
|
|
|
ret = ext4_mb_load_buddy(sb, group, &e4b);
|
|
|
|
if (ret) {
|
|
|
|
ext4_error(sb, "Error in loading buddy "
|
|
|
|
"information for %u", group);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
bitmap = e4b.bd_bitmap;
|
2011-05-25 00:28:07 +02:00
|
|
|
|
|
|
|
ext4_lock_group(sb, group);
|
2011-07-11 06:03:38 +02:00
|
|
|
if (EXT4_MB_GRP_WAS_TRIMMED(e4b.bd_info) &&
|
|
|
|
minblocks >= atomic_read(&EXT4_SB(sb)->s_last_trim_minblks))
|
|
|
|
goto out;
|
|
|
|
|
2011-05-25 00:16:27 +02:00
|
|
|
start = (e4b.bd_info->bb_first_free > start) ?
|
|
|
|
e4b.bd_info->bb_first_free : start;
|
2010-10-28 03:30:12 +02:00
|
|
|
|
2012-03-22 02:22:22 +01:00
|
|
|
while (start <= max) {
|
|
|
|
start = mb_find_next_zero_bit(bitmap, max + 1, start);
|
|
|
|
if (start > max)
|
2010-10-28 03:30:12 +02:00
|
|
|
break;
|
2012-03-22 02:22:22 +01:00
|
|
|
next = mb_find_next_bit(bitmap, max + 1, start);
|
2010-10-28 03:30:12 +02:00
|
|
|
|
|
|
|
if ((next - start) >= minblocks) {
|
2012-11-08 20:04:52 +01:00
|
|
|
ret = ext4_trim_extent(sb, start,
|
|
|
|
next - start, group, &e4b);
|
|
|
|
if (ret && ret != -EOPNOTSUPP)
|
|
|
|
break;
|
|
|
|
ret = 0;
|
2010-10-28 03:30:12 +02:00
|
|
|
count += next - start;
|
|
|
|
}
|
2011-07-11 06:00:07 +02:00
|
|
|
free_count += next - start;
|
2010-10-28 03:30:12 +02:00
|
|
|
start = next + 1;
|
|
|
|
|
|
|
|
if (fatal_signal_pending(current)) {
|
|
|
|
count = -ERESTARTSYS;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (need_resched()) {
|
|
|
|
ext4_unlock_group(sb, group);
|
|
|
|
cond_resched();
|
|
|
|
ext4_lock_group(sb, group);
|
|
|
|
}
|
|
|
|
|
2011-07-11 06:00:07 +02:00
|
|
|
if ((e4b.bd_info->bb_free - free_count) < minblocks)
|
2010-10-28 03:30:12 +02:00
|
|
|
break;
|
|
|
|
}
|
2011-07-11 06:03:38 +02:00
|
|
|
|
2012-11-08 20:04:52 +01:00
|
|
|
if (!ret) {
|
|
|
|
ret = count;
|
2011-07-11 06:03:38 +02:00
|
|
|
EXT4_MB_GRP_SET_TRIMMED(e4b.bd_info);
|
2012-11-08 20:04:52 +01:00
|
|
|
}
|
2011-07-11 06:03:38 +02:00
|
|
|
out:
|
2010-10-28 03:30:12 +02:00
|
|
|
ext4_unlock_group(sb, group);
|
2011-05-25 00:16:27 +02:00
|
|
|
ext4_mb_unload_buddy(&e4b);
|
2010-10-28 03:30:12 +02:00
|
|
|
|
|
|
|
ext4_debug("trimmed %d blocks in the group %d\n",
|
|
|
|
count, group);
|
|
|
|
|
2012-11-08 20:04:52 +01:00
|
|
|
return ret;
|
2010-10-28 03:30:12 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ext4_trim_fs() -- trim ioctl handle function
|
|
|
|
* @sb: superblock for filesystem
|
|
|
|
* @range: fstrim_range structure
|
|
|
|
*
|
|
|
|
* start: First Byte to trim
|
|
|
|
* len: number of Bytes to trim from start
|
|
|
|
* minlen: minimum extent length in Bytes
|
|
|
|
* ext4_trim_fs goes through all allocation groups containing Bytes from
|
|
|
|
* start to start+len. For each such a group ext4_trim_all_free function
|
|
|
|
* is invoked to trim all free space.
|
|
|
|
*/
|
|
|
|
int ext4_trim_fs(struct super_block *sb, struct fstrim_range *range)
|
|
|
|
{
|
2011-05-25 00:16:27 +02:00
|
|
|
struct ext4_group_info *grp;
|
2012-03-22 02:22:22 +01:00
|
|
|
ext4_group_t group, first_group, last_group;
|
2011-09-10 00:38:51 +02:00
|
|
|
ext4_grpblk_t cnt = 0, first_cluster, last_cluster;
|
2012-03-22 02:22:22 +01:00
|
|
|
uint64_t start, end, minlen, trimmed = 0;
|
2011-01-11 21:16:31 +01:00
|
|
|
ext4_fsblk_t first_data_blk =
|
|
|
|
le32_to_cpu(EXT4_SB(sb)->s_es->s_first_data_block);
|
2012-03-22 02:22:22 +01:00
|
|
|
ext4_fsblk_t max_blks = ext4_blocks_count(EXT4_SB(sb)->s_es);
|
2010-10-28 03:30:12 +02:00
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
start = range->start >> sb->s_blocksize_bits;
|
2012-03-22 02:22:22 +01:00
|
|
|
end = start + (range->len >> sb->s_blocksize_bits) - 1;
|
2012-09-27 04:21:21 +02:00
|
|
|
minlen = EXT4_NUM_B2C(EXT4_SB(sb),
|
|
|
|
range->minlen >> sb->s_blocksize_bits);
|
2010-10-28 03:30:12 +02:00
|
|
|
|
2012-10-23 00:01:19 +02:00
|
|
|
if (minlen > EXT4_CLUSTERS_PER_GROUP(sb) ||
|
|
|
|
start >= max_blks ||
|
|
|
|
range->len < sb->s_blocksize)
|
2010-10-28 03:30:12 +02:00
|
|
|
return -EINVAL;
|
2012-03-22 02:22:22 +01:00
|
|
|
if (end >= max_blks)
|
|
|
|
end = max_blks - 1;
|
|
|
|
if (end <= first_data_blk)
|
2011-07-11 05:52:37 +02:00
|
|
|
goto out;
|
2012-03-22 02:22:22 +01:00
|
|
|
if (start < first_data_blk)
|
2011-01-11 21:16:31 +01:00
|
|
|
start = first_data_blk;
|
2010-10-28 03:30:12 +02:00
|
|
|
|
2012-03-22 02:22:22 +01:00
|
|
|
/* Determine first and last group to examine based on start and end */
|
2010-10-28 03:30:12 +02:00
|
|
|
ext4_get_group_no_and_offset(sb, (ext4_fsblk_t) start,
|
2011-09-10 00:38:51 +02:00
|
|
|
&first_group, &first_cluster);
|
2012-03-22 02:22:22 +01:00
|
|
|
ext4_get_group_no_and_offset(sb, (ext4_fsblk_t) end,
|
2011-09-10 00:38:51 +02:00
|
|
|
&last_group, &last_cluster);
|
2010-10-28 03:30:12 +02:00
|
|
|
|
2012-03-22 02:22:22 +01:00
|
|
|
/* end now represents the last cluster to discard in this group */
|
|
|
|
end = EXT4_CLUSTERS_PER_GROUP(sb) - 1;
|
2010-10-28 03:30:12 +02:00
|
|
|
|
|
|
|
for (group = first_group; group <= last_group; group++) {
|
2011-05-25 00:16:27 +02:00
|
|
|
grp = ext4_get_group_info(sb, group);
|
|
|
|
/* We only do this if the grp has never been initialized */
|
|
|
|
if (unlikely(EXT4_MB_GRP_NEED_INIT(grp))) {
|
|
|
|
ret = ext4_mb_init_group(sb, group);
|
|
|
|
if (ret)
|
|
|
|
break;
|
2010-10-28 03:30:12 +02:00
|
|
|
}
|
|
|
|
|
2011-03-23 20:48:11 +01:00
|
|
|
/*
|
2012-03-22 02:22:22 +01:00
|
|
|
* For all the groups except the last one, last cluster will
|
|
|
|
* always be EXT4_CLUSTERS_PER_GROUP(sb)-1, so we only need to
|
|
|
|
* change it for the last group, note that last_cluster is
|
|
|
|
* already computed earlier by ext4_get_group_no_and_offset()
|
2011-03-23 20:48:11 +01:00
|
|
|
*/
|
2012-03-22 02:22:22 +01:00
|
|
|
if (group == last_group)
|
|
|
|
end = last_cluster;
|
2010-10-28 03:30:12 +02:00
|
|
|
|
2011-05-25 00:16:27 +02:00
|
|
|
if (grp->bb_free >= minlen) {
|
2011-09-10 00:38:51 +02:00
|
|
|
cnt = ext4_trim_all_free(sb, group, first_cluster,
|
2012-03-22 02:22:22 +01:00
|
|
|
end, minlen);
|
2010-10-28 03:30:12 +02:00
|
|
|
if (cnt < 0) {
|
|
|
|
ret = cnt;
|
|
|
|
break;
|
|
|
|
}
|
2012-03-22 02:24:22 +01:00
|
|
|
trimmed += cnt;
|
2010-10-28 03:30:12 +02:00
|
|
|
}
|
2012-03-22 02:22:22 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* For every group except the first one, we are sure
|
|
|
|
* that the first cluster to discard will be cluster #0.
|
|
|
|
*/
|
2011-09-10 00:38:51 +02:00
|
|
|
first_cluster = 0;
|
2010-10-28 03:30:12 +02:00
|
|
|
}
|
|
|
|
|
2011-07-11 06:03:38 +02:00
|
|
|
if (!ret)
|
|
|
|
atomic_set(&EXT4_SB(sb)->s_last_trim_minblks, minlen);
|
|
|
|
|
2011-07-11 05:52:37 +02:00
|
|
|
out:
|
2012-09-27 04:21:21 +02:00
|
|
|
range->len = EXT4_C2B(EXT4_SB(sb), trimmed) << sb->s_blocksize_bits;
|
2010-10-28 03:30:12 +02:00
|
|
|
return ret;
|
|
|
|
}
|