Debug code to see remote kmsgs
[akaros.git] / kern / src / ext2fs.c
index fc8b04a..c81a223 100644 (file)
@@ -14,7 +14,7 @@
 #include <endian.h>
 #include <error.h>
 #include <pmap.h>
-#include <arch/bitmask.h>
+#include <bitmask.h>
 
 /* These structs are declared again and initialized farther down */
 struct page_map_operations ext2_pm_op;
@@ -111,7 +111,7 @@ void ext2_init(void)
 void *__ext2_get_metablock(struct block_device *bdev, unsigned long blk_num,
                            unsigned int blk_sz)
 {
-       return get_buffer(bdev, blk_num, blk_sz)->bh_buffer;
+       return bdev_get_buffer(bdev, blk_num, blk_sz)->bh_buffer;
 }
 
 /* Convenience wrapper */
@@ -141,12 +141,12 @@ static struct buffer_head *ext2_my_bh(struct super_block *sb, void *addr)
 
 /* Decrefs the buffer from get_metablock().  Call this when you no longer
  * reference your metadata block/buffer.  Yes, we could just decref the page,
- * but this will work if we end up changing how put_buffer() works. */
+ * but this will work if we end up changing how bdev_put_buffer() works. */
 void ext2_put_metablock(struct super_block *sb, void *buffer)
 {
        struct buffer_head *bh = ext2_my_bh(sb, buffer);
        if (bh)
-               put_buffer(bh);
+               bdev_put_buffer(bh);
 }
 
 /* Will dirty the block/BH/page for the given metadata block/buffer. */
@@ -154,7 +154,7 @@ void ext2_dirty_metablock(struct super_block *sb, void *buffer)
 {
        struct buffer_head *bh = ext2_my_bh(sb, buffer);
        if (bh)
-               dirty_buffer(bh);
+               bdev_dirty_buffer(bh);
 }
 
 /* Helper for alloc_block.  It will try to alloc a block from the BG, starting
@@ -706,17 +706,16 @@ int ext2_readpage(struct page_map *pm, struct page *page)
 
        assert(page->pg_flags & PG_BUFFER);
        retval = ext2_mappage(pm, page);
-       if (retval) {
-               unlock_page(page);
+       if (retval)
                return retval;
-       }
        /* Build and submit the request */
        breq = kmem_cache_alloc(breq_kcache, 0);
-       if (!breq) {
-               unlock_page(page);
+       if (!breq)
                return -ENOMEM;
-       }
        breq->flags = BREQ_READ;
+       breq->callback = generic_breq_done;
+       breq->data = 0;
+       init_sem(&breq->sem, 0);
        breq->bhs = breq->local_bhs;
        breq->nr_bhs = 0;
        /* Pack the BH pointers in the block request */
@@ -735,9 +734,10 @@ int ext2_readpage(struct page_map *pm, struct page *page)
                        bh->bh_page->pg_flags |= PG_DIRTY;
                }
        }
-       /* TODO: (BLK) this assumes we slept til the request was done */
-       retval = make_request(bdev, breq);
+       retval = bdev_submit_request(bdev, breq);
        assert(!retval);
+       sleep_on_breq(breq);
+       kmem_cache_free(breq_kcache, breq);
        /* zero out whatever is beyond the EOF.  we could do this by figuring out
         * where the BHs end and zeroing from there, but I'd rather zero from where
         * the file ends (which could be in the middle of an FS block */
@@ -747,10 +747,8 @@ int ext2_readpage(struct page_map *pm, struct page *page)
        /* at this point, eof_off is the offset into the page of the EOF, or 0 */
        if (eof_off)
                memset(eof_off + page2kva(page), 0, PGSIZE - eof_off);
-       /* after the data is read, we mark it up to date and unlock the page. */
+       /* Now the page is up to date */
        page->pg_flags |= PG_UPTODATE;
-       unlock_page(page);
-       kmem_cache_free(breq_kcache, breq);
        /* Useful debugging.  Put one higher up if the page is not getting mapped */
        //print_pageinfo(page);
        return 0;
