Chinaunix首页 | 论坛 | 博客

wangcong02345wangcong02345.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

wangcong02345

  • 博客访问： 2112699
  • 博文数量： 438
  • 博客积分： 3871
  • 博客等级： 中校
  • 技术积分： 6075
  • 用 户 组： 普通用户
  • 注册时间： 2011-09-10 00:11
个人简介

邮箱: wangcong02345@163.com

文章分类

全部博文（438）

文章存档

2017年（15）

2016年（119）

2015年（91）

2014年（62）

2013年（56）

2012年（79）

2011年（16）

我的朋友
最近访客
推荐博文
相关博文
linux0.12--4.创建并访问linux0.12的文件系统

分类： LINUX

2016-09-12 16:37:23

1. mkfs.c
1.1 说明
a. linux 0.12使用的是minix的文件系统，现在发行版的ubuntu中没有这个工具
b. 在 里面有mkfs.c下载
c. 但是直接下载后不能直接编译，我作了一点点修改，使mkfs.c可以在Ubuntu 14.04.2 LTS 64位下编译运行
1.2 mkfs.c
  1. /*
  2.  * mkfs.c - make a linux (minix) file-system.
  3.  *
  4.  * (C) 1991 Linus Torvalds. This file may be redistributed as per
  5.  * the Linux copyright.
  6.  */

  8. /*
  9.  * 24.11.91 -    time began. Used the fsck sources to get started.
  10.  *
  11.  * 25.11.91 -    corrected some bugs. Added support for ".badblocks"
  12.  *        The algorithm for ".badblocks" is a bit weird, but
  13.  *        it should work. Oh, well.
  14.  *
  15.  * Usuage: mkfs [-c] device size-in-blocks
  16.  *
  17.  *    -c for readablility checking (
  18.  *
  19.  * The device may be a block device or a image of one, but this isn't
  20.  * enforced (but it's not much fun on a character device :-).
  21.  */

  23. #include <stdio.h>
  24. #include <unistd.h>
  25. #include <string.h>
  26. #include <fcntl.h>
  27. #include <ctype.h>
  28. #include <stdlib.h>
  29. #include <termios.h>
  30. #include <sys/stat.h>

  32. //#include "mkfs.h"
  33. #include "fs.h"

  35. #ifndef __GNUC__
  36. #error "needs gcc for the bitop-__asm__'s"
  37. #endif

  39. #ifndef __linux__
  40. #define volatile
  41. #endif

  43. #define ROOT_INO 1
  44. #define BAD_INO 2

  46. #define TEST_BUFFER_BLOCKS 32
  47. #define MAX_GOOD_BLOCKS 512

  49. #define UPPER(size,n) ((size+((n)-1))/(n))
  50. #define INODE_SIZE (sizeof(struct d_inode))
  51. #define INODE_BLOCKS UPPER(INODES,INODES_PER_BLOCK)
  52. #define INODE_BUFFER_SIZE (INODE_BLOCKS * BLOCK_SIZE)

  54. #define BITS_PER_BLOCK (BLOCK_SIZE<<3)

  56. static char * program_name = "mkfs";
  57. static char * device_name = NULL;
  58. static int DEV = -1;
  59. static long BLOCKS = 0;
  60. static int check = 0;
  61. static int badblocks = 0;

  63. #define ROOT_INO_STRING "\001\000"
  64. #define BAD_INO_STRING "\002\000"

  66. static char root_block[BLOCK_SIZE] =
  67. ROOT_INO_STRING ".\0\0\0\0\0\0\0\0\0\0\0\0\0"
  68. ROOT_INO_STRING "..\0\0\0\0\0\0\0\0\0\0\0\0"
  69. BAD_INO_STRING ".badblocks\0\0\0\0";

  71. static char * inode_buffer = NULL;
  72. #define Inode (((struct d_inode *) inode_buffer)-1)
  73. static char super_block_buffer[BLOCK_SIZE];
  74. #define Super (*(struct super_block *)super_block_buffer)
  75. #define INODES ((unsigned long)Super.s_ninodes)
  76. #define ZONES ((unsigned long)Super.s_nzones)
  77. #define IMAPS ((unsigned long)Super.s_imap_blocks)
  78. #define ZMAPS ((unsigned long)Super.s_zmap_blocks)
  79. #define FIRSTZONE ((unsigned long)Super.s_firstdatazone)
  80. #define ZONESIZE ((unsigned long)Super.s_log_zone_size)
  81. #define MAXSIZE ((unsigned long)Super.s_max_size)
  82. #define MAGIC (Super.s_magic)
  83. #define NORM_FIRSTZONE (2+IMAPS+ZMAPS+INODE_BLOCKS)

  85. static char inode_map[BLOCK_SIZE * I_MAP_SLOTS];
  86. static char zone_map[BLOCK_SIZE * Z_MAP_SLOTS];

  88. static unsigned short good_blocks_table[MAX_GOOD_BLOCKS];
  89. static int used_good_blocks = 0;

  91. #define bitop(name,op) \
  92.     static inline int name(char * addr,unsigned int nr) \
  93. { \
  94.     int __res; \
  95.     __asm__ __volatile__("bt" op " %1,%2; adcl $0,%0" \
  96.             :"=g" (__res) \
  97.             :"r" (nr),"m" (*(addr)),"0" (0)); \
  98.     return __res; \
  99. }

  101. bitop(bit,"")
  102. bitop(setbit,"s")
  103. bitop(clrbit,"r")

  105. #define inode_in_use(x) (bit(inode_map,(x)))
  106. #define zone_in_use(x) (bit(zone_map,(x)-FIRSTZONE+1))

  108. #define mark_inode(x) (setbit(inode_map,(x)))
  109. #define unmark_inode(x) (clrbit(inode_map,(x)))

  111. #define mark_zone(x) (setbit(zone_map,(x)-FIRSTZONE+1))
  112. #define unmark_zone(x) (clrbit(zone_map,(x)-FIRSTZONE+1))

  114. /*
  115.  * Volatile to let gcc know that this doesn't return. When trying
  116.  * to compile this under minix, volatile gives a warning, as
  117.  * exit() isn't defined as volatile under minix.
  118.  */
  119. void fatal_error(const char * fmt_string)
  120. {
  121.     fprintf(stderr,fmt_string,__func__, __LINE__, program_name,device_name);
  122.     exit(1);
  123. }

  125. #define usage() fatal_error("Usage: %s:[%d]%s [-c] %s blocks\n")
  126. #define die(str) fatal_error("%s: " str "\n")

  128. void write_tables(void)
  129. {
  130.     if (BLOCK_SIZE != lseek(DEV, BLOCK_SIZE, SEEK_SET))
  131.         die("seek failed in write_tables");
  132.     if (BLOCK_SIZE != write(DEV, super_block_buffer, BLOCK_SIZE))
  133.         die("unable to write super-block");
  134.     if (IMAPS*BLOCK_SIZE != write(DEV,inode_map,IMAPS*BLOCK_SIZE))
  135.         die("Unable to write inode map");
  136.     if (ZMAPS*BLOCK_SIZE != write(DEV,zone_map,ZMAPS*BLOCK_SIZE))
  137.         die("Unable to write zone map");
  138.     if (INODE_BUFFER_SIZE != write(DEV,inode_buffer,INODE_BUFFER_SIZE))
  139.         die("Unable to write inodes");
  140. }

  142. void write_block(int blk, char * buffer)
  143. {
  144.     if (blk*BLOCK_SIZE != lseek(DEV, blk*BLOCK_SIZE, SEEK_SET))
  145.         die("seek failed in write_block");
  146.     if (BLOCK_SIZE != write(DEV, buffer, BLOCK_SIZE))
  147.         die("write failed in write_block");
  148. }

  150. int get_free_block(void)
  151. {
  152.     int blk;

  154.     if (used_good_blocks+1 >= MAX_GOOD_BLOCKS)
  155.         die("too many bad blocks");
  156.     if (used_good_blocks)
  157.         blk = good_blocks_table[used_good_blocks-1]+1;
  158.     else
  159.         blk = FIRSTZONE;
  160.     while (blk < ZONES && zone_in_use(blk))
  161.         blk++;
  162.     if (blk >= ZONES)
  163.         die("not enough good blocks");
  164.     good_blocks_table[used_good_blocks] = blk;
  165.     used_good_blocks++;
  166.     return blk;
  167. }

  169. void mark_good_blocks(void)
  170. {
  171.     int blk;

  173.     for (blk=0 ; blk < used_good_blocks ; blk++)
  174.         mark_zone(good_blocks_table[blk]);
  175. }

  177. inline int next(int zone)
  178. {
  179.     if (!zone)
  180.         zone = FIRSTZONE-1;
  181.     while (++zone < ZONES)
  182.         if (zone_in_use(zone))
  183.             return zone;
  184.     return 0;
  185. }

  187. void make_bad_inode(void)
  188. {
  189.     struct d_inode * inode = &Inode[BAD_INO];
  190.     int i,j,zone;
  191.     int ind=0,dind=0;
  192.     unsigned short ind_block[BLOCK_SIZE>>1];
  193.     unsigned short dind_block[BLOCK_SIZE>>1];

  195. #define NEXT_BAD (zone = next(zone))

  197.     if (!badblocks)
  198.         return;
  199.     mark_inode(BAD_INO);
  200.     inode->i_nlinks = 1;
  201.     inode->i_time = time(NULL);
  202.     inode->i_mode = S_IFREG + 0000;
  203.     inode->i_size = badblocks*BLOCK_SIZE;
  204.     zone = next(0);
  205.     for (i=0 ; i<7 ; i++) {
  206.         inode->i_zone[i] = zone;
  207.         if (!NEXT_BAD)
  208.             goto end_bad;
  209.     }
  210.     inode->i_zone[7] = ind = get_free_block();
  211.     memset(ind_block,0,BLOCK_SIZE);
  212.     for (i=0 ; i<512 ; i++) {
  213.         ind_block[i] = zone;
  214.         if (!NEXT_BAD)
  215.             goto end_bad;
  216.     }
  217.     inode->i_zone[8] = dind = get_free_block();
  218.     memset(dind_block,0,BLOCK_SIZE);
  219.     for (i=0 ; i<512 ; i++) {
  220.         write_block(ind,(char *) ind_block);
  221.         dind_block[i] = ind = get_free_block();
  222.         memset(ind_block,0,BLOCK_SIZE);
  223.         for (j=0 ; j<512 ; j++) {
  224.             ind_block[j] = zone;
  225.             if (!NEXT_BAD)
  226.                 goto end_bad;
  227.         }
  228.     }
  229.     die("too many bad blocks");
  230. end_bad:
  231.     if (ind)
  232.         write_block(ind, (char *) ind_block);
  233.     if (dind)
  234.         write_block(dind, (char *) dind_block);
  235. }

  237. void make_root_inode(void)
  238. {
  239.     struct d_inode * inode = &Inode[ROOT_INO];

  241.     mark_inode(ROOT_INO);
  242.     inode->i_zone[0] = get_free_block();
  243.     inode->i_nlinks = 2;
  244.     inode->i_time = time(NULL);
  245.     if (badblocks)
  246.         inode->i_size = 48;
  247.     else
  248.         inode->i_size = 32;
  249.     inode->i_mode = S_IFDIR + 0755;
  250.     write_block(inode->i_zone[0],root_block);
  251. }

  253. void setup_tables(void)
  254. {
  255.     int i;
  256.     struct super_block * p;
  257.     p = (struct super_block*)super_block_buffer;
  258.     memset(inode_map,0xff,sizeof(inode_map));
  259.     memset(zone_map,0xff,sizeof(zone_map));
  260.     memset(super_block_buffer,0,BLOCK_SIZE);
  261.     MAGIC = SUPER_MAGIC;
  262.     p->s_log_zone_size = 0;
  263.     p->s_max_size = (7+512+512*512)*1024;
  264.     p->s_nzones = BLOCKS;
  265.     /* some magic nrs: 1 inode / 3 blocks */
  266.     p->s_ninodes = BLOCKS/3;
  267.     /* I don't want some off-by-one errors, so this hack... */
  268.     if ((p->s_ninodes & 8191) > 8188)
  269.         p->s_ninodes -= 5;
  270.     if ((p->s_ninodes & 8191) < 10)
  271.         p->s_ninodes -= 20;
  272.     if ((p->s_ninodes & 8191) > 8188)
  273.         p->s_ninodes = 5;
  274.     if ((p->s_ninodes & 8191) < 10)
  275.         p->s_ninodes -= 20;

  277.     p->s_imap_blocks = UPPER(p->s_ninodes, BITS_PER_BLOCK);
  278.     p->s_zmap_blocks = 0;
  279.     while (p->s_zmap_blocks != UPPER(BLOCKS - NORM_FIRSTZONE,BITS_PER_BLOCK))
  280.         p->s_zmap_blocks = UPPER(BLOCKS - NORM_FIRSTZONE, BITS_PER_BLOCK);
  281.     p->s_firstdatazone = NORM_FIRSTZONE;
  282.     for (i = p->s_firstdatazone; i<p->s_nzones; i++)
  283.         unmark_zone(i);
  284.     for (i = ROOT_INO ; i<p->s_ninodes; i++)
  285.         unmark_inode(i);
  286.     inode_buffer = malloc(INODE_BUFFER_SIZE);
  287.     if (!inode_buffer)
  288.         die("Unable to allocate buffer for inodes");
  289.     memset(inode_buffer,0,INODE_BUFFER_SIZE);
  290.     printf("%d inodes\n",p->s_ninodes);
  291.     printf("%d blocks\n", p->s_nzones);
  292.     printf("Firstdatazone=%d (%d)\n",p->s_firstdatazone,NORM_FIRSTZONE);
  293.     printf("Zonesize=%d\n",BLOCK_SIZE<<p->s_log_zone_size);
  294.     printf("Maxsize=%d\n\n", p->s_max_size);
  295. }

  297. void check_blocks(void)
  298. {
  299.     unsigned int current_block=0;
  300.     int try,got;
  301.     static char buffer[BLOCK_SIZE * TEST_BUFFER_BLOCKS];

  303.     while (current_block < ZONES) {
  304.         if (lseek(DEV,current_block*BLOCK_SIZE,SEEK_SET) !=
  305.                 current_block*BLOCK_SIZE)
  306.             die("seek failed in check_blocks");
  307.         try = TEST_BUFFER_BLOCKS;
  308.         if (current_block + try > ZONES)
  309.             try = ZONES-current_block;
  310.         got = read(DEV, buffer, try * BLOCK_SIZE);
  311.         if (got<0)
  312.             got = 0;
  313.         if (got & (BLOCK_SIZE-1))
  314.             printf("Weird values in check_blocks: probably bugs\n");
  315.         got /= BLOCK_SIZE;
  316.         current_block += got;
  317.         if (got == try)
  318.             continue;
  319.         if (current_block < FIRSTZONE)
  320.             die("bad blocks before data-area: cannot make fs");
  321.         mark_zone(current_block);
  322.         badblocks++;
  323.         current_block++;
  324.     }
  325.     if (badblocks)
  326.         printf("%d bad block%s\n",badblocks,(badblocks>1)?"s":"");
  327. }

  329. int main(int argc, char ** argv)
  330. {
  331.     char * tmp;
  332.     struct stat statbuf;

  334.     if (argc && *argv)
  335.         program_name = *argv;
  336.     //printf("INODE_SIZE=%d, INODES_PER_BLOCK=%d, BLOCK_SIZE=%d\n", INODE_SIZE, INODES_PER_BLOCK, BLOCK_SIZE);
  337.     if (INODE_SIZE * INODES_PER_BLOCK != BLOCK_SIZE)
  338.         die("bad inode size");
  339.     while (argc-- > 1) {
  340.         argv++;
  341.         if (argv[0][0] != '-')
  342.             if (device_name) {
  343.                 BLOCKS = strtol(argv[0],&tmp,0);
  344.                 if (*tmp)
  345.                 {
  346.                     printf("argv=%s, tmp!=0\n", argv[0]);
  347.                     return 0;
  348.                 }
  349.             } else
  350.                 device_name = argv[0];
  351.             else while (*++argv[0])
  352.                 switch (argv[0][0]) {
  353.                     case 'c': check=1; break;
  354.                     default: usage();
  355.                 }
  356.     }
  357.     printf("device_name=%s\n", device_name);
  358.     if (!device_name || BLOCKS<10 || BLOCKS > 65536)
  359.     {
  360.         printf("!device_name || BLOCKS<10 || BLOCKS > 65536\n");
  361.         return 0;
  362.     }
  363.     DEV = open(device_name,O_RDWR);
  364.     if (DEV<0)
  365.         die("unable to open %s");
  366.     if (fstat(DEV,&statbuf)<0)
  367.         die("unable to stat %s");
  368.     if (!S_ISBLK(statbuf.st_mode))
  369.         check=0;
  370.     else if (statbuf.st_rdev == 0x0300 || statbuf.st_rdev == 0x0305)
  371.         die("Will not try to make filesystem on '%s'");
  372.     setup_tables();
  373.     if (check)
  374.         check_blocks();
  375.     make_root_inode();
  376.     make_bad_inode();
  377.     mark_good_blocks();
  378.     write_tables();
  379.     return 0;
  380. }
