xfs: global error sign conversion
authorDave Chinner <dchinner@redhat.com>
Wed, 25 Jun 2014 04:58:08 +0000 (14:58 +1000)
committerDave Chinner <david@fromorbit.com>
Wed, 25 Jun 2014 04:58:08 +0000 (14:58 +1000)
Convert all the errors the core XFs code to negative error signs
like the rest of the kernel and remove all the sign conversion we
do in the interface layers.

Errors for conversion (and comparison) found via searches like:

$ git grep " E" fs/xfs
$ git grep "return E" fs/xfs
$ git grep " E[A-Z].*;$" fs/xfs

Negation points found via searches like:

$ git grep "= -[a-z,A-Z]" fs/xfs
$ git grep "return -[a-z,A-D,F-Z]" fs/xfs
$ git grep " -[a-z].*;" fs/xfs

[ with some bits I missed from Brian Foster ]

Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
67 files changed:
fs/xfs/libxfs/xfs_alloc.c
fs/xfs/libxfs/xfs_alloc_btree.c
fs/xfs/libxfs/xfs_attr.c
fs/xfs/libxfs/xfs_attr_leaf.c
fs/xfs/libxfs/xfs_attr_remote.c
fs/xfs/libxfs/xfs_bmap.c
fs/xfs/libxfs/xfs_bmap_btree.c
fs/xfs/libxfs/xfs_btree.c
fs/xfs/libxfs/xfs_da_btree.c
fs/xfs/libxfs/xfs_dir2.c
fs/xfs/libxfs/xfs_dir2_block.c
fs/xfs/libxfs/xfs_dir2_data.c
fs/xfs/libxfs/xfs_dir2_leaf.c
fs/xfs/libxfs/xfs_dir2_node.c
fs/xfs/libxfs/xfs_dir2_sf.c
fs/xfs/libxfs/xfs_dquot_buf.c
fs/xfs/libxfs/xfs_ialloc.c
fs/xfs/libxfs/xfs_ialloc_btree.c
fs/xfs/libxfs/xfs_inode_buf.c
fs/xfs/libxfs/xfs_inode_fork.c
fs/xfs/libxfs/xfs_sb.c
fs/xfs/libxfs/xfs_symlink_remote.c
fs/xfs/xfs_acl.c
fs/xfs/xfs_aops.c
fs/xfs/xfs_attr_inactive.c
fs/xfs/xfs_attr_list.c
fs/xfs/xfs_bmap_util.c
fs/xfs/xfs_buf.c
fs/xfs/xfs_buf.h
fs/xfs/xfs_buf_item.c
fs/xfs/xfs_dir2_readdir.c
fs/xfs/xfs_discard.c
fs/xfs/xfs_dquot.c
fs/xfs/xfs_error.c
fs/xfs/xfs_error.h
fs/xfs/xfs_export.c
fs/xfs/xfs_extfree_item.c
fs/xfs/xfs_file.c
fs/xfs/xfs_filestream.c
fs/xfs/xfs_fsops.c
fs/xfs/xfs_icache.c
fs/xfs/xfs_icache.h
fs/xfs/xfs_inode.c
fs/xfs/xfs_inode_item.c
fs/xfs/xfs_ioctl.c
fs/xfs/xfs_ioctl32.c
fs/xfs/xfs_iomap.c
fs/xfs/xfs_iops.c
fs/xfs/xfs_itable.c
fs/xfs/xfs_log.c
fs/xfs/xfs_log_cil.c
fs/xfs/xfs_log_recover.c
fs/xfs/xfs_mount.c
fs/xfs/xfs_mru_cache.c
fs/xfs/xfs_qm.c
fs/xfs/xfs_qm_bhv.c
fs/xfs/xfs_qm_syscalls.c
fs/xfs/xfs_quotaops.c
fs/xfs/xfs_rtalloc.c
fs/xfs/xfs_rtalloc.h
fs/xfs/xfs_super.c
fs/xfs/xfs_symlink.c
fs/xfs/xfs_trans.c
fs/xfs/xfs_trans_ail.c
fs/xfs/xfs_trans_buf.c
fs/xfs/xfs_trans_dquot.c
fs/xfs/xfs_xattr.c

