fs/ext2/ram_mke2fs.c

   1 /**
   2  * thunix/fs/ramfs/ram_mke2fs.c
   3  *
   4  * make an ext2 ram fs
   5  * yeah, it's far-fetched, all the things done here
   6  * are by ourself, all the things here are static.
   7  *
   8  * but, it just a TEST for ext2_file system,
   9  * and that's enough.
  10  *
  11  * Copyright (c) 2008 - 2009 by Aleaxander
  12  *
  13  *           Aleaxander@gmail.com
  14  *
  15  */
  16
  17 #include <fs_ext2.h>
  18 #include <thunix.h>
  19 #include <rd.h>
  20 #include <string.h>
  21
  22
  23 void ram_ext2_init_super_block()
  24 {
  25         struct ext2_super_block *sb;
  26
  27         sb = (struct ext2_super_block *) (ram_start + EXT2_BLOCK_SIZE);
  28
  29
  30         /* just init. some nessesary filed */
  31         sb->s_inodes_count = 184;
  32         sb->s_blocks_count = 1440;
  33         sb->s_r_blocks_count = 72;
  34         sb->s_free_blocks_count = 1393;
  35         sb->s_free_inodes_count = 173;
  36         sb->s_first_data_block = 1;
  37         sb->s_log_block_size = 0;
  38         sb->s_log_frag_size = 0;
  39         sb->s_blocks_per_group = 8192;
  40         sb->s_frags_per_group = 8192;
  41         sb->s_inodes_per_group = 184;
  42
  43         sb->s_magic = 0x0ef53;
  44 }
  45
  46
  47 void ram_ext2_init_group_desc()
  48 {
  49         struct ext2_group_desc *desc;
  50
  51         desc = (struct ext2_group_desc *)(ram_start + EXT2_BLOCK_SIZE * 2);
  52
  53         desc->bg_block_bitmap = 8;
  54         desc->bg_inode_bitmap = 9;
  55         desc->bg_inode_table = 10;
  56         desc->bg_free_blocks_count = 1393;
  57         desc->bg_free_inodes_count = 173;
  58         desc->bg_used_dirs_count = 2;
  59
  60         /* we just make it to be so, but in fact ,
  61          * i think this are be done by ext_mkdir,
  62          * ext2_alloc_block or something of that
  63          * sort.
  64          *
  65          * we just do it for test.
  66          */
  67 }
  68
  69
  70 void ram_ext2_init_bitmap()
  71 {/*
  72    struct ext2_group_desc *desc;
  73    desc = ext2_get_group(0);
  74  */
  75         unsigned long *block_bitmap;
  76         unsigned char *inode_bitmap;
  77
  78         block_bitmap = (unsigned long *)(ram_start + EXT2_BLOCK_SIZE * 8);
  79         inode_bitmap = (unsigned char* )(ram_start + EXT2_BLOCK_SIZE * 9);
  80
  81         *block_bitmap = 0xffffffff;
  82         *(++block_bitmap) = 0x3fff;
  83
  84         *inode_bitmap = 0xff;
  85         *(++inode_bitmap) = 0xf0;
  86 }
  87
  88
  89 void ram_ext2_init_root_inode()
  90 {
  91         struct ext2_inode *root_inode;
  92         unsigned long inode_table;
  93
  94         inode_table = ram_start + EXT2_BLOCK_SIZE * 10;
  95
  96         root_inode = (struct ext2_inode *)inode_table + (ROOT_INODE - 1) ;
  97         memset(root_inode, 0, sizeof (struct ext2_inode));
  98
  99         root_inode->i_size = 0x400;  /* 1K */
 100         root_inode->i_links_count = 3;
 101         root_inode->i_blocks = 2;
 102         root_inode->i_block[0] = 33;
 103
 104
 105
 106 }
 107
 108
 109 void ram_ext2fs_init()
 110 {
 111         EXT2_DEBUG();
 112
 113         ram_ext2_init_super_block();
 114         ram_ext2_init_group_desc();
 115         ram_ext2_init_bitmap();
 116         ram_ext2_init_root_inode();
 117
 118
 119 }
 120
 121 struct m_inode * ram_ext2_get_root_inode()
 122 {
 123         struct ext2_inode *root_inode;
 124         unsigned long inode_table;
 125
 126         inode_table = ram_start + EXT2_BLOCK_SIZE * 10;
 127
 128         root_inode = (struct ext2_inode *)inode_table + (ROOT_INODE - 1) ;
 129
 130         return (struct m_inode*)root_inode;
 131 }
 132
 133 void ram_mke2fs()
 134 {
 135         int block;
 136         void * block_buffer;
 137
 138         struct m_inode *root_inode;
 139         struct ext2_dir_entry root = {2,12,1,2,"."};
 140         struct ext2_dir_entry root_dot_dot = {2,12,2,2,".."};
 141         struct ext2_dir_entry lost = {11,20,10,2,"lost+found"};
 142
 143         EXT2_DEBUG();
 144
 145         root_inode = ram_ext2_get_root_inode ();
 146
 147         block = root_inode->inode.i_block[0];
 148         block_buffer = (void *)(ram_start + EXT2_BLOCK_SIZE * block);
 149
 150         memcpy(block_buffer, &root, EXT2_DIR_REC_LEN(1));
 151         block_buffer += EXT2_DIR_REC_LEN(1);
 152
 153         memcpy(block_buffer, &root_dot_dot, EXT2_DIR_REC_LEN(1));
 154         block_buffer += EXT2_DIR_REC_LEN(2);
 155
 156         memcpy(block_buffer, &lost, EXT2_DIR_REC_LEN(10));
 157
 158 }