net: tcp: Fix up the receive window
[akaros.git] / kern / src / ext2fs.c
index 78bc842..97c8f38 100644 (file)
@@ -98,8 +98,10 @@ struct kmem_cache *ext2_i_kcache;
 /* One-time init for all ext2 instances */
 void ext2_init(void)
 {
-       ext2_i_kcache = kmem_cache_create("ext2_i_info", sizeof(struct ext2_i_info),
-                                         __alignof__(struct ext2_i_info), 0, 0, 0);
+       ext2_i_kcache = kmem_cache_create("ext2_i_info",
+                                         sizeof(struct ext2_i_info),
+                                         __alignof__(struct ext2_i_info), 0,
+                                         NULL, 0, 0, NULL);
 }
 
 /* Block management */
@@ -462,7 +464,7 @@ void *ext2_get_ino_metablock(struct inode *inode, unsigned long ino_block)
  * the 2x and 3x walks are jacked up. */
 void ext2_print_ino_blocks(struct inode *inode)
 {
-       printk("Inode %08p, Size: %d, 512B 'blocks': %d\n-------------\n", inode,
+       printk("Inode %p, Size: %d, 512B 'blocks': %d\n-------------\n", inode,
               inode->i_size, inode->i_blocks);
        for (int i = 0; i < inode->i_blocks * (inode->i_sb->s_blocksize / 512); i++)
                printk("# %03d, Block %03d\n", i, ext2_find_inoblock(inode, i));
@@ -486,7 +488,7 @@ void ext2_check_sb(struct ext2_sb *e2sb, struct ext2_block_group *bg,
        blksize = 1024 << le32_to_cpu(e2sb->s_log_block_size);
        blks_per_group = le32_to_cpu(e2sb->s_blocks_per_group);
        num_blk_group = num_blks / blks_per_group + (num_blks % blks_per_group ? 1 : 0);
-       
+
        if (print) {
                printk("EXT2 info:\n-------------------------\n");
                printk("Total Inodes:     %8d\n", le32_to_cpu(e2sb->s_inodes_cnt));
@@ -516,12 +518,12 @@ void ext2_check_sb(struct ext2_sb *e2sb, struct ext2_block_group *bg,
                printk("Volume name:      %s\n", e2sb->s_volume_name);
                printk("\nBlock Group Info:\n----------------------\n");
        }
-       
+
        for (int i = 0; i < num_blk_group; i++) {
                sum_blks += le16_to_cpu(bg[i].bg_free_blocks_cnt);
                sum_inodes += le16_to_cpu(bg[i].bg_free_inodes_cnt);
                if (print) {
-                       printk("*** BG %d at %08p\n", i, &bg[i]);
+                       printk("*** BG %d at %p\n", i, &bg[i]);
                        printk("Block bitmap:%8d\n", le32_to_cpu(bg[i].bg_block_bitmap));
                        printk("Inode bitmap:%8d\n", le32_to_cpu(bg[i].bg_inode_bitmap));
                        printk("Inode table: %8d\n", le32_to_cpu(bg[i].bg_inode_table));
@@ -530,7 +532,7 @@ void ext2_check_sb(struct ext2_sb *e2sb, struct ext2_block_group *bg,
                        printk("Used Dirs:   %8d\n", le16_to_cpu(bg[i].bg_used_dirs_cnt));
                }
        }
-       
+
        /* Sanity Assertions.  A good ext2 will always pass these. */
        inodes_per_grp = le32_to_cpu(e2sb->s_inodes_per_group);
        blks_per_group = le32_to_cpu(e2sb->s_blocks_per_group);
@@ -704,7 +706,7 @@ int ext2_readpage(struct page_map *pm, struct page *page)
        struct block_request *breq;
        void *eobh;
 
-       assert(page->pg_flags & PG_BUFFER);
+       atomic_or(&page->pg_flags, PG_BUFFER);
        retval = ext2_mappage(pm, page);
        if (retval)
                return retval;
@@ -715,7 +717,7 @@ int ext2_readpage(struct page_map *pm, struct page *page)
        breq->flags = BREQ_READ;
        breq->callback = generic_breq_done;
        breq->data = 0;
-       init_sem(&breq->sem, 0);
+       sem_init_irqsave(&breq->sem, 0);
        breq->bhs = breq->local_bhs;
        breq->nr_bhs = 0;
        /* Pack the BH pointers in the block request */
@@ -731,7 +733,7 @@ int ext2_readpage(struct page_map *pm, struct page *page)
                } else {
                        memset(bh->bh_buffer, 0, pm->pm_host->i_sb->s_blocksize);
                        bh->bh_flags |= BH_DIRTY;
-                       bh->bh_page->pg_flags |= PG_DIRTY;
+                       atomic_or(&bh->bh_page->pg_flags, PG_DIRTY);
                }
        }
        retval = bdev_submit_request(bdev, breq);
@@ -748,12 +750,17 @@ int ext2_readpage(struct page_map *pm, struct page *page)
        if (eof_off)
                memset(eof_off + page2kva(page), 0, PGSIZE - eof_off);
        /* Now the page is up to date */
-       page->pg_flags |= PG_UPTODATE;
+       atomic_or(&page->pg_flags, PG_UPTODATE);
        /* Useful debugging.  Put one higher up if the page is not getting mapped */
        //print_pageinfo(page);
        return 0;
 }
 
+int ext2_writepage(struct page_map *pm, struct page *page)
+{
+       return -1;
+}
+
 /* Super Operations */
 
 /* Creates and initializes a new inode.  FS specific, yet inode-generic fields
@@ -960,14 +967,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;
@@ -1008,10 +1015,12 @@ static unsigned int ext2_dirent_len(struct ext2_dirent *e2dir)
                return 0;
 }
 
-/* Helper for writing the contents of a dentry to a disk dirent */
+/* Helper for writing the contents of a dentry to a disk dirent. Zeroes the
+ * contents of the dirent so that we don't write random data to disk. */
 static void ext2_write_dirent(struct ext2_dirent *e2dir, struct dentry *dentry,
                               unsigned int rec_len)
 {
+       memset(e2dir, 0, sizeof(*e2dir));
        e2dir->dir_inode = cpu_to_le32(dentry->d_inode->i_ino);
        e2dir->dir_reclen = cpu_to_le16(rec_len);
        e2dir->dir_namelen = dentry->d_name.len;
@@ -1039,17 +1048,18 @@ static void ext2_write_dirent(struct ext2_dirent *e2dir, struct dentry *dentry,
                        e2dir->dir_filetype = EXT2_FT_UNKNOWN;
        }
        assert(dentry->d_name.len <= 255);
-       strncpy((char*)e2dir->dir_name, dentry->d_name.name, dentry->d_name.len);
+       strlcpy((char*)e2dir->dir_name, dentry->d_name.name,
+               sizeof(e2dir->dir_name));
 }
 
 /* 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;
-       uintptr_t our_rec_len = (uintptr_t)a2;
-       uintptr_t mode = (uintptr_t)a3;
+       unsigned int our_rec_len = (unsigned int)a2;
+       unsigned int mode = (unsigned int)a3;
        struct ext2_dirent *dir_new;
        unsigned int real_len = ext2_dirent_len(dir_i);
        /* How much room is available after this dir_i before the next one */
@@ -1082,20 +1092,12 @@ int ext2_create(struct inode *dir, struct dentry *dentry, int mode,
        struct ext2_inode *disk_inode;
        struct ext2_i_info *e2ii;
        uint32_t dir_block;
-       uintptr_t our_rec_len;
-       /* TODO: figure out the real time!  (Nanwan's birthday, bitches!) */
-       time_t now = 1242129600;
+       unsigned int our_rec_len;
        struct ext2_dirent *new_dirent;
        /* Set basic inode stuff for files, get a disk inode, etc */
        SET_FTYPE(inode->i_mode, __S_IFREG);
        inode->i_fop = &ext2_f_op_file;
        inode->i_ino = ext2_alloc_diskinode(inode, dir_bg);
-       inode->i_atime.tv_sec = now;
-       inode->i_atime.tv_nsec = 0;
-       inode->i_ctime.tv_sec = now;
-       inode->i_ctime.tv_nsec = 0;
-       inode->i_mtime.tv_sec = now;
-       inode->i_mtime.tv_nsec = 0;
        /* Initialize disk inode (this will be different for short symlinks) */
        disk_inode = ext2_get_diskinode(inode);
        ext2_init_diskinode(disk_inode, inode);
@@ -1113,8 +1115,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*)(uintptr_t)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
@@ -1130,8 +1132,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
@@ -1139,7 +1141,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;
        }
@@ -1158,9 +1160,9 @@ 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);   
+       printd("EXT2: Not Found, %s\n", dentry->d_name.name);
        return 0;
 }
 