1.3 mkfs.c编译的Makefile
  1. cong@msi:/work/os/linux12/tools/mkfs$ cat Makefile
  2. mkfs:mkfs.c
  3.     gcc -m32 -g -o $@ $^
  4. clean:
  5.     -rm -rf *.o mkfs
2. 创建系统的脚本如下
有了mkfs之后就可以正常的构建linux0.12的文件系统了，脚本如下:
  1. #!/bin/sh
  2. create_fs()
  3. {
  4.     #create filesystem
  5.     cd /tmp/minix

  7.     #先创建系统目录
  8.     sudo mkdir -pv etc dev bin usr usr/bin var
  9.     sudo mknod ./dev/tty1 c 4 1                      -->需要打开tty1
  10.     sudo cp /work/os/linux12/tools/sh/init ./bin/    -->这儿随意写了个init
  11. }


  14. #fdisk hdc.img to minix 80
  15. make_fs()
  16. {
  17.     #sector的数目=524288=256M/512=256*1024*1024/512
  18.     dd if=/dev/zero of=./hdc.img bs=512 count=524288
  19.     fdisk ./hdc.img <<EOF       --->对hdc.img进行分区，只分一个主分区，并设置分区为80(old minix)    
  20.     n
  21.     p
  22.     1
  23.     2048                        -->分区开始
  24.     524159                      -->分区结束 
  25.     t                           -->t   change a partition's system id
  26.     80
  27.     w
  28. EOF                              --->注意这个EOF必须顶格写，要不会出错
  29.     sleep 1
  30.     fdisk -l ./hdc.img
  31.     losetup /dev/loop0 ./hdc.img               -->将整个的hdc.img镜像关联到/dev/loop0上去
  32.     #512*2048=1048576                          -->分区是从2048个sector开始的
  33.     losetup -o 1048576 /dev/loop1 /dev/loop0   -->所以这儿 -o 加上偏移
  34.     losetup -a                                 --> list all used losetup
  35.     ./mkfs -c /dev/loop1 65535                 -->对分区1格式化为 old minix分区
  36.     mkdir /tmp/minix                           
  37.     sudo mount -t minix /dev/loop1 /tmp/minix/  -->格式化后就可以挂载了
  38.     create_fs
  39. }
  40. umount_fs()
  41. {
  42.     sudo umount /tmp/minix
  43.     losetup -d /dev/loop0
  44.     losetup -d /dev/loop1
  45.     losetup -a
  46. }

  48. clean_fs()
  49. {
  50.     sudo umount /tmp/minix
  51.     losetup -d /dev/loop0
  52.     losetup -d /dev/loop1
  53.     rm -rf ./hdc.img
  54. }

  56. case "$1" in
  57.     fs)
  58.         make_fs
  59.         ;;
  60.     clean)
  61.         clean_fs
  62.         ;;
  63.     umount)
  64.         umount_fs
  65.         ;;
  66.     *)
  67.         make_fs
  68.         ;;
  69. esac

