License cleanup: add SPDX GPL-2.0 license identifier to files with no license
Many source files in the tree are missing licensing information, which
makes it harder for compliance tools to determine the correct license.
By default all files without license information are under the default
license of the kernel, which is GPL version 2.
Update the files which contain no license information with the 'GPL-2.0'
SPDX license identifier. The SPDX identifier is a legally binding
shorthand, which can be used instead of the full boiler plate text.
This patch is based on work done by Thomas Gleixner and Kate Stewart and
Philippe Ombredanne.
How this work was done:
Patches were generated and checked against linux-4.14-rc6 for a subset of
the use cases:
- file had no licensing information it it.
- file was a */uapi/* one with no licensing information in it,
- file was a */uapi/* one with existing licensing information,
Further patches will be generated in subsequent months to fix up cases
where non-standard license headers were used, and references to license
had to be inferred by heuristics based on keywords.
The analysis to determine which SPDX License Identifier to be applied to
a file was done in a spreadsheet of side by side results from of the
output of two independent scanners (ScanCode & Windriver) producing SPDX
tag:value files created by Philippe Ombredanne. Philippe prepared the
base worksheet, and did an initial spot review of a few 1000 files.
The 4.13 kernel was the starting point of the analysis with 60,537 files
assessed. Kate Stewart did a file by file comparison of the scanner
results in the spreadsheet to determine which SPDX license identifier(s)
to be applied to the file. She confirmed any determination that was not
immediately clear with lawyers working with the Linux Foundation.
Criteria used to select files for SPDX license identifier tagging was:
- Files considered eligible had to be source code files.
- Make and config files were included as candidates if they contained >5
lines of source
- File already had some variant of a license header in it (even if <5
lines).
All documentation files were explicitly excluded.
The following heuristics were used to determine which SPDX license
identifiers to apply.
- when both scanners couldn't find any license traces, file was
considered to have no license information in it, and the top level
COPYING file license applied.
For non */uapi/* files that summary was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 11139
and resulted in the first patch in this series.
If that file was a */uapi/* path one, it was "GPL-2.0 WITH
Linux-syscall-note" otherwise it was "GPL-2.0". Results of that was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 WITH Linux-syscall-note 930
and resulted in the second patch in this series.
- if a file had some form of licensing information in it, and was one
of the */uapi/* ones, it was denoted with the Linux-syscall-note if
any GPL family license was found in the file or had no licensing in
it (per prior point). Results summary:
SPDX license identifier # files
---------------------------------------------------|------
GPL-2.0 WITH Linux-syscall-note 270
GPL-2.0+ WITH Linux-syscall-note 169
((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) 21
((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 17
LGPL-2.1+ WITH Linux-syscall-note 15
GPL-1.0+ WITH Linux-syscall-note 14
((GPL-2.0+ WITH Linux-syscall-note) OR BSD-3-Clause) 5
LGPL-2.0+ WITH Linux-syscall-note 4
LGPL-2.1 WITH Linux-syscall-note 3
((GPL-2.0 WITH Linux-syscall-note) OR MIT) 3
((GPL-2.0 WITH Linux-syscall-note) AND MIT) 1
and that resulted in the third patch in this series.
- when the two scanners agreed on the detected license(s), that became
the concluded license(s).
- when there was disagreement between the two scanners (one detected a
license but the other didn't, or they both detected different
licenses) a manual inspection of the file occurred.
- In most cases a manual inspection of the information in the file
resulted in a clear resolution of the license that should apply (and
which scanner probably needed to revisit its heuristics).
- When it was not immediately clear, the license identifier was
confirmed with lawyers working with the Linux Foundation.
- If there was any question as to the appropriate license identifier,
the file was flagged for further research and to be revisited later
in time.
In total, over 70 hours of logged manual review was done on the
spreadsheet to determine the SPDX license identifiers to apply to the
source files by Kate, Philippe, Thomas and, in some cases, confirmation
by lawyers working with the Linux Foundation.
Kate also obtained a third independent scan of the 4.13 code base from
FOSSology, and compared selected files where the other two scanners
disagreed against that SPDX file, to see if there was new insights. The
Windriver scanner is based on an older version of FOSSology in part, so
they are related.
Thomas did random spot checks in about 500 files from the spreadsheets
for the uapi headers and agreed with SPDX license identifier in the
files he inspected. For the non-uapi files Thomas did random spot checks
in about 15000 files.
In initial set of patches against 4.14-rc6, 3 files were found to have
copy/paste license identifier errors, and have been fixed to reflect the
correct identifier.
Additionally Philippe spent 10 hours this week doing a detailed manual
inspection and review of the 12,461 patched files from the initial patch
version early this week with:
- a full scancode scan run, collecting the matched texts, detected
license ids and scores
- reviewing anything where there was a license detected (about 500+
files) to ensure that the applied SPDX license was correct
- reviewing anything where there was no detection but the patch license
was not GPL-2.0 WITH Linux-syscall-note to ensure that the applied
SPDX license was correct
This produced a worksheet with 20 files needing minor correction. This
worksheet was then exported into 3 different .csv files for the
different types of files to be modified.
These .csv files were then reviewed by Greg. Thomas wrote a script to
parse the csv files and add the proper SPDX tag to the file, in the
format that the file expected. This script was further refined by Greg
based on the output to detect more types of files automatically and to
distinguish between header and source .c files (which need different
comment types.) Finally Greg ran the script using the .csv files to
generate the patches.
Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org>
Reviewed-by: Philippe Ombredanne <pombredanne@nexb.com>
Reviewed-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2017-11-01 08:07:57 -06:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* linux/fs/ext2/balloc.c
|
|
|
|
*
|
|
|
|
* Copyright (C) 1992, 1993, 1994, 1995
|
|
|
|
* Remy Card (card@masi.ibp.fr)
|
|
|
|
* Laboratoire MASI - Institut Blaise Pascal
|
|
|
|
* Universite Pierre et Marie Curie (Paris VI)
|
|
|
|
*
|
|
|
|
* Enhanced block allocation by Stephen Tweedie (sct@redhat.com), 1993
|
|
|
|
* Big-endian to little-endian byte-swapping/bitmaps by
|
|
|
|
* David S. Miller (davem@caip.rutgers.edu), 1995
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "ext2.h"
|
|
|
|
#include <linux/quotaops.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 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/sched.h>
|
2017-02-02 09:54:15 -07:00
|
|
|
#include <linux/cred.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/buffer_head.h>
|
2006-01-11 13:17:46 -07:00
|
|
|
#include <linux/capability.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* balloc.c contains the blocks allocation and deallocation routines
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The free blocks are managed by bitmaps. A file system contains several
|
|
|
|
* blocks groups. Each group contains 1 bitmap block for blocks, 1 bitmap
|
|
|
|
* block for inodes, N blocks for the inode table and data blocks.
|
|
|
|
*
|
|
|
|
* The file system contains group descriptors which are located after the
|
|
|
|
* super block. Each descriptor contains the number of the bitmap block and
|
|
|
|
* the free blocks count in the block. The descriptors are loaded in memory
|
2007-02-20 14:57:58 -07:00
|
|
|
* when a file system is mounted (see ext2_fill_super).
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
#define in_range(b, first, len) ((b) >= (first) && (b) <= (first) + (len) - 1)
|
|
|
|
|
|
|
|
struct ext2_group_desc * ext2_get_group_desc(struct super_block * sb,
|
|
|
|
unsigned int block_group,
|
|
|
|
struct buffer_head ** bh)
|
|
|
|
{
|
|
|
|
unsigned long group_desc;
|
|
|
|
unsigned long offset;
|
|
|
|
struct ext2_group_desc * desc;
|
|
|
|
struct ext2_sb_info *sbi = EXT2_SB(sb);
|
|
|
|
|
|
|
|
if (block_group >= sbi->s_groups_count) {
|
|
|
|
ext2_error (sb, "ext2_get_group_desc",
|
|
|
|
"block_group >= groups_count - "
|
|
|
|
"block_group = %d, groups_count = %lu",
|
|
|
|
block_group, sbi->s_groups_count);
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
group_desc = block_group >> EXT2_DESC_PER_BLOCK_BITS(sb);
|
|
|
|
offset = block_group & (EXT2_DESC_PER_BLOCK(sb) - 1);
|
|
|
|
if (!sbi->s_group_desc[group_desc]) {
|
|
|
|
ext2_error (sb, "ext2_get_group_desc",
|
|
|
|
"Group descriptor not loaded - "
|
|
|
|
"block_group = %d, group_desc = %lu, desc = %lu",
|
|
|
|
block_group, group_desc, offset);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
desc = (struct ext2_group_desc *) sbi->s_group_desc[group_desc]->b_data;
|
|
|
|
if (bh)
|
|
|
|
*bh = sbi->s_group_desc[group_desc];
|
|
|
|
return desc + offset;
|
|
|
|
}
|
|
|
|
|
2008-02-06 02:40:08 -07:00
|
|
|
static int ext2_valid_block_bitmap(struct super_block *sb,
|
|
|
|
struct ext2_group_desc *desc,
|
|
|
|
unsigned int block_group,
|
|
|
|
struct buffer_head *bh)
|
|
|
|
{
|
|
|
|
ext2_grpblk_t offset;
|
|
|
|
ext2_grpblk_t next_zero_bit;
|
|
|
|
ext2_fsblk_t bitmap_blk;
|
|
|
|
ext2_fsblk_t group_first_block;
|
|
|
|
|
|
|
|
group_first_block = ext2_group_first_block_no(sb, block_group);
|
|
|
|
|
|
|
|
/* check whether block bitmap block number is set */
|
|
|
|
bitmap_blk = le32_to_cpu(desc->bg_block_bitmap);
|
|
|
|
offset = bitmap_blk - group_first_block;
|
|
|
|
if (!ext2_test_bit(offset, bh->b_data))
|
|
|
|
/* bad block bitmap */
|
|
|
|
goto err_out;
|
|
|
|
|
|
|
|
/* check whether the inode bitmap block number is set */
|
|
|
|
bitmap_blk = le32_to_cpu(desc->bg_inode_bitmap);
|
|
|
|
offset = bitmap_blk - group_first_block;
|
|
|
|
if (!ext2_test_bit(offset, bh->b_data))
|
|
|
|
/* bad block bitmap */
|
|
|
|
goto err_out;
|
|
|
|
|
|
|
|
/* check whether the inode table block number is set */
|
|
|
|
bitmap_blk = le32_to_cpu(desc->bg_inode_table);
|
|
|
|
offset = bitmap_blk - group_first_block;
|
|
|
|
next_zero_bit = ext2_find_next_zero_bit(bh->b_data,
|
|
|
|
offset + EXT2_SB(sb)->s_itb_per_group,
|
|
|
|
offset);
|
|
|
|
if (next_zero_bit >= offset + EXT2_SB(sb)->s_itb_per_group)
|
|
|
|
/* good bitmap for inode tables */
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
err_out:
|
2008-04-28 03:16:03 -06:00
|
|
|
ext2_error(sb, __func__,
|
2008-02-06 02:40:08 -07:00
|
|
|
"Invalid block bitmap - "
|
|
|
|
"block_group = %d, block = %lu",
|
|
|
|
block_group, bitmap_blk);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2008-02-06 02:40:08 -07:00
|
|
|
* Read the bitmap for a given block_group,and validate the
|
|
|
|
* bits for block/inode/inode tables are set in the bitmaps
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* Return buffer_head on success or NULL in case of failure.
|
|
|
|
*/
|
|
|
|
static struct buffer_head *
|
|
|
|
read_block_bitmap(struct super_block *sb, unsigned int block_group)
|
|
|
|
{
|
|
|
|
struct ext2_group_desc * desc;
|
|
|
|
struct buffer_head * bh = NULL;
|
2008-02-06 02:40:08 -07:00
|
|
|
ext2_fsblk_t bitmap_blk;
|
|
|
|
|
|
|
|
desc = ext2_get_group_desc(sb, block_group, NULL);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!desc)
|
2008-02-06 02:40:08 -07:00
|
|
|
return NULL;
|
|
|
|
bitmap_blk = le32_to_cpu(desc->bg_block_bitmap);
|
|
|
|
bh = sb_getblk(sb, bitmap_blk);
|
|
|
|
if (unlikely(!bh)) {
|
2008-04-28 03:16:03 -06:00
|
|
|
ext2_error(sb, __func__,
|
2008-02-06 02:40:08 -07:00
|
|
|
"Cannot read block bitmap - "
|
|
|
|
"block_group = %d, block_bitmap = %u",
|
|
|
|
block_group, le32_to_cpu(desc->bg_block_bitmap));
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
if (likely(bh_uptodate_or_lock(bh)))
|
|
|
|
return bh;
|
|
|
|
|
|
|
|
if (bh_submit_read(bh) < 0) {
|
|
|
|
brelse(bh);
|
2008-04-28 03:16:03 -06:00
|
|
|
ext2_error(sb, __func__,
|
2005-04-16 16:20:36 -06:00
|
|
|
"Cannot read block bitmap - "
|
|
|
|
"block_group = %d, block_bitmap = %u",
|
|
|
|
block_group, le32_to_cpu(desc->bg_block_bitmap));
|
2008-02-06 02:40:08 -07:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2008-04-28 03:16:04 -06:00
|
|
|
ext2_valid_block_bitmap(sb, desc, block_group, bh);
|
|
|
|
/*
|
|
|
|
* file system mounted not to panic on error, continue with corrupt
|
|
|
|
* bitmap
|
|
|
|
*/
|
2007-11-13 09:07:31 -07:00
|
|
|
return bh;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-10-17 00:30:46 -06:00
|
|
|
static void group_adjust_blocks(struct super_block *sb, int group_no,
|
2005-04-16 16:20:36 -06:00
|
|
|
struct ext2_group_desc *desc, struct buffer_head *bh, int count)
|
|
|
|
{
|
|
|
|
if (count) {
|
|
|
|
struct ext2_sb_info *sbi = EXT2_SB(sb);
|
|
|
|
unsigned free_blocks;
|
|
|
|
|
|
|
|
spin_lock(sb_bgl_lock(sbi, group_no));
|
|
|
|
free_blocks = le16_to_cpu(desc->bg_free_blocks_count);
|
|
|
|
desc->bg_free_blocks_count = cpu_to_le16(free_blocks + count);
|
|
|
|
spin_unlock(sb_bgl_lock(sbi, group_no));
|
|
|
|
mark_buffer_dirty(bh);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-10-17 00:30:46 -06:00
|
|
|
/*
|
|
|
|
* The reservation window structure operations
|
|
|
|
* --------------------------------------------
|
|
|
|
* Operations include:
|
|
|
|
* dump, find, add, remove, is_empty, find_next_reservable_window, etc.
|
|
|
|
*
|
|
|
|
* We use a red-black tree to represent per-filesystem reservation
|
|
|
|
* windows.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __rsv_window_dump() -- Dump the filesystem block allocation reservation map
|
|
|
|
* @rb_root: root of per-filesystem reservation rb tree
|
|
|
|
* @verbose: verbose mode
|
|
|
|
* @fn: function which wishes to dump the reservation map
|
|
|
|
*
|
|
|
|
* If verbose is turned on, it will print the whole block reservation
|
|
|
|
* windows(start, end). Otherwise, it will only print out the "bad" windows,
|
|
|
|
* those windows that overlap with their immediate neighbors.
|
|
|
|
*/
|
|
|
|
#if 1
|
|
|
|
static void __rsv_window_dump(struct rb_root *root, int verbose,
|
|
|
|
const char *fn)
|
|
|
|
{
|
|
|
|
struct rb_node *n;
|
|
|
|
struct ext2_reserve_window_node *rsv, *prev;
|
|
|
|
int bad;
|
|
|
|
|
|
|
|
restart:
|
|
|
|
n = rb_first(root);
|
|
|
|
bad = 0;
|
|
|
|
prev = NULL;
|
|
|
|
|
|
|
|
printk("Block Allocation Reservation Windows Map (%s):\n", fn);
|
|
|
|
while (n) {
|
|
|
|
rsv = rb_entry(n, struct ext2_reserve_window_node, rsv_node);
|
|
|
|
if (verbose)
|
|
|
|
printk("reservation window 0x%p "
|
|
|
|
"start: %lu, end: %lu\n",
|
|
|
|
rsv, rsv->rsv_start, rsv->rsv_end);
|
|
|
|
if (rsv->rsv_start && rsv->rsv_start >= rsv->rsv_end) {
|
|
|
|
printk("Bad reservation %p (start >= end)\n",
|
|
|
|
rsv);
|
|
|
|
bad = 1;
|
|
|
|
}
|
|
|
|
if (prev && prev->rsv_end >= rsv->rsv_start) {
|
|
|
|
printk("Bad reservation %p (prev->end >= start)\n",
|
|
|
|
rsv);
|
|
|
|
bad = 1;
|
|
|
|
}
|
|
|
|
if (bad) {
|
|
|
|
if (!verbose) {
|
|
|
|
printk("Restarting reservation walk in verbose mode\n");
|
|
|
|
verbose = 1;
|
|
|
|
goto restart;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
n = rb_next(n);
|
|
|
|
prev = rsv;
|
|
|
|
}
|
|
|
|
printk("Window map complete.\n");
|
2008-04-28 03:16:02 -06:00
|
|
|
BUG_ON(bad);
|
2007-10-17 00:30:46 -06:00
|
|
|
}
|
|
|
|
#define rsv_window_dump(root, verbose) \
|
2008-04-28 03:16:03 -06:00
|
|
|
__rsv_window_dump((root), (verbose), __func__)
|
2007-10-17 00:30:46 -06:00
|
|
|
#else
|
|
|
|
#define rsv_window_dump(root, verbose) do {} while (0)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/**
|
|
|
|
* goal_in_my_reservation()
|
|
|
|
* @rsv: inode's reservation window
|
|
|
|
* @grp_goal: given goal block relative to the allocation block group
|
|
|
|
* @group: the current allocation block group
|
|
|
|
* @sb: filesystem super block
|
|
|
|
*
|
|
|
|
* Test if the given goal block (group relative) is within the file's
|
|
|
|
* own block reservation window range.
|
|
|
|
*
|
|
|
|
* If the reservation window is outside the goal allocation group, return 0;
|
|
|
|
* grp_goal (given goal block) could be -1, which means no specific
|
|
|
|
* goal block. In this case, always return 1.
|
|
|
|
* If the goal block is within the reservation window, return 1;
|
|
|
|
* otherwise, return 0;
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
goal_in_my_reservation(struct ext2_reserve_window *rsv, ext2_grpblk_t grp_goal,
|
|
|
|
unsigned int group, struct super_block * sb)
|
|
|
|
{
|
|
|
|
ext2_fsblk_t group_first_block, group_last_block;
|
|
|
|
|
|
|
|
group_first_block = ext2_group_first_block_no(sb, group);
|
|
|
|
group_last_block = group_first_block + EXT2_BLOCKS_PER_GROUP(sb) - 1;
|
|
|
|
|
|
|
|
if ((rsv->_rsv_start > group_last_block) ||
|
|
|
|
(rsv->_rsv_end < group_first_block))
|
|
|
|
return 0;
|
|
|
|
if ((grp_goal >= 0) && ((grp_goal + group_first_block < rsv->_rsv_start)
|
|
|
|
|| (grp_goal + group_first_block > rsv->_rsv_end)))
|
|
|
|
return 0;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* search_reserve_window()
|
|
|
|
* @rb_root: root of reservation tree
|
|
|
|
* @goal: target allocation block
|
|
|
|
*
|
|
|
|
* Find the reserved window which includes the goal, or the previous one
|
|
|
|
* if the goal is not in any window.
|
|
|
|
* Returns NULL if there are no windows or if all windows start after the goal.
|
|
|
|
*/
|
|
|
|
static struct ext2_reserve_window_node *
|
|
|
|
search_reserve_window(struct rb_root *root, ext2_fsblk_t goal)
|
|
|
|
{
|
|
|
|
struct rb_node *n = root->rb_node;
|
|
|
|
struct ext2_reserve_window_node *rsv;
|
|
|
|
|
|
|
|
if (!n)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
do {
|
|
|
|
rsv = rb_entry(n, struct ext2_reserve_window_node, rsv_node);
|
|
|
|
|
|
|
|
if (goal < rsv->rsv_start)
|
|
|
|
n = n->rb_left;
|
|
|
|
else if (goal > rsv->rsv_end)
|
|
|
|
n = n->rb_right;
|
|
|
|
else
|
|
|
|
return rsv;
|
|
|
|
} while (n);
|
|
|
|
/*
|
|
|
|
* We've fallen off the end of the tree: the goal wasn't inside
|
|
|
|
* any particular node. OK, the previous node must be to one
|
|
|
|
* side of the interval containing the goal. If it's the RHS,
|
|
|
|
* we need to back up one.
|
|
|
|
*/
|
|
|
|
if (rsv->rsv_start > goal) {
|
|
|
|
n = rb_prev(&rsv->rsv_node);
|
|
|
|
rsv = rb_entry(n, struct ext2_reserve_window_node, rsv_node);
|
|
|
|
}
|
|
|
|
return rsv;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ext2_rsv_window_add() -- Insert a window to the block reservation rb tree.
|
|
|
|
* @sb: super block
|
|
|
|
* @rsv: reservation window to add
|
|
|
|
*
|
|
|
|
* Must be called with rsv_lock held.
|
|
|
|
*/
|
|
|
|
void ext2_rsv_window_add(struct super_block *sb,
|
|
|
|
struct ext2_reserve_window_node *rsv)
|
|
|
|
{
|
|
|
|
struct rb_root *root = &EXT2_SB(sb)->s_rsv_window_root;
|
|
|
|
struct rb_node *node = &rsv->rsv_node;
|
|
|
|
ext2_fsblk_t start = rsv->rsv_start;
|
|
|
|
|
|
|
|
struct rb_node ** p = &root->rb_node;
|
|
|
|
struct rb_node * parent = NULL;
|
|
|
|
struct ext2_reserve_window_node *this;
|
|
|
|
|
|
|
|
while (*p)
|
|
|
|
{
|
|
|
|
parent = *p;
|
|
|
|
this = rb_entry(parent, struct ext2_reserve_window_node, rsv_node);
|
|
|
|
|
|
|
|
if (start < this->rsv_start)
|
|
|
|
p = &(*p)->rb_left;
|
|
|
|
else if (start > this->rsv_end)
|
|
|
|
p = &(*p)->rb_right;
|
|
|
|
else {
|
|
|
|
rsv_window_dump(root, 1);
|
|
|
|
BUG();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
rb_link_node(node, parent, p);
|
|
|
|
rb_insert_color(node, root);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* rsv_window_remove() -- unlink a window from the reservation rb tree
|
|
|
|
* @sb: super block
|
|
|
|
* @rsv: reservation window to remove
|
|
|
|
*
|
|
|
|
* Mark the block reservation window as not allocated, and unlink it
|
|
|
|
* from the filesystem reservation window rb tree. Must be called with
|
|
|
|
* rsv_lock held.
|
|
|
|
*/
|
|
|
|
static void rsv_window_remove(struct super_block *sb,
|
|
|
|
struct ext2_reserve_window_node *rsv)
|
|
|
|
{
|
|
|
|
rsv->rsv_start = EXT2_RESERVE_WINDOW_NOT_ALLOCATED;
|
|
|
|
rsv->rsv_end = EXT2_RESERVE_WINDOW_NOT_ALLOCATED;
|
|
|
|
rsv->rsv_alloc_hit = 0;
|
|
|
|
rb_erase(&rsv->rsv_node, &EXT2_SB(sb)->s_rsv_window_root);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* rsv_is_empty() -- Check if the reservation window is allocated.
|
|
|
|
* @rsv: given reservation window to check
|
|
|
|
*
|
|
|
|
* returns 1 if the end block is EXT2_RESERVE_WINDOW_NOT_ALLOCATED.
|
|
|
|
*/
|
|
|
|
static inline int rsv_is_empty(struct ext2_reserve_window *rsv)
|
|
|
|
{
|
|
|
|
/* a valid reservation end block could not be 0 */
|
|
|
|
return (rsv->_rsv_end == EXT2_RESERVE_WINDOW_NOT_ALLOCATED);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ext2_init_block_alloc_info()
|
|
|
|
* @inode: file inode structure
|
|
|
|
*
|
|
|
|
* Allocate and initialize the reservation window structure, and
|
|
|
|
* link the window to the ext2 inode structure at last
|
|
|
|
*
|
|
|
|
* The reservation window structure is only dynamically allocated
|
|
|
|
* and linked to ext2 inode the first time the open file
|
|
|
|
* needs a new block. So, before every ext2_new_block(s) call, for
|
|
|
|
* regular files, we should check whether the reservation window
|
|
|
|
* structure exists or not. In the latter case, this function is called.
|
|
|
|
* Fail to do so will result in block reservation being turned off for that
|
|
|
|
* open file.
|
|
|
|
*
|
|
|
|
* This function is called from ext2_get_blocks_handle(), also called
|
|
|
|
* when setting the reservation window size through ioctl before the file
|
|
|
|
* is open for write (needs block allocation).
|
|
|
|
*
|
|
|
|
* Needs truncate_mutex protection prior to calling this function.
|
|
|
|
*/
|
|
|
|
void ext2_init_block_alloc_info(struct inode *inode)
|
|
|
|
{
|
|
|
|
struct ext2_inode_info *ei = EXT2_I(inode);
|
2011-08-04 04:29:32 -06:00
|
|
|
struct ext2_block_alloc_info *block_i;
|
2007-10-17 00:30:46 -06:00
|
|
|
struct super_block *sb = inode->i_sb;
|
|
|
|
|
|
|
|
block_i = kmalloc(sizeof(*block_i), GFP_NOFS);
|
|
|
|
if (block_i) {
|
|
|
|
struct ext2_reserve_window_node *rsv = &block_i->rsv_window_node;
|
|
|
|
|
|
|
|
rsv->rsv_start = EXT2_RESERVE_WINDOW_NOT_ALLOCATED;
|
|
|
|
rsv->rsv_end = EXT2_RESERVE_WINDOW_NOT_ALLOCATED;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* if filesystem is mounted with NORESERVATION, the goal
|
|
|
|
* reservation window size is set to zero to indicate
|
|
|
|
* block reservation is off
|
|
|
|
*/
|
|
|
|
if (!test_opt(sb, RESERVATION))
|
|
|
|
rsv->rsv_goal_size = 0;
|
|
|
|
else
|
|
|
|
rsv->rsv_goal_size = EXT2_DEFAULT_RESERVE_BLOCKS;
|
|
|
|
rsv->rsv_alloc_hit = 0;
|
|
|
|
block_i->last_alloc_logical_block = 0;
|
|
|
|
block_i->last_alloc_physical_block = 0;
|
|
|
|
}
|
|
|
|
ei->i_block_alloc_info = block_i;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ext2_discard_reservation()
|
|
|
|
* @inode: inode
|
|
|
|
*
|
|
|
|
* Discard(free) block reservation window on last file close, or truncate
|
|
|
|
* or at last iput().
|
|
|
|
*
|
|
|
|
* It is being called in three cases:
|
|
|
|
* ext2_release_file(): last writer closes the file
|
|
|
|
* ext2_clear_inode(): last iput(), when nobody links to this file.
|
|
|
|
* ext2_truncate(): when the block indirect map is about to change.
|
|
|
|
*/
|
|
|
|
void ext2_discard_reservation(struct inode *inode)
|
|
|
|
{
|
|
|
|
struct ext2_inode_info *ei = EXT2_I(inode);
|
|
|
|
struct ext2_block_alloc_info *block_i = ei->i_block_alloc_info;
|
|
|
|
struct ext2_reserve_window_node *rsv;
|
|
|
|
spinlock_t *rsv_lock = &EXT2_SB(inode->i_sb)->s_rsv_window_lock;
|
|
|
|
|
|
|
|
if (!block_i)
|
|
|
|
return;
|
|
|
|
|
|
|
|
rsv = &block_i->rsv_window_node;
|
|
|
|
if (!rsv_is_empty(&rsv->rsv_window)) {
|
|
|
|
spin_lock(rsv_lock);
|
|
|
|
if (!rsv_is_empty(&rsv->rsv_window))
|
|
|
|
rsv_window_remove(inode->i_sb, rsv);
|
|
|
|
spin_unlock(rsv_lock);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2012-05-18 01:04:45 -06:00
|
|
|
* ext2_free_blocks() -- Free given blocks and update quota and i_blocks
|
2007-10-17 00:30:46 -06:00
|
|
|
* @inode: inode
|
2012-09-01 11:31:09 -06:00
|
|
|
* @block: start physical block to free
|
2007-10-17 00:30:46 -06:00
|
|
|
* @count: number of blocks to free
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
void ext2_free_blocks (struct inode * inode, unsigned long block,
|
|
|
|
unsigned long count)
|
|
|
|
{
|
|
|
|
struct buffer_head *bitmap_bh = NULL;
|
|
|
|
struct buffer_head * bh2;
|
|
|
|
unsigned long block_group;
|
|
|
|
unsigned long bit;
|
|
|
|
unsigned long i;
|
|
|
|
unsigned long overflow;
|
|
|
|
struct super_block * sb = inode->i_sb;
|
|
|
|
struct ext2_sb_info * sbi = EXT2_SB(sb);
|
|
|
|
struct ext2_group_desc * desc;
|
|
|
|
struct ext2_super_block * es = sbi->s_es;
|
|
|
|
unsigned freed = 0, group_freed;
|
|
|
|
|
|
|
|
if (block < le32_to_cpu(es->s_first_data_block) ||
|
|
|
|
block + count < block ||
|
|
|
|
block + count > le32_to_cpu(es->s_blocks_count)) {
|
|
|
|
ext2_error (sb, "ext2_free_blocks",
|
|
|
|
"Freeing blocks not in datazone - "
|
|
|
|
"block = %lu, count = %lu", block, count);
|
|
|
|
goto error_return;
|
|
|
|
}
|
|
|
|
|
|
|
|
ext2_debug ("freeing block(s) %lu-%lu\n", block, block + count - 1);
|
|
|
|
|
|
|
|
do_more:
|
|
|
|
overflow = 0;
|
|
|
|
block_group = (block - le32_to_cpu(es->s_first_data_block)) /
|
|
|
|
EXT2_BLOCKS_PER_GROUP(sb);
|
|
|
|
bit = (block - le32_to_cpu(es->s_first_data_block)) %
|
|
|
|
EXT2_BLOCKS_PER_GROUP(sb);
|
|
|
|
/*
|
|
|
|
* Check to see if we are freeing blocks across a group
|
|
|
|
* boundary.
|
|
|
|
*/
|
|
|
|
if (bit + count > EXT2_BLOCKS_PER_GROUP(sb)) {
|
|
|
|
overflow = bit + count - EXT2_BLOCKS_PER_GROUP(sb);
|
|
|
|
count -= overflow;
|
|
|
|
}
|
|
|
|
brelse(bitmap_bh);
|
|
|
|
bitmap_bh = read_block_bitmap(sb, block_group);
|
|
|
|
if (!bitmap_bh)
|
|
|
|
goto error_return;
|
|
|
|
|
|
|
|
desc = ext2_get_group_desc (sb, block_group, &bh2);
|
|
|
|
if (!desc)
|
|
|
|
goto error_return;
|
|
|
|
|
|
|
|
if (in_range (le32_to_cpu(desc->bg_block_bitmap), block, count) ||
|
|
|
|
in_range (le32_to_cpu(desc->bg_inode_bitmap), block, count) ||
|
|
|
|
in_range (block, le32_to_cpu(desc->bg_inode_table),
|
|
|
|
sbi->s_itb_per_group) ||
|
|
|
|
in_range (block + count - 1, le32_to_cpu(desc->bg_inode_table),
|
2008-02-06 02:36:17 -07:00
|
|
|
sbi->s_itb_per_group)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
ext2_error (sb, "ext2_free_blocks",
|
|
|
|
"Freeing blocks in system zones - "
|
|
|
|
"Block = %lu, count = %lu",
|
|
|
|
block, count);
|
2008-02-06 02:36:17 -07:00
|
|
|
goto error_return;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
for (i = 0, group_freed = 0; i < count; i++) {
|
|
|
|
if (!ext2_clear_bit_atomic(sb_bgl_lock(sbi, block_group),
|
|
|
|
bit + i, bitmap_bh->b_data)) {
|
2008-04-28 03:16:03 -06:00
|
|
|
ext2_error(sb, __func__,
|
2005-04-16 16:20:36 -06:00
|
|
|
"bit already cleared for block %lu", block + i);
|
|
|
|
} else {
|
|
|
|
group_freed++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
mark_buffer_dirty(bitmap_bh);
|
2017-11-27 14:05:09 -07:00
|
|
|
if (sb->s_flags & SB_SYNCHRONOUS)
|
2005-04-16 16:20:36 -06:00
|
|
|
sync_dirty_buffer(bitmap_bh);
|
|
|
|
|
2007-10-17 00:30:46 -06:00
|
|
|
group_adjust_blocks(sb, block_group, desc, bh2, group_freed);
|
2005-04-16 16:20:36 -06:00
|
|
|
freed += group_freed;
|
|
|
|
|
|
|
|
if (overflow) {
|
|
|
|
block += count;
|
|
|
|
count = overflow;
|
|
|
|
goto do_more;
|
|
|
|
}
|
|
|
|
error_return:
|
|
|
|
brelse(bitmap_bh);
|
2013-02-07 07:57:53 -07:00
|
|
|
if (freed) {
|
2013-02-07 07:57:54 -07:00
|
|
|
percpu_counter_add(&sbi->s_freeblocks_counter, freed);
|
2013-02-07 07:57:53 -07:00
|
|
|
dquot_free_block_nodirty(inode, freed);
|
|
|
|
mark_inode_dirty(inode);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-10-17 00:30:46 -06:00
|
|
|
/**
|
|
|
|
* bitmap_search_next_usable_block()
|
|
|
|
* @start: the starting block (group relative) of the search
|
|
|
|
* @bh: bufferhead contains the block group bitmap
|
|
|
|
* @maxblocks: the ending block (group relative) of the reservation
|
|
|
|
*
|
|
|
|
* The bitmap search --- search forward through the actual bitmap on disk until
|
|
|
|
* we find a bit free.
|
|
|
|
*/
|
|
|
|
static ext2_grpblk_t
|
|
|
|
bitmap_search_next_usable_block(ext2_grpblk_t start, struct buffer_head *bh,
|
|
|
|
ext2_grpblk_t maxblocks)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-10-17 00:30:46 -06:00
|
|
|
ext2_grpblk_t next;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-10-17 00:30:46 -06:00
|
|
|
next = ext2_find_next_zero_bit(bh->b_data, maxblocks, start);
|
|
|
|
if (next >= maxblocks)
|
|
|
|
return -1;
|
|
|
|
return next;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-10-17 00:30:46 -06:00
|
|
|
/**
|
|
|
|
* find_next_usable_block()
|
|
|
|
* @start: the starting block (group relative) to find next
|
|
|
|
* allocatable block in bitmap.
|
|
|
|
* @bh: bufferhead contains the block group bitmap
|
|
|
|
* @maxblocks: the ending block (group relative) for the search
|
|
|
|
*
|
|
|
|
* Find an allocatable block in a bitmap. We perform the "most
|
|
|
|
* appropriate allocation" algorithm of looking for a free block near
|
|
|
|
* the initial goal; then for a free byte somewhere in the bitmap;
|
|
|
|
* then for any free bit in the bitmap.
|
|
|
|
*/
|
|
|
|
static ext2_grpblk_t
|
|
|
|
find_next_usable_block(int start, struct buffer_head *bh, int maxblocks)
|
|
|
|
{
|
|
|
|
ext2_grpblk_t here, next;
|
|
|
|
char *p, *r;
|
|
|
|
|
|
|
|
if (start > 0) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* The goal was occupied; search forward for a free
|
|
|
|
* block within the next XX blocks.
|
|
|
|
*
|
|
|
|
* end_goal is more or less random, but it has to be
|
|
|
|
* less than EXT2_BLOCKS_PER_GROUP. Aligning up to the
|
|
|
|
* next 64-bit boundary is simple..
|
|
|
|
*/
|
2007-10-17 00:30:46 -06:00
|
|
|
ext2_grpblk_t end_goal = (start + 63) & ~63;
|
|
|
|
if (end_goal > maxblocks)
|
|
|
|
end_goal = maxblocks;
|
|
|
|
here = ext2_find_next_zero_bit(bh->b_data, end_goal, start);
|
|
|
|
if (here < end_goal)
|
|
|
|
return here;
|
|
|
|
ext2_debug("Bit not found near goal\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
here = start;
|
|
|
|
if (here < 0)
|
|
|
|
here = 0;
|
|
|
|
|
|
|
|
p = ((char *)bh->b_data) + (here >> 3);
|
|
|
|
r = memscan(p, 0, ((maxblocks + 7) >> 3) - (here >> 3));
|
|
|
|
next = (r - ((char *)bh->b_data)) << 3;
|
|
|
|
|
|
|
|
if (next < maxblocks && next >= here)
|
|
|
|
return next;
|
|
|
|
|
|
|
|
here = bitmap_search_next_usable_block(here, bh, maxblocks);
|
|
|
|
return here;
|
|
|
|
}
|
|
|
|
|
2010-09-26 00:31:00 -06:00
|
|
|
/**
|
2007-10-17 00:30:46 -06:00
|
|
|
* ext2_try_to_allocate()
|
|
|
|
* @sb: superblock
|
|
|
|
* @group: given allocation block group
|
|
|
|
* @bitmap_bh: bufferhead holds the block bitmap
|
|
|
|
* @grp_goal: given target block within the group
|
|
|
|
* @count: target number of blocks to allocate
|
|
|
|
* @my_rsv: reservation window
|
|
|
|
*
|
|
|
|
* Attempt to allocate blocks within a give range. Set the range of allocation
|
|
|
|
* first, then find the first free bit(s) from the bitmap (within the range),
|
|
|
|
* and at last, allocate the blocks by claiming the found free bit as allocated.
|
|
|
|
*
|
|
|
|
* To set the range of this allocation:
|
|
|
|
* if there is a reservation window, only try to allocate block(s)
|
|
|
|
* from the file's own reservation window;
|
|
|
|
* Otherwise, the allocation range starts from the give goal block,
|
|
|
|
* ends at the block group's last block.
|
|
|
|
*
|
|
|
|
* If we failed to allocate the desired block then we may end up crossing to a
|
|
|
|
* new bitmap.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
ext2_try_to_allocate(struct super_block *sb, int group,
|
|
|
|
struct buffer_head *bitmap_bh, ext2_grpblk_t grp_goal,
|
|
|
|
unsigned long *count,
|
|
|
|
struct ext2_reserve_window *my_rsv)
|
|
|
|
{
|
|
|
|
ext2_fsblk_t group_first_block;
|
|
|
|
ext2_grpblk_t start, end;
|
|
|
|
unsigned long num = 0;
|
|
|
|
|
|
|
|
/* we do allocation within the reservation window if we have a window */
|
|
|
|
if (my_rsv) {
|
|
|
|
group_first_block = ext2_group_first_block_no(sb, group);
|
|
|
|
if (my_rsv->_rsv_start >= group_first_block)
|
|
|
|
start = my_rsv->_rsv_start - group_first_block;
|
|
|
|
else
|
|
|
|
/* reservation window cross group boundary */
|
|
|
|
start = 0;
|
|
|
|
end = my_rsv->_rsv_end - group_first_block + 1;
|
|
|
|
if (end > EXT2_BLOCKS_PER_GROUP(sb))
|
|
|
|
/* reservation window crosses group boundary */
|
|
|
|
end = EXT2_BLOCKS_PER_GROUP(sb);
|
|
|
|
if ((start <= grp_goal) && (grp_goal < end))
|
|
|
|
start = grp_goal;
|
|
|
|
else
|
|
|
|
grp_goal = -1;
|
|
|
|
} else {
|
|
|
|
if (grp_goal > 0)
|
|
|
|
start = grp_goal;
|
|
|
|
else
|
|
|
|
start = 0;
|
|
|
|
end = EXT2_BLOCKS_PER_GROUP(sb);
|
|
|
|
}
|
|
|
|
|
|
|
|
BUG_ON(start > EXT2_BLOCKS_PER_GROUP(sb));
|
|
|
|
|
|
|
|
repeat:
|
|
|
|
if (grp_goal < 0) {
|
|
|
|
grp_goal = find_next_usable_block(start, bitmap_bh, end);
|
|
|
|
if (grp_goal < 0)
|
|
|
|
goto fail_access;
|
|
|
|
if (!my_rsv) {
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < 7 && grp_goal > start &&
|
|
|
|
!ext2_test_bit(grp_goal - 1,
|
|
|
|
bitmap_bh->b_data);
|
|
|
|
i++, grp_goal--)
|
|
|
|
;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
start = grp_goal;
|
|
|
|
|
|
|
|
if (ext2_set_bit_atomic(sb_bgl_lock(EXT2_SB(sb), group), grp_goal,
|
|
|
|
bitmap_bh->b_data)) {
|
|
|
|
/*
|
|
|
|
* The block was allocated by another thread, or it was
|
|
|
|
* allocated and then freed by another thread
|
|
|
|
*/
|
|
|
|
start++;
|
|
|
|
grp_goal++;
|
|
|
|
if (start >= end)
|
|
|
|
goto fail_access;
|
|
|
|
goto repeat;
|
|
|
|
}
|
|
|
|
num++;
|
|
|
|
grp_goal++;
|
|
|
|
while (num < *count && grp_goal < end
|
|
|
|
&& !ext2_set_bit_atomic(sb_bgl_lock(EXT2_SB(sb), group),
|
|
|
|
grp_goal, bitmap_bh->b_data)) {
|
|
|
|
num++;
|
|
|
|
grp_goal++;
|
|
|
|
}
|
|
|
|
*count = num;
|
|
|
|
return grp_goal - num;
|
|
|
|
fail_access:
|
|
|
|
*count = num;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* find_next_reservable_window():
|
|
|
|
* find a reservable space within the given range.
|
|
|
|
* It does not allocate the reservation window for now:
|
|
|
|
* alloc_new_reservation() will do the work later.
|
|
|
|
*
|
|
|
|
* @search_head: the head of the searching list;
|
|
|
|
* This is not necessarily the list head of the whole filesystem
|
|
|
|
*
|
|
|
|
* We have both head and start_block to assist the search
|
|
|
|
* for the reservable space. The list starts from head,
|
|
|
|
* but we will shift to the place where start_block is,
|
|
|
|
* then start from there, when looking for a reservable space.
|
|
|
|
*
|
|
|
|
* @size: the target new reservation window size
|
|
|
|
*
|
|
|
|
* @group_first_block: the first block we consider to start
|
|
|
|
* the real search from
|
|
|
|
*
|
|
|
|
* @last_block:
|
|
|
|
* the maximum block number that our goal reservable space
|
|
|
|
* could start from. This is normally the last block in this
|
|
|
|
* group. The search will end when we found the start of next
|
|
|
|
* possible reservable space is out of this boundary.
|
|
|
|
* This could handle the cross boundary reservation window
|
|
|
|
* request.
|
|
|
|
*
|
|
|
|
* basically we search from the given range, rather than the whole
|
|
|
|
* reservation double linked list, (start_block, last_block)
|
|
|
|
* to find a free region that is of my size and has not
|
|
|
|
* been reserved.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
static int find_next_reservable_window(
|
|
|
|
struct ext2_reserve_window_node *search_head,
|
|
|
|
struct ext2_reserve_window_node *my_rsv,
|
|
|
|
struct super_block * sb,
|
|
|
|
ext2_fsblk_t start_block,
|
|
|
|
ext2_fsblk_t last_block)
|
|
|
|
{
|
|
|
|
struct rb_node *next;
|
|
|
|
struct ext2_reserve_window_node *rsv, *prev;
|
|
|
|
ext2_fsblk_t cur;
|
|
|
|
int size = my_rsv->rsv_goal_size;
|
|
|
|
|
|
|
|
/* TODO: make the start of the reservation window byte-aligned */
|
|
|
|
/* cur = *start_block & ~7;*/
|
|
|
|
cur = start_block;
|
|
|
|
rsv = search_head;
|
|
|
|
if (!rsv)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
if (cur <= rsv->rsv_end)
|
|
|
|
cur = rsv->rsv_end + 1;
|
|
|
|
|
|
|
|
/* TODO?
|
|
|
|
* in the case we could not find a reservable space
|
|
|
|
* that is what is expected, during the re-search, we could
|
|
|
|
* remember what's the largest reservable space we could have
|
|
|
|
* and return that one.
|
|
|
|
*
|
|
|
|
* For now it will fail if we could not find the reservable
|
|
|
|
* space with expected-size (or more)...
|
|
|
|
*/
|
|
|
|
if (cur > last_block)
|
|
|
|
return -1; /* fail */
|
|
|
|
|
|
|
|
prev = rsv;
|
|
|
|
next = rb_next(&rsv->rsv_node);
|
|
|
|
rsv = rb_entry(next,struct ext2_reserve_window_node,rsv_node);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2007-10-17 00:30:46 -06:00
|
|
|
* Reached the last reservation, we can just append to the
|
|
|
|
* previous one.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2007-10-17 00:30:46 -06:00
|
|
|
if (!next)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (cur + size <= rsv->rsv_start) {
|
|
|
|
/*
|
|
|
|
* Found a reserveable space big enough. We could
|
|
|
|
* have a reservation across the group boundary here
|
|
|
|
*/
|
|
|
|
break;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2007-10-17 00:30:46 -06:00
|
|
|
/*
|
|
|
|
* we come here either :
|
|
|
|
* when we reach the end of the whole list,
|
|
|
|
* and there is empty reservable space after last entry in the list.
|
|
|
|
* append it to the end of the list.
|
|
|
|
*
|
|
|
|
* or we found one reservable space in the middle of the list,
|
|
|
|
* return the reservation window that we could append to.
|
|
|
|
* succeed.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if ((prev != my_rsv) && (!rsv_is_empty(&my_rsv->rsv_window)))
|
|
|
|
rsv_window_remove(sb, my_rsv);
|
|
|
|
|
|
|
|
/*
|
2011-03-30 19:57:33 -06:00
|
|
|
* Let's book the whole available window for now. We will check the
|
2007-10-17 00:30:46 -06:00
|
|
|
* disk bitmap later and then, if there are free blocks then we adjust
|
|
|
|
* the window size if it's larger than requested.
|
|
|
|
* Otherwise, we will remove this node from the tree next time
|
|
|
|
* call find_next_reservable_window.
|
|
|
|
*/
|
|
|
|
my_rsv->rsv_start = cur;
|
|
|
|
my_rsv->rsv_end = cur + size - 1;
|
|
|
|
my_rsv->rsv_alloc_hit = 0;
|
|
|
|
|
|
|
|
if (prev != my_rsv)
|
|
|
|
ext2_rsv_window_add(sb, my_rsv);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* alloc_new_reservation()--allocate a new reservation window
|
|
|
|
*
|
|
|
|
* To make a new reservation, we search part of the filesystem
|
|
|
|
* reservation list (the list that inside the group). We try to
|
|
|
|
* allocate a new reservation window near the allocation goal,
|
|
|
|
* or the beginning of the group, if there is no goal.
|
|
|
|
*
|
|
|
|
* We first find a reservable space after the goal, then from
|
|
|
|
* there, we check the bitmap for the first free block after
|
|
|
|
* it. If there is no free block until the end of group, then the
|
|
|
|
* whole group is full, we failed. Otherwise, check if the free
|
|
|
|
* block is inside the expected reservable space, if so, we
|
|
|
|
* succeed.
|
|
|
|
* If the first free block is outside the reservable space, then
|
|
|
|
* start from the first free block, we search for next available
|
|
|
|
* space, and go on.
|
|
|
|
*
|
|
|
|
* on succeed, a new reservation will be found and inserted into the list
|
|
|
|
* It contains at least one free block, and it does not overlap with other
|
|
|
|
* reservation windows.
|
|
|
|
*
|
|
|
|
* failed: we failed to find a reservation window in this group
|
|
|
|
*
|
|
|
|
* @rsv: the reservation
|
|
|
|
*
|
|
|
|
* @grp_goal: The goal (group-relative). It is where the search for a
|
|
|
|
* free reservable space should start from.
|
|
|
|
* if we have a goal(goal >0 ), then start from there,
|
|
|
|
* no goal(goal = -1), we start from the first block
|
|
|
|
* of the group.
|
|
|
|
*
|
|
|
|
* @sb: the super block
|
|
|
|
* @group: the group we are trying to allocate in
|
|
|
|
* @bitmap_bh: the block group block bitmap
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
static int alloc_new_reservation(struct ext2_reserve_window_node *my_rsv,
|
|
|
|
ext2_grpblk_t grp_goal, struct super_block *sb,
|
|
|
|
unsigned int group, struct buffer_head *bitmap_bh)
|
|
|
|
{
|
|
|
|
struct ext2_reserve_window_node *search_head;
|
|
|
|
ext2_fsblk_t group_first_block, group_end_block, start_block;
|
|
|
|
ext2_grpblk_t first_free_block;
|
|
|
|
struct rb_root *fs_rsv_root = &EXT2_SB(sb)->s_rsv_window_root;
|
|
|
|
unsigned long size;
|
|
|
|
int ret;
|
|
|
|
spinlock_t *rsv_lock = &EXT2_SB(sb)->s_rsv_window_lock;
|
|
|
|
|
|
|
|
group_first_block = ext2_group_first_block_no(sb, group);
|
|
|
|
group_end_block = group_first_block + (EXT2_BLOCKS_PER_GROUP(sb) - 1);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-10-17 00:30:46 -06:00
|
|
|
if (grp_goal < 0)
|
|
|
|
start_block = group_first_block;
|
|
|
|
else
|
|
|
|
start_block = grp_goal + group_first_block;
|
|
|
|
|
|
|
|
size = my_rsv->rsv_goal_size;
|
|
|
|
|
|
|
|
if (!rsv_is_empty(&my_rsv->rsv_window)) {
|
|
|
|
/*
|
|
|
|
* if the old reservation is cross group boundary
|
|
|
|
* and if the goal is inside the old reservation window,
|
|
|
|
* we will come here when we just failed to allocate from
|
|
|
|
* the first part of the window. We still have another part
|
|
|
|
* that belongs to the next group. In this case, there is no
|
|
|
|
* point to discard our window and try to allocate a new one
|
|
|
|
* in this group(which will fail). we should
|
|
|
|
* keep the reservation window, just simply move on.
|
|
|
|
*
|
|
|
|
* Maybe we could shift the start block of the reservation
|
|
|
|
* window to the first block of next group.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2007-10-17 00:30:46 -06:00
|
|
|
|
|
|
|
if ((my_rsv->rsv_start <= group_end_block) &&
|
|
|
|
(my_rsv->rsv_end > group_end_block) &&
|
|
|
|
(start_block >= my_rsv->rsv_start))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if ((my_rsv->rsv_alloc_hit >
|
|
|
|
(my_rsv->rsv_end - my_rsv->rsv_start + 1) / 2)) {
|
|
|
|
/*
|
|
|
|
* if the previously allocation hit ratio is
|
|
|
|
* greater than 1/2, then we double the size of
|
|
|
|
* the reservation window the next time,
|
|
|
|
* otherwise we keep the same size window
|
|
|
|
*/
|
|
|
|
size = size * 2;
|
|
|
|
if (size > EXT2_MAX_RESERVE_BLOCKS)
|
|
|
|
size = EXT2_MAX_RESERVE_BLOCKS;
|
|
|
|
my_rsv->rsv_goal_size= size;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-10-17 00:30:46 -06:00
|
|
|
spin_lock(rsv_lock);
|
|
|
|
/*
|
|
|
|
* shift the search start to the window near the goal block
|
|
|
|
*/
|
|
|
|
search_head = search_reserve_window(fs_rsv_root, start_block);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* find_next_reservable_window() simply finds a reservable window
|
|
|
|
* inside the given range(start_block, group_end_block).
|
|
|
|
*
|
|
|
|
* To make sure the reservation window has a free bit inside it, we
|
|
|
|
* need to check the bitmap after we found a reservable window.
|
|
|
|
*/
|
|
|
|
retry:
|
|
|
|
ret = find_next_reservable_window(search_head, my_rsv, sb,
|
|
|
|
start_block, group_end_block);
|
|
|
|
|
|
|
|
if (ret == -1) {
|
|
|
|
if (!rsv_is_empty(&my_rsv->rsv_window))
|
|
|
|
rsv_window_remove(sb, my_rsv);
|
|
|
|
spin_unlock(rsv_lock);
|
|
|
|
return -1;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2007-10-17 00:30:46 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* On success, find_next_reservable_window() returns the
|
|
|
|
* reservation window where there is a reservable space after it.
|
|
|
|
* Before we reserve this reservable space, we need
|
|
|
|
* to make sure there is at least a free block inside this region.
|
|
|
|
*
|
|
|
|
* Search the first free bit on the block bitmap. Search starts from
|
|
|
|
* the start block of the reservable space we just found.
|
|
|
|
*/
|
|
|
|
spin_unlock(rsv_lock);
|
|
|
|
first_free_block = bitmap_search_next_usable_block(
|
|
|
|
my_rsv->rsv_start - group_first_block,
|
|
|
|
bitmap_bh, group_end_block - group_first_block + 1);
|
|
|
|
|
|
|
|
if (first_free_block < 0) {
|
|
|
|
/*
|
|
|
|
* no free block left on the bitmap, no point
|
|
|
|
* to reserve the space. return failed.
|
|
|
|
*/
|
|
|
|
spin_lock(rsv_lock);
|
|
|
|
if (!rsv_is_empty(&my_rsv->rsv_window))
|
|
|
|
rsv_window_remove(sb, my_rsv);
|
|
|
|
spin_unlock(rsv_lock);
|
|
|
|
return -1; /* failed */
|
|
|
|
}
|
|
|
|
|
|
|
|
start_block = first_free_block + group_first_block;
|
|
|
|
/*
|
|
|
|
* check if the first free block is within the
|
|
|
|
* free space we just reserved
|
|
|
|
*/
|
|
|
|
if (start_block >= my_rsv->rsv_start && start_block <= my_rsv->rsv_end)
|
|
|
|
return 0; /* success */
|
|
|
|
/*
|
|
|
|
* if the first free bit we found is out of the reservable space
|
|
|
|
* continue search for next reservable space,
|
|
|
|
* start from where the free block is,
|
|
|
|
* we also shift the list head to where we stopped last time
|
|
|
|
*/
|
|
|
|
search_head = my_rsv;
|
|
|
|
spin_lock(rsv_lock);
|
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* try_to_extend_reservation()
|
|
|
|
* @my_rsv: given reservation window
|
|
|
|
* @sb: super block
|
|
|
|
* @size: the delta to extend
|
|
|
|
*
|
|
|
|
* Attempt to expand the reservation window large enough to have
|
|
|
|
* required number of free blocks
|
|
|
|
*
|
|
|
|
* Since ext2_try_to_allocate() will always allocate blocks within
|
|
|
|
* the reservation window range, if the window size is too small,
|
|
|
|
* multiple blocks allocation has to stop at the end of the reservation
|
|
|
|
* window. To make this more efficient, given the total number of
|
|
|
|
* blocks needed and the current size of the window, we try to
|
|
|
|
* expand the reservation window size if necessary on a best-effort
|
|
|
|
* basis before ext2_new_blocks() tries to allocate blocks.
|
|
|
|
*/
|
|
|
|
static void try_to_extend_reservation(struct ext2_reserve_window_node *my_rsv,
|
|
|
|
struct super_block *sb, int size)
|
|
|
|
{
|
|
|
|
struct ext2_reserve_window_node *next_rsv;
|
|
|
|
struct rb_node *next;
|
|
|
|
spinlock_t *rsv_lock = &EXT2_SB(sb)->s_rsv_window_lock;
|
|
|
|
|
|
|
|
if (!spin_trylock(rsv_lock))
|
|
|
|
return;
|
|
|
|
|
|
|
|
next = rb_next(&my_rsv->rsv_node);
|
|
|
|
|
|
|
|
if (!next)
|
|
|
|
my_rsv->rsv_end += size;
|
|
|
|
else {
|
|
|
|
next_rsv = rb_entry(next, struct ext2_reserve_window_node, rsv_node);
|
|
|
|
|
|
|
|
if ((next_rsv->rsv_start - my_rsv->rsv_end - 1) >= size)
|
|
|
|
my_rsv->rsv_end += size;
|
|
|
|
else
|
|
|
|
my_rsv->rsv_end = next_rsv->rsv_start - 1;
|
|
|
|
}
|
|
|
|
spin_unlock(rsv_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ext2_try_to_allocate_with_rsv()
|
|
|
|
* @sb: superblock
|
|
|
|
* @group: given allocation block group
|
|
|
|
* @bitmap_bh: bufferhead holds the block bitmap
|
|
|
|
* @grp_goal: given target block within the group
|
|
|
|
* @count: target number of blocks to allocate
|
|
|
|
* @my_rsv: reservation window
|
|
|
|
*
|
|
|
|
* This is the main function used to allocate a new block and its reservation
|
|
|
|
* window.
|
|
|
|
*
|
|
|
|
* Each time when a new block allocation is need, first try to allocate from
|
|
|
|
* its own reservation. If it does not have a reservation window, instead of
|
|
|
|
* looking for a free bit on bitmap first, then look up the reservation list to
|
|
|
|
* see if it is inside somebody else's reservation window, we try to allocate a
|
|
|
|
* reservation window for it starting from the goal first. Then do the block
|
|
|
|
* allocation within the reservation window.
|
|
|
|
*
|
|
|
|
* This will avoid keeping on searching the reservation list again and
|
|
|
|
* again when somebody is looking for a free block (without
|
|
|
|
* reservation), and there are lots of free blocks, but they are all
|
|
|
|
* being reserved.
|
|
|
|
*
|
|
|
|
* We use a red-black tree for the per-filesystem reservation list.
|
|
|
|
*/
|
|
|
|
static ext2_grpblk_t
|
|
|
|
ext2_try_to_allocate_with_rsv(struct super_block *sb, unsigned int group,
|
|
|
|
struct buffer_head *bitmap_bh, ext2_grpblk_t grp_goal,
|
|
|
|
struct ext2_reserve_window_node * my_rsv,
|
|
|
|
unsigned long *count)
|
|
|
|
{
|
|
|
|
ext2_fsblk_t group_first_block, group_last_block;
|
|
|
|
ext2_grpblk_t ret = 0;
|
|
|
|
unsigned long num = *count;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* we don't deal with reservation when
|
|
|
|
* filesystem is mounted without reservation
|
|
|
|
* or the file is not a regular file
|
|
|
|
* or last attempt to allocate a block with reservation turned on failed
|
|
|
|
*/
|
|
|
|
if (my_rsv == NULL) {
|
|
|
|
return ext2_try_to_allocate(sb, group, bitmap_bh,
|
|
|
|
grp_goal, count, NULL);
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* grp_goal is a group relative block number (if there is a goal)
|
|
|
|
* 0 <= grp_goal < EXT2_BLOCKS_PER_GROUP(sb)
|
|
|
|
* first block is a filesystem wide block number
|
|
|
|
* first block is the block number of the first block in this group
|
|
|
|
*/
|
|
|
|
group_first_block = ext2_group_first_block_no(sb, group);
|
|
|
|
group_last_block = group_first_block + (EXT2_BLOCKS_PER_GROUP(sb) - 1);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Basically we will allocate a new block from inode's reservation
|
|
|
|
* window.
|
|
|
|
*
|
|
|
|
* We need to allocate a new reservation window, if:
|
|
|
|
* a) inode does not have a reservation window; or
|
|
|
|
* b) last attempt to allocate a block from existing reservation
|
|
|
|
* failed; or
|
|
|
|
* c) we come here with a goal and with a reservation window
|
|
|
|
*
|
|
|
|
* We do not need to allocate a new reservation window if we come here
|
|
|
|
* at the beginning with a goal and the goal is inside the window, or
|
|
|
|
* we don't have a goal but already have a reservation window.
|
|
|
|
* then we could go to allocate from the reservation window directly.
|
|
|
|
*/
|
|
|
|
while (1) {
|
|
|
|
if (rsv_is_empty(&my_rsv->rsv_window) || (ret < 0) ||
|
|
|
|
!goal_in_my_reservation(&my_rsv->rsv_window,
|
|
|
|
grp_goal, group, sb)) {
|
|
|
|
if (my_rsv->rsv_goal_size < *count)
|
|
|
|
my_rsv->rsv_goal_size = *count;
|
|
|
|
ret = alloc_new_reservation(my_rsv, grp_goal, sb,
|
|
|
|
group, bitmap_bh);
|
|
|
|
if (ret < 0)
|
|
|
|
break; /* failed */
|
|
|
|
|
|
|
|
if (!goal_in_my_reservation(&my_rsv->rsv_window,
|
|
|
|
grp_goal, group, sb))
|
|
|
|
grp_goal = -1;
|
|
|
|
} else if (grp_goal >= 0) {
|
|
|
|
int curr = my_rsv->rsv_end -
|
|
|
|
(grp_goal + group_first_block) + 1;
|
|
|
|
|
|
|
|
if (curr < *count)
|
|
|
|
try_to_extend_reservation(my_rsv, sb,
|
|
|
|
*count - curr);
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((my_rsv->rsv_start > group_last_block) ||
|
|
|
|
(my_rsv->rsv_end < group_first_block)) {
|
|
|
|
rsv_window_dump(&EXT2_SB(sb)->s_rsv_window_root, 1);
|
|
|
|
BUG();
|
|
|
|
}
|
|
|
|
ret = ext2_try_to_allocate(sb, group, bitmap_bh, grp_goal,
|
|
|
|
&num, &my_rsv->rsv_window);
|
|
|
|
if (ret >= 0) {
|
|
|
|
my_rsv->rsv_alloc_hit += num;
|
|
|
|
*count = num;
|
|
|
|
break; /* succeed */
|
|
|
|
}
|
|
|
|
num = *count;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ext2_has_free_blocks()
|
|
|
|
* @sbi: in-core super block structure.
|
|
|
|
*
|
|
|
|
* Check if filesystem has at least 1 free block available for allocation.
|
|
|
|
*/
|
|
|
|
static int ext2_has_free_blocks(struct ext2_sb_info *sbi)
|
|
|
|
{
|
|
|
|
ext2_fsblk_t free_blocks, root_blocks;
|
|
|
|
|
|
|
|
free_blocks = percpu_counter_read_positive(&sbi->s_freeblocks_counter);
|
|
|
|
root_blocks = le32_to_cpu(sbi->s_es->s_r_blocks_count);
|
|
|
|
if (free_blocks < root_blocks + 1 && !capable(CAP_SYS_RESOURCE) &&
|
2012-02-07 16:39:12 -07:00
|
|
|
!uid_eq(sbi->s_resuid, current_fsuid()) &&
|
|
|
|
(gid_eq(sbi->s_resgid, GLOBAL_ROOT_GID) ||
|
|
|
|
!in_group_p (sbi->s_resgid))) {
|
2007-10-17 00:30:46 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
ext2: fix filesystem deadlock while reading corrupted xattr block
This bug can be reproducible with fsfuzzer, although, I couldn't reproduce it
100% of my tries, it is quite easily reproducible.
During the deletion of an inode, ext2_xattr_delete_inode() does not check if the
block pointed by EXT2_I(inode)->i_file_acl is a valid data block, this might
lead to a deadlock, when i_file_acl == 1, and the filesystem block size is 1024.
In that situation, ext2_xattr_delete_inode, will load the superblock's buffer
head (instead of a valid i_file_acl block), and then lock that buffer head,
which, ext2_sync_super will also try to lock, making the filesystem deadlock in
the following stack trace:
root 17180 0.0 0.0 113660 660 pts/0 D+ 07:08 0:00 rmdir
/media/test/dir1
[<ffffffff8125da9f>] __sync_dirty_buffer+0xaf/0x100
[<ffffffff8125db03>] sync_dirty_buffer+0x13/0x20
[<ffffffffa03f0d57>] ext2_sync_super+0xb7/0xc0 [ext2]
[<ffffffffa03f10b9>] ext2_error+0x119/0x130 [ext2]
[<ffffffffa03e9d93>] ext2_free_blocks+0x83/0x350 [ext2]
[<ffffffffa03f3d03>] ext2_xattr_delete_inode+0x173/0x190 [ext2]
[<ffffffffa03ee9e9>] ext2_evict_inode+0xc9/0x130 [ext2]
[<ffffffff8123fd23>] evict+0xb3/0x180
[<ffffffff81240008>] iput+0x1b8/0x240
[<ffffffff8123c4ac>] d_delete+0x11c/0x150
[<ffffffff8122fa7e>] vfs_rmdir+0xfe/0x120
[<ffffffff812340ee>] do_rmdir+0x17e/0x1f0
[<ffffffff81234dd6>] SyS_rmdir+0x16/0x20
[<ffffffff81838cf2>] entry_SYSCALL_64_fastpath+0x1a/0xa4
[<ffffffffffffffff>] 0xffffffffffffffff
Fix this by using the same approach ext4 uses to test data blocks validity,
implementing ext2_data_block_valid.
An another possibility when the superblock is very corrupted, is that i_file_acl
is 1, block_count is 1 and first_data_block is 0. For such situations, we might
have i_file_acl pointing to a 'valid' block, but still step over the superblock.
The approach I used was to also test if the superblock is not in the range
described by ext2_data_block_valid() arguments
Signed-off-by: Carlos Maiolino <cmaiolino@redhat.com>
Signed-off-by: Theodore Ts'o <tytso@mit.edu>
2016-07-05 20:02:41 -06:00
|
|
|
/*
|
|
|
|
* Returns 1 if the passed-in block region is valid; 0 if some part overlaps
|
|
|
|
* with filesystem metadata blocksi.
|
|
|
|
*/
|
|
|
|
int ext2_data_block_valid(struct ext2_sb_info *sbi, ext2_fsblk_t start_blk,
|
|
|
|
unsigned int count)
|
|
|
|
{
|
|
|
|
if ((start_blk <= le32_to_cpu(sbi->s_es->s_first_data_block)) ||
|
|
|
|
(start_blk + count < start_blk) ||
|
|
|
|
(start_blk > le32_to_cpu(sbi->s_es->s_blocks_count)))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* Ensure we do not step over superblock */
|
|
|
|
if ((start_blk <= sbi->s_sb_block) &&
|
|
|
|
(start_blk + count >= sbi->s_sb_block))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2007-10-17 00:30:46 -06:00
|
|
|
* ext2_new_blocks() -- core block(s) allocation function
|
|
|
|
* @inode: file inode
|
|
|
|
* @goal: given target block(filesystem wide)
|
|
|
|
* @count: target number of blocks to allocate
|
|
|
|
* @errp: error code
|
|
|
|
*
|
|
|
|
* ext2_new_blocks uses a goal block to assist allocation. If the goal is
|
2005-04-16 16:20:36 -06:00
|
|
|
* free, or there is a free block within 32 blocks of the goal, that block
|
|
|
|
* is allocated. Otherwise a forward search is made for a free block; within
|
|
|
|
* each block group the search first looks for an entire free byte in the block
|
|
|
|
* bitmap, and then for any free bit if that fails.
|
|
|
|
* This function also updates quota and i_blocks field.
|
|
|
|
*/
|
2007-10-17 00:30:46 -06:00
|
|
|
ext2_fsblk_t ext2_new_blocks(struct inode *inode, ext2_fsblk_t goal,
|
|
|
|
unsigned long *count, int *errp)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct buffer_head *bitmap_bh = NULL;
|
2007-10-17 00:30:46 -06:00
|
|
|
struct buffer_head *gdp_bh;
|
|
|
|
int group_no;
|
|
|
|
int goal_group;
|
|
|
|
ext2_grpblk_t grp_target_blk; /* blockgroup relative goal block */
|
|
|
|
ext2_grpblk_t grp_alloc_blk; /* blockgroup-relative allocated block*/
|
|
|
|
ext2_fsblk_t ret_block; /* filesyetem-wide allocated block */
|
|
|
|
int bgi; /* blockgroup iteration index */
|
|
|
|
int performed_allocation = 0;
|
|
|
|
ext2_grpblk_t free_blocks; /* number of free blocks in a group */
|
|
|
|
struct super_block *sb;
|
|
|
|
struct ext2_group_desc *gdp;
|
|
|
|
struct ext2_super_block *es;
|
|
|
|
struct ext2_sb_info *sbi;
|
|
|
|
struct ext2_reserve_window_node *my_rsv = NULL;
|
|
|
|
struct ext2_block_alloc_info *block_i;
|
|
|
|
unsigned short windowsz = 0;
|
|
|
|
unsigned long ngroups;
|
|
|
|
unsigned long num = *count;
|
2010-03-03 07:05:00 -07:00
|
|
|
int ret;
|
2007-10-17 00:30:46 -06:00
|
|
|
|
|
|
|
*errp = -ENOSPC;
|
|
|
|
sb = inode->i_sb;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-10-17 00:30:46 -06:00
|
|
|
/*
|
|
|
|
* Check quota for allocation of this block.
|
|
|
|
*/
|
2010-03-03 07:05:00 -07:00
|
|
|
ret = dquot_alloc_block(inode, num);
|
|
|
|
if (ret) {
|
|
|
|
*errp = ret;
|
2007-10-17 00:30:46 -06:00
|
|
|
return 0;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-10-17 00:30:46 -06:00
|
|
|
sbi = EXT2_SB(sb);
|
|
|
|
es = EXT2_SB(sb)->s_es;
|
|
|
|
ext2_debug("goal=%lu.\n", goal);
|
|
|
|
/*
|
|
|
|
* Allocate a block from reservation only when
|
|
|
|
* filesystem is mounted with reservation(default,-o reservation), and
|
|
|
|
* it's a regular file, and
|
|
|
|
* the desired window size is greater than 0 (One could use ioctl
|
|
|
|
* command EXT2_IOC_SETRSVSZ to set the window size to 0 to turn off
|
|
|
|
* reservation on that particular file)
|
|
|
|
*/
|
|
|
|
block_i = EXT2_I(inode)->i_block_alloc_info;
|
|
|
|
if (block_i) {
|
|
|
|
windowsz = block_i->rsv_window_node.rsv_goal_size;
|
|
|
|
if (windowsz > 0)
|
|
|
|
my_rsv = &block_i->rsv_window_node;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-10-17 00:30:46 -06:00
|
|
|
if (!ext2_has_free_blocks(sbi)) {
|
|
|
|
*errp = -ENOSPC;
|
|
|
|
goto out;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-10-17 00:30:46 -06:00
|
|
|
/*
|
|
|
|
* First, test whether the goal block is free.
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
if (goal < le32_to_cpu(es->s_first_data_block) ||
|
|
|
|
goal >= le32_to_cpu(es->s_blocks_count))
|
|
|
|
goal = le32_to_cpu(es->s_first_data_block);
|
2007-10-17 00:30:46 -06:00
|
|
|
group_no = (goal - le32_to_cpu(es->s_first_data_block)) /
|
|
|
|
EXT2_BLOCKS_PER_GROUP(sb);
|
|
|
|
goal_group = group_no;
|
|
|
|
retry_alloc:
|
|
|
|
gdp = ext2_get_group_desc(sb, group_no, &gdp_bh);
|
|
|
|
if (!gdp)
|
2005-04-16 16:20:36 -06:00
|
|
|
goto io_error;
|
|
|
|
|
2007-10-17 00:30:46 -06:00
|
|
|
free_blocks = le16_to_cpu(gdp->bg_free_blocks_count);
|
|
|
|
/*
|
|
|
|
* if there is not enough free blocks to make a new resevation
|
|
|
|
* turn off reservation for this allocation
|
|
|
|
*/
|
|
|
|
if (my_rsv && (free_blocks < windowsz)
|
2008-10-15 23:04:01 -06:00
|
|
|
&& (free_blocks > 0)
|
2007-10-17 00:30:46 -06:00
|
|
|
&& (rsv_is_empty(&my_rsv->rsv_window)))
|
|
|
|
my_rsv = NULL;
|
|
|
|
|
|
|
|
if (free_blocks > 0) {
|
|
|
|
grp_target_blk = ((goal - le32_to_cpu(es->s_first_data_block)) %
|
|
|
|
EXT2_BLOCKS_PER_GROUP(sb));
|
2005-04-16 16:20:36 -06:00
|
|
|
bitmap_bh = read_block_bitmap(sb, group_no);
|
|
|
|
if (!bitmap_bh)
|
|
|
|
goto io_error;
|
2007-10-17 00:30:46 -06:00
|
|
|
grp_alloc_blk = ext2_try_to_allocate_with_rsv(sb, group_no,
|
|
|
|
bitmap_bh, grp_target_blk,
|
|
|
|
my_rsv, &num);
|
|
|
|
if (grp_alloc_blk >= 0)
|
|
|
|
goto allocated;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-10-17 00:30:46 -06:00
|
|
|
ngroups = EXT2_SB(sb)->s_groups_count;
|
|
|
|
smp_rmb();
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
2008-02-06 02:40:15 -07:00
|
|
|
* Now search the rest of the groups. We assume that
|
|
|
|
* group_no and gdp correctly point to the last group visited.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2007-10-17 00:30:46 -06:00
|
|
|
for (bgi = 0; bgi < ngroups; bgi++) {
|
2005-04-16 16:20:36 -06:00
|
|
|
group_no++;
|
2007-10-17 00:30:46 -06:00
|
|
|
if (group_no >= ngroups)
|
2005-04-16 16:20:36 -06:00
|
|
|
group_no = 0;
|
2007-10-17 00:30:46 -06:00
|
|
|
gdp = ext2_get_group_desc(sb, group_no, &gdp_bh);
|
|
|
|
if (!gdp)
|
2005-04-16 16:20:36 -06:00
|
|
|
goto io_error;
|
|
|
|
|
2007-10-17 00:30:46 -06:00
|
|
|
free_blocks = le16_to_cpu(gdp->bg_free_blocks_count);
|
2010-03-29 05:55:39 -06:00
|
|
|
/*
|
|
|
|
* skip this group (and avoid loading bitmap) if there
|
|
|
|
* are no free blocks
|
|
|
|
*/
|
|
|
|
if (!free_blocks)
|
|
|
|
continue;
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2007-10-17 00:30:46 -06:00
|
|
|
* skip this group if the number of
|
|
|
|
* free blocks is less than half of the reservation
|
|
|
|
* window size.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2008-10-15 23:04:01 -06:00
|
|
|
if (my_rsv && (free_blocks <= (windowsz/2)))
|
2007-10-17 00:30:46 -06:00
|
|
|
continue;
|
|
|
|
|
|
|
|
brelse(bitmap_bh);
|
|
|
|
bitmap_bh = read_block_bitmap(sb, group_no);
|
|
|
|
if (!bitmap_bh)
|
2005-04-16 16:20:36 -06:00
|
|
|
goto io_error;
|
|
|
|
/*
|
2007-10-17 00:30:46 -06:00
|
|
|
* try to allocate block(s) from this group, without a goal(-1).
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2007-10-17 00:30:46 -06:00
|
|
|
grp_alloc_blk = ext2_try_to_allocate_with_rsv(sb, group_no,
|
|
|
|
bitmap_bh, -1, my_rsv, &num);
|
|
|
|
if (grp_alloc_blk >= 0)
|
|
|
|
goto allocated;
|
|
|
|
}
|
|
|
|
/*
|
2011-03-30 19:57:33 -06:00
|
|
|
* We may end up a bogus earlier ENOSPC error due to
|
2007-10-17 00:30:46 -06:00
|
|
|
* filesystem is "full" of reservations, but
|
2011-03-30 19:57:33 -06:00
|
|
|
* there maybe indeed free blocks available on disk
|
2007-10-17 00:30:46 -06:00
|
|
|
* In this case, we just forget about the reservations
|
|
|
|
* just do block allocation as without reservations.
|
|
|
|
*/
|
|
|
|
if (my_rsv) {
|
|
|
|
my_rsv = NULL;
|
|
|
|
windowsz = 0;
|
|
|
|
group_no = goal_group;
|
|
|
|
goto retry_alloc;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2007-10-17 00:30:46 -06:00
|
|
|
/* No space left on the device */
|
|
|
|
*errp = -ENOSPC;
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
allocated:
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
ext2_debug("using block group %d(%d)\n",
|
2007-10-17 00:30:46 -06:00
|
|
|
group_no, gdp->bg_free_blocks_count);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-10-17 00:30:46 -06:00
|
|
|
ret_block = grp_alloc_blk + ext2_group_first_block_no(sb, group_no);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-10-17 00:30:46 -06:00
|
|
|
if (in_range(le32_to_cpu(gdp->bg_block_bitmap), ret_block, num) ||
|
|
|
|
in_range(le32_to_cpu(gdp->bg_inode_bitmap), ret_block, num) ||
|
|
|
|
in_range(ret_block, le32_to_cpu(gdp->bg_inode_table),
|
|
|
|
EXT2_SB(sb)->s_itb_per_group) ||
|
|
|
|
in_range(ret_block + num - 1, le32_to_cpu(gdp->bg_inode_table),
|
2008-02-06 02:36:17 -07:00
|
|
|
EXT2_SB(sb)->s_itb_per_group)) {
|
2007-10-17 00:30:46 -06:00
|
|
|
ext2_error(sb, "ext2_new_blocks",
|
2005-04-16 16:20:36 -06:00
|
|
|
"Allocating block in system zone - "
|
2007-10-17 00:30:46 -06:00
|
|
|
"blocks from "E2FSBLK", length %lu",
|
|
|
|
ret_block, num);
|
2008-04-28 03:16:04 -06:00
|
|
|
/*
|
|
|
|
* ext2_try_to_allocate marked the blocks we allocated as in
|
|
|
|
* use. So we may want to selectively mark some of the blocks
|
|
|
|
* as free
|
|
|
|
*/
|
|
|
|
goto retry_alloc;
|
2008-02-06 02:36:17 -07:00
|
|
|
}
|
2007-10-17 00:30:46 -06:00
|
|
|
|
|
|
|
performed_allocation = 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-10-17 00:30:46 -06:00
|
|
|
if (ret_block + num - 1 >= le32_to_cpu(es->s_blocks_count)) {
|
|
|
|
ext2_error(sb, "ext2_new_blocks",
|
|
|
|
"block("E2FSBLK") >= blocks count(%d) - "
|
2005-04-16 16:20:36 -06:00
|
|
|
"block_group = %d, es == %p ", ret_block,
|
|
|
|
le32_to_cpu(es->s_blocks_count), group_no, es);
|
2007-10-17 00:30:46 -06:00
|
|
|
goto out;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-10-17 00:30:46 -06:00
|
|
|
group_adjust_blocks(sb, group_no, gdp, gdp_bh, -num);
|
|
|
|
percpu_counter_sub(&sbi->s_freeblocks_counter, num);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
mark_buffer_dirty(bitmap_bh);
|
2017-11-27 14:05:09 -07:00
|
|
|
if (sb->s_flags & SB_SYNCHRONOUS)
|
2005-04-16 16:20:36 -06:00
|
|
|
sync_dirty_buffer(bitmap_bh);
|
|
|
|
|
2007-10-17 00:30:46 -06:00
|
|
|
*errp = 0;
|
|
|
|
brelse(bitmap_bh);
|
2013-02-07 07:57:53 -07:00
|
|
|
if (num < *count) {
|
|
|
|
dquot_free_block_nodirty(inode, *count-num);
|
|
|
|
mark_inode_dirty(inode);
|
|
|
|
*count = num;
|
|
|
|
}
|
2007-10-17 00:30:46 -06:00
|
|
|
return ret_block;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-10-17 00:30:46 -06:00
|
|
|
io_error:
|
|
|
|
*errp = -EIO;
|
2005-04-16 16:20:36 -06:00
|
|
|
out:
|
2007-10-17 00:30:46 -06:00
|
|
|
/*
|
|
|
|
* Undo the block allocation
|
|
|
|
*/
|
2010-07-21 15:13:36 -06:00
|
|
|
if (!performed_allocation) {
|
|
|
|
dquot_free_block_nodirty(inode, *count);
|
|
|
|
mark_inode_dirty(inode);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
brelse(bitmap_bh);
|
2007-10-17 00:30:46 -06:00
|
|
|
return 0;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-10-17 00:30:46 -06:00
|
|
|
ext2_fsblk_t ext2_new_block(struct inode *inode, unsigned long goal, int *errp)
|
|
|
|
{
|
|
|
|
unsigned long count = 1;
|
|
|
|
|
|
|
|
return ext2_new_blocks(inode, goal, &count, errp);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2006-06-25 06:48:12 -06:00
|
|
|
#ifdef EXT2FS_DEBUG
|
|
|
|
|
2012-07-30 15:41:05 -06:00
|
|
|
unsigned long ext2_count_free(struct buffer_head *map, unsigned int numchars)
|
2006-06-25 06:48:12 -06:00
|
|
|
{
|
2012-07-30 15:41:05 -06:00
|
|
|
return numchars * BITS_PER_BYTE - memweight(map->b_data, numchars);
|
2006-06-25 06:48:12 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* EXT2FS_DEBUG */
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned long ext2_count_free_blocks (struct super_block * sb)
|
|
|
|
{
|
|
|
|
struct ext2_group_desc * desc;
|
|
|
|
unsigned long desc_count = 0;
|
|
|
|
int i;
|
|
|
|
#ifdef EXT2FS_DEBUG
|
|
|
|
unsigned long bitmap_count, x;
|
|
|
|
struct ext2_super_block *es;
|
|
|
|
|
|
|
|
es = EXT2_SB(sb)->s_es;
|
|
|
|
desc_count = 0;
|
|
|
|
bitmap_count = 0;
|
|
|
|
desc = NULL;
|
|
|
|
for (i = 0; i < EXT2_SB(sb)->s_groups_count; i++) {
|
|
|
|
struct buffer_head *bitmap_bh;
|
|
|
|
desc = ext2_get_group_desc (sb, i, NULL);
|
|
|
|
if (!desc)
|
|
|
|
continue;
|
|
|
|
desc_count += le16_to_cpu(desc->bg_free_blocks_count);
|
|
|
|
bitmap_bh = read_block_bitmap(sb, i);
|
|
|
|
if (!bitmap_bh)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
x = ext2_count_free(bitmap_bh, sb->s_blocksize);
|
|
|
|
printk ("group %d: stored = %d, counted = %lu\n",
|
|
|
|
i, le16_to_cpu(desc->bg_free_blocks_count), x);
|
|
|
|
bitmap_count += x;
|
|
|
|
brelse(bitmap_bh);
|
|
|
|
}
|
|
|
|
printk("ext2_count_free_blocks: stored = %lu, computed = %lu, %lu\n",
|
|
|
|
(long)le32_to_cpu(es->s_free_blocks_count),
|
|
|
|
desc_count, bitmap_count);
|
|
|
|
return bitmap_count;
|
|
|
|
#else
|
|
|
|
for (i = 0; i < EXT2_SB(sb)->s_groups_count; i++) {
|
|
|
|
desc = ext2_get_group_desc (sb, i, NULL);
|
|
|
|
if (!desc)
|
|
|
|
continue;
|
|
|
|
desc_count += le16_to_cpu(desc->bg_free_blocks_count);
|
|
|
|
}
|
|
|
|
return desc_count;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int test_root(int a, int b)
|
|
|
|
{
|
|
|
|
int num = b;
|
|
|
|
|
|
|
|
while (a > num)
|
|
|
|
num *= b;
|
|
|
|
return num == a;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ext2_group_sparse(int group)
|
|
|
|
{
|
|
|
|
if (group <= 1)
|
|
|
|
return 1;
|
|
|
|
return (test_root(group, 3) || test_root(group, 5) ||
|
|
|
|
test_root(group, 7));
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ext2_bg_has_super - number of blocks used by the superblock in group
|
|
|
|
* @sb: superblock for filesystem
|
|
|
|
* @group: group number to check
|
|
|
|
*
|
|
|
|
* Return the number of blocks used by the superblock (primary or backup)
|
|
|
|
* in this group. Currently this will be only 0 or 1.
|
|
|
|
*/
|
|
|
|
int ext2_bg_has_super(struct super_block *sb, int group)
|
|
|
|
{
|
|
|
|
if (EXT2_HAS_RO_COMPAT_FEATURE(sb,EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER)&&
|
|
|
|
!ext2_group_sparse(group))
|
|
|
|
return 0;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ext2_bg_num_gdb - number of blocks used by the group table in group
|
|
|
|
* @sb: superblock for filesystem
|
|
|
|
* @group: group number to check
|
|
|
|
*
|
|
|
|
* Return the number of blocks used by the group descriptor table
|
|
|
|
* (primary or backup) in this group. In the future there may be a
|
|
|
|
* different number of descriptor blocks in each group.
|
|
|
|
*/
|
|
|
|
unsigned long ext2_bg_num_gdb(struct super_block *sb, int group)
|
|
|
|
{
|
2008-02-06 02:40:17 -07:00
|
|
|
return ext2_bg_has_super(sb, group) ? EXT2_SB(sb)->s_gdb_count : 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|