@@ -1190,8 +1192,7 @@ I_AM_HERE;
        struct inode *inode = dentry->d_inode;
        SET_FTYPE(inode->i_mode, __S_IFLNK);
        inode->i_fop = &ext2_f_op_sym;
-       strncpy(string, symname, len);
-       string[len] = '\0';             /* symname should be \0d anyway, but just in case */
+       strlcpy(string, symname, len + 1);
        #endif
        return 0;
 }
@@ -1273,12 +1274,6 @@ int ext2_d_revalidate(struct dentry *dir, struct nameidata *nd)
        return -1;
 }
 
-/* Produces the hash to lookup this dentry from the dcache */
-int ext2_d_hash(struct dentry *dentry, struct qstr *name)
-{
-       return -1;
-}
-
 /* Compares name1 and name2.  name1 should be a member of dir. */
 int ext2_d_compare(struct dentry *dir, struct qstr *name1, struct qstr *name2)
 { // default, string comp (case sensitive)
@@ -1308,9 +1303,9 @@ void ext2_d_iput(struct dentry *dentry, struct inode *inode)
 /* Updates the file pointer.  TODO: think about locking, and putting this in the
  * VFS. */
 #include <syscall.h>   /* just for set_errno, may go away later */
-off_t ext2_llseek(struct file *file, off_t offset, int whence)
+int ext2_llseek(struct file *file, off64_t offset, off64_t *ret, int whence)
 {
-       off_t temp_off = 0;
+       off64_t temp_off = 0;
        switch (whence) {
                case SEEK_SET:
                        temp_off = offset;
@@ -1327,7 +1322,8 @@ off_t ext2_llseek(struct file *file, off_t offset, int whence)
                        return -1;
        }
        file->f_pos = temp_off;
-       return temp_off;
+       *ret = temp_off;
+       return 0;
 }
 
 /* Fills in the next directory entry (dirent), starting with d_off.  Like with
@@ -1343,7 +1339,7 @@ int ext2_readdir(struct file *dir, struct dirent *dirent)
        int block = dirent->d_off / dir->f_dentry->d_sb->s_blocksize;
        blk_buf = ext2_get_ino_metablock(dir->f_dentry->d_inode, block);
        assert(blk_buf);
-       off_t f_off = dirent->d_off % dir->f_dentry->d_sb->s_blocksize;
+       off64_t f_off = dirent->d_off % dir->f_dentry->d_sb->s_blocksize;
        /* Copy out the dirent info */
        struct ext2_dirent *e2dir = (struct ext2_dirent*)(blk_buf + f_off);
        dirent->d_ino = le32_to_cpu(e2dir->dir_inode);
@@ -1352,11 +1348,10 @@ int ext2_readdir(struct file *dir, struct dirent *dirent)
                panic("Something is jacked with the dirent going beyond the dir/file");
        /* note, dir_namelen doesn't include the \0 */
        dirent->d_reclen = e2dir->dir_namelen;
-       strncpy(dirent->d_name, (char*)e2dir->dir_name, e2dir->dir_namelen);
        assert(e2dir->dir_namelen <= MAX_FILENAME_SZ);
-       dirent->d_name[e2dir->dir_namelen] = '\0';
+       strlcpy(dirent->d_name, (char*)e2dir->dir_name, e2dir->dir_namelen + 1);
        ext2_put_metablock(dir->f_dentry->d_sb, blk_buf);
-       
+
        /* At the end of the directory, sort of.  ext2 often preallocates blocks, so
         * this will cause us to walk along til the end, which isn't quite right. */
        if (dir->f_dentry->d_inode->i_size == dirent->d_off)
@@ -1418,7 +1413,7 @@ unsigned int ext2_poll(struct file *file, struct poll_table_struct *poll_table)
 /* Reads count bytes from a file, starting from (and modifiying) offset, and
  * putting the bytes into buffers described by vector */
 ssize_t ext2_readv(struct file *file, const struct iovec *vector,
-                  unsigned long count, off_t *offset)
+                  unsigned long count, off64_t *offset)
 {
        return -1;
 }