3.代码打包
  1. cong@msi:/work/os/linux12/tools/mkfs$ tree
  2. .
  3. ├── fs.h
  4. ├── Makefile
  5. ├── mkfs
  6. ├── mkfs.c
  7. ├── mkfs.c_bak
  8. └── mkfs_notation.c
mkfs.rar(下载后改名为mkfs.tar.gz)
4.运行结果

说明在建文件系统时init进程不正确导致，但至少文件系统是成功了。
5. 对于己建好的例如: rootimage-0.12-hd如何访问里面的内容呢?
  1. cong@msi:/work/os/linux12$ fdisk -l ./rootimage-0.12-hd                 -->查看分区

  3. Disk ./rootimage-0.12-hd: 251 MB, 251338752 bytes
  4. 16 heads, 63 sectors/track, 487 cylinders, total 490896 sectors
  5. Units = sectors of 1 * 512 = 512 bytes
  6. Sector size (logical/physical): 512 bytes / 512 bytes
  7. I/O size (minimum/optimal): 512 bytes / 512 bytes
  8. Disk identifier: 0x00000000

  10.               Device Boot Start End Blocks Id System
  11. ./rootimage-0.12-hd1 * 1 132047 66023+ 81 Minix / old Linux             -->第1个分区是在偏移1*512处
  12. ./rootimage-0.12-hd2 132048 264095 66024 81 Minix / old Linux
  13. ./rootimage-0.12-hd3 264096 396143 66024 81 Minix / old Linux
  14. ./rootimage-0.12-hd4 396144 478799 41328 82 Linux swap / Solaris


  17. cong@msi:/work/os/linux12$ losetup /dev/loop0 ./rootimage-0.12-hd       -->losetup整个镜像
  18. cong@msi:/work/os/linux12$ losetup -a                                   
  19. /dev/loop0: [0808]:49164984 (/work/os/linux12/rootimage-0.12-hd)

  21. cong@msi:/work/os/linux12$ losetup -o 512 /dev/loop1 /dev/loop0         -->losetup分区1

  23. cong@msi:/work/os/linux12$ losetup -a                                   -->查看losetup
  24. /dev/loop0: [0808]:49164984 (/work/os/linux12/rootimage-0.12-hd)
  25. /dev/loop1: [0005]:1164 (/dev/loop0), offset 512

  27. cong@msi:/work/os/linux12$ sudo mount -t minix /dev/loop0 /tmp/linux011/  -->挂载分区1

  29. cong@msi:/work/os/linux12$ ls /tmp/linux011/
  30. bin dev etc hdd home image MCC-0.12 mnt mnt1 README root tmp usr vmlinux
  31. cong@msi:/work/os/linux12$ ls /tmp/linux011/bin/
  32. agetty chage clock echo fdisk groupadd init logoutd mkswap newusers pwunconv sleep true userdel zic
  33. awk chfn crond env fsck groupdel kdb mkfs mount passwd rm su umount usermod
  34. bash chpasswd date faillog gawk groupmod lex.yy.c mknod mv ps sh sulogin update vi
  35. bash.old chsh dpasswd false gpasswd id login mkpasswd newgrp pwconv sh.old sync useradd zdump
  36. cong@msi:/work/os/linux12$ sudo file /tmp/linux011/bin/bash
  37. /tmp/linux011/bin/bash: a.out little-endian 32-bit demand paged pure executable  -->说明正确
根据上面的步骤就可以把己移植好的程序放到自己的hdc.img里面去了。
阅读(1359) | 评论(0) | 转发(0) |
0

上一篇：写操作系统----12.整页内存分配

下一篇：linux0.12--4.《完全剖析》第四章多任务内核实例linux0.00

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6