9a538f578845f06ce47036b8091be85c576d2299
[akaros.git] / kern / src / ext2fs.c
1 /* Copyright (c) 2010 The Regents of the University of California
2  * Barret Rhoden <brho@cs.berkeley.edu>
3  * See LICENSE for details.
4  *
5  * Ext2, VFS required functions, internal functions, life, the universe, and
6  * everything! */
7
8 #include <vfs.h>
9 #include <ext2fs.h>
10 #include <blockdev.h>
11 #include <kmalloc.h>
12 #include <assert.h>
13 #include <kref.h>
14 #include <endian.h>
15 #include <error.h>
16 #include <pmap.h>
17 #include <arch/bitmask.h>
18
19 /* These structs are declared again and initialized farther down */
20 struct page_map_operations ext2_pm_op;
21 struct super_operations ext2_s_op;
22 struct inode_operations ext2_i_op;
23 struct dentry_operations ext2_d_op;
24 struct file_operations ext2_f_op_file;
25 struct file_operations ext2_f_op_dir;
26 struct file_operations ext2_f_op_sym;
27
28 /* EXT2 Internal Functions */
29
30 /* Useful helper functions. */
31
32 /* Returns the block group ID of the BG containing the inode.  BGs start with 0,
33  * inodes are indexed starting at 1. */
34 static struct ext2_block_group *ext2_inode2bg(struct inode *inode)
35 {
36         struct ext2_sb_info *e2sbi = (struct ext2_sb_info*)inode->i_sb->s_fs_info;
37         unsigned int bg_num = (inode->i_ino - 1) /
38                               le32_to_cpu(e2sbi->e2sb->s_inodes_per_group);
39         return &e2sbi->e2bg[bg_num];
40 }
41
42 /* This returns the inode's 0-index within a block group */
43 static unsigned int ext2_inode2bgidx(struct inode *inode)
44 {
45         struct ext2_sb_info *e2sbi = (struct ext2_sb_info*)inode->i_sb->s_fs_info;
46         return (inode->i_ino - 1) % le32_to_cpu(e2sbi->e2sb->s_inodes_per_group);
47 }
48
49 /* Returns an uncounted reference to the BG in the BG table, which is pinned,
50  * hanging off the sb.  Note, the BGs cover the blocks starting from the first
51  * data block, not from 0.  So if the FDB is 1, BG 0 covers 1 through 1024, and
52  * not 0 through 1023. */
53 static struct ext2_block_group *ext2_block2bg(struct super_block *sb,
54                                               uint32_t blk_num)
55 {
56         struct ext2_sb_info *e2sbi = (struct ext2_sb_info*)sb->s_fs_info;
57         unsigned int bg_num;
58         bg_num = (blk_num - le32_to_cpu(e2sbi->e2sb->s_first_data_block)) /
59                  le32_to_cpu(e2sbi->e2sb->s_blocks_per_group);
60         return &e2sbi->e2bg[bg_num];
61 }
62
63 /* This returns the block's 0-index within a block group.  Note all blocks are
64  * offset by FDB when dealing with BG membership. */
65 static unsigned int ext2_block2bgidx(struct super_block *sb, uint32_t blk_num)
66 {
67         struct ext2_sb_info *e2sbi = (struct ext2_sb_info*)sb->s_fs_info;
68         return (blk_num - le32_to_cpu(e2sbi->e2sb->s_first_data_block)) %
69                le32_to_cpu(e2sbi->e2sb->s_blocks_per_group);
70 }
71
72 /* Returns the FS block for the given BG's idx block */
73 static uint32_t ext2_bgidx2block(struct super_block *sb,
74                                  struct ext2_block_group *bg,
75                                  unsigned int blk_idx)
76 {
77         struct ext2_sb_info *e2sbi = (struct ext2_sb_info*)sb->s_fs_info;
78         struct ext2_sb *e2sb = e2sbi->e2sb;
79         struct ext2_block_group *e2bg = e2sbi->e2bg;
80         return (bg - e2bg) * le32_to_cpu(e2sb->s_blocks_per_group) + blk_idx +
81                le32_to_cpu(e2sb->s_first_data_block);
82 }
83
84 /* Slabs for ext2 specific info chunks */
85 struct kmem_cache *ext2_i_kcache;
86
87 /* One-time init for all ext2 instances */
88 void ext2_init(void)
89 {
90         ext2_i_kcache = kmem_cache_create("ext2_i_info", sizeof(struct ext2_i_info),
91                                           __alignof__(struct ext2_i_info), 0, 0, 0);
92 }
93
94 /* Block management */
95
96 /* TODO: pull these metablock functions out of ext2 */
97 /* Makes sure the FS block of metadata is in memory.  This returns a pointer to
98  * the beginning of the requested block.  Release it with put_metablock().
99  * Internally, the kreffing is done on the page. */
100 void *__ext2_get_metablock(struct block_device *bdev, unsigned long blk_num,
101                            unsigned int blk_sz)
102 {
103         return get_buffer(bdev, blk_num, blk_sz)->bh_buffer;
104 }
105
106 /* Convenience wrapper */
107 void *ext2_get_metablock(struct super_block *sb, unsigned long block_num)
108 {
109         return __ext2_get_metablock(sb->s_bdev, block_num, sb->s_blocksize);
110 }
111
112 /* Helper to figure out the BH for any address within it's buffer */
113 static struct buffer_head *ext2_my_bh(struct super_block *sb, void *addr)
114 {
115         struct page *page = kva2page(addr);
116         struct buffer_head *bh = (struct buffer_head*)page->pg_private;
117         /* This case is for when we try do decref a non-BH'd 'metablock'.  It's tied
118          * to e2ii->i_block[]. */
119         if (!bh)
120                 return 0;
121         void *my_buf = (void*)ROUNDDOWN((uintptr_t)addr, sb->s_blocksize);
122         while (bh) {
123                 if (bh->bh_buffer == my_buf)
124                         break;
125                 bh = bh->bh_next;
126         }
127         assert(bh && bh->bh_buffer == my_buf);
128         return bh;
129 }
130
131 /* Decrefs the buffer from get_metablock().  Call this when you no longer
132  * reference your metadata block/buffer.  Yes, we could just decref the page,
133  * but this will work if we end up changing how put_buffer() works. */
134 void ext2_put_metablock(struct super_block *sb, void *buffer)
135 {
136         struct buffer_head *bh = ext2_my_bh(sb, buffer);
137         if (bh)
138                 put_buffer(bh);
139 }
140
141 /* Will dirty the block/BH/page for the given metadata block/buffer. */
142 void ext2_dirty_metablock(struct super_block *sb, void *buffer)
143 {
144         struct buffer_head *bh = ext2_my_bh(sb, buffer);
145         if (bh)
146                 dirty_buffer(bh);
147 }
148
149 /* Helper for alloc_block.  It will try to alloc a block from the BG, starting
150  * with blk_idx (relative number within the BG).   If successful, it will return
151  * the FS block number via *block_num.  TODO: concurrency protection */
152 static bool ext2_tryalloc(struct super_block *sb, struct ext2_block_group *bg,
153                           unsigned int blk_idx, uint32_t *block_num)
154 {
155         uint8_t *blk_bitmap;
156         struct ext2_sb_info *e2sbi = (struct ext2_sb_info*)sb->s_fs_info;
157         unsigned int blks_per_bg = le32_to_cpu(e2sbi->e2sb->s_blocks_per_group);
158         bool found = FALSE;
159
160         /* Check to see if there are any free blocks */
161         if (!le32_to_cpu(bg->bg_free_blocks_cnt))
162                 return FALSE;
163         /* Check the bitmap for your desired block.  We'll loop through the whole
164          * BG, starting with the one we want first. */
165         blk_bitmap = ext2_get_metablock(sb, bg->bg_block_bitmap);
166         for (int i = 0; i < blks_per_bg; i++) {
167                 if (!(GET_BITMASK_BIT(blk_bitmap, blk_idx))) {
168                         SET_BITMASK_BIT(blk_bitmap, blk_idx);
169                         bg->bg_free_blocks_cnt--;
170                         ext2_dirty_metablock(sb, blk_bitmap);
171                         found = TRUE;
172                         break;
173                 }
174                 /* Note: the wrap-around hasn't been tested yet */
175                 blk_idx = (blk_idx + 1) % blks_per_bg;
176         }
177         ext2_put_metablock(sb, blk_bitmap);
178         if (found)
179                 *block_num = ext2_bgidx2block(sb, bg, blk_idx);
180         return found;
181 }
182
183 /* This allocates a fresh block for the inode, preferably 'fetish' (name
184  * courtesy of L.F.), returning the FS block number that's been allocated.
185  * Note, Linux does some block preallocation here.  Consider doing the same (off
186  * the in-memory inode).  Note the lack of concurrency protections here. */
187 uint32_t ext2_alloc_block(struct inode *inode, uint32_t fetish)
188 {
189         struct ext2_sb_info *e2sbi = (struct ext2_sb_info*)inode->i_sb->s_fs_info;
190         struct ext2_block_group *fetish_bg, *bg_i = e2sbi->e2bg;
191         unsigned int blk_idx;
192         uint8_t *blk_bitmap;
193         bool found = FALSE;
194         uint32_t retval = 0;
195
196         /* Get our ideal starting point */
197         fetish_bg = ext2_block2bg(inode->i_sb, fetish);
198         blk_idx = ext2_block2bgidx(inode->i_sb, fetish);
199         /* Try to find a free block in the BG of the one we desire */
200         found = ext2_tryalloc(inode->i_sb, fetish_bg, blk_idx, &retval);
201         if (found)
202                 return retval;
203
204         warn("This part hasn't been tested yet.");
205         /* Find a block anywhere else (perhaps using the log trick, but for now just
206          * linearly scanning). */
207         for (int i = 0; i < e2sbi->nr_bgs; i++, bg_i++) {
208                 if (bg_i == fetish_bg)
209                         continue;
210                 found = ext2_tryalloc(inode->i_sb, bg_i, 0, &retval);
211                 if (found)
212                         break;
213         }
214         if (!found)
215                 panic("Ran out of blocks! (probably a bug)");
216         return retval;
217 }
218
219 /* Inode Table Management */
220
221 /* Helper for ino table management.  blkid is the inode table block we are
222  * looking in, rel_blkid is the block we want, relative to the current
223  * threshhold for a level of indirection, and reach is how many items a given
224  * slot indexes.  Returns a pointer to the slot for the given block. */
225 static uint32_t *ext2_find_inotable_slot(struct inode *inode, uint32_t blkid,
226                                          uint32_t rel_blkid,
227                                          unsigned int reach)
228 {
229         uint32_t *blk_buf = ext2_get_metablock(inode->i_sb, blkid);
230         assert(blk_buf);
231         return &blk_buf[rel_blkid / reach];
232 }
233
234 /* If blk_slot is empty (no block mapped there) it will alloc and link a new
235  * block.  This is only used for allocating a block to be an indirect table
236  * (it's grabbing a metablock, we have no hint, and it handles the buffer
237  * differently than for a file page/buffer). */
238 static void ext2_fill_inotable_slot(struct inode *inode, uint32_t *blk_slot)
239 {
240         uint32_t new_blkid, hint_blk;
241         void *new_blk;
242
243         if (le32_to_cpu(*blk_slot))
244                 return;
245         /* Use any block in our inode's BG as a hint for the indirect block */
246         hint_blk = ext2_bgidx2block(inode->i_sb, ext2_inode2bg(inode), 0);
247         new_blkid = ext2_alloc_block(inode, hint_blk);
248         /* Actually read in the block we alloc'd */
249         new_blk = ext2_get_metablock(inode->i_sb, new_blkid);
250         memset(new_blk, 0, inode->i_sb->s_blocksize);
251         ext2_dirty_metablock(inode->i_sb, new_blk);
252         /* We put it, despite it getting relooked up in the next walk */
253         ext2_put_metablock(inode->i_sb, new_blk);
254         /* Now write the new block into its slot */
255         *blk_slot = cpu_to_le32(new_blkid);
256         ext2_dirty_metablock(inode->i_sb, blk_slot);
257 }
258
259 /* This walks a table stored at block 'blkid', returning which block you should
260  * walk next in 'blkid'.  rel_inoblk is where you are given the current level of
261  * indirection tables, and returns where you should be for the next one.  Reach
262  * is how many items the current table's *items* can index (so if we're on a
263  * 3x indir block, reach should be for the doubly-indirect entries, and
264  * rel_inoblk will tell you where within that double block you want).
265  *
266  * This will also alloc intermediate tables if there isn't one already (TODO:
267  * concurrency protection on modifying the table). */
268 static void ext2_walk_inotable(struct inode *inode, uint32_t *blkid,
269                                uint32_t *rel_inoblk, unsigned int reach)
270 {
271         uint32_t *blk_slot;
272         blk_slot = ext2_find_inotable_slot(inode, *blkid, *rel_inoblk, reach);
273         /* We could only do this based on a bool, but if we're trying to walk it,
274          * we ought to want to alloc if there is no block. */
275         ext2_fill_inotable_slot(inode, blk_slot);
276         *blkid = le32_to_cpu(*blk_slot);
277         *rel_inoblk = *rel_inoblk % reach;
278         ext2_put_metablock(inode->i_sb, blk_slot);      /* ref for the one looked in */
279 }
280
281 /* Finds the slot of the FS block corresponding to a specific block number of an
282  * inode.  It does this by walking the inode's tables.  The general idea is that
283  * if the ino_block num is above a threshold, we'll need to go into indirect
284  * tables (1x, 2x, or 3x (triply indirect) tables).  Block numbers start at 0.
285  *
286  * This returns a pointer within a metablock, which needs to be decref'd (and
287  * possibly dirtied) when you are done.  Note, it can return a pointer to
288  * something that is NOT in a metablock (e2ii->i_block[]), but put_metablock can
289  * handle it for now.
290  *
291  * Horrendously untested, btw. */
292 uint32_t *ext2_lookup_inotable_slot(struct inode *inode, uint32_t ino_block)
293 {
294         struct ext2_i_info *e2ii = (struct ext2_i_info*)inode->i_fs_info;
295
296         uint32_t blkid, *blk_slot;
297         /* The 'reach' is how many blocks a given table can 'address' */
298         int ptrs_per_blk = inode->i_sb->s_blocksize / sizeof(uint32_t);
299         int reach_1xblk = ptrs_per_blk;
300         int reach_2xblk = ptrs_per_blk * ptrs_per_blk;
301         /* thresholds are the first blocks that require a level of indirection */
302         int single_threshold = 12;
303         int double_threshold = single_threshold + reach_1xblk;
304         int triple_threshold = double_threshold + reach_2xblk;
305         /* this is the desired block num lookup within a level of indirection.  It
306          * will need to be offset based on what level of lookups we want (try it in
307          * your head with 12 first). */
308         uint32_t rel_inoblk;
309
310         if (ino_block >= triple_threshold) {
311                 /* ino_block requires a triply-indirect lookup */
312                 rel_inoblk = ino_block - triple_threshold;
313                 /* Make sure a 14 block (3x indirect) is there */
314                 ext2_fill_inotable_slot(inode, &e2ii->i_block[14]);
315                 blkid = e2ii->i_block[14];
316                 ext2_walk_inotable(inode, &blkid, &rel_inoblk, reach_2xblk);
317                 ext2_walk_inotable(inode, &blkid, &rel_inoblk, reach_1xblk);
318                 blk_slot = ext2_find_inotable_slot(inode, blkid, rel_inoblk, 1);
319         } else if (ino_block >= double_threshold) {
320                 /* ino_block requires a doubly-indirect lookup  */
321                 rel_inoblk = ino_block - double_threshold;
322                 ext2_fill_inotable_slot(inode, &e2ii->i_block[13]);
323                 blkid = e2ii->i_block[13];
324                 ext2_walk_inotable(inode, &blkid, &rel_inoblk, reach_1xblk);
325                 blk_slot = ext2_find_inotable_slot(inode, blkid, rel_inoblk, 1);
326         } else if (ino_block >= single_threshold) {
327                 /* ino_block requires a singly-indirect lookup */
328                 rel_inoblk = ino_block - single_threshold;
329                 ext2_fill_inotable_slot(inode, &e2ii->i_block[12]);
330                 blkid = e2ii->i_block[12];
331                 blk_slot = ext2_find_inotable_slot(inode, blkid, rel_inoblk, 1);
332         } else {
333                 /* Direct block, straight out of the inode */
334                 blk_slot = &e2ii->i_block[ino_block];
335         }
336         return blk_slot;
337 }
338
339 /* Determines the FS block id for a given inode block id.  Convenience wrapper
340  * that may go away soon. */
341 uint32_t ext2_find_inoblock(struct inode *inode, unsigned int ino_block)
342 {
343         uint32_t retval, *buf = ext2_lookup_inotable_slot(inode, ino_block);
344         retval = *buf;
345         ext2_put_metablock(inode->i_sb, buf);
346         return retval;
347 }
348
349 /* Returns an incref'd metadata block for the contents of the ino block.  Don't
350  * use this for regular files - use their inode's page cache instead (used for
351  * directories for now).  If there isn't a block allocated yet, it will provide
352  * a zeroed one. */
353 void *ext2_get_ino_metablock(struct inode *inode, unsigned long ino_block)
354 {
355         uint32_t blkid, *retval, *blk_slot;
356         blk_slot = ext2_lookup_inotable_slot(inode, ino_block);
357         blkid = le32_to_cpu(*blk_slot);
358         if (blkid) {
359                 ext2_put_metablock(inode->i_sb, blk_slot);
360                 return ext2_get_metablock(inode->i_sb, blkid);
361         }
362         /* If there isn't a block there, alloc and insert one.  This block will be
363          * the next big chunk of "file" data for this inode. */
364         blkid = ext2_alloc_block(inode, ext2_bgidx2block(inode->i_sb,
365                                                          ext2_inode2bg(inode),
366                                                          0));
367         *blk_slot = cpu_to_le32(blkid);
368         ext2_dirty_metablock(inode->i_sb, blk_slot);
369         ext2_put_metablock(inode->i_sb, blk_slot);
370         inode->i_blocks += inode->i_sb->s_blocksize >> 9;       /* inc by 1 FS block */
371         inode->i_size += inode->i_sb->s_blocksize;
372         retval = ext2_get_metablock(inode->i_sb, blkid);
373         memset(retval, 0, inode->i_sb->s_blocksize);            /* 0 the new block */
374         return retval;
375 }
376
377 /* This should help with degubbing.  In read_inode(), print out the i_block, and
378  * consider manually (via memory inspection) examining those blocks.  Odds are,
379  * the 2x and 3x walks are jacked up. */
380 void ext2_print_ino_blocks(struct inode *inode)
381 {
382         printk("Inode %08p, Size: %d, 512B 'blocks': %d\n-------------\n", inode,
383                inode->i_size, inode->i_blocks);
384         for (int i = 0; i < inode->i_blocks * (inode->i_sb->s_blocksize / 512); i++)
385                 printk("# %03d, Block %03d\n", i, ext2_find_inoblock(inode, i));
386 }
387
388 /* Misc Functions */
389
390 /* This checks an ext2 disc SB for consistency, optionally printing out its
391  * stats.  It also will also read in a copy of the block group descriptor table
392  * from its first location (right after the primary SB copy) */
393 void ext2_check_sb(struct ext2_sb *e2sb, struct ext2_block_group *bg,
394                    bool print)
395 {
396         int retval;
397         unsigned int blksize, blks_per_group, num_blk_group, num_blks;
398         unsigned int inodes_per_grp, inode_size;
399         unsigned int sum_blks = 0, sum_inodes = 0;
400
401         assert(le16_to_cpu(e2sb->s_magic) == EXT2_SUPER_MAGIC);
402         num_blks = le32_to_cpu(e2sb->s_blocks_cnt);
403         blksize = 1024 << le32_to_cpu(e2sb->s_log_block_size);
404         blks_per_group = le32_to_cpu(e2sb->s_blocks_per_group);
405         num_blk_group = num_blks / blks_per_group + (num_blks % blks_per_group ? 1 : 0);
406         
407         if (print) {
408                 printk("EXT2 info:\n-------------------------\n");
409                 printk("Total Inodes:     %8d\n", le32_to_cpu(e2sb->s_inodes_cnt));
410                 printk("Total Blocks:     %8d\n", le32_to_cpu(e2sb->s_blocks_cnt));
411                 printk("Num R-Blocks:     %8d\n", le32_to_cpu(e2sb->s_rblocks_cnt));
412                 printk("Num Free Blocks:  %8d\n", le32_to_cpu(e2sb->s_free_blocks_cnt));
413                 printk("Num Free Inodes:  %8d\n", le32_to_cpu(e2sb->s_free_inodes_cnt));
414                 printk("First Data Block: %8d\n",
415                        le32_to_cpu(e2sb->s_first_data_block));
416                 printk("Block Size:       %8d\n",
417                        1024 << le32_to_cpu(e2sb->s_log_block_size));
418                 printk("Fragment Size:    %8d\n",
419                        1024 << le32_to_cpu(e2sb->s_log_frag_size));
420                 printk("Blocks per group: %8d\n",
421                        le32_to_cpu(e2sb->s_blocks_per_group));
422                 printk("Inodes per group: %8d\n",
423                        le32_to_cpu(e2sb->s_inodes_per_group));
424                 printk("Block groups:     %8d\n", num_blk_group);
425                 printk("Mount state:      %8d\n", le16_to_cpu(e2sb->s_state));
426                 printk("Rev Level:        %8d\n", le32_to_cpu(e2sb->s_minor_rev_level));
427                 printk("Minor Rev Level:  %8d\n", le16_to_cpu(e2sb->s_minor_rev_level));
428                 printk("Creator OS:       %8d\n", le32_to_cpu(e2sb->s_creator_os));
429                 printk("First Inode:      %8d\n", le32_to_cpu(e2sb->s_first_ino));
430                 printk("Inode size:       %8d\n", le16_to_cpu(e2sb->s_inode_size));
431                 printk("This block group: %8d\n", le16_to_cpu(e2sb->s_block_group_nr));
432                 printk("BG ID of 1st meta:%8d\n", le16_to_cpu(e2sb->s_first_meta_bg));
433                 printk("Volume name:      %s\n", e2sb->s_volume_name);
434                 printk("\nBlock Group Info:\n----------------------\n");
435         }
436         
437         for (int i = 0; i < num_blk_group; i++) {
438                 sum_blks += le16_to_cpu(bg[i].bg_free_blocks_cnt);
439                 sum_inodes += le16_to_cpu(bg[i].bg_free_inodes_cnt);
440                 if (print) {
441                         printk("*** BG %d at %08p\n", i, &bg[i]);
442                         printk("Block bitmap:%8d\n", le32_to_cpu(bg[i].bg_block_bitmap));
443                         printk("Inode bitmap:%8d\n", le32_to_cpu(bg[i].bg_inode_bitmap));
444                         printk("Inode table: %8d\n", le32_to_cpu(bg[i].bg_inode_table));
445                         printk("Free blocks: %8d\n", le16_to_cpu(bg[i].bg_free_blocks_cnt));
446                         printk("Free inodes: %8d\n", le16_to_cpu(bg[i].bg_free_inodes_cnt));
447                         printk("Used Dirs:   %8d\n", le16_to_cpu(bg[i].bg_used_dirs_cnt));
448                 }
449         }
450         
451         /* Sanity Assertions.  A good ext2 will always pass these. */
452         inodes_per_grp = le32_to_cpu(e2sb->s_inodes_per_group);
453         blks_per_group = le32_to_cpu(e2sb->s_blocks_per_group);
454         inode_size = le32_to_cpu(e2sb->s_inode_size);
455         assert(le32_to_cpu(e2sb->s_inodes_cnt) <= inodes_per_grp * num_blk_group);
456         assert(le32_to_cpu(e2sb->s_free_inodes_cnt) == sum_inodes);
457         assert(le32_to_cpu(e2sb->s_blocks_cnt) <= blks_per_group * num_blk_group);
458         assert(le32_to_cpu(e2sb->s_free_blocks_cnt) == sum_blks);
459         if (blksize == 1024)
460                 assert(le32_to_cpu(e2sb->s_first_data_block) == 1);
461         else
462                 assert(le32_to_cpu(e2sb->s_first_data_block) == 0);
463         assert(inode_size <= blksize);
464         assert(inode_size == 1 << LOG2_UP(inode_size));
465         assert(blksize * 8 >= inodes_per_grp);
466         assert(inodes_per_grp % (blksize / inode_size) == 0);
467         if (print)
468                 printk("Passed EXT2 Checks\n");
469 }
470
471 /* VFS required Misc Functions */
472
473 /* Creates the SB.  Like with Ext2's, we should consider pulling out the
474  * FS-independent stuff, if possible. */
475 struct super_block *ext2_get_sb(struct fs_type *fs, int flags,
476                                char *dev_name, struct vfsmount *vmnt)
477 {
478         struct block_device *bdev;
479         struct ext2_sb *e2sb;
480         struct ext2_block_group *e2bg;
481         unsigned int blks_per_group, num_blk_group, num_blks;
482
483         static bool ran_once = FALSE;
484         if (!ran_once) {
485                 ran_once = TRUE;
486                 ext2_init();
487         }
488         bdev = get_bdev(dev_name);
489         assert(bdev);
490         /* Read the SB.  It's always at byte 1024 and 1024 bytes long.  Note we do
491          * not put the metablock (we pin it off the sb later).  Same with e2bg. */
492         e2sb = (struct ext2_sb*)__ext2_get_metablock(bdev, 1, 1024);
493         if (!(le16_to_cpu(e2sb->s_magic) == EXT2_SUPER_MAGIC)) {
494                 warn("EXT2 Not detected when it was expected!");
495                 return 0;
496         }
497         /* Read in the block group descriptor table.  Which block the BG table is on
498          * depends on the blocksize */
499         unsigned int blksize = 1024 << le32_to_cpu(e2sb->s_log_block_size);
500         e2bg = __ext2_get_metablock(bdev, blksize == 1024 ? 2 : 1, blksize);
501         assert(e2bg);
502         ext2_check_sb(e2sb, e2bg, FALSE);
503
504         /* Now we build and init the VFS SB */
505         struct super_block *sb = get_sb();
506         sb->s_dev = 0;                  /* what do we really want here? */
507         sb->s_blocksize = blksize;
508         /* max file size for a 1024 blocksize FS.  good enough for now (TODO) */
509         sb->s_maxbytes = 17247252480;
510         sb->s_type = &ext2_fs_type;
511         sb->s_op = &ext2_s_op;
512         sb->s_flags = flags;    /* from the disc too?  which flags are these? */
513         sb->s_magic = EXT2_SUPER_MAGIC;
514         sb->s_mount = vmnt;     /* Kref?  also in KFS */
515         sb->s_syncing = FALSE;
516         kref_get(&bdev->b_kref, 1);
517         sb->s_bdev = bdev;
518         strlcpy(sb->s_name, "EXT2", 32);
519         sb->s_fs_info = kmalloc(sizeof(struct ext2_sb_info), 0);
520         assert(sb->s_fs_info);
521         /* store the in-memory copy of the disk SB and bg desc table */
522         ((struct ext2_sb_info*)sb->s_fs_info)->e2sb = e2sb;
523         ((struct ext2_sb_info*)sb->s_fs_info)->e2bg = e2bg;
524         /* Precompute the number of BGs */
525         num_blks = le32_to_cpu(e2sb->s_blocks_cnt);
526         blks_per_group = le32_to_cpu(e2sb->s_blocks_per_group);
527         ((struct ext2_sb_info*)sb->s_fs_info)->nr_bgs = num_blks / blks_per_group +
528                                                (num_blks % blks_per_group ? 1 : 0);
529
530         /* Final stages of initializing the sb, mostly FS-independent */
531         init_sb(sb, vmnt, &ext2_d_op, EXT2_ROOT_INO, 0);
532
533         printk("EXT2 superblock loaded\n");
534         kref_put(&bdev->b_kref);
535         return sb;
536 }
537
538 void ext2_kill_sb(struct super_block *sb)
539 {
540         /* don't forget to kfree the s_fs_info and its two members */
541         panic("Killing an EXT2 SB is not supported!");
542 }
543
544 /* Every FS must have a static FS Type, with which the VFS code can bootstrap */
545 struct fs_type ext2_fs_type = {"EXT2", 0, ext2_get_sb, ext2_kill_sb, {0, 0},
546                                TAILQ_HEAD_INITIALIZER(ext2_fs_type.fs_supers)};
547
548 /* Page Map Operations */
549
550 /* Sets up the bidirectional mapping between the page and its buffer heads.  As
551  * a future optimization, we could try and detect if all of the blocks are
552  * contiguous (either before or after making them) and compact them to one BH.
553  * Note there is an assumption that the file has at least one block in it. */
554 int ext2_mappage(struct page_map *pm, struct page *page)
555 {
556         struct buffer_head *bh;
557         struct inode *inode = (struct inode*)pm->pm_host;
558         assert(!page->pg_private);              /* double check that we aren't bh-mapped */
559         assert(inode->i_mapping == pm); /* double check we are the inode for pm */
560         struct block_device *bdev = inode->i_sb->s_bdev;
561         unsigned int blk_per_pg = PGSIZE / inode->i_sb->s_blocksize;
562         unsigned int sct_per_blk = inode->i_sb->s_blocksize / bdev->b_sector_sz;
563         uint32_t ino_blk_num, fs_blk_num = 0, *fs_blk_slot;
564
565         bh = kmem_cache_alloc(bh_kcache, 0);
566         page->pg_private = bh;
567         for (int i = 0; i < blk_per_pg; i++) {
568                 /* free_bh() can handle having a halfway aborted mappage() */
569                 if (!bh)
570                         return -ENOMEM;
571                 bh->bh_page = page;                                                     /* weak ref */
572                 bh->bh_buffer = page2kva(page) + i * inode->i_sb->s_blocksize;
573                 bh->bh_flags = 0;                                                       /* whatever... */
574                 bh->bh_bdev = bdev;                                                     /* uncounted ref */
575                 /* compute the first sector of the FS block for the ith buf in the pg */
576                 ino_blk_num = page->pg_index * blk_per_pg + i;
577                 fs_blk_slot = ext2_lookup_inotable_slot(inode, ino_blk_num);
578                 /* If there isn't a block there, lets get one.  The previous fs_blk_num
579                  * is our hint (or we have to compute one). */
580                 if (!*fs_blk_slot) {
581                         if (!fs_blk_num) {
582                                 fs_blk_num = ext2_bgidx2block(inode->i_sb,
583                                                               ext2_inode2bg(inode), 0);
584                         }
585                         fs_blk_num = ext2_alloc_block(inode, fs_blk_num + 1);
586                         /* Link it, and dirty the inode indirect block */
587                         *fs_blk_slot = cpu_to_le32(fs_blk_num);
588                         ext2_dirty_metablock(inode->i_sb, fs_blk_slot);
589                         /* the block is still on disk, and we don't want its contents */
590                         bh->bh_flags = BH_NEEDS_ZEROED;                 /* talking to readpage */
591                         /* update our num blocks, with 512B each "block" (ext2-style) */
592                         inode->i_blocks += inode->i_sb->s_blocksize >> 9;
593                 } else {        /* there is a block there already */
594                         fs_blk_num = *fs_blk_slot;
595                 }
596                 ext2_put_metablock(inode->i_sb, fs_blk_slot);
597                 bh->bh_sector = fs_blk_num * sct_per_blk;
598                 bh->bh_nr_sector = sct_per_blk;
599                 /* Stop if we're the last block in the page.  We could be going beyond
600                  * the end of the file, in which case the next BHs will be zeroed. */
601                 if (i == blk_per_pg - 1) {
602                         bh->bh_next = 0;
603                         break;
604                 } else {
605                         /* get and link to the next BH. */
606                         bh->bh_next = kmem_cache_alloc(bh_kcache, 0);
607                         bh = bh->bh_next;
608                 }
609         }
610         return 0;
611 }
612
613 /* Fills page with its contents from its backing store file.  Note that we do
614  * the zero padding here, instead of higher in the VFS.  Might change in the
615  * future.  TODO: make this a block FS generic call. */
616 int ext2_readpage(struct page_map *pm, struct page *page)
617 {
618         int retval;
619         struct block_device *bdev = pm->pm_host->i_sb->s_bdev;
620         struct buffer_head *bh;
621         struct block_request *breq;
622         void *eobh;
623
624         assert(page->pg_flags & PG_BUFFER);
625         retval = ext2_mappage(pm, page);
626         if (retval) {
627                 unlock_page(page);
628                 return retval;
629         }
630         /* Build and submit the request */
631         breq = kmem_cache_alloc(breq_kcache, 0);
632         if (!breq) {
633                 unlock_page(page);
634                 return -ENOMEM;
635         }
636         breq->flags = BREQ_READ;
637         breq->bhs = breq->local_bhs;
638         breq->nr_bhs = 0;
639         /* Pack the BH pointers in the block request */
640         bh = (struct buffer_head*)page->pg_private;
641         assert(bh);
642         /* Either read the block in, or zero the buffer.  If we wanted to ensure no
643          * data is leaked after a crash, we'd write a 0 block too. */
644         for (int i = 0; bh; bh = bh->bh_next) {
645                 if (!(bh->bh_flags & BH_NEEDS_ZEROED)) {
646                         breq->bhs[i] = bh;
647                         breq->nr_bhs++;
648                         i++;
649                 } else {
650                         memset(bh->bh_buffer, 0, pm->pm_host->i_sb->s_blocksize);
651                         bh->bh_flags |= BH_DIRTY;
652                         bh->bh_page->pg_flags |= PG_DIRTY;
653                 }
654         }
655         /* TODO: (BLK) this assumes we slept til the request was done */
656         retval = make_request(bdev, breq);
657         assert(!retval);
658         /* zero out whatever is beyond the EOF.  we could do this by figuring out
659          * where the BHs end and zeroing from there, but I'd rather zero from where
660          * the file ends (which could be in the middle of an FS block */
661         uintptr_t eof_off;
662         eof_off = (pm->pm_host->i_size - page->pg_index * PGSIZE);
663         eof_off = MIN(eof_off, PGSIZE) % PGSIZE;
664         /* at this point, eof_off is the offset into the page of the EOF, or 0 */
665         if (eof_off)
666                 memset(eof_off + page2kva(page), 0, PGSIZE - eof_off);
667         /* after the data is read, we mark it up to date and unlock the page. */
668         page->pg_flags |= PG_UPTODATE;
669         unlock_page(page);
670         kmem_cache_free(breq_kcache, breq);
671         /* Useful debugging.  Put one higher up if the page is not getting mapped */
672         //print_pageinfo(page);
673         return 0;
674 }
675
676 /* Super Operations */
677
678 /* Creates and initializes a new inode.  FS specific, yet inode-generic fields
679  * are filled in.  inode-specific fields are filled in in read_inode() based on
680  * what's on the disk for a given i_no.  i_no and i_fop are set by the caller.
681  *
682  * Note that this means this inode can be for an inode that is already on disk,
683  * or it can be used when creating.  The i_fop depends on the type of file
684  * (file, directory, symlink, etc). */
685 struct inode *ext2_alloc_inode(struct super_block *sb)
686 {
687         struct inode *inode = kmem_cache_alloc(inode_kcache, 0);
688         memset(inode, 0, sizeof(struct inode));
689         inode->i_op = &ext2_i_op;
690         inode->i_pm.pm_op = &ext2_pm_op;
691         return inode;
692 }
693
694 /* FS-specific clean up when an inode is dealloced.  this is just cleaning up
695  * the in-memory version, and only the FS-specific parts.  whether or not the
696  * inode is still on disc is irrelevant. */
697 void ext2_dealloc_inode(struct inode *inode)
698 {
699         kmem_cache_free(ext2_i_kcache, inode->i_fs_info);
700 }
701
702 /* reads the inode data on disk specified by inode->i_ino into the inode.
703  * basically, it's a "make this inode the one for i_ino (i number)" */
704 void ext2_read_inode(struct inode *inode)
705 {
706         unsigned int bg_idx, ino_per_blk, my_ino_blk;
707         struct ext2_sb_info *e2sbi = (struct ext2_sb_info*)inode->i_sb->s_fs_info;
708         struct ext2_block_group *my_bg;
709         struct ext2_inode *ino_tbl_chunk, *my_ino;
710
711         /* Need to compute the blockgroup and index of the requested inode */
712         ino_per_blk = inode->i_sb->s_blocksize /
713                       le16_to_cpu(e2sbi->e2sb->s_inode_size);
714         bg_idx = ext2_inode2bgidx(inode);
715         my_bg = ext2_inode2bg(inode);
716         /* Figure out which FS block of the inode table we want and read in that
717          * chunk */
718         my_ino_blk = le32_to_cpu(my_bg->bg_inode_table) + bg_idx / ino_per_blk;
719         ino_tbl_chunk = ext2_get_metablock(inode->i_sb, my_ino_blk);
720         my_ino = &ino_tbl_chunk[bg_idx % ino_per_blk];
721
722         /* Have the disk inode now, let's put its info into the VFS inode: */
723         inode->i_mode = le16_to_cpu(my_ino->i_mode);
724         switch (inode->i_mode & __S_IFMT) {
725                 case (__S_IFDIR):
726                         inode->i_fop = &ext2_f_op_dir;
727                         break;
728                 case (__S_IFREG):
729                         inode->i_fop = &ext2_f_op_file;
730                         break;
731                 case (__S_IFLNK):
732                         inode->i_fop = &ext2_f_op_sym;
733                         break;
734                 case (__S_IFCHR):
735                 case (__S_IFBLK):
736                 default:
737                         inode->i_fop = &ext2_f_op_file;
738                         warn("[Calm British Accent] Look around you.  Unhandled filetype.");
739         }
740         inode->i_nlink = le16_to_cpu(my_ino->i_links_cnt);
741         inode->i_uid = le16_to_cpu(my_ino->i_uid);
742         inode->i_gid = le16_to_cpu(my_ino->i_gid);
743         /* technically, for large F_REG, we should | with i_dir_acl */
744         inode->i_size = le32_to_cpu(my_ino->i_size);
745         inode->i_atime.tv_sec = le32_to_cpu(my_ino->i_atime);
746         inode->i_atime.tv_nsec = 0;
747         inode->i_mtime.tv_sec = le32_to_cpu(my_ino->i_mtime);
748         inode->i_mtime.tv_nsec = 0;
749         inode->i_ctime.tv_sec = le32_to_cpu(my_ino->i_ctime);
750         inode->i_ctime.tv_nsec = 0;
751         inode->i_blocks = le32_to_cpu(my_ino->i_blocks);
752         inode->i_flags = le32_to_cpu(my_ino->i_flags);
753         inode->i_socket = FALSE;                /* for now */
754         /* Copy over the other inode stuff that isn't in the VFS inode.  For now,
755          * it's just the block pointers */
756         inode->i_fs_info = kmem_cache_alloc(ext2_i_kcache, 0);
757         struct ext2_i_info *e2ii = (struct ext2_i_info*)inode->i_fs_info;
758         for (int i = 0; i < 15; i++)
759                 e2ii->i_block[i] = le32_to_cpu(my_ino->i_block[i]);
760         /* TODO: (HASH) unused: inode->i_hash add to hash (saves on disc reading) */
761         /* TODO: we could consider saving a pointer to the disk inode and pinning
762          * its buffer in memory, but for now we'll just free it. */
763         ext2_put_metablock(inode->i_sb, ino_tbl_chunk);
764 }
765
766 /* called when an inode in memory is modified (journalling FS's care) */
767 void ext2_dirty_inode(struct inode *inode)
768 {
769         // presumably we'll ext2_dirty_metablock(void *buffer) here
770 }
771
772 /* write the inode to disk (specifically, to inode inode->i_ino), synchronously
773  * if we're asked to wait */
774 void ext2_write_inode(struct inode *inode, bool wait)
775 {
776 I_AM_HERE;
777 }
778
779 /* called when an inode is decref'd, to do any FS specific work */
780 void ext2_put_inode(struct inode *inode)
781 {
782 I_AM_HERE;
783 }
784
785 /* Unused for now, will get rid of this if inode_release is sufficient */
786 void ext2_drop_inode(struct inode *inode)
787 {
788 I_AM_HERE;
789 }
790
791 /* delete the inode from disk (all data) */
792 void ext2_delete_inode(struct inode *inode)
793 {
794 I_AM_HERE;
795         // would remove from "disk" here
796         /* TODO: give up our i_ino */
797 }
798
799 /* unmount and release the super block */
800 void ext2_put_super(struct super_block *sb)
801 {
802         panic("Shazbot! Ext2 can't be unmounted yet!");
803 }
804
805 /* updates the on-disk SB with the in-memory SB */
806 void ext2_write_super(struct super_block *sb)
807 {
808 I_AM_HERE;
809 }
810
811 /* syncs FS metadata with the disc, synchronously if we're waiting.  this info
812  * also includes anything pointed to by s_fs_info. */
813 int ext2_sync_fs(struct super_block *sb, bool wait)
814 {
815 I_AM_HERE;
816         return 0;
817 }
818
819 /* remount the FS with the new flags */
820 int ext2_remount_fs(struct super_block *sb, int flags, char *data)
821 {
822         warn("Ext2 will not remount.");
823         return -1; // can't remount
824 }
825
826 /* interrupts a mount operation - used by NFS and friends */
827 void ext2_umount_begin(struct super_block *sb)
828 {
829         panic("Cannot abort a Ext2 mount, and why would you?");
830 }
831
832 /* inode_operations */
833
834 /* Little helper, used for initializing new inodes for file-like objects (files,
835  * symlinks, etc).  We pass the dentry, since we need to up it. */
836 static void ext2_init_inode(struct inode *dir, struct dentry *dentry)
837 {
838 #if 0
839         struct inode *inode = dentry->d_inode;
840         inode->i_ino = ext2_get_free_ino();
841 #endif
842 }
843
844 /* Called when creating a new disk inode in dir associated with dentry.  We need
845  * to fill out the i_ino, set the type, and do whatever else we need */
846 int ext2_create(struct inode *dir, struct dentry *dentry, int mode,
847                struct nameidata *nd)
848 {
849 I_AM_HERE;
850         #if 0
851         struct inode *inode = dentry->d_inode;
852         ext2_init_inode(dir, dentry);
853         SET_FTYPE(inode->i_mode, __S_IFREG);
854         inode->i_fop = &ext2_f_op_file;
855         /* fs_info->filestart is set by the caller, or else when first written (for
856          * new files.  it was set to 0 in alloc_inode(). */
857         #endif
858         return 0;
859 }
860
861 /* Searches the directory for the filename in the dentry, filling in the dentry
862  * with the FS specific info of this file.  If it succeeds, it will pass back
863  * the *dentry you should use (which might be the same as the one you passed in).
864  * If this fails, it will return 0, but not free the memory of "dentry."
865  *
866  * Callers, make sure you alloc and fill out the name parts of the dentry.  We
867  * don't currently use the ND.  Might remove it in the future.  */
868 struct dentry *ext2_lookup(struct inode *dir, struct dentry *dentry,
869                            struct nameidata *nd)
870 {
871         assert(S_ISDIR(dir->i_mode));
872         struct ext2_dirent *dir_buf, *dir_i;
873         unsigned int dir_block = 0;
874         bool found = FALSE;
875         dir_buf = ext2_get_ino_metablock(dir, dir_block++);
876         dir_i = dir_buf;
877         /* now we have the first block worth of dirents.  We'll get another block if
878          * dir_i hits a block boundary */
879         for (unsigned int bytes = 0; bytes < dir->i_size; ) {
880                 /* On subsequent loops, we might need to advance to the next block.
881                  * This is where a file abstraction for a dir might be easier. */
882                 if ((void*)dir_i >= (void*)dir_buf + dir->i_sb->s_blocksize) {
883                         ext2_put_metablock(dir->i_sb, dir_buf);
884                         dir_buf = ext2_get_ino_metablock(dir, dir_block++);
885                         dir_i = dir_buf;
886                         assert(dir_buf);
887                 }
888                 /* Test if we're the one (TODO: use d_compare).  Note, dir_name is not
889                  * null terminated, hence the && test. */
890                 if (!strncmp((char*)dir_i->dir_name, dentry->d_name.name,
891                              dir_i->dir_namelen) &&
892                             (dentry->d_name.name[dir_i->dir_namelen] == '\0')) {
893                         load_inode(dentry, le32_to_cpu(dir_i->dir_inode));
894                         /* TODO: (HASH) add dentry to dcache (maybe the caller should) */
895                         ext2_put_metablock(dir->i_sb, dir_buf);
896                         return dentry;
897                 }
898                 /* Get ready for the next loop */
899                 bytes += dir_i->dir_reclen;
900                 dir_i = (void*)dir_i + dir_i->dir_reclen;
901         }
902         printd("EXT2: Not Found, %s\n", dentry->d_name.name);   
903         ext2_put_metablock(dir->i_sb, dir_buf);
904         return 0;
905 }
906
907 /* Hard link to old_dentry in directory dir with a name specified by new_dentry.
908  * At the very least, set the new_dentry's FS-specific fields. */
909 int ext2_link(struct dentry *old_dentry, struct inode *dir,
910              struct dentry *new_dentry)
911 {
912 I_AM_HERE;
913         assert(new_dentry->d_op = &ext2_d_op);
914         return 0;
915 }
916
917 /* Removes the link from the dentry in the directory */
918 int ext2_unlink(struct inode *dir, struct dentry *dentry)
919 {
920 I_AM_HERE;
921         return 0;
922 }
923
924 /* Creates a new inode for a symlink dir, linking to / containing the name
925  * symname.  dentry is the controlling dentry of the inode. */
926 int ext2_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
927 {
928 I_AM_HERE;
929         #if 0
930         struct inode *inode = dentry->d_inode;
931         SET_FTYPE(inode->i_mode, __S_IFLNK);
932         inode->i_fop = &ext2_f_op_sym;
933         strncpy(string, symname, len);
934         string[len] = '\0';             /* symname should be \0d anyway, but just in case */
935         #endif
936         return 0;
937 }
938
939 /* Called when creating a new inode for a directory associated with dentry in
940  * dir with the given mode.  Note, we might (later) need to track subdirs within
941  * the parent inode, like we do with regular files.  I'd rather not, so we'll
942  * see if we need it. */
943 int ext2_mkdir(struct inode *dir, struct dentry *dentry, int mode)
944 {
945 I_AM_HERE;
946         #if 0
947         struct inode *inode = dentry->d_inode;
948         inode->i_ino = ext2_get_free_ino();
949         SET_FTYPE(inode->i_mode, __S_IFDIR);
950         inode->i_fop = &ext2_f_op_dir;
951         #endif
952         return 0;
953 }
954
955 /* Removes from dir the directory 'dentry.'  Ext2 doesn't store anything in the
956  * inode for which children it has.  It probably should, but since everything is
957  * pinned, it just relies on the dentry connections. */
958 int ext2_rmdir(struct inode *dir, struct dentry *dentry)
959 {
960 I_AM_HERE;
961         return 0;
962 }
963
964 /* Used to make a generic file, based on the type and the major/minor numbers
965  * (in rdev), with the given mode.  As with others, this creates a new disk
966  * inode for the file */
967 int ext2_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev)
968 {
969 I_AM_HERE;
970         return -1;
971 }
972
973 /* Moves old_dentry from old_dir to new_dentry in new_dir */
974 int ext2_rename(struct inode *old_dir, struct dentry *old_dentry,
975                struct inode *new_dir, struct dentry *new_dentry)
976 {
977 I_AM_HERE;
978         return -1;
979 }
980
981 /* Returns the char* for the symname for the given dentry.  The VFS code that
982  * calls this for real FS's might assume it's already read in, so if the char *
983  * isn't already in memory, we'd need to read it in here.  Regarding the char*
984  * storage, the char* only will last as long as the dentry and inode are in
985  * memory. */
986 char *ext2_readlink(struct dentry *dentry)
987 {
988 I_AM_HERE;
989         struct inode *inode = dentry->d_inode;
990         if (!S_ISLNK(inode->i_mode))
991                 return 0;
992         return 0;
993 }
994
995 /* Modifies the size of the file of inode to whatever its i_size is set to */
996 void ext2_truncate(struct inode *inode)
997 {
998 }
999
1000 /* Checks whether the the access mode is allowed for the file belonging to the
1001  * inode.  Implies that the permissions are on the file, and not the hardlink */
1002 int ext2_permission(struct inode *inode, int mode, struct nameidata *nd)
1003 {
1004         return -1;
1005 }
1006
1007
1008 /* dentry_operations */
1009 /* Determines if the dentry is still valid before using it to translate a path.
1010  * Network FS's need to deal with this. */
1011 int ext2_d_revalidate(struct dentry *dir, struct nameidata *nd)
1012 { // default, nothing
1013         return -1;
1014 }
1015
1016 /* Produces the hash to lookup this dentry from the dcache */
1017 int ext2_d_hash(struct dentry *dentry, struct qstr *name)
1018 {
1019         return -1;
1020 }
1021
1022 /* Compares name1 and name2.  name1 should be a member of dir. */
1023 int ext2_d_compare(struct dentry *dir, struct qstr *name1, struct qstr *name2)
1024 { // default, string comp (case sensitive)
1025         return -1;
1026 }
1027
1028 /* Called when the last ref is deleted (refcnt == 0) */
1029 int ext2_d_delete(struct dentry *dentry)
1030 { // default, nothin
1031         return -1;
1032 }
1033
1034 /* Called when it's about to be slab-freed */
1035 int ext2_d_release(struct dentry *dentry)
1036 {
1037         return -1;
1038 }
1039
1040 /* Called when the dentry loses it's inode (becomes "negative") */
1041 void ext2_d_iput(struct dentry *dentry, struct inode *inode)
1042 { // default, call i_put to release the inode object
1043 }
1044
1045
1046 /* file_operations */
1047
1048 /* Updates the file pointer.  TODO: think about locking, and putting this in the
1049  * VFS. */
1050 #include <syscall.h>    /* just for set_errno, may go away later */
1051 off_t ext2_llseek(struct file *file, off_t offset, int whence)
1052 {
1053         off_t temp_off = 0;
1054         switch (whence) {
1055                 case SEEK_SET:
1056                         temp_off = offset;
1057                         break;
1058                 case SEEK_CUR:
1059                         temp_off = file->f_pos + offset;
1060                         break;
1061                 case SEEK_END:
1062                         temp_off = file->f_dentry->d_inode->i_size + offset;
1063                         break;
1064                 default:
1065                         set_errno(EINVAL);
1066                         warn("Unknown 'whence' in llseek()!\n");
1067                         return -1;
1068         }
1069         file->f_pos = temp_off;
1070         return temp_off;
1071 }
1072
1073 /* Fills in the next directory entry (dirent), starting with d_off.  Like with
1074  * read and write, there will be issues with userspace and the *dirent buf.
1075  * TODO: (UMEM) */
1076 int ext2_readdir(struct file *dir, struct dirent *dirent)
1077 {
1078         void *blk_buf;
1079         /* Not enough data at the end of the directory */
1080         if (dir->f_dentry->d_inode->i_size < dirent->d_off + 8)
1081                 return -ENOENT;
1082         /* Figure out which block we need to read in for dirent->d_off */
1083         int block = dirent->d_off / dir->f_dentry->d_sb->s_blocksize;
1084         blk_buf = ext2_get_ino_metablock(dir->f_dentry->d_inode, block);
1085         assert(blk_buf);
1086         off_t f_off = dirent->d_off % dir->f_dentry->d_sb->s_blocksize;
1087         /* Copy out the dirent info */
1088         struct ext2_dirent *e2dir = (struct ext2_dirent*)(blk_buf + f_off);
1089         dirent->d_ino = le32_to_cpu(e2dir->dir_inode);
1090         dirent->d_off += le16_to_cpu(e2dir->dir_reclen);
1091         if (dir->f_dentry->d_inode->i_size < dirent->d_off)
1092                 panic("Something is jacked with the dirent going beyond the dir/file");
1093         /* note, dir_namelen doesn't include the \0 */
1094         dirent->d_reclen = e2dir->dir_namelen;
1095         strncpy(dirent->d_name, (char*)e2dir->dir_name, e2dir->dir_namelen);
1096         assert(e2dir->dir_namelen <= MAX_FILENAME_SZ);
1097         dirent->d_name[e2dir->dir_namelen] = '\0';
1098         ext2_put_metablock(dir->f_dentry->d_sb, blk_buf);
1099         
1100         /* At the end of the directory, sort of.  ext2 often preallocates blocks, so
1101          * this will cause us to walk along til the end, which isn't quite right. */
1102         if (dir->f_dentry->d_inode->i_size == dirent->d_off)
1103                 return 0;
1104         if (dir->f_dentry->d_inode->i_size < dirent->d_off) {
1105                 warn("Issues reaching the end of an ext2 directory!");
1106                 return 0;
1107         }
1108         return 1;                                                       /* normal success for readdir */
1109 }
1110
1111 /* This is called when a VMR is mapping a particular file.  The FS needs to do
1112  * whatever it needs so that faults can be handled by read_page(), and handle all
1113  * of the cases of MAP_SHARED, MAP_PRIVATE, whatever.  It also needs to ensure
1114  * the file is not being mmaped in a way that conflicts with the manner in which
1115  * the file was opened or the file type. */
1116 int ext2_mmap(struct file *file, struct vm_region *vmr)
1117 {
1118         if (S_ISREG(file->f_dentry->d_inode->i_mode))
1119                 return 0;
1120         return -1;
1121 }
1122
1123 /* Called by the VFS while opening the file, which corresponds to inode,  for
1124  * the FS to do whatever it needs. */
1125 int ext2_open(struct inode *inode, struct file *file)
1126 {
1127         /* TODO: check to make sure the file is openable, and maybe do some checks
1128          * for the open mode (like did we want to truncate, append, etc) */
1129         return 0;
1130 }
1131
1132 /* Called when a file descriptor is closed. */
1133 int ext2_flush(struct file *file)
1134 {
1135 I_AM_HERE;
1136         return -1;
1137 }
1138
1139 /* Called when the file is about to be closed (file obj freed) */
1140 int ext2_release(struct inode *inode, struct file *file)
1141 {
1142         return 0;
1143 }
1144
1145 /* Flushes the file's dirty contents to disc */
1146 int ext2_fsync(struct file *file, struct dentry *dentry, int datasync)
1147 {
1148         return -1;
1149 }
1150
1151 /* Traditionally, sleeps until there is file activity.  We probably won't
1152  * support this, or we'll handle it differently. */
1153 unsigned int ext2_poll(struct file *file, struct poll_table_struct *poll_table)
1154 {
1155         return -1;
1156 }
1157
1158 /* Reads count bytes from a file, starting from (and modifiying) offset, and
1159  * putting the bytes into buffers described by vector */
1160 ssize_t ext2_readv(struct file *file, const struct iovec *vector,
1161                   unsigned long count, off_t *offset)
1162 {
1163         return -1;
1164 }
1165
1166 /* Writes count bytes to a file, starting from (and modifiying) offset, and
1167  * taking the bytes from buffers described by vector */
1168 ssize_t ext2_writev(struct file *file, const struct iovec *vector,
1169                   unsigned long count, off_t *offset)
1170 {
1171         return -1;
1172 }
1173
1174 /* Write the contents of file to the page.  Will sort the params later */
1175 ssize_t ext2_sendpage(struct file *file, struct page *page, int offset,
1176                      size_t size, off_t pos, int more)
1177 {
1178         return -1;
1179 }
1180
1181 /* Checks random FS flags.  Used by NFS. */
1182 int ext2_check_flags(int flags)
1183 { // default, nothing
1184         return -1;
1185 }
1186
1187 /* Redeclaration and initialization of the FS ops structures */
1188 struct page_map_operations ext2_pm_op = {
1189         ext2_readpage,
1190 };
1191
1192 struct super_operations ext2_s_op = {
1193         ext2_alloc_inode,
1194         ext2_dealloc_inode,
1195         ext2_read_inode,
1196         ext2_dirty_inode,
1197         ext2_write_inode,
1198         ext2_put_inode,
1199         ext2_drop_inode,
1200         ext2_delete_inode,
1201         ext2_put_super,
1202         ext2_write_super,
1203         ext2_sync_fs,
1204         ext2_remount_fs,
1205         ext2_umount_begin,
1206 };
1207
1208 struct inode_operations ext2_i_op = {
1209         ext2_create,
1210         ext2_lookup,
1211         ext2_link,
1212         ext2_unlink,
1213         ext2_symlink,
1214         ext2_mkdir,
1215         ext2_rmdir,
1216         ext2_mknod,
1217         ext2_rename,
1218         ext2_readlink,
1219         ext2_truncate,
1220         ext2_permission,
1221 };
1222
1223 struct dentry_operations ext2_d_op = {
1224         ext2_d_revalidate,
1225         ext2_d_hash,
1226         ext2_d_compare,
1227         ext2_d_delete,
1228         ext2_d_release,
1229         ext2_d_iput,
1230 };
1231
1232 struct file_operations ext2_f_op_file = {
1233         ext2_llseek,
1234         generic_file_read,
1235         generic_file_write,
1236         ext2_readdir,
1237         ext2_mmap,
1238         ext2_open,
1239         ext2_flush,
1240         ext2_release,
1241         ext2_fsync,
1242         ext2_poll,
1243         ext2_readv,
1244         ext2_writev,
1245         ext2_sendpage,
1246         ext2_check_flags,
1247 };
1248
1249 struct file_operations ext2_f_op_dir = {
1250         ext2_llseek,
1251         generic_dir_read,
1252         0,
1253         ext2_readdir,
1254         ext2_mmap,
1255         ext2_open,
1256         ext2_flush,
1257         ext2_release,
1258         ext2_fsync,
1259         ext2_poll,
1260         ext2_readv,
1261         ext2_writev,
1262         ext2_sendpage,
1263         ext2_check_flags,
1264 };
1265
1266 struct file_operations ext2_f_op_sym = {
1267         ext2_llseek,
1268         generic_file_read,
1269         generic_file_write,
1270         ext2_readdir,
1271         ext2_mmap,
1272         ext2_open,
1273         ext2_flush,
1274         ext2_release,
1275         ext2_fsync,
1276         ext2_poll,
1277         ext2_readv,
1278         ext2_writev,
1279         ext2_sendpage,
1280         ext2_check_flags,
1281 };