fedora core 6 1.2949 + vserver 2.2.0

[linux-2.6.git] / fs / ufs / util.c

diff --git a/fs/ufs/util.c b/fs/ufs/util.c
index 59acc8f..1743757 100644 (file)
--- a/fs/ufs/util.c
+++ b/fs/ufs/util.c
@@ -14,15 +14,6 @@
 #include "swab.h"
 #include "util.h"
 
-#undef UFS_UTILS_DEBUG
-
-#ifdef UFS_UTILS_DEBUG
-#define UFSD(x) printk("(%s, %d), %s: ", __FILE__, __LINE__, __FUNCTION__); printk x;
-#else
-#define UFSD(x)
-#endif
-
-
 struct ufs_buffer_head * _ubh_bread_ (struct ufs_sb_private_info * uspi,
        struct super_block *sb, u64 fragment, u64 size)
 {
@@ -63,17 +54,17 @@ struct ufs_buffer_head * ubh_bread_uspi (struct ufs_sb_private_info * uspi,
        count = size >> uspi->s_fshift;
        if (count <= 0 || count > UFS_MAXFRAG)
                return NULL;
-       USPI_UBH->fragment = fragment;
-       USPI_UBH->count = count;
+       USPI_UBH(uspi)->fragment = fragment;
+       USPI_UBH(uspi)->count = count;
        for (i = 0; i < count; i++)
-               if (!(USPI_UBH->bh[i] = sb_bread(sb, fragment + i)))
+               if (!(USPI_UBH(uspi)->bh[i] = sb_bread(sb, fragment + i)))
                        goto failed;
        for (; i < UFS_MAXFRAG; i++)
-               USPI_UBH->bh[i] = NULL;
-       return USPI_UBH;
+               USPI_UBH(uspi)->bh[i] = NULL;
+       return USPI_UBH(uspi);
 failed:
        for (j = 0; j < i; j++)
-               brelse (USPI_UBH->bh[j]);
+               brelse (USPI_UBH(uspi)->bh[j]);
        return NULL;
 }
 
@@ -90,11 +81,11 @@ void ubh_brelse (struct ufs_buffer_head * ubh)
 void ubh_brelse_uspi (struct ufs_sb_private_info * uspi)
 {
        unsigned i;
-       if (!USPI_UBH)
+       if (!USPI_UBH(uspi))
                return;
-       for ( i = 0; i < USPI_UBH->count; i++ ) {
-               brelse (USPI_UBH->bh[i]);
-               USPI_UBH->bh[i] = NULL;
+       for ( i = 0; i < USPI_UBH(uspi)->count; i++ ) {
+               brelse (USPI_UBH(uspi)->bh[i]);
+               USPI_UBH(uspi)->bh[i] = NULL;
        }
 }
 
@@ -121,13 +112,12 @@ void ubh_mark_buffer_uptodate (struct ufs_buffer_head * ubh, int flag)
        }
 }
 
-void ubh_ll_rw_block (int rw, unsigned nr, struct ufs_buffer_head * ubh[])
+void ubh_ll_rw_block(int rw, struct ufs_buffer_head *ubh)
 {
-       unsigned i;
        if (!ubh)
                return;
-       for ( i = 0; i < nr; i++ )
-               ll_rw_block (rw, ubh[i]->count, ubh[i]->bh);
+
+       ll_rw_block(rw, ubh->count, ubh->bh);
 }
 
 void ubh_wait_on_buffer (struct ufs_buffer_head * ubh)
@@ -139,18 +129,6 @@ void ubh_wait_on_buffer (struct ufs_buffer_head * ubh)
                wait_on_buffer (ubh->bh[i]);
 }
 
-unsigned ubh_max_bcount (struct ufs_buffer_head * ubh)
-{
-       unsigned i;
-       unsigned max = 0;
-       if (!ubh)
-               return 0;
-       for ( i = 0; i < ubh->count; i++ ) 
-               if ( atomic_read(&ubh->bh[i]->b_count) > max )
-                       max = atomic_read(&ubh->bh[i]->b_count);
-       return max;
-}
-
 void ubh_bforget (struct ufs_buffer_head * ubh)
 {
        unsigned i;
@@ -206,14 +184,13 @@ void _ubh_memcpyubh_(struct ufs_sb_private_info * uspi,
 dev_t
 ufs_get_inode_dev(struct super_block *sb, struct ufs_inode_info *ufsi)
 {
-       __fs32 fs32;
+       __u32 fs32;
        dev_t dev;
 
        if ((UFS_SB(sb)->s_flags & UFS_ST_MASK) == UFS_ST_SUNx86)
-               fs32 = ufsi->i_u1.i_data[1];
+               fs32 = fs32_to_cpu(sb, ufsi->i_u1.i_data[1]);
        else
-               fs32 = ufsi->i_u1.i_data[0];
-       fs32 = fs32_to_cpu(sb, fs32);
+               fs32 = fs32_to_cpu(sb, ufsi->i_u1.i_data[0]);
        switch (UFS_SB(sb)->s_flags & UFS_ST_MASK) {
        case UFS_ST_SUNx86:
        case UFS_ST_SUN:
@@ -234,7 +211,7 @@ ufs_get_inode_dev(struct super_block *sb, struct ufs_inode_info *ufsi)
 void
 ufs_set_inode_dev(struct super_block *sb, struct ufs_inode_info *ufsi, dev_t dev)
 {
-       __fs32 fs32;
+       __u32 fs32;
 
        switch (UFS_SB(sb)->s_flags & UFS_ST_MASK) {
        case UFS_ST_SUNx86:
@@ -249,9 +226,63 @@ ufs_set_inode_dev(struct super_block *sb, struct ufs_inode_info *ufsi, dev_t dev
                fs32 = old_encode_dev(dev);
                break;
        }
-       fs32 = cpu_to_fs32(sb, fs32);
        if ((UFS_SB(sb)->s_flags & UFS_ST_MASK) == UFS_ST_SUNx86)
-               ufsi->i_u1.i_data[1] = fs32;
+               ufsi->i_u1.i_data[1] = cpu_to_fs32(sb, fs32);
        else
-               ufsi->i_u1.i_data[0] = fs32;
+               ufsi->i_u1.i_data[0] = cpu_to_fs32(sb, fs32);
+}
+
+/**
+ * ufs_get_locked_page() - locate, pin and lock a pagecache page, if not exist
+ * read it from disk.
+ * @mapping: the address_space to search
+ * @index: the page index
+ *
+ * Locates the desired pagecache page, if not exist we'll read it,
+ * locks it, increments its reference
+ * count and returns its address.
+ *
+ */
+
+struct page *ufs_get_locked_page(struct address_space *mapping,
+                                pgoff_t index)
+{
+       struct page *page;
+
+       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);
+
+               if (unlikely(page->mapping == NULL)) {
+                       /* Truncate got there first */
+                       unlock_page(page);
+                       page_cache_release(page);
+                       page = NULL;
+                       goto out;
+               }
+
+               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);
+               }
+       }
+out:
+       return page;
 }