2.4.23

 fs

 jfs

diff -urN linux-2.4.22/fs/jfs/jfs_dmap.c linux-2.4.23/fs/jfs/jfs_dmap.c
--- linux-2.4.22/fs/jfs/jfs_dmap.c   2003-06-13 07:51:37.000000000 -0700
+++ linux-2.4.23/fs/jfs/jfs_dmap.c   2003-11-28 10:26:21.000000000 -0800
@@ -1,5 +1,5 @@
 /*
- *   Copyright (c) International Business Machines Corp., 2000-2002
+ *   Copyright (C) International Business Machines Corp., 2000-2003
  *
  *   This program is free software;  you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -18,6 +18,7 @@
 
 #include <linux/fs.h>
 #include "jfs_incore.h"
+#include "jfs_superblock.h"
 #include "jfs_dmap.h"
 #include "jfs_imap.h"
 #include "jfs_lock.h"
@@ -135,7 +136,6 @@
 static int dbMaxBud(u8 * cp);
 s64 dbMapFileSizeToMapSize(struct inode *ipbmap);
 int blkstol2(s64 nb);
-void fsDirty(void);
 
 int cntlz(u32 value);
 int cnttz(u32 word);
@@ -189,8 +189,8 @@
  *
  * RETURN VALUES:
  *      0   - success
- *      ENOMEM   - insufficient memory
- *      EIO   - i/o error
+ *      -ENOMEM   - insufficient memory
+ *      -EIO   - i/o error
  */
 int dbMount(struct inode *ipbmap)
 {
@@ -205,7 +205,7 @@
    /* allocate memory for the in-memory bmap descriptor */
    bmp = kmalloc(sizeof(struct bmap), GFP_KERNEL);
    if (bmp == NULL)
-      return (ENOMEM);
+      return -ENOMEM;
 
    /* read the on-disk bmap descriptor. */
    mp = read_metapage(ipbmap,
@@ -213,7 +213,7 @@
             PSIZE, 0);
    if (mp == NULL) {
       kfree(bmp);
-      return (EIO);
+      return -EIO;
    }
 
    /* copy the on-disk bmap descriptor to its in-memory version. */
@@ -268,7 +268,7 @@
  *
  * RETURN VALUES:
  *      0   - success
- *      EIO   - i/o error
+ *      -EIO   - i/o error
  */
 int dbUnmount(struct inode *ipbmap, int mounterror)
 {
@@ -316,7 +316,7 @@
             PSIZE, 0);
    if (mp == NULL) {
       jfs_err("dbSync: read_metapage failed!");
-      return (EIO);
+      return -EIO;
    }
    /* copy the in-memory version of the bmap to the on-disk version */
    dbmp_le = (struct dbmap *) mp->data;
@@ -368,7 +368,7 @@
  *
  * RETURN VALUES:
  *      0   - success
- *      EIO   - i/o error
+ *      -EIO   - i/o error
  */
 int dbFree(struct inode *ip, s64 blkno, s64 nblocks)
 {
@@ -383,20 +383,13 @@
 
    /* block to be freed better be within the mapsize. */
    if (unlikely(blkno + nblocks > bmp->db_mapsize)) {
-      /*
-       * Trying to catch a bug here
-       */
-      printk(KERN_ERR
-             "JFS: dbFree asked to free block larger than mapsize\n");
-      printk(KERN_ERR
-             "blkno = 0x%Lx, nblocks = 0x%Lx, mapsize = 0x%Lx\n",
-             blkno, nblocks, bmp->db_mapsize);
-      printk(KERN_ERR "ino = %ld, cflag = %lx\n", ip->i_ino,
-             JFS_IP(ip)->cflag);
-      dump_stack();
-      /* Make sure fsck fixes things back up */
-      updateSuper(ip->i_sb, FM_DIRTY);
-      return -EIO;   /* Nobody checks the return code */
+      IREAD_UNLOCK(ipbmap);
+      printk(KERN_ERR "blkno = %Lx, nblocks = %Lx\n",
+             (unsigned long long) blkno,
+             (unsigned long long) nblocks);
+      jfs_error(ip->i_sb,
+           "dbFree: block to be freed is outside the map");
+      return -EIO;
    }
 
    /*
@@ -414,7 +407,7 @@
       mp = read_metapage(ipbmap, lblkno, PSIZE, 0);
       if (mp == NULL) {
          IREAD_UNLOCK(ipbmap);
-         return (EIO);
+         return -EIO;
       }
       dp = (struct dmap *) mp->data;
 
@@ -463,7 +456,7 @@
  *
  * RETURN VALUES:
  *      0   - success
- *      EIO   - i/o error
+ *      -EIO   - i/o error
  */
 int
 dbUpdatePMap(struct inode *ipbmap,
@@ -480,7 +473,14 @@
    int lsn, difft, diffp;
 
    /* the blocks better be within the mapsize. */
-   assert(blkno + nblocks <= bmp->db_mapsize);
+   if (blkno + nblocks > bmp->db_mapsize) {
+      printk(KERN_ERR "blkno = %Lx, nblocks = %Lx\n",
+             (unsigned long long) blkno,
+             (unsigned long long) nblocks);
+      jfs_error(ipbmap->i_sb,
+           "dbUpdatePMap: blocks are outside the map");
+      return -EIO;
+   }
 
    /* compute delta of transaction lsn from log syncpt */
    lsn = tblk->lsn;
@@ -503,7 +503,7 @@
          mp = read_metapage(bmp->db_ipbmap, lblkno, PSIZE,
                   0);
          if (mp == NULL)
-            return (EIO);
+            return -EIO;
       }
       dp = (struct dmap *) mp->data;
 
@@ -737,8 +737,8 @@
  *
  * RETURN VALUES:
  *      0   - success
- *      ENOSPC   - insufficient disk resources
- *      EIO   - i/o error
+ *      -ENOSPC   - insufficient disk resources
+ *      -EIO   - i/o error
  */
 int dbAlloc(struct inode *ip, s64 hint, s64 nblocks, s64 * results)
 {
@@ -758,7 +758,7 @@
 #ifdef _STILL_TO_PORT
    /* DASD limit check                                     F226941 */
    if (OVER_LIMIT(ip, nblocks))
-      return ENOSPC;
+      return -ENOSPC;
 #endif            /* _STILL_TO_PORT */
 
    /* get the log2 number of blocks to be allocated.
@@ -773,7 +773,10 @@
    mapSize = bmp->db_mapsize;
 
    /* the hint should be within the map */
-   assert(hint < mapSize);
+   if (hint >= mapSize) {
+      jfs_error(ip->i_sb, "dbAlloc: the hint is outside the map");
+      return -EIO;
+   }
 
    /* if the number of blocks to be allocated is greater than the
     * allocation group size, try to allocate anywhere.
@@ -828,7 +831,7 @@
 
       /* get the buffer for the dmap containing the hint.
        */
-      rc = EIO;
+      rc = -EIO;
       lblkno = BLKTODMAP(blkno, bmp->db_l2nbperpage);
       mp = read_metapage(ipbmap, lblkno, PSIZE, 0);
       if (mp == NULL)
@@ -840,7 +843,7 @@
        * blocks beginning at the hint.
        */
       if ((rc = dbAllocNext(bmp, dp, blkno, (int) nblocks))
-          != ENOSPC) {
+          != -ENOSPC) {
          if (rc == 0) {
             *results = blkno;
             DBALLOC(bmp->db_DBmap, bmp->db_mapsize,
@@ -869,7 +872,7 @@
        */
       if ((rc =
            dbAllocNear(bmp, dp, blkno, (int) nblocks, l2nb, results))
-          != ENOSPC) {
+          != -ENOSPC) {
          if (rc == 0) {
             DBALLOC(bmp->db_DBmap, bmp->db_mapsize,
                *results, nblocks);
@@ -884,7 +887,7 @@
        * the same dmap as the hint.
        */
       if ((rc = dbAllocDmapLev(bmp, dp, (int) nblocks, l2nb, results))
-          != ENOSPC) {
+          != -ENOSPC) {
          if (rc == 0) {
             DBALLOC(bmp->db_DBmap, bmp->db_mapsize,
                *results, nblocks);
@@ -904,7 +907,7 @@
     */
    IWRITE_LOCK(ipbmap);
    if ((rc = dbAllocAG(bmp, agno, nblocks, l2nb, results))
-       != ENOSPC) {
+       != -ENOSPC) {
       if (rc == 0)
          DBALLOC(bmp->db_DBmap, bmp->db_mapsize,
             *results, nblocks);
@@ -923,7 +926,7 @@
    /* Try to allocate within this allocation group.  if that fails, try to
     * allocate anywhere in the map.
     */
-   if ((rc = dbAllocAG(bmp, agno, nblocks, l2nb, results)) == ENOSPC)
+   if ((rc = dbAllocAG(bmp, agno, nblocks, l2nb, results)) == -ENOSPC)
       rc = dbAllocAny(bmp, nblocks, l2nb, results);
    if (rc == 0) {
       DBALLOC(bmp->db_DBmap, bmp->db_mapsize, *results, nblocks);
@@ -953,8 +956,8 @@
  *
  * RETURN VALUES:
  *      0   - success
- *      ENOSPC   - insufficient disk resources
- *      EIO   - i/o error
+ *      -ENOSPC   - insufficient disk resources
+ *      -EIO   - i/o error
  */
 int dbAllocExact(struct inode *ip, s64 blkno, int nblocks)
 {
@@ -976,13 +979,13 @@
     */
    if (nblocks <= 0 || nblocks > BPERDMAP || blkno >= bmp->db_mapsize) {
       IREAD_UNLOCK(ipbmap);
-      return EINVAL;
+      return -EINVAL;
    }
 
    if (nblocks > ((s64) 1 << bmp->db_maxfreebud)) {
       /* the free space is no longer available */
       IREAD_UNLOCK(ipbmap);
-      return ENOSPC;
+      return -ENOSPC;
    }
 
    /* read in the dmap covering the extent */
@@ -990,7 +993,7 @@
    mp = read_metapage(ipbmap, lblkno, PSIZE, 0);
    if (mp == NULL) {
       IREAD_UNLOCK(ipbmap);
-      return (EIO);
+      return -EIO;
    }
    dp = (struct dmap *) mp->data;
 
@@ -1038,8 +1041,8 @@
  *
  * RETURN VALUES:
  *      0   - success
- *      ENOSPC   - insufficient disk resources
- *      EIO   - i/o error
+ *      -ENOSPC   - insufficient disk resources
+ *      -EIO   - i/o error
  */
 int
 dbReAlloc(struct inode *ip,
@@ -1053,7 +1056,7 @@
       *results = blkno;
       return (0);
    } else {
-      if (rc != ENOSPC)
+      if (rc != -ENOSPC)
          return (rc);
    }
 
@@ -1087,8 +1090,8 @@
  *
  * RETURN VALUES:
  *      0   - success
- *      ENOSPC   - insufficient disk resources
- *      EIO   - i/o error
+ *      -ENOSPC   - insufficient disk resources
+ *      -EIO   - i/o error
  */
 int dbExtend(struct inode *ip, s64 blkno, s64 nblocks, s64 addnblocks)
 {
@@ -1106,7 +1109,7 @@
     */
    if (((rel_block = blkno & (sbi->nbperpage - 1))) &&
        (rel_block + nblocks + addnblocks > sbi->nbperpage))
-      return (ENOSPC);
+      return -ENOSPC;
 
    /* get the last block of the current allocation */
    lastblkno = blkno + nblocks - 1;
@@ -1120,7 +1123,12 @@
 
    /* better be within the file system */
    bmp = sbi->bmap;
-   assert(lastblkno >= 0 && lastblkno < bmp->db_mapsize);
+   if (lastblkno < 0 || lastblkno >= bmp->db_mapsize) {
+      IREAD_UNLOCK(ipbmap);
+      jfs_error(ip->i_sb,
+           "dbExtend: the block is outside the filesystem");
+      return -EIO;
+   }
 
    /* we'll attempt to extend the current allocation in place by
     * allocating the additional blocks as the blocks immediately
@@ -1133,7 +1141,7 @@
    if (addnblocks > BPERDMAP || extblkno >= bmp->db_mapsize ||
        (extblkno & (bmp->db_agsize - 1)) == 0) {
       IREAD_UNLOCK(ipbmap);
-      return (ENOSPC);
+      return -ENOSPC;
    }
 
    /* get the buffer for the dmap containing the first block
@@ -1143,7 +1151,7 @@
    mp = read_metapage(ipbmap, lblkno, PSIZE, 0);
    if (mp == NULL) {
       IREAD_UNLOCK(ipbmap);
-      return (EIO);
+      return -EIO;
    }
 
    DBALLOCCK(bmp->db_DBmap, bmp->db_mapsize, blkno, nblocks);
@@ -1161,11 +1169,10 @@
       DBALLOC(bmp->db_DBmap, bmp->db_mapsize, extblkno,
          addnblocks);
       write_metapage(mp);
-   } else {
+   } else
       /* we were not successful */
       release_metapage(mp);
-      assert(rc == ENOSPC || rc == EIO);
-   }
+
 
    return (rc);
 }
@@ -1185,8 +1192,8 @@
  *
  * RETURN VALUES:
  *      0   - success
- *      ENOSPC   - insufficient disk resources
- *      EIO   - i/o error
+ *      -ENOSPC   - insufficient disk resources
+ *      -EIO   - i/o error
  *
  * serialization: IREAD_LOCK(ipbmap) held on entry/exit;
  */
@@ -1212,13 +1219,13 @@
     * this dmap.
     */
    if (dbitno + nblocks > BPERDMAP)
-      return (ENOSPC);
+      return -ENOSPC;
 
    /* check if the starting leaf indicates that anything
     * is free.
     */
    if (leaf[word] == NOFREE)
-      return (ENOSPC);
+      return -ENOSPC;
 
    /* check the dmaps words corresponding to block range to see
     * if the block range is free.  not all bits of the first and
@@ -1247,7 +1254,7 @@
           */
          mask = (ONES << (DBWORD - nb) >> wbitno);
          if ((mask & ~le32_to_cpu(dp->wmap[word])) != mask)
-            return (ENOSPC);
+            return -ENOSPC;
 
          word += 1;
       } else {
@@ -1265,7 +1272,7 @@
             /* does the leaf describe any free space ?
              */
             if (leaf[word] < BUDMIN)
-               return (ENOSPC);
+               return -ENOSPC;
 
             /* determine the l2 number of bits provided
              * by this leaf.
@@ -1311,8 +1318,8 @@
  *
  * RETURN VALUES:
  *      0   - success
- *      ENOSPC   - insufficient disk resources
- *      EIO   - i/o error
+ *      -ENOSPC   - insufficient disk resources
+ *      -EIO   - i/o error
  *
  * serialization: IREAD_LOCK(ipbmap) held on entry/exit;
  */
@@ -1360,7 +1367,7 @@
       return (rc);
    }
 
-   return (ENOSPC);
+   return -ENOSPC;
 }
 
 
@@ -1413,8 +1420,8 @@
  *
  * RETURN VALUES:
  *      0   - success
- *      ENOSPC   - insufficient disk resources
- *      EIO   - i/o error
+ *      -ENOSPC   - insufficient disk resources
+ *      -EIO   - i/o error
  *
  * note: IWRITE_LOCK(ipmap) held on entry/exit;
  */
@@ -1430,7 +1437,12 @@
    /* allocation request should not be for more than the
     * allocation group size.
     */
-   assert(l2nb <= bmp->db_agl2size);
+   if (l2nb > bmp->db_agl2size) {
+      jfs_error(bmp->db_ipbmap->i_sb,
+           "dbAllocAG: allocation request is larger than the "
+           "allocation group size");
+      return -EIO;
+   }
 
    /* determine the starting block number of the allocation
     * group.
@@ -1457,13 +1469,13 @@
    if (bmp->db_agsize == BPERDMAP
        || bmp->db_agfree[agno] == bmp->db_agsize) {
       rc = dbAllocCtl(bmp, nblocks, l2nb, blkno, results);
-      /* assert(!(rc == ENOSPC && bmp->db_agfree[agno] == bmp->db_agsize)); */
-      if ((rc == ENOSPC) &&
+      if ((rc == -ENOSPC) &&
           (bmp->db_agfree[agno] == bmp->db_agsize)) {
-         jfs_err("dbAllocAG: removed assert, but still need to "
-            "debug here\nblkno = 0x%Lx, nblocks = 0x%Lx",
-            (unsigned long long) blkno,
-            (unsigned long long) nblocks);
+         printk(KERN_ERR "blkno = %Lx, blocks = %Lx\n",
+                (unsigned long long) blkno,
+                (unsigned long long) nblocks);
+         jfs_error(bmp->db_ipbmap->i_sb,
+              "dbAllocAG: dbAllocCtl failed in free AG");
       }
       return (rc);
    }
@@ -1474,7 +1486,7 @@
    lblkno = BLKTOCTL(blkno, bmp->db_l2nbperpage, bmp->db_aglevel);
    mp = read_metapage(bmp->db_ipbmap, lblkno, PSIZE, 0);
    if (mp == NULL)
-      return (EIO);
+      return -EIO;
    dcp = (struct dmapctl *) mp->data;
    budmin = dcp->budmin;
 
@@ -1512,7 +1524,11 @@
                break;
             }
          }
-         assert(n < 4);
+         if (n == 4) {
+            jfs_error(bmp->db_ipbmap->i_sb,
+                 "dbAllocAG: failed descending stree");
+            return -EIO;
+         }
       }
 
       /* determine the block number within the file system
@@ -1547,7 +1563,12 @@
          if ((rc =
               dbFindCtl(bmp, l2nb, bmp->db_aglevel - 1,
                    &blkno))) {
-            assert(rc != ENOSPC);
+            if (rc == -ENOSPC) {
+               jfs_error(bmp->db_ipbmap->i_sb,
+                    "dbAllocAG: control page "
+                    "inconsistent");
+               return -EIO;
+            }
             return (rc);
          }
       }
@@ -1555,16 +1576,20 @@
       /* allocate the blocks.
        */
       rc = dbAllocCtl(bmp, nblocks, l2nb, blkno, results);
-      assert(rc != ENOSPC);
+      if (rc == -ENOSPC) {
+         jfs_error(bmp->db_ipbmap->i_sb,
+              "dbAllocAG: unable to allocate blocks");
+         rc = -EIO;
+      }
       return (rc);
    }
 
    /* no space in the allocation group.  release the buffer and
-    * return ENOSPC.
+    * return -ENOSPC.
     */
    release_metapage(mp);
 
-   return (ENOSPC);
+   return -ENOSPC;
 }
 
 
@@ -1589,8 +1614,8 @@
  *
  * RETURN VALUES:
  *      0   - success
- *      ENOSPC   - insufficient disk resources
- *      EIO   - i/o error
+ *      -ENOSPC   - insufficient disk resources
+ *      -EIO   - i/o error
  *
  * serialization: IWRITE_LOCK(ipbmap) held on entry/exit;
  */
@@ -1611,7 +1636,11 @@
    /* allocate the blocks.
     */
    rc = dbAllocCtl(bmp, nblocks, l2nb, blkno, results);
-   assert(rc != ENOSPC);
+   if (rc == -ENOSPC) {
+      jfs_error(bmp->db_ipbmap->i_sb,
+           "dbAllocAny: unable to allocate blocks");
+      return -EIO;
+   }
    return (rc);
 }
 
@@ -1639,8 +1668,8 @@
  *
  * RETURN VALUES:
  *      0   - success
- *      ENOSPC   - insufficient disk resources
- *      EIO   - i/o error
+ *      -ENOSPC   - insufficient disk resources
+ *      -EIO   - i/o error
  *
  * serialization: IWRITE_LOCK(ipbmap) held on entry/exit;
  */
@@ -1664,7 +1693,7 @@
       lblkno = BLKTOCTL(b, bmp->db_l2nbperpage, lev);
       mp = read_metapage(bmp->db_ipbmap, lblkno, PSIZE, 0);
       if (mp == NULL)
-         return (EIO);
+         return -EIO;
       dcp = (struct dmapctl *) mp->data;
       budmin = dcp->budmin;
 
@@ -1682,8 +1711,12 @@
       /* space found ?
        */
       if (rc) {
-         assert(lev == level);
-         return (ENOSPC);
+         if (lev != level) {
+            jfs_error(bmp->db_ipbmap->i_sb,
+                 "dbFindCtl: dmap inconsistent");
+            return -EIO;
+         }
+         return -ENOSPC;
       }
 
       /* adjust the block number to reflect the location within
@@ -1746,8 +1779,8 @@
  *
  * RETURN VALUES:
  *      0   - success
- *      ENOSPC   - insufficient disk resources
- *      EIO   - i/o error
+ *      -ENOSPC   - insufficient disk resources
+ *      -EIO   - i/o error
  *
  * serialization: IWRITE_LOCK(ipbmap) held on entry/exit;
  */
@@ -1767,7 +1800,7 @@
       lblkno = BLKTODMAP(blkno, bmp->db_l2nbperpage);
       mp = read_metapage(bmp->db_ipbmap, lblkno, PSIZE, 0);
       if (mp == NULL)
-         return (EIO);
+         return -EIO;
       dp = (struct dmap *) mp->data;
 
       /* try to allocate the blocks.
@@ -1794,14 +1827,20 @@
       lblkno = BLKTODMAP(b, bmp->db_l2nbperpage);
       mp = read_metapage(bmp->db_ipbmap, lblkno, PSIZE, 0);
       if (mp == NULL) {
-         rc = EIO;
+         rc = -EIO;
          goto backout;
       }
       dp = (struct dmap *) mp->data;
 
       /* the dmap better be all free.
        */
-      assert(dp->tree.stree[ROOT] == L2BPERDMAP);
+      if (dp->tree.stree[ROOT] != L2BPERDMAP) {
+         release_metapage(mp);
+         jfs_error(bmp->db_ipbmap->i_sb,
+              "dbAllocCtl: the dmap is not all free");
+         rc = -EIO;
+         goto backout;
+      }
 
       /* determine how many blocks to allocate from this dmap.
        */
@@ -1844,8 +1883,8 @@
          /* could not back out.  mark the file system
           * to indicate that we have leaked blocks.
           */
-         fsDirty();   /* !!! */
-         jfs_err("dbAllocCtl: I/O Error: Block Leakage.");
+         jfs_error(bmp->db_ipbmap->i_sb,
+              "dbAllocCtl: I/O Error: Block Leakage.");
          continue;
       }
       dp = (struct dmap *) mp->data;
@@ -1857,8 +1896,8 @@
           * to indicate that we have leaked blocks.
           */
          release_metapage(mp);
-         fsDirty();   /* !!! */
-         jfs_err("dbAllocCtl: Block Leakage.");
+         jfs_error(bmp->db_ipbmap->i_sb,
+              "dbAllocCtl: Block Leakage.");
          continue;
       }
 
@@ -1891,8 +1930,8 @@
  *
  * RETURN VALUES:
  *      0   - success
- *      ENOSPC   - insufficient disk resources
- *      EIO   - i/o error
+ *      -ENOSPC   - insufficient disk resources
+ *      -EIO   - i/o error
  *
  * serialization: IREAD_LOCK(ipbmap), e.g., from dbAlloc(), or 
  *   IWRITE_LOCK(ipbmap), e.g., dbAllocCtl(), held on entry/exit;
@@ -1912,7 +1951,7 @@
     * returns the index of the leaf at which free space was found.
     */
    if (dbFindLeaf((dmtree_t *) & dp->tree, l2nb, &leafidx))
-      return (ENOSPC);
+      return -ENOSPC;
 
    /* determine the block number within the file system corresponding
     * to the leaf at which free space was found.
@@ -1957,7 +1996,7 @@
  *
  * RETURN VALUES:
  *      0   - success
- *      EIO   - i/o error
+ *      -EIO   - i/o error
  *
  * serialization: IREAD_LOCK(ipbmap) or IWRITE_LOCK(ipbmap) held on entry/exit;
  */
@@ -2012,7 +2051,7 @@
  *
  * RETURN VALUES:
  *      0   - success
- *      EIO   - i/o error
+ *      -EIO   - i/o error
  *
  * serialization: IREAD_LOCK(ipbmap) or IWRITE_LOCK(ipbmap) held on entry/exit;
  */
@@ -2153,7 +2192,12 @@
           * the allocated words.
           */
          for (; nwords > 0; nwords -= nw) {
-            assert(leaf[word] >= BUDMIN);
+                 if (leaf[word] < BUDMIN) {
+               jfs_error(bmp->db_ipbmap->i_sb,
+                    "dbAllocBits: leaf page "
+                    "corrupt");
+               break;
+            }
 
             /* determine what the leaf value should be
              * updated to as the minimum of the l2 number
@@ -2392,7 +2436,7 @@
  *
  * RETURN VALUES:
  *      0   - success
- *      EIO   - i/o error
+ *      -EIO   - i/o error
  *
  * serialization: IREAD_LOCK(ipbmap) or IWRITE_LOCK(ipbmap) held on entry/exit;
  */
@@ -2412,7 +2456,7 @@
    lblkno = BLKTOCTL(blkno, bmp->db_l2nbperpage, level);
    mp = read_metapage(bmp->db_ipbmap, lblkno, PSIZE, 0);
    if (mp == NULL)
-      return (EIO);
+      return -EIO;
    dcp = (struct dmapctl *) mp->data;
 
    /* determine the leaf number corresponding to the block and
@@ -2505,7 +2549,11 @@
           * of the maximum free buddy system.
           */
          assert(level == bmp->db_maxlevel);
-         assert(bmp->db_maxfreebud == oldroot);
+         if (bmp->db_maxfreebud != oldroot) {
+            jfs_error(bmp->db_ipbmap->i_sb,
+                 "dbAdjCtl: the maximum free buddy is "
+                 "not the old root");
+         }
          bmp->db_maxfreebud = dcp->stree[ROOT];
       }
    }
@@ -2835,7 +2883,7 @@
  *
  * RETURN VALUES:
  *      0   - success
- *      ENOSPC   - insufficient free blocks. 
+ *      -ENOSPC   - insufficient free blocks. 
  */
 static int dbFindLeaf(dmtree_t * tp, int l2nb, int *leafidx)
 {
@@ -2845,7 +2893,7 @@
     * sufficient free space.
     */
    if (l2nb > tp->dmt_stree[ROOT])
-      return (ENOSPC);
+      return -ENOSPC;
 
    /* sufficient free space available. now search down the tree
     * starting at the next level for the leftmost leaf that
@@ -3056,24 +3104,6 @@
 
 
 /*
- * NAME:   fsDirty()
- *
- * FUNCTION:    xxx
- *
- * PARAMETERS:
- *      ipmnt   - mount inode
- *
- * RETURN VALUES:
- *      none
- */
-void fsDirty()
-{
-   printk("fsDirty(): bye-bye\n");
-   assert(0);
-}
-
-
-/*
  * NAME:       dbAllocBottomUp()
  *
  * FUNCTION:   alloc the specified block range from the working block
@@ -3089,7 +3119,7 @@
  *
  * RETURN VALUES:
  *      0   - success
- *      EIO   - i/o error
+ *      -EIO   - i/o error
  */
 int dbAllocBottomUp(struct inode *ip, s64 blkno, s64 nblocks)
 {
@@ -3120,7 +3150,7 @@
       mp = read_metapage(ipbmap, lblkno, PSIZE, 0);
       if (mp == NULL) {
          IREAD_UNLOCK(ipbmap);
-         return (EIO);
+         return -EIO;
       }
       dp = (struct dmap *) mp->data;
 
@@ -3359,7 +3389,10 @@
    /* get L2 page */
    p = BMAPBLKNO + nbperpage;   /* L2 page */
    l2mp = read_metapage(ipbmap, p, PSIZE, 0);
-   assert(l2mp);
+   if (!l2mp) {
+      jfs_error(ipbmap->i_sb, "dbExtendFS: L2 page could not be read");
+      return -EIO;
+   }
    l2dcp = (struct dmapctl *) l2mp->data;
 
    /* compute start L1 */
@@ -3520,7 +3553,9 @@
       }
    }         /* for each L1 in a L2 */
 
-   assert(0);
+   jfs_error(ipbmap->i_sb,
+        "dbExtendFS: function has not returned as expected");
+   return -EIO;
 
    /*
     *      finalize bmap control page
@@ -3530,7 +3565,7 @@
    return 0;
 
       errout:
-   return EIO;
+   return -EIO;
 }
 
 
@@ -3584,7 +3619,10 @@
          if (bmp->db_agfree[bmp->db_agpref] >= avgfree)
             break;
       }
-      assert(bmp->db_agpref < bmp->db_numag);
+      if (bmp->db_agpref >= bmp->db_numag) {
+         jfs_error(ipbmap->i_sb,
+              "cannot find ag with average freespace");
+      }
    }
 
    /*
@@ -3605,10 +3643,6 @@
       n <<= 2;
    }
 
-/*
-printk("bmap: agpref:%d aglevel:%d agheigth:%d agwidth:%d\n",
-   bmp->db_agpref, bmp->db_aglevel, bmp->db_agheigth, bmp->db_agwidth);
-*/
 }
 
 
