# 2.11BSD#431 - /usr/src/sys/sys/init_main.c

##### Functions

    main              X

##### Variables

    cmask             X
    netoff            X
    securelevel       X

       1: /*
       2:  * Copyright (c) 1986 Regents of the University of California.
       3:  * All rights reserved.  The Berkeley software License Agreement
       4:  * specifies the terms and conditions for redistribution.
       5:  *
       6:  *	@(#)init_main.c	2.5 (2.11BSD GTE) 1997/9/26
       7:  */
       8:
       9: #include "param.h"
      10: #include "../machine/seg.h"
      11:
      12: #include "user.h"
      13: #include "fs.h"
      14: #include "mount.h"
      15: #include "map.h"
      16: #include "proc.h"
      17: #include "ioctl.h"
      18: #include "inode.h"
      19: #include "conf.h"
      20: #include "buf.h"
      21: #include "fcntl.h"
      22: #include "vm.h"
      23: #include "clist.h"
      24: #include "uba.h"
      25: #include "reboot.h"
      26: #include "systm.h"
      27: #include "kernel.h"
      28: #include "namei.h"
      29: #include "disklabel.h"
      30: #include "stat.h"
      31: #ifdef QUOTA
      32: #include "quota.h"
      33: #endif
      34:
      35: int netoff = 1;
      36: int cmask = CMASK;
      37: int securelevel;
      38:
      39: extern  size_t physmem;
      40: extern  struct  mapent _coremap[];
      41:
      42: /*
      43:  * Initialization code.
      44:  * Called from cold start routine as
      45:  * soon as a stack and segmentation
      46:  * have been established.
      47:  * Functions:
      48:  *	clear and free user core
      49:  *	turn on clock
      50:  *	hand craft 0th process
      51:  *	call all initialization routines
      52:  *	fork - process 0 to schedule
      53:  *	     - process 1 execute bootstrap
      54:  */
      55: main()
      56: {
      57:     extern dev_t bootdev;
      58:     extern caddr_t bootcsr;
      59:     register struct proc *p;
      60:     register int i;
      61:     register struct fs *fs;
      62:     time_t  toytime, toyclk();
      63:     daddr_t swsize;
      64:     int (*ioctl)();
      65:     struct  partinfo dpart;
      66:
      67:     startup();
      68:
      69:     /*
      70: 	 * set up system process 0 (swapper)
      71: 	 */
      72:     p = &proc[0];
      73:     p->p_addr = *ka6;
      74:     p->p_stat = SRUN;
      75:     p->p_flag |= SLOAD|SSYS;
      76:     p->p_nice = NZERO;
      77:
      78:     u.u_procp = p;          /* init user structure */
      79:     u.u_ap = u.u_arg;
      80:     u.u_cmask = cmask;
      81:     u.u_lastfile = -1;
      82:     for (i = 1; i < NGROUPS; i++)
      83:         u.u_groups[i] = NOGROUP;
      84:     for (i = 0; i < sizeof(u.u_rlimit)/sizeof(u.u_rlimit[0]); i++)
      85:         u.u_rlimit[i].rlim_cur = u.u_rlimit[i].rlim_max =
      86:             RLIM_INFINITY;
      87:     bcopy("root", u.u_login, sizeof ("root"));
      88:
      89:     /* Initialize signal state for process 0 */
      90:     siginit(p);
      91:
      92:     /*
      93: 	 * Initialize tables, protocols, and set up well-known inodes.
      94: 	 */
      95:     cinit();
      96:     pqinit();
      97:     xinit();
      98:     ihinit();
      99:     bhinit();
     100:     binit();
     101:     ubinit();
     102: #ifdef QUOTA
     103:     QUOTAMAP();
     104:     qtinit();
     105:     u.u_quota = getquota(0, 0, Q_NDQ);
     106:     QUOTAUNMAP();
     107: #endif
     108:     nchinit();
     109:     clkstart();
     110:
     111: /*
     112:  * If the kernel is configured for the boot/load device AND the use of the
     113:  * compiled in 'bootdev' has not been overridden (by turning on RB_DFLTROOT,
     114:  * see conf/boot.c for details) THEN switch 'rootdev', 'swapdev' and 'pipedev'
     115:  * over to the boot/load device.  Set 'pipedev' to be 'rootdev'.
     116:  *
     117:  * The &077 removes the controller number (bits 6 and 7) - those bits are
     118:  * passed thru from /boot but would only greatly confuse the rest of the kernel.
     119: */
     120:     i = major(bootdev);
     121:     if  ((bdevsw[i].d_strategy != nodev) && !(boothowto & RB_DFLTROOT))
     122:         {
     123:         rootdev = makedev(i, minor(bootdev) & 077);
     124:         swapdev = rootdev | 1;  /* partition 'b' */
     125:         pipedev = rootdev;
     126: /*
     127:  * We check that the dump device is the same as the boot device.  If it is
     128:  * different then it is likely that crashdumps go to a tape device rather than
     129:  * the swap area.  In that case do not switch the dump device.
     130: */
     131:         if  ((dumpdev != NODEV) && major(dumpdev) == i)
     132:             dumpdev = swapdev;
     133:         }
     134:
     135: /*
     136:  * Need to attach the root device.  The CSR is passed thru because this
     137:  * may be a 2nd or 3rd controller rather than the 1st.  NOTE: This poses
     138:  * a big problem if 'swapdev' is not on the same controller as 'rootdev'
     139:  * _or_ if 'swapdev' itself is on a 2nd or 3rd controller.  Short of moving
     140:  * autconfigure back in to the kernel it is not known what can be done about
     141:  * this.
     142:  *
     143:  * One solution (for now) is to call swapdev's attach routine with a zero
     144:  * address.  The MSCP driver treats the 0 as a signal to perform the
     145:  * old (fixed address) attach.  Drivers (all the rest at this point) which
     146:  * do not support alternate controller booting always attach the first
     147:  * (primary) CSR and do not expect an argument to be passed.
     148: */
     149:     (void)(*bdevsw[major(bootdev)].d_root)(bootcsr);
     150:     (void)(*bdevsw[major(swapdev)].d_root)((caddr_t) 0);    /* XXX */
     151:
     152: /*
     153:  * Now we find out how much swap space is available.  Since 'nswap' is
     154:  * a "u_int" we have to restrict the amount of swap to 65535 sectors (~32mb).
     155:  * Considering that 4mb is the maximum physical memory capacity of a pdp-11
     156:  * 32mb swap should be enough ;-)
     157:  *
     158:  * The initialization of the swap map was moved here from machdep2.c because
     159:  * 'nswap' was no longer statically defined and this is where the swap dev
     160:  * is opened/initialized.
     161:  *
     162:  * Also, we toss away/ignore .5kb (1 sector) of swap space (because a 0 value
     163:  * can not be placed in a resource map).
     164:  *
     165:  * 'swplo' was a hack which has _finally_ gone away!  It was never anything
     166:  * but 0 and caused a number of double word adds in the kernel.
     167: */
     168:     (*bdevsw[major(swapdev)].d_open)(swapdev, FREAD|FWRITE, S_IFBLK);
     169:     swsize = (*bdevsw[major(swapdev)].d_psize)(swapdev);
     170:     if  (swsize <= 0)
     171:         panic("swsiz");     /* don't want to panic, but what ? */
     172:
     173: /*
     174:  * Next we make sure that we do not swap on a partition unless it is of
     175:  * type FS_SWAP.  If the driver does not have an ioctl entry point or if
     176:  * retrieving the partition information fails then the driver does not
     177:  * support labels and we proceed normally, otherwise the partition must be
     178:  * a swap partition (so that we do not swap on top of a filesystem by mistake).
     179: */
     180:     ioctl = cdevsw[blktochr(swapdev)].d_ioctl;
     181:     if  (ioctl && !(*ioctl)(swapdev, DIOCGPART, (caddr_t)&dpart, FREAD))
     182:         {
     183:         if  (dpart.part->p_fstype != FS_SWAP)
     184:             panic("swtyp");
     185:         }
     186:     if  (swsize > (daddr_t)65535)
     187:         swsize = 65535;
     188:     nswap = swsize;
     189:     mfree(swapmap, --nswap, 1);
     190:
     191:     fs = mountfs(rootdev, boothowto & RB_RDONLY ? MNT_RDONLY : 0,
     192:             (struct inode *)0);
     193:     if (!fs)
     194:         panic("iinit");
     195:     mount[0].m_inodp = (struct inode *)1;   /* XXX */
     196:     mount_updname(fs, "/", "root", 1, 4);
     197:     time.tv_sec = fs->fs_time;
     198:     if  (toytime = toyclk())
     199:         time.tv_sec = toytime;
     200:     boottime = time;
     201:
     202: /* kick off timeout driven events by calling first time */
     203:     schedcpu();
     204:
     205: /* set up the root file system */
     206:     rootdir = iget(rootdev, &mount[0].m_filsys, (ino_t)ROOTINO);
     207:     iunlock(rootdir);
     208:     u.u_cdir = iget(rootdev, &mount[0].m_filsys, (ino_t)ROOTINO);
     209:     iunlock(u.u_cdir);
     210:     u.u_rdir = NULL;
     211:
     212: #ifdef INET
     213:     if (netoff = netinit())
     214:         printf("netinit failed\n");
     215:     else
     216:         {
     217:         NETSETHZ();
     218:         NETSTART();
     219:         }
     220: #endif
     221:
     222: /*
     223:  * This came from pdp/machdep2.c because the memory available statements
     224:  * were being made _before_ memory for the networking code was allocated.
     225:  * A side effect of moving this code is that network "attach" and MSCP
     226:  * "online" messages can appear before the memory sizes.  The (currently
     227:  * safe) assumption is made that no 'free' calls are made so that the
     228:  * size in the first entry of the core map is correct.
     229: */
     230:     printf("\nphys mem  = %D\n", ctob((long)physmem));
     231:     printf("avail mem = %D\n", ctob((long)_coremap[0].m_size));
     232:     maxmem = MAXMEM;
     233:     printf("user mem  = %D\n", ctob((long)MAXMEM));
     234: #if NRAM > 0
     235:     printf("ram disk  = %D\n", ctob((long)ramsize));
     236: #endif
     237:     printf("\n");
     238:
     239:     /*
     240: 	 * make init process
     241: 	 */
     242:     if (newproc(0)) {
     243:         expand((int)btoc(szicode), S_DATA);
     244:         expand((int)1, S_STACK);    /* one click of stack */
     245:         estabur((u_int)0, (u_int)btoc(szicode), (u_int)1, 0, RO);
     246:         copyout((caddr_t)icode, (caddr_t)0, szicode);
     247:         /*
     248: 		 * return goes to location 0 of user init code
     249: 		 * just copied out.
     250: 		 */
     251:         return;
     252:     }
     253:     else
     254:         sched();
     255: }
     256:
     257: /*
     258:  * Initialize hash links for buffers.
     259:  */
     260: static
     261: bhinit()
     262: {
     263:     register int i;
     264:     register struct bufhd *bp;
     265:
     266:     for (bp = bufhash, i = 0; i < BUFHSZ; i++, bp++)
     267:         bp->b_forw = bp->b_back = (struct buf *)bp;
     268: }
     269:
     270: memaddr bpaddr;     /* physical click-address of buffers */
     271: /*
     272:  * Initialize the buffer I/O system by freeing
     273:  * all buffers and setting all device buffer lists to empty.
     274:  */
     275: static
     276: binit()
     277: {
     278:     register struct buf *bp;
     279:     register int i;
     280:     long paddr;
     281:
     282:     for (bp = bfreelist; bp < &bfreelist[BQUEUES]; bp++)
     283:         bp->b_forw = bp->b_back = bp->av_forw = bp->av_back = bp;
     284:     paddr = ((long)bpaddr) << 6;
     285:     for (i = 0; i < nbuf; i++, paddr += MAXBSIZE) {
     286:         bp = &buf[i];
     287:         bp->b_dev = NODEV;
     288:         bp->b_bcount = 0;
     289:         bp->b_un.b_addr = (caddr_t)loint(paddr);
     290:         bp->b_xmem = hiint(paddr);
     291:         binshash(bp, &bfreelist[BQ_AGE]);
     292:         bp->b_flags = B_BUSY|B_INVAL;
     293:         brelse(bp);
     294:     }
     295: }
     296:
     297: /*
     298:  * Initialize clist by freeing all character blocks, then count
     299:  * number of character devices. (Once-only routine)
     300:  */
     301: static
     302: cinit()
     303: {
     304:     register int ccp;
     305:     register struct cblock *cp;
     306:
     307:     ccp = (int)cfree;
     308: #ifdef UCB_CLIST
     309:     mapseg5(clststrt, clstdesc);    /* don't save, we know it's normal */
     310: #else
     311:     ccp = (ccp + CROUND) & ~CROUND;
     312: #endif
     313:     for (cp = (struct cblock *)ccp; cp <= &cfree[nclist - 1]; cp++) {
     314:         cp->c_next = cfreelist;
     315:         cfreelist = cp;
     316:         cfreecount += CBSIZE;
     317:     }
     318: #ifdef UCB_CLIST
     319:     normalseg5();
     320: #endif
     321: }
     322:
     323: #ifdef INET
     324: memaddr netdata;        /* click address of start of net data */
     325:
     326: /*
     327:  * We are called here after all the other init routines (clist, inode,
     328:  * unibusmap, etc...) have been called.  Open the
     329:  * file NETNIX and read the a.out header, based on that go allocate
     330:  * memory and read the text+data into the memory.  Set up supervisor page
     331:  * registers, SDSA6 and SDSA7 have already been set up in mch_start.s.
     332:  */
     333:
     334: static char NETNIX[] = "/netnix";
     335:
     336: static
     337: netinit()
     338: {
     339:     register u_short *ap, *dp;
     340:     register int i;
     341:     struct exec ex;
     342:     struct inode *ip;
     343:     memaddr nettext;
     344:     long lsize;
     345:     off_t   off;
     346:     int initdata, netdsize, nettsize, ret, err, resid;
     347:     char oneclick[ctob(1)];
     348:     struct  nameidata nd;
     349:     register struct nameidata *ndp = &nd;
     350:
     351:     ret = 1;
     352:     NDINIT(ndp, LOOKUP, FOLLOW, UIO_SYSSPACE, NETNIX);
     353:     if (!(ip = namei(ndp))) {
     354:         printf("%s not found\n", NETNIX);
     355:         goto leave;
     356:     }
     357:     if ((ip->i_mode & IFMT) != IFREG || !ip->i_size) {
     358:         printf("%s bad inode\n", NETNIX);
     359:         goto leave;
     360:     }
     361:     err = rdwri(UIO_READ, ip, &ex, sizeof (ex), (off_t)0, UIO_SYSSPACE,
     362:             IO_UNIT, &resid);
     363:     if (err || resid) {
     364:         printf("%s header %d\n", NETNIX, ret);
     365:         goto leave;
     366:     }
     367:     if (ex.a_magic != A_MAGIC3) {
     368:         printf("%s bad magic %o\n", NETNIX, ex.a_magic);
     369:         goto leave;
     370:     }
     371:     lsize = (long)ex.a_data + (long)ex.a_bss;
     372:     if (lsize > 48L * 1024L) {
     373:         printf("%s 2big %ld\n", NETNIX, lsize);
     374:         goto leave;
     375:     }
     376:     nettsize = btoc(ex.a_text);
     377:     nettext = (memaddr)malloc(coremap, nettsize);
     378:     netdsize = btoc(ex.a_data + ex.a_bss);
     379:     netdata = (memaddr)malloc(coremap, netdsize);
     380:     initdata = ex.a_data >> 6;
     381:     off = sizeof (ex);
     382:     for (i = 0; i < nettsize; i++) {
     383:         err = rdwri(UIO_READ, ip, oneclick, ctob(1), off, UIO_SYSSPACE,
     384:                 IO_UNIT, &resid);
     385:         if (err || resid)
     386:             goto release;
     387:         mapseg5(nettext + i, 077406);
     388:         bcopy(oneclick, SEG5, ctob(1));
     389:         off += ctob(1);
     390:         normalseg5();
     391:     }
     392:     for (i = 0; i < initdata; i++) {
     393:         err = rdwri(UIO_READ, ip, oneclick, ctob(1), off, UIO_SYSSPACE,
     394:                 IO_UNIT, &resid);
     395:         if (err || resid)
     396:             goto release;
     397:         mapseg5(netdata + i, 077406);
     398:         bcopy(oneclick, SEG5, ctob(1));
     399:         normalseg5();
     400:         off += ctob(1);
     401:     }
     402:     if (ex.a_data & 077) {
     403:         err = rdwri(UIO_READ, ip, oneclick, ex.a_data & 077, off,
     404:                 UIO_SYSSPACE, IO_UNIT, &resid);
     405:         if (err || resid) {
     406: release:        printf("%s err %d\n", NETNIX, err);
     407:             mfree(coremap, nettsize, nettext);
     408:             mfree(coremap, netdsize, netdata);
     409:             nettsize = netdsize = 0;
     410:             netdata = nettext = 0;
     411:             goto leave;
     412:         }
     413:         mapseg5(netdata + i, 077406);   /* i is set from above loop */
     414:         bcopy(oneclick, SEG5, ex.a_data & 077);
     415:         normalseg5();
     416:     }
     417:     for (i = 0, ap = SISA0, dp = SISD0; i < nettsize; i += stoc(1)) {
     418:         *ap++ = nettext + i;
     419:         *dp++ = ((stoc(1) - 1) << 8) | RO;
     420:     }
     421:     /* might have over run the length on the last one, patch it now */
     422:     if (i > nettsize)
     423:         *--dp -= ((i - nettsize) << 8);
     424:     for (i = 0, ap = SDSA0, dp = SDSD0; i < netdsize; i += stoc(1)) {
     425:         *ap++ = netdata + i;
     426:         *dp++ = ((stoc(1) - 1) << 8) | RW;
     427:     }
     428:     if (i > netdsize)
     429:         *--dp -= ((i - netdsize) << 8);
     430:     ret = 0;
     431: leave:  if (ip)
     432:         iput(ip);
     433:     u.u_error = 0;
     434:     return(ret);
     435: }
     436: #endif

#### Defined functions

bhinit defined in line 260; used 1 times

- in line 99

binit defined in line 275; used 1 times

- in line 100

cinit defined in line 301; used 1 times

- in line 95

main defined in line 55; never used
netinit defined in line 336; used 1 times

- in line 213

#### Defined variables

NETNIX defined in line 334; used 7 times

- in line 352-358(3), 364-373(3), 406

bpaddr defined in line 270; used 1 times

- in line 284

cmask defined in line 36; used 1 times

- in line 80

netdata defined in line 324; used 6 times

- in line 379, 397, 408-413(3), 425

netoff defined in line 35; used 16 times

- in line 213
- in /usr/src/sys/pdp/trap.c line 268-269(2)
- in /usr/src/sys/sys/uipc_syscalls.c line 59, 86, 109, 131, 199, 249, 382, 524, 586, 607, 640, 683, 719

securelevel defined in line 37; used 9 times

- in /usr/src/sys/sys/kern_sysctl.c line 229-235(3)
- in /usr/src/sys/sys/kern_time.c line 94
- in /usr/src/sys/sys/sys_inode.c line 655, 663, 682, 694
- in /usr/src/sys/sys/ufs_fio.c line 136

Last modified: 1997-09-27 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 1474 |