main.c

一个简单的操作系统minix的核心代码

22679	PRIVATE void buf_pool()
22680	{
22681	/* Initialize the buffer pool. */
22682	
22683	  register struct buf *bp;
22684	
22685	  bufs_in_use = 0;
22686	  front = &buf[0];
22687	  rear = &buf[NR_BUFS - 1];
22688	
22689	  for (bp = &buf[0]; bp < &buf[NR_BUFS]; bp++) {
22690	        bp->b_blocknr = NO_BLOCK;
22691	        bp->b_dev = NO_DEV;
22692	        bp->b_next = bp + 1;
22693	        bp->b_prev = bp - 1;
22694	  }
22695	  buf[0].b_prev = NIL_BUF;
22696	  buf[NR_BUFS - 1].b_next = NIL_BUF;
22697	
22698	  for (bp = &buf[0]; bp < &buf[NR_BUFS]; bp++) bp->b_hash = bp->b_next;
22699	  buf_hash[0] = front;
22700	}
	
	
22703	/*===========================================================================*
22704	 *                              get_boot_parameters                          *
22705	 *===========================================================================*/
22706	PUBLIC struct bparam_s boot_parameters;
22707	
22708	PRIVATE void get_boot_parameters()
22709	{
22710	/* Ask kernel for boot parameters. */
22711	
22712	  m1.m_type = SYS_GBOOT;
22713	  m1.PROC1 = FS_PROC_NR;
22714	  m1.MEM_PTR = (char *) &boot_parameters;
22715	  (void) sendrec(SYSTASK, &m1);
22716	}
	
	
22719	/*===========================================================================*
22720	 *                              load_ram                                     *
22721	 *===========================================================================*/
22722	PRIVATE void load_ram()
22723	{
22724	/* If the root device is the RAM disk, copy the entire root image device
22725	 * block-by-block to a RAM disk with the same size as the image.
22726	 * Otherwise, just allocate a RAM disk with size given in the boot parameters.
22727	 */
22728	
22729	  register struct buf *bp, *bp1;
22730	  long k_loaded, lcount;
22731	  u32_t ram_size, fsmax;
22732	  zone_t zones;
22733	  struct super_block *sp, *dsp;
22734	  block_t b;
22735	  int major, task;
22736	  message dev_mess;
22737	
22738	  ram_size = boot_parameters.bp_ramsize;
22739	
22740	  /* Open the root device. */
22741	  major = (ROOT_DEV >> MAJOR) & BYTE;   /* major device nr */
22742	  task = dmap[major].dmap_task;         /* device task nr */
22743	  dev_mess.m_type = DEV_OPEN;           /* distinguish from close */
22744	  dev_mess.DEVICE = ROOT_DEV;
22745	  dev_mess.COUNT = R_BIT|W_BIT;
22746	  (*dmap[major].dmap_open)(task, &dev_mess);
22747	  if (dev_mess.REP_STATUS != OK) panic("Cannot open root device",NO_NUM);
22748	
22749	  /* If the root device is the ram disk then fill it from the image device. */
22750	  if (ROOT_DEV == DEV_RAM) {
22751	        major = (IMAGE_DEV >> MAJOR) & BYTE;    /* major device nr */
22752	        task = dmap[major].dmap_task;           /* device task nr */
22753	        dev_mess.m_type = DEV_OPEN;             /* distinguish from close */
22754	        dev_mess.DEVICE = IMAGE_DEV;
22755	        dev_mess.COUNT = R_BIT;
22756	        (*dmap[major].dmap_open)(task, &dev_mess);
22757	        if (dev_mess.REP_STATUS != OK) panic("Cannot open root device", NO_NUM);
22758	
22759	        /* Get size of RAM disk by reading root file system's super block. */
22760	        sp = &super_block[0];
22761	        sp->s_dev = IMAGE_DEV;
22762	        if (read_super(sp) != OK) panic("Bad root file system", NO_NUM);
22763	
22764	        lcount = sp->s_zones << sp->s_log_zone_size;    /* # blks on root dev*/
22765	
22766	        /* Stretch the RAM disk file system to the boot parameters size, but
22767	         * no further than the last zone bit map block allows.
22768	         */
22769	        if (ram_size < lcount) ram_size = lcount;
22770	        fsmax = (u32_t) sp->s_zmap_blocks * CHAR_BIT * BLOCK_SIZE;
22771	        fsmax = (fsmax + (sp->s_firstdatazone-1)) << sp->s_log_zone_size;
22772	        if (ram_size > fsmax) ram_size = fsmax;
22773	  }
22774	
22775	  /* Tell RAM driver how big the RAM disk must be. */
22776	  m1.m_type = DEV_IOCTL;
22777	  m1.PROC_NR = FS_PROC_NR;
22778	  m1.REQUEST = MIOCRAMSIZE;
22779	  m1.POSITION = ram_size;
22780	  if (sendrec(MEM, &m1) != OK || m1.REP_STATUS != OK)
22781	        panic("Can't set RAM disk size", NO_NUM);
22782	
22783	  /* Tell MM the RAM disk size, and wait for it to come "on-line". */
22784	  m1.m1_i1 = ((long) ram_size * BLOCK_SIZE) >> CLICK_SHIFT;
22785	  if (sendrec(MM_PROC_NR, &m1) != OK)
22786	        panic("FS can't sync up with MM", NO_NUM);
22787	
22788	  /* If the root device is not the RAM disk, it doesn't need loading. */
22789	  if (ROOT_DEV != DEV_RAM) return;
22790	
22791	  /* Copy the blocks one at a time from the image to the RAM disk. */
22792	  printf("Loading RAM disk.\33[23CLoaded:    0K ");
22793	
22794	  inode[0].i_mode = I_BLOCK_SPECIAL;    /* temp inode for rahead() */
22795	  inode[0].i_size = LONG_MAX;
22796	  inode[0].i_dev = IMAGE_DEV;
22797	  inode[0].i_zone[0] = IMAGE_DEV;
22798	
22799	  for (b = 0; b < (block_t) lcount; b++) {
22800	        bp = rahead(&inode[0], b, (off_t)BLOCK_SIZE * b, BLOCK_SIZE);
22801	        bp1 = get_block(ROOT_DEV, b, NO_READ);
22802	        memcpy(bp1->b_data, bp->b_data, (size_t) BLOCK_SIZE);
22803	        bp1->b_dirt = DIRTY;
22804	        put_block(bp, FULL_DATA_BLOCK);
22805	        put_block(bp1, FULL_DATA_BLOCK);
22806	        k_loaded = ( (long) b * BLOCK_SIZE)/1024L;      /* K loaded so far */
22807	        if (k_loaded % 5 == 0) printf("\b\b\b\b\b\b\b%5ldK ", k_loaded);
22808	  }
22809	
22810	  printf("\rRAM disk loaded.\33[K\n\n");
22811	
22812	  /* Close and invalidate image device. */
22813	  dev_mess.m_type = DEV_CLOSE;
22814	  dev_mess.DEVICE = IMAGE_DEV;
22815	  (*dmap[major].dmap_close)(task, &dev_mess);
22816	  invalidate(IMAGE_DEV);
22817	
22818	  /* Resize the RAM disk root file system. */
22819	  bp = get_block(ROOT_DEV, SUPER_BLOCK, NORMAL);
22820	  dsp = (struct super_block *) bp->b_data;
22821	  zones = ram_size >> sp->s_log_zone_size;
22822	  dsp->s_nzones = conv2(sp->s_native, (u16_t) zones);
22823	  dsp->s_zones = conv4(sp->s_native, zones);
22824	  bp->b_dirt = DIRTY;
22825	  put_block(bp, ZUPER_BLOCK);
22826	}
	
	
22829	/*===========================================================================*
22830	 *                              load_super                                   *
22831	 *===========================================================================*/
22832	PRIVATE void load_super(super_dev)
22833	dev_t super_dev;                        /* place to get superblock from */
22834	{
22835	  int bad;
22836	  register struct super_block *sp;
22837	  register struct inode *rip;
22838	
22839	  /* Initialize the super_block table. */
22840	  for (sp = &super_block[0]; sp < &super_block[NR_SUPERS]; sp++)
22841	        sp->s_dev = NO_DEV;
22842	
22843	  /* Read in super_block for the root file system. */
22844	  sp = &super_block[0];
22845	  sp->s_dev = super_dev;
22846	
22847	  /* Check super_block for consistency (is it the right diskette?). */
22848	  bad = (read_super(sp) != OK);
22849	  if (!bad) {
22850	        rip = get_inode(super_dev, ROOT_INODE); /* inode for root dir */
22851	        if ( (rip->i_mode & I_TYPE) != I_DIRECTORY || rip->i_nlinks < 3) bad++;
22852	  }
22853	  if (bad)panic("Invalid root file system.  Possibly wrong diskette.",NO_NUM);
22854	
22855	  sp->s_imount = rip;
22856	  dup_inode(rip);
22857	  sp->s_isup = rip;
22858	  sp->s_rd_only = 0;
22859	  return;
22860	}