@@ -3632,9 +3666,6 @@
 static int dbInitDmap(struct dmap * dp, s64 Blkno, int nblocks)
 {
    int blkno, w, b, r, nw, nb, i;
-/*
-printk("sbh_dmap:  in dbInitDmap blkno:%Ld nblocks:%ld\n", Blkno, nblocks); 
-*/
 
    /* starting block number within the dmap */
    blkno = Blkno & (BPERDMAP - 1);
@@ -3694,10 +3725,6 @@
     * mark bits following the range to be freed (non-existing 
     * blocks) as allocated (ONES)
     */
-/*
-printk("sbh_dmap:  in dbInitDmap, preparing to mark unbacked, blkno:%ld nblocks:%ld\n",
-      blkno, nblocks); 
-*/
 
    if (blkno == BPERDMAP)
       goto initTree;
@@ -3707,9 +3734,6 @@
 
    /* does nblocks fall on a 32-bit boundary ? */
    b = blkno & (DBWORD - 1);
-/*
-printk("sbh_dmap:  in dbInitDmap, b:%ld w:%ld mask: %lx\n", b, w, (ONES>>b)); 
-*/
    if (b) {
       /* mark a partial word allocated */
       dp->wmap[w] = dp->pmap[w] = cpu_to_le32(ONES >> b);
@@ -4006,7 +4030,7 @@
 
    dbmap = (u32 *) xmalloc(npages * 4096, L2PSIZE, kernel_heap);
    if (dbmap == NULL)
-      assert(0);
+      BUG();   /* Not robust since this is only unused debug code */
 
    for (n = 0, d = dbmap; n < npages; n++, d += 1024)
       bzero(d, 4096);
@@ -4020,7 +4044,9 @@
                db_l2nbperpage);
       mp = read_metapage(ipbmap, lblkno, PSIZE, 0);
       if (mp == NULL) {
-         assert(0);
+         jfs_error(ipbmap->i_sb,
+              "DBinitmap: could not read disk map page");
+         continue;
       }
       dp = (struct dmap *) mp->data;