New direcotory layout:

[fs/lustre-release.git] / lustre / obdfs / rw.c

diff --git a/lustre/obdfs/rw.c b/lustre/obdfs/rw.c
index 389058c..1e2b2a2 100644 (file)
--- a/lustre/obdfs/rw.c
+++ b/lustre/obdfs/rw.c
@@ -28,9 +28,11 @@
 #include <linux/pagemap.h>
 #include <linux/smp_lock.h>
 
 #include <linux/pagemap.h>
 #include <linux/smp_lock.h>
 

-#include <../obd/linux/obd_support.h>
-#include <../obd/linux/obd_sim.h>
-#include <obdfs.h>
+#include <linux/obd_support.h>
+#include <linux/obd_sim.h>
+#include <linux/obdfs.h>
+
+int console_loglevel;

 
 /* VFS super_block ops */
 
 
 /* VFS super_block ops */
 


@@ -45,14 +47,14 @@ int obdfs_readpage(struct file *file, struct page *page)
 
        /* XXX flush stuff */
        sbi = sb->u.generic_sbp;
 
        /* XXX flush stuff */
        sbi = sb->u.generic_sbp;

-       PDEBUG(page, READ);
+       PDEBUG(page, "READ");

        rc =  sbi->osi_ops->o_brw(READ, sbi->osi_conn_info.conn_id, 
        rc =  sbi->osi_ops->o_brw(READ, sbi->osi_conn_info.conn_id, 

-                     file->f_dentry->d_inode->i_ino, page);
+                     file->f_dentry->d_inode, page, 0);

        if (rc == PAGE_SIZE ) {
                SetPageUptodate(page);
                UnlockPage(page);
        } 
        if (rc == PAGE_SIZE ) {
                SetPageUptodate(page);
                UnlockPage(page);
        } 

-       PDEBUG(page, READ);
+       PDEBUG(page, "READ");

        if ( rc == PAGE_SIZE ) 
                rc = 0;
        return rc;
        if ( rc == PAGE_SIZE ) 
                rc = 0;
        return rc;


