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