![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to unix_startup.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / machdep / ppc|
Return to unix_startup.c CVS log | Up to [Apple Darwin 0.x] / kernel / machdep / ppc |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /*
26: * Copyright (c) 1992,7 NeXT Computer, Inc.
27: *
28: * Unix data structure initialization.
29: *
30: * HISTORY
31: *
32: * 11 Mar 1997 Eryk Vershen @ NeXT
33: * Modified from hppa version.
34: * 26 May 1992 ? at NeXT
35: * Created from 68k version.
36: */
37:
38: #include <mach_nbc.h>
39: #import <mach/mach_types.h>
40:
41: #import <vm/vm_kern.h>
42: #import <vm/vm_page.h>
43:
44: #import <kern/time_stamp.h>
45:
46: #import <sys/param.h>
47: #import <sys/buf.h>
48: #import <sys/callout.h>
49: #import <sys/clist.h>
50: #import <sys/mbuf.h>
51: #import <sys/systm.h>
52: #import <sys/tty.h>
53: #import <bsd/dev/ppc/cons.h>
54:
55: /*
56: * Declare these as initialized data so we can patch them.
57: */
58: int niobuf = 0;
59:
60: #ifdef NBUF
61: int nbuf = NBUF;
62: #else
63: int nbuf = 0;
64: #endif
65: #ifdef NMFSBUF
66: int nmfsbuf = NMFSBUF
67: #else
68: int nmfsbuf = 0;
69: #endif
70: #ifdef BUFPAGES
71: int bufpages = BUFPAGES;
72: #else
73: int bufpages = 0;
74: #endif
75: int show_space = 0;
76: int srv = 0; /* Flag indicates a server boot when set */
77: int ncl = 0;
78: vm_map_t buffer_map;
79:
80: /*
81: * Machine-dependent startup code
82: */
83: /*
84: * Machine-dependent early startup code
85: */
86:
87: #define valloc(name, type, num) \
88: (name) = (type *)(v); (v) = (vm_offset_t)((name)+(num))
89:
90: #define valloclim(name, type, num, lim) \
91: (name) = (type *)(v); (v) = (vm_offset_t)((lim) = ((name)+(num)));
92:
93: vm_size_t
94: buffer_map_sizer(void)
95: {
96: /*
97: * Since these pages are virtual-size pages (larger
98: * than physical page size), use only one page
99: * per buffer.
100: */
101: if (bufpages == 0) {
102: #if MACH_NBC
103: if (srv) {
104: if (mem_size > (64 * 1024 * 1024)) {
105: bufpages = atop(mem_size) / 2;
106:
107: if ((mem_size - ptoa(bufpages)) < (64 * 1024 * 1024))
108: bufpages = atop(mem_size - (64 * 1024 * 1024));
109: } else {
110: bufpages = atop(mem_size / 100);
111: bufpages = bufpages * 3; /* 3% */
112: }
113: } else {
114: bufpages = atop(mem_size / 100);
115: bufpages = bufpages * 3; /* 3% */
116: }
117: #else
118: bufpages = atop(mem_size / 20) & ~1; /* force even */
119:
120: #endif /* MACH_NBC */
121: }
122:
123: if (nbuf == 0) {
124: #if PRIVATE_BUFS
125: nbuf = 100;
126: #else PRIVATE_BUFS
127: /* Go for a 1-1 correspondence between the number of buffer
128: * headers and bufpages. Then add some extra (empty) buffer
129: * headers to aid clustering.
130: */
131: if (bufpages > 60000)
132: bufpages = 60000;
133: if ((nbuf = bufpages) < 16)
134: nbuf = 16;
135: nbuf += 64;
136: #endif PRIVATE_BUFS
137: } else if (nbuf > 60000)
138: nbuf = 60000;
139:
140: if (bufpages > nbuf * (MAXBSIZE / page_size))
141: bufpages = nbuf * (MAXBSIZE / page_size);
142:
143: if (niobuf == 0) {
144: niobuf = bufpages / (MAXPHYSIO / page_size);
145: if (niobuf < 128)
146: niobuf = 128;
147: }
148: if (niobuf > 4096)
149: niobuf = 4096;
150:
151: return (round_page(((vm_size_t)nbuf * MAXBSIZE)) + ((vm_size_t)niobuf * MAXPHYSIO));
152: }
153:
154: void
155: startup_early(vm_offset_t *first_avail)
156: {
157: vm_offset_t v;
158:
159: v = *first_avail;
160: (void) buffer_map_sizer();
161:
162: valloc(buf, struct buf, nbuf + niobuf);
163:
164: /*
165: * Unless set at the boot command line, mfs gets no more than
166: * half of the system's bufs. Hack to prevent buf starvation
167: * and system hang.
168: */
169: if (nmfsbuf == 0)
170: nmfsbuf = nbuf / 2;
171:
172: /*
173: * Clear space allocated thus far, and make r/w entries
174: * for the space in the kernel map.
175: */
176:
177: bzero(*first_avail, v - *first_avail);
178: *first_avail = v;
179:
180: if ((mem_size > (64 * 1024 * 1024)) || ncl) {
181: int scale;
182: extern u_long tcp_sendspace;
183: extern u_long tcp_recvspace;
184:
185: if ((nmbclusters = ncl) == 0) {
186: if ((nmbclusters = ((mem_size / 16) / MCLBYTES)) > 8192)
187: nmbclusters = 8192;
188: }
189: if ((scale = nmbclusters / NMBCLUSTERS) > 1) {
190: tcp_sendspace *= scale;
191: tcp_recvspace *= scale;
192:
193: if (tcp_sendspace > (32 * 1024))
194: tcp_sendspace = 32 * 1024;
195: if (tcp_recvspace > (32 * 1024))
196: tcp_recvspace = 32 * 1024;
197: }
198: }
199: }
200:
201:
202: void
203: startup(
204: vm_offset_t firstaddr
205: )
206: {
207: unsigned int i;
208: vm_size_t map_size;
209: kern_return_t ret;
210: vm_offset_t buffer_max;
211: int base, residual;
212: extern int vm_page_free_count;
213:
214: cons.t_dev = makedev(12, 0);
215:
216: /*
217: * Good {morning,afternoon,evening,night}.
218: */
219: panic_init();
220:
221: #define MEG (1024*1024)
222: printf("physical memory = %d.%d%d megabytes.\n",
223: mem_size/MEG,
224: ((mem_size%MEG)*10)/MEG,
225: ((mem_size%(MEG/10))*100)/MEG);
226:
227: /*
228: * Allocate space for system data structures.
229: * The first available real memory address is in "firstaddr".
230: * The first available kernel virtual address is in "v".
231: * As pages of kernel virtual memory are allocated, "v" is incremented.
232: * As pages of memory are allocated and cleared,
233: * "firstaddr" is incremented.
234: * An index into the kernel page table corresponding to the
235: * virtual memory address maintained in "v" is kept in "mapaddr".
236: */
237:
238: /*
239: * Since the virtual memory system has already been set up,
240: * we cannot bypass it to allocate memory as the old code
241: * DOES. we therefore make two passes over the table
242: * allocation code. The first pass merely calculates the
243: * size needed for the various data structures. The
244: * second pass allocates the memory and then sets the
245: * actual addresses. The code must not change any of
246: * the allocated sizes between the two passes.
247: */
248: firstaddr = round_page(firstaddr);
249: map_size = buffer_map_sizer();
250:
251: /*
252: * Between the following find, and the next one below
253: * we can't cause any other memory to be allocated. Since
254: * below is the first place we really need an object, it
255: * will cause the object zone to be expanded, and will
256: * use our memory! Therefore we allocate a dummy object
257: * here. This is all a hack of course.
258: */
259: ret = vm_map_find(kernel_map, vm_object_allocate(0), (vm_offset_t) 0,
260: &firstaddr, map_size, TRUE);
261: ASSERT(ret == KERN_SUCCESS);
262: vm_map_remove(kernel_map, firstaddr, firstaddr + map_size);
263:
264: /*
265: * Now allocate buffers proper. They are different than the above
266: * in that they usually occupy more virtual memory than physical.
267: */
268: buffers = (void *)firstaddr;
269: base = bufpages / nbuf;
270: residual = bufpages % nbuf;
271:
272: /*
273: * Allocate virtual memory for buffer pool.
274: */
275: buffer_map = kmem_suballoc(kernel_map,
276: &firstaddr, &buffer_max, map_size, TRUE);
277: ret = vm_map_find(buffer_map,
278: vm_object_allocate(map_size), (vm_offset_t) 0,
279: &firstaddr, map_size, FALSE);
280:
281: ASSERT(ret == KERN_SUCCESS);
282: ASSERT(page_size == CLBYTES);
283:
284: for (i = 0; i < nbuf; i++) {
285: vm_size_t thisbsize;
286: vm_offset_t curbuf;
287:
288: /*
289: * First <residual> buffers get (base+1) physical pages
290: * allocated for them. The rest get (base) physical pages.
291: *
292: * The rest of each buffer occupies virtual space,
293: * but has no physical memory allocated for it.
294: */
295:
296: thisbsize = page_size*(i < residual ? base+1 : base);
297: curbuf = (vm_offset_t)buffers + i * MAXBSIZE;
298: vm_map_pageable(buffer_map, curbuf, curbuf+thisbsize, FALSE);
299: }
300:
301: {
302: register int nbytes;
303:
304: nbytes = ptoa(bufpages);
305: printf("using %d buffers containing %d.%d%d megabytes of memory\n",
306: nbuf,
307: nbytes/MEG,
308: ((nbytes%MEG)*10)/MEG,
309: ((nbytes%(MEG/10))*100)/MEG);
310:
311: nbytes = ptoa(vm_page_free_count);
312: printf("available memory = %d.%d%d megabytes. vm_page_free_count = %x\n",
313: nbytes/MEG,
314: ((nbytes%MEG)*10)/MEG,
315: ((nbytes%(MEG/10))*100)/MEG,
316: vm_page_free_count);
317: }
318:
319: /*
320: * Initialize memory allocator and swap
321: * and user page table maps.
322: */
323: mb_map = kmem_suballoc(kernel_map,
324: (vm_offset_t *) &mbutl,
325: (vm_offset_t *) &embutl,
326: (vm_size_t) (nmbclusters * MCLBYTES),
327: FALSE);
328:
329: /*
330: * Set up buffers, so they can be used to read disk labels.
331: */
332: bufinit();
333: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.