index d43813267a80dc06e91a0015d07e6277e1bb9624..4bffffe038a1a8ac329b9dc19e5a885878270088 100644 (file)
@@ -483,9 +483,9 @@ xfs_agfl_read_verify(
                return;
 
        if (!xfs_buf_verify_cksum(bp, XFS_AGFL_CRC_OFF))
-               xfs_buf_ioerror(bp, EFSBADCRC);
+               xfs_buf_ioerror(bp, -EFSBADCRC);
        else if (!xfs_agfl_verify(bp))
-               xfs_buf_ioerror(bp, EFSCORRUPTED);
+               xfs_buf_ioerror(bp, -EFSCORRUPTED);
 
        if (bp->b_error)
                xfs_verifier_error(bp);
@@ -503,7 +503,7 @@ xfs_agfl_write_verify(
                return;
 
        if (!xfs_agfl_verify(bp)) {
-               xfs_buf_ioerror(bp, EFSCORRUPTED);
+               xfs_buf_ioerror(bp, -EFSCORRUPTED);
                xfs_verifier_error(bp);
                return;
        }
@@ -559,7 +559,7 @@ xfs_alloc_update_counters(
        xfs_trans_agblocks_delta(tp, len);
        if (unlikely(be32_to_cpu(agf->agf_freeblks) >
                     be32_to_cpu(agf->agf_length)))
-               return EFSCORRUPTED;
+               return -EFSCORRUPTED;
 
        xfs_alloc_log_agf(tp, agbp, XFS_AGF_FREEBLKS);
        return 0;
@@ -2234,11 +2234,11 @@ xfs_agf_read_verify(
 
        if (xfs_sb_version_hascrc(&mp->m_sb) &&
            !xfs_buf_verify_cksum(bp, XFS_AGF_CRC_OFF))
-               xfs_buf_ioerror(bp, EFSBADCRC);
+               xfs_buf_ioerror(bp, -EFSBADCRC);
        else if (XFS_TEST_ERROR(!xfs_agf_verify(mp, bp), mp,
                                XFS_ERRTAG_ALLOC_READ_AGF,
                                XFS_RANDOM_ALLOC_READ_AGF))
-               xfs_buf_ioerror(bp, EFSCORRUPTED);
+               xfs_buf_ioerror(bp, -EFSCORRUPTED);
 
        if (bp->b_error)
                xfs_verifier_error(bp);
@@ -2252,7 +2252,7 @@ xfs_agf_write_verify(
        struct xfs_buf_log_item *bip = bp->b_fspriv;
 
        if (!xfs_agf_verify(mp, bp)) {
-               xfs_buf_ioerror(bp, EFSCORRUPTED);
+               xfs_buf_ioerror(bp, -EFSCORRUPTED);
                xfs_verifier_error(bp);
                return;
        }
@@ -2601,11 +2601,11 @@ xfs_free_extent(
         */
        args.agno = XFS_FSB_TO_AGNO(args.mp, bno);
        if (args.agno >= args.mp->m_sb.sb_agcount)
-               return EFSCORRUPTED;
+               return -EFSCORRUPTED;
 
        args.agbno = XFS_FSB_TO_AGBNO(args.mp, bno);
        if (args.agbno >= args.mp->m_sb.sb_agblocks)
-               return EFSCORRUPTED;
+               return -EFSCORRUPTED;
 
        args.pag = xfs_perag_get(args.mp, args.agno);
        ASSERT(args.pag);
@@ -2617,7 +2617,7 @@ xfs_free_extent(
        /* validate the extent size is legal now we have the agf locked */
        if (args.agbno + len >
                        be32_to_cpu(XFS_BUF_TO_AGF(args.agbp)->agf_length)) {
-               error = EFSCORRUPTED;
+               error = -EFSCORRUPTED;
                goto error0;
        }
 
index 8358f1ded94df6a548ca5c41ca05255b719ddd59..e0e83e24d3efacaa26dd3e9a8354eb54658c48f8 100644 (file)
@@ -355,9 +355,9 @@ xfs_allocbt_read_verify(
        struct xfs_buf  *bp)
 {
        if (!xfs_btree_sblock_verify_crc(bp))
-               xfs_buf_ioerror(bp, EFSBADCRC);
+               xfs_buf_ioerror(bp, -EFSBADCRC);
        else if (!xfs_allocbt_verify(bp))
-               xfs_buf_ioerror(bp, EFSCORRUPTED);
+               xfs_buf_ioerror(bp, -EFSCORRUPTED);
 
        if (bp->b_error) {
                trace_xfs_btree_corrupt(bp, _RET_IP_);
@@ -371,7 +371,7 @@ xfs_allocbt_write_verify(
 {
        if (!xfs_allocbt_verify(bp)) {
                trace_xfs_btree_corrupt(bp, _RET_IP_);
-               xfs_buf_ioerror(bp, EFSCORRUPTED);
+               xfs_buf_ioerror(bp, -EFSCORRUPTED);
                xfs_verifier_error(bp);
                return;
        }
index 7d95b16f09196e6eb228feae77488628848b8123..353fb425faef6362db52eee3f75fa47ff761f111 100644 (file)
@@ -85,7 +85,7 @@ xfs_attr_args_init(
 {
 
        if (!name)
-               return EINVAL;
+               return -EINVAL;
 
        memset(args, 0, sizeof(*args));
        args->geo = dp->i_mount->m_attr_geo;
@@ -95,7 +95,7 @@ xfs_attr_args_init(
        args->name = name;
        args->namelen = strlen((const char *)name);
        if (args->namelen >= MAXNAMELEN)
-               return EFAULT;          /* match IRIX behaviour */
+               return -EFAULT;         /* match IRIX behaviour */
 
        args->hashval = xfs_da_hashname(args->name, args->namelen);
        return 0;
@@ -131,10 +131,10 @@ xfs_attr_get(
        XFS_STATS_INC(xs_attr_get);
 
        if (XFS_FORCED_SHUTDOWN(ip->i_mount))
-               return EIO;
+               return -EIO;
 
        if (!xfs_inode_hasattr(ip))
-               return ENOATTR;
+               return -ENOATTR;
 
        error = xfs_attr_args_init(&args, ip, name, flags);
        if (error)
@@ -145,7 +145,7 @@ xfs_attr_get(
 
        lock_mode = xfs_ilock_attr_map_shared(ip);
        if (!xfs_inode_hasattr(ip))
-               error = ENOATTR;
+               error = -ENOATTR;
        else if (ip->i_d.di_aformat == XFS_DINODE_FMT_LOCAL)
                error = xfs_attr_shortform_getvalue(&args);
        else if (xfs_bmap_one_block(ip, XFS_ATTR_FORK))
@@ -155,7 +155,7 @@ xfs_attr_get(
        xfs_iunlock(ip, lock_mode);
 
        *valuelenp = args.valuelen;
-       return error == EEXIST ? 0 : error;
+       return error == -EEXIST ? 0 : error;
 }
 
 /*
@@ -213,7 +213,7 @@ xfs_attr_set(
        XFS_STATS_INC(xs_attr_set);
 
        if (XFS_FORCED_SHUTDOWN(dp->i_mount))
-               return EIO;
+               return -EIO;
 
        error = xfs_attr_args_init(&args, dp, name, flags);
        if (error)
@@ -304,7 +304,7 @@ xfs_attr_set(
                 * the inode.
                 */
                error = xfs_attr_shortform_addname(&args);
-               if (error != ENOSPC) {
+               if (error != -ENOSPC) {
                        /*
                         * Commit the shortform mods, and we're done.
                         * NOTE: this is also the error path (EEXIST, etc).
@@ -419,10 +419,10 @@ xfs_attr_remove(
        XFS_STATS_INC(xs_attr_remove);
 
        if (XFS_FORCED_SHUTDOWN(dp->i_mount))
-               return EIO;
+               return -EIO;
 
        if (!xfs_inode_hasattr(dp))
-               return ENOATTR;
+               return -ENOATTR;
 
        error = xfs_attr_args_init(&args, dp, name, flags);
        if (error)
@@ -477,7 +477,7 @@ xfs_attr_remove(
        xfs_trans_ijoin(args.trans, dp, 0);
 
        if (!xfs_inode_hasattr(dp)) {
-               error = ENOATTR;
+               error = -ENOATTR;
        } else if (dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL) {
                ASSERT(dp->i_afp->if_flags & XFS_IFINLINE);
                error = xfs_attr_shortform_remove(&args);
@@ -534,9 +534,9 @@ xfs_attr_shortform_addname(xfs_da_args_t *args)
        trace_xfs_attr_sf_addname(args);
 
        retval = xfs_attr_shortform_lookup(args);
-       if ((args->flags & ATTR_REPLACE) && (retval == ENOATTR)) {
+       if ((args->flags & ATTR_REPLACE) && (retval == -ENOATTR)) {
                return retval;
-       } else if (retval == EEXIST) {
+       } else if (retval == -EEXIST) {
                if (args->flags & ATTR_CREATE)
                        return retval;
                retval = xfs_attr_shortform_remove(args);
@@ -545,14 +545,14 @@ xfs_attr_shortform_addname(xfs_da_args_t *args)
 
        if (args->namelen >= XFS_ATTR_SF_ENTSIZE_MAX ||
            args->valuelen >= XFS_ATTR_SF_ENTSIZE_MAX)
-               return ENOSPC;
+               return -ENOSPC;
 
        newsize = XFS_ATTR_SF_TOTSIZE(args->dp);
        newsize += XFS_ATTR_SF_ENTSIZE_BYNAME(args->namelen, args->valuelen);
 
        forkoff = xfs_attr_shortform_bytesfit(args->dp, newsize);
        if (!forkoff)
-               return ENOSPC;
+               return -ENOSPC;
 
        xfs_attr_shortform_add(args, forkoff);
        return 0;
@@ -592,10 +592,10 @@ xfs_attr_leaf_addname(xfs_da_args_t *args)
         * the given flags produce an error or call for an atomic rename.
         */
        retval = xfs_attr3_leaf_lookup_int(bp, args);
-       if ((args->flags & ATTR_REPLACE) && (retval == ENOATTR)) {
+       if ((args->flags & ATTR_REPLACE) && (retval == -ENOATTR)) {
                xfs_trans_brelse(args->trans, bp);
                return retval;
-       } else if (retval == EEXIST) {
+       } else if (retval == -EEXIST) {
                if (args->flags & ATTR_CREATE) {        /* pure create op */
                        xfs_trans_brelse(args->trans, bp);
                        return retval;
@@ -626,7 +626,7 @@ xfs_attr_leaf_addname(xfs_da_args_t *args)
         * if required.
         */
        retval = xfs_attr3_leaf_add(bp, args);
-       if (retval == ENOSPC) {
+       if (retval == -ENOSPC) {
                /*
                 * Promote the attribute list to the Btree format, then
                 * Commit that transaction so that the node_addname() call
@@ -795,7 +795,7 @@ xfs_attr_leaf_removename(xfs_da_args_t *args)
                return error;
 
        error = xfs_attr3_leaf_lookup_int(bp, args);
-       if (error == ENOATTR) {
+       if (error == -ENOATTR) {
                xfs_trans_brelse(args->trans, bp);
                return error;
        }
@@ -850,7 +850,7 @@ xfs_attr_leaf_get(xfs_da_args_t *args)
                return error;
 
        error = xfs_attr3_leaf_lookup_int(bp, args);
-       if (error != EEXIST)  {
+       if (error != -EEXIST)  {
                xfs_trans_brelse(args->trans, bp);
                return error;
        }
@@ -906,9 +906,9 @@ restart:
                goto out;
        blk = &state->path.blk[ state->path.active-1 ];
        ASSERT(blk->magic == XFS_ATTR_LEAF_MAGIC);
-       if ((args->flags & ATTR_REPLACE) && (retval == ENOATTR)) {
+       if ((args->flags & ATTR_REPLACE) && (retval == -ENOATTR)) {
                goto out;
-       } else if (retval == EEXIST) {
+       } else if (retval == -EEXIST) {
                if (args->flags & ATTR_CREATE)
                        goto out;
 
@@ -933,7 +933,7 @@ restart:
        }
 
        retval = xfs_attr3_leaf_add(blk->bp, state->args);
-       if (retval == ENOSPC) {
+       if (retval == -ENOSPC) {
                if (state->path.active == 1) {
                        /*
                         * Its really a single leaf node, but it had
@@ -1168,7 +1168,7 @@ xfs_attr_node_removename(xfs_da_args_t *args)
         * Search to see if name exists, and get back a pointer to it.
         */
        error = xfs_da3_node_lookup_int(state, &retval);
-       if (error || (retval != EEXIST)) {
+       if (error || (retval != -EEXIST)) {
                if (error == 0)
                        error = retval;
                goto out;
@@ -1431,7 +1431,7 @@ xfs_attr_node_get(xfs_da_args_t *args)
        error = xfs_da3_node_lookup_int(state, &retval);
        if (error) {
                retval = error;
-       } else if (retval == EEXIST) {
+       } else if (retval == -EEXIST) {
                blk = &state->path.blk[ state->path.active-1 ];
                ASSERT(blk->bp != NULL);
                ASSERT(blk->magic == XFS_ATTR_LEAF_MAGIC);
index 127d96aba84584590bfcd9b9f3960abf8f284b11..b1f73dbbf3d84faa192a9440e9dc961073afa330 100644 (file)
@@ -214,7 +214,7 @@ xfs_attr3_leaf_write_verify(
        struct xfs_attr3_leaf_hdr *hdr3 = bp->b_addr;
 
        if (!xfs_attr3_leaf_verify(bp)) {
-               xfs_buf_ioerror(bp, EFSCORRUPTED);
+               xfs_buf_ioerror(bp, -EFSCORRUPTED);
                xfs_verifier_error(bp);
                return;
        }
@@ -242,9 +242,9 @@ xfs_attr3_leaf_read_verify(
 
        if (xfs_sb_version_hascrc(&mp->m_sb) &&
             !xfs_buf_verify_cksum(bp, XFS_ATTR3_LEAF_CRC_OFF))
-               xfs_buf_ioerror(bp, EFSBADCRC);
+               xfs_buf_ioerror(bp, -EFSBADCRC);
        else if (!xfs_attr3_leaf_verify(bp))
-               xfs_buf_ioerror(bp, EFSCORRUPTED);
+               xfs_buf_ioerror(bp, -EFSCORRUPTED);
 
        if (bp->b_error)
                xfs_verifier_error(bp);
@@ -547,7 +547,7 @@ xfs_attr_shortform_remove(xfs_da_args_t *args)
                break;
        }
        if (i == end)
-               return ENOATTR;
+               return -ENOATTR;
 
        /*
         * Fix up the attribute fork data, covering the hole
@@ -611,9 +611,9 @@ xfs_attr_shortform_lookup(xfs_da_args_t *args)
                        continue;
                if (!xfs_attr_namesp_match(args->flags, sfe->flags))
                        continue;
-               return EEXIST;
+               return -EEXIST;
        }
-       return ENOATTR;
+       return -ENOATTR;
 }
 
 /*
@@ -640,18 +640,18 @@ xfs_attr_shortform_getvalue(xfs_da_args_t *args)
                        continue;
                if (args->flags & ATTR_KERNOVAL) {
                        args->valuelen = sfe->valuelen;
-                       return EEXIST;
+                       return -EEXIST;
                }
                if (args->valuelen < sfe->valuelen) {
                        args->valuelen = sfe->valuelen;
-                       return ERANGE;
+                       return -ERANGE;
                }
                args->valuelen = sfe->valuelen;
                memcpy(args->value, &sfe->nameval[args->namelen],
                                                    args->valuelen);
-               return EEXIST;
+               return -EEXIST;
        }
-       return ENOATTR;
+       return -ENOATTR;
 }
 
 /*
@@ -691,7 +691,7 @@ xfs_attr_shortform_to_leaf(xfs_da_args_t *args)
                 * If we hit an IO error middle of the transaction inside
                 * grow_inode(), we may have inconsistent data. Bail out.
                 */
-               if (error == EIO)
+               if (error == -EIO)
                        goto out;
                xfs_idata_realloc(dp, size, XFS_ATTR_FORK);     /* try to put */
                memcpy(ifp->if_u1.if_data, tmpbuffer, size);    /* it back */
@@ -730,9 +730,9 @@ xfs_attr_shortform_to_leaf(xfs_da_args_t *args)
                                                sfe->namelen);
                nargs.flags = XFS_ATTR_NSP_ONDISK_TO_ARGS(sfe->flags);
                error = xfs_attr3_leaf_lookup_int(bp, &nargs); /* set a->index */
-               ASSERT(error == ENOATTR);
+               ASSERT(error == -ENOATTR);
                error = xfs_attr3_leaf_add(bp, &nargs);
-               ASSERT(error != ENOSPC);
+               ASSERT(error != -ENOSPC);
                if (error)
                        goto out;
                sfe = XFS_ATTR_SF_NEXTENTRY(sfe);
@@ -809,7 +809,7 @@ xfs_attr3_leaf_to_shortform(
 
        tmpbuffer = kmem_alloc(args->geo->blksize, KM_SLEEP);
        if (!tmpbuffer)
-               return ENOMEM;
+               return -ENOMEM;
 
        memcpy(tmpbuffer, bp->b_addr, args->geo->blksize);
 
@@ -1108,7 +1108,7 @@ xfs_attr3_leaf_add(
         * no good and we should just give up.
         */
        if (!ichdr.holes && sum < entsize)
-               return ENOSPC;
+               return -ENOSPC;
 
        /*
         * Compact the entries to coalesce free space.
@@ -1121,7 +1121,7 @@ xfs_attr3_leaf_add(
         * free region, in freemap[0].  If it is not big enough, give up.
         */
        if (ichdr.freemap[0].size < (entsize + sizeof(xfs_attr_leaf_entry_t))) {
-               tmp = ENOSPC;
+               tmp = -ENOSPC;
                goto out_log_hdr;
        }
 
@@ -2123,7 +2123,7 @@ xfs_attr3_leaf_lookup_int(
        }
        if (probe == ichdr.count || be32_to_cpu(entry->hashval) != hashval) {
                args->index = probe;
-               return ENOATTR;
+               return -ENOATTR;
        }
 
        /*
@@ -2152,7 +2152,7 @@ xfs_attr3_leaf_lookup_int(
                        if (!xfs_attr_namesp_match(args->flags, entry->flags))
                                continue;
                        args->index = probe;
-                       return EEXIST;
+                       return -EEXIST;
                } else {
                        name_rmt = xfs_attr3_leaf_name_remote(leaf, probe);
                        if (name_rmt->namelen != args->namelen)
@@ -2168,11 +2168,11 @@ xfs_attr3_leaf_lookup_int(
                        args->rmtblkcnt = xfs_attr3_rmt_blocks(
                                                        args->dp->i_mount,
                                                        args->rmtvaluelen);
-                       return EEXIST;
+                       return -EEXIST;
                }
        }
        args->index = probe;
-       return ENOATTR;
+       return -ENOATTR;
 }
 
 /*
@@ -2208,7 +2208,7 @@ xfs_attr3_leaf_getvalue(
                }
                if (args->valuelen < valuelen) {
                        args->valuelen = valuelen;
-                       return ERANGE;
+                       return -ERANGE;
                }
                args->valuelen = valuelen;
                memcpy(args->value, &name_loc->nameval[args->namelen], valuelen);
@@ -2226,7 +2226,7 @@ xfs_attr3_leaf_getvalue(
                }
                if (args->valuelen < args->rmtvaluelen) {
                        args->valuelen = args->rmtvaluelen;
-                       return ERANGE;
+                       return -ERANGE;
                }
                args->valuelen = args->rmtvaluelen;
        }
index a8bbc562ff35efac4c115cd198c4a12e9357584d..7510ab8058a4f56624eed83724e0f613e107edb4 100644 (file)
@@ -138,11 +138,11 @@ xfs_attr3_rmt_read_verify(
 
        while (len > 0) {
                if (!xfs_verify_cksum(ptr, blksize, XFS_ATTR3_RMT_CRC_OFF)) {
-                       xfs_buf_ioerror(bp, EFSBADCRC);
+                       xfs_buf_ioerror(bp, -EFSBADCRC);
                        break;
                }
                if (!xfs_attr3_rmt_verify(mp, ptr, blksize, bno)) {
-                       xfs_buf_ioerror(bp, EFSCORRUPTED);
+                       xfs_buf_ioerror(bp, -EFSCORRUPTED);
                        break;
                }
                len -= blksize;
@@ -178,7 +178,7 @@ xfs_attr3_rmt_write_verify(
 
        while (len > 0) {
                if (!xfs_attr3_rmt_verify(mp, ptr, blksize, bno)) {
-                       xfs_buf_ioerror(bp, EFSCORRUPTED);
+                       xfs_buf_ioerror(bp, -EFSCORRUPTED);
                        xfs_verifier_error(bp);
                        return;
                }
@@ -257,7 +257,7 @@ xfs_attr_rmtval_copyout(
                                xfs_alert(mp,
 "remote attribute header mismatch bno/off/len/owner (0x%llx/0x%x/Ox%x/0x%llx)",
                                        bno, *offset, byte_cnt, ino);
-                               return EFSCORRUPTED;
+                               return -EFSCORRUPTED;
                        }
                        hdr_size = sizeof(struct xfs_attr3_rmt_hdr);
                }
@@ -508,7 +508,7 @@ xfs_attr_rmtval_set(
 
                bp = xfs_buf_get(mp->m_ddev_targp, dblkno, dblkcnt, 0);
                if (!bp)
-                       return ENOMEM;
+                       return -ENOMEM;
                bp->b_ops = &xfs_attr3_rmt_buf_ops;
 
                xfs_attr_rmtval_copyin(mp, bp, args->dp->i_ino, &offset,
index b44d63189dabd2c972d1d14cfbdd5ec07f15833b..72a110eb1ddac5520f47261ccbe4f6967d61fccc 100644 (file)
@@ -1033,7 +1033,7 @@ xfs_bmap_add_attrfork_btree(
                        goto error0;
                if (stat == 0) {
                        xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR);
-                       return ENOSPC;
+                       return -ENOSPC;
                }
                *firstblock = cur->bc_private.b.firstblock;
                cur->bc_private.b.allocated = 0;
@@ -1115,7 +1115,7 @@ xfs_bmap_add_attrfork_local(
 
        /* should only be called for types that support local format data */
        ASSERT(0);
-       return EFSCORRUPTED;
+       return -EFSCORRUPTED;
 }
 
 /*
@@ -1192,7 +1192,7 @@ xfs_bmap_add_attrfork(
                break;
        default:
                ASSERT(0);
-               error = EINVAL;
+               error = -EINVAL;
                goto trans_cancel;
        }
 
@@ -1399,7 +1399,7 @@ xfs_bmap_read_extents(
        return 0;
 error0:
        xfs_trans_brelse(tp, bp);
-       return EFSCORRUPTED;
+       return -EFSCORRUPTED;
 }
 
 
@@ -1576,7 +1576,7 @@ xfs_bmap_last_before(
        if (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE &&
            XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS &&
            XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_LOCAL)
-              return EIO;
+              return -EIO;
        if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL) {
                *last_block = 0;
                return 0;
@@ -1690,7 +1690,7 @@ xfs_bmap_last_offset(
 
        if (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE &&
            XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS)
-              return EIO;
+              return -EIO;
 
        error = xfs_bmap_last_extent(NULL, ip, whichfork, &rec, &is_empty);
        if (error || is_empty)
@@ -3323,7 +3323,7 @@ xfs_bmap_extsize_align(
                if (orig_off < align_off ||
                    orig_end > align_off + align_alen ||
                    align_alen - temp < orig_alen)
-                       return EINVAL;
+                       return -EINVAL;
                /*
                 * Try to fix it by moving the start up.
                 */
@@ -3348,7 +3348,7 @@ xfs_bmap_extsize_align(
                 * Result doesn't cover the request, fail it.
                 */
                if (orig_off < align_off || orig_end > align_off + align_alen)
-                       return EINVAL;
+                       return -EINVAL;
        } else {
                ASSERT(orig_off >= align_off);
                ASSERT(orig_end <= align_off + align_alen);
@@ -4051,11 +4051,11 @@ xfs_bmapi_read(
             XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE),
             mp, XFS_ERRTAG_BMAPIFORMAT, XFS_RANDOM_BMAPIFORMAT))) {
                XFS_ERROR_REPORT("xfs_bmapi_read", XFS_ERRLEVEL_LOW, mp);
-               return EFSCORRUPTED;
+               return -EFSCORRUPTED;
        }
 
        if (XFS_FORCED_SHUTDOWN(mp))
-               return EIO;
+               return -EIO;
 
        XFS_STATS_INC(xs_blk_mapr);
 
@@ -4246,11 +4246,11 @@ xfs_bmapi_delay(
             XFS_IFORK_FORMAT(ip, XFS_DATA_FORK) != XFS_DINODE_FMT_BTREE),
             mp, XFS_ERRTAG_BMAPIFORMAT, XFS_RANDOM_BMAPIFORMAT))) {
                XFS_ERROR_REPORT("xfs_bmapi_delay", XFS_ERRLEVEL_LOW, mp);
-               return EFSCORRUPTED;
+               return -EFSCORRUPTED;
        }
 
        if (XFS_FORCED_SHUTDOWN(mp))
-               return EIO;
+               return -EIO;
 
        XFS_STATS_INC(xs_blk_mapw);
 
@@ -4469,7 +4469,7 @@ xfs_bmapi_convert_unwritten(
         * so generate another request.
         */
        if (mval->br_blockcount < len)
-               return EAGAIN;
+               return -EAGAIN;
        return 0;
 }
 
@@ -4540,11 +4540,11 @@ xfs_bmapi_write(
             XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE),
             mp, XFS_ERRTAG_BMAPIFORMAT, XFS_RANDOM_BMAPIFORMAT))) {
                XFS_ERROR_REPORT("xfs_bmapi_write", XFS_ERRLEVEL_LOW, mp);
-               return EFSCORRUPTED;
+               return -EFSCORRUPTED;
        }
 
        if (XFS_FORCED_SHUTDOWN(mp))
-               return EIO;
+               return -EIO;
 
        ifp = XFS_IFORK_PTR(ip, whichfork);
 
@@ -4623,7 +4623,7 @@ xfs_bmapi_write(
 
                /* Execute unwritten extent conversion if necessary */
                error = xfs_bmapi_convert_unwritten(&bma, mval, len, flags);
-               if (error == EAGAIN)
+               if (error == -EAGAIN)
                        continue;
                if (error)
                        goto error0;
@@ -4925,7 +4925,7 @@ xfs_bmap_del_extent(
                                        goto done;
                                cur->bc_rec.b = new;
                                error = xfs_btree_insert(cur, &i);
-                               if (error && error != ENOSPC)
+                               if (error && error != -ENOSPC)
                                        goto done;
                                /*
                                 * If get no-space back from btree insert,
@@ -4933,7 +4933,7 @@ xfs_bmap_del_extent(
                                 * block reservation.
                                 * Fix up our state and return the error.
                                 */
-                               if (error == ENOSPC) {
+                               if (error == -ENOSPC) {
                                        /*
                                         * Reset the cursor, don't trust
                                         * it after any insert operation.
@@ -4961,7 +4961,7 @@ xfs_bmap_del_extent(
                                        xfs_bmbt_set_blockcount(ep,
                                                got.br_blockcount);
                                        flags = 0;
-                                       error = ENOSPC;
+                                       error = -ENOSPC;
                                        goto done;
                                }
                                XFS_WANT_CORRUPTED_GOTO(i == 1, done);
@@ -5079,11 +5079,11 @@ xfs_bunmapi(
            XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE)) {
                XFS_ERROR_REPORT("xfs_bunmapi", XFS_ERRLEVEL_LOW,
                                 ip->i_mount);
-               return EFSCORRUPTED;
+               return -EFSCORRUPTED;
        }
        mp = ip->i_mount;
        if (XFS_FORCED_SHUTDOWN(mp))
-               return EIO;
+               return -EIO;
 
        ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
        ASSERT(len > 0);
@@ -5328,7 +5328,7 @@ xfs_bunmapi(
                    del.br_startoff > got.br_startoff &&
                    del.br_startoff + del.br_blockcount <
                    got.br_startoff + got.br_blockcount) {
-                       error = ENOSPC;
+                       error = -ENOSPC;
                        goto error0;
                }
                error = xfs_bmap_del_extent(ip, tp, &lastx, flist, cur, &del,
@@ -5452,11 +5452,11 @@ xfs_bmap_shift_extents(
             mp, XFS_ERRTAG_BMAPIFORMAT, XFS_RANDOM_BMAPIFORMAT))) {
                XFS_ERROR_REPORT("xfs_bmap_shift_extents",
                                 XFS_ERRLEVEL_LOW, mp);
-               return EFSCORRUPTED;
+               return -EFSCORRUPTED;
        }
 
        if (XFS_FORCED_SHUTDOWN(mp))
-               return EIO;
+               return -EIO;
 
        ASSERT(current_ext != NULL);
 
@@ -5519,14 +5519,14 @@ xfs_bmap_shift_extents(
                                                *current_ext - 1), &left);
 
                        if (startoff < left.br_startoff + left.br_blockcount)
-                               error = EINVAL;
+                               error = -EINVAL;
                } else if (offset_shift_fsb > got.br_startoff) {
                        /*
                         * When first extent is shifted, offset_shift_fsb
                         * should be less than the stating offset of
                         * the first extent.
                         */
-                       error = EINVAL;
+                       error = -EINVAL;
                }
 
                if (error)
index de65bb8bab04f433809622926ace5f7e9a313a88..a388de4ceaa1ffddf8d632e89be1bf55950459b5 100644 (file)
@@ -554,7 +554,7 @@ xfs_bmbt_alloc_block(
        args.minlen = args.maxlen = args.prod = 1;
        args.wasdel = cur->bc_private.b.flags & XFS_BTCUR_BPRV_WASDEL;
        if (!args.wasdel && xfs_trans_get_block_res(args.tp) == 0) {
-               error = ENOSPC;
+               error = -ENOSPC;
                goto error0;
        }
        error = xfs_alloc_vextent(&args);
@@ -779,9 +779,9 @@ xfs_bmbt_read_verify(
        struct xfs_buf  *bp)
 {
        if (!xfs_btree_lblock_verify_crc(bp))
-               xfs_buf_ioerror(bp, EFSBADCRC);
+               xfs_buf_ioerror(bp, -EFSBADCRC);
        else if (!xfs_bmbt_verify(bp))
-               xfs_buf_ioerror(bp, EFSCORRUPTED);
+               xfs_buf_ioerror(bp, -EFSCORRUPTED);
 
        if (bp->b_error) {
                trace_xfs_btree_corrupt(bp, _RET_IP_);
@@ -795,7 +795,7 @@ xfs_bmbt_write_verify(
 {
        if (!xfs_bmbt_verify(bp)) {
                trace_xfs_btree_corrupt(bp, _RET_IP_);
-               xfs_buf_ioerror(bp, EFSCORRUPTED);
+               xfs_buf_ioerror(bp, -EFSCORRUPTED);
                xfs_verifier_error(bp);
                return;
        }
@@ -959,7 +959,7 @@ xfs_bmbt_change_owner(
 
        cur = xfs_bmbt_init_cursor(ip->i_mount, tp, ip, whichfork);
        if (!cur)
-               return ENOMEM;
+               return -ENOMEM;
 
        error = xfs_btree_change_owner(cur, new_owner, buffer_list);
        xfs_btree_del_cursor(cur, error ? XFS_BTREE_ERROR : XFS_BTREE_NOERROR);
index 036b4fd34bf7f1910d07e0b618876100fd1a2bff..0097c42f1f1042abcc2f309389dbde748797eb65 100644 (file)
@@ -91,7 +91,7 @@ xfs_btree_check_lblock(
                if (bp)
                        trace_xfs_btree_corrupt(bp, _RET_IP_);
                XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, mp);
-               return EFSCORRUPTED;
+               return -EFSCORRUPTED;
        }
        return 0;
 }
@@ -139,7 +139,7 @@ xfs_btree_check_sblock(
                if (bp)
                        trace_xfs_btree_corrupt(bp, _RET_IP_);
                XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, mp);
-               return EFSCORRUPTED;
+               return -EFSCORRUPTED;
        }
        return 0;
 }
@@ -1139,7 +1139,7 @@ xfs_btree_get_buf_block(
                                 mp->m_bsize, flags);
 
        if (!*bpp)
-               return ENOMEM;
+               return -ENOMEM;
 
        (*bpp)->b_ops = cur->bc_ops->buf_ops;
        *block = XFS_BUF_TO_BLOCK(*bpp);
@@ -1497,7 +1497,7 @@ xfs_btree_increment(
                if (cur->bc_flags & XFS_BTREE_ROOT_IN_INODE)
                        goto out0;
                ASSERT(0);
-               error = EFSCORRUPTED;
+               error = -EFSCORRUPTED;
                goto error0;
        }
        ASSERT(lev < cur->bc_nlevels);
@@ -1596,7 +1596,7 @@ xfs_btree_decrement(
                if (cur->bc_flags & XFS_BTREE_ROOT_IN_INODE)
                        goto out0;
                ASSERT(0);
-               error = EFSCORRUPTED;
+               error = -EFSCORRUPTED;
                goto error0;
        }
        ASSERT(lev < cur->bc_nlevels);
@@ -3938,7 +3938,7 @@ xfs_btree_block_change_owner(
        /* now read rh sibling block for next iteration */
        xfs_btree_get_sibling(cur, block, &rptr, XFS_BB_RIGHTSIB);
        if (xfs_btree_ptr_is_null(cur, &rptr))
-               return ENOENT;
+               return -ENOENT;
 
        return xfs_btree_lookup_get_block(cur, level, &rptr, &block);
 }
@@ -3981,7 +3981,7 @@ xfs_btree_change_owner(
                                                             buffer_list);
                } while (!error);
 
-               if (error != ENOENT)
+               if (error != -ENOENT)
                        return error;
        }
 
index a1a4e3e47a1e77338082b49531d648b94d27c831..8d809873525bbfda5d6eda12256d57b641837ae2 100644 (file)
@@ -185,7 +185,7 @@ xfs_da3_node_write_verify(
        struct xfs_da3_node_hdr *hdr3 = bp->b_addr;
 
        if (!xfs_da3_node_verify(bp)) {
-               xfs_buf_ioerror(bp, EFSCORRUPTED);
+               xfs_buf_ioerror(bp, -EFSCORRUPTED);
                xfs_verifier_error(bp);
                return;
        }
@@ -214,13 +214,13 @@ xfs_da3_node_read_verify(
        switch (be16_to_cpu(info->magic)) {
                case XFS_DA3_NODE_MAGIC:
                        if (!xfs_buf_verify_cksum(bp, XFS_DA3_NODE_CRC_OFF)) {
-                               xfs_buf_ioerror(bp, EFSBADCRC);
+                               xfs_buf_ioerror(bp, -EFSBADCRC);
                                break;
                        }
                        /* fall through */
                case XFS_DA_NODE_MAGIC:
                        if (!xfs_da3_node_verify(bp)) {
-                               xfs_buf_ioerror(bp, EFSCORRUPTED);
+                               xfs_buf_ioerror(bp, -EFSCORRUPTED);
                                break;
                        }
                        return;
@@ -385,7 +385,7 @@ xfs_da3_split(
                switch (oldblk->magic) {
                case XFS_ATTR_LEAF_MAGIC:
                        error = xfs_attr3_leaf_split(state, oldblk, newblk);
-                       if ((error != 0) && (error != ENOSPC)) {
+                       if ((error != 0) && (error != -ENOSPC)) {
                                return error;   /* GROT: attr is inconsistent */
                        }
                        if (!error) {
@@ -1579,9 +1579,9 @@ xfs_da3_node_lookup_int(
                        args->blkno = blk->blkno;
                } else {
                        ASSERT(0);
-                       return EFSCORRUPTED;
+                       return -EFSCORRUPTED;
                }
-               if (((retval == ENOENT) || (retval == ENOATTR)) &&
+               if (((retval == -ENOENT) || (retval == -ENOATTR)) &&
                    (blk->hashval == args->hashval)) {
                        error = xfs_da3_path_shift(state, &state->path, 1, 1,
                                                         &retval);
@@ -1591,7 +1591,7 @@ xfs_da3_node_lookup_int(
                                continue;
                        } else if (blk->magic == XFS_ATTR_LEAF_MAGIC) {
                                /* path_shift() gives ENOENT */
-                               retval = ENOATTR;
+                               retval = -ENOATTR;
                        }
                }
                break;
@@ -1859,7 +1859,7 @@ xfs_da3_path_shift(
                }
        }
        if (level < 0) {
-               *result = ENOENT;       /* we're out of our tree */
+               *result = -ENOENT;      /* we're out of our tree */
                ASSERT(args->op_flags & XFS_DA_OP_OKNOENT);
                return 0;
        }
@@ -2068,7 +2068,7 @@ xfs_da_grow_inode_int(
        if (got != count || mapp[0].br_startoff != *bno ||
            mapp[mapi - 1].br_startoff + mapp[mapi - 1].br_blockcount !=
            *bno + count) {
-               error = ENOSPC;
+               error = -ENOSPC;
                goto out_free_map;
        }
 
@@ -2158,7 +2158,7 @@ xfs_da3_swap_lastblock(
        if (unlikely(lastoff == 0)) {
                XFS_ERROR_REPORT("xfs_da_swap_lastblock(1)", XFS_ERRLEVEL_LOW,
                                 mp);
-               return EFSCORRUPTED;
+               return -EFSCORRUPTED;
        }
        /*
         * Read the last block in the btree space.
@@ -2209,7 +2209,7 @@ xfs_da3_swap_lastblock(
                    sib_info->magic != dead_info->magic)) {
                        XFS_ERROR_REPORT("xfs_da_swap_lastblock(2)",
                                         XFS_ERRLEVEL_LOW, mp);
-                       error = EFSCORRUPTED;
+                       error = -EFSCORRUPTED;
                        goto done;
                }
                sib_info->forw = cpu_to_be32(dead_blkno);
@@ -2231,7 +2231,7 @@ xfs_da3_swap_lastblock(
                       sib_info->magic != dead_info->magic)) {
                        XFS_ERROR_REPORT("xfs_da_swap_lastblock(3)",
                                         XFS_ERRLEVEL_LOW, mp);
-                       error = EFSCORRUPTED;
+                       error = -EFSCORRUPTED;
                        goto done;
                }
                sib_info->back = cpu_to_be32(dead_blkno);
@@ -2254,7 +2254,7 @@ xfs_da3_swap_lastblock(
                if (level >= 0 && level != par_hdr.level + 1) {
                        XFS_ERROR_REPORT("xfs_da_swap_lastblock(4)",
                                         XFS_ERRLEVEL_LOW, mp);
-                       error = EFSCORRUPTED;
+                       error = -EFSCORRUPTED;
                        goto done;
                }
                level = par_hdr.level;
@@ -2267,7 +2267,7 @@ xfs_da3_swap_lastblock(
                if (entno == par_hdr.count) {
                        XFS_ERROR_REPORT("xfs_da_swap_lastblock(5)",
                                         XFS_ERRLEVEL_LOW, mp);
-                       error = EFSCORRUPTED;
+                       error = -EFSCORRUPTED;
                        goto done;
                }
                par_blkno = be32_to_cpu(btree[entno].before);
@@ -2294,7 +2294,7 @@ xfs_da3_swap_lastblock(
                if (unlikely(par_blkno == 0)) {
                        XFS_ERROR_REPORT("xfs_da_swap_lastblock(6)",
                                         XFS_ERRLEVEL_LOW, mp);
-                       error = EFSCORRUPTED;
+                       error = -EFSCORRUPTED;
                        goto done;
                }
                error = xfs_da3_node_read(tp, dp, par_blkno, -1, &par_buf, w);
@@ -2305,7 +2305,7 @@ xfs_da3_swap_lastblock(
                if (par_hdr.level != level) {
                        XFS_ERROR_REPORT("xfs_da_swap_lastblock(7)",
                                         XFS_ERRLEVEL_LOW, mp);
-                       error = EFSCORRUPTED;
+                       error = -EFSCORRUPTED;
                        goto done;
                }
                btree = dp->d_ops->node_tree_p(par_node);
@@ -2359,7 +2359,7 @@ xfs_da_shrink_inode(
                error = xfs_bunmapi(tp, dp, dead_blkno, count,
                                    xfs_bmapi_aflag(w)|XFS_BMAPI_METADATA,
                                    0, args->firstblock, args->flist, &done);
-               if (error == ENOSPC) {
+               if (error == -ENOSPC) {
                        if (w != XFS_DATA_FORK)
                                break;
                        error = xfs_da3_swap_lastblock(args, &dead_blkno,
@@ -2427,7 +2427,7 @@ xfs_buf_map_from_irec(
                map = kmem_zalloc(nirecs * sizeof(struct xfs_buf_map),
                                  KM_SLEEP | KM_NOFS);
                if (!map)
-                       return ENOMEM;
+                       return -ENOMEM;
                *mapp = map;
        }
 
@@ -2500,8 +2500,8 @@ xfs_dabuf_map(
        }
 
        if (!xfs_da_map_covers_blocks(nirecs, irecs, bno, nfsb)) {
-               error = mappedbno == -2 ? -1 : EFSCORRUPTED;
-               if (unlikely(error == EFSCORRUPTED)) {
+               error = mappedbno == -2 ? -1 : -EFSCORRUPTED;
+               if (unlikely(error == -EFSCORRUPTED)) {
                        if (xfs_error_level >= XFS_ERRLEVEL_LOW) {
                                int i;
                                xfs_alert(mp, "%s: bno %lld dir: inode %lld",
@@ -2561,7 +2561,7 @@ xfs_da_get_buf(
 
        bp = xfs_trans_get_buf_map(trans, dp->i_mount->m_ddev_targp,
                                    mapp, nmap, 0);
-       error = bp ? bp->b_error : EIO;
+       error = bp ? bp->b_error : -EIO;
        if (error) {
                xfs_trans_brelse(trans, bp);
                goto out_free;
index a0aca734199bfbf35c3db1c405a57a92dbb8058f..6cef22152fd6440d46581bc141b4267b34119aea 100644 (file)
@@ -108,7 +108,7 @@ xfs_da_mount(
        if (!mp->m_dir_geo || !mp->m_attr_geo) {
                kmem_free(mp->m_dir_geo);
                kmem_free(mp->m_attr_geo);
-               return ENOMEM;
+               return -ENOMEM;
        }
 
        /* set up directory geometry */
@@ -202,7 +202,7 @@ xfs_dir_ino_validate(
                xfs_warn(mp, "Invalid inode number 0x%Lx",
                                (unsigned long long) ino);
                XFS_ERROR_REPORT("xfs_dir_ino_validate", XFS_ERRLEVEL_LOW, mp);
-               return EFSCORRUPTED;
+               return -EFSCORRUPTED;
        }
        return 0;
 }
@@ -226,7 +226,7 @@ xfs_dir_init(
 
        args = kmem_zalloc(sizeof(*args), KM_SLEEP | KM_NOFS);
        if (!args)
-               return ENOMEM;
+               return -ENOMEM;
 
        args->geo = dp->i_mount->m_dir_geo;
        args->dp = dp;
@@ -261,7 +261,7 @@ xfs_dir_createname(
 
        args = kmem_zalloc(sizeof(*args), KM_SLEEP | KM_NOFS);
        if (!args)
-               return ENOMEM;
+               return -ENOMEM;
 
        args->geo = dp->i_mount->m_dir_geo;
        args->name = name->name;
@@ -314,18 +314,18 @@ xfs_dir_cilookup_result(
        int             len)
 {
        if (args->cmpresult == XFS_CMP_DIFFERENT)
-               return ENOENT;
+               return -ENOENT;
        if (args->cmpresult != XFS_CMP_CASE ||
                                        !(args->op_flags & XFS_DA_OP_CILOOKUP))
-               return EEXIST;
+               return -EEXIST;
 
        args->value = kmem_alloc(len, KM_NOFS | KM_MAYFAIL);
        if (!args->value)
-               return ENOMEM;
+               return -ENOMEM;
 
        memcpy(args->value, name, len);
        args->valuelen = len;
-       return EEXIST;
+       return -EEXIST;
 }
 
 /*
@@ -392,7 +392,7 @@ xfs_dir_lookup(
                rval = xfs_dir2_node_lookup(args);
 
 out_check_rval:
-       if (rval == EEXIST)
+       if (rval == -EEXIST)
                rval = 0;
        if (!rval) {
                *inum = args->inumber;
@@ -428,7 +428,7 @@ xfs_dir_removename(
 
        args = kmem_zalloc(sizeof(*args), KM_SLEEP | KM_NOFS);
        if (!args)
-               return ENOMEM;
+               return -ENOMEM;
 
        args->geo = dp->i_mount->m_dir_geo;
        args->name = name->name;
@@ -493,7 +493,7 @@ xfs_dir_replace(
 
        args = kmem_zalloc(sizeof(*args), KM_SLEEP | KM_NOFS);
        if (!args)
-               return ENOMEM;
+               return -ENOMEM;
 
        args->geo = dp->i_mount->m_dir_geo;
        args->name = name->name;
@@ -555,7 +555,7 @@ xfs_dir_canenter(
 
        args = kmem_zalloc(sizeof(*args), KM_SLEEP | KM_NOFS);
        if (!args)
-               return ENOMEM;
+               return -ENOMEM;
 
        args->geo = dp->i_mount->m_dir_geo;
        args->name = name->name;
index ab0bffccf5c3c8febd8255834a0daf01eefeca83..9628ceccfa02f195b83f8989a7064f0411bc0ab3 100644 (file)
@@ -91,9 +91,9 @@ xfs_dir3_block_read_verify(
 
        if (xfs_sb_version_hascrc(&mp->m_sb) &&
             !xfs_buf_verify_cksum(bp, XFS_DIR3_DATA_CRC_OFF))
-               xfs_buf_ioerror(bp, EFSBADCRC);
+               xfs_buf_ioerror(bp, -EFSBADCRC);
        else if (!xfs_dir3_block_verify(bp))
-               xfs_buf_ioerror(bp, EFSCORRUPTED);
+               xfs_buf_ioerror(bp, -EFSCORRUPTED);
 
        if (bp->b_error)
                xfs_verifier_error(bp);
@@ -108,7 +108,7 @@ xfs_dir3_block_write_verify(
        struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr;
 
        if (!xfs_dir3_block_verify(bp)) {
-               xfs_buf_ioerror(bp, EFSCORRUPTED);
+               xfs_buf_ioerror(bp, -EFSCORRUPTED);
                xfs_verifier_error(bp);
                return;
        }
@@ -392,7 +392,7 @@ xfs_dir2_block_addname(
        if (args->op_flags & XFS_DA_OP_JUSTCHECK) {
                xfs_trans_brelse(tp, bp);
                if (!dup)
-                       return ENOSPC;
+                       return -ENOSPC;
                return 0;
        }
 
@@ -402,7 +402,7 @@ xfs_dir2_block_addname(
        if (!dup) {
                /* Don't have a space reservation: return no-space.  */
                if (args->total == 0)
-                       return ENOSPC;
+                       return -ENOSPC;
                /*
                 * Convert to the next larger format.
                 * Then add the new entry in that format.
@@ -703,7 +703,7 @@ xfs_dir2_block_lookup_int(
                if (low > high) {
                        ASSERT(args->op_flags & XFS_DA_OP_OKNOENT);
                        xfs_trans_brelse(tp, bp);
-                       return ENOENT;
+                       return -ENOENT;
                }
        }
        /*
@@ -751,7 +751,7 @@ xfs_dir2_block_lookup_int(
         * No match, release the buffer and return ENOENT.
         */
        xfs_trans_brelse(tp, bp);
-       return ENOENT;
+       return -ENOENT;
 }
 
 /*
@@ -1091,7 +1091,7 @@ xfs_dir2_sf_to_block(
         */
        if (dp->i_d.di_size < offsetof(xfs_dir2_sf_hdr_t, parent)) {
                ASSERT(XFS_FORCED_SHUTDOWN(mp));
-               return EIO;
+               return -EIO;
        }
 
        oldsfp = (xfs_dir2_sf_hdr_t *)ifp->if_u1.if_data;
index 8c2f6422648ea76788a32b0a3accf755db14f000..fdd803fecb8e266a009835cbd563ef5d04dbee6e 100644 (file)
@@ -100,7 +100,7 @@ __xfs_dir3_data_check(
                break;
        default:
                XFS_ERROR_REPORT("Bad Magic", XFS_ERRLEVEL_LOW, mp);
-               return EFSCORRUPTED;
+               return -EFSCORRUPTED;
        }
 
        /*
@@ -256,7 +256,7 @@ xfs_dir3_data_reada_verify(
                xfs_dir3_data_verify(bp);
                return;
        default:
-               xfs_buf_ioerror(bp, EFSCORRUPTED);
+               xfs_buf_ioerror(bp, -EFSCORRUPTED);
                xfs_verifier_error(bp);
                break;
        }
@@ -270,9 +270,9 @@ xfs_dir3_data_read_verify(
 
        if (xfs_sb_version_hascrc(&mp->m_sb) &&
             !xfs_buf_verify_cksum(bp, XFS_DIR3_DATA_CRC_OFF))
-                xfs_buf_ioerror(bp, EFSBADCRC);
+                xfs_buf_ioerror(bp, -EFSBADCRC);
        else if (!xfs_dir3_data_verify(bp))
-               xfs_buf_ioerror(bp, EFSCORRUPTED);
+               xfs_buf_ioerror(bp, -EFSCORRUPTED);
 
        if (bp->b_error)
                xfs_verifier_error(bp);
@@ -287,7 +287,7 @@ xfs_dir3_data_write_verify(
        struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr;
 
        if (!xfs_dir3_data_verify(bp)) {
-               xfs_buf_ioerror(bp, EFSCORRUPTED);
+               xfs_buf_ioerror(bp, -EFSCORRUPTED);
                xfs_verifier_error(bp);
                return;
        }
index 78b411bfc543fb1ed0ecf8efcaeaecc2831a7f4e..a19174eb3cb21cfece4ebe8bbe7acb1eac6d7c80 100644 (file)
@@ -183,9 +183,9 @@ __read_verify(
 
        if (xfs_sb_version_hascrc(&mp->m_sb) &&
             !xfs_buf_verify_cksum(bp, XFS_DIR3_LEAF_CRC_OFF))
-               xfs_buf_ioerror(bp, EFSBADCRC);
+               xfs_buf_ioerror(bp, -EFSBADCRC);
        else if (!xfs_dir3_leaf_verify(bp, magic))
-               xfs_buf_ioerror(bp, EFSCORRUPTED);
+               xfs_buf_ioerror(bp, -EFSCORRUPTED);
 
        if (bp->b_error)
                xfs_verifier_error(bp);
@@ -201,7 +201,7 @@ __write_verify(
        struct xfs_dir3_leaf_hdr *hdr3 = bp->b_addr;
 
        if (!xfs_dir3_leaf_verify(bp, magic)) {
-               xfs_buf_ioerror(bp, EFSCORRUPTED);
+               xfs_buf_ioerror(bp, -EFSCORRUPTED);
                xfs_verifier_error(bp);
                return;
        }
@@ -731,7 +731,7 @@ xfs_dir2_leaf_addname(
                if ((args->op_flags & XFS_DA_OP_JUSTCHECK) ||
                                                        args->total == 0) {
                        xfs_trans_brelse(tp, lbp);
-                       return ENOSPC;
+                       return -ENOSPC;
                }
                /*
                 * Convert to node form.
@@ -755,7 +755,7 @@ xfs_dir2_leaf_addname(
         */
        if (args->op_flags & XFS_DA_OP_JUSTCHECK) {
                xfs_trans_brelse(tp, lbp);
-               return use_block == -1 ? ENOSPC : 0;
+               return use_block == -1 ? -ENOSPC : 0;
        }
        /*
         * If no allocations are allowed, return now before we've
@@ -763,7 +763,7 @@ xfs_dir2_leaf_addname(
         */
        if (args->total == 0 && use_block == -1) {
                xfs_trans_brelse(tp, lbp);
-               return ENOSPC;
+               return -ENOSPC;
        }
        /*
         * Need to compact the leaf entries, removing stale ones.
@@ -1327,13 +1327,13 @@ xfs_dir2_leaf_lookup_int(
                return 0;
        }
        /*
-        * No match found, return ENOENT.
+        * No match found, return -ENOENT.
         */
        ASSERT(cidb == -1);
        if (dbp)
                xfs_trans_brelse(tp, dbp);
        xfs_trans_brelse(tp, lbp);
-       return ENOENT;
+       return -ENOENT;
 }
 
 /*
@@ -1440,7 +1440,7 @@ xfs_dir2_leaf_removename(
                         * Just go on, returning success, leaving the
                         * empty block in place.
                         */
-                       if (error == ENOSPC && args->total == 0)
+                       if (error == -ENOSPC && args->total == 0)
                                error = 0;
                        xfs_dir3_leaf_check(dp, lbp);
                        return error;
@@ -1641,7 +1641,7 @@ xfs_dir2_leaf_trim_data(
         * Get rid of the data block.
         */
        if ((error = xfs_dir2_shrink_inode(args, db, dbp))) {
-               ASSERT(error != ENOSPC);
+               ASSERT(error != -ENOSPC);
                xfs_trans_brelse(tp, dbp);
                return error;
        }
@@ -1815,7 +1815,7 @@ xfs_dir2_node_to_leaf(
                 * punching out the middle of an extent, and this is an
                 * isolated block.
                 */
-               ASSERT(error != ENOSPC);
+               ASSERT(error != -ENOSPC);
                return error;
        }
        fbp = NULL;
index 4cf8b99d09a47efa3c5f477bd734bca1f6b264dc..2ae6ac2c11aefb696b785ff3972526c15956ccec 100644 (file)
@@ -117,9 +117,9 @@ xfs_dir3_free_read_verify(
 
        if (xfs_sb_version_hascrc(&mp->m_sb) &&
            !xfs_buf_verify_cksum(bp, XFS_DIR3_FREE_CRC_OFF))
-               xfs_buf_ioerror(bp, EFSBADCRC);
+               xfs_buf_ioerror(bp, -EFSBADCRC);
        else if (!xfs_dir3_free_verify(bp))
-               xfs_buf_ioerror(bp, EFSCORRUPTED);
+               xfs_buf_ioerror(bp, -EFSCORRUPTED);
 
        if (bp->b_error)
                xfs_verifier_error(bp);
@@ -134,7 +134,7 @@ xfs_dir3_free_write_verify(
        struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr;
 
        if (!xfs_dir3_free_verify(bp)) {
-               xfs_buf_ioerror(bp, EFSCORRUPTED);
+               xfs_buf_ioerror(bp, -EFSCORRUPTED);
                xfs_verifier_error(bp);
                return;
        }
@@ -406,7 +406,7 @@ xfs_dir2_leafn_add(
         * into other peoples memory
         */
        if (index < 0)
-               return EFSCORRUPTED;
+               return -EFSCORRUPTED;
 
        /*
         * If there are already the maximum number of leaf entries in
@@ -417,7 +417,7 @@ xfs_dir2_leafn_add(
 
        if (leafhdr.count == dp->d_ops->leaf_max_ents(args->geo)) {
                if (!leafhdr.stale)
-                       return ENOSPC;
+                       return -ENOSPC;
                compact = leafhdr.stale > 1;
        } else
                compact = 0;
@@ -629,7 +629,7 @@ xfs_dir2_leafn_lookup_for_addname(
                                                        XFS_ERRLEVEL_LOW, mp);
                                if (curfdb != newfdb)
                                        xfs_trans_brelse(tp, curbp);
-                               return EFSCORRUPTED;
+                               return -EFSCORRUPTED;
                        }
                        curfdb = newfdb;
                        if (be16_to_cpu(bests[fi]) >= length)
@@ -660,7 +660,7 @@ out:
         * Return the index, that will be the insertion point.
         */
        *indexp = index;
-       return ENOENT;
+       return -ENOENT;
 }
 
 /*
@@ -789,7 +789,7 @@ xfs_dir2_leafn_lookup_for_entry(
                        curbp->b_ops = &xfs_dir3_data_buf_ops;
                        xfs_trans_buf_set_type(tp, curbp, XFS_BLFT_DIR_DATA_BUF);
                        if (cmp == XFS_CMP_EXACT)
-                               return EEXIST;
+                               return -EEXIST;
                }
        }
        ASSERT(index == leafhdr.count || (args->op_flags & XFS_DA_OP_OKNOENT));
@@ -812,7 +812,7 @@ xfs_dir2_leafn_lookup_for_entry(
                state->extravalid = 0;
        }
        *indexp = index;
-       return ENOENT;
+       return -ENOENT;
 }
 
 /*
@@ -1133,7 +1133,7 @@ xfs_dir3_data_block_free(
                if (error == 0) {
                        fbp = NULL;
                        logfree = 0;
-               } else if (error != ENOSPC || args->total != 0)
+               } else if (error != -ENOSPC || args->total != 0)
                        return error;
                /*
                 * It's possible to get ENOSPC if there is no
@@ -1287,7 +1287,7 @@ xfs_dir2_leafn_remove(
                         * In this case just drop the buffer and some one else
                         * will eventually get rid of the empty block.
                         */
-                       else if (!(error == ENOSPC && args->total == 0))
+                       else if (!(error == -ENOSPC && args->total == 0))
                                return error;
                }
                /*
@@ -1599,7 +1599,7 @@ xfs_dir2_node_addname(
        error = xfs_da3_node_lookup_int(state, &rval);
        if (error)
                rval = error;
-       if (rval != ENOENT) {
+       if (rval != -ENOENT) {
                goto done;
        }
        /*
@@ -1628,7 +1628,7 @@ xfs_dir2_node_addname(
                 * It didn't work, we need to split the leaf block.
                 */
                if (args->total == 0) {
-                       ASSERT(rval == ENOSPC);
+                       ASSERT(rval == -ENOSPC);
                        goto done;
                }
                /*
@@ -1815,7 +1815,7 @@ xfs_dir2_node_addname_int(
                 * Not allowed to allocate, return failure.
                 */
                if ((args->op_flags & XFS_DA_OP_JUSTCHECK) || args->total == 0)
-                       return ENOSPC;
+                       return -ENOSPC;
 
                /*
                 * Allocate and initialize the new data block.
@@ -1876,7 +1876,7 @@ xfs_dir2_node_addname_int(
                                }
                                XFS_ERROR_REPORT("xfs_dir2_node_addname_int",
                                                 XFS_ERRLEVEL_LOW, mp);
-                               return EFSCORRUPTED;
+                               return -EFSCORRUPTED;
                        }
 
                        /*
@@ -2042,8 +2042,8 @@ xfs_dir2_node_lookup(
        error = xfs_da3_node_lookup_int(state, &rval);
        if (error)
                rval = error;
-       else if (rval == ENOENT && args->cmpresult == XFS_CMP_CASE) {
-               /* If a CI match, dup the actual name and return EEXIST */
+       else if (rval == -ENOENT && args->cmpresult == XFS_CMP_CASE) {
+               /* If a CI match, dup the actual name and return -EEXIST */
                xfs_dir2_data_entry_t   *dep;
 
                dep = (xfs_dir2_data_entry_t *)
@@ -2096,7 +2096,7 @@ xfs_dir2_node_removename(
                goto out_free;
 
        /* Didn't find it, upper layer screwed up. */
-       if (rval != EEXIST) {
+       if (rval != -EEXIST) {
                error = rval;
                goto out_free;
        }
@@ -2169,7 +2169,7 @@ xfs_dir2_node_replace(
         * It should be found, since the vnodeops layer has looked it up
         * and locked it.  But paranoia is good.
         */
-       if (rval == EEXIST) {
+       if (rval == -EEXIST) {
                struct xfs_dir2_leaf_entry *ents;
                /*
                 * Find the leaf entry.
@@ -2272,7 +2272,7 @@ xfs_dir2_node_trim_free(
                 * space reservation, when breaking up an extent into two
                 * pieces.  This is the last block of an extent.
                 */
-               ASSERT(error != ENOSPC);
+               ASSERT(error != -ENOSPC);
                xfs_trans_brelse(tp, bp);
                return error;
        }
index ab3563b8799560d9b932face2670cf463090e62d..8f4f26af35e1081fcf3e54b45a04a03010ca4b15 100644 (file)
@@ -251,7 +251,7 @@ xfs_dir2_block_to_sf(
        logflags = XFS_ILOG_CORE;
        error = xfs_dir2_shrink_inode(args, args->geo->datablk, bp);
        if (error) {
-               ASSERT(error != ENOSPC);
+               ASSERT(error != -ENOSPC);
                goto out;
        }
 
@@ -299,7 +299,7 @@ xfs_dir2_sf_addname(
 
        trace_xfs_dir2_sf_addname(args);
 
-       ASSERT(xfs_dir2_sf_lookup(args) == ENOENT);
+       ASSERT(xfs_dir2_sf_lookup(args) == -ENOENT);
        dp = args->dp;
        ASSERT(dp->i_df.if_flags & XFS_IFINLINE);
        /*
@@ -307,7 +307,7 @@ xfs_dir2_sf_addname(
         */
        if (dp->i_d.di_size < offsetof(xfs_dir2_sf_hdr_t, parent)) {
                ASSERT(XFS_FORCED_SHUTDOWN(dp->i_mount));
-               return EIO;
+               return -EIO;
        }
        ASSERT(dp->i_df.if_bytes == dp->i_d.di_size);
        ASSERT(dp->i_df.if_u1.if_data != NULL);
@@ -345,7 +345,7 @@ xfs_dir2_sf_addname(
                 * Just checking or no space reservation, it doesn't fit.
                 */
                if ((args->op_flags & XFS_DA_OP_JUSTCHECK) || args->total == 0)
-                       return ENOSPC;
+                       return -ENOSPC;
                /*
                 * Convert to block form then add the name.
                 */
@@ -738,7 +738,7 @@ xfs_dir2_sf_lookup(
         */
        if (dp->i_d.di_size < offsetof(xfs_dir2_sf_hdr_t, parent)) {
                ASSERT(XFS_FORCED_SHUTDOWN(dp->i_mount));
-               return EIO;
+               return -EIO;
        }
        ASSERT(dp->i_df.if_bytes == dp->i_d.di_size);
        ASSERT(dp->i_df.if_u1.if_data != NULL);
@@ -751,7 +751,7 @@ xfs_dir2_sf_lookup(
                args->inumber = dp->i_ino;
                args->cmpresult = XFS_CMP_EXACT;
                args->filetype = XFS_DIR3_FT_DIR;
-               return EEXIST;
+               return -EEXIST;
        }
        /*
         * Special case for ..
@@ -761,7 +761,7 @@ xfs_dir2_sf_lookup(
                args->inumber = dp->d_ops->sf_get_parent_ino(sfp);
                args->cmpresult = XFS_CMP_EXACT;
                args->filetype = XFS_DIR3_FT_DIR;
-               return EEXIST;
+               return -EEXIST;
        }
        /*
         * Loop over all the entries trying to match ours.
@@ -781,17 +781,17 @@ xfs_dir2_sf_lookup(
                        args->inumber = dp->d_ops->sf_get_ino(sfp, sfep);
                        args->filetype = dp->d_ops->sf_get_ftype(sfep);
                        if (cmp == XFS_CMP_EXACT)
-                               return EEXIST;
+                               return -EEXIST;
                        ci_sfep = sfep;
                }
        }
        ASSERT(args->op_flags & XFS_DA_OP_OKNOENT);
        /*
         * Here, we can only be doing a lookup (not a rename or replace).
-        * If a case-insensitive match was not found, return ENOENT.
+        * If a case-insensitive match was not found, return -ENOENT.
         */
        if (!ci_sfep)
-               return ENOENT;
+               return -ENOENT;
        /* otherwise process the CI match as required by the caller */
        error = xfs_dir_cilookup_result(args, ci_sfep->name, ci_sfep->namelen);
        return error;
@@ -824,7 +824,7 @@ xfs_dir2_sf_removename(
         */
        if (oldsize < offsetof(xfs_dir2_sf_hdr_t, parent)) {
                ASSERT(XFS_FORCED_SHUTDOWN(dp->i_mount));
-               return EIO;
+               return -EIO;
        }
        ASSERT(dp->i_df.if_bytes == oldsize);
        ASSERT(dp->i_df.if_u1.if_data != NULL);
@@ -847,7 +847,7 @@ xfs_dir2_sf_removename(
         * Didn't find it.
         */
        if (i == sfp->count)
-               return ENOENT;
+               return -ENOENT;
        /*
         * Calculate sizes.
         */
@@ -914,7 +914,7 @@ xfs_dir2_sf_replace(
         */
        if (dp->i_d.di_size < offsetof(xfs_dir2_sf_hdr_t, parent)) {
                ASSERT(XFS_FORCED_SHUTDOWN(dp->i_mount));
-               return EIO;
+               return -EIO;
        }
        ASSERT(dp->i_df.if_bytes == dp->i_d.di_size);
        ASSERT(dp->i_df.if_u1.if_data != NULL);
@@ -990,7 +990,7 @@ xfs_dir2_sf_replace(
                        if (i8elevated)
                                xfs_dir2_sf_toino4(args);
 #endif
-                       return ENOENT;
+                       return -ENOENT;
                }
        }
 #if XFS_BIG_INUMS
index c2ac0c611ad877f3a6321e15bf899c1bf520386a..bb969337efc83cb895fe3ccd11936148d0b69de9 100644 (file)
@@ -257,9 +257,9 @@ xfs_dquot_buf_read_verify(
        struct xfs_mount        *mp = bp->b_target->bt_mount;
 
        if (!xfs_dquot_buf_verify_crc(mp, bp))
-               xfs_buf_ioerror(bp, EFSBADCRC);
+               xfs_buf_ioerror(bp, -EFSBADCRC);
        else if (!xfs_dquot_buf_verify(mp, bp))
-               xfs_buf_ioerror(bp, EFSCORRUPTED);
+               xfs_buf_ioerror(bp, -EFSCORRUPTED);
 
        if (bp->b_error)
                xfs_verifier_error(bp);
@@ -277,7 +277,7 @@ xfs_dquot_buf_write_verify(
        struct xfs_mount        *mp = bp->b_target->bt_mount;
 
        if (!xfs_dquot_buf_verify(mp, bp)) {
-               xfs_buf_ioerror(bp, EFSCORRUPTED);
+               xfs_buf_ioerror(bp, -EFSCORRUPTED);
                xfs_verifier_error(bp);
                return;
        }
index 16fb63a9bc5e843f28e02801b639b68930b2ca8c..b62771f1f4b5b7028569b32af3b16bc806005132 100644 (file)
@@ -292,7 +292,7 @@ xfs_ialloc_inode_init(
                                         mp->m_bsize * blks_per_cluster,
                                         XBF_UNMAPPED);
                if (!fbuf)
-                       return ENOMEM;
+                       return -ENOMEM;
 
                /* Initialize the inode buffers and log them appropriately. */
                fbuf->b_ops = &xfs_inode_buf_ops;
@@ -380,7 +380,7 @@ xfs_ialloc_ag_alloc(
        newlen = args.mp->m_ialloc_inos;
        if (args.mp->m_maxicount &&
            args.mp->m_sb.sb_icount + newlen > args.mp->m_maxicount)
-               return ENOSPC;
+               return -ENOSPC;
        args.minlen = args.maxlen = args.mp->m_ialloc_blks;
        /*
         * First try to allocate inodes contiguous with the last-allocated
@@ -1385,7 +1385,7 @@ xfs_dialloc(
                if (error) {
                        xfs_trans_brelse(tp, agbp);
 
-                       if (error != ENOSPC)
+                       if (error != -ENOSPC)
                                goto out_error;
 
                        xfs_perag_put(pag);
@@ -1416,7 +1416,7 @@ nextag:
                        agno = 0;
                if (agno == start_agno) {
                        *inop = NULLFSINO;
-                       return noroom ? ENOSPC : 0;
+                       return noroom ? -ENOSPC : 0;
                }
        }
 
@@ -1682,7 +1682,7 @@ xfs_difree(
                xfs_warn(mp, "%s: agno >= mp->m_sb.sb_agcount (%d >= %d).",
                        __func__, agno, mp->m_sb.sb_agcount);
                ASSERT(0);
-               return EINVAL;
+               return -EINVAL;
        }
        agino = XFS_INO_TO_AGINO(mp, inode);
        if (inode != XFS_AGINO_TO_INO(mp, agno, agino))  {
@@ -1690,14 +1690,14 @@ xfs_difree(
                        __func__, (unsigned long long)inode,
                        (unsigned long long)XFS_AGINO_TO_INO(mp, agno, agino));
                ASSERT(0);
-               return EINVAL;
+               return -EINVAL;
        }
        agbno = XFS_AGINO_TO_AGBNO(mp, agino);
        if (agbno >= mp->m_sb.sb_agblocks)  {
                xfs_warn(mp, "%s: agbno >= mp->m_sb.sb_agblocks (%d >= %d).",
                        __func__, agbno, mp->m_sb.sb_agblocks);
                ASSERT(0);
-               return EINVAL;
+               return -EINVAL;
        }
        /*
         * Get the allocation group header.
@@ -1769,7 +1769,7 @@ xfs_imap_lookup(
                if (i)
                        error = xfs_inobt_get_rec(cur, &rec, &i);
                if (!error && i == 0)
-                       error = EINVAL;
+                       error = -EINVAL;
        }
 
        xfs_trans_brelse(tp, agbp);
@@ -1780,12 +1780,12 @@ xfs_imap_lookup(
        /* check that the returned record contains the required inode */
        if (rec.ir_startino > agino ||
            rec.ir_startino + mp->m_ialloc_inos <= agino)
-               return EINVAL;
+               return -EINVAL;
 
        /* for untrusted inodes check it is allocated first */
        if ((flags & XFS_IGET_UNTRUSTED) &&
            (rec.ir_free & XFS_INOBT_MASK(agino - rec.ir_startino)))
-               return EINVAL;
+               return -EINVAL;
 
        *chunk_agbno = XFS_AGINO_TO_AGBNO(mp, rec.ir_startino);
        *offset_agbno = agbno - *chunk_agbno;
@@ -1829,7 +1829,7 @@ xfs_imap(
                 * as they can be invalid without implying corruption.
                 */
                if (flags & XFS_IGET_UNTRUSTED)
-                       return EINVAL;
+                       return -EINVAL;
                if (agno >= mp->m_sb.sb_agcount) {
                        xfs_alert(mp,
                                "%s: agno (%d) >= mp->m_sb.sb_agcount (%d)",
@@ -1849,7 +1849,7 @@ xfs_imap(
                }
                xfs_stack_trace();
 #endif /* DEBUG */
-               return EINVAL;
+               return -EINVAL;
        }
 
        blks_per_cluster = xfs_icluster_size_fsb(mp);
@@ -1922,7 +1922,7 @@ out_map:
                        __func__, (unsigned long long) imap->im_blkno,
                        (unsigned long long) imap->im_len,
                        XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks));
-               return EINVAL;
+               return -EINVAL;
        }
        return 0;
 }
@@ -2072,11 +2072,11 @@ xfs_agi_read_verify(
 
        if (xfs_sb_version_hascrc(&mp->m_sb) &&
            !xfs_buf_verify_cksum(bp, XFS_AGI_CRC_OFF))
-               xfs_buf_ioerror(bp, EFSBADCRC);
+               xfs_buf_ioerror(bp, -EFSBADCRC);
        else if (XFS_TEST_ERROR(!xfs_agi_verify(bp), mp,
                                XFS_ERRTAG_IALLOC_READ_AGI,
                                XFS_RANDOM_IALLOC_READ_AGI))
-               xfs_buf_ioerror(bp, EFSCORRUPTED);
+               xfs_buf_ioerror(bp, -EFSCORRUPTED);
 
        if (bp->b_error)
                xfs_verifier_error(bp);
@@ -2090,7 +2090,7 @@ xfs_agi_write_verify(
        struct xfs_buf_log_item *bip = bp->b_fspriv;
 
        if (!xfs_agi_verify(bp)) {
-               xfs_buf_ioerror(bp, EFSCORRUPTED);
+               xfs_buf_ioerror(bp, -EFSCORRUPTED);
                xfs_verifier_error(bp);
                return;
        }
index 726f83a681a59412817e7281774f7fa7ca77a3d2..c9b06f30fe86d98df43d3ef403997c77d393bf0b 100644 (file)
@@ -272,9 +272,9 @@ xfs_inobt_read_verify(
        struct xfs_buf  *bp)
 {
        if (!xfs_btree_sblock_verify_crc(bp))
-               xfs_buf_ioerror(bp, EFSBADCRC);
+               xfs_buf_ioerror(bp, -EFSBADCRC);
        else if (!xfs_inobt_verify(bp))
-               xfs_buf_ioerror(bp, EFSCORRUPTED);
+               xfs_buf_ioerror(bp, -EFSCORRUPTED);
 
        if (bp->b_error) {
                trace_xfs_btree_corrupt(bp, _RET_IP_);
@@ -288,7 +288,7 @@ xfs_inobt_write_verify(
 {
        if (!xfs_inobt_verify(bp)) {
                trace_xfs_btree_corrupt(bp, _RET_IP_);
-               xfs_buf_ioerror(bp, EFSCORRUPTED);
+               xfs_buf_ioerror(bp, -EFSCORRUPTED);
                xfs_verifier_error(bp);
                return;
        }
index 1e5366d7745e53256cf70c8a83a53a6a83a63dd3..f18fd2da49f70fe510fa8cfabe7c5f3014757dbb 100644 (file)
@@ -101,7 +101,7 @@ xfs_inode_buf_verify(
                                return;
                        }
 
-                       xfs_buf_ioerror(bp, EFSCORRUPTED);
+                       xfs_buf_ioerror(bp, -EFSCORRUPTED);
                        xfs_verifier_error(bp);
 #ifdef DEBUG
                        xfs_alert(mp,
@@ -174,14 +174,14 @@ xfs_imap_to_bp(
                                   (int)imap->im_len, buf_flags, &bp,
                                   &xfs_inode_buf_ops);
        if (error) {
-               if (error == EAGAIN) {
+               if (error == -EAGAIN) {
                        ASSERT(buf_flags & XBF_TRYLOCK);
                        return error;
                }
 
-               if (error == EFSCORRUPTED &&
+               if (error == -EFSCORRUPTED &&
                    (iget_flags & XFS_IGET_UNTRUSTED))
-                       return EINVAL;
+                       return -EINVAL;
 
                xfs_warn(mp, "%s: xfs_trans_read_buf() returned error %d.",
                        __func__, error);
@@ -390,7 +390,7 @@ xfs_iread(
                                __func__, ip->i_ino);
 
                XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, dip);
-               error = EFSCORRUPTED;
+               error = -EFSCORRUPTED;
                goto out_brelse;
        }
 
index 2a124e97f0820a0687025a065ecacbb22b67603f..8ac9411bcf2afe66c8563ae1c8186811bdc2825c 100644 (file)
@@ -102,7 +102,7 @@ xfs_iformat_fork(
                                be64_to_cpu(dip->di_nblocks));
                XFS_CORRUPTION_ERROR("xfs_iformat(1)", XFS_ERRLEVEL_LOW,
                                     ip->i_mount, dip);
-               return EFSCORRUPTED;
+               return -EFSCORRUPTED;
        }
 
        if (unlikely(dip->di_forkoff > ip->i_mount->m_sb.sb_inodesize)) {
@@ -111,7 +111,7 @@ xfs_iformat_fork(
                        dip->di_forkoff);
                XFS_CORRUPTION_ERROR("xfs_iformat(2)", XFS_ERRLEVEL_LOW,
                                     ip->i_mount, dip);
-               return EFSCORRUPTED;
+               return -EFSCORRUPTED;
        }
 
        if (unlikely((ip->i_d.di_flags & XFS_DIFLAG_REALTIME) &&
@@ -121,7 +121,7 @@ xfs_iformat_fork(
                        ip->i_ino);
                XFS_CORRUPTION_ERROR("xfs_iformat(realtime)",
                                     XFS_ERRLEVEL_LOW, ip->i_mount, dip);
-               return EFSCORRUPTED;
+               return -EFSCORRUPTED;
        }
 
        switch (ip->i_d.di_mode & S_IFMT) {
@@ -132,7 +132,7 @@ xfs_iformat_fork(
                if (unlikely(dip->di_format != XFS_DINODE_FMT_DEV)) {
                        XFS_CORRUPTION_ERROR("xfs_iformat(3)", XFS_ERRLEVEL_LOW,
                                              ip->i_mount, dip);
-                       return EFSCORRUPTED;
+                       return -EFSCORRUPTED;
                }
                ip->i_d.di_size = 0;
                ip->i_df.if_u2.if_rdev = xfs_dinode_get_rdev(dip);
@@ -153,7 +153,7 @@ xfs_iformat_fork(
                                XFS_CORRUPTION_ERROR("xfs_iformat(4)",
                                                     XFS_ERRLEVEL_LOW,
                                                     ip->i_mount, dip);
-                               return EFSCORRUPTED;
+                               return -EFSCORRUPTED;
                        }
 
                        di_size = be64_to_cpu(dip->di_size);
@@ -166,7 +166,7 @@ xfs_iformat_fork(
                                XFS_CORRUPTION_ERROR("xfs_iformat(5)",
                                                     XFS_ERRLEVEL_LOW,
                                                     ip->i_mount, dip);
-                               return EFSCORRUPTED;
+                               return -EFSCORRUPTED;
                        }
 
                        size = (int)di_size;
@@ -181,13 +181,13 @@ xfs_iformat_fork(
                default:
                        XFS_ERROR_REPORT("xfs_iformat(6)", XFS_ERRLEVEL_LOW,
                                         ip->i_mount);
-                       return EFSCORRUPTED;
+                       return -EFSCORRUPTED;
                }
                break;
 
        default:
                XFS_ERROR_REPORT("xfs_iformat(7)", XFS_ERRLEVEL_LOW, ip->i_mount);
-               return EFSCORRUPTED;
+               return -EFSCORRUPTED;
        }
        if (error) {
                return error;
@@ -211,7 +211,7 @@ xfs_iformat_fork(
                        XFS_CORRUPTION_ERROR("xfs_iformat(8)",
                                             XFS_ERRLEVEL_LOW,
                                             ip->i_mount, dip);
-                       return EFSCORRUPTED;
+                       return -EFSCORRUPTED;
                }
 
                error = xfs_iformat_local(ip, dip, XFS_ATTR_FORK, size);
@@ -223,7 +223,7 @@ xfs_iformat_fork(
                error = xfs_iformat_btree(ip, dip, XFS_ATTR_FORK);
                break;
        default:
-               error = EFSCORRUPTED;
+               error = -EFSCORRUPTED;
                break;
        }
        if (error) {
@@ -266,7 +266,7 @@ xfs_iformat_local(
                        XFS_DFORK_SIZE(dip, ip->i_mount, whichfork));
                XFS_CORRUPTION_ERROR("xfs_iformat_local", XFS_ERRLEVEL_LOW,
                                     ip->i_mount, dip);
-               return EFSCORRUPTED;
+               return -EFSCORRUPTED;
        }
        ifp = XFS_IFORK_PTR(ip, whichfork);
        real_size = 0;
@@ -322,7 +322,7 @@ xfs_iformat_extents(
                        (unsigned long long) ip->i_ino, nex);
                XFS_CORRUPTION_ERROR("xfs_iformat_extents(1)", XFS_ERRLEVEL_LOW,
                                     ip->i_mount, dip);
-               return EFSCORRUPTED;
+               return -EFSCORRUPTED;
        }
 
        ifp->if_real_bytes = 0;
@@ -350,7 +350,7 @@ xfs_iformat_extents(
                                        XFS_ERROR_REPORT("xfs_iformat_extents(2)",
                                                         XFS_ERRLEVEL_LOW,
                                                         ip->i_mount);
-                                       return EFSCORRUPTED;
+                                       return -EFSCORRUPTED;
                                }
        }
        ifp->if_flags |= XFS_IFEXTENTS;
@@ -399,7 +399,7 @@ xfs_iformat_btree(
                                        (unsigned long long) ip->i_ino);
                XFS_CORRUPTION_ERROR("xfs_iformat_btree", XFS_ERRLEVEL_LOW,
                                         mp, dip);
-               return EFSCORRUPTED;
+               return -EFSCORRUPTED;
        }
 
        ifp->if_broot_bytes = size;
@@ -436,7 +436,7 @@ xfs_iread_extents(
        if (unlikely(XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE)) {
                XFS_ERROR_REPORT("xfs_iread_extents", XFS_ERRLEVEL_LOW,
                                 ip->i_mount);
-               return EFSCORRUPTED;
+               return -EFSCORRUPTED;
        }
        nextents = XFS_IFORK_NEXTENTS(ip, whichfork);
        ifp = XFS_IFORK_PTR(ip, whichfork);
index 06ad60b4b9fd45d39c0b87741406a4fd44096ae3..f5ca0286a0afc3ebaf7451d7bd0f135af18ef4c5 100644 (file)
@@ -186,13 +186,13 @@ xfs_mount_validate_sb(
         */
        if (sbp->sb_magicnum != XFS_SB_MAGIC) {
                xfs_warn(mp, "bad magic number");
-               return EWRONGFS;
+               return -EWRONGFS;
        }
 
 
        if (!xfs_sb_good_version(sbp)) {
                xfs_warn(mp, "bad version");
-               return EWRONGFS;
+               return -EWRONGFS;
        }
 
        /*
@@ -220,7 +220,7 @@ xfs_mount_validate_sb(
                                xfs_warn(mp,
 "Attempted to mount read-only compatible filesystem read-write.\n"
 "Filesystem can only be safely mounted read only.");
-                               return EINVAL;
+                               return -EINVAL;
                        }
                }
                if (xfs_sb_has_incompat_feature(sbp,
@@ -230,7 +230,7 @@ xfs_mount_validate_sb(
 "Filesystem can not be safely mounted by this kernel.",
                                (sbp->sb_features_incompat &
                                                XFS_SB_FEAT_INCOMPAT_UNKNOWN));
-                       return EINVAL;
+                       return -EINVAL;
                }
        }
 
@@ -238,13 +238,13 @@ xfs_mount_validate_sb(
                if (sbp->sb_qflags & (XFS_OQUOTA_ENFD | XFS_OQUOTA_CHKD)) {
                        xfs_notice(mp,
                           "Version 5 of Super block has XFS_OQUOTA bits.");
-                       return EFSCORRUPTED;
+                       return -EFSCORRUPTED;
                }
        } else if (sbp->sb_qflags & (XFS_PQUOTA_ENFD | XFS_GQUOTA_ENFD |
                                XFS_PQUOTA_CHKD | XFS_GQUOTA_CHKD)) {
                        xfs_notice(mp,
 "Superblock earlier than Version 5 has XFS_[PQ]UOTA_{ENFD|CHKD} bits.");
-                       return EFSCORRUPTED;
+                       return -EFSCORRUPTED;
        }
 
        if (unlikely(
@@ -252,7 +252,7 @@ xfs_mount_validate_sb(
                xfs_warn(mp,
                "filesystem is marked as having an external log; "
                "specify logdev on the mount command line.");
-               return EINVAL;
+               return -EINVAL;
        }
 
        if (unlikely(
@@ -260,7 +260,7 @@ xfs_mount_validate_sb(
                xfs_warn(mp,
                "filesystem is marked as having an internal log; "
                "do not specify logdev on the mount command line.");
-               return EINVAL;
+               return -EINVAL;
        }
 
        /*
@@ -294,7 +294,7 @@ xfs_mount_validate_sb(
            sbp->sb_dblocks < XFS_MIN_DBLOCKS(sbp)                      ||
            sbp->sb_shared_vn != 0)) {
                xfs_notice(mp, "SB sanity check failed");
-               return EFSCORRUPTED;
+               return -EFSCORRUPTED;
        }
 
        /*
@@ -305,7 +305,7 @@ xfs_mount_validate_sb(
                "File system with blocksize %d bytes. "
                "Only pagesize (%ld) or less will currently work.",
                                sbp->sb_blocksize, PAGE_SIZE);
-               return ENOSYS;
+               return -ENOSYS;
        }
 
        /*
@@ -320,19 +320,19 @@ xfs_mount_validate_sb(
        default:
                xfs_warn(mp, "inode size of %d bytes not supported",
                                sbp->sb_inodesize);
-               return ENOSYS;
+               return -ENOSYS;
        }
 
        if (xfs_sb_validate_fsb_count(sbp, sbp->sb_dblocks) ||
            xfs_sb_validate_fsb_count(sbp, sbp->sb_rblocks)) {
                xfs_warn(mp,
                "file system too large to be mounted on this system.");
-               return EFBIG;
+               return -EFBIG;
        }
 
        if (check_inprogress && sbp->sb_inprogress) {
                xfs_warn(mp, "Offline file system operation in progress!");
-               return EFSCORRUPTED;
+               return -EFSCORRUPTED;
        }
        return 0;
 }
@@ -603,7 +603,7 @@ xfs_sb_read_verify(
                        /* Only fail bad secondaries on a known V5 filesystem */
                        if (bp->b_bn == XFS_SB_DADDR ||
                            xfs_sb_version_hascrc(&mp->m_sb)) {
-                               error = EFSBADCRC;
+                               error = -EFSBADCRC;
                                goto out_error;
                        }
                }
@@ -613,7 +613,7 @@ xfs_sb_read_verify(
 out_error:
        if (error) {
                xfs_buf_ioerror(bp, error);
-               if (error == EFSCORRUPTED || error == EFSBADCRC)
+               if (error == -EFSCORRUPTED || error == -EFSBADCRC)
                        xfs_verifier_error(bp);
        }
 }
@@ -636,7 +636,7 @@ xfs_sb_quiet_read_verify(
                return;
        }
        /* quietly fail */
-       xfs_buf_ioerror(bp, EWRONGFS);
+       xfs_buf_ioerror(bp, -EWRONGFS);
 }
 
 static void
index 23c2f2577c8d75fdd85660cb0aac0524318cd384..5782f037eab4a9f863669a61eba28881d00e0a5a 100644 (file)
@@ -133,9 +133,9 @@ xfs_symlink_read_verify(
                return;
 
        if (!xfs_buf_verify_cksum(bp, XFS_SYMLINK_CRC_OFF))
-               xfs_buf_ioerror(bp, EFSBADCRC);
+               xfs_buf_ioerror(bp, -EFSBADCRC);
        else if (!xfs_symlink_verify(bp))
-               xfs_buf_ioerror(bp, EFSCORRUPTED);
+               xfs_buf_ioerror(bp, -EFSCORRUPTED);
 
        if (bp->b_error)
                xfs_verifier_error(bp);
@@ -153,7 +153,7 @@ xfs_symlink_write_verify(
                return;
 
        if (!xfs_symlink_verify(bp)) {
-               xfs_buf_ioerror(bp, EFSCORRUPTED);
+               xfs_buf_ioerror(bp, -EFSCORRUPTED);
                xfs_verifier_error(bp);
                return;
        }
index 6888ad886ff6205cc0baf0aa36352fa92f9d93ea..a65fa5dde6e9c514b0e5fbfeecd6d14a83e202bc 100644 (file)
@@ -152,7 +152,7 @@ xfs_get_acl(struct inode *inode, int type)
        if (!xfs_acl)
                return ERR_PTR(-ENOMEM);
 
-       error = -xfs_attr_get(ip, ea_name, (unsigned char *)xfs_acl,
+       error = xfs_attr_get(ip, ea_name, (unsigned char *)xfs_acl,
                                                        &len, ATTR_ROOT);
        if (error) {
                /*
@@ -210,7 +210,7 @@ __xfs_set_acl(struct inode *inode, int type, struct posix_acl *acl)
                len -= sizeof(struct xfs_acl_entry) *
                         (XFS_ACL_MAX_ENTRIES(ip->i_mount) - acl->a_count);
 
-               error = -xfs_attr_set(ip, ea_name, (unsigned char *)xfs_acl,
+               error = xfs_attr_set(ip, ea_name, (unsigned char *)xfs_acl,
                                len, ATTR_ROOT);
 
                kmem_free(xfs_acl);
@@ -218,7 +218,7 @@ __xfs_set_acl(struct inode *inode, int type, struct posix_acl *acl)
                /*
                 * A NULL ACL argument means we want to remove the ACL.
                 */
-               error = -xfs_attr_remove(ip, ea_name, ATTR_ROOT);
+               error = xfs_attr_remove(ip, ea_name, ATTR_ROOT);
 
                /*
                 * If the attribute didn't exist to start with that's fine.
@@ -244,7 +244,7 @@ xfs_set_mode(struct inode *inode, umode_t mode)
                iattr.ia_mode = mode;
                iattr.ia_ctime = current_fs_time(inode->i_sb);
 
-               error = -xfs_setattr_nonsize(XFS_I(inode), &iattr, XFS_ATTR_NOACL);
+               error = xfs_setattr_nonsize(XFS_I(inode), &iattr, XFS_ATTR_NOACL);
        }
 
        return error;
index eb67f416b13ac8a2963b80a332345800606c7aa6..11e9b4caa54f168f7e429f5d7e5a01302d026e1c 100644 (file)
@@ -240,7 +240,7 @@ xfs_end_io(
 
 done:
        if (error)
-               ioend->io_error = -error;
+               ioend->io_error = error;
        xfs_destroy_ioend(ioend);
 }
 
@@ -332,14 +332,14 @@ xfs_map_blocks(
        xfs_iunlock(ip, XFS_ILOCK_SHARED);
 
        if (error)
-               return -error;
+               return error;
 
        if (type == XFS_IO_DELALLOC &&
            (!nimaps || isnullstartblock(imap->br_startblock))) {
                error = xfs_iomap_write_allocate(ip, offset, imap);
                if (!error)
                        trace_xfs_map_blocks_alloc(ip, offset, count, type, imap);
-               return -error;
+               return error;
        }
 
 #ifdef DEBUG
@@ -502,7 +502,7 @@ xfs_submit_ioend(
                 * time.
                 */
                if (fail) {
-                       ioend->io_error = -fail;
+                       ioend->io_error = fail;
                        xfs_finish_ioend(ioend);
                        continue;
                }
@@ -1302,7 +1302,7 @@ __xfs_get_blocks(
                        error = xfs_iomap_write_direct(ip, offset, size,
                                                       &imap, nimaps);
                        if (error)
-                               return -error;
+                               return error;
                        new = 1;
                } else {
                        /*
@@ -1415,7 +1415,7 @@ __xfs_get_blocks(
 
 out_unlock:
        xfs_iunlock(ip, lockmode);
-       return -error;
+       return error;
 }
 
 int
index f19d1ef1f84a1a01cad9d1fc7d253f41a2b50802..aa2a8b1838a2939d62ef104a25b4a4f98f1b9020 100644 (file)
@@ -95,7 +95,7 @@ xfs_attr3_leaf_freextent(
                                        dp->i_mount->m_ddev_targp,
                                        dblkno, dblkcnt, 0);
                        if (!bp)
-                               return ENOMEM;
+                               return -ENOMEM;
                        xfs_trans_binval(*trans, bp);
                        /*
                         * Roll to next transaction.
@@ -227,7 +227,7 @@ xfs_attr3_node_inactive(
         */
        if (level > XFS_DA_NODE_MAXDEPTH) {
                xfs_trans_brelse(*trans, bp);   /* no locks for later trans */
-               return EIO;
+               return -EIO;
        }
 
        node = bp->b_addr;
@@ -277,7 +277,7 @@ xfs_attr3_node_inactive(
                                                        child_bp);
                                break;
                        default:
-                               error = EIO;
+                               error = -EIO;
                                xfs_trans_brelse(*trans, child_bp);
                                break;
                        }
@@ -360,7 +360,7 @@ xfs_attr3_root_inactive(
                error = xfs_attr3_leaf_inactive(trans, dp, bp);
                break;
        default:
-               error = EIO;
+               error = -EIO;
                xfs_trans_brelse(*trans, bp);
                break;
        }
index 84ea231e0da462d8034276f90ec77281f493c917..62db83ab6cbc5e45f7dc1527738897b653c98e0f 100644 (file)
@@ -150,7 +150,7 @@ xfs_attr_shortform_list(xfs_attr_list_context_t *context)
                                             XFS_ERRLEVEL_LOW,
                                             context->dp->i_mount, sfe);
                        kmem_free(sbuf);
-                       return EFSCORRUPTED;
+                       return -EFSCORRUPTED;
                }
 
                sbp->entno = i;
@@ -243,7 +243,7 @@ xfs_attr_node_list(xfs_attr_list_context_t *context)
        if (cursor->blkno > 0) {
                error = xfs_da3_node_read(NULL, dp, cursor->blkno, -1,
                                              &bp, XFS_ATTR_FORK);
-               if ((error != 0) && (error != EFSCORRUPTED))
+               if ((error != 0) && (error != -EFSCORRUPTED))
                        return error;
                if (bp) {
                        struct xfs_attr_leaf_entry *entries;
@@ -308,7 +308,7 @@ xfs_attr_node_list(xfs_attr_list_context_t *context)
                                                     context->dp->i_mount,
                                                     node);
                                xfs_trans_brelse(NULL, bp);
-                               return EFSCORRUPTED;
+                               return -EFSCORRUPTED;
                        }
 
                        dp->d_ops->node_hdr_from_disk(&nodehdr, node);
@@ -514,7 +514,7 @@ xfs_attr_list_int(
        XFS_STATS_INC(xs_attr_list);
 
        if (XFS_FORCED_SHUTDOWN(dp->i_mount))
-               return EIO;
+               return -EIO;
 
        /*
         * Decide on what work routines to call based on the inode size.
@@ -616,16 +616,16 @@ xfs_attr_list(
         * Validate the cursor.
         */
        if (cursor->pad1 || cursor->pad2)
-               return EINVAL;
+               return -EINVAL;
        if ((cursor->initted == 0) &&
            (cursor->hashval || cursor->blkno || cursor->offset))
-               return EINVAL;
+               return -EINVAL;
 
        /*
         * Check for a properly aligned buffer.
         */
        if (((long)buffer) & (sizeof(int)-1))
-               return EFAULT;
+               return -EFAULT;
        if (flags & ATTR_KERNOVAL)
                bufsize = 0;
 
@@ -648,6 +648,6 @@ xfs_attr_list(
        alist->al_offset[0] = context.bufsize;
 
        error = xfs_attr_list_int(&context);
-       ASSERT(error >= 0);
+       ASSERT(error <= 0);
        return error;
 }
index ee48642c2802aac101dd0eaeed36d108b855d372..56f050efcac8864a98fab69effc664e2b703aaef 100644 (file)
@@ -133,7 +133,7 @@ xfs_bmap_finish(
                        mp = ntp->t_mountp;
                        if (!XFS_FORCED_SHUTDOWN(mp))
                                xfs_force_shutdown(mp,
-                                                  (error == EFSCORRUPTED) ?
+                                                  (error == -EFSCORRUPTED) ?
                                                   SHUTDOWN_CORRUPT_INCORE :
                                                   SHUTDOWN_META_IO_ERROR);
                        return error;
@@ -418,7 +418,7 @@ xfs_bmap_count_tree(
                        xfs_trans_brelse(tp, bp);
                        XFS_ERROR_REPORT("xfs_bmap_count_tree(1)",
                                         XFS_ERRLEVEL_LOW, mp);
-                       return EFSCORRUPTED;
+                       return -EFSCORRUPTED;
                }
                xfs_trans_brelse(tp, bp);
        } else {
@@ -485,7 +485,7 @@ xfs_bmap_count_blocks(
        if (unlikely(xfs_bmap_count_tree(mp, tp, ifp, bno, level, count) < 0)) {
                XFS_ERROR_REPORT("xfs_bmap_count_blocks(2)", XFS_ERRLEVEL_LOW,
                                 mp);
-               return EFSCORRUPTED;
+               return -EFSCORRUPTED;
        }
 
        return 0;
@@ -577,13 +577,13 @@ xfs_getbmap(
                        if (ip->i_d.di_aformat != XFS_DINODE_FMT_EXTENTS &&
                            ip->i_d.di_aformat != XFS_DINODE_FMT_BTREE &&
                            ip->i_d.di_aformat != XFS_DINODE_FMT_LOCAL)
-                               return EINVAL;
+                               return -EINVAL;
                } else if (unlikely(
                           ip->i_d.di_aformat != 0 &&
                           ip->i_d.di_aformat != XFS_DINODE_FMT_EXTENTS)) {
                        XFS_ERROR_REPORT("xfs_getbmap", XFS_ERRLEVEL_LOW,
                                         ip->i_mount);
-                       return EFSCORRUPTED;
+                       return -EFSCORRUPTED;
                }
 
                prealloced = 0;
@@ -592,7 +592,7 @@ xfs_getbmap(
                if (ip->i_d.di_format != XFS_DINODE_FMT_EXTENTS &&
                    ip->i_d.di_format != XFS_DINODE_FMT_BTREE &&
                    ip->i_d.di_format != XFS_DINODE_FMT_LOCAL)
-                       return EINVAL;
+                       return -EINVAL;
 
                if (xfs_get_extsz_hint(ip) ||
                    ip->i_d.di_flags & (XFS_DIFLAG_PREALLOC|XFS_DIFLAG_APPEND)){
@@ -612,26 +612,26 @@ xfs_getbmap(
                bmv->bmv_entries = 0;
                return 0;
        } else if (bmv->bmv_length < 0) {
-               return EINVAL;
+               return -EINVAL;
        }
 
        nex = bmv->bmv_count - 1;
        if (nex <= 0)
-               return EINVAL;
+               return -EINVAL;
        bmvend = bmv->bmv_offset + bmv->bmv_length;
 
 
        if (bmv->bmv_count > ULONG_MAX / sizeof(struct getbmapx))
-               return ENOMEM;
+               return -ENOMEM;
        out = kmem_zalloc_large(bmv->bmv_count * sizeof(struct getbmapx), 0);
        if (!out)
-               return ENOMEM;
+               return -ENOMEM;
 
        xfs_ilock(ip, XFS_IOLOCK_SHARED);
        if (whichfork == XFS_DATA_FORK) {
                if (!(iflags & BMV_IF_DELALLOC) &&
                    (ip->i_delayed_blks || XFS_ISIZE(ip) > ip->i_d.di_size)) {
-                       error = -filemap_write_and_wait(VFS_I(ip)->i_mapping);
+                       error = filemap_write_and_wait(VFS_I(ip)->i_mapping);
                        if (error)
                                goto out_unlock_iolock;
 
@@ -664,7 +664,7 @@ xfs_getbmap(
        /*
         * Allocate enough space to handle "subnex" maps at a time.
         */
-       error = ENOMEM;
+       error = -ENOMEM;
        subnex = 16;
        map = kmem_alloc(subnex * sizeof(*map), KM_MAYFAIL | KM_NOFS);
        if (!map)
@@ -935,7 +935,7 @@ xfs_free_eofblocks(
                if (need_iolock) {
                        if (!xfs_ilock_nowait(ip, XFS_IOLOCK_EXCL)) {
                                xfs_trans_cancel(tp, 0);
-                               return EAGAIN;
+                               return -EAGAIN;
                        }
                }
 
@@ -1008,14 +1008,14 @@ xfs_alloc_file_space(
        trace_xfs_alloc_file_space(ip);
 
        if (XFS_FORCED_SHUTDOWN(mp))
-               return EIO;
+               return -EIO;
 
        error = xfs_qm_dqattach(ip, 0);
        if (error)
                return error;
 
        if (len <= 0)
-               return EINVAL;
+               return -EINVAL;
 
        rt = XFS_IS_REALTIME_INODE(ip);
        extsz = xfs_get_extsz_hint(ip);
@@ -1081,7 +1081,7 @@ xfs_alloc_file_space(
                        /*
                         * Free the transaction structure.
                         */
-                       ASSERT(error == ENOSPC || XFS_FORCED_SHUTDOWN(mp));
+                       ASSERT(error == -ENOSPC || XFS_FORCED_SHUTDOWN(mp));
                        xfs_trans_cancel(tp, 0);
                        break;
                }
@@ -1118,7 +1118,7 @@ xfs_alloc_file_space(
                allocated_fsb = imapp->br_blockcount;
 
                if (nimaps == 0) {
-                       error = ENOSPC;
+                       error = -ENOSPC;
                        break;
                }
 
@@ -1179,7 +1179,7 @@ xfs_zero_remaining_bytes(
                                        mp->m_rtdev_targp : mp->m_ddev_targp,
                                  BTOBB(mp->m_sb.sb_blocksize), 0);
        if (!bp)
-               return ENOMEM;
+               return -ENOMEM;
 
        xfs_buf_unlock(bp);
 
@@ -1211,7 +1211,7 @@ xfs_zero_remaining_bytes(
                XFS_BUF_SET_ADDR(bp, xfs_fsb_to_db(ip, imap.br_startblock));
 
                if (XFS_FORCED_SHUTDOWN(mp)) {
-                       error = EIO;
+                       error = -EIO;
                        break;
                }
                xfs_buf_iorequest(bp);
@@ -1229,7 +1229,7 @@ xfs_zero_remaining_bytes(
                XFS_BUF_WRITE(bp);
 
                if (XFS_FORCED_SHUTDOWN(mp)) {
-                       error = EIO;
+                       error = -EIO;
                        break;
                }
                xfs_buf_iorequest(bp);
@@ -1287,7 +1287,7 @@ xfs_free_file_space(
 
        rounding = max_t(xfs_off_t, 1 << mp->m_sb.sb_blocklog, PAGE_CACHE_SIZE);
        ioffset = offset & ~(rounding - 1);
-       error = -filemap_write_and_wait_range(VFS_I(ip)->i_mapping,
+       error = filemap_write_and_wait_range(VFS_I(ip)->i_mapping,
                                              ioffset, -1);
        if (error)
                goto out;
@@ -1368,7 +1368,7 @@ xfs_free_file_space(
                        /*
                         * Free the transaction structure.
                         */
-                       ASSERT(error == ENOSPC || XFS_FORCED_SHUTDOWN(mp));
+                       ASSERT(error == -ENOSPC || XFS_FORCED_SHUTDOWN(mp));
                        xfs_trans_cancel(tp, 0);
                        break;
                }
@@ -1610,14 +1610,14 @@ xfs_swap_extents_check_format(
        /* Should never get a local format */
        if (ip->i_d.di_format == XFS_DINODE_FMT_LOCAL ||
            tip->i_d.di_format == XFS_DINODE_FMT_LOCAL)
-               return EINVAL;
+               return -EINVAL;
 
        /*
         * if the target inode has less extents that then temporary inode then
         * why did userspace call us?
         */
        if (ip->i_d.di_nextents < tip->i_d.di_nextents)
-               return EINVAL;
+               return -EINVAL;
 
        /*
         * if the target inode is in extent form and the temp inode is in btree
@@ -1626,19 +1626,19 @@ xfs_swap_extents_check_format(
         */
        if (ip->i_d.di_format == XFS_DINODE_FMT_EXTENTS &&
            tip->i_d.di_format == XFS_DINODE_FMT_BTREE)
-               return EINVAL;
+               return -EINVAL;
 
        /* Check temp in extent form to max in target */
        if (tip->i_d.di_format == XFS_DINODE_FMT_EXTENTS &&
            XFS_IFORK_NEXTENTS(tip, XFS_DATA_FORK) >
                        XFS_IFORK_MAXEXT(ip, XFS_DATA_FORK))
-               return EINVAL;
+               return -EINVAL;
 
        /* Check target in extent form to max in temp */
        if (ip->i_d.di_format == XFS_DINODE_FMT_EXTENTS &&
            XFS_IFORK_NEXTENTS(ip, XFS_DATA_FORK) >
                        XFS_IFORK_MAXEXT(tip, XFS_DATA_FORK))
-               return EINVAL;
+               return -EINVAL;
 
        /*
         * If we are in a btree format, check that the temp root block will fit
@@ -1652,20 +1652,20 @@ xfs_swap_extents_check_format(
        if (tip->i_d.di_format == XFS_DINODE_FMT_BTREE) {
                if (XFS_IFORK_BOFF(ip) &&
                    XFS_BMAP_BMDR_SPACE(tip->i_df.if_broot) > XFS_IFORK_BOFF(ip))
-                       return EINVAL;
+                       return -EINVAL;
                if (XFS_IFORK_NEXTENTS(tip, XFS_DATA_FORK) <=
                    XFS_IFORK_MAXEXT(ip, XFS_DATA_FORK))
-                       return EINVAL;
+                       return -EINVAL;
        }
 
        /* Reciprocal target->temp btree format checks */
        if (ip->i_d.di_format == XFS_DINODE_FMT_BTREE) {
                if (XFS_IFORK_BOFF(tip) &&
                    XFS_BMAP_BMDR_SPACE(ip->i_df.if_broot) > XFS_IFORK_BOFF(tip))
-                       return EINVAL;
+                       return -EINVAL;
                if (XFS_IFORK_NEXTENTS(ip, XFS_DATA_FORK) <=
                    XFS_IFORK_MAXEXT(tip, XFS_DATA_FORK))
-                       return EINVAL;
+                       return -EINVAL;
        }
 
        return 0;
@@ -1689,7 +1689,7 @@ xfs_swap_extents(
 
        tempifp = kmem_alloc(sizeof(xfs_ifork_t), KM_MAYFAIL);
        if (!tempifp) {
-               error = ENOMEM;
+               error = -ENOMEM;
                goto out;
        }
 
@@ -1704,24 +1704,24 @@ xfs_swap_extents(
 
        /* Verify that both files have the same format */
        if ((ip->i_d.di_mode & S_IFMT) != (tip->i_d.di_mode & S_IFMT)) {
-               error = EINVAL;
+               error = -EINVAL;
                goto out_unlock;
        }
 
        /* Verify both files are either real-time or non-realtime */
        if (XFS_IS_REALTIME_INODE(ip) != XFS_IS_REALTIME_INODE(tip)) {
-               error = EINVAL;
+               error = -EINVAL;
                goto out_unlock;
        }
 
-       error = -filemap_write_and_wait(VFS_I(tip)->i_mapping);
+       error = filemap_write_and_wait(VFS_I(tip)->i_mapping);
        if (error)
                goto out_unlock;
        truncate_pagecache_range(VFS_I(tip), 0, -1);
 
        /* Verify O_DIRECT for ftmp */
        if (VN_CACHED(VFS_I(tip)) != 0) {
-               error = EINVAL;
+               error = -EINVAL;
                goto out_unlock;
        }
 
@@ -1729,7 +1729,7 @@ xfs_swap_extents(
        if (sxp->sx_offset != 0 ||
            sxp->sx_length != ip->i_d.di_size ||
            sxp->sx_length != tip->i_d.di_size) {
-               error = EFAULT;
+               error = -EFAULT;
                goto out_unlock;
        }
 
@@ -1756,7 +1756,7 @@ xfs_swap_extents(
            (sbp->bs_ctime.tv_nsec != VFS_I(ip)->i_ctime.tv_nsec) ||
            (sbp->bs_mtime.tv_sec != VFS_I(ip)->i_mtime.tv_sec) ||
            (sbp->bs_mtime.tv_nsec != VFS_I(ip)->i_mtime.tv_nsec)) {
-               error = EBUSY;
+               error = -EBUSY;
                goto out_unlock;
        }
 
@@ -1767,7 +1767,7 @@ xfs_swap_extents(
         * until we have switched the extents.
         */
        if (VN_MAPPED(VFS_I(ip))) {
-               error = EBUSY;
+               error = -EBUSY;
                goto out_unlock;
        }
 
index 7a34a1ae655246e6e07fb0b71fabb3bac4c1b6c2..a6dc83e70ece5e3ad7eede2072869ed5599f8e26 100644 (file)
@@ -130,7 +130,7 @@ xfs_buf_get_maps(
        bp->b_maps = kmem_zalloc(map_count * sizeof(struct xfs_buf_map),
                                KM_NOFS);
        if (!bp->b_maps)
-               return ENOMEM;
+               return -ENOMEM;
        return 0;
 }
 
@@ -344,7 +344,7 @@ retry:
                if (unlikely(page == NULL)) {
                        if (flags & XBF_READ_AHEAD) {
                                bp->b_page_count = i;
-                               error = ENOMEM;
+                               error = -ENOMEM;
                                goto out_free_pages;
                        }
 
@@ -465,7 +465,7 @@ _xfs_buf_find(
        eofs = XFS_FSB_TO_BB(btp->bt_mount, btp->bt_mount->m_sb.sb_dblocks);
        if (blkno >= eofs) {
                /*
-                * XXX (dgc): we should really be returning EFSCORRUPTED here,
+                * XXX (dgc): we should really be returning -EFSCORRUPTED here,
                 * but none of the higher level infrastructure supports
                 * returning a specific error on buffer lookup failures.
                 */
@@ -1052,8 +1052,8 @@ xfs_buf_ioerror(
        xfs_buf_t               *bp,
        int                     error)
 {
-       ASSERT(error >= 0 && error <= 0xffff);
-       bp->b_error = (unsigned short)error;
+       ASSERT(error <= 0 && error >= -1000);
+       bp->b_error = error;
        trace_xfs_buf_ioerror(bp, error, _RET_IP_);
 }
 
@@ -1064,7 +1064,7 @@ xfs_buf_ioerror_alert(
 {
        xfs_alert(bp->b_target->bt_mount,
 "metadata I/O error: block 0x%llx (\"%s\") error %d numblks %d",
-               (__uint64_t)XFS_BUF_ADDR(bp), func, bp->b_error, bp->b_length);
+               (__uint64_t)XFS_BUF_ADDR(bp), func, -bp->b_error, bp->b_length);
 }
 
 /*
@@ -1083,7 +1083,7 @@ xfs_bioerror(
        /*
         * No need to wait until the buffer is unpinned, we aren't flushing it.
         */
-       xfs_buf_ioerror(bp, EIO);
+       xfs_buf_ioerror(bp, -EIO);
 
        /*
         * We're calling xfs_buf_ioend, so delete XBF_DONE flag.
@@ -1094,7 +1094,7 @@ xfs_bioerror(
 
        xfs_buf_ioend(bp, 0);
 
-       return EIO;
+       return -EIO;
 }
 
 /*
@@ -1127,13 +1127,13 @@ xfs_bioerror_relse(
                 * There's no reason to mark error for
                 * ASYNC buffers.
                 */
-               xfs_buf_ioerror(bp, EIO);
+               xfs_buf_ioerror(bp, -EIO);
                complete(&bp->b_iowait);
        } else {
                xfs_buf_relse(bp);
        }
 
-       return EIO;
+       return -EIO;
 }
 
 STATIC int
@@ -1199,7 +1199,7 @@ xfs_buf_bio_end_io(
         * buffers that require multiple bios to complete.
         */
        if (!bp->b_error)
-               xfs_buf_ioerror(bp, -error);
+               xfs_buf_ioerror(bp, error);
 
        if (!bp->b_error && xfs_buf_is_vmapped(bp) && (bp->b_flags & XBF_READ))
                invalidate_kernel_vmap_range(bp->b_addr, xfs_buf_vmap_len(bp));
@@ -1286,7 +1286,7 @@ next_chunk:
                 * because the caller (xfs_buf_iorequest) holds a count itself.
                 */
                atomic_dec(&bp->b_io_remaining);
-               xfs_buf_ioerror(bp, EIO);
+               xfs_buf_ioerror(bp, -EIO);
                bio_put(bio);
        }
 
@@ -1628,7 +1628,7 @@ xfs_setsize_buftarg(
                xfs_warn(btp->bt_mount,
                        "Cannot set_blocksize to %u on device %s",
                        sectorsize, name);
-               return EINVAL;
+               return -EINVAL;
        }
 
        /* Set up device logical sector size mask */
index 3a7a5523d3dc8c7df8b2d22bfbb5216b93326a86..c753183900b369b9dbbb377194c3e7b0fc3c9343 100644 (file)
@@ -178,7 +178,7 @@ typedef struct xfs_buf {
        atomic_t                b_io_remaining; /* #outstanding I/O requests */
        unsigned int            b_page_count;   /* size of page array */
        unsigned int            b_offset;       /* page offset in first page */
-       unsigned short          b_error;        /* error code on I/O */
+       int                     b_error;        /* error code on I/O */
        const struct xfs_buf_ops        *b_ops;
 
 #ifdef XFS_BUF_LOCK_TRACKING
index 4654338b03fc5a160247fbc9d0a52ffb26b79cf9..76007deed31fe4455d80956f5debf82faa8baf96 100644 (file)
@@ -488,7 +488,7 @@ xfs_buf_item_unpin(
                xfs_buf_lock(bp);
                xfs_buf_hold(bp);
                bp->b_flags |= XBF_ASYNC;
-               xfs_buf_ioerror(bp, EIO);
+               xfs_buf_ioerror(bp, -EIO);
                XFS_BUF_UNDONE(bp);
                xfs_buf_stale(bp);
                xfs_buf_ioend(bp, 0);
@@ -725,7 +725,7 @@ xfs_buf_item_get_format(
        bip->bli_formats = kmem_zalloc(count * sizeof(struct xfs_buf_log_format),
                                KM_SLEEP);
        if (!bip->bli_formats)
-               return ENOMEM;
+               return -ENOMEM;
        return 0;
 }
 
index 02390739abf75884092f207a611a6ea2eb0c7c59..f1b69edcdf310fc0342c0aff40bacfa2682f13c2 100644 (file)
@@ -95,7 +95,7 @@ xfs_dir2_sf_getdents(
         */
        if (dp->i_d.di_size < offsetof(xfs_dir2_sf_hdr_t, parent)) {
                ASSERT(XFS_FORCED_SHUTDOWN(dp->i_mount));
-               return EIO;
+               return -EIO;
        }
 
        ASSERT(dp->i_df.if_bytes == dp->i_d.di_size);
@@ -677,7 +677,7 @@ xfs_readdir(
        trace_xfs_readdir(dp);
 
        if (XFS_FORCED_SHUTDOWN(dp->i_mount))
-               return EIO;
+               return -EIO;
 
        ASSERT(S_ISDIR(dp->i_d.di_mode));
        XFS_STATS_INC(xs_dir_getdents);
index 3fee16e63f3a7dd7593da189c09504b83a15285c..13d08a1b390e6a756c34927af4797576a809ad77 100644 (file)
@@ -124,7 +124,7 @@ xfs_trim_extents(
                }
 
                trace_xfs_discard_extent(mp, agno, fbno, flen);
-               error = -blkdev_issue_discard(bdev, dbno, dlen, GFP_NOFS, 0);
+               error = blkdev_issue_discard(bdev, dbno, dlen, GFP_NOFS, 0);
                if (error)
                        goto out_del_cursor;
                *blocks_trimmed += flen;
@@ -195,7 +195,7 @@ xfs_ioc_trim(
        end_agno = xfs_daddr_to_agno(mp, end);
 
        for (agno = start_agno; agno <= end_agno; agno++) {
-               error = -xfs_trim_extents(mp, agno, start, end, minlen,
+               error = xfs_trim_extents(mp, agno, start, end, minlen,
                                          &blocks_trimmed);
                if (error)
                        last_error = error;
@@ -222,11 +222,11 @@ xfs_discard_extents(
                trace_xfs_discard_extent(mp, busyp->agno, busyp->bno,
                                         busyp->length);
 
-               error = -blkdev_issue_discard(mp->m_ddev_targp->bt_bdev,
+               error = blkdev_issue_discard(mp->m_ddev_targp->bt_bdev,
                                XFS_AGB_TO_DADDR(mp, busyp->agno, busyp->bno),
                                XFS_FSB_TO_BB(mp, busyp->length),
                                GFP_NOFS, 0);
-               if (error && error != EOPNOTSUPP) {
+               if (error && error != -EOPNOTSUPP) {
                        xfs_info(mp,
         "discard failed for extent [0x%llu,%u], error %d",
                                 (unsigned long long)busyp->bno,
index 3ee24268618133c0342188395db5e25228309f58..8a44a79f49afa35dcd8a9e6609410b2ae945ba80 100644 (file)
@@ -327,7 +327,7 @@ xfs_qm_dqalloc(
         */
        if (!xfs_this_quota_on(dqp->q_mount, dqp->dq_flags)) {
                xfs_iunlock(quotip, XFS_ILOCK_EXCL);
-               return ESRCH;
+               return -ESRCH;
        }
 
        xfs_trans_ijoin(tp, quotip, XFS_ILOCK_EXCL);
@@ -354,7 +354,7 @@ xfs_qm_dqalloc(
                               mp->m_quotainfo->qi_dqchunklen,
                               0);
        if (!bp) {
-               error = ENOMEM;
+               error = -ENOMEM;
                goto error1;
        }
        bp->b_ops = &xfs_dquot_buf_ops;
@@ -442,7 +442,7 @@ xfs_qm_dqrepair(
                if (error) {
                        /* repair failed, we're screwed */
                        xfs_trans_brelse(tp, *bpp);
-                       return EIO;
+                       return -EIO;
                }
        }
 
@@ -480,7 +480,7 @@ xfs_qm_dqtobp(
                 * didn't have the quota inode lock.
                 */
                xfs_iunlock(quotip, lock_mode);
-               return ESRCH;
+               return -ESRCH;
        }
 
        /*
@@ -508,7 +508,7 @@ xfs_qm_dqtobp(
                 * We don't allocate unless we're asked to
                 */
                if (!(flags & XFS_QMOPT_DQALLOC))
-                       return ENOENT;
+                       return -ENOENT;
 
                ASSERT(tp);
                error = xfs_qm_dqalloc(tpp, mp, dqp, quotip,
@@ -530,7 +530,7 @@ xfs_qm_dqtobp(
                                           mp->m_quotainfo->qi_dqchunklen,
                                           0, &bp, &xfs_dquot_buf_ops);
 
-               if (error == EFSCORRUPTED && (flags & XFS_QMOPT_DQREPAIR)) {
+               if (error == -EFSCORRUPTED && (flags & XFS_QMOPT_DQREPAIR)) {
                        xfs_dqid_t firstid = (xfs_dqid_t)map.br_startoff *
                                                mp->m_quotainfo->qi_dqperchunk;
                        ASSERT(bp == NULL);
@@ -715,7 +715,7 @@ xfs_qm_dqget(
        if ((! XFS_IS_UQUOTA_ON(mp) && type == XFS_DQ_USER) ||
            (! XFS_IS_PQUOTA_ON(mp) && type == XFS_DQ_PROJ) ||
            (! XFS_IS_GQUOTA_ON(mp) && type == XFS_DQ_GROUP)) {
-               return ESRCH;
+               return -ESRCH;
        }
 
 #ifdef DEBUG
@@ -723,7 +723,7 @@ xfs_qm_dqget(
                if ((xfs_dqerror_target == mp->m_ddev_targp) &&
                    (xfs_dqreq_num++ % xfs_dqerror_mod) == 0) {
                        xfs_debug(mp, "Returning error in dqget");
-                       return EIO;
+                       return -EIO;
                }
        }
 
@@ -796,14 +796,14 @@ restart:
                } else {
                        /* inode stays locked on return */
                        xfs_qm_dqdestroy(dqp);
-                       return ESRCH;
+                       return -ESRCH;
                }
        }
 
        mutex_lock(&qi->qi_tree_lock);
-       error = -radix_tree_insert(tree, id, dqp);
+       error = radix_tree_insert(tree, id, dqp);
        if (unlikely(error)) {
-               WARN_ON(error != EEXIST);
+               WARN_ON(error != -EEXIST);
 
                /*
                 * Duplicate found. Just throw away the new dquot and start
@@ -966,7 +966,7 @@ xfs_qm_dqflush(
                                             SHUTDOWN_CORRUPT_INCORE);
                else
                        spin_unlock(&mp->m_ail->xa_lock);
-               error = EIO;
+               error = -EIO;
                goto out_unlock;
        }
 
@@ -992,7 +992,7 @@ xfs_qm_dqflush(
                xfs_buf_relse(bp);
                xfs_dqfunlock(dqp);
                xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
-               return EIO;
+               return -EIO;
        }
 
        /* This is the only portion of data that needs to persist */
@@ -1045,7 +1045,7 @@ xfs_qm_dqflush(
 
 out_unlock:
        xfs_dqfunlock(dqp);
-       return EIO;
+       return -EIO;
 }
 
 /*
index 14f98c2f0daf723bc83e992cdae7ffda67b23d96..b92fd7bc49e358159eff5ab24db6fd6a78be2ced 100644 (file)
@@ -167,7 +167,7 @@ xfs_verifier_error(
        struct xfs_mount *mp = bp->b_target->bt_mount;
 
        xfs_alert(mp, "Metadata %s detected at %pF, block 0x%llx",
-                 bp->b_error == EFSBADCRC ? "CRC error" : "corruption",
+                 bp->b_error == -EFSBADCRC ? "CRC error" : "corruption",
                  __return_address, bp->b_bn);
 
        xfs_alert(mp, "Unmount and run xfs_repair");
index a2b5b4cfd22861003497b2105a4e692659fb8457..279a76e52791fcee2bb8d40b4724231dc35d92bb 100644 (file)
@@ -47,7 +47,7 @@ extern void xfs_verifier_error(struct xfs_buf *bp);
                if (unlikely(!fs_is_ok)) { \
                        XFS_ERROR_REPORT("XFS_WANT_CORRUPTED_GOTO", \
                                         XFS_ERRLEVEL_LOW, NULL); \
-                       error = EFSCORRUPTED; \
+                       error = -EFSCORRUPTED; \
                        goto l; \
                } \
        }
@@ -59,7 +59,7 @@ extern void xfs_verifier_error(struct xfs_buf *bp);
                if (unlikely(!fs_is_ok)) { \
                        XFS_ERROR_REPORT("XFS_WANT_CORRUPTED_RETURN", \
                                         XFS_ERRLEVEL_LOW, NULL); \
-                       return EFSCORRUPTED; \
+                       return -EFSCORRUPTED; \
                } \
        }
 
index 753e467aa1a5991d0175087284ff9cde35591c40..5a6bd5d8779ab0029818c5880b15c1b260fb37fb 100644 (file)
@@ -147,9 +147,9 @@ xfs_nfs_get_inode(
                 * We don't use ESTALE directly down the chain to not
                 * confuse applications using bulkstat that expect EINVAL.
                 */
-               if (error == EINVAL || error == ENOENT)
-                       error = ESTALE;
-               return ERR_PTR(-error);
+               if (error == -EINVAL || error == -ENOENT)
+                       error = -ESTALE;
+               return ERR_PTR(error);
        }
 
        if (ip->i_d.di_gen != generation) {
@@ -217,7 +217,7 @@ xfs_fs_get_parent(
 
        error = xfs_lookup(XFS_I(child->d_inode), &xfs_name_dotdot, &cip, NULL);
        if (unlikely(error))
-               return ERR_PTR(-error);
+               return ERR_PTR(error);
 
        return d_obtain_alias(VFS_I(cip));
 }
@@ -237,7 +237,7 @@ xfs_fs_nfs_commit_metadata(
 
        if (!lsn)
                return 0;
-       return -_xfs_log_force_lsn(mp, lsn, XFS_LOG_SYNC, NULL);
+       return _xfs_log_force_lsn(mp, lsn, XFS_LOG_SYNC, NULL);
 }
 
 const struct export_operations xfs_export_operations = {
index fb7a4c1ce1c537255294d66e79639699658544b1..c4327419dc5cbc5f3b0e33f00ae6a01afd24e300 100644 (file)
@@ -298,7 +298,7 @@ xfs_efi_copy_format(xfs_log_iovec_t *buf, xfs_efi_log_format_t *dst_efi_fmt)
                }
                return 0;
        }
-       return EFSCORRUPTED;
+       return -EFSCORRUPTED;
 }
 
 /*
index 754caa0e8ef2fa297944a65dc38e111976176714..181605da08e4b84b1b11b25c76efb1e61271f1b2 100644 (file)
@@ -155,7 +155,7 @@ xfs_dir_fsync(
 
        if (!lsn)
                return 0;
-       return -_xfs_log_force_lsn(mp, lsn, XFS_LOG_SYNC, NULL);
+       return _xfs_log_force_lsn(mp, lsn, XFS_LOG_SYNC, NULL);
 }
 
 STATIC int
@@ -225,7 +225,7 @@ xfs_file_fsync(
            !log_flushed)
                xfs_blkdev_issue_flush(mp->m_ddev_targp);
 
-       return -error;
+       return error;
 }
 
 STATIC ssize_t
@@ -524,7 +524,7 @@ restart:
                        xfs_rw_ilock(ip, *iolock);
                        goto restart;
                }
-               error = -xfs_zero_eof(ip, *pos, i_size_read(inode));
+               error = xfs_zero_eof(ip, *pos, i_size_read(inode));
                if (error)
                        return error;
        }
@@ -772,7 +772,7 @@ xfs_file_fallocate(
                unsigned blksize_mask = (1 << inode->i_blkbits) - 1;
 
                if (offset & blksize_mask || len & blksize_mask) {
-                       error = EINVAL;
+                       error = -EINVAL;
                        goto out_unlock;
                }
 
@@ -781,7 +781,7 @@ xfs_file_fallocate(
                 * in which case it is effectively a truncate operation
                 */
                if (offset + len >= i_size_read(inode)) {
-                       error = EINVAL;
+                       error = -EINVAL;
                        goto out_unlock;
                }
 
@@ -794,7 +794,7 @@ xfs_file_fallocate(
                if (!(mode & FALLOC_FL_KEEP_SIZE) &&
                    offset + len > i_size_read(inode)) {
                        new_size = offset + len;
-                       error = -inode_newsize_ok(inode, new_size);
+                       error = inode_newsize_ok(inode, new_size);
                        if (error)
                                goto out_unlock;
                }
@@ -844,7 +844,7 @@ xfs_file_fallocate(
 
 out_unlock:
        xfs_iunlock(ip, XFS_IOLOCK_EXCL);
-       return -error;
+       return error;
 }
 
 
@@ -889,7 +889,7 @@ xfs_file_release(
        struct inode    *inode,
        struct file     *filp)
 {
-       return -xfs_release(XFS_I(inode));
+       return xfs_release(XFS_I(inode));
 }
 
 STATIC int
@@ -918,7 +918,7 @@ xfs_file_readdir(
 
        error = xfs_readdir(ip, ctx, bufsize);
        if (error)
-               return -error;
+               return error;
        return 0;
 }
 
@@ -1184,7 +1184,7 @@ xfs_seek_data(
 
        isize = i_size_read(inode);
        if (start >= isize) {
-               error = ENXIO;
+               error = -ENXIO;
                goto out_unlock;
        }
 
@@ -1206,7 +1206,7 @@ xfs_seek_data(
 
                /* No extents at given offset, must be beyond EOF */
                if (nmap == 0) {
-                       error = ENXIO;
+                       error = -ENXIO;
                        goto out_unlock;
                }
 
@@ -1237,7 +1237,7 @@ xfs_seek_data(
                 * we are reading after EOF if nothing in map[1].
                 */
                if (nmap == 1) {
-                       error = ENXIO;
+                       error = -ENXIO;
                        goto out_unlock;
                }
 
@@ -1250,7 +1250,7 @@ xfs_seek_data(
                fsbno = map[i - 1].br_startoff + map[i - 1].br_blockcount;
                start = XFS_FSB_TO_B(mp, fsbno);
                if (start >= isize) {
-                       error = ENXIO;
+                       error = -ENXIO;
                        goto out_unlock;
                }
        }
@@ -1262,7 +1262,7 @@ out_unlock:
        xfs_iunlock(ip, lock);
 
        if (error)
-               return -error;
+               return error;
        return offset;
 }
 
@@ -1288,7 +1288,7 @@ xfs_seek_hole(
 
        isize = i_size_read(inode);
        if (start >= isize) {
-               error = ENXIO;
+               error = -ENXIO;
                goto out_unlock;
        }
 
@@ -1307,7 +1307,7 @@ xfs_seek_hole(
 
                /* No extents at given offset, must be beyond EOF */
                if (nmap == 0) {
-                       error = ENXIO;
+                       error = -ENXIO;
                        goto out_unlock;
                }
 
@@ -1370,7 +1370,7 @@ out_unlock:
        xfs_iunlock(ip, lock);
 
        if (error)
-               return -error;
+               return error;
        return offset;
 }
 
index 8ec81bed7992149420efd5781cfb12c9596633f5..e92730c1d3ca6d7ba7f32938154d261285f7d1ef 100644 (file)
@@ -258,7 +258,7 @@ next_ag:
        if (*agp == NULLAGNUMBER)
                return 0;
 
-       err = ENOMEM;
+       err = -ENOMEM;
        item = kmem_alloc(sizeof(*item), KM_MAYFAIL);
        if (!item)
                goto out_put_ag;
@@ -268,7 +268,7 @@ next_ag:
 
        err = xfs_mru_cache_insert(mp->m_filestream, ip->i_ino, &item->mru);
        if (err) {
-               if (err == EEXIST)
+               if (err == -EEXIST)
                        err = 0;
                goto out_free_item;
        }
index 4334638b7b83a6bea084cedd9669b3363ad6ece5..f91de1ef05e1024b24e2f13046f828f3be497d15 100644 (file)
@@ -168,7 +168,7 @@ xfs_growfs_data_private(
        nb = in->newblocks;
        pct = in->imaxpct;
        if (nb < mp->m_sb.sb_dblocks || pct < 0 || pct > 100)
-               return EINVAL;
+               return -EINVAL;
        if ((error = xfs_sb_validate_fsb_count(&mp->m_sb, nb)))
                return error;
        dpct = pct - mp->m_sb.sb_imax_pct;
@@ -176,7 +176,7 @@ xfs_growfs_data_private(
                                XFS_FSB_TO_BB(mp, nb) - XFS_FSS_TO_BB(mp, 1),
                                XFS_FSS_TO_BB(mp, 1), 0, NULL);
        if (!bp)
-               return EIO;
+               return -EIO;
        if (bp->b_error) {
                error = bp->b_error;
                xfs_buf_relse(bp);
@@ -191,7 +191,7 @@ xfs_growfs_data_private(
                nagcount--;
                nb = (xfs_rfsblock_t)nagcount * mp->m_sb.sb_agblocks;
                if (nb < mp->m_sb.sb_dblocks)
-                       return EINVAL;
+                       return -EINVAL;
        }
        new = nb - mp->m_sb.sb_dblocks;
        oagcount = mp->m_sb.sb_agcount;
@@ -229,7 +229,7 @@ xfs_growfs_data_private(
                                XFS_FSS_TO_BB(mp, 1), 0,
                                &xfs_agf_buf_ops);
                if (!bp) {
-                       error = ENOMEM;
+                       error = -ENOMEM;
                        goto error0;
                }
 
@@ -270,7 +270,7 @@ xfs_growfs_data_private(
                                XFS_FSS_TO_BB(mp, 1), 0,
                                &xfs_agfl_buf_ops);
                if (!bp) {
-                       error = ENOMEM;
+                       error = -ENOMEM;
                        goto error0;
                }
 
@@ -298,7 +298,7 @@ xfs_growfs_data_private(
                                XFS_FSS_TO_BB(mp, 1), 0,
                                &xfs_agi_buf_ops);
                if (!bp) {
-                       error = ENOMEM;
+                       error = -ENOMEM;
                        goto error0;
                }
 
@@ -336,7 +336,7 @@ xfs_growfs_data_private(
                                &xfs_allocbt_buf_ops);
 
                if (!bp) {
-                       error = ENOMEM;
+                       error = -ENOMEM;
                        goto error0;
                }
 
@@ -365,7 +365,7 @@ xfs_growfs_data_private(
                                BTOBB(mp->m_sb.sb_blocksize), 0,
                                &xfs_allocbt_buf_ops);
                if (!bp) {
-                       error = ENOMEM;
+                       error = -ENOMEM;
                        goto error0;
                }
 
@@ -395,7 +395,7 @@ xfs_growfs_data_private(
                                BTOBB(mp->m_sb.sb_blocksize), 0,
                                &xfs_inobt_buf_ops);
                if (!bp) {
-                       error = ENOMEM;
+                       error = -ENOMEM;
                        goto error0;
                }
 
@@ -420,7 +420,7 @@ xfs_growfs_data_private(
                                BTOBB(mp->m_sb.sb_blocksize), 0,
                                &xfs_inobt_buf_ops);
                        if (!bp) {
-                               error = ENOMEM;
+                               error = -ENOMEM;
                                goto error0;
                        }
 
@@ -531,7 +531,7 @@ xfs_growfs_data_private(
                                bp->b_ops = &xfs_sb_buf_ops;
                                xfs_buf_zero(bp, 0, BBTOB(bp->b_length));
                        } else
-                               error = ENOMEM;
+                               error = -ENOMEM;
                }
 
                /*
@@ -576,17 +576,17 @@ xfs_growfs_log_private(
 
        nb = in->newblocks;
        if (nb < XFS_MIN_LOG_BLOCKS || nb < XFS_B_TO_FSB(mp, XFS_MIN_LOG_BYTES))
-               return EINVAL;
+               return -EINVAL;
        if (nb == mp->m_sb.sb_logblocks &&
            in->isint == (mp->m_sb.sb_logstart != 0))
-               return EINVAL;
+               return -EINVAL;
        /*
         * Moving the log is hard, need new interfaces to sync
         * the log first, hold off all activity while moving it.
         * Can have shorter or longer log in the same space,
         * or transform internal to external log or vice versa.
         */
-       return ENOSYS;
+       return -ENOSYS;
 }
 
 /*
@@ -604,9 +604,9 @@ xfs_growfs_data(
        int error;
 
        if (!capable(CAP_SYS_ADMIN))
-               return EPERM;
+               return -EPERM;
        if (!mutex_trylock(&mp->m_growlock))
-               return EWOULDBLOCK;
+               return -EWOULDBLOCK;
        error = xfs_growfs_data_private(mp, in);
        mutex_unlock(&mp->m_growlock);
        return error;
@@ -620,9 +620,9 @@ xfs_growfs_log(
        int error;
 
        if (!capable(CAP_SYS_ADMIN))
-               return EPERM;
+               return -EPERM;
        if (!mutex_trylock(&mp->m_growlock))
-               return EWOULDBLOCK;
+               return -EWOULDBLOCK;
        error = xfs_growfs_log_private(mp, in);
        mutex_unlock(&mp->m_growlock);
        return error;
@@ -674,7 +674,7 @@ xfs_reserve_blocks(
        /* If inval is null, report current values and return */
        if (inval == (__uint64_t *)NULL) {
                if (!outval)
-                       return EINVAL;
+                       return -EINVAL;
                outval->resblks = mp->m_resblks;
                outval->resblks_avail = mp->m_resblks_avail;
                return 0;
@@ -757,7 +757,7 @@ out:
                int error;
                error = xfs_icsb_modify_counters(mp, XFS_SBS_FDBLOCKS,
                                                 fdblks_delta, 0);
-               if (error == ENOSPC)
+               if (error == -ENOSPC)
                        goto retry;
        }
        return 0;
@@ -818,7 +818,7 @@ xfs_fs_goingdown(
                                SHUTDOWN_FORCE_UMOUNT | SHUTDOWN_LOG_IO_ERROR);
                break;
        default:
-               return EINVAL;
+               return -EINVAL;
        }
 
        return 0;
index f2cc936d713e964262ffee480f249da2e21729eb..08ba4c6e1359dfdc3a836ebd3da799e25e5f26b9 100644 (file)
@@ -158,7 +158,7 @@ xfs_iget_cache_hit(
        if (ip->i_ino != ino) {
                trace_xfs_iget_skip(ip);
                XFS_STATS_INC(xs_ig_frecycle);
-               error = EAGAIN;
+               error = -EAGAIN;
                goto out_error;
        }
 
@@ -176,7 +176,7 @@ xfs_iget_cache_hit(
        if (ip->i_flags & (XFS_INEW|XFS_IRECLAIM)) {
                trace_xfs_iget_skip(ip);
                XFS_STATS_INC(xs_ig_frecycle);
-               error = EAGAIN;
+               error = -EAGAIN;
                goto out_error;
        }
 
@@ -184,7 +184,7 @@ xfs_iget_cache_hit(
         * If lookup is racing with unlink return an error immediately.
         */
        if (ip->i_d.di_mode == 0 && !(flags & XFS_IGET_CREATE)) {
-               error = ENOENT;
+               error = -ENOENT;
                goto out_error;
        }
 
@@ -206,7 +206,7 @@ xfs_iget_cache_hit(
                spin_unlock(&ip->i_flags_lock);
                rcu_read_unlock();
 
-               error = -inode_init_always(mp->m_super, inode);
+               error = inode_init_always(mp->m_super, inode);
                if (error) {
                        /*
                         * Re-initializing the inode failed, and we are in deep
@@ -243,7 +243,7 @@ xfs_iget_cache_hit(
                /* If the VFS inode is being torn down, pause and try again. */
                if (!igrab(inode)) {
                        trace_xfs_iget_skip(ip);
-                       error = EAGAIN;
+                       error = -EAGAIN;
                        goto out_error;
                }
 
@@ -285,7 +285,7 @@ xfs_iget_cache_miss(
 
        ip = xfs_inode_alloc(mp, ino);
        if (!ip)
-               return ENOMEM;
+               return -ENOMEM;
 
        error = xfs_iread(mp, tp, ip, flags);
        if (error)
@@ -294,7 +294,7 @@ xfs_iget_cache_miss(
        trace_xfs_iget_miss(ip);
 
        if ((ip->i_d.di_mode == 0) && !(flags & XFS_IGET_CREATE)) {
-               error = ENOENT;
+               error = -ENOENT;
                goto out_destroy;
        }
 
@@ -305,7 +305,7 @@ xfs_iget_cache_miss(
         * recurse into the file system.
         */
        if (radix_tree_preload(GFP_NOFS)) {
-               error = EAGAIN;
+               error = -EAGAIN;
                goto out_destroy;
        }
 
@@ -341,7 +341,7 @@ xfs_iget_cache_miss(
        if (unlikely(error)) {
                WARN_ON(error != -EEXIST);
                XFS_STATS_INC(xs_ig_dup);
-               error = EAGAIN;
+               error = -EAGAIN;
                goto out_preload_end;
        }
        spin_unlock(&pag->pag_ici_lock);
@@ -408,7 +408,7 @@ xfs_iget(
 
        /* reject inode numbers outside existing AGs */
        if (!ino || XFS_INO_TO_AGNO(mp, ino) >= mp->m_sb.sb_agcount)
-               return EINVAL;
+               return -EINVAL;
 
        /* get the perag structure and ensure that it's inode capable */
        pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, ino));
@@ -445,7 +445,7 @@ again:
        return 0;
 
 out_error_or_again:
-       if (error == EAGAIN) {
+       if (error == -EAGAIN) {
                delay(1);
                goto again;
        }
@@ -489,18 +489,18 @@ xfs_inode_ag_walk_grab(
 
        /* nothing to sync during shutdown */
        if (XFS_FORCED_SHUTDOWN(ip->i_mount))
-               return EFSCORRUPTED;
+               return -EFSCORRUPTED;
 
        /* If we can't grab the inode, it must on it's way to reclaim. */
        if (!igrab(inode))
-               return ENOENT;
+               return -ENOENT;
 
        /* inode is valid */
        return 0;
 
 out_unlock_noent:
        spin_unlock(&ip->i_flags_lock);
-       return ENOENT;
+       return -ENOENT;
 }
 
 STATIC int
@@ -583,16 +583,16 @@ restart:
                                continue;
                        error = execute(batch[i], flags, args);
                        IRELE(batch[i]);
-                       if (error == EAGAIN) {
+                       if (error == -EAGAIN) {
                                skipped++;
                                continue;
                        }
-                       if (error && last_error != EFSCORRUPTED)
+                       if (error && last_error != -EFSCORRUPTED)
                                last_error = error;
                }
 
                /* bail out if the filesystem is corrupted.  */
-               if (error == EFSCORRUPTED)
+               if (error == -EFSCORRUPTED)
                        break;
 
                cond_resched();
@@ -652,7 +652,7 @@ xfs_inode_ag_iterator(
                xfs_perag_put(pag);
                if (error) {
                        last_error = error;
-                       if (error == EFSCORRUPTED)
+                       if (error == -EFSCORRUPTED)
                                break;
                }
        }
@@ -680,7 +680,7 @@ xfs_inode_ag_iterator_tag(
                xfs_perag_put(pag);
                if (error) {
                        last_error = error;
-                       if (error == EFSCORRUPTED)
+                       if (error == -EFSCORRUPTED)
                                break;
                }
        }
@@ -944,7 +944,7 @@ restart:
         * see the stale flag set on the inode.
         */
        error = xfs_iflush(ip, &bp);
-       if (error == EAGAIN) {
+       if (error == -EAGAIN) {
                xfs_iunlock(ip, XFS_ILOCK_EXCL);
                /* backoff longer than in xfs_ifree_cluster */
                delay(2);
@@ -997,7 +997,7 @@ out:
        xfs_iflags_clear(ip, XFS_IRECLAIM);
        xfs_iunlock(ip, XFS_ILOCK_EXCL);
        /*
-        * We could return EAGAIN here to make reclaim rescan the inode tree in
+        * We could return -EAGAIN here to make reclaim rescan the inode tree in
         * a short while. However, this just burns CPU time scanning the tree
         * waiting for IO to complete and the reclaim work never goes back to
         * the idle state. Instead, return 0 to let the next scheduled
@@ -1100,7 +1100,7 @@ restart:
                                if (!batch[i])
                                        continue;
                                error = xfs_reclaim_inode(batch[i], pag, flags);
-                               if (error && last_error != EFSCORRUPTED)
+                               if (error && last_error != -EFSCORRUPTED)
                                        last_error = error;
                        }
 
@@ -1240,7 +1240,7 @@ xfs_inode_free_eofblocks(
        ret = xfs_free_eofblocks(ip->i_mount, ip, true);
 
        /* don't revisit the inode if we're not waiting */
-       if (ret == EAGAIN && !(flags & SYNC_WAIT))
+       if (ret == -EAGAIN && !(flags & SYNC_WAIT))
                ret = 0;
 
        return ret;
index 9cf017b899be9d531e46d6d7b33a3a110c051cb8..6250430d609c9fc9a3d84ac67c00648f3ad2e856 100644 (file)
@@ -72,14 +72,14 @@ xfs_fs_eofblocks_from_user(
        struct xfs_eofblocks            *dst)
 {
        if (src->eof_version != XFS_EOFBLOCKS_VERSION)
-               return EINVAL;
+               return -EINVAL;
 
        if (src->eof_flags & ~XFS_EOF_FLAGS_VALID)
-               return EINVAL;
+               return -EINVAL;
 
        if (memchr_inv(&src->pad32, 0, sizeof(src->pad32)) ||
            memchr_inv(src->pad64, 0, sizeof(src->pad64)))
-               return EINVAL;
+               return -EINVAL;
 
        dst->eof_flags = src->eof_flags;
        dst->eof_prid = src->eof_prid;
@@ -89,14 +89,14 @@ xfs_fs_eofblocks_from_user(
        if (src->eof_flags & XFS_EOF_FLAGS_UID) {
                dst->eof_uid = make_kuid(current_user_ns(), src->eof_uid);
                if (!uid_valid(dst->eof_uid))
-                       return EINVAL;
+                       return -EINVAL;
        }
 
        dst->eof_gid = INVALID_GID;
        if (src->eof_flags & XFS_EOF_FLAGS_GID) {
                dst->eof_gid = make_kgid(current_user_ns(), src->eof_gid);
                if (!gid_valid(dst->eof_gid))
-                       return EINVAL;
+                       return -EINVAL;
        }
        return 0;
 }
index 605e3e1dff28ec96a2ede6a0f4868ccfe8bf827b..1a5e068bc420fa7c218ab14b87fc642938edcf21 100644 (file)
@@ -583,7 +583,7 @@ xfs_lookup(
        trace_xfs_lookup(dp, name);
 
        if (XFS_FORCED_SHUTDOWN(dp->i_mount))
-               return EIO;
+               return -EIO;
 
        lock_mode = xfs_ilock_data_map_shared(dp);
        error = xfs_dir_lookup(NULL, dp, name, &inum, ci_name);
@@ -893,7 +893,7 @@ xfs_dir_ialloc(
        }
        if (!ialloc_context && !ip) {
                *ipp = NULL;
-               return ENOSPC;
+               return -ENOSPC;
        }
 
        /*
@@ -1088,7 +1088,7 @@ xfs_create(
        trace_xfs_create(dp, name);
 
        if (XFS_FORCED_SHUTDOWN(mp))
-               return EIO;
+               return -EIO;
 
        prid = xfs_get_initial_prid(dp);
 
@@ -1125,12 +1125,12 @@ xfs_create(
         */
        tres.tr_logflags = XFS_TRANS_PERM_LOG_RES;
        error = xfs_trans_reserve(tp, &tres, resblks, 0);
-       if (error == ENOSPC) {
+       if (error == -ENOSPC) {
                /* flush outstanding delalloc blocks and retry */
                xfs_flush_inodes(mp);
                error = xfs_trans_reserve(tp, &tres, resblks, 0);
        }
-       if (error == ENOSPC) {
+       if (error == -ENOSPC) {
                /* No space at all so try a "no-allocation" reservation */
                resblks = 0;
                error = xfs_trans_reserve(tp, &tres, 0, 0);
@@ -1165,7 +1165,7 @@ xfs_create(
        error = xfs_dir_ialloc(&tp, dp, mode, is_dir ? 2 : 1, rdev,
                               prid, resblks > 0, &ip, &committed);
        if (error) {
-               if (error == ENOSPC)
+               if (error == -ENOSPC)
                        goto out_trans_cancel;
                goto out_trans_abort;
        }
@@ -1184,7 +1184,7 @@ xfs_create(
                                        &first_block, &free_list, resblks ?
                                        resblks - XFS_IALLOC_SPACE_RES(mp) : 0);
        if (error) {
-               ASSERT(error != ENOSPC);
+               ASSERT(error != -ENOSPC);
                goto out_trans_abort;
        }
        xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
@@ -1274,7 +1274,7 @@ xfs_create_tmpfile(
        uint                    resblks;
 
        if (XFS_FORCED_SHUTDOWN(mp))
-               return EIO;
+               return -EIO;
 
        prid = xfs_get_initial_prid(dp);
 
@@ -1293,7 +1293,7 @@ xfs_create_tmpfile(
 
        tres = &M_RES(mp)->tr_create_tmpfile;
        error = xfs_trans_reserve(tp, tres, resblks, 0);
-       if (error == ENOSPC) {
+       if (error == -ENOSPC) {
                /* No space at all so try a "no-allocation" reservation */
                resblks = 0;
                error = xfs_trans_reserve(tp, tres, 0, 0);
@@ -1311,7 +1311,7 @@ xfs_create_tmpfile(
        error = xfs_dir_ialloc(&tp, dp, mode, 1, 0,
                                prid, resblks > 0, &ip, NULL);
        if (error) {
-               if (error == ENOSPC)
+               if (error == -ENOSPC)
                        goto out_trans_cancel;
                goto out_trans_abort;
        }
@@ -1382,7 +1382,7 @@ xfs_link(
        ASSERT(!S_ISDIR(sip->i_d.di_mode));
 
        if (XFS_FORCED_SHUTDOWN(mp))
-               return EIO;
+               return -EIO;
 
        error = xfs_qm_dqattach(sip, 0);
        if (error)
@@ -1396,7 +1396,7 @@ xfs_link(
        cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
        resblks = XFS_LINK_SPACE_RES(mp, target_name->len);
        error = xfs_trans_reserve(tp, &M_RES(mp)->tr_link, resblks, 0);
-       if (error == ENOSPC) {
+       if (error == -ENOSPC) {
                resblks = 0;
                error = xfs_trans_reserve(tp, &M_RES(mp)->tr_link, 0, 0);
        }
@@ -1417,7 +1417,7 @@ xfs_link(
         */
        if (unlikely((tdp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT) &&
                     (xfs_get_projid(tdp) != xfs_get_projid(sip)))) {
-               error = EXDEV;
+               error = -EXDEV;
                goto error_return;
        }
 
@@ -1636,7 +1636,7 @@ xfs_release(
                if (truncated) {
                        xfs_iflags_clear(ip, XFS_IDIRTY_RELEASE);
                        if (VN_DIRTY(VFS_I(ip)) && ip->i_delayed_blks > 0) {
-                               error = -filemap_flush(VFS_I(ip)->i_mapping);
+                               error = filemap_flush(VFS_I(ip)->i_mapping);
                                if (error)
                                        return error;
                        }
@@ -1673,7 +1673,7 @@ xfs_release(
                        return 0;
 
                error = xfs_free_eofblocks(mp, ip, true);
-               if (error && error != EAGAIN)
+               if (error && error != -EAGAIN)
                        return error;
 
                /* delalloc blocks after truncation means it really is dirty */
@@ -1772,7 +1772,7 @@ xfs_inactive_ifree(
        error = xfs_trans_reserve(tp, &M_RES(mp)->tr_ifree,
                                  XFS_IFREE_SPACE_RES(mp), 0);
        if (error) {
-               if (error == ENOSPC) {
+               if (error == -ENOSPC) {
                        xfs_warn_ratelimited(mp,
                        "Failed to remove inode(s) from unlinked list. "
                        "Please free space, unmount and run xfs_repair.");
@@ -2219,7 +2219,7 @@ xfs_ifree_cluster(
                                        XBF_UNMAPPED);
 
                if (!bp)
-                       return ENOMEM;
+                       return -ENOMEM;
 
                /*
                 * This buffer may not have been correctly initialised as we
@@ -2491,7 +2491,7 @@ xfs_remove(
        trace_xfs_remove(dp, name);
 
        if (XFS_FORCED_SHUTDOWN(mp))
-               return EIO;
+               return -EIO;
 
        error = xfs_qm_dqattach(dp, 0);
        if (error)
@@ -2521,12 +2521,12 @@ xfs_remove(
         */
        resblks = XFS_REMOVE_SPACE_RES(mp);
        error = xfs_trans_reserve(tp, &M_RES(mp)->tr_remove, resblks, 0);
-       if (error == ENOSPC) {
+       if (error == -ENOSPC) {
                resblks = 0;
                error = xfs_trans_reserve(tp, &M_RES(mp)->tr_remove, 0, 0);
        }
        if (error) {
-               ASSERT(error != ENOSPC);
+               ASSERT(error != -ENOSPC);
                cancel_flags = 0;
                goto out_trans_cancel;
        }
@@ -2543,11 +2543,11 @@ xfs_remove(
        if (is_dir) {
                ASSERT(ip->i_d.di_nlink >= 2);
                if (ip->i_d.di_nlink != 2) {
-                       error = ENOTEMPTY;
+                       error = -ENOTEMPTY;
                        goto out_trans_cancel;
                }
                if (!xfs_dir_isempty(ip)) {
-                       error = ENOTEMPTY;
+                       error = -ENOTEMPTY;
                        goto out_trans_cancel;
                }
 
@@ -2582,7 +2582,7 @@ xfs_remove(
        error = xfs_dir_removename(tp, dp, name, ip->i_ino,
                                        &first_block, &free_list, resblks);
        if (error) {
-               ASSERT(error != ENOENT);
+               ASSERT(error != -ENOENT);
                goto out_bmap_cancel;
        }
 
@@ -2702,7 +2702,7 @@ xfs_rename(
        cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
        spaceres = XFS_RENAME_SPACE_RES(mp, target_name->len);
        error = xfs_trans_reserve(tp, &M_RES(mp)->tr_rename, spaceres, 0);
-       if (error == ENOSPC) {
+       if (error == -ENOSPC) {
                spaceres = 0;
                error = xfs_trans_reserve(tp, &M_RES(mp)->tr_rename, 0, 0);
        }
@@ -2747,7 +2747,7 @@ xfs_rename(
         */
        if (unlikely((target_dp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT) &&
                     (xfs_get_projid(target_dp) != xfs_get_projid(src_ip)))) {
-               error = EXDEV;
+               error = -EXDEV;
                goto error_return;
        }
 
@@ -2770,7 +2770,7 @@ xfs_rename(
                error = xfs_dir_createname(tp, target_dp, target_name,
                                                src_ip->i_ino, &first_block,
                                                &free_list, spaceres);
-               if (error == ENOSPC)
+               if (error == -ENOSPC)
                        goto error_return;
                if (error)
                        goto abort_return;
@@ -2795,7 +2795,7 @@ xfs_rename(
                         */
                        if (!(xfs_dir_isempty(target_ip)) ||
                            (target_ip->i_d.di_nlink > 2)) {
-                               error = EEXIST;
+                               error = -EEXIST;
                                goto error_return;
                        }
                }
@@ -2847,7 +2847,7 @@ xfs_rename(
                error = xfs_dir_replace(tp, src_ip, &xfs_name_dotdot,
                                        target_dp->i_ino,
                                        &first_block, &free_list, spaceres);
-               ASSERT(error != EEXIST);
+               ASSERT(error != -EEXIST);
                if (error)
                        goto abort_return;
        }
@@ -3055,7 +3055,7 @@ cluster_corrupt_out:
                if (bp->b_iodone) {
                        XFS_BUF_UNDONE(bp);
                        xfs_buf_stale(bp);
-                       xfs_buf_ioerror(bp, EIO);
+                       xfs_buf_ioerror(bp, -EIO);
                        xfs_buf_ioend(bp, 0);
                } else {
                        xfs_buf_stale(bp);
@@ -3069,7 +3069,7 @@ cluster_corrupt_out:
        xfs_iflush_abort(iq, false);
        kmem_free(ilist);
        xfs_perag_put(pag);
-       return EFSCORRUPTED;
+       return -EFSCORRUPTED;
 }
 
 /*
@@ -3124,7 +3124,7 @@ xfs_iflush(
         * as we wait for an empty AIL as part of the unmount process.
         */
        if (XFS_FORCED_SHUTDOWN(mp)) {
-               error = EIO;
+               error = -EIO;
                goto abort_out;
        }
 
@@ -3167,7 +3167,7 @@ corrupt_out:
        xfs_buf_relse(bp);
        xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
 cluster_corrupt_out:
-       error = EFSCORRUPTED;
+       error = -EFSCORRUPTED;
 abort_out:
        /*
         * Unlocks the flush lock
@@ -3331,5 +3331,5 @@ xfs_iflush_int(
        return 0;
 
 corrupt_out:
-       return EFSCORRUPTED;
+       return -EFSCORRUPTED;
 }
index a640137b357326de1d4df03ac63b9b918ec92588..de5a7be36e603e5525ac5ba3c49264aa7af6d5d1 100644 (file)
@@ -788,5 +788,5 @@ xfs_inode_item_format_convert(
                in_f->ilf_boffset = in_f64->ilf_boffset;
                return 0;
        }
-       return EFSCORRUPTED;
+       return -EFSCORRUPTED;
 }
index 1a1648fbda1c3f16bf00a125cf1a2f22579ad539..30983b8ceaa16072073acc30d14060d3213ec0f4 100644 (file)
@@ -305,7 +305,7 @@ xfs_readlink_by_handle(
                goto out_dput;
        }
 
-       error = -xfs_readlink(XFS_I(dentry->d_inode), link);
+       error = xfs_readlink(XFS_I(dentry->d_inode), link);
        if (error)
                goto out_kfree;
        error = readlink_copy(hreq->ohandle, olen, link);
@@ -330,10 +330,10 @@ xfs_set_dmattrs(
        int             error;
 
        if (!capable(CAP_SYS_ADMIN))
-               return EPERM;
+               return -EPERM;
 
        if (XFS_FORCED_SHUTDOWN(mp))
-               return EIO;
+               return -EIO;
 
        tp = xfs_trans_alloc(mp, XFS_TRANS_SET_DMATTRS);
        error = xfs_trans_reserve(tp, &M_RES(mp)->tr_ichange, 0, 0);
@@ -388,7 +388,7 @@ xfs_fssetdm_by_handle(
                goto out;
        }
 
-       error = -xfs_set_dmattrs(XFS_I(dentry->d_inode), fsd.fsd_dmevmask,
+       error = xfs_set_dmattrs(XFS_I(dentry->d_inode), fsd.fsd_dmevmask,
                                 fsd.fsd_dmstate);
 
  out:
@@ -431,7 +431,7 @@ xfs_attrlist_by_handle(
                goto out_dput;
 
        cursor = (attrlist_cursor_kern_t *)&al_hreq.pos;
-       error = -xfs_attr_list(XFS_I(dentry->d_inode), kbuf, al_hreq.buflen,
+       error = xfs_attr_list(XFS_I(dentry->d_inode), kbuf, al_hreq.buflen,
                                        al_hreq.flags, cursor);
        if (error)
                goto out_kfree;
@@ -455,20 +455,20 @@ xfs_attrmulti_attr_get(
        __uint32_t              flags)
 {
        unsigned char           *kbuf;
-       int                     error = EFAULT;
+       int                     error = -EFAULT;
 
        if (*len > XATTR_SIZE_MAX)
-               return EINVAL;
+               return -EINVAL;
        kbuf = kmem_zalloc_large(*len, KM_SLEEP);
        if (!kbuf)
-               return ENOMEM;
+               return -ENOMEM;
 
        error = xfs_attr_get(XFS_I(inode), name, kbuf, (int *)len, flags);
        if (error)
                goto out_kfree;
 
        if (copy_to_user(ubuf, kbuf, *len))
-               error = EFAULT;
+               error = -EFAULT;
 
 out_kfree:
        kmem_free(kbuf);
@@ -484,20 +484,17 @@ xfs_attrmulti_attr_set(
        __uint32_t              flags)
 {
        unsigned char           *kbuf;
-       int                     error = EFAULT;
 
        if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
-               return EPERM;
+               return -EPERM;
        if (len > XATTR_SIZE_MAX)
-               return EINVAL;
+               return -EINVAL;
 
        kbuf = memdup_user(ubuf, len);
        if (IS_ERR(kbuf))
                return PTR_ERR(kbuf);
 
-       error = xfs_attr_set(XFS_I(inode), name, kbuf, len, flags);
-
-       return error;
+       return xfs_attr_set(XFS_I(inode), name, kbuf, len, flags);
 }
 
 int
@@ -507,7 +504,7 @@ xfs_attrmulti_attr_remove(
        __uint32_t              flags)
 {
        if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
-               return EPERM;
+               return -EPERM;
        return xfs_attr_remove(XFS_I(inode), name, flags);
 }
 
@@ -536,18 +533,18 @@ xfs_attrmulti_by_handle(
        if (IS_ERR(dentry))
                return PTR_ERR(dentry);
 
-       error = E2BIG;
+       error = -E2BIG;
        size = am_hreq.opcount * sizeof(xfs_attr_multiop_t);
        if (!size || size > 16 * PAGE_SIZE)
                goto out_dput;
 
        ops = memdup_user(am_hreq.ops, size);
        if (IS_ERR(ops)) {
-               error = -PTR_ERR(ops);
+               error = PTR_ERR(ops);
                goto out_dput;
        }
 
-       error = ENOMEM;
+       error = -ENOMEM;
        attr_name = kmalloc(MAXNAMELEN, GFP_KERNEL);
        if (!attr_name)
                goto out_kfree_ops;
@@ -557,7 +554,7 @@ xfs_attrmulti_by_handle(
                ops[i].am_error = strncpy_from_user((char *)attr_name,
                                ops[i].am_attrname, MAXNAMELEN);
                if (ops[i].am_error == 0 || ops[i].am_error == MAXNAMELEN)
-                       error = ERANGE;
+                       error = -ERANGE;
                if (ops[i].am_error < 0)
                        break;
 
@@ -588,19 +585,19 @@ xfs_attrmulti_by_handle(
                        mnt_drop_write_file(parfilp);
                        break;
                default:
-                       ops[i].am_error = EINVAL;
+                       ops[i].am_error = -EINVAL;
                }
        }
 
        if (copy_to_user(am_hreq.ops, ops, size))
-               error = EFAULT;
+               error = -EFAULT;
 
        kfree(attr_name);
  out_kfree_ops:
        kfree(ops);
  out_dput:
        dput(dentry);
-       return -error;
+       return error;
 }
 
 int
@@ -652,7 +649,7 @@ xfs_ioc_space(
                bf->l_start += XFS_ISIZE(ip);
                break;
        default:
-               error = EINVAL;
+               error = -EINVAL;
                goto out_unlock;
        }
 
@@ -669,7 +666,7 @@ xfs_ioc_space(
        case XFS_IOC_UNRESVSP:
        case XFS_IOC_UNRESVSP64:
                if (bf->l_len <= 0) {
-                       error = EINVAL;
+                       error = -EINVAL;
                        goto out_unlock;
                }
                break;
@@ -682,7 +679,7 @@ xfs_ioc_space(
            bf->l_start > mp->m_super->s_maxbytes ||
            bf->l_start + bf->l_len < 0 ||
            bf->l_start + bf->l_len >= mp->m_super->s_maxbytes) {
-               error = EINVAL;
+               error = -EINVAL;
                goto out_unlock;
        }
 
@@ -723,7 +720,7 @@ xfs_ioc_space(
                break;
        default:
                ASSERT(0);
-               error = EINVAL;
+               error = -EINVAL;
        }
 
        if (error)
@@ -759,7 +756,7 @@ xfs_ioc_space(
 out_unlock:
        xfs_iunlock(ip, XFS_IOLOCK_EXCL);
        mnt_drop_write_file(filp);
-       return -error;
+       return error;
 }
 
 STATIC int
@@ -807,7 +804,7 @@ xfs_ioc_bulkstat(
                                     &done);
 
        if (error)
-               return -error;
+               return error;
 
        if (bulkreq.ocount != NULL) {
                if (copy_to_user(bulkreq.lastip, &inlast,
@@ -831,7 +828,7 @@ xfs_ioc_fsgeometry_v1(
 
        error = xfs_fs_geometry(mp, &fsgeo, 3);
        if (error)
-               return -error;
+               return error;
 
        /*
         * Caller should have passed an argument of type
@@ -853,7 +850,7 @@ xfs_ioc_fsgeometry(
 
        error = xfs_fs_geometry(mp, &fsgeo, 4);
        if (error)
-               return -error;
+               return error;
 
        if (copy_to_user(arg, &fsgeo, sizeof(fsgeo)))
                return -EFAULT;
@@ -1041,16 +1038,16 @@ xfs_ioctl_setattr(
        trace_xfs_ioctl_setattr(ip);
 
        if (mp->m_flags & XFS_MOUNT_RDONLY)
-               return EROFS;
+               return -EROFS;
        if (XFS_FORCED_SHUTDOWN(mp))
-               return EIO;
+               return -EIO;
 
        /*
         * Disallow 32bit project ids when projid32bit feature is not enabled.
         */
        if ((mask & FSX_PROJID) && (fa->fsx_projid > (__uint16_t)-1) &&
                        !xfs_sb_version_hasprojid32bit(&ip->i_mount->m_sb))
-               return EINVAL;
+               return -EINVAL;
 
        /*
         * If disk quotas is on, we make sure that the dquots do exist on disk,
@@ -1088,7 +1085,7 @@ xfs_ioctl_setattr(
         * CAP_FSETID capability is applicable.
         */
        if (!inode_owner_or_capable(VFS_I(ip))) {
-               code = EPERM;
+               code = -EPERM;
                goto error_return;
        }
 
@@ -1099,7 +1096,7 @@ xfs_ioctl_setattr(
         */
        if (mask & FSX_PROJID) {
                if (current_user_ns() != &init_user_ns) {
-                       code = EINVAL;
+                       code = -EINVAL;
                        goto error_return;
                }
 
@@ -1122,7 +1119,7 @@ xfs_ioctl_setattr(
                if (ip->i_d.di_nextents &&
                    ((ip->i_d.di_extsize << mp->m_sb.sb_blocklog) !=
                     fa->fsx_extsize)) {
-                       code = EINVAL;  /* EFBIG? */
+                       code = -EINVAL; /* EFBIG? */
                        goto error_return;
                }
 
@@ -1141,7 +1138,7 @@ xfs_ioctl_setattr(
 
                        extsize_fsb = XFS_B_TO_FSB(mp, fa->fsx_extsize);
                        if (extsize_fsb > MAXEXTLEN) {
-                               code = EINVAL;
+                               code = -EINVAL;
                                goto error_return;
                        }
 
@@ -1153,13 +1150,13 @@ xfs_ioctl_setattr(
                        } else {
                                size = mp->m_sb.sb_blocksize;
                                if (extsize_fsb > mp->m_sb.sb_agblocks / 2) {
-                                       code = EINVAL;
+                                       code = -EINVAL;
                                        goto error_return;
                                }
                        }
 
                        if (fa->fsx_extsize % size) {
-                               code = EINVAL;
+                               code = -EINVAL;
                                goto error_return;
                        }
                }
@@ -1173,7 +1170,7 @@ xfs_ioctl_setattr(
                if ((ip->i_d.di_nextents || ip->i_delayed_blks) &&
                    (XFS_IS_REALTIME_INODE(ip)) !=
                    (fa->fsx_xflags & XFS_XFLAG_REALTIME)) {
-                       code = EINVAL;  /* EFBIG? */
+                       code = -EINVAL; /* EFBIG? */
                        goto error_return;
                }
 
@@ -1184,7 +1181,7 @@ xfs_ioctl_setattr(
                        if ((mp->m_sb.sb_rblocks == 0) ||
                            (mp->m_sb.sb_rextsize == 0) ||
                            (ip->i_d.di_extsize % mp->m_sb.sb_rextsize)) {
-                               code = EINVAL;
+                               code = -EINVAL;
                                goto error_return;
                        }
                }
@@ -1198,7 +1195,7 @@ xfs_ioctl_setattr(
                     (fa->fsx_xflags &
                                (XFS_XFLAG_IMMUTABLE | XFS_XFLAG_APPEND))) &&
                    !capable(CAP_LINUX_IMMUTABLE)) {
-                       code = EPERM;
+                       code = -EPERM;
                        goto error_return;
                }
        }
@@ -1301,7 +1298,7 @@ xfs_ioc_fssetxattr(
                return error;
        error = xfs_ioctl_setattr(ip, &fa, mask);
        mnt_drop_write_file(filp);
-       return -error;
+       return error;
 }
 
 STATIC int
@@ -1346,7 +1343,7 @@ xfs_ioc_setxflags(
                return error;
        error = xfs_ioctl_setattr(ip, &fa, mask);
        mnt_drop_write_file(filp);
-       return -error;
+       return error;
 }
 
 STATIC int
@@ -1356,7 +1353,7 @@ xfs_getbmap_format(void **ap, struct getbmapx *bmv, int *full)
 
        /* copy only getbmap portion (not getbmapx) */
        if (copy_to_user(base, bmv, sizeof(struct getbmap)))
-               return EFAULT;
+               return -EFAULT;
 
        *ap += sizeof(struct getbmap);
        return 0;
@@ -1385,7 +1382,7 @@ xfs_ioc_getbmap(
        error = xfs_getbmap(ip, &bmx, xfs_getbmap_format,
                            (struct getbmap *)arg+1);
        if (error)
-               return -error;
+               return error;
 
        /* copy back header - only size of getbmap */
        if (copy_to_user(arg, &bmx, sizeof(struct getbmap)))
@@ -1399,7 +1396,7 @@ xfs_getbmapx_format(void **ap, struct getbmapx *bmv, int *full)
        struct getbmapx __user  *base = *ap;
 
        if (copy_to_user(base, bmv, sizeof(struct getbmapx)))
-               return EFAULT;
+               return -EFAULT;
 
        *ap += sizeof(struct getbmapx);
        return 0;
@@ -1425,7 +1422,7 @@ xfs_ioc_getbmapx(
        error = xfs_getbmap(ip, &bmx, xfs_getbmapx_format,
                            (struct getbmapx *)arg+1);
        if (error)
-               return -error;
+               return error;
 
        /* copy back header */
        if (copy_to_user(arg, &bmx, sizeof(struct getbmapx)))
@@ -1445,33 +1442,33 @@ xfs_ioc_swapext(
        /* Pull information for the target fd */
        f = fdget((int)sxp->sx_fdtarget);
        if (!f.file) {
-               error = EINVAL;
+               error = -EINVAL;
                goto out;
        }
 
        if (!(f.file->f_mode & FMODE_WRITE) ||
            !(f.file->f_mode & FMODE_READ) ||
            (f.file->f_flags & O_APPEND)) {
-               error = EBADF;
+               error = -EBADF;
                goto out_put_file;
        }
 
        tmp = fdget((int)sxp->sx_fdtmp);
        if (!tmp.file) {
-               error = EINVAL;
+               error = -EINVAL;
                goto out_put_file;
        }
 
        if (!(tmp.file->f_mode & FMODE_WRITE) ||
            !(tmp.file->f_mode & FMODE_READ) ||
            (tmp.file->f_flags & O_APPEND)) {
-               error = EBADF;
+               error = -EBADF;
                goto out_put_tmp_file;
        }
 
        if (IS_SWAPFILE(file_inode(f.file)) ||
            IS_SWAPFILE(file_inode(tmp.file))) {
-               error = EINVAL;
+               error = -EINVAL;
                goto out_put_tmp_file;
        }
 
@@ -1479,17 +1476,17 @@ xfs_ioc_swapext(
        tip = XFS_I(file_inode(tmp.file));
 
        if (ip->i_mount != tip->i_mount) {
-               error = EINVAL;
+               error = -EINVAL;
                goto out_put_tmp_file;
        }
 
        if (ip->i_ino == tip->i_ino) {
-               error = EINVAL;
+               error = -EINVAL;
                goto out_put_tmp_file;
        }
 
        if (XFS_FORCED_SHUTDOWN(ip->i_mount)) {
-               error = EIO;
+               error = -EIO;
                goto out_put_tmp_file;
        }
 
@@ -1597,7 +1594,7 @@ xfs_file_ioctl(
                error = xfs_set_dmattrs(ip, dmi.fsd_dmevmask,
                                dmi.fsd_dmstate);
                mnt_drop_write_file(filp);
-               return -error;
+               return error;
        }
 
        case XFS_IOC_GETBMAP:
@@ -1649,7 +1646,7 @@ xfs_file_ioctl(
                        return error;
                error = xfs_ioc_swapext(&sxp);
                mnt_drop_write_file(filp);
-               return -error;
+               return error;
        }
 
        case XFS_IOC_FSCOUNTS: {
@@ -1657,7 +1654,7 @@ xfs_file_ioctl(
 
                error = xfs_fs_counts(mp, &out);
                if (error)
-                       return -error;
+                       return error;
 
                if (copy_to_user(arg, &out, sizeof(out)))
                        return -EFAULT;
@@ -1686,7 +1683,7 @@ xfs_file_ioctl(
                error = xfs_reserve_blocks(mp, &in, &inout);
                mnt_drop_write_file(filp);
                if (error)
-                       return -error;
+                       return error;
 
                if (copy_to_user(arg, &inout, sizeof(inout)))
                        return -EFAULT;
@@ -1701,7 +1698,7 @@ xfs_file_ioctl(
 
                error = xfs_reserve_blocks(mp, NULL, &out);
                if (error)
-                       return -error;
+                       return error;
 
                if (copy_to_user(arg, &out, sizeof(out)))
                        return -EFAULT;
@@ -1720,7 +1717,7 @@ xfs_file_ioctl(
                        return error;
                error = xfs_growfs_data(mp, &in);
                mnt_drop_write_file(filp);
-               return -error;
+               return error;
        }
 
        case XFS_IOC_FSGROWFSLOG: {
@@ -1734,7 +1731,7 @@ xfs_file_ioctl(
                        return error;
                error = xfs_growfs_log(mp, &in);
                mnt_drop_write_file(filp);
-               return -error;
+               return error;
        }
 
        case XFS_IOC_FSGROWFSRT: {
@@ -1748,7 +1745,7 @@ xfs_file_ioctl(
                        return error;
                error = xfs_growfs_rt(mp, &in);
                mnt_drop_write_file(filp);
-               return -error;
+               return error;
        }
 
        case XFS_IOC_GOINGDOWN: {
@@ -1760,8 +1757,7 @@ xfs_file_ioctl(
                if (get_user(in, (__uint32_t __user *)arg))
                        return -EFAULT;
 
-               error = xfs_fs_goingdown(mp, in);
-               return -error;
+               return xfs_fs_goingdown(mp, in);
        }
 
        case XFS_IOC_ERROR_INJECTION: {
@@ -1773,16 +1769,14 @@ xfs_file_ioctl(
                if (copy_from_user(&in, arg, sizeof(in)))
                        return -EFAULT;
 
-               error = xfs_errortag_add(in.errtag, mp);
-               return -error;
+               return xfs_errortag_add(in.errtag, mp);
        }
 
        case XFS_IOC_ERROR_CLEARALL:
                if (!capable(CAP_SYS_ADMIN))
                        return -EPERM;
 
-               error = xfs_errortag_clearall(mp, 1);
-               return -error;
+               return xfs_errortag_clearall(mp, 1);
 
        case XFS_IOC_FREE_EOFBLOCKS: {
                struct xfs_fs_eofblocks eofb;
@@ -1799,9 +1793,9 @@ xfs_file_ioctl(
 
                error = xfs_fs_eofblocks_from_user(&eofb, &keofb);
                if (error)
-                       return -error;
+                       return error;
 
-               return -xfs_icache_free_eofblocks(mp, &keofb);
+               return xfs_icache_free_eofblocks(mp, &keofb);
        }
 
        default:
index 357963ec9ba6e43af52d59535abd3ffae5e8683e..e65ea67e3ae3005c37990589bac0d7942fc98eff 100644 (file)
@@ -70,7 +70,7 @@ xfs_compat_ioc_fsgeometry_v1(
 
        error = xfs_fs_geometry(mp, &fsgeo, 3);
        if (error)
-               return -error;
+               return error;
        /* The 32-bit variant simply has some padding at the end */
        if (copy_to_user(arg32, &fsgeo, sizeof(struct compat_xfs_fsop_geom_v1)))
                return -EFAULT;
@@ -195,7 +195,7 @@ xfs_bulkstat_one_fmt_compat(
        compat_xfs_bstat_t      __user *p32 = ubuffer;
 
        if (ubsize < sizeof(*p32))
-               return ENOMEM;
+               return -ENOMEM;
 
        if (put_user(buffer->bs_ino,      &p32->bs_ino)         ||
            put_user(buffer->bs_mode,     &p32->bs_mode)        ||
@@ -218,7 +218,7 @@ xfs_bulkstat_one_fmt_compat(
            put_user(buffer->bs_dmevmask, &p32->bs_dmevmask)    ||
            put_user(buffer->bs_dmstate,  &p32->bs_dmstate)     ||
            put_user(buffer->bs_aextents, &p32->bs_aextents))
-               return EFAULT;
+               return -EFAULT;
        if (ubused)
                *ubused = sizeof(*p32);
        return 0;
@@ -294,9 +294,9 @@ xfs_compat_ioc_bulkstat(
                        xfs_bulkstat_one_compat, sizeof(compat_xfs_bstat_t),
                        bulkreq.ubuffer, &done);
        } else
-               error = EINVAL;
+               error = -EINVAL;
        if (error)
-               return -error;
+               return error;
 
        if (bulkreq.ocount != NULL) {
                if (copy_to_user(bulkreq.lastip, &inlast,
@@ -376,7 +376,7 @@ xfs_compat_attrlist_by_handle(
                goto out_dput;
 
        cursor = (attrlist_cursor_kern_t *)&al_hreq.pos;
-       error = -xfs_attr_list(XFS_I(dentry->d_inode), kbuf, al_hreq.buflen,
+       error = xfs_attr_list(XFS_I(dentry->d_inode), kbuf, al_hreq.buflen,
                                        al_hreq.flags, cursor);
        if (error)
                goto out_kfree;
@@ -417,7 +417,7 @@ xfs_compat_attrmulti_by_handle(
        if (IS_ERR(dentry))
                return PTR_ERR(dentry);
 
-       error = E2BIG;
+       error = -E2BIG;
        size = am_hreq.opcount * sizeof(compat_xfs_attr_multiop_t);
        if (!size || size > 16 * PAGE_SIZE)
                goto out_dput;
@@ -428,7 +428,7 @@ xfs_compat_attrmulti_by_handle(
                goto out_dput;
        }
 
-       error = ENOMEM;
+       error = -ENOMEM;
        attr_name = kmalloc(MAXNAMELEN, GFP_KERNEL);
        if (!attr_name)
                goto out_kfree_ops;
@@ -439,7 +439,7 @@ xfs_compat_attrmulti_by_handle(
                                compat_ptr(ops[i].am_attrname),
                                MAXNAMELEN);
                if (ops[i].am_error == 0 || ops[i].am_error == MAXNAMELEN)
-                       error = ERANGE;
+                       error = -ERANGE;
                if (ops[i].am_error < 0)
                        break;
 
@@ -470,19 +470,19 @@ xfs_compat_attrmulti_by_handle(
                        mnt_drop_write_file(parfilp);
                        break;
                default:
-                       ops[i].am_error = EINVAL;
+                       ops[i].am_error = -EINVAL;
                }
        }
 
        if (copy_to_user(compat_ptr(am_hreq.ops), ops, size))
-               error = EFAULT;
+               error = -EFAULT;
 
        kfree(attr_name);
  out_kfree_ops:
        kfree(ops);
  out_dput:
        dput(dentry);
-       return -error;
+       return error;
 }
 
 STATIC int
@@ -515,7 +515,7 @@ xfs_compat_fssetdm_by_handle(
                goto out;
        }
 
-       error = -xfs_set_dmattrs(XFS_I(dentry->d_inode), fsd.fsd_dmevmask,
+       error = xfs_set_dmattrs(XFS_I(dentry->d_inode), fsd.fsd_dmevmask,
                                 fsd.fsd_dmstate);
 
 out:
@@ -604,7 +604,7 @@ xfs_file_compat_ioctl(
                        return error;
                error = xfs_growfs_data(mp, &in);
                mnt_drop_write_file(filp);
-               return -error;
+               return error;
        }
        case XFS_IOC_FSGROWFSRT_32: {
                struct xfs_growfs_rt    in;
@@ -616,7 +616,7 @@ xfs_file_compat_ioctl(
                        return error;
                error = xfs_growfs_rt(mp, &in);
                mnt_drop_write_file(filp);
-               return -error;
+               return error;
        }
 #endif
        /* long changes size, but xfs only copiese out 32 bits */
@@ -639,7 +639,7 @@ xfs_file_compat_ioctl(
                        return error;
                error = xfs_ioc_swapext(&sxp);
                mnt_drop_write_file(filp);
-               return -error;
+               return error;
        }
        case XFS_IOC_FSBULKSTAT_32:
        case XFS_IOC_FSBULKSTAT_SINGLE_32:
index c6d603080e5baaecffd3c0eaf2345587845f56ef..923c044bd26f04efbbcde012c1d89e58cd40b697 100644 (file)
@@ -110,7 +110,7 @@ xfs_alert_fsblock_zero(
                (unsigned long long)imap->br_startoff,
                (unsigned long long)imap->br_blockcount,
                imap->br_state);
-       return EFSCORRUPTED;
+       return -EFSCORRUPTED;
 }
 
 int
@@ -225,7 +225,7 @@ xfs_iomap_write_direct(
         * Copy any maps to caller's array and return any error.
         */
        if (nimaps == 0) {
-               error = ENOSPC;
+               error = -ENOSPC;
                goto out_unlock;
        }
 
@@ -596,8 +596,8 @@ retry:
                                imap, &nimaps, XFS_BMAPI_ENTIRE);
        switch (error) {
        case 0:
-       case ENOSPC:
-       case EDQUOT:
+       case -ENOSPC:
+       case -EDQUOT:
                break;
        default:
                return error;
@@ -614,7 +614,7 @@ retry:
                        error = 0;
                        goto retry;
                }
-               return error ? error : ENOSPC;
+               return error ? error : -ENOSPC;
        }
 
        if (!(imap[0].br_startblock || XFS_IS_REALTIME_INODE(ip)))
@@ -739,7 +739,7 @@ xfs_iomap_write_allocate(
                        if ((map_start_fsb + count_fsb) > last_block) {
                                count_fsb = last_block - map_start_fsb;
                                if (count_fsb == 0) {
-                                       error = EAGAIN;
+                                       error = -EAGAIN;
                                        goto trans_cancel;
                                }
                        }
index 6bdc1fc8f95052bac572efb37002414536dca8b8..d75621ae3e3682db1a9787b53939124fe51c9df1 100644 (file)
@@ -72,7 +72,7 @@ xfs_initxattrs(
        int                     error = 0;
 
        for (xattr = xattr_array; xattr->name != NULL; xattr++) {
-               error = -xfs_attr_set(ip, xattr->name, xattr->value,
+               error = xfs_attr_set(ip, xattr->name, xattr->value,
                                      xattr->value_len, ATTR_SECURE);
                if (error < 0)
                        break;
@@ -93,7 +93,7 @@ xfs_init_security(
        struct inode    *dir,
        const struct qstr *qstr)
 {
-       return -security_inode_init_security(inode, dir, qstr,
+       return security_inode_init_security(inode, dir, qstr,
                                             &xfs_initxattrs, NULL);
 }
 
@@ -173,12 +173,12 @@ xfs_generic_create(
 
 #ifdef CONFIG_XFS_POSIX_ACL
        if (default_acl) {
-               error = -xfs_set_acl(inode, default_acl, ACL_TYPE_DEFAULT);
+               error = xfs_set_acl(inode, default_acl, ACL_TYPE_DEFAULT);
                if (error)
                        goto out_cleanup_inode;
        }
        if (acl) {
-               error = -xfs_set_acl(inode, acl, ACL_TYPE_ACCESS);
+               error = xfs_set_acl(inode, acl, ACL_TYPE_ACCESS);
                if (error)
                        goto out_cleanup_inode;
        }
@@ -194,7 +194,7 @@ xfs_generic_create(
                posix_acl_release(default_acl);
        if (acl)
                posix_acl_release(acl);
-       return -error;
+       return error;
 
  out_cleanup_inode:
        if (!tmpfile)
@@ -248,8 +248,8 @@ xfs_vn_lookup(
        xfs_dentry_to_name(&name, dentry, 0);
        error = xfs_lookup(XFS_I(dir), &name, &cip, NULL);
        if (unlikely(error)) {
-               if (unlikely(error != ENOENT))
-                       return ERR_PTR(-error);
+               if (unlikely(error != -ENOENT))
+                       return ERR_PTR(error);
                d_add(dentry, NULL);
                return NULL;
        }
@@ -275,8 +275,8 @@ xfs_vn_ci_lookup(
        xfs_dentry_to_name(&xname, dentry, 0);
        error = xfs_lookup(XFS_I(dir), &xname, &ip, &ci_name);
        if (unlikely(error)) {
-               if (unlikely(error != ENOENT))
-                       return ERR_PTR(-error);
+               if (unlikely(error != -ENOENT))
+                       return ERR_PTR(error);
                /*
                 * call d_add(dentry, NULL) here when d_drop_negative_children
                 * is called in xfs_vn_mknod (ie. allow negative dentries
@@ -311,7 +311,7 @@ xfs_vn_link(
 
        error = xfs_link(XFS_I(dir), XFS_I(inode), &name);
        if (unlikely(error))
-               return -error;
+               return error;
 
        ihold(inode);
        d_instantiate(dentry, inode);
@@ -328,7 +328,7 @@ xfs_vn_unlink(
 
        xfs_dentry_to_name(&name, dentry, 0);
 
-       error = -xfs_remove(XFS_I(dir), &name, XFS_I(dentry->d_inode));
+       error = xfs_remove(XFS_I(dir), &name, XFS_I(dentry->d_inode));
        if (error)
                return error;
 
@@ -375,7 +375,7 @@ xfs_vn_symlink(
        xfs_cleanup_inode(dir, inode, dentry);
        iput(inode);
  out:
-       return -error;
+       return error;
 }
 
 STATIC int
@@ -392,8 +392,8 @@ xfs_vn_rename(
        xfs_dentry_to_name(&oname, odentry, 0);
        xfs_dentry_to_name(&nname, ndentry, odentry->d_inode->i_mode);
 
-       return -xfs_rename(XFS_I(odir), &oname, XFS_I(odentry->d_inode),
-                          XFS_I(ndir), &nname, new_inode ?
+       return xfs_rename(XFS_I(odir), &oname, XFS_I(odentry->d_inode),
+                         XFS_I(ndir), &nname, new_inode ?
                                                XFS_I(new_inode) : NULL);
 }
 
@@ -414,7 +414,7 @@ xfs_vn_follow_link(
        if (!link)
                goto out_err;
 
-       error = -xfs_readlink(XFS_I(dentry->d_inode), link);
+       error = xfs_readlink(XFS_I(dentry->d_inode), link);
        if (unlikely(error))
                goto out_kfree;
 
@@ -546,12 +546,12 @@ xfs_setattr_nonsize(
        /* If acls are being inherited, we already have this checked */
        if (!(flags & XFS_ATTR_NOACL)) {
                if (mp->m_flags & XFS_MOUNT_RDONLY)
-                       return EROFS;
+                       return -EROFS;
 
                if (XFS_FORCED_SHUTDOWN(mp))
-                       return EIO;
+                       return -EIO;
 
-               error = -inode_change_ok(inode, iattr);
+               error = inode_change_ok(inode, iattr);
                if (error)
                        return error;
        }
@@ -713,7 +713,7 @@ xfs_setattr_nonsize(
         *           Posix ACL code seems to care about this issue either.
         */
        if ((mask & ATTR_MODE) && !(flags & XFS_ATTR_NOACL)) {
-               error = -posix_acl_chmod(inode, inode->i_mode);
+               error = posix_acl_chmod(inode, inode->i_mode);
                if (error)
                        return error;
        }
@@ -748,12 +748,12 @@ xfs_setattr_size(
        trace_xfs_setattr(ip);
 
        if (mp->m_flags & XFS_MOUNT_RDONLY)
-               return EROFS;
+               return -EROFS;
 
        if (XFS_FORCED_SHUTDOWN(mp))
-               return EIO;
+               return -EIO;
 
-       error = -inode_change_ok(inode, iattr);
+       error = inode_change_ok(inode, iattr);
        if (error)
                return error;
 
@@ -818,7 +818,7 @@ xfs_setattr_size(
         * care about here.
         */
        if (oldsize != ip->i_d.di_size && newsize > ip->i_d.di_size) {
-               error = -filemap_write_and_wait_range(VFS_I(ip)->i_mapping,
+               error = filemap_write_and_wait_range(VFS_I(ip)->i_mapping,
                                                      ip->i_d.di_size, newsize);
                if (error)
                        return error;
@@ -844,7 +844,7 @@ xfs_setattr_size(
         * much we can do about this, except to hope that the caller sees ENOMEM
         * and retries the truncate operation.
         */
-       error = -block_truncate_page(inode->i_mapping, newsize, xfs_get_blocks);
+       error = block_truncate_page(inode->i_mapping, newsize, xfs_get_blocks);
        if (error)
                return error;
        truncate_setsize(inode, newsize);
@@ -950,7 +950,7 @@ xfs_vn_setattr(
                error = xfs_setattr_nonsize(ip, iattr, 0);
        }
 
-       return -error;
+       return error;
 }
 
 STATIC int
@@ -970,7 +970,7 @@ xfs_vn_update_time(
        error = xfs_trans_reserve(tp, &M_RES(mp)->tr_fsyncts, 0, 0);
        if (error) {
                xfs_trans_cancel(tp, 0);
-               return -error;
+               return error;
        }
 
        xfs_ilock(ip, XFS_ILOCK_EXCL);
@@ -991,7 +991,7 @@ xfs_vn_update_time(
        }
        xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
        xfs_trans_log_inode(tp, ip, XFS_ILOG_TIMESTAMP);
-       return -xfs_trans_commit(tp, 0);
+       return xfs_trans_commit(tp, 0);
 }
 
 #define XFS_FIEMAP_FLAGS       (FIEMAP_FLAG_SYNC|FIEMAP_FLAG_XATTR)
@@ -1036,7 +1036,7 @@ xfs_fiemap_format(
                *full = 1;      /* user array now full */
        }
 
-       return -error;
+       return error;
 }
 
 STATIC int
@@ -1075,7 +1075,7 @@ xfs_vn_fiemap(
 
        error = xfs_getbmap(ip, &bm, xfs_fiemap_format, fieinfo);
        if (error)
-               return -error;
+               return error;
 
        return 0;
 }
index e4056a7495e5abe2ed0bfb359964bda6df94feb7..7e54992bcae90a7dba507dbe88dc8e2621a3b16a 100644 (file)
@@ -67,11 +67,11 @@ xfs_bulkstat_one_int(
        *stat = BULKSTAT_RV_NOTHING;
 
        if (!buffer || xfs_internal_inum(mp, ino))
-               return EINVAL;
+               return -EINVAL;
 
        buf = kmem_alloc(sizeof(*buf), KM_SLEEP | KM_MAYFAIL);
        if (!buf)
-               return ENOMEM;
+               return -ENOMEM;
 
        error = xfs_iget(mp, NULL, ino,
                         (XFS_IGET_DONTCACHE | XFS_IGET_UNTRUSTED),
@@ -154,9 +154,9 @@ xfs_bulkstat_one_fmt(
        const xfs_bstat_t       *buffer)
 {
        if (ubsize < sizeof(*buffer))
-               return ENOMEM;
+               return -ENOMEM;
        if (copy_to_user(ubuffer, buffer, sizeof(*buffer)))
-               return EFAULT;
+               return -EFAULT;
        if (ubused)
                *ubused = sizeof(*buffer);
        return 0;
@@ -234,7 +234,7 @@ xfs_bulkstat(
                return 0;
        }
        if (!ubcountp || *ubcountp <= 0) {
-               return EINVAL;
+               return -EINVAL;
        }
        ubcount = *ubcountp; /* statstruct's */
        ubleft = ubcount * statstruct_size; /* bytes */
@@ -246,7 +246,7 @@ xfs_bulkstat(
        inodes_per_cluster = blks_per_cluster << mp->m_sb.sb_inopblog;
        irbuf = kmem_zalloc_greedy(&irbsize, PAGE_SIZE, PAGE_SIZE * 4);
        if (!irbuf)
-               return ENOMEM;
+               return -ENOMEM;
 
        nirbuf = irbsize / sizeof(*irbuf);
 
@@ -452,8 +452,8 @@ xfs_bulkstat(
                                error = formatter(mp, ino, ubufp, ubleft,
                                                  &ubused, &fmterror);
                                if (fmterror == BULKSTAT_RV_NOTHING) {
-                                       if (error && error != ENOENT &&
-                                               error != EINVAL) {
+                                       if (error && error != -ENOENT &&
+                                               error != -EINVAL) {
                                                ubleft = 0;
                                                rval = error;
                                                break;
@@ -551,7 +551,7 @@ xfs_bulkstat_single(
                                sizeof(xfs_bstat_t), buffer, done))
                        return error;
                if (count == 0 || (xfs_ino_t)*lastinop != ino)
-                       return error == EFSCORRUPTED ?
+                       return error == -EFSCORRUPTED ?
                                EINVAL : error;
                else
                        return 0;
@@ -661,7 +661,7 @@ xfs_inumbers(
                if (bufidx == bcount) {
                        long written;
                        if (formatter(ubuffer, buffer, bufidx, &written)) {
-                               error = EFAULT;
+                               error = -EFAULT;
                                break;
                        }
                        ubuffer += written;
@@ -688,7 +688,7 @@ xfs_inumbers(
                if (bufidx) {
                        long written;
                        if (formatter(ubuffer, buffer, bufidx, &written))
-                               error = EFAULT;
+                               error = -EFAULT;
                        else
                                *count += bufidx;
                }
index 01b715677596f8e678d7a9f99fd0e30d109d60a2..7647818b8c8ae4aa4d85557ebf78637125e4de4d 100644 (file)
@@ -283,7 +283,7 @@ xlog_grant_head_wait(
        return 0;
 shutdown:
        list_del_init(&tic->t_queue);
-       return EIO;
+       return -EIO;
 }
 
 /*
@@ -377,7 +377,7 @@ xfs_log_regrant(
        int                     error = 0;
 
        if (XLOG_FORCED_SHUTDOWN(log))
-               return EIO;
+               return -EIO;
 
        XFS_STATS_INC(xs_try_logspace);
 
@@ -446,7 +446,7 @@ xfs_log_reserve(
        ASSERT(client == XFS_TRANSACTION || client == XFS_LOG);
 
        if (XLOG_FORCED_SHUTDOWN(log))
-               return EIO;
+               return -EIO;
 
        XFS_STATS_INC(xs_try_logspace);
 
@@ -454,7 +454,7 @@ xfs_log_reserve(
        tic = xlog_ticket_alloc(log, unit_bytes, cnt, client, permanent,
                                KM_SLEEP | KM_MAYFAIL);
        if (!tic)
-               return ENOMEM;
+               return -ENOMEM;
 
        tic->t_trans_type = t_type;
        *ticp = tic;
@@ -590,7 +590,7 @@ xfs_log_release_iclog(
 {
        if (xlog_state_release_iclog(mp->m_log, iclog)) {
                xfs_force_shutdown(mp, SHUTDOWN_LOG_IO_ERROR);
-               return EIO;
+               return -EIO;
        }
 
        return 0;
@@ -628,7 +628,7 @@ xfs_log_mount(
 
        mp->m_log = xlog_alloc_log(mp, log_target, blk_offset, num_bblks);
        if (IS_ERR(mp->m_log)) {
-               error = -PTR_ERR(mp->m_log);
+               error = PTR_ERR(mp->m_log);
                goto out;
        }
 
@@ -652,18 +652,18 @@ xfs_log_mount(
                xfs_warn(mp,
                "Log size %d blocks too small, minimum size is %d blocks",
                         mp->m_sb.sb_logblocks, min_logfsbs);
-               error = EINVAL;
+               error = -EINVAL;
        } else if (mp->m_sb.sb_logblocks > XFS_MAX_LOG_BLOCKS) {
                xfs_warn(mp,
                "Log size %d blocks too large, maximum size is %lld blocks",
                         mp->m_sb.sb_logblocks, XFS_MAX_LOG_BLOCKS);
-               error = EINVAL;
+               error = -EINVAL;
        } else if (XFS_FSB_TO_B(mp, mp->m_sb.sb_logblocks) > XFS_MAX_LOG_BYTES) {
                xfs_warn(mp,
                "log size %lld bytes too large, maximum size is %lld bytes",
                         XFS_FSB_TO_B(mp, mp->m_sb.sb_logblocks),
                         XFS_MAX_LOG_BYTES);
-               error = EINVAL;
+               error = -EINVAL;
        }
        if (error) {
                if (xfs_sb_version_hascrc(&mp->m_sb)) {
@@ -1313,7 +1313,7 @@ xlog_alloc_log(
        xlog_in_core_t          *iclog, *prev_iclog=NULL;
        xfs_buf_t               *bp;
        int                     i;
-       int                     error = ENOMEM;
+       int                     error = -ENOMEM;
        uint                    log2_size = 0;
 
        log = kmem_zalloc(sizeof(struct xlog), KM_MAYFAIL);
@@ -1340,7 +1340,7 @@ xlog_alloc_log(
        xlog_grant_head_init(&log->l_reserve_head);
        xlog_grant_head_init(&log->l_write_head);
 
-       error = EFSCORRUPTED;
+       error = -EFSCORRUPTED;
        if (xfs_sb_version_hassector(&mp->m_sb)) {
                log2_size = mp->m_sb.sb_logsectlog;
                if (log2_size < BBSHIFT) {
@@ -1369,7 +1369,7 @@ xlog_alloc_log(
 
        xlog_get_iclog_buffer_size(mp, log);
 
-       error = ENOMEM;
+       error = -ENOMEM;
        bp = xfs_buf_alloc(mp->m_logdev_targp, 0, BTOBB(log->l_iclog_size), 0);
        if (!bp)
                goto out_free_log;
@@ -1463,7 +1463,7 @@ out_free_iclog:
 out_free_log:
        kmem_free(log);
 out:
-       return ERR_PTR(-error);
+       return ERR_PTR(error);
 }      /* xlog_alloc_log */
 
 
@@ -1661,7 +1661,7 @@ xlog_bdstrat(
 
        xfs_buf_lock(bp);
        if (iclog->ic_state & XLOG_STATE_IOERROR) {
-               xfs_buf_ioerror(bp, EIO);
+               xfs_buf_ioerror(bp, -EIO);
                xfs_buf_stale(bp);
                xfs_buf_ioend(bp, 0);
                /*
@@ -2360,7 +2360,7 @@ xlog_write(
 
                        ophdr = xlog_write_setup_ophdr(log, ptr, ticket, flags);
                        if (!ophdr)
-                               return EIO;
+                               return -EIO;
 
                        xlog_write_adv_cnt(&ptr, &len, &log_offset,
                                           sizeof(struct xlog_op_header));
@@ -2859,7 +2859,7 @@ restart:
        spin_lock(&log->l_icloglock);
        if (XLOG_FORCED_SHUTDOWN(log)) {
                spin_unlock(&log->l_icloglock);
-               return EIO;
+               return -EIO;
        }
 
        iclog = log->l_iclog;
@@ -3047,7 +3047,7 @@ xlog_state_release_iclog(
        int             sync = 0;       /* do we sync? */
 
        if (iclog->ic_state & XLOG_STATE_IOERROR)
-               return EIO;
+               return -EIO;
 
        ASSERT(atomic_read(&iclog->ic_refcnt) > 0);
        if (!atomic_dec_and_lock(&iclog->ic_refcnt, &log->l_icloglock))
@@ -3055,7 +3055,7 @@ xlog_state_release_iclog(
 
        if (iclog->ic_state & XLOG_STATE_IOERROR) {
                spin_unlock(&log->l_icloglock);
-               return EIO;
+               return -EIO;
        }
        ASSERT(iclog->ic_state == XLOG_STATE_ACTIVE ||
               iclog->ic_state == XLOG_STATE_WANT_SYNC);
@@ -3172,7 +3172,7 @@ _xfs_log_force(
        iclog = log->l_iclog;
        if (iclog->ic_state & XLOG_STATE_IOERROR) {
                spin_unlock(&log->l_icloglock);
-               return EIO;
+               return -EIO;
        }
 
        /* If the head iclog is not active nor dirty, we just attach
@@ -3210,7 +3210,7 @@ _xfs_log_force(
                                spin_unlock(&log->l_icloglock);
 
                                if (xlog_state_release_iclog(log, iclog))
-                                       return EIO;
+                                       return -EIO;
 
                                if (log_flushed)
                                        *log_flushed = 1;
@@ -3246,7 +3246,7 @@ maybe_sleep:
                 */
                if (iclog->ic_state & XLOG_STATE_IOERROR) {
                        spin_unlock(&log->l_icloglock);
-                       return EIO;
+                       return -EIO;
                }
                XFS_STATS_INC(xs_log_force_sleep);
                xlog_wait(&iclog->ic_force_wait, &log->l_icloglock);
@@ -3256,7 +3256,7 @@ maybe_sleep:
                 * and the memory read should be atomic.
                 */
                if (iclog->ic_state & XLOG_STATE_IOERROR)
-                       return EIO;
+                       return -EIO;
                if (log_flushed)
                        *log_flushed = 1;
        } else {
@@ -3324,7 +3324,7 @@ try_again:
        iclog = log->l_iclog;
        if (iclog->ic_state & XLOG_STATE_IOERROR) {
                spin_unlock(&log->l_icloglock);
-               return EIO;
+               return -EIO;
        }
 
        do {
@@ -3375,7 +3375,7 @@ try_again:
                        xlog_state_switch_iclogs(log, iclog, 0);
                        spin_unlock(&log->l_icloglock);
                        if (xlog_state_release_iclog(log, iclog))
-                               return EIO;
+                               return -EIO;
                        if (log_flushed)
                                *log_flushed = 1;
                        spin_lock(&log->l_icloglock);
@@ -3390,7 +3390,7 @@ try_again:
                         */
                        if (iclog->ic_state & XLOG_STATE_IOERROR) {
                                spin_unlock(&log->l_icloglock);
-                               return EIO;
+                               return -EIO;
                        }
                        XFS_STATS_INC(xs_log_force_sleep);
                        xlog_wait(&iclog->ic_force_wait, &log->l_icloglock);
@@ -3400,7 +3400,7 @@ try_again:
                         * and the memory read should be atomic.
                         */
                        if (iclog->ic_state & XLOG_STATE_IOERROR)
-                               return EIO;
+                               return -EIO;
 
                        if (log_flushed)
                                *log_flushed = 1;
index 0d554f2cb4a8059468e1268f9db01ed78b0ccff2..2ee4388dc68251aeec19b7e991a4919209234a3b 100644 (file)
@@ -634,7 +634,7 @@ out_abort_free_ticket:
        xfs_log_ticket_put(tic);
 out_abort:
        xlog_cil_committed(ctx, XFS_LI_ABORTED);
-       return EIO;
+       return -EIO;
 }
 
 static void
@@ -928,12 +928,12 @@ xlog_cil_init(
 
        cil = kmem_zalloc(sizeof(*cil), KM_SLEEP|KM_MAYFAIL);
        if (!cil)
-               return ENOMEM;
+               return -ENOMEM;
 
        ctx = kmem_zalloc(sizeof(*ctx), KM_SLEEP|KM_MAYFAIL);
        if (!ctx) {
                kmem_free(cil);
-               return ENOMEM;
+               return -ENOMEM;
        }
 
        INIT_WORK(&cil->xc_push_work, xlog_cil_push_work);
index 845a92c9c241d07225e070a73ca7d49df1e50967..fbc2362d13e3b4c0531d310b9aa4c2e7054409ab 100644 (file)
@@ -179,7 +179,7 @@ xlog_bread_noalign(
                xfs_warn(log->l_mp, "Invalid block length (0x%x) for buffer",
                        nbblks);
                XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_HIGH, log->l_mp);
-               return EFSCORRUPTED;
+               return -EFSCORRUPTED;
        }
 
        blk_no = round_down(blk_no, log->l_sectBBsize);
@@ -194,7 +194,7 @@ xlog_bread_noalign(
        bp->b_error = 0;
 
        if (XFS_FORCED_SHUTDOWN(log->l_mp))
-               return EIO;
+               return -EIO;
 
        xfs_buf_iorequest(bp);
        error = xfs_buf_iowait(bp);
@@ -268,7 +268,7 @@ xlog_bwrite(
                xfs_warn(log->l_mp, "Invalid block length (0x%x) for buffer",
                        nbblks);
                XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_HIGH, log->l_mp);
-               return EFSCORRUPTED;
+               return -EFSCORRUPTED;
        }
 
        blk_no = round_down(blk_no, log->l_sectBBsize);
@@ -330,14 +330,14 @@ xlog_header_check_recover(
                xlog_header_check_dump(mp, head);
                XFS_ERROR_REPORT("xlog_header_check_recover(1)",
                                 XFS_ERRLEVEL_HIGH, mp);
-               return EFSCORRUPTED;
+               return -EFSCORRUPTED;
        } else if (unlikely(!uuid_equal(&mp->m_sb.sb_uuid, &head->h_fs_uuid))) {
                xfs_warn(mp,
        "dirty log entry has mismatched uuid - can't recover");
                xlog_header_check_dump(mp, head);
                XFS_ERROR_REPORT("xlog_header_check_recover(2)",
                                 XFS_ERRLEVEL_HIGH, mp);
-               return EFSCORRUPTED;
+               return -EFSCORRUPTED;
        }
        return 0;
 }
@@ -364,7 +364,7 @@ xlog_header_check_mount(
                xlog_header_check_dump(mp, head);
                XFS_ERROR_REPORT("xlog_header_check_mount",
                                 XFS_ERRLEVEL_HIGH, mp);
-               return EFSCORRUPTED;
+               return -EFSCORRUPTED;
        }
        return 0;
 }
@@ -462,7 +462,7 @@ xlog_find_verify_cycle(
        while (!(bp = xlog_get_bp(log, bufblks))) {
                bufblks >>= 1;
                if (bufblks < log->l_sectBBsize)
-                       return ENOMEM;
+                       return -ENOMEM;
        }
 
        for (i = start_blk; i < start_blk + nbblks; i += bufblks) {
@@ -524,7 +524,7 @@ xlog_find_verify_log_record(
 
        if (!(bp = xlog_get_bp(log, num_blks))) {
                if (!(bp = xlog_get_bp(log, 1)))
-                       return ENOMEM;
+                       return -ENOMEM;
                smallmem = 1;
        } else {
                error = xlog_bread(log, start_blk, num_blks, bp, &offset);
@@ -539,7 +539,7 @@ xlog_find_verify_log_record(
                        xfs_warn(log->l_mp,
                "Log inconsistent (didn't find previous header)");
                        ASSERT(0);
-                       error = EIO;
+                       error = -EIO;
                        goto out;
                }
 
@@ -564,7 +564,7 @@ xlog_find_verify_log_record(
         * will be called again for the end of the physical log.
         */
        if (i == -1) {
-               error = -1;
+               error = 1;
                goto out;
        }
 
@@ -628,7 +628,12 @@ xlog_find_head(
        int             error, log_bbnum = log->l_logBBsize;
 
        /* Is the end of the log device zeroed? */
-       if ((error = xlog_find_zeroed(log, &first_blk)) == -1) {
+       error = xlog_find_zeroed(log, &first_blk);
+       if (error < 0) {
+               xfs_warn(log->l_mp, "empty log check failed");
+               return error;
+       }
+       if (error == 1) {
                *return_head_blk = first_blk;
 
                /* Is the whole lot zeroed? */
@@ -641,15 +646,12 @@ xlog_find_head(
                }
 
                return 0;
-       } else if (error) {
-               xfs_warn(log->l_mp, "empty log check failed");
-               return error;
        }
 
        first_blk = 0;                  /* get cycle # of 1st block */
        bp = xlog_get_bp(log, 1);
        if (!bp)
-               return ENOMEM;
+               return -ENOMEM;
 
        error = xlog_bread(log, 0, 1, bp, &offset);
        if (error)
@@ -818,29 +820,29 @@ validate_head:
                start_blk = head_blk - num_scan_bblks; /* don't read head_blk */
 
                /* start ptr at last block ptr before head_blk */
-               if ((error = xlog_find_verify_log_record(log, start_blk,
-                                                       &head_blk, 0)) == -1) {
-                       error = EIO;
-                       goto bp_err;
-               } else if (error)
+               error = xlog_find_verify_log_record(log, start_blk, &head_blk, 0);
+               if (error == 1)
+                       error = -EIO;
+               if (error)
                        goto bp_err;
        } else {
                start_blk = 0;
                ASSERT(head_blk <= INT_MAX);
-               if ((error = xlog_find_verify_log_record(log, start_blk,
-                                                       &head_blk, 0)) == -1) {
+               error = xlog_find_verify_log_record(log, start_blk, &head_blk, 0);
+               if (error < 0)
+                       goto bp_err;
+               if (error == 1) {
                        /* We hit the beginning of the log during our search */
                        start_blk = log_bbnum - (num_scan_bblks - head_blk);
                        new_blk = log_bbnum;
                        ASSERT(start_blk <= INT_MAX &&
                                (xfs_daddr_t) log_bbnum-start_blk >= 0);
                        ASSERT(head_blk <= INT_MAX);
-                       if ((error = xlog_find_verify_log_record(log,
-                                                       start_blk, &new_blk,
-                                                       (int)head_blk)) == -1) {
-                               error = EIO;
-                               goto bp_err;
-                       } else if (error)
+                       error = xlog_find_verify_log_record(log, start_blk,
+                                                       &new_blk, (int)head_blk);
+                       if (error == 1)
+                               error = -EIO;
+                       if (error)
                                goto bp_err;
                        if (new_blk != log_bbnum)
                                head_blk = new_blk;
@@ -911,7 +913,7 @@ xlog_find_tail(
 
        bp = xlog_get_bp(log, 1);
        if (!bp)
-               return ENOMEM;
+               return -ENOMEM;
        if (*head_blk == 0) {                           /* special case */
                error = xlog_bread(log, 0, 1, bp, &offset);
                if (error)
@@ -961,7 +963,7 @@ xlog_find_tail(
                xfs_warn(log->l_mp, "%s: couldn't find sync record", __func__);
                xlog_put_bp(bp);
                ASSERT(0);
-               return EIO;
+               return -EIO;
        }
 
        /* find blk_no of tail of log */
@@ -1092,8 +1094,8 @@ done:
  *
  * Return:
  *     0  => the log is completely written to
- *     -1 => use *blk_no as the first block of the log
- *     >0 => error has occurred
+ *     1 => use *blk_no as the first block of the log
+ *     <0 => error has occurred
  */
 STATIC int
 xlog_find_zeroed(
@@ -1112,7 +1114,7 @@ xlog_find_zeroed(
        /* check totally zeroed log */
        bp = xlog_get_bp(log, 1);
        if (!bp)
-               return ENOMEM;
+               return -ENOMEM;
        error = xlog_bread(log, 0, 1, bp, &offset);
        if (error)
                goto bp_err;
@@ -1121,7 +1123,7 @@ xlog_find_zeroed(
        if (first_cycle == 0) {         /* completely zeroed log */
                *blk_no = 0;
                xlog_put_bp(bp);
-               return -1;
+               return 1;
        }
 
        /* check partially zeroed log */
@@ -1141,7 +1143,7 @@ xlog_find_zeroed(
                 */
                xfs_warn(log->l_mp,
                        "Log inconsistent or not a log (last==0, first!=1)");
-               error = EINVAL;
+               error = -EINVAL;
                goto bp_err;
        }
 
@@ -1179,19 +1181,18 @@ xlog_find_zeroed(
         * Potentially backup over partial log record write.  We don't need
         * to search the end of the log because we know it is zero.
         */
-       if ((error = xlog_find_verify_log_record(log, start_blk,
-                               &last_blk, 0)) == -1) {
-           error = EIO;
-           goto bp_err;
-       } else if (error)
-           goto bp_err;
+       error = xlog_find_verify_log_record(log, start_blk, &last_blk, 0);
+       if (error == 1)
+               error = -EIO;
+       if (error)
+               goto bp_err;
 
        *blk_no = last_blk;
 bp_err:
        xlog_put_bp(bp);
        if (error)
                return error;
-       return -1;
+       return 1;
 }
 
 /*
@@ -1251,7 +1252,7 @@ xlog_write_log_records(
        while (!(bp = xlog_get_bp(log, bufblks))) {
                bufblks >>= 1;
                if (bufblks < sectbb)
-                       return ENOMEM;
+                       return -ENOMEM;
        }
 
        /* We may need to do a read at the start to fill in part of
@@ -1354,7 +1355,7 @@ xlog_clear_stale_blocks(
                if (unlikely(head_block < tail_block || head_block >= log->l_logBBsize)) {
                        XFS_ERROR_REPORT("xlog_clear_stale_blocks(1)",
                                         XFS_ERRLEVEL_LOW, log->l_mp);
-                       return EFSCORRUPTED;
+                       return -EFSCORRUPTED;
                }
                tail_distance = tail_block + (log->l_logBBsize - head_block);
        } else {
@@ -1366,7 +1367,7 @@ xlog_clear_stale_blocks(
                if (unlikely(head_block >= tail_block || head_cycle != (tail_cycle + 1))){
                        XFS_ERROR_REPORT("xlog_clear_stale_blocks(2)",
                                         XFS_ERRLEVEL_LOW, log->l_mp);
-                       return EFSCORRUPTED;
+                       return -EFSCORRUPTED;
                }
                tail_distance = tail_block - head_block;
        }
@@ -1551,7 +1552,7 @@ xlog_recover_add_to_trans(
                        xfs_warn(log->l_mp, "%s: bad header magic number",
                                __func__);
                        ASSERT(0);
-                       return EIO;
+                       return -EIO;
                }
                if (len == sizeof(xfs_trans_header_t))
                        xlog_recover_add_item(&trans->r_itemq);
@@ -1581,7 +1582,7 @@ xlog_recover_add_to_trans(
                                  in_f->ilf_size);
                        ASSERT(0);
                        kmem_free(ptr);
-                       return EIO;
+                       return -EIO;
                }
 
                item->ri_total = in_f->ilf_size;
@@ -1702,7 +1703,7 @@ xlog_recover_reorder_trans(
                         */
                        if (!list_empty(&sort_list))
                                list_splice_init(&sort_list, &trans->r_itemq);
-                       error = EIO;
+                       error = -EIO;
                        goto out;
                }
        }
@@ -1943,7 +1944,7 @@ xlog_recover_do_inode_buffer(
                                item, bp);
                        XFS_ERROR_REPORT("xlog_recover_do_inode_buf",
                                         XFS_ERRLEVEL_LOW, mp);
-                       return EFSCORRUPTED;
+                       return -EFSCORRUPTED;
                }
 
                buffer_nextp = (xfs_agino_t *)xfs_buf_offset(bp,
@@ -2496,7 +2497,7 @@ xlog_recover_buffer_pass2(
        bp = xfs_buf_read(mp->m_ddev_targp, buf_f->blf_blkno, buf_f->blf_len,
                          buf_flags, NULL);
        if (!bp)
-               return ENOMEM;
+               return -ENOMEM;
        error = bp->b_error;
        if (error) {
                xfs_buf_ioerror_alert(bp, "xlog_recover_do..(read#1)");
@@ -2598,7 +2599,7 @@ xfs_recover_inode_owner_change(
 
        ip = xfs_inode_alloc(mp, in_f->ilf_ino);
        if (!ip)
-               return ENOMEM;
+               return -ENOMEM;
 
        /* instantiate the inode */
        xfs_dinode_from_disk(&ip->i_d, dip);
@@ -2676,7 +2677,7 @@ xlog_recover_inode_pass2(
        bp = xfs_buf_read(mp->m_ddev_targp, in_f->ilf_blkno, in_f->ilf_len, 0,
                          &xfs_inode_buf_ops);
        if (!bp) {
-               error = ENOMEM;
+               error = -ENOMEM;
                goto error;
        }
        error = bp->b_error;
@@ -2697,7 +2698,7 @@ xlog_recover_inode_pass2(
                        __func__, dip, bp, in_f->ilf_ino);
                XFS_ERROR_REPORT("xlog_recover_inode_pass2(1)",
                                 XFS_ERRLEVEL_LOW, mp);
-               error = EFSCORRUPTED;
+               error = -EFSCORRUPTED;
                goto out_release;
        }
        dicp = item->ri_buf[1].i_addr;
@@ -2707,7 +2708,7 @@ xlog_recover_inode_pass2(
                        __func__, item, in_f->ilf_ino);
                XFS_ERROR_REPORT("xlog_recover_inode_pass2(2)",
                                 XFS_ERRLEVEL_LOW, mp);
-               error = EFSCORRUPTED;
+               error = -EFSCORRUPTED;
                goto out_release;
        }
 
@@ -2764,7 +2765,7 @@ xlog_recover_inode_pass2(
                "%s: Bad regular inode log record, rec ptr 0x%p, "
                "ino ptr = 0x%p, ino bp = 0x%p, ino %Ld",
                                __func__, item, dip, bp, in_f->ilf_ino);
-                       error = EFSCORRUPTED;
+                       error = -EFSCORRUPTED;
                        goto out_release;
                }
        } else if (unlikely(S_ISDIR(dicp->di_mode))) {
@@ -2777,7 +2778,7 @@ xlog_recover_inode_pass2(
                "%s: Bad dir inode log record, rec ptr 0x%p, "
                "ino ptr = 0x%p, ino bp = 0x%p, ino %Ld",
                                __func__, item, dip, bp, in_f->ilf_ino);
-                       error = EFSCORRUPTED;
+                       error = -EFSCORRUPTED;
                        goto out_release;
                }
        }
@@ -2790,7 +2791,7 @@ xlog_recover_inode_pass2(
                        __func__, item, dip, bp, in_f->ilf_ino,
                        dicp->di_nextents + dicp->di_anextents,
                        dicp->di_nblocks);
-               error = EFSCORRUPTED;
+               error = -EFSCORRUPTED;
                goto out_release;
        }
        if (unlikely(dicp->di_forkoff > mp->m_sb.sb_inodesize)) {
@@ -2800,7 +2801,7 @@ xlog_recover_inode_pass2(
        "%s: Bad inode log record, rec ptr 0x%p, dino ptr 0x%p, "
        "dino bp 0x%p, ino %Ld, forkoff 0x%x", __func__,
                        item, dip, bp, in_f->ilf_ino, dicp->di_forkoff);
-               error = EFSCORRUPTED;
+               error = -EFSCORRUPTED;
                goto out_release;
        }
        isize = xfs_icdinode_size(dicp->di_version);
@@ -2810,7 +2811,7 @@ xlog_recover_inode_pass2(
                xfs_alert(mp,
                        "%s: Bad inode log record length %d, rec ptr 0x%p",
                        __func__, item->ri_buf[1].i_len, item);
-               error = EFSCORRUPTED;
+               error = -EFSCORRUPTED;
                goto out_release;
        }
 
@@ -2898,7 +2899,7 @@ xlog_recover_inode_pass2(
                default:
                        xfs_warn(log->l_mp, "%s: Invalid flag", __func__);
                        ASSERT(0);
-                       error = EIO;
+                       error = -EIO;
                        goto out_release;
                }
        }
@@ -2976,12 +2977,12 @@ xlog_recover_dquot_pass2(
        recddq = item->ri_buf[1].i_addr;
        if (recddq == NULL) {
                xfs_alert(log->l_mp, "NULL dquot in %s.", __func__);
-               return EIO;
+               return -EIO;
        }
        if (item->ri_buf[1].i_len < sizeof(xfs_disk_dquot_t)) {
                xfs_alert(log->l_mp, "dquot too small (%d) in %s.",
                        item->ri_buf[1].i_len, __func__);
-               return EIO;
+               return -EIO;
        }
 
        /*
@@ -3007,7 +3008,7 @@ xlog_recover_dquot_pass2(
        error = xfs_dqcheck(mp, recddq, dq_f->qlf_id, 0, XFS_QMOPT_DOWARN,
                           "xlog_recover_dquot_pass2 (log copy)");
        if (error)
-               return EIO;
+               return -EIO;
        ASSERT(dq_f->qlf_len == 1);
 
        error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp, dq_f->qlf_blkno,
@@ -3028,7 +3029,7 @@ xlog_recover_dquot_pass2(
                           "xlog_recover_dquot_pass2");
        if (error) {
                xfs_buf_relse(bp);
-               return EIO;
+               return -EIO;
        }
 
        /*
@@ -3178,38 +3179,38 @@ xlog_recover_do_icreate_pass2(
        icl = (struct xfs_icreate_log *)item->ri_buf[0].i_addr;
        if (icl->icl_type != XFS_LI_ICREATE) {
                xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad type");
-               return EINVAL;
+               return -EINVAL;
        }
 
        if (icl->icl_size != 1) {
                xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad icl size");
-               return EINVAL;
+               return -EINVAL;
        }
 
        agno = be32_to_cpu(icl->icl_ag);
        if (agno >= mp->m_sb.sb_agcount) {
                xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad agno");
-               return EINVAL;
+               return -EINVAL;
        }
        agbno = be32_to_cpu(icl->icl_agbno);
        if (!agbno || agbno == NULLAGBLOCK || agbno >= mp->m_sb.sb_agblocks) {
                xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad agbno");
-               return EINVAL;
+               return -EINVAL;
        }
        isize = be32_to_cpu(icl->icl_isize);
        if (isize != mp->m_sb.sb_inodesize) {
                xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad isize");
-               return EINVAL;
+               return -EINVAL;
        }
        count = be32_to_cpu(icl->icl_count);
        if (!count) {
                xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad count");
-               return EINVAL;
+               return -EINVAL;
        }
        length = be32_to_cpu(icl->icl_length);
        if (!length || length >= mp->m_sb.sb_agblocks) {
                xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad length");
-               return EINVAL;
+               return -EINVAL;
        }
 
        /* existing allocation is fixed value */
@@ -3218,7 +3219,7 @@ xlog_recover_do_icreate_pass2(
        if (count != mp->m_ialloc_inos ||
             length != mp->m_ialloc_blks) {
                xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad count 2");
-               return EINVAL;
+               return -EINVAL;
        }
 
        /*
@@ -3389,7 +3390,7 @@ xlog_recover_commit_pass1(
                xfs_warn(log->l_mp, "%s: invalid item type (%d)",
                        __func__, ITEM_TYPE(item));
                ASSERT(0);
-               return EIO;
+               return -EIO;
        }
 }
 
@@ -3425,7 +3426,7 @@ xlog_recover_commit_pass2(
                xfs_warn(log->l_mp, "%s: invalid item type (%d)",
                        __func__, ITEM_TYPE(item));
                ASSERT(0);
-               return EIO;
+               return -EIO;
        }
 }
 
@@ -3560,7 +3561,7 @@ xlog_recover_process_data(
 
        /* check the log format matches our own - else we can't recover */
        if (xlog_header_check_recover(log->l_mp, rhead))
-               return EIO;
+               return -EIO;
 
        while ((dp < lp) && num_logops) {
                ASSERT(dp + sizeof(xlog_op_header_t) <= lp);
@@ -3571,7 +3572,7 @@ xlog_recover_process_data(
                        xfs_warn(log->l_mp, "%s: bad clientid 0x%x",
                                        __func__, ohead->oh_clientid);
                        ASSERT(0);
-                       return EIO;
+                       return -EIO;
                }
                tid = be32_to_cpu(ohead->oh_tid);
                hash = XLOG_RHASH(tid);
@@ -3585,7 +3586,7 @@ xlog_recover_process_data(
                                xfs_warn(log->l_mp, "%s: bad length 0x%x",
                                        __func__, be32_to_cpu(ohead->oh_len));
                                WARN_ON(1);
-                               return EIO;
+                               return -EIO;
                        }
                        flags = ohead->oh_flags & ~XLOG_END_TRANS;
                        if (flags & XLOG_WAS_CONT_TRANS)
@@ -3607,7 +3608,7 @@ xlog_recover_process_data(
                                xfs_warn(log->l_mp, "%s: bad transaction",
                                        __func__);
                                ASSERT(0);
-                               error = EIO;
+                               error = -EIO;
                                break;
                        case 0:
                        case XLOG_CONTINUE_TRANS:
@@ -3618,7 +3619,7 @@ xlog_recover_process_data(
                                xfs_warn(log->l_mp, "%s: bad flag 0x%x",
                                        __func__, flags);
                                ASSERT(0);
-                               error = EIO;
+                               error = -EIO;
                                break;
                        }
                        if (error) {
@@ -3669,7 +3670,7 @@ xlog_recover_process_efi(
                         */
                        set_bit(XFS_EFI_RECOVERED, &efip->efi_flags);
                        xfs_efi_release(efip, efip->efi_format.efi_nextents);
-                       return EIO;
+                       return -EIO;
                }
        }
 
@@ -3969,7 +3970,7 @@ xlog_unpack_data_crc(
                 * CRC protection by punting an error back up the stack.
                 */
                if (xfs_sb_version_hascrc(&log->l_mp->m_sb))
-                       return EFSCORRUPTED;
+                       return -EFSCORRUPTED;
        }
 
        return 0;
@@ -4018,14 +4019,14 @@ xlog_valid_rec_header(
        if (unlikely(rhead->h_magicno != cpu_to_be32(XLOG_HEADER_MAGIC_NUM))) {
                XFS_ERROR_REPORT("xlog_valid_rec_header(1)",
                                XFS_ERRLEVEL_LOW, log->l_mp);
-               return EFSCORRUPTED;
+               return -EFSCORRUPTED;
        }
        if (unlikely(
            (!rhead->h_version ||
            (be32_to_cpu(rhead->h_version) & (~XLOG_VERSION_OKBITS))))) {
                xfs_warn(log->l_mp, "%s: unrecognised log version (%d).",
                        __func__, be32_to_cpu(rhead->h_version));
-               return EIO;
+               return -EIO;
        }
 
        /* LR body must have data or it wouldn't have been written */
@@ -4033,12 +4034,12 @@ xlog_valid_rec_header(
        if (unlikely( hlen <= 0 || hlen > INT_MAX )) {
                XFS_ERROR_REPORT("xlog_valid_rec_header(2)",
                                XFS_ERRLEVEL_LOW, log->l_mp);
-               return EFSCORRUPTED;
+               return -EFSCORRUPTED;
        }
        if (unlikely( blkno > log->l_logBBsize || blkno > INT_MAX )) {
                XFS_ERROR_REPORT("xlog_valid_rec_header(3)",
                                XFS_ERRLEVEL_LOW, log->l_mp);
-               return EFSCORRUPTED;
+               return -EFSCORRUPTED;
        }
        return 0;
 }
@@ -4081,7 +4082,7 @@ xlog_do_recovery_pass(
                 */
                hbp = xlog_get_bp(log, 1);
                if (!hbp)
-                       return ENOMEM;
+                       return -ENOMEM;
 
                error = xlog_bread(log, tail_blk, 1, hbp, &offset);
                if (error)
@@ -4110,11 +4111,11 @@ xlog_do_recovery_pass(
        }
 
        if (!hbp)
-               return ENOMEM;
+               return -ENOMEM;
        dbp = xlog_get_bp(log, BTOBB(h_size));
        if (!dbp) {
                xlog_put_bp(hbp);
-               return ENOMEM;
+               return -ENOMEM;
        }
 
        memset(rhash, 0, sizeof(rhash));
@@ -4388,7 +4389,7 @@ xlog_do_recover(
         * If IO errors happened during recovery, bail out.
         */
        if (XFS_FORCED_SHUTDOWN(log->l_mp)) {
-               return EIO;
+               return -EIO;
        }
 
        /*
@@ -4415,7 +4416,7 @@ xlog_do_recover(
 
        if (XFS_FORCED_SHUTDOWN(log->l_mp)) {
                xfs_buf_relse(bp);
-               return EIO;
+               return -EIO;
        }
 
        xfs_buf_iorequest(bp);
@@ -4492,7 +4493,7 @@ xlog_recover(
 "Please recover the log on a kernel that supports the unknown features.",
                                (log->l_mp->m_sb.sb_features_log_incompat &
                                        XFS_SB_FEAT_INCOMPAT_LOG_UNKNOWN));
-                       return EINVAL;
+                       return -EINVAL;
                }
 
                xfs_notice(log->l_mp, "Starting recovery (logdev: %s)",
index b50ec92f9620357dfa6d986fa3a1c9abbf747264..d5c44a6bdb5b50c4393b6648acc7533beaf25b36 100644 (file)
@@ -76,7 +76,7 @@ xfs_uuid_mount(
 
        if (uuid_is_nil(uuid)) {
                xfs_warn(mp, "Filesystem has nil UUID - can't mount");
-               return EINVAL;
+               return -EINVAL;
        }
 
        mutex_lock(&xfs_uuid_table_mutex);
@@ -104,7 +104,7 @@ xfs_uuid_mount(
  out_duplicate:
        mutex_unlock(&xfs_uuid_table_mutex);
        xfs_warn(mp, "Filesystem has duplicate UUID %pU - can't mount", uuid);
-       return EINVAL;
+       return -EINVAL;
 }
 
 STATIC void
@@ -175,10 +175,10 @@ xfs_sb_validate_fsb_count(
 
 #if XFS_BIG_BLKNOS     /* Limited by ULONG_MAX of page cache index */
        if (nblocks >> (PAGE_CACHE_SHIFT - sbp->sb_blocklog) > ULONG_MAX)
-               return EFBIG;
+               return -EFBIG;
 #else                  /* Limited by UINT_MAX of sectors */
        if (nblocks << (sbp->sb_blocklog - BBSHIFT) > UINT_MAX)
-               return EFBIG;
+               return -EFBIG;
 #endif
        return 0;
 }
@@ -308,15 +308,15 @@ reread:
        if (!bp) {
                if (loud)
                        xfs_warn(mp, "SB buffer read failed");
-               return EIO;
+               return -EIO;
        }
        if (bp->b_error) {
                error = bp->b_error;
                if (loud)
                        xfs_warn(mp, "SB validate failed with error %d.", error);
                /* bad CRC means corrupted metadata */
-               if (error == EFSBADCRC)
-                       error = EFSCORRUPTED;
+               if (error == -EFSBADCRC)
+                       error = -EFSCORRUPTED;
                goto release_buf;
        }
 
@@ -333,7 +333,7 @@ reread:
        if (sbp->sb_magicnum != XFS_SB_MAGIC) {
                if (loud)
                        xfs_warn(mp, "Invalid superblock magic number");
-               error = EINVAL;
+               error = -EINVAL;
                goto release_buf;
        }
 
@@ -344,7 +344,7 @@ reread:
                if (loud)
                        xfs_warn(mp, "device supports %u byte sectors (not %u)",
                                sector_size, sbp->sb_sectsize);
-               error = ENOSYS;
+               error = -ENOSYS;
                goto release_buf;
        }
 
@@ -392,7 +392,7 @@ xfs_update_alignment(xfs_mount_t *mp)
                        xfs_warn(mp,
                "alignment check failed: sunit/swidth vs. blocksize(%d)",
                                sbp->sb_blocksize);
-                       return EINVAL;
+                       return -EINVAL;
                } else {
                        /*
                         * Convert the stripe unit and width to FSBs.
@@ -402,14 +402,14 @@ xfs_update_alignment(xfs_mount_t *mp)
                                xfs_warn(mp,
                        "alignment check failed: sunit/swidth vs. agsize(%d)",
                                         sbp->sb_agblocks);
-                               return EINVAL;
+                               return -EINVAL;
                        } else if (mp->m_dalign) {
                                mp->m_swidth = XFS_BB_TO_FSBT(mp, mp->m_swidth);
                        } else {
                                xfs_warn(mp,
                        "alignment check failed: sunit(%d) less than bsize(%d)",
                                         mp->m_dalign, sbp->sb_blocksize);
-                               return EINVAL;
+                               return -EINVAL;
                        }
                }
 
@@ -429,7 +429,7 @@ xfs_update_alignment(xfs_mount_t *mp)
                } else {
                        xfs_warn(mp,
        "cannot change alignment: superblock does not support data alignment");
-                       return EINVAL;
+                       return -EINVAL;
                }
        } else if ((mp->m_flags & XFS_MOUNT_NOALIGN) != XFS_MOUNT_NOALIGN &&
                    xfs_sb_version_hasdalign(&mp->m_sb)) {
@@ -556,14 +556,14 @@ xfs_check_sizes(xfs_mount_t *mp)
        d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks);
        if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_dblocks) {
                xfs_warn(mp, "filesystem size mismatch detected");
-               return EFBIG;
+               return -EFBIG;
        }
        bp = xfs_buf_read_uncached(mp->m_ddev_targp,
                                        d - XFS_FSS_TO_BB(mp, 1),
                                        XFS_FSS_TO_BB(mp, 1), 0, NULL);
        if (!bp) {
                xfs_warn(mp, "last sector read failed");
-               return EIO;
+               return -EIO;
        }
        xfs_buf_relse(bp);
 
@@ -571,14 +571,14 @@ xfs_check_sizes(xfs_mount_t *mp)
                d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_logblocks);
                if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_logblocks) {
                        xfs_warn(mp, "log size mismatch detected");
-                       return EFBIG;
+                       return -EFBIG;
                }
                bp = xfs_buf_read_uncached(mp->m_logdev_targp,
                                        d - XFS_FSB_TO_BB(mp, 1),
                                        XFS_FSB_TO_BB(mp, 1), 0, NULL);
                if (!bp) {
                        xfs_warn(mp, "log device read failed");
-                       return EIO;
+                       return -EIO;
                }
                xfs_buf_relse(bp);
        }
@@ -816,7 +816,7 @@ xfs_mountfs(
        if (!sbp->sb_logblocks) {
                xfs_warn(mp, "no log defined");
                XFS_ERROR_REPORT("xfs_mountfs", XFS_ERRLEVEL_LOW, mp);
-               error = EFSCORRUPTED;
+               error = -EFSCORRUPTED;
                goto out_free_perag;
        }
 
@@ -876,7 +876,7 @@ xfs_mountfs(
                xfs_iunlock(rip, XFS_ILOCK_EXCL);
                XFS_ERROR_REPORT("xfs_mountfs_int(2)", XFS_ERRLEVEL_LOW,
                                 mp);
-               error = EFSCORRUPTED;
+               error = -EFSCORRUPTED;
                goto out_rele_rip;
        }
        mp->m_rootip = rip;     /* save it */
@@ -1152,7 +1152,7 @@ xfs_mod_incore_sb_unlocked(
                lcounter += delta;
                if (lcounter < 0) {
                        ASSERT(0);
-                       return EINVAL;
+                       return -EINVAL;
                }
                mp->m_sb.sb_icount = lcounter;
                return 0;
@@ -1161,7 +1161,7 @@ xfs_mod_incore_sb_unlocked(
                lcounter += delta;
                if (lcounter < 0) {
                        ASSERT(0);
-                       return EINVAL;
+                       return -EINVAL;
                }
                mp->m_sb.sb_ifree = lcounter;
                return 0;
@@ -1191,7 +1191,7 @@ xfs_mod_incore_sb_unlocked(
                         * blocks if were allowed to.
                         */
                        if (!rsvd)
-                               return ENOSPC;
+                               return -ENOSPC;
 
                        lcounter = (long long)mp->m_resblks_avail + delta;
                        if (lcounter >= 0) {
@@ -1202,7 +1202,7 @@ xfs_mod_incore_sb_unlocked(
                                "Filesystem \"%s\": reserve blocks depleted! "
                                "Consider increasing reserve pool size.",
                                mp->m_fsname);
-                       return ENOSPC;
+                       return -ENOSPC;
                }
 
                mp->m_sb.sb_fdblocks = lcounter + XFS_ALLOC_SET_ASIDE(mp);
@@ -1211,7 +1211,7 @@ xfs_mod_incore_sb_unlocked(
                lcounter = (long long)mp->m_sb.sb_frextents;
                lcounter += delta;
                if (lcounter < 0) {
-                       return ENOSPC;
+                       return -ENOSPC;
                }
                mp->m_sb.sb_frextents = lcounter;
                return 0;
@@ -1220,7 +1220,7 @@ xfs_mod_incore_sb_unlocked(
                lcounter += delta;
                if (lcounter < 0) {
                        ASSERT(0);
-                       return EINVAL;
+                       return -EINVAL;
                }
                mp->m_sb.sb_dblocks = lcounter;
                return 0;
@@ -1229,7 +1229,7 @@ xfs_mod_incore_sb_unlocked(
                scounter += delta;
                if (scounter < 0) {
                        ASSERT(0);
-                       return EINVAL;
+                       return -EINVAL;
                }
                mp->m_sb.sb_agcount = scounter;
                return 0;
@@ -1238,7 +1238,7 @@ xfs_mod_incore_sb_unlocked(
                scounter += delta;
                if (scounter < 0) {
                        ASSERT(0);
-                       return EINVAL;
+                       return -EINVAL;
                }
                mp->m_sb.sb_imax_pct = scounter;
                return 0;
@@ -1247,7 +1247,7 @@ xfs_mod_incore_sb_unlocked(
                scounter += delta;
                if (scounter < 0) {
                        ASSERT(0);
-                       return EINVAL;
+                       return -EINVAL;
                }
                mp->m_sb.sb_rextsize = scounter;
                return 0;
@@ -1256,7 +1256,7 @@ xfs_mod_incore_sb_unlocked(
                scounter += delta;
                if (scounter < 0) {
                        ASSERT(0);
-                       return EINVAL;
+                       return -EINVAL;
                }
                mp->m_sb.sb_rbmblocks = scounter;
                return 0;
@@ -1265,7 +1265,7 @@ xfs_mod_incore_sb_unlocked(
                lcounter += delta;
                if (lcounter < 0) {
                        ASSERT(0);
-                       return EINVAL;
+                       return -EINVAL;
                }
                mp->m_sb.sb_rblocks = lcounter;
                return 0;
@@ -1274,7 +1274,7 @@ xfs_mod_incore_sb_unlocked(
                lcounter += delta;
                if (lcounter < 0) {
                        ASSERT(0);
-                       return EINVAL;
+                       return -EINVAL;
                }
                mp->m_sb.sb_rextents = lcounter;
                return 0;
@@ -1283,13 +1283,13 @@ xfs_mod_incore_sb_unlocked(
                scounter += delta;
                if (scounter < 0) {
                        ASSERT(0);
-                       return EINVAL;
+                       return -EINVAL;
                }
                mp->m_sb.sb_rextslog = scounter;
                return 0;
        default:
                ASSERT(0);
-               return EINVAL;
+               return -EINVAL;
        }
 }
 
@@ -1452,7 +1452,7 @@ xfs_dev_is_read_only(
            (mp->m_rtdev_targp && xfs_readonly_buftarg(mp->m_rtdev_targp))) {
                xfs_notice(mp, "%s required on read-only device.", message);
                xfs_notice(mp, "write access unavailable, cannot proceed.");
-               return EROFS;
+               return -EROFS;
        }
        return 0;
 }
@@ -1995,7 +1995,7 @@ slow_path:
         * (e.g. lots of space just got freed). After that
         * we are done.
         */
-       if (ret != ENOSPC)
+       if (ret != -ENOSPC)
                xfs_icsb_balance_counter(mp, field, 0);
        xfs_icsb_unlock(mp);
        return ret;
index f99b4933dc226267935493cacd0ba103a38cef30..1eb6f3df698c8bb4eac11b5c03aa23790cbc65c4 100644 (file)
@@ -337,20 +337,20 @@ xfs_mru_cache_create(
                *mrup = NULL;
 
        if (!mrup || !grp_count || !lifetime_ms || !free_func)
-               return EINVAL;
+               return -EINVAL;
 
        if (!(grp_time = msecs_to_jiffies(lifetime_ms) / grp_count))
-               return EINVAL;
+               return -EINVAL;
 
        if (!(mru = kmem_zalloc(sizeof(*mru), KM_SLEEP)))
-               return ENOMEM;
+               return -ENOMEM;
 
        /* An extra list is needed to avoid reaping up to a grp_time early. */
        mru->grp_count = grp_count + 1;
        mru->lists = kmem_zalloc(mru->grp_count * sizeof(*mru->lists), KM_SLEEP);
 
        if (!mru->lists) {
-               err = ENOMEM;
+               err = -ENOMEM;
                goto exit;
        }
 
@@ -434,16 +434,16 @@ xfs_mru_cache_insert(
 
        ASSERT(mru && mru->lists);
        if (!mru || !mru->lists)
-               return EINVAL;
+               return -EINVAL;
 
        if (radix_tree_preload(GFP_KERNEL))
-               return ENOMEM;
+               return -ENOMEM;
 
        INIT_LIST_HEAD(&elem->list_node);
        elem->key = key;
 
        spin_lock(&mru->lock);
-       error = -radix_tree_insert(&mru->store, key, elem);
+       error = radix_tree_insert(&mru->store, key, elem);
        radix_tree_preload_end();
        if (!error)
                _xfs_mru_cache_list_insert(mru, elem);
index a97d94d69a1e0e91b4cdc03d51cd498811e5a9ab..ba284f6469db33eb7ea0be5d5a70cf78d2f9713b 100644 (file)
@@ -98,18 +98,18 @@ restart:
                        next_index = be32_to_cpu(dqp->q_core.d_id) + 1;
 
                        error = execute(batch[i], data);
-                       if (error == EAGAIN) {
+                       if (error == -EAGAIN) {
                                skipped++;
                                continue;
                        }
-                       if (error && last_error != EFSCORRUPTED)
+                       if (error && last_error != -EFSCORRUPTED)
                                last_error = error;
                }
 
                mutex_unlock(&qi->qi_tree_lock);
 
                /* bail out if the filesystem is corrupted.  */
-               if (last_error == EFSCORRUPTED) {
+               if (last_error == -EFSCORRUPTED) {
                        skipped = 0;
                        break;
                }
@@ -138,7 +138,7 @@ xfs_qm_dqpurge(
        xfs_dqlock(dqp);
        if ((dqp->dq_flags & XFS_DQ_FREEING) || dqp->q_nrefs != 0) {
                xfs_dqunlock(dqp);
-               return EAGAIN;
+               return -EAGAIN;
        }
 
        dqp->dq_flags |= XFS_DQ_FREEING;
@@ -671,7 +671,7 @@ xfs_qm_init_quotainfo(
 
        qinf = mp->m_quotainfo = kmem_zalloc(sizeof(xfs_quotainfo_t), KM_SLEEP);
 
-       error = -list_lru_init(&qinf->qi_lru);
+       error = list_lru_init(&qinf->qi_lru);
        if (error)
                goto out_free_qinf;
 
@@ -995,7 +995,7 @@ xfs_qm_dqiter_bufs(
                 * will leave a trace in the log indicating corruption has
                 * been detected.
                 */
-               if (error == EFSCORRUPTED) {
+               if (error == -EFSCORRUPTED) {
                        error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp,
                                      XFS_FSB_TO_DADDR(mp, bno),
                                      mp->m_quotainfo->qi_dqchunklen, 0, &bp,
@@ -1138,8 +1138,8 @@ xfs_qm_quotacheck_dqadjust(
                /*
                 * Shouldn't be able to turn off quotas here.
                 */
-               ASSERT(error != ESRCH);
-               ASSERT(error != ENOENT);
+               ASSERT(error != -ESRCH);
+               ASSERT(error != -ENOENT);
                return error;
        }
 
@@ -1226,7 +1226,7 @@ xfs_qm_dqusage_adjust(
         */
        if (xfs_is_quota_inode(&mp->m_sb, ino)) {
                *res = BULKSTAT_RV_NOTHING;
-               return EINVAL;
+               return -EINVAL;
        }
 
        /*
@@ -1679,7 +1679,7 @@ xfs_qm_vop_dqalloc(
                                                 XFS_QMOPT_DOWARN,
                                                 &uq);
                        if (error) {
-                               ASSERT(error != ENOENT);
+                               ASSERT(error != -ENOENT);
                                return error;
                        }
                        /*
@@ -1706,7 +1706,7 @@ xfs_qm_vop_dqalloc(
                                                 XFS_QMOPT_DOWARN,
                                                 &gq);
                        if (error) {
-                               ASSERT(error != ENOENT);
+                               ASSERT(error != -ENOENT);
                                goto error_rele;
                        }
                        xfs_dqunlock(gq);
@@ -1726,7 +1726,7 @@ xfs_qm_vop_dqalloc(
                                                 XFS_QMOPT_DOWARN,
                                                 &pq);
                        if (error) {
-                               ASSERT(error != ENOENT);
+                               ASSERT(error != -ENOENT);
                                goto error_rele;
                        }
                        xfs_dqunlock(pq);
index fa9797382d5b153547ab35c6966d4468573c9858..2c61e61b0205eef889af4fe88c2a58359e010649 100644 (file)
@@ -117,7 +117,7 @@ xfs_qm_newmount(
                        (uquotaondisk ? " usrquota" : ""),
                        (gquotaondisk ? " grpquota" : ""),
                        (pquotaondisk ? " prjquota" : ""));
-               return EPERM;
+               return -EPERM;
        }
 
        if (XFS_IS_QUOTA_ON(mp) || quotaondisk) {
index f5167e8378282e13df0343bb8571560710b155c0..80f2d77d929a87797b67269880b1c04907b9f402 100644 (file)
@@ -64,10 +64,10 @@ xfs_qm_scall_quotaoff(
        /*
         * No file system can have quotas enabled on disk but not in core.
         * Note that quota utilities (like quotaoff) _expect_
-        * errno == EEXIST here.
+        * errno == -EEXIST here.
         */
        if ((mp->m_qflags & flags) == 0)
-               return EEXIST;
+               return -EEXIST;
        error = 0;
 
        flags &= (XFS_ALL_QUOTA_ACCT | XFS_ALL_QUOTA_ENFD);
@@ -278,13 +278,13 @@ xfs_qm_scall_trunc_qfiles(
        xfs_mount_t     *mp,
        uint            flags)
 {
-       int             error = EINVAL;
+       int             error = -EINVAL;
 
        if (!xfs_sb_version_hasquota(&mp->m_sb) || flags == 0 ||
            (flags & ~XFS_DQ_ALLTYPES)) {
                xfs_debug(mp, "%s: flags=%x m_qflags=%x",
                        __func__, flags, mp->m_qflags);
-               return EINVAL;
+               return -EINVAL;
        }
 
        if (flags & XFS_DQ_USER) {
@@ -328,7 +328,7 @@ xfs_qm_scall_quotaon(
        if (flags == 0) {
                xfs_debug(mp, "%s: zero flags, m_qflags=%x",
                        __func__, mp->m_qflags);
-               return EINVAL;
+               return -EINVAL;
        }
 
        /* No fs can turn on quotas with a delayed effect */
@@ -351,13 +351,13 @@ xfs_qm_scall_quotaon(
                xfs_debug(mp,
                        "%s: Can't enforce without acct, flags=%x sbflags=%x",
                        __func__, flags, mp->m_sb.sb_qflags);
-               return EINVAL;
+               return -EINVAL;
        }
        /*
         * If everything's up to-date incore, then don't waste time.
         */
        if ((mp->m_qflags & flags) == flags)
-               return EEXIST;
+               return -EEXIST;
 
        /*
         * Change sb_qflags on disk but not incore mp->qflags
@@ -372,7 +372,7 @@ xfs_qm_scall_quotaon(
         * There's nothing to change if it's the same.
         */
        if ((qf & flags) == flags && sbflags == 0)
-               return EEXIST;
+               return -EEXIST;
        sbflags |= XFS_SB_QFLAGS;
 
        if ((error = xfs_qm_write_sb_changes(mp, sbflags)))
@@ -390,7 +390,7 @@ xfs_qm_scall_quotaon(
                return 0;
 
        if (! XFS_IS_QUOTA_RUNNING(mp))
-               return ESRCH;
+               return -ESRCH;
 
        /*
         * Switch on quota enforcement in core.
@@ -595,7 +595,7 @@ xfs_qm_scall_setqlim(
        xfs_qcnt_t              hard, soft;
 
        if (newlim->d_fieldmask & ~XFS_DQ_MASK)
-               return EINVAL;
+               return -EINVAL;
        if ((newlim->d_fieldmask & XFS_DQ_MASK) == 0)
                return 0;
 
@@ -615,7 +615,7 @@ xfs_qm_scall_setqlim(
         */
        error = xfs_qm_dqget(mp, NULL, id, type, XFS_QMOPT_DQALLOC, &dqp);
        if (error) {
-               ASSERT(error != ENOENT);
+               ASSERT(error != -ENOENT);
                goto out_unlock;
        }
        xfs_dqunlock(dqp);
@@ -850,7 +850,7 @@ xfs_qm_scall_getquota(
         * our utility programs are concerned.
         */
        if (XFS_IS_DQUOT_UNINITIALIZED(dqp)) {
-               error = ENOENT;
+               error = -ENOENT;
                goto out_put;
        }
 
index 2ad1b9822e92f5f712b5cbeab615bd04c939d22d..4f7aecbe61da3e06a4231a5a29ff6a4e698fb429 100644 (file)
@@ -51,7 +51,7 @@ xfs_fs_get_xstate(
 
        if (!XFS_IS_QUOTA_RUNNING(mp))
                return -ENOSYS;
-       return -xfs_qm_scall_getqstat(mp, fqs);
+       return xfs_qm_scall_getqstat(mp, fqs);
 }
 
 STATIC int
@@ -63,7 +63,7 @@ xfs_fs_get_xstatev(
 
        if (!XFS_IS_QUOTA_RUNNING(mp))
                return -ENOSYS;
-       return -xfs_qm_scall_getqstatv(mp, fqs);
+       return xfs_qm_scall_getqstatv(mp, fqs);
 }
 
 STATIC int
@@ -95,11 +95,11 @@ xfs_fs_set_xstate(
 
        switch (op) {
        case Q_XQUOTAON:
-               return -xfs_qm_scall_quotaon(mp, flags);
+               return xfs_qm_scall_quotaon(mp, flags);
        case Q_XQUOTAOFF:
                if (!XFS_IS_QUOTA_ON(mp))
                        return -EINVAL;
-               return -xfs_qm_scall_quotaoff(mp, flags);
+               return xfs_qm_scall_quotaoff(mp, flags);
        }
 
        return -EINVAL;
@@ -112,7 +112,7 @@ xfs_fs_rm_xquota(
 {
        struct xfs_mount        *mp = XFS_M(sb);
        unsigned int            flags = 0;
-       
+
        if (sb->s_flags & MS_RDONLY)
                return -EROFS;
 
@@ -126,8 +126,8 @@ xfs_fs_rm_xquota(
        if (uflags & FS_USER_QUOTA)
                flags |= XFS_DQ_PROJ;
 
-       return -xfs_qm_scall_trunc_qfiles(mp, flags);
-}      
+       return xfs_qm_scall_trunc_qfiles(mp, flags);
+}
 
 STATIC int
 xfs_fs_get_dqblk(
@@ -142,7 +142,7 @@ xfs_fs_get_dqblk(
        if (!XFS_IS_QUOTA_ON(mp))
                return -ESRCH;
 
-       return -xfs_qm_scall_getquota(mp, from_kqid(&init_user_ns, qid),
+       return xfs_qm_scall_getquota(mp, from_kqid(&init_user_ns, qid),
                                      xfs_quota_type(qid.type), fdq);
 }
 
@@ -161,7 +161,7 @@ xfs_fs_set_dqblk(
        if (!XFS_IS_QUOTA_ON(mp))
                return -ESRCH;
 
-       return -xfs_qm_scall_setqlim(mp, from_kqid(&init_user_ns, qid),
+       return xfs_qm_scall_setqlim(mp, from_kqid(&init_user_ns, qid),
                                     xfs_quota_type(qid.type), fdq);
 }
 
index 1a98a783cf4b8efd44fca58d6f5dd56db0343ba4..b741d7286990e2d1b99cfc040d1c24c5154a6acf 100644 (file)
@@ -863,7 +863,7 @@ xfs_growfs_rt_alloc(
                                        XFS_BMAPI_METADATA, &firstblock,
                                        resblks, &map, &nmap, &flist);
                if (!error && nmap < 1)
-                       error = ENOSPC;
+                       error = -ENOSPC;
                if (error)
                        goto error_cancel;
                /*
@@ -903,7 +903,7 @@ xfs_growfs_rt_alloc(
                        bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, d,
                                mp->m_bsize, 0);
                        if (bp == NULL) {
-                               error = EIO;
+                               error = -EIO;
 error_cancel:
                                xfs_trans_cancel(tp, cancelflags);
                                goto error;
@@ -962,11 +962,11 @@ xfs_growfs_rt(
         * Initial error checking.
         */
        if (!capable(CAP_SYS_ADMIN))
-               return EPERM;
+               return -EPERM;
        if (mp->m_rtdev_targp == NULL || mp->m_rbmip == NULL ||
            (nrblocks = in->newblocks) <= sbp->sb_rblocks ||
            (sbp->sb_rblocks && (in->extsize != sbp->sb_rextsize)))
-               return EINVAL;
+               return -EINVAL;
        if ((error = xfs_sb_validate_fsb_count(sbp, nrblocks)))
                return error;
        /*
@@ -976,7 +976,7 @@ xfs_growfs_rt(
                                XFS_FSB_TO_BB(mp, nrblocks - 1),
                                XFS_FSB_TO_BB(mp, 1), 0, NULL);
        if (!bp)
-               return EIO;
+               return -EIO;
        if (bp->b_error) {
                error = bp->b_error;
                xfs_buf_relse(bp);
@@ -1001,7 +1001,7 @@ xfs_growfs_rt(
         * since we'll log basically the whole summary file at once.
         */
        if (nrsumblocks > (mp->m_sb.sb_logblocks >> 1))
-               return EINVAL;
+               return -EINVAL;
        /*
         * Get the old block counts for bitmap and summary inodes.
         * These can't change since other growfs callers are locked out.
@@ -1208,7 +1208,7 @@ xfs_rtallocate_extent(
                                len, &sumbp, &sb, prod, &r);
                break;
        default:
-               error = EIO;
+               error = -EIO;
                ASSERT(0);
        }
        if (error)
@@ -1247,7 +1247,7 @@ xfs_rtmount_init(
        if (mp->m_rtdev_targp == NULL) {
                xfs_warn(mp,
        "Filesystem has a realtime volume, use rtdev=device option");
-               return ENODEV;
+               return -ENODEV;
        }
        mp->m_rsumlevels = sbp->sb_rextslog + 1;
        mp->m_rsumsize =
@@ -1263,7 +1263,7 @@ xfs_rtmount_init(
                xfs_warn(mp, "realtime mount -- %llu != %llu",
                        (unsigned long long) XFS_BB_TO_FSB(mp, d),
                        (unsigned long long) mp->m_sb.sb_rblocks);
-               return EFBIG;
+               return -EFBIG;
        }
        bp = xfs_buf_read_uncached(mp->m_rtdev_targp,
                                        d - XFS_FSB_TO_BB(mp, 1),
@@ -1272,7 +1272,7 @@ xfs_rtmount_init(
                xfs_warn(mp, "realtime device size check failed");
                if (bp)
                        xfs_buf_relse(bp);
-               return EIO;
+               return -EIO;
        }
        xfs_buf_relse(bp);
        return 0;
index 752b63d103003288d48c463571cc59279f8c531d..c642795324af649c1c80666e5bdc7e0739551e1d 100644 (file)
@@ -132,7 +132,7 @@ xfs_rtmount_init(
                return 0;
 
        xfs_warn(mp, "Not built with CONFIG_XFS_RT");
-       return ENOSYS;
+       return -ENOSYS;
 }
 # define xfs_rtmount_inodes(m)  (((mp)->m_sb.sb_rblocks == 0)? 0 : (ENOSYS))
 # define xfs_rtunmount_inodes(m)
index 12d3ad3203ff84618856ed332a10d3adaa7e92b9..f2e5f8a503d2f8c40c0f90fd791ad77f30c56c88 100644 (file)
@@ -185,7 +185,7 @@ xfs_parseargs(
         */
        mp->m_fsname = kstrndup(sb->s_id, MAXNAMELEN, GFP_KERNEL);
        if (!mp->m_fsname)
-               return ENOMEM;
+               return -ENOMEM;
        mp->m_fsname_len = strlen(mp->m_fsname) + 1;
 
        /*
@@ -227,57 +227,57 @@ xfs_parseargs(
                        if (!value || !*value) {
                                xfs_warn(mp, "%s option requires an argument",
                                        this_char);
-                               return EINVAL;
+                               return -EINVAL;
                        }
                        if (kstrtoint(value, 10, &mp->m_logbufs))
-                               return EINVAL;
+                               return -EINVAL;
                } else if (!strcmp(this_char, MNTOPT_LOGBSIZE)) {
                        if (!value || !*value) {
                                xfs_warn(mp, "%s option requires an argument",
                                        this_char);
-                               return EINVAL;
+                               return -EINVAL;
                        }
                        if (suffix_kstrtoint(value, 10, &mp->m_logbsize))
-                               return EINVAL;
+                               return -EINVAL;
                } else if (!strcmp(this_char, MNTOPT_LOGDEV)) {
                        if (!value || !*value) {
                                xfs_warn(mp, "%s option requires an argument",
                                        this_char);
-                               return EINVAL;
+                               return -EINVAL;
                        }
                        mp->m_logname = kstrndup(value, MAXNAMELEN, GFP_KERNEL);
                        if (!mp->m_logname)
-                               return ENOMEM;
+                               return -ENOMEM;
                } else if (!strcmp(this_char, MNTOPT_MTPT)) {
                        xfs_warn(mp, "%s option not allowed on this system",
                                this_char);
-                       return EINVAL;
+                       return -EINVAL;
                } else if (!strcmp(this_char, MNTOPT_RTDEV)) {
                        if (!value || !*value) {
                                xfs_warn(mp, "%s option requires an argument",
                                        this_char);
-                               return EINVAL;
+                               return -EINVAL;
                        }
                        mp->m_rtname = kstrndup(value, MAXNAMELEN, GFP_KERNEL);
                        if (!mp->m_rtname)
-                               return ENOMEM;
+                               return -ENOMEM;
                } else if (!strcmp(this_char, MNTOPT_BIOSIZE)) {
                        if (!value || !*value) {
                                xfs_warn(mp, "%s option requires an argument",
                                        this_char);
-                               return EINVAL;
+                               return -EINVAL;
                        }
                        if (kstrtoint(value, 10, &iosize))
-                               return EINVAL;
+                               return -EINVAL;
                        iosizelog = ffs(iosize) - 1;
                } else if (!strcmp(this_char, MNTOPT_ALLOCSIZE)) {
                        if (!value || !*value) {
                                xfs_warn(mp, "%s option requires an argument",
                                        this_char);
-                               return EINVAL;
+                               return -EINVAL;
                        }
                        if (suffix_kstrtoint(value, 10, &iosize))
-                               return EINVAL;
+                               return -EINVAL;
                        iosizelog = ffs(iosize) - 1;
                } else if (!strcmp(this_char, MNTOPT_GRPID) ||
                           !strcmp(this_char, MNTOPT_BSDGROUPS)) {
@@ -297,18 +297,18 @@ xfs_parseargs(
                        if (!value || !*value) {
                                xfs_warn(mp, "%s option requires an argument",
                                        this_char);
-                               return EINVAL;
+                               return -EINVAL;
                        }
                        if (kstrtoint(value, 10, &dsunit))
-                               return EINVAL;
+                               return -EINVAL;
                } else if (!strcmp(this_char, MNTOPT_SWIDTH)) {
                        if (!value || !*value) {
                                xfs_warn(mp, "%s option requires an argument",
                                        this_char);
-                               return EINVAL;
+                               return -EINVAL;
                        }
                        if (kstrtoint(value, 10, &dswidth))
-                               return EINVAL;
+                               return -EINVAL;
                } else if (!strcmp(this_char, MNTOPT_32BITINODE)) {
                        mp->m_flags |= XFS_MOUNT_SMALL_INUMS;
                } else if (!strcmp(this_char, MNTOPT_64BITINODE)) {
@@ -316,7 +316,7 @@ xfs_parseargs(
 #if !XFS_BIG_INUMS
                        xfs_warn(mp, "%s option not allowed on this system",
                                this_char);
-                       return EINVAL;
+                       return -EINVAL;
 #endif
                } else if (!strcmp(this_char, MNTOPT_NOUUID)) {
                        mp->m_flags |= XFS_MOUNT_NOUUID;
@@ -390,7 +390,7 @@ xfs_parseargs(
        "irixsgid is now a sysctl(2) variable, option is deprecated.");
                } else {
                        xfs_warn(mp, "unknown mount option [%s].", this_char);
-                       return EINVAL;
+                       return -EINVAL;
                }
        }
 
@@ -400,32 +400,32 @@ xfs_parseargs(
        if ((mp->m_flags & XFS_MOUNT_NORECOVERY) &&
            !(mp->m_flags & XFS_MOUNT_RDONLY)) {
                xfs_warn(mp, "no-recovery mounts must be read-only.");
-               return EINVAL;
+               return -EINVAL;
        }
 
        if ((mp->m_flags & XFS_MOUNT_NOALIGN) && (dsunit || dswidth)) {
                xfs_warn(mp,
        "sunit and swidth options incompatible with the noalign option");
-               return EINVAL;
+               return -EINVAL;
        }
 
 #ifndef CONFIG_XFS_QUOTA
        if (XFS_IS_QUOTA_RUNNING(mp)) {
                xfs_warn(mp, "quota support not available in this kernel.");
-               return EINVAL;
+               return -EINVAL;
        }
 #endif
 
        if ((dsunit && !dswidth) || (!dsunit && dswidth)) {
                xfs_warn(mp, "sunit and swidth must be specified together");
-               return EINVAL;
+               return -EINVAL;
        }
 
        if (dsunit && (dswidth % dsunit != 0)) {
                xfs_warn(mp,
        "stripe width (%d) must be a multiple of the stripe unit (%d)",
                        dswidth, dsunit);
-               return EINVAL;
+               return -EINVAL;
        }
 
 done:
@@ -446,7 +446,7 @@ done:
             mp->m_logbufs > XLOG_MAX_ICLOGS)) {
                xfs_warn(mp, "invalid logbufs value: %d [not %d-%d]",
                        mp->m_logbufs, XLOG_MIN_ICLOGS, XLOG_MAX_ICLOGS);
-               return EINVAL;
+               return -EINVAL;
        }
        if (mp->m_logbsize != -1 &&
            mp->m_logbsize !=  0 &&
@@ -456,7 +456,7 @@ done:
                xfs_warn(mp,
                        "invalid logbufsize: %d [not 16k,32k,64k,128k or 256k]",
                        mp->m_logbsize);
-               return EINVAL;
+               return -EINVAL;
        }
 
        if (iosizelog) {
@@ -465,7 +465,7 @@ done:
                        xfs_warn(mp, "invalid log iosize: %d [not %d-%d]",
                                iosizelog, XFS_MIN_IO_LOG,
                                XFS_MAX_IO_LOG);
-                       return EINVAL;
+                       return -EINVAL;
                }
 
                mp->m_flags |= XFS_MOUNT_DFLT_IOSIZE;
@@ -686,7 +686,7 @@ xfs_blkdev_get(
                xfs_warn(mp, "Invalid device [%s], error=%d\n", name, error);
        }
 
-       return -error;
+       return error;
 }
 
 STATIC void
@@ -756,7 +756,7 @@ xfs_open_devices(
                if (rtdev == ddev || rtdev == logdev) {
                        xfs_warn(mp,
        "Cannot mount filesystem with identical rtdev and ddev/logdev.");
-                       error = EINVAL;
+                       error = -EINVAL;
                        goto out_close_rtdev;
                }
        }
@@ -764,7 +764,7 @@ xfs_open_devices(
        /*
         * Setup xfs_mount buffer target pointers
         */
-       error = ENOMEM;
+       error = -ENOMEM;
        mp->m_ddev_targp = xfs_alloc_buftarg(mp, ddev);
        if (!mp->m_ddev_targp)
                goto out_close_rtdev;
@@ -1295,7 +1295,7 @@ xfs_fs_freeze(
 
        xfs_save_resvblks(mp);
        xfs_quiesce_attr(mp);
-       return -xfs_fs_log_dummy(mp);
+       return xfs_fs_log_dummy(mp);
 }
 
 STATIC int
@@ -1314,7 +1314,7 @@ xfs_fs_show_options(
        struct seq_file         *m,
        struct dentry           *root)
 {
-       return -xfs_showargs(XFS_M(root->d_sb), m);
+       return xfs_showargs(XFS_M(root->d_sb), m);
 }
 
 /*
@@ -1336,14 +1336,14 @@ xfs_finish_flags(
                           mp->m_logbsize < mp->m_sb.sb_logsunit) {
                        xfs_warn(mp,
                "logbuf size must be greater than or equal to log stripe size");
-                       return EINVAL;
+                       return -EINVAL;
                }
        } else {
                /* Fail a mount if the logbuf is larger than 32K */
                if (mp->m_logbsize > XLOG_BIG_RECORD_BSIZE) {
                        xfs_warn(mp,
                "logbuf size for version 1 logs must be 16K or 32K");
-                       return EINVAL;
+                       return -EINVAL;
                }
        }
 
@@ -1355,7 +1355,7 @@ xfs_finish_flags(
                xfs_warn(mp,
 "Cannot mount a V5 filesystem as %s. %s is always enabled for V5 filesystems.",
                        MNTOPT_NOATTR2, MNTOPT_ATTR2);
-               return EINVAL;
+               return -EINVAL;
        }
 
        /*
@@ -1372,7 +1372,7 @@ xfs_finish_flags(
        if ((mp->m_sb.sb_flags & XFS_SBF_READONLY) && !ronly) {
                xfs_warn(mp,
                        "cannot mount a read-only filesystem as read-write");
-               return EROFS;
+               return -EROFS;
        }
 
        if ((mp->m_qflags & (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE)) &&
@@ -1380,7 +1380,7 @@ xfs_finish_flags(
            !xfs_sb_version_has_pquotino(&mp->m_sb)) {
                xfs_warn(mp,
                  "Super block does not support project and group quota together");
-               return EINVAL;
+               return -EINVAL;
        }
 
        return 0;
@@ -1394,7 +1394,7 @@ xfs_fs_fill_super(
 {
        struct inode            *root;
        struct xfs_mount        *mp = NULL;
-       int                     flags = 0, error = ENOMEM;
+       int                     flags = 0, error = -ENOMEM;
 
        mp = kzalloc(sizeof(struct xfs_mount), GFP_KERNEL);
        if (!mp)
@@ -1428,11 +1428,11 @@ xfs_fs_fill_super(
        if (error)
                goto out_free_fsname;
 
-       error = -xfs_init_mount_workqueues(mp);
+       error = xfs_init_mount_workqueues(mp);
        if (error)
                goto out_close_devices;
 
-       error = -xfs_icsb_init_counters(mp);
+       error = xfs_icsb_init_counters(mp);
        if (error)
                goto out_destroy_workqueues;
 
@@ -1474,12 +1474,12 @@ xfs_fs_fill_super(
 
        root = igrab(VFS_I(mp->m_rootip));
        if (!root) {
-               error = ENOENT;
+               error = -ENOENT;
                goto out_unmount;
        }
        sb->s_root = d_make_root(root);
        if (!sb->s_root) {
-               error = ENOMEM;
+               error = -ENOMEM;
                goto out_unmount;
        }
 
@@ -1499,7 +1499,7 @@ out_destroy_workqueues:
        xfs_free_fsname(mp);
        kfree(mp);
  out:
-       return -error;
+       return error;
 
  out_unmount:
        xfs_filestream_unmount(mp);
index c2c8173d16344e967af898cbd26890e09f692f3a..6a944a2cd36fbf97717ea31f56e82c101caef3a9 100644 (file)
@@ -76,15 +76,15 @@ xfs_readlink_bmap(
                bp = xfs_buf_read(mp->m_ddev_targp, d, BTOBB(byte_cnt), 0,
                                  &xfs_symlink_buf_ops);
                if (!bp)
-                       return ENOMEM;
+                       return -ENOMEM;
                error = bp->b_error;
                if (error) {
                        xfs_buf_ioerror_alert(bp, __func__);
                        xfs_buf_relse(bp);
 
                        /* bad CRC means corrupted metadata */
-                       if (error == EFSBADCRC)
-                               error = EFSCORRUPTED;
+                       if (error == -EFSBADCRC)
+                               error = -EFSCORRUPTED;
                        goto out;
                }
                byte_cnt = XFS_SYMLINK_BUF_SPACE(mp, byte_cnt);
@@ -95,7 +95,7 @@ xfs_readlink_bmap(
                if (xfs_sb_version_hascrc(&mp->m_sb)) {
                        if (!xfs_symlink_hdr_ok(ip->i_ino, offset,
                                                        byte_cnt, bp)) {
-                               error = EFSCORRUPTED;
+                               error = -EFSCORRUPTED;
                                xfs_alert(mp,
 "symlink header does not match required off/len/owner (0x%x/Ox%x,0x%llx)",
                                        offset, byte_cnt, ip->i_ino);
@@ -135,7 +135,7 @@ xfs_readlink(
        trace_xfs_readlink(ip);
 
        if (XFS_FORCED_SHUTDOWN(mp))
-               return EIO;
+               return -EIO;
 
        xfs_ilock(ip, XFS_ILOCK_SHARED);
 
@@ -148,7 +148,7 @@ xfs_readlink(
                         __func__, (unsigned long long) ip->i_ino,
                         (long long) pathlen);
                ASSERT(0);
-               error = EFSCORRUPTED;
+               error = -EFSCORRUPTED;
                goto out;
        }
 
@@ -203,14 +203,14 @@ xfs_symlink(
        trace_xfs_symlink(dp, link_name);
 
        if (XFS_FORCED_SHUTDOWN(mp))
-               return EIO;
+               return -EIO;
 
        /*
         * Check component lengths of the target path name.
         */
        pathlen = strlen(target_path);
        if (pathlen >= MAXPATHLEN)      /* total string too long */
-               return ENAMETOOLONG;
+               return -ENAMETOOLONG;
 
        udqp = gdqp = NULL;
        prid = xfs_get_initial_prid(dp);
@@ -238,7 +238,7 @@ xfs_symlink(
                fs_blocks = xfs_symlink_blocks(mp, pathlen);
        resblks = XFS_SYMLINK_SPACE_RES(mp, link_name->len, fs_blocks);
        error = xfs_trans_reserve(tp, &M_RES(mp)->tr_symlink, resblks, 0);
-       if (error == ENOSPC && fs_blocks == 0) {
+       if (error == -ENOSPC && fs_blocks == 0) {
                resblks = 0;
                error = xfs_trans_reserve(tp, &M_RES(mp)->tr_symlink, 0, 0);
        }
@@ -254,7 +254,7 @@ xfs_symlink(
         * Check whether the directory allows new symlinks or not.
         */
        if (dp->i_d.di_flags & XFS_DIFLAG_NOSYMLINKS) {
-               error = EPERM;
+               error = -EPERM;
                goto error_return;
        }
 
@@ -284,7 +284,7 @@ xfs_symlink(
        error = xfs_dir_ialloc(&tp, dp, S_IFLNK | (mode & ~S_IFMT), 1, 0,
                               prid, resblks > 0, &ip, NULL);
        if (error) {
-               if (error == ENOSPC)
+               if (error == -ENOSPC)
                        goto error_return;
                goto error1;
        }
@@ -348,7 +348,7 @@ xfs_symlink(
                        bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, d,
                                               BTOBB(byte_cnt), 0);
                        if (!bp) {
-                               error = ENOMEM;
+                               error = -ENOMEM;
                                goto error2;
                        }
                        bp->b_ops = &xfs_symlink_buf_ops;
@@ -489,7 +489,7 @@ xfs_inactive_symlink_rmt(
                        XFS_FSB_TO_DADDR(mp, mval[i].br_startblock),
                        XFS_FSB_TO_BB(mp, mval[i].br_blockcount), 0);
                if (!bp) {
-                       error = ENOMEM;
+                       error = -ENOMEM;
                        goto error_bmap_cancel;
                }
                xfs_trans_binval(tp, bp);
@@ -562,7 +562,7 @@ xfs_inactive_symlink(
        trace_xfs_inactive_symlink(ip);
 
        if (XFS_FORCED_SHUTDOWN(mp))
-               return EIO;
+               return -EIO;
 
        xfs_ilock(ip, XFS_ILOCK_EXCL);
 
@@ -580,7 +580,7 @@ xfs_inactive_symlink(
                         __func__, (unsigned long long)ip->i_ino, pathlen);
                xfs_iunlock(ip, XFS_ILOCK_EXCL);
                ASSERT(0);
-               return EFSCORRUPTED;
+               return -EFSCORRUPTED;
        }
 
        if (ip->i_df.if_flags & XFS_IFINLINE) {
index 6b9b48dfddaa71c07ec8a62e807c6fb22468987b..30e8e34109553d3aee7673382f8b2ab2e44c8446 100644 (file)
@@ -190,7 +190,7 @@ xfs_trans_reserve(
                                          -((int64_t)blocks), rsvd);
                if (error != 0) {
                        current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
-                       return ENOSPC;
+                       return -ENOSPC;
                }
                tp->t_blk_res += blocks;
        }
@@ -241,7 +241,7 @@ xfs_trans_reserve(
                error = xfs_mod_incore_sb(tp->t_mountp, XFS_SBS_FREXTENTS,
                                          -((int64_t)rtextents), rsvd);
                if (error) {
-                       error = ENOSPC;
+                       error = -ENOSPC;
                        goto undo_log;
                }
                tp->t_rtx_res += rtextents;
@@ -874,7 +874,7 @@ xfs_trans_commit(
                goto out_unreserve;
 
        if (XFS_FORCED_SHUTDOWN(mp)) {
-               error = EIO;
+               error = -EIO;
                goto out_unreserve;
        }
 
@@ -917,7 +917,7 @@ out_unreserve:
        if (tp->t_ticket) {
                commit_lsn = xfs_log_done(mp, tp->t_ticket, NULL, log_flags);
                if (commit_lsn == -1 && !error)
-                       error = EIO;
+                       error = -EIO;
        }
        current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
        xfs_trans_free_items(tp, NULLCOMMITLSN, error ? XFS_TRANS_ABORT : 0);
index cb0f3a84cc68452155b36c6b4a754edd450aa619..859482f53b5a87540e54b2cddb7097c53caa7447 100644 (file)
@@ -762,7 +762,7 @@ xfs_trans_ail_init(
 
        ailp = kmem_zalloc(sizeof(struct xfs_ail), KM_MAYFAIL);
        if (!ailp)
-               return ENOMEM;
+               return -ENOMEM;
 
        ailp->xa_mount = mp;
        INIT_LIST_HEAD(&ailp->xa_ail);
@@ -781,7 +781,7 @@ xfs_trans_ail_init(
 
 out_free_ailp:
        kmem_free(ailp);
-       return ENOMEM;
+       return -ENOMEM;
 }
 
 void
index 33bf55d7403ab0845643acfc6901d5056c06a82c..96c898e7ac9a7af67f0ab5a6147c7ba9f01cf4b9 100644 (file)
@@ -266,7 +266,7 @@ xfs_trans_read_buf_map(
                bp = xfs_buf_read_map(target, map, nmaps, flags, ops);
                if (!bp)
                        return (flags & XBF_TRYLOCK) ?
-                                       EAGAIN : ENOMEM;
+                                       -EAGAIN : -ENOMEM;
 
                if (bp->b_error) {
                        error = bp->b_error;
@@ -276,8 +276,8 @@ xfs_trans_read_buf_map(
                        xfs_buf_relse(bp);
 
                        /* bad CRC means corrupted metadata */
-                       if (error == EFSBADCRC)
-                               error = EFSCORRUPTED;
+                       if (error == -EFSBADCRC)
+                               error = -EFSCORRUPTED;
                        return error;
                }
 #ifdef DEBUG
@@ -286,7 +286,7 @@ xfs_trans_read_buf_map(
                                if (((xfs_req_num++) % xfs_error_mod) == 0) {
                                        xfs_buf_relse(bp);
                                        xfs_debug(mp, "Returning error!");
-                                       return EIO;
+                                       return -EIO;
                                }
                        }
                }
@@ -342,8 +342,8 @@ xfs_trans_read_buf_map(
                                        xfs_force_shutdown(tp->t_mountp,
                                                        SHUTDOWN_META_IO_ERROR);
                                /* bad CRC means corrupted metadata */
-                               if (error == EFSBADCRC)
-                                       error = EFSCORRUPTED;
+                               if (error == -EFSBADCRC)
+                                       error = -EFSCORRUPTED;
                                return error;
                        }
                }
@@ -354,7 +354,7 @@ xfs_trans_read_buf_map(
                if (XFS_FORCED_SHUTDOWN(mp)) {
                        trace_xfs_trans_read_buf_shut(bp, _RET_IP_);
                        *bpp = NULL;
-                       return EIO;
+                       return -EIO;
                }
 
 
@@ -371,7 +371,7 @@ xfs_trans_read_buf_map(
        if (bp == NULL) {
                *bpp = NULL;
                return (flags & XBF_TRYLOCK) ?
-                                       0 : ENOMEM;
+                                       0 : -ENOMEM;
        }
        if (bp->b_error) {
                error = bp->b_error;
@@ -383,8 +383,8 @@ xfs_trans_read_buf_map(
                xfs_buf_relse(bp);
 
                /* bad CRC means corrupted metadata */
-               if (error == EFSBADCRC)
-                       error = EFSCORRUPTED;
+               if (error == -EFSBADCRC)
+                       error = -EFSCORRUPTED;
                return error;
        }
 #ifdef DEBUG
@@ -395,7 +395,7 @@ xfs_trans_read_buf_map(
                                                   SHUTDOWN_META_IO_ERROR);
                                xfs_buf_relse(bp);
                                xfs_debug(mp, "Returning trans error!");
-                               return EIO;
+                               return -EIO;
                        }
                }
        }
@@ -413,7 +413,7 @@ shutdown_abort:
        trace_xfs_trans_read_buf_shut(bp, _RET_IP_);
        xfs_buf_relse(bp);
        *bpp = NULL;
-       return EIO;
+       return -EIO;
 }
 
 /*
index 41172861e857bf8c487f7adf3037aad0214b1681..846e061c2e9870efebfd98ecb9f7e6de6be7a200 100644 (file)
@@ -722,8 +722,8 @@ xfs_trans_dqresv(
 error_return:
        xfs_dqunlock(dqp);
        if (flags & XFS_QMOPT_ENOSPC)
-               return ENOSPC;
-       return EDQUOT;
+               return -ENOSPC;
+       return -EDQUOT;
 }
 
 
index 78ed92a46fdd3323c9bada9a35257f839285c630..93455b99804155d11c748239fde20700eea76c05 100644 (file)
@@ -49,7 +49,7 @@ xfs_xattr_get(struct dentry *dentry, const char *name,
                value = NULL;
        }
 
-       error = -xfs_attr_get(ip, (unsigned char *)name, value, &asize, xflags);
+       error = xfs_attr_get(ip, (unsigned char *)name, value, &asize, xflags);
        if (error)
                return error;
        return asize;
@@ -71,8 +71,8 @@ xfs_xattr_set(struct dentry *dentry, const char *name, const void *value,
                xflags |= ATTR_REPLACE;
 
        if (!value)
-               return -xfs_attr_remove(ip, (unsigned char *)name, xflags);
-       return -xfs_attr_set(ip, (unsigned char *)name,
+               return xfs_attr_remove(ip, (unsigned char *)name, xflags);
+       return xfs_attr_set(ip, (unsigned char *)name,
                                (void *)value, size, xflags);
 }