Second round of changing functions to return negative errors

4 files changed, 61 insertions, 31 deletions

diff --git a/kernel/fs/squashfs/fragment.c b/kernel/fs/squashfs/fragment.c
index 24871e4..186b346 100644
--- a/kernel/fs/squashfs/fragment.c
+++ b/kernel/fs/squashfs/fragment.c
@@ -51,7 +51,7 @@ int get_fragment_location(struct super_block *s, unsigned int fragment,
 	int offset = SQUASHFS_FRAGMENT_INDEX_OFFSET(fragment);
 	long long start_block = le64_to_cpu(msblk->fragment_index[block]);
 	struct squashfs_fragment_entry fragment_entry;
-	int size = 0;
+	int size = -EIO;
 
 	if (!squashfs_read_metadata(s, &fragment_entry, &start_block, &offset,
 				 		sizeof(fragment_entry)))
diff --git a/kernel/fs/squashfs/inode.c b/kernel/fs/squashfs/inode.c
index 092a20a..7f2cef2 100644
--- a/kernel/fs/squashfs/inode.c
+++ b/kernel/fs/squashfs/inode.c
@@ -62,7 +62,7 @@ static int squashfs_new_inode(struct super_block *s, struct inode *i,
 		goto out;
 
 	err = squashfs_get_id(s, le16_to_cpu(inodeb->guid), &i->i_gid);
-	if (err < 0)
+	if (err)
 		goto out;
 
 	i->i_ino = le32_to_cpu(inodeb->inode_number);
@@ -81,14 +81,22 @@ struct inode *squashfs_iget(struct super_block *s, long long inode,
 				unsigned int inode_number)
 {
 	struct inode *i = iget_locked(s, inode_number);
+	int err;
 
 	TRACE("Entered squashfs_iget\n");
 
-	if (i && (i->i_state & I_NEW)) {
-		squashfs_read_inode(i, inode);
-		unlock_new_inode(i);
+	if (!i)
+		return ERR_PTR(-ENOMEM);
+	if (!(i->i_state & I_NEW))
+		return i;
+
+	err = squashfs_read_inode(i, inode);
+	if (err) {
+		iget_failed(i);
+		return ERR_PTR(err);
 	}
 
+	unlock_new_inode(i);
 	return i;
 }
 
@@ -136,8 +144,10 @@ int squashfs_read_inode(struct inode *i, long long inode)
 		if (frag != SQUASHFS_INVALID_FRAG) {
 			frag_offset = le32_to_cpu(inodep->offset);
 			frag_size = get_fragment_location(s, frag, &frag_blk);
-			if (frag_size == 0)
+			if (frag_size < 0) {
+				err = frag_size;
 				goto failed_read;
+			}
 		} else {
 			frag_blk = SQUASHFS_INVALID_BLK;
 			frag_size = 0;
@@ -175,8 +185,10 @@ int squashfs_read_inode(struct inode *i, long long inode)
 		if (frag != SQUASHFS_INVALID_FRAG) {
 			frag_offset = le32_to_cpu(inodep->offset);
 			frag_size = get_fragment_location(s, frag, &frag_blk);
-			if (frag_size == 0)
+			if (frag_size < 0) {
+				err = frag_size;
 				goto failed_read;
+			}
 		} else {
 			frag_blk = SQUASHFS_INVALID_BLK;
 			frag_size = 0;
@@ -305,15 +317,15 @@ int squashfs_read_inode(struct inode *i, long long inode)
 	}
 	default:
 		ERROR("Unknown inode type %d in squashfs_iget!\n", type);
+		err = -EINVAL;
 		goto failed_read1;
 	}
 
-	return 1;
+	return 0;
 
 failed_read:
-	ERROR("Unable to read inode [%llx:%x]\n", block, offset);
+	ERROR("Unable to read inode 0x%llx\n", inode);
 
 failed_read1:
-	make_bad_inode(i);
-	return 0;
+	return err;
 }
diff --git a/kernel/fs/squashfs/namei.c b/kernel/fs/squashfs/namei.c
index a6b2ae5..5c8dd29 100644
--- a/kernel/fs/squashfs/namei.c
+++ b/kernel/fs/squashfs/namei.c
@@ -130,12 +130,13 @@ static struct dentry *squashfs_lookup(struct inode *i, struct dentry *dentry,
 	int len = dentry->d_name.len;
 	struct inode *inode = NULL;
 	struct squashfs_sb_info *msblk = i->i_sb->s_fs_info;
-	long long next_block = SQUASHFS_I(i)->start_block +
-				msblk->directory_table_start;
-	int next_offset = SQUASHFS_I(i)->offset, length = 0, dir_count, size;
 	struct squashfs_dir_header dirh;
 	struct squashfs_dir_entry *dire;
+	long long next_block = SQUASHFS_I(i)->start_block +
+				msblk->directory_table_start;
+	int next_offset = SQUASHFS_I(i)->offset;
 	unsigned int start_block, offset, ino_number;
+	int err, length = 0, dir_count, size;
 	long long ino;
 
 	TRACE("Entered squashfs_lookup [%llx:%x]\n", next_block, next_offset);
@@ -143,11 +144,14 @@ static struct dentry *squashfs_lookup(struct inode *i, struct dentry *dentry,
 	dire = kmalloc(sizeof(*dire) + SQUASHFS_NAME_LEN + 1, GFP_KERNEL);
 	if (dire == NULL) {
 		ERROR("Failed to allocate squashfs_dir_entry\n");
-		goto exit_lookup;
+		err = -ENOMEM;
+		goto failure;
 	}
 
-	if (len > SQUASHFS_NAME_LEN)
-		goto exit_lookup;
+	if (len > SQUASHFS_NAME_LEN) {
+		err = -ENAMETOOLONG;
+		goto failure;
+	}
 
 	length = get_dir_index_using_name(i->i_sb, &next_block, &next_offset,
 				SQUASHFS_I(i)->dir_index_start,
@@ -160,7 +164,7 @@ static struct dentry *squashfs_lookup(struct inode *i, struct dentry *dentry,
 		 */
 		if (!squashfs_read_metadata(i->i_sb, &dirh, &next_block,
 				&next_offset, sizeof(dirh)))
-			goto failed_read;
+			goto read_failure;
 
 		length += sizeof(dirh);
 
@@ -171,13 +175,13 @@ static struct dentry *squashfs_lookup(struct inode *i, struct dentry *dentry,
 			 */
 			if (!squashfs_read_metadata(i->i_sb, dire, &next_block,
 					&next_offset, sizeof(*dire)))
-				goto failed_read;
+				goto read_failure;
 
 			size = le16_to_cpu(dire->size) + 1;
 
 			if (!squashfs_read_metadata(i->i_sb, dire->name,
 					&next_block, &next_offset, size))
-				goto failed_read;
+				goto read_failure;
 
 			length += sizeof(*dire) + size;
 
@@ -197,6 +201,10 @@ static struct dentry *squashfs_lookup(struct inode *i, struct dentry *dentry,
 
 				inode = squashfs_iget(i->i_sb, ino, ino_number);
 
+				if (IS_ERR(inode)) {
+					err = PTR_ERR(inode);
+					goto failure;
+				}
 				goto exit_lookup;
 			}
 		}
@@ -209,10 +217,12 @@ exit_lookup:
 	d_add(dentry, inode);
 	return ERR_PTR(0);
 
-failed_read:
-	ERROR("Unable to read directory block [%llx:%x]\n", next_block,
-		next_offset);
-	goto exit_lookup;
+read_failure:
+	ERROR("Unable to read directory block [%llx:%x]\n", 
+		SQUASHFS_I(i)->start_block + msblk->directory_table_start,
+		SQUASHFS_I(i)->offset);
+failure:
+	return ERR_PTR(err);
 }
 
 
diff --git a/kernel/fs/squashfs/super.c b/kernel/fs/squashfs/super.c
index e4e58da..a3b862b 100644
--- a/kernel/fs/squashfs/super.c
+++ b/kernel/fs/squashfs/super.c
@@ -47,21 +47,23 @@ static struct super_operations squashfs_super_ops;
 
 static int supported_squashfs_filesystem(short major, short minor, short comp)
 {
+	int err = 0;
+
 	if (major < SQUASHFS_MAJOR) {
 		ERROR("Major/Minor mismatch, older Squashfs %d.%d "
 			"filesystems are unsupported\n", major, minor);
-		return 0;
+		err = -EINVAL;
 	} else if (major > SQUASHFS_MAJOR || minor > SQUASHFS_MINOR) {
 		ERROR("Major/Minor mismatch, trying to mount newer "
 			"%d.%d filesystem\n", major, minor);
 		ERROR("Please update your kernel\n");
-		return 0;
+		err = -EINVAL;
 	}
 
 	if (comp != ZLIB_COMPRESSION)
-		return 0;
+		err = -EINVAL;
 
-	return 1;
+	return err;
 }
 
 
@@ -130,9 +132,9 @@ static int squashfs_fill_super(struct super_block *s, void *data, int silent)
 	}
 
 	/* Check the MAJOR & MINOR versions and compression type */
-	if (!supported_squashfs_filesystem(le16_to_cpu(sblk->s_major),
+	if (supported_squashfs_filesystem(le16_to_cpu(sblk->s_major),
 			le16_to_cpu(sblk->s_minor),
-			le16_to_cpu(sblk->compression)))
+			le16_to_cpu(sblk->compression)) < 0)
 		goto failed_mount;
 
 	/* Check the filesystem does not extend beyond the end of the
@@ -230,8 +232,14 @@ allocate_lookup_table:
 
 allocate_root:
 	root = new_inode(s);
-	if (squashfs_read_inode(root, root_inode) == 0)
+	if (!root)
 		goto failed_mount;
+	
+	res = squashfs_read_inode(root, root_inode);
+	if (res) {
+		iget_failed(root);
+		goto failed_mount;
+	}
 	insert_inode_hash(root);
 
 	s->s_root = d_alloc_root(root);