@@ -962,14 +960,14 @@ static void ext2_init_diskinode(struct ext2_inode *e2i, struct inode *inode)
 
 /* These should return true if foreach_dirent should stop working on the
  * dirents. */
-typedef bool (*each_func_t) (struct ext2_dirent *dir_i, void *a1, void *a2,
-                             void *a3);
+typedef bool (*each_func_t) (struct ext2_dirent *dir_i, long a1, long a2,
+                             long a3);
 
 /* Loads the buffer and performs my_work on each dirent, stopping and returning
  * 0 if one of the calls succeeded, or returning the dir block num of what would
  * be the next dir block otherwise (aka, how many blocks we went through). */
 static uint32_t ext2_foreach_dirent(struct inode *dir, each_func_t my_work,
-                                    void *a1, void *a2, void *a3)
+                                    long a1, long a2, long a3)
 {
        struct ext2_dirent *dir_buf, *dir_i;
        uint32_t dir_block = 0;
@@ -1046,8 +1044,8 @@ static void ext2_write_dirent(struct ext2_dirent *e2dir, struct dentry *dentry,
 
 /* Helper for ext2_create().  This tries to squeeze a dirent in the slack space
  * after an existing dirent, returning TRUE if it succeeded (to break out). */
-static bool create_each_func(struct ext2_dirent *dir_i, void *a1, void *a2,
-                             void *a3)
+static bool create_each_func(struct ext2_dirent *dir_i, long a1, long a2,
+                             long a3)
 {
        struct dentry *dentry = (struct dentry*)a1;
        unsigned int our_rec_len = (unsigned int)a2;
@@ -1115,8 +1113,8 @@ int ext2_create(struct inode *dir, struct dentry *dentry, int mode,
        assert(our_rec_len <= 8 + 256);
        /* Consider caching the start point for future dirent ops.  Or even using
         * the indexed directory.... */
-       dir_block = ext2_foreach_dirent(dir, create_each_func, dentry,
-                                       (void*)our_rec_len, (void*)mode);
+       dir_block = ext2_foreach_dirent(dir, create_each_func, (long)dentry,
+                                       (long)our_rec_len, (long)mode);
        /* If this returned a block number, we didn't find room in any of the
         * existing directory blocks, so we need to make a new one, stick it in the
         * dir inode, and stick our dirent at the beginning.  The reclen is the
@@ -1132,8 +1130,8 @@ int ext2_create(struct inode *dir, struct dentry *dentry, int mode,
 
 /* If we match, this loads the inode for the dentry and returns true (so we
  * break out) */
-static bool lookup_each_func(struct ext2_dirent *dir_i, void *a1, void *a2,
-                             void *a3)
+static bool lookup_each_func(struct ext2_dirent *dir_i, long a1, long a2,
+                             long a3)
 {
        struct dentry *dentry = (struct dentry*)a1;
        /* Test if we're the one (TODO: use d_compare).  Note, dir_name is not
@@ -1141,7 +1139,7 @@ static bool lookup_each_func(struct ext2_dirent *dir_i, void *a1, void *a2,
        if (!strncmp((char*)dir_i->dir_name, dentry->d_name.name,
                     dir_i->dir_namelen) &&
                    (dentry->d_name.name[dir_i->dir_namelen] == '\0')) {
-               load_inode(dentry, le32_to_cpu(dir_i->dir_inode));
+               load_inode(dentry, (long)le32_to_cpu(dir_i->dir_inode));
                /* TODO: (HASH) add dentry to dcache (maybe the caller should) */
                return TRUE;
        }
@@ -1160,7 +1158,7 @@ struct dentry *ext2_lookup(struct inode *dir, struct dentry *dentry,
 {
        assert(S_ISDIR(dir->i_mode));
        struct ext2_dirent *dir_buf, *dir_i;
-       if (!ext2_foreach_dirent(dir, lookup_each_func, dentry, 0, 0))
+       if (!ext2_foreach_dirent(dir, lookup_each_func, (long)dentry, 0, 0))
                return dentry;
        printd("EXT2: Not Found, %s\n", dentry->d_name.name);   
        return 0;