adulau/aha
1
0
Fork 0
mirror of https://github.com/adulau/aha.git synced 2024-12-28 11:46:19 +00:00
Code Issues Projects Releases Packages Wiki Activity

iget: stop BFS from using iget() and read_inode()

Browse source 
Stop the BFS filesystem from using iget() and read_inode().  Replace
bfs_read_inode() with bfs_iget(), and call that instead of iget().  bfs_iget()
then uses iget_locked() directly and returns a proper error code instead of an
inode in the event of an error.

bfs_fill_super() returns any error incurred when getting the root inode
instead of EINVAL.

[kamalesh@linux.vnet.ibm.com: build fix]
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Kamalesh Babulal <kamalesh@linux.vnet.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
This commit is contained in:
David Howells 2008-02-07 00:15:32 -08:00 committed by Linus Torvalds
parent 96eb541941
commit e33ab086ae
3 changed files with 27 additions and 13 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
fs/bfs/bfs.h
View file

@ -44,6 +44,8 @@ static inline struct bfs_inode_info *BFS_I(struct inode *inode)
#define printf(format, args...) \ #define printf(format, args...) \
printk(KERN_ERR "BFS-fs: %s(): " format, __FUNCTION__, ## args) printk(KERN_ERR "BFS-fs: %s(): " format, __FUNCTION__, ## args)
/* inode.c */
extern struct inode *bfs_iget(struct super_block *sb, unsigned long ino);
/* file.c */ /* file.c */
extern const struct inode_operations bfs_file_inops; extern const struct inode_operations bfs_file_inops;

6
fs/bfs/dir.c
View file

@ -148,10 +148,10 @@ static struct dentry *bfs_lookup(struct inode *dir, struct dentry *dentry,
if (bh) { if (bh) {
unsigned long ino = (unsigned long)le16_to_cpu(de->ino); unsigned long ino = (unsigned long)le16_to_cpu(de->ino);
brelse(bh); brelse(bh);
inode = iget(dir->i_sb, ino); inode = bfs_iget(dir->i_sb, ino);
if (!inode) { if (IS_ERR(inode)) {
unlock_kernel(); unlock_kernel();
return ERR_PTR(-EACCES); return ERR_CAST(inode);
} }
} }
unlock_kernel(); unlock_kernel();

32
fs/bfs/inode.c
View file

@ -32,17 +32,22 @@ MODULE_LICENSE("GPL");
void dump_imap(const char *prefix, struct super_block *s); void dump_imap(const char *prefix, struct super_block *s);
static void bfs_read_inode(struct inode *inode) struct inode *bfs_iget(struct super_block *sb, unsigned long ino)
{ {
unsigned long ino = inode->i_ino;
struct bfs_inode *di; struct bfs_inode *di;
struct inode *inode;
struct buffer_head *bh; struct buffer_head *bh;
int block, off; int block, off;
inode = iget_locked(sb, ino);
if (IS_ERR(inode))
return ERR_PTR(-ENOMEM);
if (!(inode->i_state & I_NEW))
return inode;
if ((ino < BFS_ROOT_INO) || (ino > BFS_SB(inode->i_sb)->si_lasti)) { if ((ino < BFS_ROOT_INO) || (ino > BFS_SB(inode->i_sb)->si_lasti)) {
printf("Bad inode number %s:%08lx\n", inode->i_sb->s_id, ino); printf("Bad inode number %s:%08lx\n", inode->i_sb->s_id, ino);
make_bad_inode(inode); goto error;
return;
} }
block = (ino - BFS_ROOT_INO) / BFS_INODES_PER_BLOCK + 1; block = (ino - BFS_ROOT_INO) / BFS_INODES_PER_BLOCK + 1;
@ -50,8 +55,7 @@ static void bfs_read_inode(struct inode *inode)
if (!bh) { if (!bh) {
printf("Unable to read inode %s:%08lx\n", inode->i_sb->s_id, printf("Unable to read inode %s:%08lx\n", inode->i_sb->s_id,
ino); ino);
make_bad_inode(inode); goto error;
return;
} }
off = (ino - BFS_ROOT_INO) % BFS_INODES_PER_BLOCK; off = (ino - BFS_ROOT_INO) % BFS_INODES_PER_BLOCK;
@ -85,6 +89,12 @@ static void bfs_read_inode(struct inode *inode)
inode->i_ctime.tv_nsec = 0; inode->i_ctime.tv_nsec = 0;
brelse(bh); brelse(bh);
unlock_new_inode(inode);
return inode;
error:
iget_failed(inode);
return ERR_PTR(-EIO);
} }
static int bfs_write_inode(struct inode *inode, int unused) static int bfs_write_inode(struct inode *inode, int unused)
@ -276,7 +286,6 @@ static void destroy_inodecache(void)
static const struct super_operations bfs_sops = { static const struct super_operations bfs_sops = {
.alloc_inode = bfs_alloc_inode, .alloc_inode = bfs_alloc_inode,
.destroy_inode = bfs_destroy_inode, .destroy_inode = bfs_destroy_inode,
.read_inode = bfs_read_inode,
.write_inode = bfs_write_inode, .write_inode = bfs_write_inode,
.delete_inode = bfs_delete_inode, .delete_inode = bfs_delete_inode,
.put_super = bfs_put_super, .put_super = bfs_put_super,
@ -312,6 +321,7 @@ static int bfs_fill_super(struct super_block *s, void *data, int silent)
struct inode *inode; struct inode *inode;
unsigned i, imap_len; unsigned i, imap_len;
struct bfs_sb_info *info; struct bfs_sb_info *info;
long ret = -EINVAL;
info = kzalloc(sizeof(*info), GFP_KERNEL); info = kzalloc(sizeof(*info), GFP_KERNEL);
if (!info) if (!info)
@ -346,14 +356,16 @@ static int bfs_fill_super(struct super_block *s, void *data, int silent)
set_bit(i, info->si_imap); set_bit(i, info->si_imap);
s->s_op = &bfs_sops; s->s_op = &bfs_sops;
inode = iget(s, BFS_ROOT_INO); inode = bfs_iget(s, BFS_ROOT_INO);
if (!inode) { if (IS_ERR(inode)) {
ret = PTR_ERR(inode);
kfree(info->si_imap); kfree(info->si_imap);
goto out; goto out;
} }
s->s_root = d_alloc_root(inode); s->s_root = d_alloc_root(inode);
if (!s->s_root) { if (!s->s_root) {
iput(inode); iput(inode);
ret = -ENOMEM;
kfree(info->si_imap); kfree(info->si_imap);
goto out; goto out;
} }
@ -404,7 +416,7 @@ out:
brelse(bh); brelse(bh);
kfree(info); kfree(info);
s->s_fs_info = NULL; s->s_fs_info = NULL;
return -EINVAL; return ret;
} }
static int bfs_get_sb(struct file_system_type *fs_type, static int bfs_get_sb(struct file_system_type *fs_type,