lkml.org 
[lkml]   [2010]   [Nov]   [19]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
/
SubjectRe: [PATCH] ext3: Coding style fix in namei.c
From
Date

On Nov 19, 2010, at 5:13 AM, Namhyung Kim wrote:

> * break long lines (using temp variables if needed)
> * merge short lines
> * put open brace on the same line
> * use C89-style comments
> * remove a space between function name and parenthesis
> * remove a space between '*' and pointer name
> * add a space after ','
> * other random whitespace fixes
>
> Signed-off-by: Namhyung Kim <namhyung@gmail.com>

What's the benefit of such massive cleanup patches, really? Does it really enhance readability _that_ much?

I believe in cleaning up code as I make substantive, useful change, but code churn for code churn's sake has a number of downsides:

*) It breaks other people's patches that might be pending (probably not as much of an issue for ext3)
*) It makes it really easy to introduce security holes in code (although it looks like --- I haven't checked to make sure --- this shouldn't change the compiled code any so we can at least audit this by applying the patch, and then checking to make sure the .o hasn't changed. What really makes my skin crawl is a massive change like that which doesn't have zero impact on the compiled object code. If I get a patch like that, I reject it out of hand for ext4.)

Bottom line is I really don't think cleanup code helps a lot. It wastes your time --- why not find some way of improving the kernel that has more impact --- and it wastes the time of the responsible maintainer (who has to go through the code with a fined-toothed comb to make sure there's nothing bad hidden in a massive patch like this).

Best regards,

-- Ted


