int     lksp[]
{
        0177546,   /* KW11-L line clock */
        0172540,   /* KW11-P programmable clock */
        0          /* sentinel */
};

The PDP-11 could have different clock hardware. This array lists possible clock register addresses (in octal). The kernel probes each until one responds.

int     icode[]
{
        0104413,   /* sys exec; initp; initarg */
        0000014,
        0000010,
        0000777,
        0000014,
        0000000,
        0062457,   /* /etc/init\0 */
        0061564,
        0064457,
        0064556,
        0000164,
};

This is PDP-11 machine code that calls exec("/etc/init"). It's copied into the address space of process 1. When process 1 starts executing, it runs this code, which replaces itself with /etc/init.

The string "/etc/init" is encoded in the octal words at the end:

• 0062457 = "/e"
• 0061564 = "tc"
• 0064457 = "/i"
• 0064556 = "ni"
• 0000164 = "t\0"

        updlock = 0;
        UISA->r[0] = KISA->r[6] + USIZE;
        UISD->r[0] = 077406;
        for(; fubyte(0) >= 0; UISA->r[0]++) {
                clearseg(UISA->r[0]);
                maxmem++;
                mfree(coremap, 1, UISA->r[0]);
        }
        printf("mem = %l\n", maxmem*10/32);

This probes memory by trying to read from increasingly higher addresses. fubyte(0) returns -1 when it hits non-existent memory.

• UISA/UISD = User Instruction Space Address/Descriptor registers (MMU)
• KISA = Kernel Instruction Space Address registers
• clearseg() = zero out a 64-byte segment
• mfree() = add segment to free memory pool

The printf shows something like "mem = 64530" — memory in 32-byte units.

        UISA->r[7] = KISA->r[7];
        UISD->r[7] = 077406;
        for(p=lksp;; p++) {
                if(*p == 0)
                        panic("no clock");
                if(fuword(*p) != -1) {
                        lks = *p;
                        break;
                }
        }

Probe the clock addresses in lksp[]. fuword() reads a word from user space; returns -1 if the address doesn't exist. First valid address becomes lks.

If no clock is found: panic("no clock") — the system halts.

        proc[0].p_addr = KISA->r[6];
        proc[0].p_size = USIZE;
        proc[0].p_stat = SRUN;
        proc[0].p_flag =| SLOAD|SSYS;
        u.u_procp = &proc[0];

Create the first process entry. Note =|= — this is pre-ANSI compound assignment (modern C uses |=).

• proc[0] = first slot in process table
• SRUN = runnable state
• SLOAD = in memory (not swapped)
• SSYS = system process (can't be swapped)
• u = the "user structure" — per-process kernel data

        sureg();
        *lks = 0115;
        cinit();
        binit();
        iinit();
        rootdir = iget(rootdev, ROOTINO);
        rootdir->i_flag =& ~ILOCK;
        u.u_cdir = iget(rootdev, ROOTINO);
        u.u_cdir->i_flag =& ~ILOCK;

• sureg() = set up user-space memory mapping
• *lks = 0115 = start the clock (magic constant enables interrupts)
• cinit() = character device init
• binit() = block device buffer init
• iinit() = inode/superblock init
• iget(rootdev, ROOTINO) = get the root directory inode

The =&= is another pre-ANSI operator (modern: &=).

        if(newproc()) {
                expand(USIZE+1);
                u.u_uisa[0] = USIZE;
                u.u_uisd[0] = 6;
                sureg();
                copyout(icode, 0, 30);
                return;
        }
        sched();
}

newproc() is fork. It returns:

• 0 in the parent (process 0)
• 1 in the child (process 1)

Child path (process 1):

• expand() = allocate more memory
• copyout(icode, 0, 30) = copy the init program to address 0
• return = start executing at address 0 → runs /etc/init

Parent path (process 0):

• sched() = become the scheduler, never returns