一份古老的C代码

ling830

chdir  /usr/sys/ken

1. # cat main.c
   
2. #
   
3. #include "../param.h"
   
4. #include "../user.h"
   
5. #include "../systm.h"
   
6. #include "../proc.h"
   
7. #include "../text.h"
   
8. #include "../inode.h"
   
9. #include "../seg.h"
   
10. 
    
11. #define CLOCK1  0177546
    
12. #define CLOCK2  0172540
    
13. /*
    
14. * Icode is the octal bootstrap
    
15. * program executed in user mode
    
16. * to bring up the system.
    
17. */
    
18. int     icode[]
    
19. {
    
20.         0104413,        /* sys exec; init; initp */
    
21.         0000014,
    
22.         0000010,
    
23.         0000777,        /* br . */
    
24.         0000014,        /* initp: init; 0 */
    
25.         0000000,
    
26.         0062457,        /* init: </etc/init\0> */
    
27.         0061564,
    
28.         0064457,
    
29.         0064556,
    
30.         0000164,
    
31. };
    
32. 
    
33. /*
    
34. * Initialization code.
    
35. * Called from m40.s or m45.s as
    
36. * soon as a stack and segmentation
    
37. * have been established.
    
38. * Functions:
    
39. *      clear and free user core
    
40. *      find which clock is configured
    
41. *      hand craft 0th process
    
42. *      call all initialization routines
    
43. *      fork - process 0 to schedule
    
44. *           - process 1 execute bootstrap
    
45. *
    
46. * panic: no clock -- neither clock responds
    
47. * loop at loc 6 in user mode -- /etc/init
    
48. *      cannot be executed.
    
49. */
    
50. main()
    
51. {
    
52.         extern schar;
    
53.         register i, *p;
    
54. 
    
55.         /*
    
56.          * zero and free all of core
    
57.          */
    
58. 
    
59.         updlock = 0;
    
60.         i = *ka6 + USIZE;
    
61.         UISD->r[0] = 077406;
    
62.         for(;;) {
    
63.                 UISA->r[0] = i;
    
64.                 if(fuibyte(0) < 0)
    
65.                         break;
    
66.                 clearseg(i);
    
67.                 maxmem++;
    
68.                 mfree(coremap, 1, i);
    
69.                 i++;
    
70.         }
    
71.         if(cputype == 70)
    
72.         for(i=0; i<62; i=+2) {
    
73.                 UBMAP->r[i] = i<<12;
    
74.                 UBMAP->r[i+1] = 0;
    
75.         }
    
76.         printf("mem = %l\n", maxmem*5/16);
    
77.         printf("RESTRICTED RIGHTS\n\n");
    
78.         printf("Use, duplication or disclosure is subject to\n");
    
79.         printf("restrictions stated in Contract with Western\n");
    
80.         printf("Electric Company, Inc.\n");
    
81. 
    
82.         maxmem = min(maxmem, MAXMEM);
    
83.         mfree(swapmap, nswap, swplo);
    
84. 
    
85.         /*
    
86.          * determine clock
    
87.          */
    
88. 
    
89.         UISA->r[7] = ka6[1]; /* io segment */
    
90.         UISD->r[7] = 077406;
    
91.         lks = CLOCK1;
    
92.         if(fuiword(lks) == -1) {
    
93.                 lks = CLOCK2;
    
94.                 if(fuiword(lks) == -1)
    
95.                         panic("no clock");
    
96.         }
    
97. 
    
98.         /*
    
99.          * set up system process
    
100.          */
     
101. 
     
102.         proc[0].p_addr = *ka6;
     
103.         proc[0].p_size = USIZE;
     
104.         proc[0].p_stat = SRUN;
     
105.         proc[0].p_flag =| SLOAD|SSYS;
     
106.         u.u_procp = &proc[0];
     
107. 
     
108.         /*
     
109.          * set up 'known' i-nodes
     
110.          */
     
111. 
     
112.         *lks = 0115;
     
113.         cinit();
     
114.         binit();
     
115.         iinit();
     
116.         rootdir = iget(rootdev, ROOTINO);
     
117.         rootdir->i_flag =& ~ILOCK;
     
118.         u.u_cdir = iget(rootdev, ROOTINO);
     
119.         u.u_cdir->i_flag =& ~ILOCK;
     
120. 
     
121.         /*
     
122.          * make init process
     
123.          * enter scheduling loop
     
124.          * with system process
     
125.          */
     
126. 
     
127.         if(newproc()) {
     
128.                 expand(USIZE+1);
     
129.                 estabur(0, 1, 0, 0);
     
130.                 copyout(icode, 0, sizeof icode);
     
131.                 /*
     
132.                  * Return goes to loc. 0 of user init
     
133.                  * code just copied out.
     
134.                  */
     
135.                 return;
     
136.         }
     
137.         sched();
     
138. }
     
139. 
     
140. /*
     
141. * Load the user hardware segmentation
     
142. * registers from the software prototype.
     
143. * The software registers must have
     
144. * been setup prior by estabur.
     
145. */
     
146. sureg()
     
147. {
     
148.         register *up, *rp, a;
     
149. 
     
150.         a = u.u_procp->p_addr;
     
151.         up = &u.u_uisa[16];
     
152.         rp = &UISA->r[16];
     
153.         if(cputype == 40) {
     
154.                 up =- 8;
     
155.                 rp =- 8;
     
156.         }
     
157.         while(rp > &UISA->r[0])
     
158.                 *--rp = *--up + a;
     
159.         if((up=u.u_procp->p_textp) != NULL)
     
160.                 a =- up->x_caddr;
     
161.         up = &u.u_uisd[16];
     
162.         rp = &UISD->r[16];
     
163.         if(cputype == 40) {
     
164.                 up =- 8;
     
165.                 rp =- 8;
     
166.         }
     
167.         while(rp > &UISD->r[0]) {
     
168.                 *--rp = *--up;
     
169.                 if((*rp & WO) == 0)
     
170.                         rp[(UISA-UISD)/2] =- a;
     
171.         }
     
172. }
     
