Commit bd4c625c authored by Linus Torvalds's avatar Linus Torvalds
Browse files

reiserfs: run scripts/Lindent on reiserfs code



This was a pure indentation change, using:

	scripts/Lindent fs/reiserfs/*.c include/linux/reiserfs_*.h

to make reiserfs match the regular Linux indentation style.  As Jeff
Mahoney <jeffm@suse.com> writes:

 The ReiserFS code is a mix of a number of different coding styles, sometimes
 different even from line-to-line. Since the code has been relatively stable
 for quite some time and there are few outstanding patches to be applied, it
 is time to reformat the code to conform to the Linux style standard outlined
 in Documentation/CodingStyle.

 This patch contains the result of running scripts/Lindent against
 fs/reiserfs/*.c and include/linux/reiserfs_*.h. There are places where the
 code can be made to look better, but I'd rather keep those patches separate
 so that there isn't a subtle by-hand hand accident in the middle of a huge
 patch. To be clear: This patch is reformatting *only*.

 A number of patches may follow that continue to make the code more consistent
 with the Linux coding style.

 Hans wasn't particularly enthusiastic about these patches, but said he
 wouldn't really oppose them either.
Signed-off-by: default avatarLinus Torvalds <torvalds@osdl.org>
parent 7fa94c88
......@@ -46,41 +46,43 @@
#define TEST_OPTION(optname, s) \
test_bit(_ALLOC_ ## optname , &SB_ALLOC_OPTS(s))
static inline void get_bit_address (struct super_block * s,
b_blocknr_t block, int * bmap_nr, int * offset)
static inline void get_bit_address(struct super_block *s,
b_blocknr_t block, int *bmap_nr, int *offset)
{
/* It is in the bitmap block number equal to the block
* number divided by the number of bits in a block. */
*bmap_nr = block / (s->s_blocksize << 3);
/* Within that bitmap block it is located at bit offset *offset. */
*offset = block & ((s->s_blocksize << 3) - 1 );
*offset = block & ((s->s_blocksize << 3) - 1);
return;
}
#ifdef CONFIG_REISERFS_CHECK
int is_reusable (struct super_block * s, b_blocknr_t block, int bit_value)
int is_reusable(struct super_block *s, b_blocknr_t block, int bit_value)
{
int i, j;
if (block == 0 || block >= SB_BLOCK_COUNT (s)) {
reiserfs_warning (s, "vs-4010: is_reusable: block number is out of range %lu (%u)",
block, SB_BLOCK_COUNT (s));
if (block == 0 || block >= SB_BLOCK_COUNT(s)) {
reiserfs_warning(s,
"vs-4010: is_reusable: block number is out of range %lu (%u)",
block, SB_BLOCK_COUNT(s));
return 0;
}
/* it can't be one of the bitmap blocks */
for (i = 0; i < SB_BMAP_NR (s); i ++)
if (block == SB_AP_BITMAP (s)[i].bh->b_blocknr) {
reiserfs_warning (s, "vs: 4020: is_reusable: "
for (i = 0; i < SB_BMAP_NR(s); i++)
if (block == SB_AP_BITMAP(s)[i].bh->b_blocknr) {
reiserfs_warning(s, "vs: 4020: is_reusable: "
"bitmap block %lu(%u) can't be freed or reused",
block, SB_BMAP_NR (s));
block, SB_BMAP_NR(s));
return 0;
}
get_bit_address (s, block, &i, &j);
get_bit_address(s, block, &i, &j);
if (i >= SB_BMAP_NR (s)) {
reiserfs_warning (s, "vs-4030: is_reusable: there is no so many bitmap blocks: "
if (i >= SB_BMAP_NR(s)) {
reiserfs_warning(s,
"vs-4030: is_reusable: there is no so many bitmap blocks: "
"block=%lu, bitmap_nr=%d", block, i);
return 0;
}
......@@ -88,17 +90,22 @@ int is_reusable (struct super_block * s, b_blocknr_t block, int bit_value)
if ((bit_value == 0 &&
reiserfs_test_le_bit(j, SB_AP_BITMAP(s)[i].bh->b_data)) ||
(bit_value == 1 &&
reiserfs_test_le_bit(j, SB_AP_BITMAP (s)[i].bh->b_data) == 0)) {
reiserfs_warning (s, "vs-4040: is_reusable: corresponding bit of block %lu does not "
reiserfs_test_le_bit(j, SB_AP_BITMAP(s)[i].bh->b_data) == 0)) {
reiserfs_warning(s,
"vs-4040: is_reusable: corresponding bit of block %lu does not "
"match required value (i==%d, j==%d) test_bit==%d",
block, i, j, reiserfs_test_le_bit (j, SB_AP_BITMAP (s)[i].bh->b_data));
block, i, j, reiserfs_test_le_bit(j,
SB_AP_BITMAP
(s)[i].bh->
b_data));
return 0;
}
if (bit_value == 0 && block == SB_ROOT_BLOCK (s)) {
reiserfs_warning (s, "vs-4050: is_reusable: this is root block (%u), "
"it must be busy", SB_ROOT_BLOCK (s));
if (bit_value == 0 && block == SB_ROOT_BLOCK(s)) {
reiserfs_warning(s,
"vs-4050: is_reusable: this is root block (%u), "
"it must be busy", SB_ROOT_BLOCK(s));
return 0;
}
......@@ -108,20 +115,20 @@ int is_reusable (struct super_block * s, b_blocknr_t block, int bit_value)
/* searches in journal structures for a given block number (bmap, off). If block
is found in reiserfs journal it suggests next free block candidate to test. */
static inline int is_block_in_journal (struct super_block * s, int bmap, int
off, int *next)
static inline int is_block_in_journal(struct super_block *s, int bmap, int
off, int *next)
{
b_blocknr_t tmp;
if (reiserfs_in_journal (s, bmap, off, 1, &tmp)) {
if (reiserfs_in_journal(s, bmap, off, 1, &tmp)) {
if (tmp) { /* hint supplied */
*next = tmp;
PROC_INFO_INC( s, scan_bitmap.in_journal_hint );
PROC_INFO_INC(s, scan_bitmap.in_journal_hint);
} else {
(*next) = off + 1; /* inc offset to avoid looping. */
PROC_INFO_INC( s, scan_bitmap.in_journal_nohint );
PROC_INFO_INC(s, scan_bitmap.in_journal_nohint);
}
PROC_INFO_INC( s, scan_bitmap.retry );
PROC_INFO_INC(s, scan_bitmap.retry);
return 1;
}
return 0;
......@@ -129,30 +136,33 @@ off, int *next)
/* it searches for a window of zero bits with given minimum and maximum lengths in one bitmap
* block; */
static int scan_bitmap_block (struct reiserfs_transaction_handle *th,
int bmap_n, int *beg, int boundary, int min, int max, int unfm)
static int scan_bitmap_block(struct reiserfs_transaction_handle *th,
int bmap_n, int *beg, int boundary, int min,
int max, int unfm)
{
struct super_block *s = th->t_super;
struct reiserfs_bitmap_info *bi=&SB_AP_BITMAP(s)[bmap_n];
struct reiserfs_bitmap_info *bi = &SB_AP_BITMAP(s)[bmap_n];
int end, next;
int org = *beg;
BUG_ON (!th->t_trans_id);
BUG_ON(!th->t_trans_id);
RFALSE(bmap_n >= SB_BMAP_NR (s), "Bitmap %d is out of range (0..%d)",bmap_n, SB_BMAP_NR (s) - 1);
PROC_INFO_INC( s, scan_bitmap.bmap );
RFALSE(bmap_n >= SB_BMAP_NR(s), "Bitmap %d is out of range (0..%d)",
bmap_n, SB_BMAP_NR(s) - 1);
PROC_INFO_INC(s, scan_bitmap.bmap);
/* this is unclear and lacks comments, explain how journal bitmaps
work here for the reader. Convey a sense of the design here. What
is a window? */
/* - I mean `a window of zero bits' as in description of this function - Zam. */
if ( !bi ) {
reiserfs_warning (s, "NULL bitmap info pointer for bitmap %d", bmap_n);
if (!bi) {
reiserfs_warning(s, "NULL bitmap info pointer for bitmap %d",
bmap_n);
return 0;
}
if (buffer_locked (bi->bh)) {
PROC_INFO_INC( s, scan_bitmap.wait );
__wait_on_buffer (bi->bh);
if (buffer_locked(bi->bh)) {
PROC_INFO_INC(s, scan_bitmap.wait);
__wait_on_buffer(bi->bh);
}
while (1) {
......@@ -162,18 +172,19 @@ static int scan_bitmap_block (struct reiserfs_transaction_handle *th,
/* search for a first zero bit -- beggining of a window */
*beg = reiserfs_find_next_zero_le_bit
((unsigned long*)(bi->bh->b_data), boundary, *beg);
((unsigned long *)(bi->bh->b_data), boundary, *beg);
if (*beg + min > boundary) { /* search for a zero bit fails or the rest of bitmap block
* cannot contain a zero window of minimum size */
return 0;
}
if (unfm && is_block_in_journal(s,bmap_n, *beg, beg))
if (unfm && is_block_in_journal(s, bmap_n, *beg, beg))
continue;
/* first zero bit found; we check next bits */
for (end = *beg + 1;; end ++) {
if (end >= *beg + max || end >= boundary || reiserfs_test_le_bit (end, bi->bh->b_data)) {
for (end = *beg + 1;; end++) {
if (end >= *beg + max || end >= boundary
|| reiserfs_test_le_bit(end, bi->bh->b_data)) {
next = end;
break;
}
......@@ -187,14 +198,15 @@ static int scan_bitmap_block (struct reiserfs_transaction_handle *th,
* (end) points to one bit after the window end */
if (end - *beg >= min) { /* it seems we have found window of proper size */
int i;
reiserfs_prepare_for_journal (s, bi->bh, 1);
reiserfs_prepare_for_journal(s, bi->bh, 1);
/* try to set all blocks used checking are they still free */
for (i = *beg; i < end; i++) {
/* It seems that we should not check in journal again. */
if (reiserfs_test_and_set_le_bit (i, bi->bh->b_data)) {
if (reiserfs_test_and_set_le_bit
(i, bi->bh->b_data)) {
/* bit was set by another process
* while we slept in prepare_for_journal() */
PROC_INFO_INC( s, scan_bitmap.stolen );
PROC_INFO_INC(s, scan_bitmap.stolen);
if (i >= *beg + min) { /* we can continue with smaller set of allocated blocks,
* if length of this set is more or equal to `min' */
end = i;
......@@ -202,20 +214,24 @@ static int scan_bitmap_block (struct reiserfs_transaction_handle *th,
}
/* otherwise we clear all bit were set ... */
while (--i >= *beg)
reiserfs_test_and_clear_le_bit (i, bi->bh->b_data);
reiserfs_restore_prepared_buffer (s, bi->bh);
reiserfs_test_and_clear_le_bit
(i, bi->bh->b_data);
reiserfs_restore_prepared_buffer(s,
bi->
bh);
*beg = org;
/* ... and search again in current block from beginning */
goto cont;
}
}
bi->free_count -= (end - *beg);
journal_mark_dirty (th, s, bi->bh);
journal_mark_dirty(th, s, bi->bh);
/* free block count calculation */
reiserfs_prepare_for_journal (s, SB_BUFFER_WITH_SB(s), 1);
reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s),
1);
PUT_SB_FREE_BLOCKS(s, SB_FREE_BLOCKS(s) - (end - *beg));
journal_mark_dirty (th, s, SB_BUFFER_WITH_SB(s));
journal_mark_dirty(th, s, SB_BUFFER_WITH_SB(s));
return end - (*beg);
} else {
......@@ -224,8 +240,9 @@ static int scan_bitmap_block (struct reiserfs_transaction_handle *th,
}
}
static int bmap_hash_id(struct super_block *s, u32 id) {
char * hash_in = NULL;
static int bmap_hash_id(struct super_block *s, u32 id)
{
char *hash_in = NULL;
unsigned long hash;
unsigned bm;
......@@ -248,10 +265,11 @@ static int bmap_hash_id(struct super_block *s, u32 id) {
* hashes the id and then returns > 0 if the block group for the
* corresponding hash is full
*/
static inline int block_group_used(struct super_block *s, u32 id) {
static inline int block_group_used(struct super_block *s, u32 id)
{
int bm;
bm = bmap_hash_id(s, id);
if (SB_AP_BITMAP(s)[bm].free_count > ((s->s_blocksize << 3) * 60 / 100) ) {
if (SB_AP_BITMAP(s)[bm].free_count > ((s->s_blocksize << 3) * 60 / 100)) {
return 0;
}
return 1;
......@@ -260,7 +278,7 @@ static inline int block_group_used(struct super_block *s, u32 id) {
/*
* the packing is returned in disk byte order
*/
__le32 reiserfs_choose_packing(struct inode *dir)
__le32 reiserfs_choose_packing(struct inode * dir)
{
__le32 packing;
if (TEST_OPTION(packing_groups, dir->i_sb)) {
......@@ -269,7 +287,7 @@ __le32 reiserfs_choose_packing(struct inode *dir)
* some versions of reiserfsck expect packing locality 1 to be
* special
*/
if (parent_dir == 1 || block_group_used(dir->i_sb,parent_dir))
if (parent_dir == 1 || block_group_used(dir->i_sb, parent_dir))
packing = INODE_PKEY(dir)->k_objectid;
else
packing = INODE_PKEY(dir)->k_dir_id;
......@@ -280,12 +298,12 @@ __le32 reiserfs_choose_packing(struct inode *dir)
/* Tries to find contiguous zero bit window (given size) in given region of
* bitmap and place new blocks there. Returns number of allocated blocks. */
static int scan_bitmap (struct reiserfs_transaction_handle *th,
b_blocknr_t *start, b_blocknr_t finish,
static int scan_bitmap(struct reiserfs_transaction_handle *th,
b_blocknr_t * start, b_blocknr_t finish,
int min, int max, int unfm, unsigned long file_block)
{
int nr_allocated=0;
struct super_block * s = th->t_super;
int nr_allocated = 0;
struct super_block *s = th->t_super;
/* find every bm and bmap and bmap_nr in this file, and change them all to bitmap_blocknr
* - Hans, it is not a block number - Zam. */
......@@ -293,14 +311,14 @@ static int scan_bitmap (struct reiserfs_transaction_handle *th,
int end_bm, end_off;
int off_max = s->s_blocksize << 3;
BUG_ON (!th->t_trans_id);
BUG_ON(!th->t_trans_id);
PROC_INFO_INC( s, scan_bitmap.call );
if ( SB_FREE_BLOCKS(s) <= 0)
PROC_INFO_INC(s, scan_bitmap.call);
if (SB_FREE_BLOCKS(s) <= 0)
return 0; // No point in looking for more free blocks
get_bit_address (s, *start, &bm, &off);
get_bit_address (s, finish, &end_bm, &end_off);
get_bit_address(s, *start, &bm, &off);
get_bit_address(s, finish, &end_bm, &end_off);
if (bm > SB_BMAP_NR(s))
return 0;
if (end_bm > SB_BMAP_NR(s))
......@@ -318,24 +336,31 @@ static int scan_bitmap (struct reiserfs_transaction_handle *th,
* This is only an allocation policy and does not make up for getting a
* bad hint. Decent hinting must be implemented for this to work well.
*/
if ( TEST_OPTION(skip_busy, s) && SB_FREE_BLOCKS(s) > SB_BLOCK_COUNT(s)/20 ) {
for (;bm < end_bm; bm++, off = 0) {
if ( ( off && (!unfm || (file_block != 0))) || SB_AP_BITMAP(s)[bm].free_count > (s->s_blocksize << 3) / 10 )
nr_allocated = scan_bitmap_block(th, bm, &off, off_max, min, max, unfm);
if (TEST_OPTION(skip_busy, s)
&& SB_FREE_BLOCKS(s) > SB_BLOCK_COUNT(s) / 20) {
for (; bm < end_bm; bm++, off = 0) {
if ((off && (!unfm || (file_block != 0)))
|| SB_AP_BITMAP(s)[bm].free_count >
(s->s_blocksize << 3) / 10)
nr_allocated =
scan_bitmap_block(th, bm, &off, off_max,
min, max, unfm);
if (nr_allocated)
goto ret;
}
/* we know from above that start is a reasonable number */
get_bit_address (s, *start, &bm, &off);
get_bit_address(s, *start, &bm, &off);
}
for (;bm < end_bm; bm++, off = 0) {
nr_allocated = scan_bitmap_block(th, bm, &off, off_max, min, max, unfm);
for (; bm < end_bm; bm++, off = 0) {
nr_allocated =
scan_bitmap_block(th, bm, &off, off_max, min, max, unfm);
if (nr_allocated)
goto ret;
}
nr_allocated = scan_bitmap_block(th, bm, &off, end_off + 1, min, max, unfm);
nr_allocated =
scan_bitmap_block(th, bm, &off, end_off + 1, min, max, unfm);
ret:
*start = bm * off_max + off;
......@@ -343,92 +368,98 @@ static int scan_bitmap (struct reiserfs_transaction_handle *th,
}
static void _reiserfs_free_block (struct reiserfs_transaction_handle *th,
static void _reiserfs_free_block(struct reiserfs_transaction_handle *th,
struct inode *inode, b_blocknr_t block,
int for_unformatted)
{
struct super_block * s = th->t_super;
struct reiserfs_super_block * rs;
struct buffer_head * sbh;
struct super_block *s = th->t_super;
struct reiserfs_super_block *rs;
struct buffer_head *sbh;
struct reiserfs_bitmap_info *apbi;
int nr, offset;
BUG_ON (!th->t_trans_id);
BUG_ON(!th->t_trans_id);
PROC_INFO_INC( s, free_block );
PROC_INFO_INC(s, free_block);
rs = SB_DISK_SUPER_BLOCK (s);
sbh = SB_BUFFER_WITH_SB (s);
rs = SB_DISK_SUPER_BLOCK(s);
sbh = SB_BUFFER_WITH_SB(s);
apbi = SB_AP_BITMAP(s);
get_bit_address (s, block, &nr, &offset);
get_bit_address(s, block, &nr, &offset);
if (nr >= sb_bmap_nr (rs)) {
reiserfs_warning (s, "vs-4075: reiserfs_free_block: "
if (nr >= sb_bmap_nr(rs)) {
reiserfs_warning(s, "vs-4075: reiserfs_free_block: "
"block %lu is out of range on %s",
block, reiserfs_bdevname (s));
block, reiserfs_bdevname(s));
return;
}
reiserfs_prepare_for_journal(s, apbi[nr].bh, 1 ) ;
reiserfs_prepare_for_journal(s, apbi[nr].bh, 1);
/* clear bit for the given block in bit map */
if (!reiserfs_test_and_clear_le_bit (offset, apbi[nr].bh->b_data)) {
reiserfs_warning (s, "vs-4080: reiserfs_free_block: "
if (!reiserfs_test_and_clear_le_bit(offset, apbi[nr].bh->b_data)) {
reiserfs_warning(s, "vs-4080: reiserfs_free_block: "
"free_block (%s:%lu)[dev:blocknr]: bit already cleared",
reiserfs_bdevname (s), block);
reiserfs_bdevname(s), block);
}
apbi[nr].free_count ++;
journal_mark_dirty (th, s, apbi[nr].bh);
apbi[nr].free_count++;
journal_mark_dirty(th, s, apbi[nr].bh);
reiserfs_prepare_for_journal(s, sbh, 1) ;
reiserfs_prepare_for_journal(s, sbh, 1);
/* update super block */
set_sb_free_blocks( rs, sb_free_blocks(rs) + 1 );
set_sb_free_blocks(rs, sb_free_blocks(rs) + 1);
journal_mark_dirty (th, s, sbh);
journal_mark_dirty(th, s, sbh);
if (for_unformatted)
DQUOT_FREE_BLOCK_NODIRTY(inode, 1);
}
void reiserfs_free_block (struct reiserfs_transaction_handle *th,
void reiserfs_free_block(struct reiserfs_transaction_handle *th,
struct inode *inode, b_blocknr_t block,
int for_unformatted)
{
struct super_block * s = th->t_super;
struct super_block *s = th->t_super;
BUG_ON (!th->t_trans_id);
BUG_ON(!th->t_trans_id);
RFALSE(!s, "vs-4061: trying to free block on nonexistent device");
RFALSE(is_reusable (s, block, 1) == 0, "vs-4071: can not free such block");
RFALSE(is_reusable(s, block, 1) == 0,
"vs-4071: can not free such block");
/* mark it before we clear it, just in case */
journal_mark_freed(th, s, block) ;
_reiserfs_free_block(th, inode, block, for_unformatted) ;
journal_mark_freed(th, s, block);
_reiserfs_free_block(th, inode, block, for_unformatted);
}
/* preallocated blocks don't need to be run through journal_mark_freed */
static void reiserfs_free_prealloc_block (struct reiserfs_transaction_handle *th,
struct inode *inode, b_blocknr_t block) {
RFALSE(!th->t_super, "vs-4060: trying to free block on nonexistent device");
RFALSE(is_reusable (th->t_super, block, 1) == 0, "vs-4070: can not free such block");
BUG_ON (!th->t_trans_id);
_reiserfs_free_block(th, inode, block, 1) ;
static void reiserfs_free_prealloc_block(struct reiserfs_transaction_handle *th,
struct inode *inode, b_blocknr_t block)
{
RFALSE(!th->t_super,
"vs-4060: trying to free block on nonexistent device");
RFALSE(is_reusable(th->t_super, block, 1) == 0,
"vs-4070: can not free such block");
BUG_ON(!th->t_trans_id);
_reiserfs_free_block(th, inode, block, 1);
}
static void __discard_prealloc (struct reiserfs_transaction_handle * th,
static void __discard_prealloc(struct reiserfs_transaction_handle *th,
struct reiserfs_inode_info *ei)
{
unsigned long save = ei->i_prealloc_block ;
unsigned long save = ei->i_prealloc_block;
int dirty = 0;
struct inode *inode = &ei->vfs_inode;
BUG_ON (!th->t_trans_id);
BUG_ON(!th->t_trans_id);
#ifdef CONFIG_REISERFS_CHECK
if (ei->i_prealloc_count < 0)
reiserfs_warning (th->t_super, "zam-4001:%s: inode has negative prealloc blocks count.", __FUNCTION__ );
reiserfs_warning(th->t_super,
"zam-4001:%s: inode has negative prealloc blocks count.",
__FUNCTION__);
#endif
while (ei->i_prealloc_count > 0) {
reiserfs_free_prealloc_block(th, inode, ei->i_prealloc_block);
ei->i_prealloc_block++;
ei->i_prealloc_count --;
ei->i_prealloc_count--;
dirty = 1;
}
if (dirty)
......@@ -438,66 +469,73 @@ static void __discard_prealloc (struct reiserfs_transaction_handle * th,
}
/* FIXME: It should be inline function */
void reiserfs_discard_prealloc (struct reiserfs_transaction_handle *th,
void reiserfs_discard_prealloc(struct reiserfs_transaction_handle *th,
struct inode *inode)
{
struct reiserfs_inode_info *ei = REISERFS_I(inode);
BUG_ON (!th->t_trans_id);
BUG_ON(!th->t_trans_id);
if (ei->i_prealloc_count)
__discard_prealloc(th, ei);
}
void reiserfs_discard_all_prealloc (struct reiserfs_transaction_handle *th)
void reiserfs_discard_all_prealloc(struct reiserfs_transaction_handle *th)
{
struct list_head * plist = &SB_JOURNAL(th->t_super)->j_prealloc_list;
struct list_head *plist = &SB_JOURNAL(th->t_super)->j_prealloc_list;
BUG_ON (!th->t_trans_id);
BUG_ON(!th->t_trans_id);
while (!list_empty(plist)) {
struct reiserfs_inode_info *ei;
ei = list_entry(plist->next, struct reiserfs_inode_info, i_prealloc_list);
ei = list_entry(plist->next, struct reiserfs_inode_info,
i_prealloc_list);
#ifdef CONFIG_REISERFS_CHECK
if (!ei->i_prealloc_count) {
reiserfs_warning (th->t_super, "zam-4001:%s: inode is in prealloc list but has no preallocated blocks.", __FUNCTION__);
reiserfs_warning(th->t_super,
"zam-4001:%s: inode is in prealloc list but has no preallocated blocks.",
__FUNCTION__);
}
#endif
__discard_prealloc(th, ei);
}
}
void reiserfs_init_alloc_options (struct super_block *s)
void reiserfs_init_alloc_options(struct super_block *s)
{
set_bit (_ALLOC_skip_busy, &SB_ALLOC_OPTS(s));
set_bit (_ALLOC_dirid_groups, &SB_ALLOC_OPTS(s));
set_bit (_ALLOC_packing_groups, &SB_ALLOC_OPTS(s));
set_bit(_ALLOC_skip_busy, &SB_ALLOC_OPTS(s));
set_bit(_ALLOC_dirid_groups, &SB_ALLOC_OPTS(s));
set_bit(_ALLOC_packing_groups, &SB_ALLOC_OPTS(s));
}
/* block allocator related options are parsed here */
int reiserfs_parse_alloc_options(struct super_block * s, char * options)
int reiserfs_parse_alloc_options(struct super_block *s, char *options)
{
char * this_char, * value;
char *this_char, *value;
REISERFS_SB(s)->s_alloc_options.bits = 0; /* clear default settings */
while ( (this_char = strsep (&options, ":")) != NULL ) {
if ((value = strchr (this_char, '=')) != NULL)
while ((this_char = strsep(&options, ":")) != NULL) {
if ((value = strchr(this_char, '=')) != NULL)
*value++ = 0;
if (!strcmp(this_char, "concentrating_formatted_nodes")) {
int temp;
SET_OPTION(concentrating_formatted_nodes);
temp = (value && *value) ? simple_strtoul (value, &value, 0) : 10;
temp = (value
&& *value) ? simple_strtoul(value, &value,
0) : 10;
if (temp <= 0 || temp > 100) {
REISERFS_SB(s)->s_alloc_options.border = 10;
} else {
REISERFS_SB(s)->s_alloc_options.border = 100 / temp;
REISERFS_SB(s)->s_alloc_options.border =
100 / temp;
}
continue;
}
if (!strcmp(this_char, "displacing_large_files")) {
SET_OPTION(displacing_large_files);
REISERFS_SB(s)->s_alloc_options.large_file_size =
(value && *value) ? simple_strtoul (value, &value, 0) : 16;
(value
&& *value) ? simple_strtoul(value, &value, 0) : 16;
continue;
}
if (!strcmp(this_char, "displacing_new_packing_localities")) {
......@@ -554,50 +592,55 @@ int reiserfs_parse_alloc_options(struct super_block * s, char * options)
if (!strcmp(this_char, "preallocmin")) {
REISERFS_SB(s)->s_alloc_options.preallocmin =
(value && *value) ? simple_strtoul (value, &value, 0) : 4;
(value
&& *value) ? simple_strtoul(value, &value, 0) : 4;
continue;
}
if (!strcmp(this_char, "preallocsize")) {
REISERFS_SB(s)->s_alloc_options.preallocsize =
(value && *value) ? simple_strtoul (value, &value, 0) : PREALLOCATION_SIZE;
(value
&& *value) ? simple_strtoul(value, &value,
0) :
PREALLOCATION_SIZE;
continue;
}
reiserfs_warning (s, "zam-4001: %s : unknown option - %s",
__FUNCTION__ , this_char);
reiserfs_warning(s, "zam-4001: %s : unknown option - %s",
__FUNCTION__, this_char);
return 1;
}