@@ -71,15 +73,30 @@ int obdfs_readpage(struct file *file, struct page *page)
 int obdfs_write_one_page(struct file *file, struct page *page, unsigned long offset, unsigned long bytes, const char * buf)
 {
        long status;
 int obdfs_write_one_page(struct file *file, struct page *page, unsigned long offset, unsigned long bytes, const char * buf)
 {
        long status;

+        struct obdfs_sb_info *sbi = file->f_dentry->d_inode->i_sb->u.generic_sbp;

 
 

+       ENTRY;
+       if ( !Page_Uptodate(page) ) {
+               status =  sbi->osi_ops->o_brw(READ, 
+                                             sbi->osi_conn_info.conn_id, 
+                                             file->f_dentry->d_inode, 
+                                             page, 1);
+               if (status == PAGE_SIZE ) {
+                       SetPageUptodate(page);
+               } else { 
+                       return status;
+               }
+       }

        bytes -= copy_from_user((u8*)page_address(page) + offset, buf, bytes);
        status = -EFAULT;
        bytes -= copy_from_user((u8*)page_address(page) + offset, buf, bytes);
        status = -EFAULT;

-       CDEBUG(D_INODE, "page offset %ld, bytes %ld, offset %ld, page addr %lx, writing: %s, beg of page %s\n", page->offset, bytes, offset, page_address(page), ((char *) page_address(page)) + offset, (char *)page_address(page));
+

        if (bytes) {
        if (bytes) {

+

                lock_kernel();
                status = obdfs_writepage(file, page);
                unlock_kernel();
        }
                lock_kernel();
                status = obdfs_writepage(file, page);
                unlock_kernel();
        }

+       EXIT;

        if ( status != PAGE_SIZE ) 
                return status;
        else
        if ( status != PAGE_SIZE ) 
                return status;
        else


@@ -92,78 +109,117 @@ int obdfs_write_one_page(struct file *file, struct page *page, unsigned long off
 /* returns the page unlocked, but with a reference */
 int obdfs_writepage(struct file *file, struct page *page)
 {
 /* returns the page unlocked, but with a reference */
 int obdfs_writepage(struct file *file, struct page *page)
 {

-        struct obdfs_sb_info *sbi;
-       struct super_block *sb = file->f_dentry->d_inode->i_sb;
+        struct obdfs_sb_info *sbi = file->f_dentry->d_inode->i_sb->u.generic_sbp;

        int rc;
 
         ENTRY;
        int rc;
 
         ENTRY;

-       PDEBUG(page,WRITE);
+       PDEBUG(page, "WRITEPAGE");

        /* XXX flush stuff */
        /* XXX flush stuff */

-       sbi = sb->u.generic_sbp;

 
        rc = sbi->osi_ops->o_brw(WRITE, sbi->osi_conn_info.conn_id, 
 
        rc = sbi->osi_ops->o_brw(WRITE, sbi->osi_conn_info.conn_id, 

-                     file->f_dentry->d_inode->i_ino, page);
+                     file->f_dentry->d_inode, page, 1);
+

        SetPageUptodate(page);
        SetPageUptodate(page);

-       PDEBUG(page,WRITE);
+       PDEBUG(page,"WRITEPAGE");

        return rc;
 }
 
 
        return rc;
 }
 
 

+void report_inode(struct page * page) {
+       struct inode *inode = (struct inode *)0;
+       int offset = (int)&inode->i_data;
+       inode = (struct inode *)( (char *)page->mapping - offset);
+       if ( inode->i_sb->s_magic == 0x4711 )
+               printk("----> ino %ld , dev %d\n", inode->i_ino, inode->i_dev);
+}
+

 /* 
 /* 

-   page is returned unlocked, with the up to date flag set, 
-   and held, i.e. caller must do a page_put
+   return an up to date page:
+    - if locked is true then is returned locked
+    - if create is true the corresponding disk blocks are created 
+    - page is held, i.e. caller must release the page
+
+   modeled on NFS code.

 */
 */

-struct page *obdfs_getpage(struct inode *inode, unsigned long offset)
+struct page *obdfs_getpage(struct inode *inode, unsigned long offset, int create, int locked)

 {
 {

-       unsigned long new_page;
+       struct page *page_cache;

        struct page ** hash;
        struct page ** hash;

-       struct page * page; 
+       struct page * page;

        struct obdfs_sb_info *sbi;
        struct super_block *sb = inode->i_sb;
        struct obdfs_sb_info *sbi;
        struct super_block *sb = inode->i_sb;

+       int rc;

 
         ENTRY;
 
 
         ENTRY;
 

+       offset = offset & PAGE_CACHE_MASK;

        sbi = sb->u.generic_sbp;
        sbi = sb->u.generic_sbp;

+       CDEBUG(D_INODE, "\n");

        
        

-       page = find_get_page(inode, offset); 
-       if (page && Page_Uptodate(page)) { 
-               PDEBUG(page,READ);
+       page = NULL;
+       page_cache = page_cache_alloc();
+       if ( ! page_cache ) 
+               return NULL;
+       CDEBUG(D_INODE, "page_cache %p\n", page_cache);
+
+       hash = page_hash(&inode->i_data, offset);
+ repeat:
+       CDEBUG(D_INODE, "Finding page\n");
+       IDEBUG(inode);
+
+       page = __find_lock_page(&inode->i_data, offset, hash); 
+       if ( page ) {
+               CDEBUG(D_INODE, "Page found freeing\n");
+               page_cache_free(page_cache);
+       } else {
+               page = page_cache;
+               if ( page->buffers ) {
+                       PDEBUG(page, "GETPAGE: buffers bug\n");
+                       UnlockPage(page);
+                       return NULL;
+               }
+               if (add_to_page_cache_unique(page, &inode->i_data, offset, hash)) {
+                       page_cache_release(page);
+                       CDEBUG(D_INODE, "Someone raced: try again\n");
+                       goto repeat;
+               }
+       }
+
+       PDEBUG(page, "GETPAGE: got page - before reading\n");
+       /* now check if the data in the page is up to date */
+       if ( Page_Uptodate(page)) { 
+               if (!locked)
+                       UnlockPage(page);
+               EXIT;

                return page;
        } 
                return page;
        } 

-               
-       if (page && !Page_Uptodate(page) ) {
-               CDEBUG(D_INODE, "Page found but not up to date\n");
-       }

 
 

-       /* page_cache_alloc returns address of page */
-       new_page = page_cache_alloc();
-       if (!new_page)
-               return NULL;
-       
-       /* corresponding struct page in the mmap */
-       hash = page_hash(inode, offset);
-       page = page_cache_entry(new_page);
-       if (!add_to_page_cache_unique(page, inode, offset, hash)) {
-               CDEBUG(D_INODE, "Page not found. Reading it.\n");
-               PDEBUG(page,READ);
-               sbi->osi_ops->o_brw(READ, sbi->osi_conn_info.conn_id, 
-                                   inode->i_ino, page);
+       /* it's not: read it */
+       if (! page) {
+           printk("get_page_map says no dice ...\n");
+           return 0;
+           }
+
+
+
+       rc = sbi->osi_ops->o_brw(READ, sbi->osi_conn_info.conn_id, 
+                                   inode, page, create);
+       if ( rc != PAGE_SIZE ) {
+               SetPageError(page);

                UnlockPage(page);
                UnlockPage(page);

-               SetPageUptodate(page);

                return page;
        }
                return page;
        }

-       /*
-        * We arrive here in the unlikely event that someone 
-        * raced with us and added our page to the cache first.
-        */
-       CDEBUG(D_INODE, "Page not found. Someone raced us.\n");
-       PDEBUG(page,READ);
+
+       if ( !locked )
+               UnlockPage(page);
+       SetPageUptodate(page);
+       PDEBUG(page,"GETPAGE - after reading");
+       EXIT;

        return page;
 }
 
 
        return page;
 }
 
 

-
-struct file_operations obdfs_file_operations = {
+struct file_operations obdfs_file_ops = {

        NULL,                   /* lseek - default */
        generic_file_read,      /* read */
        obdfs_file_write,     /* write - bad */
        NULL,                   /* lseek - default */
        generic_file_read,      /* read */
        obdfs_file_write,     /* write - bad */


@@ -181,16 +237,16 @@ struct file_operations obdfs_file_operations = {
 };
 
 struct inode_operations obdfs_inode_ops = {
 };
 
 struct inode_operations obdfs_inode_ops = {

-       &obdfs_file_operations, /* default directory file-ops */
-       NULL,           /* create */
+       &obdfs_file_ops,        /* default directory file-ops */
+       obdfs_create,   /* create */

        obdfs_lookup,   /* lookup */
        obdfs_lookup,   /* lookup */

-       NULL,           /* link */
-       NULL,           /* unlink */
-       NULL,           /* symlink */
-       NULL,           /* mkdir */
-       NULL,           /* rmdir */
-       NULL,           /* mknod */
-       NULL,           /* rename */
+       obdfs_link,     /* link */
+       obdfs_unlink,   /* unlink */
+       obdfs_symlink,  /* symlink */
+       obdfs_mkdir,    /* mkdir */
+       obdfs_rmdir,    /* rmdir */
+       obdfs_mknod,    /* mknod */
+       obdfs_rename,   /* rename */

        NULL,           /* readlink */
        NULL,           /* follow_link */
        NULL,           /* get_block */
        NULL,           /* readlink */
        NULL,           /* follow_link */
        NULL,           /* get_block */