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