/* This file contains the main program of the File System. It consists of * a loop that gets messages requesting work, carries out the work, and sends * replies. * * The entry points into this file are: * main: main program of the File System * reply: send a reply to a process after the requested work is done * * Changes: * Mar 23, 2005 allow arbitrary partitions as RAM disk (Jorrit N. Herder) * Jan 10, 2005 register fkeys with TTY for debug dumps (Jorrit N. Herder) */ struct super_block; /* proto.h needs to know this */ #include "fs.h" #include #include #include #include #include #include #include #include #include #include "buf.h" #include "dmap.h" #include "file.h" #include "fproc.h" #include "inode.h" #include "param.h" #include "super.h" FORWARD _PROTOTYPE( void fs_init, (void) ); FORWARD _PROTOTYPE( int igetenv, (char *var) ); FORWARD _PROTOTYPE( void get_work, (void) ); FORWARD _PROTOTYPE( void load_ram, (void) ); FORWARD _PROTOTYPE( void load_super, (Dev_t super_dev) ); /*===========================================================================* * main * *===========================================================================*/ PUBLIC void main() { /* This is the main program of the file system. The main loop consists of * three major activities: getting new work, processing the work, and sending * the reply. This loop never terminates as long as the file system runs. */ int error; fs_init(); /* This is the main loop that gets work, processes it, and sends replies. */ while (TRUE) { get_work(); /* sets who and call_nr */ fp = &fproc[who]; /* pointer to proc table struct */ super_user = (fp->fp_effuid == SU_UID ? TRUE : FALSE); /* su? */ /* Check for special control messages first. */ if (call_nr == HARD_STOP) { do_sync(); sys_exit(0); /* never returns */ } else if (call_nr == FKEY_PRESSED) { do_fkey_pressed(); continue; /* get work again */ } /* Call the internal function that does the work. */ if (call_nr < 0 || call_nr >= NCALLS) error = ENOSYS; else error = (*call_vec[call_nr])(); /* Copy the results back to the user and send reply. */ if (error != SUSPEND) { reply(who, error); } if (rdahed_inode != NIL_INODE) { read_ahead(); /* do block read ahead */ } } } /*===========================================================================* * get_work * *===========================================================================*/ PRIVATE void get_work() { /* Normally wait for new input. However, if 'reviving' is * nonzero, a suspended process must be awakened. */ register struct fproc *rp; if (reviving != 0) { /* Revive a suspended process. */ for (rp = &fproc[0]; rp < &fproc[NR_PROCS]; rp++) if (rp->fp_revived == REVIVING) { who = (int)(rp - fproc); call_nr = rp->fp_fd & BYTE; m_in.fd = (rp->fp_fd >>8) & BYTE; m_in.buffer = rp->fp_buffer; m_in.nbytes = rp->fp_nbytes; rp->fp_suspended = NOT_SUSPENDED; /*no longer hanging*/ rp->fp_revived = NOT_REVIVING; reviving--; return; } panic("get_work couldn't revive anyone", NO_NUM); } /* Normal case. No one to revive. */ if (receive(ANY, &m_in) != OK) panic("fs receive error", NO_NUM); who = m_in.m_source; call_nr = m_in.m_type; } /*===========================================================================* * buf_pool * *===========================================================================*/ PRIVATE void buf_pool(void) { /* Initialize the buffer pool. */ register struct buf *bp; bufs_in_use = 0; front = &buf[0]; rear = &buf[NR_BUFS - 1]; for (bp = &buf[0]; bp < &buf[NR_BUFS]; bp++) { bp->b_blocknr = NO_BLOCK; bp->b_dev = NO_DEV; bp->b_next = bp + 1; bp->b_prev = bp - 1; } buf[0].b_prev = NIL_BUF; buf[NR_BUFS - 1].b_next = NIL_BUF; for (bp = &buf[0]; bp < &buf[NR_BUFS]; bp++) bp->b_hash = bp->b_next; buf_hash[0] = front; } /*===========================================================================* * reply * *===========================================================================*/ PUBLIC void reply(whom, result) int whom; /* process to reply to */ int result; /* result of the call (usually OK or error #) */ { /* Send a reply to a user process. It may fail (if the process has just * been killed by a signal), so don't check the return code. If the send * fails, just ignore it. */ int s; m_out.reply_type = result; s = send(whom, &m_out); if (s != OK) printf("FS: couldn't send reply: %d\n", s); } /*===========================================================================* * fs_init * *===========================================================================*/ PRIVATE void fs_init() { /* Initialize global variables, tables, etc. */ register struct inode *rip; int key, i; message mess; /* The following initializations are needed to let dev_opcl succeed .*/ fp = (struct fproc *) NULL; who = FS_PROC_NR; map_controllers(); /* map controller devices to drivers */ buf_pool(); /* initialize buffer pool */ load_ram(); /* init RAM disk, load if it is root */ load_super(root_dev); /* load super block for root device */ /* Initialize the 'fproc' fields for process 0 .. INIT. */ for (i = 0; i <= LOW_USER; i+= 1) { if (i == FS_PROC_NR) continue; /* do not initialize FS */ fp = &fproc[i]; rip = get_inode(root_dev, ROOT_INODE); fp->fp_rootdir = rip; dup_inode(rip); fp->fp_workdir = rip; fp->fp_realuid = (uid_t) SYS_UID; fp->fp_effuid = (uid_t) SYS_UID; fp->fp_realgid = (gid_t) SYS_GID; fp->fp_effgid = (gid_t) SYS_GID; fp->fp_umask = ~0; fp->fp_pid = i < LOW_USER ? PID_SERVER : 1; } /* Certain relations must hold for the file system to work at all. * (Some extra block_size requirements are checked at super-block-read-in * time.) */ if (OPEN_MAX > 127) panic("OPEN_MAX > 127", NO_NUM); if (NR_BUFS < 6) panic("NR_BUFS < 6", NO_NUM); if (V1_INODE_SIZE != 32) panic("V1 inode size != 32", NO_NUM); if (V2_INODE_SIZE != 64) panic("V2 inode size != 64", NO_NUM); if (OPEN_MAX > 8 * sizeof(long)) panic("Too few bits in fp_cloexec", NO_NUM); /* Tell the memory task where my process table is for the sake of ps(1). */ mess.m_type = DEV_IOCTL; mess.PROC_NR = FS_PROC_NR; mess.DEVICE = RAM_DEV; mess.REQUEST = MIOCSPSINFO; mess.ADDRESS = (void *) fproc; (void) sendrec(MEMORY, &mess); /* Register function keys with TTY. */ for (key=SF5; key<=SF6; key++) { if ((i=fkey_enable(key))!=OK) { printf("Warning: FS couldn't register Shift+F%d key: %d\n", SF1-key+1, i); } } } /*===========================================================================* * igetenv * *===========================================================================*/ PRIVATE int igetenv(key) char *key; { /* Ask kernel for an integer valued boot environment variable. */ char value[64]; int i; if ((i = get_mon_param(key, value, sizeof(value))) != OK) printf("FS: Warning, couldn't get monitor param: %d\n", i); return(atoi(value)); } /*===========================================================================* * load_ram * *===========================================================================*/ PRIVATE void load_ram(void) { /* Allocate a RAM disk with size given in the boot parameters. If a RAM disk * image is given, the copy the entire image device block-by-block to a RAM * disk with the same size as the image. * If the root device is not set, the RAM disk will be used as root instead. */ register struct buf *bp, *bp1; u32_t lcount, ram_size_kb; zone_t zones; struct super_block *sp, *dsp; block_t b; Dev_t image_dev; int r; static char sbbuf[MIN_BLOCK_SIZE]; int block_size_image, block_size_ram, ramfs_block_size; /* Get some boot environment variables. */ root_dev = igetenv("rootdev"); image_dev = igetenv("ramimagedev"); ram_size_kb = igetenv("ramsize"); /* Open the root device. */ if (dev_open(root_dev, FS_PROC_NR, R_BIT|W_BIT) != OK) { panic("Cannot open root device",NO_NUM); } /* If we must initialize a ram disk, get details from the image device. */ if (root_dev == DEV_RAM || root_dev != image_dev) { u32_t fsmax; if (dev_open(image_dev, FS_PROC_NR, R_BIT) != OK) panic("Cannot open RAM image device", NO_NUM); /* Get size of RAM disk image from the super block. */ sp = &super_block[0]; sp->s_dev = image_dev; if (read_super(sp) != OK) panic("Bad RAM disk image FS", NO_NUM); lcount = sp->s_zones << sp->s_log_zone_size; /* # blks on root dev*/ /* Stretch the RAM disk file system to the boot parameters size, but * no further than the last zone bit map block allows. */ if (ram_size_kb*1024 < lcount*sp->s_block_size) ram_size_kb = lcount*sp->s_block_size/1024; fsmax = (u32_t) sp->s_zmap_blocks * CHAR_BIT * sp->s_block_size; fsmax = (fsmax + (sp->s_firstdatazone-1)) << sp->s_log_zone_size; if (ram_size_kb*1024 > fsmax*sp->s_block_size) ram_size_kb = fsmax*sp->s_block_size/1024; } /* Tell RAM driver how big the RAM disk must be. */ m_out.m_type = DEV_IOCTL; m_out.PROC_NR = FS_PROC_NR; m_out.DEVICE = RAM_DEV; m_out.REQUEST = MIOCRAMSIZE; m_out.POSITION = ram_size_kb*1024; if (sendrec(MEMORY, &m_out) != OK || m_out.REP_STATUS != OK) panic("Can't set RAM disk size", NO_NUM); /* Tell MM the RAM disk size, and wait for it to come "on-line". */ m_out.MEM_CHUNK_SIZE = ((long) ram_size_kb * 1024) >> CLICK_SHIFT; if (sendrec(MM_PROC_NR, &m_out) != OK) panic("FS can't sync up with MM", NO_NUM); #if ENABLE_CACHE2 /* The RAM disk is a second level block cache while not otherwise used. */ init_cache2(ram_size); #endif /* See if we must load the RAM disk image, otherwise return. */ if (root_dev != DEV_RAM && root_dev == image_dev) return; /* Copy the blocks one at a time from the image to the RAM disk. */ printf("Loading RAM disk.\33[23CLoaded: 0K "); inode[0].i_mode = I_BLOCK_SPECIAL; /* temp inode for rahead() */ inode[0].i_size = LONG_MAX; inode[0].i_dev = image_dev; inode[0].i_zone[0] = image_dev; block_size_ram = get_block_size(DEV_RAM); block_size_image = get_block_size(image_dev); if(block_size_ram != block_size_image) { printf("ram block size: %d image block size: %d\n", block_size_ram, block_size_image); panic("Sorry, ram disk and image disk block sizes have to be the same.", NO_NUM); } for (b = 0; b < (block_t) lcount; b++) { bp = rahead(&inode[0], b, (off_t)block_size_image * b, block_size_image); bp1 = get_block(root_dev, b, NO_READ); memcpy(bp1->b_data, bp->b_data, (size_t) block_size_image); bp1->b_dirt = DIRTY; put_block(bp, FULL_DATA_BLOCK); put_block(bp1, FULL_DATA_BLOCK); printf("\b\b\b\b\b\b\b%5ldK ", ((long) b * block_size_image)/1024L); } printf("\rRAM disk of %u kb loaded.\33[K", ram_size_kb); if (root_dev == DEV_RAM) printf(" RAM disk is used as root FS."); printf("\n\n"); /* Invalidate and close the image device. */ invalidate(image_dev); dev_close(image_dev); /* Resize the RAM disk root file system. */ if(dev_io(DEV_READ, root_dev, FS_PROC_NR, sbbuf, SUPER_BLOCK_BYTES, MIN_BLOCK_SIZE, 0) != MIN_BLOCK_SIZE) { printf("WARNING: ramdisk read for resizing failed\n"); } dsp = (struct super_block *) sbbuf; if(dsp->s_magic == SUPER_V3) ramfs_block_size = dsp->s_block_size; else ramfs_block_size = STATIC_BLOCK_SIZE; zones = (ram_size_kb * 1024 / ramfs_block_size) >> sp->s_log_zone_size; dsp->s_nzones = conv2(sp->s_native, (u16_t) zones); dsp->s_zones = conv4(sp->s_native, zones); if(dev_io(DEV_WRITE, root_dev, FS_PROC_NR, sbbuf, SUPER_BLOCK_BYTES, MIN_BLOCK_SIZE, 0) != MIN_BLOCK_SIZE) { printf("WARNING: ramdisk write for resizing failed\n"); } } /*===========================================================================* * load_super * *===========================================================================*/ PRIVATE void load_super(super_dev) dev_t super_dev; /* place to get superblock from */ { int bad; register struct super_block *sp; register struct inode *rip; /* Initialize the super_block table. */ for (sp = &super_block[0]; sp < &super_block[NR_SUPERS]; sp++) sp->s_dev = NO_DEV; /* Read in super_block for the root file system. */ sp = &super_block[0]; sp->s_dev = super_dev; /* Check super_block for consistency. */ bad = (read_super(sp) != OK); if (!bad) { rip = get_inode(super_dev, ROOT_INODE); /* inode for root dir */ if ( (rip->i_mode & I_TYPE) != I_DIRECTORY || rip->i_nlinks < 3) bad++; } if (bad) panic("Invalid root file system", NO_NUM); sp->s_imount = rip; dup_inode(rip); sp->s_isup = rip; sp->s_rd_only = 0; return; }