173. 
     
174. /*
     
175. * Set up software prototype segmentation
     
176. * registers to implement the 3 pseudo
     
177. * text,data,stack segment sizes passed
     
178. * as arguments.
     
179. * The argument sep specifies if the
     
180. * text and data+stack segments are to
     
181. * be separated.
     
182. */
     
183. estabur(nt, nd, ns, sep)
     
184. {
     
185.         register a, *ap, *dp;
     
186. 
     
187.         if(sep) {
     
188.                 if(cputype == 40)
     
189.                         goto err;
     
190.                 if(nseg(nt) > 8 || nseg(nd)+nseg(ns) > 8)
     
191.                         goto err;
     
192.         } else
     
193.                 if(nseg(nt)+nseg(nd)+nseg(ns) > 8)
     
194.                         goto err;
     
195.         if(nt+nd+ns+USIZE > maxmem)
     
196.                 goto err;
     
197.         a = 0;
     
198.         ap = &u.u_uisa[0];
     
199.         dp = &u.u_uisd[0];
     
200.         while(nt >= 128) {
     
201.                 *dp++ = (127<<8) | RO;
     
202.                 *ap++ = a;
     
203.                 a =+ 128;
     
204.                 nt =- 128;
     
205.         }
     
206.         if(nt) {
     
207.                 *dp++ = ((nt-1)<<8) | RO;
     
208.                 *ap++ = a;
     
209.         }
     
210.         if(sep)
     
211.         while(ap < &u.u_uisa[8]) {
     
212.                 *ap++ = 0;
     
213.                 *dp++ = 0;
     
214.         }
     
215.         a = USIZE;
     
216.         while(nd >= 128) {
     
217.                 *dp++ = (127<<8) | RW;
     
218.                 *ap++ = a;
     
219.                 a =+ 128;
     
220.                 nd =- 128;
     
221.         }
     
222.         if(nd) {
     
223.                 *dp++ = ((nd-1)<<8) | RW;
     
224.                 *ap++ = a;
     
225.                 a =+ nd;
     
226.         }
     
227.         while(ap < &u.u_uisa[8]) {
     
228.                 *dp++ = 0;
     
229.                 *ap++ = 0;
     
230.         }
     
231.         if(sep)
     
232.         while(ap < &u.u_uisa[16]) {
     
233.                 *dp++ = 0;
     
234.                 *ap++ = 0;
     
235.         }
     
236.         a =+ ns;
     
237.         while(ns >= 128) {
     
238.                 a =- 128;
     
239.                 ns =- 128;
     
240.                 *--dp = (127<<8) | RW;
     
241.                 *--ap = a;
     
242.         }
     
243.         if(ns) {
     
244.                 *--dp = ((128-ns)<<8) | RW | ED;
     
245.                 *--ap = a-128;
     
246.         }
     
247.         if(!sep) {
     
248.                 ap = &u.u_uisa[0];
     
249.                 dp = &u.u_uisa[8];
     
250.                 while(ap < &u.u_uisa[8])
     
251.                         *dp++ = *ap++;
     
252.                 ap = &u.u_uisd[0];
     
253.                 dp = &u.u_uisd[8];
     
254.                 while(ap < &u.u_uisd[8])
     
255.                         *dp++ = *ap++;
     
256.         }
     
257.         sureg();
     
258.         return(0);
     
259. 
     
260. err:
     
261.         u.u_error = ENOMEM;
     
262.         return(-1);
     
263. }
     
264. 
     
265. /*
     
266. * Return the arg/128 rounded up.
     
267. */
     
268. nseg(n)
     
269. {
     
270. 
     
271.         return((n+127)>>7);
     
272. }
     
273. #

复制代码

FishC

这是一份非常经典的 Unix V6 内核（大约 1975 年）的 main.c 文件，来自贝尔实验室。它负责计算机启动后 第一个用户态进程的创建 和系统初始化。下面用通俗的方式解释核心逻辑：

• 清除用户核心：循环扫描所有未被内核占用的内存页，用 clearseg 清零，并调用 mfree 归还给空闲内存管理表（coremap）。
• 检测时钟：检查两个可能的时钟地址（CLOCK1 和 CLOCK2），如果都失败则调用 panic("no clock")。
• 建立 0 号进程（系统进程）：手动设置 proc 结构，赋予 SRUN（就绪）状态和 SSYS（系统进程）标志。
• 初始化文件系统：调用 cinit()（字符设备）、binit()（块设备）、iinit()（i 节点缓存），然后通过 iget 获取根目录（rootdir）。
• 创建 init 进程（1 号进程）：调用 newproc() 复制进程，如果成功（返回非零），则扩展用户空间、设置用户段寄存器、将 icode 引导程序复制到进程地址 0 处，然后 return 会跳转到该引导程序，最终执行 /etc/init。
• 调度循环：如果创建失败，则父进程（0 号进程）进入 sched() 循环，作为系统调度器永远运行。
  

1. int icode { ... }

复制代码

是一个硬编码的引导代码（八进制），它执行 exec("/etc/init") 来启动用户态的管理进程。整个流程就是操作系统从硬件启动到多任务运行的 关键桥梁。

如果你对其中某个细节（如内存分段、时钟检测）有疑问，欢迎继续提问。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。