@@ -1426,14 +1421,14 @@ ssize_t ext2_readv(struct file *file, const struct iovec *vector,
 /* Writes count bytes to a file, starting from (and modifiying) offset, and
  * taking the bytes from buffers described by vector */
 ssize_t ext2_writev(struct file *file, const struct iovec *vector,
-                  unsigned long count, off_t *offset)
+                  unsigned long count, off64_t *offset)
 {
        return -1;
 }
 
 /* Write the contents of file to the page.  Will sort the params later */
 ssize_t ext2_sendpage(struct file *file, struct page *page, int offset,
-                     size_t size, off_t pos, int more)
+                     size_t size, off64_t pos, int more)
 {
        return -1;
 }
@@ -1447,6 +1442,7 @@ int ext2_check_flags(int flags)
 /* Redeclaration and initialization of the FS ops structures */
 struct page_map_operations ext2_pm_op = {
        ext2_readpage,
+       ext2_writepage,
 };
 
 struct super_operations ext2_s_op = {
@@ -1482,7 +1478,7 @@ struct inode_operations ext2_i_op = {
 
 struct dentry_operations ext2_d_op = {
        ext2_d_revalidate,
-       ext2_d_hash,
+       generic_dentry_hash,
        ext2_d_compare,
        ext2_d_delete,
        ext2_d_release,