> ---
> fs/ext3/namei.c | 576 ++++++++++++++++++++++++++++---------------------------
> 1 files changed, 292 insertions(+), 284 deletions(-)
>
> diff --git a/fs/ext3/namei.c b/fs/ext3/namei.c
> index 8061281..c7cdf32 100644
> --- a/fs/ext3/namei.c
> +++ b/fs/ext3/namei.c
> @@ -49,8 +49,7 @@
> #define NAMEI_RA_SIZE (NAMEI_RA_CHUNKS * NAMEI_RA_BLOCKS)
> #define NAMEI_RA_INDEX(c,b) (((c) * NAMEI_RA_BLOCKS) + (b))
>
> -static struct buffer_head *ext3_append(handle_t *handle,
> - struct inode *inode,
> +static struct buffer_head *ext3_append(handle_t *handle, struct inode *inode,
> u32 *block, int *err)
> {
> struct buffer_head *bh;
> @@ -80,22 +79,19 @@ static struct buffer_head *ext3_append(handle_t *handle,
> #define dxtrace(command)
> #endif
>
> -struct fake_dirent
> -{
> +struct fake_dirent {
> __le32 inode;
> __le16 rec_len;
> u8 name_len;
> u8 file_type;
> };
>
> -struct dx_countlimit
> -{
> +struct dx_countlimit {
> __le16 limit;
> __le16 count;
> };
>
> -struct dx_entry
> -{
> +struct dx_entry {
> __le32 hash;
> __le32 block;
> };
> @@ -106,73 +102,65 @@ struct dx_entry
> * hash version mod 4 should never be 0. Sincerely, the paranoia department.
> */
>
> -struct dx_root
> -{
> +struct dx_root {
> struct fake_dirent dot;
> char dot_name[4];
> struct fake_dirent dotdot;
> char dotdot_name[4];
> - struct dx_root_info
> - {
> + struct dx_root_info {
> __le32 reserved_zero;
> u8 hash_version;
> u8 info_length; /* 8 */
> u8 indirect_levels;
> u8 unused_flags;
> - }
> - info;
> + } info;
> struct dx_entry entries[0];
> };
>
> -struct dx_node
> -{
> +struct dx_node {
> struct fake_dirent fake;
> struct dx_entry entries[0];
> };
>
> -
> -struct dx_frame
> -{
> +struct dx_frame {
> struct buffer_head *bh;
> struct dx_entry *entries;
> struct dx_entry *at;
> };
>
> -struct dx_map_entry
> -{
> +struct dx_map_entry {
> u32 hash;
> u16 offs;
> u16 size;
> };
>
> -static inline unsigned dx_get_block (struct dx_entry *entry);
> -static void dx_set_block (struct dx_entry *entry, unsigned value);
> -static inline unsigned dx_get_hash (struct dx_entry *entry);
> -static void dx_set_hash (struct dx_entry *entry, unsigned value);
> -static unsigned dx_get_count (struct dx_entry *entries);
> -static unsigned dx_get_limit (struct dx_entry *entries);
> -static void dx_set_count (struct dx_entry *entries, unsigned value);
> -static void dx_set_limit (struct dx_entry *entries, unsigned value);
> -static unsigned dx_root_limit (struct inode *dir, unsigned infosize);
> -static unsigned dx_node_limit (struct inode *dir);
> -static struct dx_frame *dx_probe(struct qstr *entry,
> - struct inode *dir,
> +static inline unsigned dx_get_block(struct dx_entry *entry);
> +static void dx_set_block(struct dx_entry *entry, unsigned value);
> +static inline unsigned dx_get_hash(struct dx_entry *entry);
> +static void dx_set_hash(struct dx_entry *entry, unsigned value);
> +static unsigned dx_get_count(struct dx_entry *entries);
> +static unsigned dx_get_limit(struct dx_entry *entries);
> +static void dx_set_count(struct dx_entry *entries, unsigned value);
> +static void dx_set_limit(struct dx_entry *entries, unsigned value);
> +static unsigned dx_root_limit(struct inode *dir, unsigned infosize);
> +static unsigned dx_node_limit(struct inode *dir);
> +static struct dx_frame *dx_probe(struct qstr *entry, struct inode *dir,
> struct dx_hash_info *hinfo,
> - struct dx_frame *frame,
> - int *err);
> -static void dx_release (struct dx_frame *frames);
> + struct dx_frame *frame, int *err);
> +static void dx_release(struct dx_frame *frames);
> static int dx_make_map(struct ext3_dir_entry_2 *de, unsigned blocksize,
> - struct dx_hash_info *hinfo, struct dx_map_entry map[]);
> + struct dx_hash_info *hinfo, struct dx_map_entry map[]);
> static void dx_sort_map(struct dx_map_entry *map, unsigned count);
> -static struct ext3_dir_entry_2 *dx_move_dirents (char *from, char *to,
> +static struct ext3_dir_entry_2 *dx_move_dirents(char *from, char *to,
> struct dx_map_entry *offsets, int count);
> -static struct ext3_dir_entry_2 *dx_pack_dirents(char *base, unsigned blocksize);
> -static void dx_insert_block (struct dx_frame *frame, u32 hash, u32 block);
> +static struct ext3_dir_entry_2 *dx_pack_dirents(char *base,
> + unsigned blocksize);
> +static void dx_insert_block(struct dx_frame *frame, u32 hash, u32 block);
> static int ext3_htree_next_block(struct inode *dir, __u32 hash,
> struct dx_frame *frame,
> struct dx_frame *frames,
> __u32 *start_hash);
> -static struct buffer_head * ext3_dx_find_entry(struct inode *dir,
> +static struct buffer_head *ext3_dx_find_entry(struct inode *dir,
> struct qstr *entry, struct ext3_dir_entry_2 **res_dir,
> int *err);
> static int ext3_dx_add_entry(handle_t *handle, struct dentry *dentry,
> @@ -193,54 +181,54 @@ ext3_next_entry(struct ext3_dir_entry_2 *p)
> * Mask them off for now.
> */
>
> -static inline unsigned dx_get_block (struct dx_entry *entry)
> +static inline unsigned dx_get_block(struct dx_entry *entry)
> {
> return le32_to_cpu(entry->block) & 0x00ffffff;
> }
>
> -static inline void dx_set_block (struct dx_entry *entry, unsigned value)
> +static inline void dx_set_block(struct dx_entry *entry, unsigned value)
> {
> entry->block = cpu_to_le32(value);
> }
>
> -static inline unsigned dx_get_hash (struct dx_entry *entry)
> +static inline unsigned dx_get_hash(struct dx_entry *entry)
> {
> return le32_to_cpu(entry->hash);
> }
>
> -static inline void dx_set_hash (struct dx_entry *entry, unsigned value)
> +static inline void dx_set_hash(struct dx_entry *entry, unsigned value)
> {
> entry->hash = cpu_to_le32(value);
> }
>
> -static inline unsigned dx_get_count (struct dx_entry *entries)
> +static inline unsigned dx_get_count(struct dx_entry *entries)
> {
> return le16_to_cpu(((struct dx_countlimit *) entries)->count);
> }
>
> -static inline unsigned dx_get_limit (struct dx_entry *entries)
> +static inline unsigned dx_get_limit(struct dx_entry *entries)
> {
> return le16_to_cpu(((struct dx_countlimit *) entries)->limit);
> }
>
> -static inline void dx_set_count (struct dx_entry *entries, unsigned value)
> +static inline void dx_set_count(struct dx_entry *entries, unsigned value)
> {
> ((struct dx_countlimit *) entries)->count = cpu_to_le16(value);
> }
>
> -static inline void dx_set_limit (struct dx_entry *entries, unsigned value)
> +static inline void dx_set_limit(struct dx_entry *entries, unsigned value)
> {
> ((struct dx_countlimit *) entries)->limit = cpu_to_le16(value);
> }
>
> -static inline unsigned dx_root_limit (struct inode *dir, unsigned infosize)
> +static inline unsigned dx_root_limit(struct inode *dir, unsigned infosize)
> {
> unsigned entry_space = dir->i_sb->s_blocksize - EXT3_DIR_REC_LEN(1) -
> EXT3_DIR_REC_LEN(2) - infosize;
> return entry_space / sizeof(struct dx_entry);
> }
>
> -static inline unsigned dx_node_limit (struct inode *dir)
> +static inline unsigned dx_node_limit(struct inode *dir)
> {
> unsigned entry_space = dir->i_sb->s_blocksize - EXT3_DIR_REC_LEN(0);
> return entry_space / sizeof(struct dx_entry);
> @@ -250,25 +238,26 @@ static inline unsigned dx_node_limit (struct inode *dir)
> * Debug
> */
> #ifdef DX_DEBUG
> -static void dx_show_index (char * label, struct dx_entry *entries)
> +static void dx_show_index(char *label, struct dx_entry *entries)
> {
> - int i, n = dx_get_count (entries);
> - printk("%s index ", label);
> - for (i = 0; i < n; i++)
> - {
> - printk("%x->%u ", i? dx_get_hash(entries + i): 0, dx_get_block(entries + i));
> - }
> - printk("\n");
> + int i, n = dx_get_count(entries);
> +
> + printk("%s index ", label);
> + for (i = 0; i < n; i++) {
> + printk("%x->%u ", i ? dx_get_hash(entries + i) : 0,
> + dx_get_block(entries + i));
> + }
> + printk("\n");
> }
>
> -struct stats
> -{
> +struct stats {
> unsigned names;
> unsigned space;
> unsigned bcount;
> };
>
> -static struct stats dx_show_leaf(struct dx_hash_info *hinfo, struct ext3_dir_entry_2 *de,
> +static struct stats dx_show_leaf(struct dx_hash_info *hinfo,
> + struct ext3_dir_entry_2 *de,
> int size, int show_names)
> {
> unsigned names = 0, space = 0;
> @@ -276,12 +265,9 @@ static struct stats dx_show_leaf(struct dx_hash_info *hinfo, struct ext3_dir_ent
> struct dx_hash_info h = *hinfo;
>
> printk("names: ");
> - while ((char *) de < base + size)
> - {
> - if (de->inode)
> - {
> - if (show_names)
> - {
> + while ((char *) de < base + size) {
> + if (de->inode) {
> + if (show_names) {
> int len = de->name_len;
> char *name = de->name;
> while (len--) printk("%c", *name++);
> @@ -302,29 +288,43 @@ struct stats dx_show_entries(struct dx_hash_info *hinfo, struct inode *dir,
> struct dx_entry *entries, int levels)
> {
> unsigned blocksize = dir->i_sb->s_blocksize;
> - unsigned count = dx_get_count (entries), names = 0, space = 0, i;
> - unsigned bcount = 0;
> + unsigned count = dx_get_count(entries), names = 0, space = 0;
> + unsigned i, bcount = 0;
> struct buffer_head *bh;
> int err;
> +
> printk("%i indexed blocks...\n", count);
> - for (i = 0; i < count; i++, entries++)
> - {
> - u32 block = dx_get_block(entries), hash = i? dx_get_hash(entries): 0;
> - u32 range = i < count - 1? (dx_get_hash(entries + 1) - hash): ~hash;
> + for (i = 0; i < count; i++, entries++) {
> + u32 block = dx_get_block(entries);
> + u32 hash = i ? dx_get_hash(entries) : 0;
> + u32 range;
> struct stats stats;
> - printk("%s%3u:%03u hash %8x/%8x ",levels?"":" ", i, block, hash, range);
> - if (!(bh = ext3_bread (NULL,dir, block, 0,&err))) continue;
> - stats = levels?
> - dx_show_entries(hinfo, dir, ((struct dx_node *) bh->b_data)->entries, levels - 1):
> - dx_show_leaf(hinfo, (struct ext3_dir_entry_2 *) bh->b_data, blocksize, 0);
> +
> + if (i < count - 1)
> + range = dx_get_hash(entries + 1) - hash;
> + else
> + range = ~hash;
> + printk("%s%3u:%03u hash %8x/%8x ", levels ? "" : " ",
> + i, block, hash, range);
> + if (!(bh = ext3_bread(NULL, dir, block, 0, &err)))
> + continue;
> + if (levels) {
> + struct dx_node *node = (struct dx_node *) bh->b_data;
> + stats = dx_show_entries(hinfo, dir, node->entries,
> + levels - 1);
> + } else {
> + struct ext3_dir_entry_2 *de;
> + de = (struct ext3_dir_entry_2 *) bh->b_data;
> + stats = dx_show_leaf(hinfo, de, blocksize, 0);
> + }
> names += stats.names;
> space += stats.space;
> bcount += stats.bcount;
> - brelse (bh);
> + brelse(bh);
> }
> if (bcount)
> - printk("%snames %u, fullness %u (%u%%)\n", levels?"":" ",
> - names, space/bcount,(space/bcount)*100/blocksize);
> + printk("%snames %u, fullness %u (%u%%)\n", levels ? "" : " ",
> + names, space/bcount, (space/bcount) * 100 / blocksize);
> return (struct stats) { names, space, bcount};
> }
> #endif /* DX_DEBUG */
> @@ -350,7 +350,7 @@ dx_probe(struct qstr *entry, struct inode *dir,
> u32 hash;
>
> frame->bh = NULL;
> - if (!(bh = ext3_bread (NULL,dir, 0, 0, err)))
> + if (!(bh = ext3_bread(NULL, dir, 0, 0, err)))
> goto fail;
> root = (struct dx_root *) bh->b_data;
> if (root->info.hash_version != DX_HASH_TEA &&
> @@ -401,9 +401,8 @@ dx_probe(struct qstr *entry, struct inode *dir,
> goto fail;
> }
>
> - dxtrace (printk("Look up %x", hash));
> - while (1)
> - {
> + dxtrace(printk("Look up %x", hash));
> + while (1) {
> count = dx_get_count(entries);
> if (!count || count > dx_get_limit(entries)) {
> ext3_warning(dir->i_sb, __func__,
> @@ -415,8 +414,7 @@ dx_probe(struct qstr *entry, struct inode *dir,
>
> p = entries + 1;
> q = entries + count - 1;
> - while (p <= q)
> - {
> + while (p <= q) {
> m = p + (q - p)/2;
> dxtrace(printk("."));
> if (dx_get_hash(m) > hash)
> @@ -425,32 +423,32 @@ dx_probe(struct qstr *entry, struct inode *dir,
> p = m + 1;
> }
>
> - if (0) // linear search cross check
> - {
> + if (0) { /* linear search cross check */
> unsigned n = count - 1;
> at = entries;
> - while (n--)
> - {
> + while (n--) {
> dxtrace(printk(","));
> - if (dx_get_hash(++at) > hash)
> - {
> + if (dx_get_hash(++at) > hash) {
> at--;
> break;
> }
> }
> - assert (at == p - 1);
> + assert(at == p - 1);
> }
>
> at = p - 1;
> - dxtrace(printk(" %x->%u\n", at == entries? 0: dx_get_hash(at), dx_get_block(at)));
> + dxtrace(printk(" %x->%u\n", at == entries ? 0 : dx_get_hash(at),
> + dx_get_block(at)));
> frame->bh = bh;
> frame->entries = entries;
> frame->at = at;
> - if (!indirect--) return frame;
> - if (!(bh = ext3_bread (NULL,dir, dx_get_block(at), 0, err)))
> +
> + if (!indirect--)
> + return frame;
> + if (!(bh = ext3_bread(NULL, dir, dx_get_block(at), 0, err)))
> goto fail2;
> at = entries = ((struct dx_node *) bh->b_data)->entries;
> - if (dx_get_limit(entries) != dx_node_limit (dir)) {
> + if (dx_get_limit(entries) != dx_node_limit(dir)) {
> ext3_warning(dir->i_sb, __func__,
> "dx entry: limit != node limit");
> brelse(bh);
> @@ -473,7 +471,7 @@ fail:
> return NULL;
> }
>
> -static void dx_release (struct dx_frame *frames)
> +static void dx_release(struct dx_frame *frames)
> {
> if (frames[0].bh == NULL)
> return;
> @@ -550,7 +548,7 @@ static int ext3_htree_next_block(struct inode *dir, __u32 hash,
> 0, &err)))
> return err; /* Failure */
> p++;
> - brelse (p->bh);
> + brelse(p->bh);
> p->bh = bh;
> p->at = p->entries = ((struct dx_node *) bh->b_data)->entries;
> }
> @@ -573,7 +571,7 @@ static int htree_dirblock_to_tree(struct file *dir_file,
> int err, count = 0;
>
> dxtrace(printk("In htree dirblock_to_tree: block %d\n", block));
> - if (!(bh = ext3_bread (NULL, dir, block, 0, &err)))
> + if (!(bh = ext3_bread(NULL, dir, block, 0, &err)))
> return err;
>
> de = (struct ext3_dir_entry_2 *) bh->b_data;
> @@ -581,13 +579,13 @@ static int htree_dirblock_to_tree(struct file *dir_file,
> dir->i_sb->s_blocksize -
> EXT3_DIR_REC_LEN(0));
> for (; de < top; de = ext3_next_entry(de)) {
> - if (!ext3_check_dir_entry("htree_dirblock_to_tree", dir, de, bh,
> - (block<<EXT3_BLOCK_SIZE_BITS(dir->i_sb))
> - +((char *)de - bh->b_data))) {
> + if (!ext3_check_dir_entry(__func__, dir, de, bh,
> + (block<<EXT3_BLOCK_SIZE_BITS(dir->i_sb))
> + + ((char *)de - bh->b_data))) {
> /* On error, skip the f_pos to the next block. */
> dir_file->f_pos = (dir_file->f_pos |
> (dir->i_sb->s_blocksize - 1)) + 1;
> - brelse (bh);
> + brelse(bh);
> return count;
> }
> ext3fs_dirhash(de->name, de->name_len, hinfo);
> @@ -645,7 +643,8 @@ int ext3_htree_fill_tree(struct file *dir_file, __u32 start_hash,
> }
> hinfo.hash = start_hash;
> hinfo.minor_hash = 0;
> - frame = dx_probe(NULL, dir_file->f_path.dentry->d_inode, &hinfo, frames, &err);
> + frame = dx_probe(NULL, dir_file->f_path.dentry->d_inode, &hinfo,
> + frames, &err);
> if (!frame)
> return err;
>
> @@ -686,8 +685,7 @@ int ext3_htree_fill_tree(struct file *dir_file, __u32 start_hash,
> * (b) we have inserted at least one entry and the
> * next hash value is not a continuation
> */
> - if ((ret == 0) ||
> - (count && ((hashval & 1) == 0)))
> + if ((ret == 0) || (count && ((hashval & 1) == 0)))
> break;
> }
> dx_release(frames);
> @@ -715,8 +713,7 @@ static int dx_make_map(struct ext3_dir_entry_2 *de, unsigned blocksize,
> char *base = (char *) de;
> struct dx_hash_info h = *hinfo;
>
> - while ((char *) de < base + blocksize)
> - {
> + while ((char *) de < base + blocksize) {
> if (de->name_len && de->inode) {
> ext3fs_dirhash(de->name, de->name_len, &h);
> map_tail--;
> @@ -733,30 +730,28 @@ static int dx_make_map(struct ext3_dir_entry_2 *de, unsigned blocksize,
> }
>
> /* Sort map by hash value */
> -static void dx_sort_map (struct dx_map_entry *map, unsigned count)
> +static void dx_sort_map(struct dx_map_entry *map, unsigned count)
> {
> - struct dx_map_entry *p, *q, *top = map + count - 1;
> - int more;
> - /* Combsort until bubble sort doesn't suck */
> - while (count > 2)
> - {
> - count = count*10/13;
> - if (count - 9 < 2) /* 9, 10 -> 11 */
> - count = 11;
> - for (p = top, q = p - count; q >= map; p--, q--)
> - if (p->hash < q->hash)
> - swap(*p, *q);
> - }
> - /* Garden variety bubble sort */
> - do {
> - more = 0;
> - q = top;
> - while (q-- > map)
> - {
> - if (q[1].hash >= q[0].hash)
> + struct dx_map_entry *p, *q, *top = map + count - 1;
> + int more;
> + /* Combsort until bubble sort doesn't suck */
> + while (count > 2) {
> + count = count * 10 / 13;
> + if (count - 9 < 2) /* 9, 10 -> 11 */
> + count = 11;
> + for (p = top, q = p - count; q >= map; p--, q--)
> + if (p->hash < q->hash)
> + swap(*p, *q);
> + }
> + /* Garden variety bubble sort */
> + do {
> + more = 0;
> + q = top;
> + while (q-- > map) {
> + if (q[1].hash >= q[0].hash)
> continue;
> - swap(*(q+1), *q);
> - more = 1;
> + swap(*(q+1), *q);
> + more = 1;
> }
> } while(more);
> }
> @@ -788,8 +783,8 @@ static void ext3_update_dx_flag(struct inode *inode)
> * `len <= EXT3_NAME_LEN' is guaranteed by caller.
> * `de != NULL' is guaranteed by caller.
> */
> -static inline int ext3_match (int len, const char * const name,
> - struct ext3_dir_entry_2 * de)
> +static inline int ext3_match(int len, const char *const name,
> + struct ext3_dir_entry_2 *de)
> {
> if (len != de->name_len)
> return 0;
> @@ -801,14 +796,14 @@ static inline int ext3_match (int len, const char * const name,
> /*
> * Returns 0 if not found, -1 on failure, and 1 on success
> */
> -static inline int search_dirblock(struct buffer_head * bh,
> +static inline int search_dirblock(struct buffer_head *bh,
> struct inode *dir,
> struct qstr *child,
> unsigned long offset,
> - struct ext3_dir_entry_2 ** res_dir)
> + struct ext3_dir_entry_2 **res_dir)
> {
> - struct ext3_dir_entry_2 * de;
> - char * dlimit;
> + struct ext3_dir_entry_2 *de;
> + char *dlimit;
> int de_len;
> const char *name = child->name;
> int namelen = child->len;
> @@ -820,7 +815,7 @@ static inline int search_dirblock(struct buffer_head * bh,
> /* do minimal checking `by hand' */
>
> if ((char *) de + namelen <= dlimit &&
> - ext3_match (namelen, name, de)) {
> + ext3_match(namelen, name, de)) {
> /* found a match - just to be sure, do a full check */
> if (!ext3_check_dir_entry("ext3_find_entry",
> dir, de, bh, offset))
> @@ -854,9 +849,9 @@ static struct buffer_head *ext3_find_entry(struct inode *dir,
> struct qstr *entry,
> struct ext3_dir_entry_2 **res_dir)
> {
> - struct super_block * sb;
> - struct buffer_head * bh_use[NAMEI_RA_SIZE];
> - struct buffer_head * bh, *ret = NULL;
> + struct super_block *sb;
> + struct buffer_head *bh_use[NAMEI_RA_SIZE];
> + struct buffer_head *bh, *ret = NULL;
> unsigned long start, block, b;
> int ra_max = 0; /* Number of bh's in the readahead
> buffer, bh_use[] */
> @@ -953,15 +948,15 @@ restart:
> cleanup_and_exit:
> /* Clean up the read-ahead blocks */
> for (; ra_ptr < ra_max; ra_ptr++)
> - brelse (bh_use[ra_ptr]);
> + brelse(bh_use[ra_ptr]);
> return ret;
> }
>
> -static struct buffer_head * ext3_dx_find_entry(struct inode *dir,
> +static struct buffer_head *ext3_dx_find_entry(struct inode *dir,
> struct qstr *entry, struct ext3_dir_entry_2 **res_dir,
> int *err)
> {
> - struct super_block * sb;
> + struct super_block *sb;
> struct dx_hash_info hinfo;
> u32 hash;
> struct dx_frame frames[2], *frame;
> @@ -986,11 +981,11 @@ static struct buffer_head * ext3_dx_find_entry(struct inode *dir,
> hash = hinfo.hash;
> do {
> block = dx_get_block(frame->at);
> - if (!(bh = ext3_bread (NULL,dir, block, 0, err)))
> + if (!(bh = ext3_bread(NULL, dir, block, 0, err)))
> goto errout;
> de = (struct ext3_dir_entry_2 *) bh->b_data;
> - top = (struct ext3_dir_entry_2 *) ((char *) de + sb->s_blocksize -
> - EXT3_DIR_REC_LEN(0));
> + top = (struct ext3_dir_entry_2 *) ((char *) de +
> + sb->s_blocksize - EXT3_DIR_REC_LEN(0));
> for (; de < top; de = ext3_next_entry(de)) {
> int off = (block << EXT3_BLOCK_SIZE_BITS(sb))
> + ((char *) de - bh->b_data);
> @@ -1007,7 +1002,7 @@ static struct buffer_head * ext3_dx_find_entry(struct inode *dir,
> return bh;
> }
> }
> - brelse (bh);
> + brelse(bh);
> /* Check to see if we should continue to search */
> retval = ext3_htree_next_block(dir, hash, frame,
> frames, NULL);
> @@ -1023,15 +1018,16 @@ static struct buffer_head * ext3_dx_find_entry(struct inode *dir,
> *err = -ENOENT;
> errout:
> dxtrace(printk("%s not found\n", name));
> - dx_release (frames);
> + dx_release(frames);
> return NULL;
> }
>
> -static struct dentry *ext3_lookup(struct inode * dir, struct dentry *dentry, struct nameidata *nd)
> +static struct dentry *ext3_lookup(struct inode *dir, struct dentry *dentry,
> + struct nameidata *nd)
> {
> - struct inode * inode;
> - struct ext3_dir_entry_2 * de;
> - struct buffer_head * bh;
> + struct inode *inode;
> + struct ext3_dir_entry_2 *de;
> + struct buffer_head *bh;
>
> if (dentry->d_name.len > EXT3_NAME_LEN)
> return ERR_PTR(-ENAMETOOLONG);
> @@ -1040,7 +1036,7 @@ static struct dentry *ext3_lookup(struct inode * dir, struct dentry *dentry, str
> inode = NULL;
> if (bh) {
> unsigned long ino = le32_to_cpu(de->inode);
> - brelse (bh);
> + brelse(bh);
> if (!ext3_valid_inum(dir->i_sb, ino)) {
> ext3_error(dir->i_sb, "ext3_lookup",
> "bad inode number: %lu", ino);
> @@ -1050,8 +1046,8 @@ static struct dentry *ext3_lookup(struct inode * dir, struct dentry *dentry, str
> if (unlikely(IS_ERR(inode))) {
> if (PTR_ERR(inode) == -ESTALE) {
> ext3_error(dir->i_sb, __func__,
> - "deleted inode referenced: %lu",
> - ino);
> + "deleted inode referenced: %lu",
> + ino);
> return ERR_PTR(-EIO);
> } else {
> return ERR_CAST(inode);
> @@ -1065,8 +1061,8 @@ static struct dentry *ext3_lookup(struct inode * dir, struct dentry *dentry, str
> struct dentry *ext3_get_parent(struct dentry *child)
> {
> unsigned long ino;
> - struct qstr dotdot = {.name = "..", .len = 2};
> - struct ext3_dir_entry_2 * de;
> + struct qstr dotdot = { .name = "..", .len = 2 };
> + struct ext3_dir_entry_2 *de;
> struct buffer_head *bh;
>
> bh = ext3_find_entry(child->d_inode, &dotdot, &de);
> @@ -1097,7 +1093,8 @@ static unsigned char ext3_type_by_mode[S_IFMT >> S_SHIFT] = {
>
> static inline void ext3_set_de_type(struct super_block *sb,
> struct ext3_dir_entry_2 *de,
> - umode_t mode) {
> + umode_t mode)
> +{
> if (EXT3_HAS_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_FILETYPE))
> de->file_type = ext3_type_by_mode[(mode & S_IFMT)>>S_SHIFT];
> }
> @@ -1112,9 +1109,10 @@ dx_move_dirents(char *from, char *to, struct dx_map_entry *map, int count)
> unsigned rec_len = 0;
>
> while (count--) {
> - struct ext3_dir_entry_2 *de = (struct ext3_dir_entry_2 *) (from + map->offs);
> + struct ext3_dir_entry_2 *de;
> + de = (struct ext3_dir_entry_2 *) (from + map->offs);
> rec_len = EXT3_DIR_REC_LEN(de->name_len);
> - memcpy (to, de, rec_len);
> + memcpy(to, de, rec_len);
> ((struct ext3_dir_entry_2 *) to)->rec_len =
> ext3_rec_len_to_disk(rec_len);
> de->inode = 0;
> @@ -1143,7 +1141,8 @@ static struct ext3_dir_entry_2 *dx_pack_dirents(char *base, unsigned blocksize)
> memmove(to, de, rec_len);
> to->rec_len = ext3_rec_len_to_disk(rec_len);
> prev = to;
> - to = (struct ext3_dir_entry_2 *) (((char *) to) + rec_len);
> + to = (struct ext3_dir_entry_2 *)
> + (((char *) to) + rec_len);
> }
> de = next;
> }
> @@ -1170,7 +1169,7 @@ static struct ext3_dir_entry_2 *do_split(handle_t *handle, struct inode *dir,
> struct ext3_dir_entry_2 *de = NULL, *de2;
> int err = 0, i;
>
> - bh2 = ext3_append (handle, dir, &newblock, &err);
> + bh2 = ext3_append(handle, dir, &newblock, &err);
> if (!(bh2)) {
> brelse(*bh);
> *bh = NULL;
> @@ -1191,10 +1190,10 @@ static struct ext3_dir_entry_2 *do_split(handle_t *handle, struct inode *dir,
>
> /* create map in the end of data2 block */
> map = (struct dx_map_entry *) (data2 + blocksize);
> - count = dx_make_map ((struct ext3_dir_entry_2 *) data1,
> + count = dx_make_map((struct ext3_dir_entry_2 *) data1,
> blocksize, hinfo, map);
> map -= count;
> - dx_sort_map (map, count);
> + dx_sort_map(map, count);
> /* Split the existing block in the middle, size-wise */
> size = 0;
> move = 0;
> @@ -1217,24 +1216,25 @@ static struct ext3_dir_entry_2 *do_split(handle_t *handle, struct inode *dir,
> de = dx_pack_dirents(data1,blocksize);
> de->rec_len = ext3_rec_len_to_disk(data1 + blocksize - (char *) de);
> de2->rec_len = ext3_rec_len_to_disk(data2 + blocksize - (char *) de2);
> - dxtrace(dx_show_leaf (hinfo, (struct ext3_dir_entry_2 *) data1, blocksize, 1));
> - dxtrace(dx_show_leaf (hinfo, (struct ext3_dir_entry_2 *) data2, blocksize, 1));
> + dxtrace(dx_show_leaf(hinfo, (struct ext3_dir_entry_2 *) data1,
> + blocksize, 1));
> + dxtrace(dx_show_leaf(hinfo, (struct ext3_dir_entry_2 *) data2,
> + blocksize, 1));
>
> /* Which block gets the new entry? */
> - if (hinfo->hash >= hash2)
> - {
> + if (hinfo->hash >= hash2) {
> swap(*bh, bh2);
> de = de2;
> }
> - dx_insert_block (frame, hash2 + continued, newblock);
> - err = ext3_journal_dirty_metadata (handle, bh2);
> + dx_insert_block(frame, hash2 + continued, newblock);
> + err = ext3_journal_dirty_metadata(handle, bh2);
> if (err)
> goto journal_error;
> - err = ext3_journal_dirty_metadata (handle, frame->bh);
> + err = ext3_journal_dirty_metadata(handle, frame->bh);
> if (err)
> goto journal_error;
> - brelse (bh2);
> - dxtrace(dx_show_index ("frame", frame->entries));
> + brelse(bh2);
> + dxtrace(dx_show_index("frame", frame->entries));
> return de;
>
> journal_error:
> @@ -1261,7 +1261,7 @@ errout:
> */
> static int add_dirent_to_buf(handle_t *handle, struct dentry *dentry,
> struct inode *inode, struct ext3_dir_entry_2 *de,
> - struct buffer_head * bh)
> + struct buffer_head *bh)
> {
> struct inode *dir = dentry->d_parent->d_inode;
> const char *name = dentry->d_name.name;
> @@ -1278,11 +1278,11 @@ static int add_dirent_to_buf(handle_t *handle, struct dentry *dentry,
> while ((char *) de <= top) {
> if (!ext3_check_dir_entry("ext3_add_entry", dir, de,
> bh, offset)) {
> - brelse (bh);
> + brelse(bh);
> return -EIO;
> }
> - if (ext3_match (namelen, name, de)) {
> - brelse (bh);
> + if (ext3_match(namelen, name, de)) {
> + brelse(bh);
> return -EEXIST;
> }
> nlen = EXT3_DIR_REC_LEN(de->name_len);
> @@ -1307,7 +1307,8 @@ static int add_dirent_to_buf(handle_t *handle, struct dentry *dentry,
> nlen = EXT3_DIR_REC_LEN(de->name_len);
> rlen = ext3_rec_len_from_disk(de->rec_len);
> if (de->inode) {
> - struct ext3_dir_entry_2 *de1 = (struct ext3_dir_entry_2 *)((char *)de + nlen);
> + struct ext3_dir_entry_2 *de1;
> + de1 = (struct ext3_dir_entry_2 *)((char *)de + nlen);
> de1->rec_len = ext3_rec_len_to_disk(rlen - nlen);
> de->rec_len = ext3_rec_len_to_disk(nlen);
> de = de1;
> @@ -1319,7 +1320,7 @@ static int add_dirent_to_buf(handle_t *handle, struct dentry *dentry,
> } else
> de->inode = 0;
> de->name_len = namelen;
> - memcpy (de->name, name, namelen);
> + memcpy(de->name, name, namelen);
> /*
> * XXX shouldn't update any times until successful
> * completion of syscall, but too many callers depend
> @@ -1389,7 +1390,7 @@ static int make_indexed_dir(handle_t *handle, struct dentry *dentry,
> }
> len = ((char *) root) + blocksize - (char *) de;
>
> - bh2 = ext3_append (handle, dir, &block, &retval);
> + bh2 = ext3_append(handle, dir, &block, &retval);
> if (!(bh2)) {
> brelse(bh);
> return retval;
> @@ -1397,7 +1398,7 @@ static int make_indexed_dir(handle_t *handle, struct dentry *dentry,
> EXT3_I(dir)->i_flags |= EXT3_INDEX_FL;
> data1 = bh2->b_data;
>
> - memcpy (data1, de, len);
> + memcpy(data1, de, len);
> de = (struct ext3_dir_entry_2 *) data1;
> top = data1 + len;
> while ((char *)(de2 = ext3_next_entry(de)) < top)
> @@ -1406,13 +1407,13 @@ static int make_indexed_dir(handle_t *handle, struct dentry *dentry,
> /* Initialize the root; the dot dirents already exist */
> de = (struct ext3_dir_entry_2 *) (&root->dotdot);
> de->rec_len = ext3_rec_len_to_disk(blocksize - EXT3_DIR_REC_LEN(2));
> - memset (&root->info, 0, sizeof(root->info));
> + memset(&root->info, 0, sizeof(root->info));
> root->info.info_length = sizeof(root->info);
> root->info.hash_version = EXT3_SB(dir->i_sb)->s_def_hash_version;
> entries = root->entries;
> - dx_set_block (entries, 1);
> - dx_set_count (entries, 1);
> - dx_set_limit (entries, dx_root_limit(dir, sizeof(root->info)));
> + dx_set_block(entries, 1);
> + dx_set_count(entries, 1);
> + dx_set_limit(entries, dx_root_limit(dir, sizeof(root->info)));
>
> /* Initialize as for dx_probe */
> hinfo.hash_version = root->info.hash_version;
> @@ -1425,8 +1426,8 @@ static int make_indexed_dir(handle_t *handle, struct dentry *dentry,
> frame->at = entries;
> frame->bh = bh;
> bh = bh2;
> - de = do_split(handle,dir, &bh, frame, &hinfo, &retval);
> - dx_release (frames);
> + de = do_split(handle, dir, &bh, frame, &hinfo, &retval);
> + dx_release(frames);
> if (!(de))
> return retval;
>
> @@ -1443,13 +1444,13 @@ static int make_indexed_dir(handle_t *handle, struct dentry *dentry,
> * may not sleep between calling this and putting something into
> * the entry, as someone else might have used it while you slept.
> */
> -static int ext3_add_entry (handle_t *handle, struct dentry *dentry,
> +static int ext3_add_entry(handle_t *handle, struct dentry *dentry,
> struct inode *inode)
> {
> struct inode *dir = dentry->d_parent->d_inode;
> - struct buffer_head * bh;
> + struct buffer_head *bh;
> struct ext3_dir_entry_2 *de;
> - struct super_block * sb;
> + struct super_block *sb;
> int retval;
> int dx_fallback=0;
> unsigned blocksize;
> @@ -1499,9 +1500,9 @@ static int ext3_dx_add_entry(handle_t *handle, struct dentry *dentry,
> struct dx_frame frames[2], *frame;
> struct dx_entry *entries, *at;
> struct dx_hash_info hinfo;
> - struct buffer_head * bh;
> + struct buffer_head *bh;
> struct inode *dir = dentry->d_parent->d_inode;
> - struct super_block * sb = dir->i_sb;
> + struct super_block *sb = dir->i_sb;
> struct ext3_dir_entry_2 *de;
> int err;
>
> @@ -1511,7 +1512,7 @@ static int ext3_dx_add_entry(handle_t *handle, struct dentry *dentry,
> entries = frame->entries;
> at = frame->at;
>
> - if (!(bh = ext3_bread(handle,dir, dx_get_block(frame->at), 0, &err)))
> + if (!(bh = ext3_bread(handle, dir, dx_get_block(frame->at), 0, &err)))
> goto cleanup;
>
> BUFFER_TRACE(bh, "get_write_access");
> @@ -1544,7 +1545,7 @@ static int ext3_dx_add_entry(handle_t *handle, struct dentry *dentry,
> err = -ENOSPC;
> goto cleanup;
> }
> - bh2 = ext3_append (handle, dir, &newblock, &err);
> + bh2 = ext3_append(handle, dir, &newblock, &err);
> if (!(bh2))
> goto cleanup;
> node2 = (struct dx_node *)(bh2->b_data);
> @@ -1556,37 +1557,42 @@ static int ext3_dx_add_entry(handle_t *handle, struct dentry *dentry,
> if (err)
> goto journal_error;
> if (levels) {
> - unsigned icount1 = icount/2, icount2 = icount - icount1;
> + unsigned icount1 = icount/2;
> + unsigned icount2 = icount - icount1;
> unsigned hash2 = dx_get_hash(entries + icount1);
> - dxtrace(printk("Split index %i/%i\n", icount1, icount2));
> + dxtrace(printk("Split index %i/%i\n",
> + icount1, icount2));
>
> - BUFFER_TRACE(frame->bh, "get_write_access"); /* index root */
> + /* index root */
> + BUFFER_TRACE(frame->bh, "get_write_access");
> err = ext3_journal_get_write_access(handle,
> frames[0].bh);
> if (err)
> goto journal_error;
>
> - memcpy ((char *) entries2, (char *) (entries + icount1),
> + memcpy((char *) entries2, (char *) (entries + icount1),
> icount2 * sizeof(struct dx_entry));
> - dx_set_count (entries, icount1);
> - dx_set_count (entries2, icount2);
> - dx_set_limit (entries2, dx_node_limit(dir));
> + dx_set_count(entries, icount1);
> + dx_set_count(entries2, icount2);
> + dx_set_limit(entries2, dx_node_limit(dir));
>
> /* Which index block gets the new entry? */
> if (at - entries >= icount1) {
> - frame->at = at = at - entries - icount1 + entries2;
> + frame->at = at = at - entries - icount1 +
> + entries2;
> frame->entries = entries = entries2;
> swap(frame->bh, bh2);
> }
> - dx_insert_block (frames + 0, hash2, newblock);
> - dxtrace(dx_show_index ("node", frames[1].entries));
> - dxtrace(dx_show_index ("node",
> + dx_insert_block(frames + 0, hash2, newblock);
> + dxtrace(dx_show_index("node", frames[1].entries));
> + dxtrace(dx_show_index("node",
> ((struct dx_node *) bh2->b_data)->entries));
> err = ext3_journal_dirty_metadata(handle, bh2);
> if (err)
> goto journal_error;
> - brelse (bh2);
> + brelse(bh2);
> } else {
> + struct dx_root *root;
> dxtrace(printk("Creating second level index...\n"));
> memcpy((char *) entries2, (char *) entries,
> icount * sizeof(struct dx_entry));
> @@ -1595,7 +1601,8 @@ static int ext3_dx_add_entry(handle_t *handle, struct dentry *dentry,
> /* Set up root */
> dx_set_count(entries, 1);
> dx_set_block(entries + 0, newblock);
> - ((struct dx_root *) frames[0].bh->b_data)->info.indirect_levels = 1;
> + root = (struct dx_root *) frames[0].bh->b_data;
> + root->info.indirect_levels = 1;
>
> /* Add new access path frame */
> frame = frames + 1;
> @@ -1629,19 +1636,18 @@ cleanup:
> * ext3_delete_entry deletes a directory entry by merging it with the
> * previous entry
> */
> -static int ext3_delete_entry (handle_t *handle,
> - struct inode * dir,
> - struct ext3_dir_entry_2 * de_del,
> - struct buffer_head * bh)
> +static int ext3_delete_entry(handle_t *handle, struct inode *dir,
> + struct ext3_dir_entry_2 *de_del,
> + struct buffer_head *bh)
> {
> - struct ext3_dir_entry_2 * de, * pde;
> + struct ext3_dir_entry_2 *de, *pde;
> int i;
>
> i = 0;
> pde = NULL;
> de = (struct ext3_dir_entry_2 *) bh->b_data;
> while (i < bh->b_size) {
> - if (!ext3_check_dir_entry("ext3_delete_entry", dir, de, bh, i))
> + if (!ext3_check_dir_entry(__func__, dir, de, bh, i))
> return -EIO;
> if (de == de_del) {
> int err;
> @@ -1698,11 +1704,11 @@ static int ext3_add_nondir(handle_t *handle,
> * If the create succeeds, we fill in the inode information
> * with d_instantiate().
> */
> -static int ext3_create (struct inode * dir, struct dentry * dentry, int mode,
> +static int ext3_create(struct inode *dir, struct dentry *dentry, int mode,
> struct nameidata *nd)
> {
> handle_t *handle;
> - struct inode * inode;
> + struct inode *inode;
> int err, retries = 0;
>
> dquot_initialize(dir);
> @@ -1717,7 +1723,7 @@ retry:
> if (IS_DIRSYNC(dir))
> handle->h_sync = 1;
>
> - inode = ext3_new_inode (handle, dir, mode);
> + inode = ext3_new_inode(handle, dir, mode);
> err = PTR_ERR(inode);
> if (!IS_ERR(inode)) {
> inode->i_op = &ext3_file_inode_operations;
> @@ -1731,7 +1737,7 @@ retry:
> return err;
> }
>
> -static int ext3_mknod (struct inode * dir, struct dentry *dentry,
> +static int ext3_mknod(struct inode *dir, struct dentry *dentry,
> int mode, dev_t rdev)
> {
> handle_t *handle;
> @@ -1753,7 +1759,7 @@ retry:
> if (IS_DIRSYNC(dir))
> handle->h_sync = 1;
>
> - inode = ext3_new_inode (handle, dir, mode);
> + inode = ext3_new_inode(handle, dir, mode);
> err = PTR_ERR(inode);
> if (!IS_ERR(inode)) {
> init_special_inode(inode, inode->i_mode, rdev);
> @@ -1768,12 +1774,12 @@ retry:
> return err;
> }
>
> -static int ext3_mkdir(struct inode * dir, struct dentry * dentry, int mode)
> +static int ext3_mkdir(struct inode *dir, struct dentry *dentry, int mode)
> {
> handle_t *handle;
> - struct inode * inode;
> - struct buffer_head * dir_block = NULL;
> - struct ext3_dir_entry_2 * de;
> + struct inode *inode;
> + struct buffer_head *dir_block = NULL;
> + struct ext3_dir_entry_2 *de;
> int err, retries = 0;
>
> if (dir->i_nlink >= EXT3_LINK_MAX)
> @@ -1791,7 +1797,7 @@ retry:
> if (IS_DIRSYNC(dir))
> handle->h_sync = 1;
>
> - inode = ext3_new_inode (handle, dir, S_IFDIR | mode);
> + inode = ext3_new_inode(handle, dir, S_IFDIR | mode);
> err = PTR_ERR(inode);
> if (IS_ERR(inode))
> goto out_stop;
> @@ -1799,7 +1805,7 @@ retry:
> inode->i_op = &ext3_dir_inode_operations;
> inode->i_fop = &ext3_dir_operations;
> inode->i_size = EXT3_I(inode)->i_disksize = inode->i_sb->s_blocksize;
> - dir_block = ext3_bread (handle, inode, 0, 1, &err);
> + dir_block = ext3_bread(handle, inode, 0, 1, &err);
> if (!dir_block)
> goto out_clear_inode;
>
> @@ -1812,14 +1818,14 @@ retry:
> de->inode = cpu_to_le32(inode->i_ino);
> de->name_len = 1;
> de->rec_len = ext3_rec_len_to_disk(EXT3_DIR_REC_LEN(de->name_len));
> - strcpy (de->name, ".");
> + strcpy(de->name, ".");
> ext3_set_de_type(dir->i_sb, de, S_IFDIR);
> de = ext3_next_entry(de);
> de->inode = cpu_to_le32(dir->i_ino);
> de->rec_len = ext3_rec_len_to_disk(inode->i_sb->s_blocksize -
> EXT3_DIR_REC_LEN(1));
> de->name_len = 2;
> - strcpy (de->name, "..");
> + strcpy(de->name, "..");
> ext3_set_de_type(dir->i_sb, de, S_IFDIR);
> inode->i_nlink = 2;
> BUFFER_TRACE(dir_block, "call ext3_journal_dirty_metadata");
> @@ -1829,14 +1835,14 @@ retry:
>
> err = ext3_mark_inode_dirty(handle, inode);
> if (!err)
> - err = ext3_add_entry (handle, dentry, inode);
> + err = ext3_add_entry(handle, dentry, inode);
>
> if (err) {
> out_clear_inode:
> inode->i_nlink = 0;
> unlock_new_inode(inode);
> ext3_mark_inode_dirty(handle, inode);
> - iput (inode);
> + iput(inode);
> goto out_stop;
> }
> inc_nlink(dir);
> @@ -1858,37 +1864,36 @@ out_stop:
> /*
> * routine to check that the specified directory is empty (for rmdir)
> */
> -static int empty_dir (struct inode * inode)
> +static int empty_dir(struct inode *inode)
> {
> unsigned long offset;
> - struct buffer_head * bh;
> - struct ext3_dir_entry_2 * de, * de1;
> - struct super_block * sb;
> + struct buffer_head *bh;
> + struct ext3_dir_entry_2 *de, *de1;
> + struct super_block *sb;
> int err = 0;
>
> sb = inode->i_sb;
> if (inode->i_size < EXT3_DIR_REC_LEN(1) + EXT3_DIR_REC_LEN(2) ||
> - !(bh = ext3_bread (NULL, inode, 0, 0, &err))) {
> + !(bh = ext3_bread(NULL, inode, 0, 0, &err))) {
> if (err)
> ext3_error(inode->i_sb, __func__,
> "error %d reading directory #%lu offset 0",
> err, inode->i_ino);
> else
> ext3_warning(inode->i_sb, __func__,
> - "bad directory (dir #%lu) - no data block",
> - inode->i_ino);
> + "bad directory (dir #%lu)"
> + " - no data block", inode->i_ino);
> return 1;
> }
> de = (struct ext3_dir_entry_2 *) bh->b_data;
> de1 = ext3_next_entry(de);
> if (le32_to_cpu(de->inode) != inode->i_ino ||
> !le32_to_cpu(de1->inode) ||
> - strcmp (".", de->name) ||
> - strcmp ("..", de1->name)) {
> - ext3_warning (inode->i_sb, "empty_dir",
> - "bad directory (dir #%lu) - no `.' or `..'",
> - inode->i_ino);
> - brelse (bh);
> + strcmp(".", de->name) ||
> + strcmp("..", de1->name)) {
> + ext3_warning(inode->i_sb, __func__, "bad directory (dir #%lu)"
> + " - no `.' or `..'", inode->i_ino);
> + brelse(bh);
> return 1;
> }
> offset = ext3_rec_len_from_disk(de->rec_len) +
> @@ -1898,8 +1903,8 @@ static int empty_dir (struct inode * inode)
> if (!bh ||
> (void *) de >= (void *) (bh->b_data+sb->s_blocksize)) {
> err = 0;
> - brelse (bh);
> - bh = ext3_bread (NULL, inode,
> + brelse(bh);
> + bh = ext3_bread(NULL, inode,
> offset >> EXT3_BLOCK_SIZE_BITS(sb), 0, &err);
> if (!bh) {
> if (err)
> @@ -1912,20 +1917,20 @@ static int empty_dir (struct inode * inode)
> }
> de = (struct ext3_dir_entry_2 *) bh->b_data;
> }
> - if (!ext3_check_dir_entry("empty_dir", inode, de, bh, offset)) {
> + if (!ext3_check_dir_entry(__func__, inode, de, bh, offset)) {
> de = (struct ext3_dir_entry_2 *)(bh->b_data +
> sb->s_blocksize);
> offset = (offset | (sb->s_blocksize - 1)) + 1;
> continue;
> }
> if (le32_to_cpu(de->inode)) {
> - brelse (bh);
> + brelse(bh);
> return 0;
> }
> offset += ext3_rec_len_from_disk(de->rec_len);
> de = ext3_next_entry(de);
> }
> - brelse (bh);
> + brelse(bh);
> return 1;
> }
>
> @@ -2046,8 +2051,11 @@ int ext3_orphan_del(handle_t *handle, struct inode *inode)
> err = ext3_journal_dirty_metadata(handle, sbi->s_sbh);
> } else {
> struct ext3_iloc iloc2;
> - struct inode *i_prev =
> - &list_entry(prev, struct ext3_inode_info, i_orphan)->vfs_inode;
> + struct ext3_inode_info *ei;
> + struct inode *i_prev;
> +
> + ei = list_entry(prev, struct ext3_inode_info, i_orphan);
> + i_prev = &ei->vfs_inode;
>
> jbd_debug(4, "orphan inode %lu will point to %lu\n",
> i_prev->i_ino, ino_next);
> @@ -2073,12 +2081,12 @@ out_brelse:
> goto out_err;
> }
>
> -static int ext3_rmdir (struct inode * dir, struct dentry *dentry)
> +static int ext3_rmdir(struct inode *dir, struct dentry *dentry)
> {
> int retval;
> - struct inode * inode;
> - struct buffer_head * bh;
> - struct ext3_dir_entry_2 * de;
> + struct inode *inode;
> + struct buffer_head *bh;
> + struct ext3_dir_entry_2 *de;
> handle_t *handle;
>
> /* Initialize quotas before so that eventual writes go in
> @@ -2105,14 +2113,14 @@ static int ext3_rmdir (struct inode * dir, struct dentry *dentry)
> goto end_rmdir;
>
> retval = -ENOTEMPTY;
> - if (!empty_dir (inode))
> + if (!empty_dir(inode))
> goto end_rmdir;
>
> retval = ext3_delete_entry(handle, dir, de, bh);
> if (retval)
> goto end_rmdir;
> if (inode->i_nlink != 2)
> - ext3_warning (inode->i_sb, "ext3_rmdir",
> + ext3_warning(inode->i_sb, "ext3_rmdir",
> "empty directory has nlink!=2 (%d)",
> inode->i_nlink);
> inode->i_version++;
> @@ -2130,16 +2138,16 @@ static int ext3_rmdir (struct inode * dir, struct dentry *dentry)
>
> end_rmdir:
> ext3_journal_stop(handle);
> - brelse (bh);
> + brelse(bh);
> return retval;
> }
>
> -static int ext3_unlink(struct inode * dir, struct dentry *dentry)
> +static int ext3_unlink(struct inode *dir, struct dentry *dentry)
> {
> int retval;
> - struct inode * inode;
> - struct buffer_head * bh;
> - struct ext3_dir_entry_2 * de;
> + struct inode *inode;
> + struct buffer_head *bh;
> + struct ext3_dir_entry_2 *de;
> handle_t *handle;
>
> /* Initialize quotas before so that eventual writes go
> @@ -2166,7 +2174,7 @@ static int ext3_unlink(struct inode * dir, struct dentry *dentry)
> goto end_unlink;
>
> if (!inode->i_nlink) {
> - ext3_warning (inode->i_sb, "ext3_unlink",
> + ext3_warning(inode->i_sb, "ext3_unlink",
> "Deleting nonexistent file (%lu), %d",
> inode->i_ino, inode->i_nlink);
> inode->i_nlink = 1;
> @@ -2186,15 +2194,15 @@ static int ext3_unlink(struct inode * dir, struct dentry *dentry)
>
> end_unlink:
> ext3_journal_stop(handle);
> - brelse (bh);
> + brelse(bh);
> return retval;
> }
>
> -static int ext3_symlink (struct inode * dir,
> - struct dentry *dentry, const char * symname)
> +static int ext3_symlink(struct inode *dir,
> + struct dentry *dentry, const char *symname)
> {
> handle_t *handle;
> - struct inode * inode;
> + struct inode *inode;
> int l, err, retries = 0;
>
> l = strlen(symname)+1;
> @@ -2213,12 +2221,12 @@ retry:
> if (IS_DIRSYNC(dir))
> handle->h_sync = 1;
>
> - inode = ext3_new_inode (handle, dir, S_IFLNK|S_IRWXUGO);
> + inode = ext3_new_inode(handle, dir, S_IFLNK|S_IRWXUGO);
> err = PTR_ERR(inode);
> if (IS_ERR(inode))
> goto out_stop;
>
> - if (l > sizeof (EXT3_I(inode)->i_data)) {
> + if (l > sizeof(EXT3_I(inode)->i_data)) {
> inode->i_op = &ext3_symlink_inode_operations;
> ext3_set_aops(inode);
> /*
> @@ -2231,7 +2239,7 @@ retry:
> drop_nlink(inode);
> unlock_new_inode(inode);
> ext3_mark_inode_dirty(handle, inode);
> - iput (inode);
> + iput(inode);
> goto out_stop;
> }
> } else {
> @@ -2248,8 +2256,8 @@ out_stop:
> return err;
> }
>
> -static int ext3_link (struct dentry * old_dentry,
> - struct inode * dir, struct dentry *dentry)
> +static int ext3_link(struct dentry *old_dentry,
> + struct inode *dir, struct dentry *dentry)
> {
> handle_t *handle;
> struct inode *inode = old_dentry->d_inode;
> @@ -2301,13 +2309,13 @@ retry:
> * Anybody can rename anything with this: the permission checks are left to the
> * higher-level routines.
> */
> -static int ext3_rename (struct inode * old_dir, struct dentry *old_dentry,
> - struct inode * new_dir,struct dentry *new_dentry)
> +static int ext3_rename(struct inode *old_dir, struct dentry *old_dentry,
> + struct inode *new_dir, struct dentry *new_dentry)
> {
> handle_t *handle;
> - struct inode * old_inode, * new_inode;
> - struct buffer_head * old_bh, * new_bh, * dir_bh;
> - struct ext3_dir_entry_2 * old_de, * new_de;
> + struct inode *old_inode, *new_inode;
> + struct buffer_head *old_bh, *new_bh, *dir_bh;
> + struct ext3_dir_entry_2 *old_de, *new_de;
> int retval, flush_file = 0;
>
> dquot_initialize(old_dir);
> @@ -2344,18 +2352,18 @@ static int ext3_rename (struct inode * old_dir, struct dentry *old_dentry,
> new_bh = ext3_find_entry(new_dir, &new_dentry->d_name, &new_de);
> if (new_bh) {
> if (!new_inode) {
> - brelse (new_bh);
> + brelse(new_bh);
> new_bh = NULL;
> }
> }
> if (S_ISDIR(old_inode->i_mode)) {
> if (new_inode) {
> retval = -ENOTEMPTY;
> - if (!empty_dir (new_inode))
> + if (!empty_dir(new_inode))
> goto end_rename;
> }
> retval = -EIO;
> - dir_bh = ext3_bread (handle, old_inode, 0, 0, &retval);
> + dir_bh = ext3_bread(handle, old_inode, 0, 0, &retval);
> if (!dir_bh)
> goto end_rename;
> if (le32_to_cpu(PARENT_INO(dir_bh->b_data)) != old_dir->i_ino)
> @@ -2366,7 +2374,7 @@ static int ext3_rename (struct inode * old_dir, struct dentry *old_dentry,
> goto end_rename;
> }
> if (!new_bh) {
> - retval = ext3_add_entry (handle, new_dentry, old_inode);
> + retval = ext3_add_entry(handle, new_dentry, old_inode);
> if (retval)
> goto end_rename;
> } else {
> @@ -2468,9 +2476,9 @@ journal_error2:
> retval = 0;
>
> end_rename:
> - brelse (dir_bh);
> - brelse (old_bh);
> - brelse (new_bh);
> + brelse(dir_bh);
> + brelse(old_bh);
> + brelse(new_bh);
> ext3_journal_stop(handle);
> if (retval == 0 && flush_file)
> filemap_flush(old_inode->i_mapping);
> --
> 1.7.0.4
>
> --
> To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at http://vger.kernel.org/majordomo-info.html
> Please read the FAQ at http://www.tux.org/lkml/



\
 
 \ /
  Last update: 2010-11-19 13:59    [W:0.096 / U:9.348 seconds]
©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site