[PATCH] ufs: wrong type cast
[linux-2.6.git] / fs / ufs / balloc.c
index 997640c..68de131 100644 (file)
@@ -13,6 +13,7 @@
 #include <linux/string.h>
 #include <linux/quotaops.h>
 #include <linux/buffer_head.h>
+#include <linux/capability.h>
 #include <linux/sched.h>
 #include <linux/bitops.h>
 #include <asm/byteorder.h>
@@ -38,7 +39,8 @@ static void ufs_clusteracct(struct super_block *, struct ufs_cg_private_info *,
 /*
  * Free 'count' fragments from fragment number 'fragment'
  */
-void ufs_free_fragments (struct inode * inode, unsigned fragment, unsigned count) {
+void ufs_free_fragments(struct inode *inode, unsigned fragment, unsigned count)
+{
        struct super_block * sb;
        struct ufs_sb_private_info * uspi;
        struct ufs_super_block_first * usb1;
@@ -48,7 +50,7 @@ void ufs_free_fragments (struct inode * inode, unsigned fragment, unsigned count
        
        sb = inode->i_sb;
        uspi = UFS_SB(sb)->s_uspi;
-       usb1 = ubh_get_usb_first(USPI_UBH);
+       usb1 = ubh_get_usb_first(uspi);
        
        UFSD(("ENTER, fragment %u, count %u\n", fragment, count))
        
@@ -67,7 +69,7 @@ void ufs_free_fragments (struct inode * inode, unsigned fragment, unsigned count
        ucpi = ufs_load_cylinder (sb, cgno);
        if (!ucpi) 
                goto failed;
-       ucg = ubh_get_ucg (UCPI_UBH);
+       ucg = ubh_get_ucg (UCPI_UBH(ucpi));
        if (!ufs_cg_chkmagic(sb, ucg)) {
                ufs_panic (sb, "ufs_free_fragments", "internal error, bad magic number on cg %u", cgno);
                goto failed;
@@ -75,13 +77,14 @@ void ufs_free_fragments (struct inode * inode, unsigned fragment, unsigned count
 
        end_bit = bit + count;
        bbase = ufs_blknum (bit);
-       blkmap = ubh_blkmap (UCPI_UBH, ucpi->c_freeoff, bbase);
+       blkmap = ubh_blkmap (UCPI_UBH(ucpi), ucpi->c_freeoff, bbase);
        ufs_fragacct (sb, blkmap, ucg->cg_frsum, -1);
        for (i = bit; i < end_bit; i++) {
-               if (ubh_isclr (UCPI_UBH, ucpi->c_freeoff, i))
-                       ubh_setbit (UCPI_UBH, ucpi->c_freeoff, i);
-               else ufs_error (sb, "ufs_free_fragments",
-                       "bit already cleared for fragment %u", i);
+               if (ubh_isclr (UCPI_UBH(ucpi), ucpi->c_freeoff, i))
+                       ubh_setbit (UCPI_UBH(ucpi), ucpi->c_freeoff, i);
+               else 
+                       ufs_error (sb, "ufs_free_fragments",
+                                  "bit already cleared for fragment %u", i);
        }
        
        DQUOT_FREE_BLOCK (inode, count);
@@ -90,14 +93,14 @@ void ufs_free_fragments (struct inode * inode, unsigned fragment, unsigned count
        fs32_add(sb, &ucg->cg_cs.cs_nffree, count);
        fs32_add(sb, &usb1->fs_cstotal.cs_nffree, count);
        fs32_add(sb, &UFS_SB(sb)->fs_cs(cgno).cs_nffree, count);
-       blkmap = ubh_blkmap (UCPI_UBH, ucpi->c_freeoff, bbase);
+       blkmap = ubh_blkmap (UCPI_UBH(ucpi), ucpi->c_freeoff, bbase);
        ufs_fragacct(sb, blkmap, ucg->cg_frsum, 1);
 
        /*
         * Trying to reassemble free fragments into block
         */
        blkno = ufs_fragstoblks (bbase);
-       if (ubh_isblockset(UCPI_UBH, ucpi->c_freeoff, blkno)) {
+       if (ubh_isblockset(UCPI_UBH(ucpi), ucpi->c_freeoff, blkno)) {
                fs32_sub(sb, &ucg->cg_cs.cs_nffree, uspi->s_fpb);
                fs32_sub(sb, &usb1->fs_cstotal.cs_nffree, uspi->s_fpb);
                fs32_sub(sb, &UFS_SB(sb)->fs_cs(cgno).cs_nffree, uspi->s_fpb);
@@ -111,12 +114,11 @@ void ufs_free_fragments (struct inode * inode, unsigned fragment, unsigned count
                fs32_add(sb, &ubh_cg_blktot(ucpi, cylno), 1);
        }
        
-       ubh_mark_buffer_dirty (USPI_UBH);
-       ubh_mark_buffer_dirty (UCPI_UBH);
+       ubh_mark_buffer_dirty (USPI_UBH(uspi));
+       ubh_mark_buffer_dirty (UCPI_UBH(ucpi));
        if (sb->s_flags & MS_SYNCHRONOUS) {
-               ubh_wait_on_buffer (UCPI_UBH);
-               ubh_ll_rw_block (WRITE, 1, (struct ufs_buffer_head **)&ucpi);
-               ubh_wait_on_buffer (UCPI_UBH);
+               ubh_ll_rw_block (SWRITE, 1, (struct ufs_buffer_head **)&ucpi);
+               ubh_wait_on_buffer (UCPI_UBH(ucpi));
        }
        sb->s_dirt = 1;
        
@@ -133,7 +135,8 @@ failed:
 /*
  * Free 'count' fragments from fragment number 'fragment' (free whole blocks)
  */
-void ufs_free_blocks (struct inode * inode, unsigned fragment, unsigned count) {
+void ufs_free_blocks(struct inode *inode, unsigned fragment, unsigned count)
+{
        struct super_block * sb;
        struct ufs_sb_private_info * uspi;
        struct ufs_super_block_first * usb1;
@@ -143,7 +146,7 @@ void ufs_free_blocks (struct inode * inode, unsigned fragment, unsigned count) {
        
        sb = inode->i_sb;
        uspi = UFS_SB(sb)->s_uspi;
-       usb1 = ubh_get_usb_first(USPI_UBH);
+       usb1 = ubh_get_usb_first(uspi);
 
        UFSD(("ENTER, fragment %u, count %u\n", fragment, count))
        
@@ -173,7 +176,7 @@ do_more:
        ucpi = ufs_load_cylinder (sb, cgno);
        if (!ucpi) 
                goto failed;
-       ucg = ubh_get_ucg (UCPI_UBH);
+       ucg = ubh_get_ucg (UCPI_UBH(ucpi));
        if (!ufs_cg_chkmagic(sb, ucg)) {
                ufs_panic (sb, "ufs_free_blocks", "internal error, bad magic number on cg %u", cgno);
                goto failed;
@@ -181,10 +184,10 @@ do_more:
 
        for (i = bit; i < end_bit; i += uspi->s_fpb) {
                blkno = ufs_fragstoblks(i);
-               if (ubh_isblockset(UCPI_UBH, ucpi->c_freeoff, blkno)) {
+               if (ubh_isblockset(UCPI_UBH(ucpi), ucpi->c_freeoff, blkno)) {
                        ufs_error(sb, "ufs_free_blocks", "freeing free fragment");
                }
-               ubh_setblock(UCPI_UBH, ucpi->c_freeoff, blkno);
+               ubh_setblock(UCPI_UBH(ucpi), ucpi->c_freeoff, blkno);
                if ((UFS_SB(sb)->s_flags & UFS_CG_MASK) == UFS_CG_44BSD)
                        ufs_clusteracct (sb, ucpi, blkno, 1);
                DQUOT_FREE_BLOCK(inode, uspi->s_fpb);
@@ -197,12 +200,11 @@ do_more:
                fs32_add(sb, &ubh_cg_blktot(ucpi, cylno), 1);
        }
 
-       ubh_mark_buffer_dirty (USPI_UBH);
-       ubh_mark_buffer_dirty (UCPI_UBH);
+       ubh_mark_buffer_dirty (USPI_UBH(uspi));
+       ubh_mark_buffer_dirty (UCPI_UBH(ucpi));
        if (sb->s_flags & MS_SYNCHRONOUS) {
-               ubh_wait_on_buffer (UCPI_UBH);
-               ubh_ll_rw_block (WRITE, 1, (struct ufs_buffer_head **)&ucpi);
-               ubh_wait_on_buffer (UCPI_UBH);
+               ubh_ll_rw_block (SWRITE, 1, (struct ufs_buffer_head **)&ucpi);
+               ubh_wait_on_buffer (UCPI_UBH(ucpi));
        }
 
        if (overflow) {
@@ -222,33 +224,124 @@ failed:
        return;
 }
 
+static struct page *ufs_get_locked_page(struct address_space *mapping,
+                                 unsigned long index)
+{
+       struct page *page;
+
+try_again:
+       page = find_lock_page(mapping, index);
+       if (!page) {
+               page = read_cache_page(mapping, index,
+                                      (filler_t*)mapping->a_ops->readpage,
+                                      NULL);
+               if (IS_ERR(page)) {
+                       printk(KERN_ERR "ufs_change_blocknr: "
+                              "read_cache_page error: ino %lu, index: %lu\n",
+                              mapping->host->i_ino, index);
+                       goto out;
+               }
 
+               lock_page(page);
 
-#define NULLIFY_FRAGMENTS \
-       for (i = oldcount; i < newcount; i++) { \
-               bh = sb_getblk(sb, result + i); \
-               memset (bh->b_data, 0, sb->s_blocksize); \
-               set_buffer_uptodate(bh); \
-               mark_buffer_dirty (bh); \
-               if (IS_SYNC(inode)) \
-                       sync_dirty_buffer(bh); \
-               brelse (bh); \
+               if (!PageUptodate(page) || PageError(page)) {
+                       unlock_page(page);
+                       page_cache_release(page);
+
+                       printk(KERN_ERR "ufs_change_blocknr: "
+                              "can not read page: ino %lu, index: %lu\n",
+                              mapping->host->i_ino, index);
+
+                       page = ERR_PTR(-EIO);
+                       goto out;
+               }
        }
 
-unsigned ufs_new_fragments (struct inode * inode, __fs32 * p, unsigned fragment,
-       unsigned goal, unsigned count, int * err )
+       if (unlikely(!page->mapping || !page_has_buffers(page))) {
+               unlock_page(page);
+               page_cache_release(page);
+               goto try_again;/*we really need these buffers*/
+       }
+out:
+       return page;
+}
+
+/*
+ * Modify inode page cache in such way:
+ * have - blocks with b_blocknr equal to oldb...oldb+count-1
+ * get - blocks with b_blocknr equal to newb...newb+count-1
+ * also we suppose that oldb...oldb+count-1 blocks
+ * situated at the end of file.
+ *
+ * We can come here from ufs_writepage or ufs_prepare_write,
+ * locked_page is argument of these functions, so we already lock it.
+ */
+static void ufs_change_blocknr(struct inode *inode, unsigned int count,
+                              unsigned int oldb, unsigned int newb,
+                              struct page *locked_page)
+{
+       unsigned int blk_per_page = 1 << (PAGE_CACHE_SHIFT - inode->i_blkbits);
+       sector_t baseblk;
+       struct address_space *mapping = inode->i_mapping;
+       pgoff_t index, cur_index = locked_page->index;
+       unsigned int i, j;
+       struct page *page;
+       struct buffer_head *head, *bh;
+
+       baseblk = ((i_size_read(inode) - 1) >> inode->i_blkbits) + 1 - count;
+
+       UFSD(("ENTER, ino %lu, count %u, oldb %u, newb %u\n",
+             inode->i_ino, count, oldb, newb));
+
+       BUG_ON(!PageLocked(locked_page));
+
+       for (i = 0; i < count; i += blk_per_page) {
+               index = (baseblk+i) >> (PAGE_CACHE_SHIFT - inode->i_blkbits);
+
+               if (likely(cur_index != index)) {
+                       page = ufs_get_locked_page(mapping, index);
+                       if (IS_ERR(page))
+                               continue;
+               } else
+                       page = locked_page;
+
+               j = i;
+               head = page_buffers(page);
+               bh = head;
+               do {
+                       if (likely(bh->b_blocknr == j + oldb && j < count)) {
+                               unmap_underlying_metadata(bh->b_bdev,
+                                                         bh->b_blocknr);
+                               bh->b_blocknr = newb + j++;
+                               mark_buffer_dirty(bh);
+                       }
+
+                       bh = bh->b_this_page;
+               } while (bh != head);
+
+               set_page_dirty(page);
+
+               if (likely(cur_index != index)) {
+                       unlock_page(page);
+                       page_cache_release(page);
+               }
+       }
+       UFSD(("EXIT\n"));
+}
+
+unsigned ufs_new_fragments(struct inode * inode, __fs32 * p, unsigned fragment,
+                          unsigned goal, unsigned count, int * err, struct page *locked_page)
 {
        struct super_block * sb;
        struct ufs_sb_private_info * uspi;
        struct ufs_super_block_first * usb1;
-       struct buffer_head * bh;
-       unsigned cgno, oldcount, newcount, tmp, request, i, result;
+       unsigned cgno, oldcount, newcount, tmp, request, result;
        
        UFSD(("ENTER, ino %lu, fragment %u, goal %u, count %u\n", inode->i_ino, fragment, goal, count))
        
        sb = inode->i_sb;
        uspi = UFS_SB(sb)->s_uspi;
-       usb1 = ubh_get_usb_first(USPI_UBH);
+       usb1 = ubh_get_usb_first(uspi);
        *err = -ENOSPC;
 
        lock_super (sb);
@@ -312,7 +405,6 @@ unsigned ufs_new_fragments (struct inode * inode, __fs32 * p, unsigned fragment,
                        *err = 0;
                        inode->i_blocks += count << uspi->s_nspfshift;
                        UFS_I(inode)->i_lastfrag = max_t(u32, UFS_I(inode)->i_lastfrag, fragment + count);
-                       NULLIFY_FRAGMENTS
                }
                unlock_super(sb);
                UFSD(("EXIT, result %u\n", result))
@@ -327,7 +419,6 @@ unsigned ufs_new_fragments (struct inode * inode, __fs32 * p, unsigned fragment,
                *err = 0;
                inode->i_blocks += count << uspi->s_nspfshift;
                UFS_I(inode)->i_lastfrag = max_t(u32, UFS_I(inode)->i_lastfrag, fragment + count);
-               NULLIFY_FRAGMENTS
                unlock_super(sb);
                UFSD(("EXIT, result %u\n", result))
                return result;
@@ -357,29 +448,12 @@ unsigned ufs_new_fragments (struct inode * inode, __fs32 * p, unsigned fragment,
        }
        result = ufs_alloc_fragments (inode, cgno, goal, request, err);
        if (result) {
-               for (i = 0; i < oldcount; i++) {
-                       bh = sb_bread(sb, tmp + i);
-                       if(bh)
-                       {
-                               clear_buffer_dirty(bh);
-                               bh->b_blocknr = result + i;
-                               mark_buffer_dirty (bh);
-                               if (IS_SYNC(inode))
-                                       sync_dirty_buffer(bh);
-                               brelse (bh);
-                       }
-                       else
-                       {
-                               printk(KERN_ERR "ufs_new_fragments: bread fail\n");
-                               unlock_super(sb);
-                               return 0;
-                       }
-               }
+               ufs_change_blocknr(inode, oldcount, tmp, result, locked_page);
+
                *p = cpu_to_fs32(sb, result);
                *err = 0;
                inode->i_blocks += count << uspi->s_nspfshift;
                UFS_I(inode)->i_lastfrag = max_t(u32, UFS_I(inode)->i_lastfrag, fragment + count);
-               NULLIFY_FRAGMENTS
                unlock_super(sb);
                if (newcount < request)
                        ufs_free_fragments (inode, result + newcount, request - newcount);
@@ -408,7 +482,7 @@ ufs_add_fragments (struct inode * inode, unsigned fragment,
        
        sb = inode->i_sb;
        uspi = UFS_SB(sb)->s_uspi;
-       usb1 = ubh_get_usb_first (USPI_UBH);
+       usb1 = ubh_get_usb_first (uspi);
        count = newcount - oldcount;
        
        cgno = ufs_dtog(fragment);
@@ -419,7 +493,7 @@ ufs_add_fragments (struct inode * inode, unsigned fragment,
        ucpi = ufs_load_cylinder (sb, cgno);
        if (!ucpi)
                return 0;
-       ucg = ubh_get_ucg (UCPI_UBH);
+       ucg = ubh_get_ucg (UCPI_UBH(ucpi));
        if (!ufs_cg_chkmagic(sb, ucg)) {
                ufs_panic (sb, "ufs_add_fragments",
                        "internal error, bad magic number on cg %u", cgno);
@@ -429,14 +503,14 @@ ufs_add_fragments (struct inode * inode, unsigned fragment,
        fragno = ufs_dtogd (fragment);
        fragoff = ufs_fragnum (fragno);
        for (i = oldcount; i < newcount; i++)
-               if (ubh_isclr (UCPI_UBH, ucpi->c_freeoff, fragno + i))
+               if (ubh_isclr (UCPI_UBH(ucpi), ucpi->c_freeoff, fragno + i))
                        return 0;
        /*
         * Block can be extended
         */
        ucg->cg_time = cpu_to_fs32(sb, get_seconds());
        for (i = newcount; i < (uspi->s_fpb - fragoff); i++)
-               if (ubh_isclr (UCPI_UBH, ucpi->c_freeoff, fragno + i))
+               if (ubh_isclr (UCPI_UBH(ucpi), ucpi->c_freeoff, fragno + i))
                        break;
        fragsize = i - oldcount;
        if (!fs32_to_cpu(sb, ucg->cg_frsum[fragsize]))
@@ -446,7 +520,7 @@ ufs_add_fragments (struct inode * inode, unsigned fragment,
        if (fragsize != count)
                fs32_add(sb, &ucg->cg_frsum[fragsize - count], 1);
        for (i = oldcount; i < newcount; i++)
-               ubh_clrbit (UCPI_UBH, ucpi->c_freeoff, fragno + i);
+               ubh_clrbit (UCPI_UBH(ucpi), ucpi->c_freeoff, fragno + i);
        if(DQUOT_ALLOC_BLOCK(inode, count)) {
                *err = -EDQUOT;
                return 0;
@@ -456,12 +530,11 @@ ufs_add_fragments (struct inode * inode, unsigned fragment,
        fs32_sub(sb, &UFS_SB(sb)->fs_cs(cgno).cs_nffree, count);
        fs32_sub(sb, &usb1->fs_cstotal.cs_nffree, count);
        
-       ubh_mark_buffer_dirty (USPI_UBH);
-       ubh_mark_buffer_dirty (UCPI_UBH);
+       ubh_mark_buffer_dirty (USPI_UBH(uspi));
+       ubh_mark_buffer_dirty (UCPI_UBH(ucpi));
        if (sb->s_flags & MS_SYNCHRONOUS) {
-               ubh_wait_on_buffer (UCPI_UBH);
-               ubh_ll_rw_block (WRITE, 1, (struct ufs_buffer_head **)&ucpi);
-               ubh_wait_on_buffer (UCPI_UBH);
+               ubh_ll_rw_block (SWRITE, 1, (struct ufs_buffer_head **)&ucpi);
+               ubh_wait_on_buffer (UCPI_UBH(ucpi));
        }
        sb->s_dirt = 1;
 
@@ -492,7 +565,7 @@ static unsigned ufs_alloc_fragments (struct inode * inode, unsigned cgno,
 
        sb = inode->i_sb;
        uspi = UFS_SB(sb)->s_uspi;
-       usb1 = ubh_get_usb_first(USPI_UBH);
+       usb1 = ubh_get_usb_first(uspi);
        oldcg = cgno;
        
        /*
@@ -529,7 +602,7 @@ cg_found:
        ucpi = ufs_load_cylinder (sb, cgno);
        if (!ucpi)
                return 0;
-       ucg = ubh_get_ucg (UCPI_UBH);
+       ucg = ubh_get_ucg (UCPI_UBH(ucpi));
        if (!ufs_cg_chkmagic(sb, ucg)) 
                ufs_panic (sb, "ufs_alloc_fragments",
                        "internal error, bad magic number on cg %u", cgno);
@@ -552,7 +625,7 @@ cg_found:
                        return 0;
                goal = ufs_dtogd (result);
                for (i = count; i < uspi->s_fpb; i++)
-                       ubh_setbit (UCPI_UBH, ucpi->c_freeoff, goal + i);
+                       ubh_setbit (UCPI_UBH(ucpi), ucpi->c_freeoff, goal + i);
                i = uspi->s_fpb - count;
                DQUOT_FREE_BLOCK(inode, i);
 
@@ -571,7 +644,7 @@ cg_found:
                return 0;
        }
        for (i = 0; i < count; i++)
-               ubh_clrbit (UCPI_UBH, ucpi->c_freeoff, result + i);
+               ubh_clrbit (UCPI_UBH(ucpi), ucpi->c_freeoff, result + i);
        
        fs32_sub(sb, &ucg->cg_cs.cs_nffree, count);
        fs32_sub(sb, &usb1->fs_cstotal.cs_nffree, count);
@@ -582,12 +655,11 @@ cg_found:
                fs32_add(sb, &ucg->cg_frsum[allocsize - count], 1);
 
 succed:
-       ubh_mark_buffer_dirty (USPI_UBH);
-       ubh_mark_buffer_dirty (UCPI_UBH);
+       ubh_mark_buffer_dirty (USPI_UBH(uspi));
+       ubh_mark_buffer_dirty (UCPI_UBH(ucpi));
        if (sb->s_flags & MS_SYNCHRONOUS) {
-               ubh_wait_on_buffer (UCPI_UBH);
-               ubh_ll_rw_block (WRITE, 1, (struct ufs_buffer_head **)&ucpi);
-               ubh_wait_on_buffer (UCPI_UBH);
+               ubh_ll_rw_block (SWRITE, 1, (struct ufs_buffer_head **)&ucpi);
+               ubh_wait_on_buffer (UCPI_UBH(ucpi));
        }
        sb->s_dirt = 1;
 
@@ -609,8 +681,8 @@ static unsigned ufs_alloccg_block (struct inode * inode,
 
        sb = inode->i_sb;
        uspi = UFS_SB(sb)->s_uspi;
-       usb1 = ubh_get_usb_first(USPI_UBH);
-       ucg = ubh_get_ucg(UCPI_UBH);
+       usb1 = ubh_get_usb_first(uspi);
+       ucg = ubh_get_ucg(UCPI_UBH(ucpi));
 
        if (goal == 0) {
                goal = ucpi->c_rotor;
@@ -622,7 +694,7 @@ static unsigned ufs_alloccg_block (struct inode * inode,
        /*
         * If the requested block is available, use it.
         */
-       if (ubh_isblockset(UCPI_UBH, ucpi->c_freeoff, ufs_fragstoblks(goal))) {
+       if (ubh_isblockset(UCPI_UBH(ucpi), ucpi->c_freeoff, ufs_fragstoblks(goal))) {
                result = goal;
                goto gotit;
        }
@@ -634,7 +706,7 @@ norot:
        ucpi->c_rotor = result;
 gotit:
        blkno = ufs_fragstoblks(result);
-       ubh_clrblock (UCPI_UBH, ucpi->c_freeoff, blkno);
+       ubh_clrblock (UCPI_UBH(ucpi), ucpi->c_freeoff, blkno);
        if ((UFS_SB(sb)->s_flags & UFS_CG_MASK) == UFS_CG_44BSD)
                ufs_clusteracct (sb, ucpi, blkno, -1);
        if(DQUOT_ALLOC_BLOCK(inode, uspi->s_fpb)) {
@@ -666,8 +738,8 @@ static unsigned ufs_bitmap_search (struct super_block * sb,
        UFSD(("ENTER, cg %u, goal %u, count %u\n", ucpi->c_cgx, goal, count))
 
        uspi = UFS_SB(sb)->s_uspi;
-       usb1 = ubh_get_usb_first (USPI_UBH);
-       ucg = ubh_get_ucg(UCPI_UBH);
+       usb1 = ubh_get_usb_first (uspi);
+       ucg = ubh_get_ucg(UCPI_UBH(ucpi));
 
        if (goal)
                start = ufs_dtogd(goal) >> 3;
@@ -675,12 +747,12 @@ static unsigned ufs_bitmap_search (struct super_block * sb,
                start = ucpi->c_frotor >> 3;
                
        length = ((uspi->s_fpg + 7) >> 3) - start;
-       location = ubh_scanc(UCPI_UBH, ucpi->c_freeoff + start, length,
+       location = ubh_scanc(UCPI_UBH(ucpi), ucpi->c_freeoff + start, length,
                (uspi->s_fpb == 8) ? ufs_fragtable_8fpb : ufs_fragtable_other,
                1 << (count - 1 + (uspi->s_fpb & 7))); 
        if (location == 0) {
                length = start + 1;
-               location = ubh_scanc(UCPI_UBH, ucpi->c_freeoff, length, 
+               location = ubh_scanc(UCPI_UBH(ucpi), ucpi->c_freeoff, length,
                        (uspi->s_fpb == 8) ? ufs_fragtable_8fpb : ufs_fragtable_other,
                        1 << (count - 1 + (uspi->s_fpb & 7)));
                if (location == 0) {
@@ -697,7 +769,7 @@ static unsigned ufs_bitmap_search (struct super_block * sb,
        /*
         * found the byte in the map
         */
-       blockmap = ubh_blkmap(UCPI_UBH, ucpi->c_freeoff, result);
+       blockmap = ubh_blkmap(UCPI_UBH(ucpi), ucpi->c_freeoff, result);
        fragsize = 0;
        for (possition = 0, mask = 1; possition < 8; possition++, mask <<= 1) {
                if (blockmap & mask) {
@@ -736,9 +808,9 @@ static void ufs_clusteracct(struct super_block * sb,
                return;
 
        if (cnt > 0)
-               ubh_setbit(UCPI_UBH, ucpi->c_clusteroff, blkno);
+               ubh_setbit(UCPI_UBH(ucpi), ucpi->c_clusteroff, blkno);
        else
-               ubh_clrbit(UCPI_UBH, ucpi->c_clusteroff, blkno);
+               ubh_clrbit(UCPI_UBH(ucpi), ucpi->c_clusteroff, blkno);
 
        /*
         * Find the size of the cluster going forward.
@@ -747,7 +819,7 @@ static void ufs_clusteracct(struct super_block * sb,
        end = start + uspi->s_contigsumsize;
        if ( end >= ucpi->c_nclusterblks)
                end = ucpi->c_nclusterblks;
-       i = ubh_find_next_zero_bit (UCPI_UBH, ucpi->c_clusteroff, end, start);
+       i = ubh_find_next_zero_bit (UCPI_UBH(ucpi), ucpi->c_clusteroff, end, start);
        if (i > end)
                i = end;
        forw = i - start;
@@ -759,7 +831,7 @@ static void ufs_clusteracct(struct super_block * sb,
        end = start - uspi->s_contigsumsize;
        if (end < 0 ) 
                end = -1;
-       i = ubh_find_last_zero_bit (UCPI_UBH, ucpi->c_clusteroff, start, end);
+       i = ubh_find_last_zero_bit (UCPI_UBH(ucpi), ucpi->c_clusteroff, start, end);
        if ( i < end) 
                i = end;
        back = start - i;
@@ -771,11 +843,11 @@ static void ufs_clusteracct(struct super_block * sb,
        i = back + forw + 1;
        if (i > uspi->s_contigsumsize)
                i = uspi->s_contigsumsize;
-       fs32_add(sb, (__fs32*)ubh_get_addr(UCPI_UBH, ucpi->c_clustersumoff + (i << 2)), cnt);
+       fs32_add(sb, (__fs32*)ubh_get_addr(UCPI_UBH(ucpi), ucpi->c_clustersumoff + (i << 2)), cnt);
        if (back > 0)
-               fs32_sub(sb, (__fs32*)ubh_get_addr(UCPI_UBH, ucpi->c_clustersumoff + (back << 2)), cnt);
+               fs32_sub(sb, (__fs32*)ubh_get_addr(UCPI_UBH(ucpi), ucpi->c_clustersumoff + (back << 2)), cnt);
        if (forw > 0)
-               fs32_sub(sb, (__fs32*)ubh_get_addr(UCPI_UBH, ucpi->c_clustersumoff + (forw << 2)), cnt);
+               fs32_sub(sb, (__fs32*)ubh_get_addr(UCPI_UBH(ucpi), ucpi->c_clustersumoff + (forw << 2)), cnt);
 }