![[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 XNU] / XNU / bsd / dev / i386|
Return to unix_startup.c CVS log | Up to [Apple XNU] / XNU / bsd / dev / i386 |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*
23: * Copyright (c) 1992,7 NeXT Computer, Inc.
24: *
25: * Unix data structure initialization.
26: *
27: * HISTORY
28: *
29: * 11 Mar 1997 Eryk Vershen @ NeXT
30: * Modified from hppa version.
31: * 26 May 1992 ? at NeXT
32: * Created from 68k version.
33: */
34:
35: #include <mach_nbc.h>
36: #import <mach/mach_types.h>
37:
38: #import <vm/vm_kern.h>
39: #include <mach/vm_prot.h>
40:
41: #import <sys/param.h>
42: #import <sys/buf.h>
43: #import <sys/clist.h>
44: #import <sys/mbuf.h>
45: #import <sys/systm.h>
46: #import <sys/tty.h>
47: #import <bsd/dev/ppc/cons.h>
48:
49:
50: extern vm_map_t mb_map;
51: /*
52: * Declare these as initialized data so we can patch them.
53: */
54: int niobuf = 0;
55:
56: #ifdef NBUF
57: int nbuf = NBUF;
58: #else
59: int nbuf = 0;
60: #endif
61: #ifdef NMFSBUF
62: int nmfsbuf = NMFSBUF
63: #else
64: int nmfsbuf = 0;
65: #endif
66: #ifdef BUFPAGES
67: int bufpages = BUFPAGES;
68: #else
69: int bufpages = 0;
70: #endif
71:
72: int srv = 0; /* Flag indicates a server boot when set */
73: int ncl = 0;
74:
75: vm_map_t buffer_map;
76: vm_map_t bufferhdr_map;
77:
78:
79:
80:
81: void
82: bsd_startupearly()
83: {
84: vm_offset_t v, firstaddr, trash_offset;
85: vm_size_t size;
86: kern_return_t ret;
87:
88:
89: /*
90: * Since these pages are virtual-size pages (larger
91: * than physical page size), use only one page
92: * per buffer.
93: */
94: if (bufpages == 0) {
95: bufpages = atop(mem_size / 50);
96: }
97:
98: if (nbuf == 0) {
99: #if PRIVATE_BUFS
100: nbuf = 100;
101: #else PRIVATE_BUFS
102: /* Go for a 1-1 correspondence between the number of buffer
103: * headers and bufpages. Then add some extra (empty) buffer
104: * headers to aid clustering.
105: */
106: if ((nbuf = bufpages) < 16)
107: nbuf = 16;
108: nbuf += 64;
109: #endif PRIVATE_BUFS
110: }
111:
112: if (bufpages > nbuf * (MAXBSIZE / page_size))
113: bufpages = nbuf * (MAXBSIZE / page_size);
114: if (niobuf == 0) {
115: if ((niobuf = bufpages / (MAXPHYSIO / page_size)) > 1024)
116: niobuf = 1024;
117: if (niobuf < 32)
118: niobuf = 32;
119: }
120:
121: size = (nbuf + niobuf) * sizeof (struct buf);
122: size = round_page(size);
123:
124: ret = kmem_suballoc(kernel_map,
125: &firstaddr,
126: size,
127: FALSE,
128: TRUE,
129: &bufferhdr_map);
130:
131: if (ret != KERN_SUCCESS)
132: panic("Failed to create bufferhdr_map\n");
133:
134: if (kernel_memory_allocate(bufferhdr_map, &firstaddr, size,
135: 0,
136: KMA_HERE | KMA_KOBJECT) != KERN_SUCCESS)
137: panic("Failed to allocate bufferhdr_map\n");
138:
139: buf = (struct buf * )firstaddr;
140: bzero(buf,size);
141:
142:
143: /*
144: * Unless set at the boot command line, mfs gets no more than
145: * half of the system's bufs. Hack to prevent buf starvation
146: * and system hang.
147: */
148: if (nmfsbuf == 0)
149: nmfsbuf = nbuf / 2;
150:
151: if (mem_size > (64 * 1024 * 1024)) {
152: int scale;
153: extern u_long tcp_sendspace;
154: extern u_long tcp_recvspace;
155:
156: if ((nmbclusters = ncl) == 0) {
157: if ((nmbclusters = ((mem_size / 16) / MCLBYTES)) > 4096)
158: nmbclusters = 8192;
159: }
160: if ((scale = nmbclusters / NMBCLUSTERS) > 1) {
161: tcp_sendspace *= scale;
162: tcp_recvspace *= scale;
163:
164: if (tcp_sendspace > (32 * 1024))
165: tcp_sendspace = 32 * 1024;
166: if (tcp_recvspace > (32 * 1024))
167: tcp_recvspace = 32 * 1024;
168: }
169: }
170:
171: }
172:
173: void
174: bsd_bufferinit()
175: {
176: unsigned int i;
177: vm_offset_t v;
178: vm_size_t size;
179: kern_return_t ret;
180: vm_offset_t trash_offset, firstaddr;
181: int base, residual;
182:
183: cons.t_dev = makedev(12, 0);
184:
185:
186: bsd_startupearly();
187:
188: size = round_page(nbuf * MAXBSIZE) + (niobuf * MAXPHYSIO);
189: ret = kmem_suballoc(kernel_map,
190: &firstaddr,
191: size,
192: TRUE,
193: TRUE,
194: &buffer_map);
195:
196: if (ret != KERN_SUCCESS)
197: panic("Failed to create buffer_map\n");
198: buffers = firstaddr;
199: base = bufpages / nbuf;
200: residual = bufpages % nbuf;
201:
202: for (i = 0; i < nbuf; i++) {
203: vm_size_t thisbsize;
204: vm_offset_t curbuf;
205:
206: /*
207: * First <residual> buffers get (base+1) physical pages
208: * allocated for them. The rest get (base) physical pages.
209: *
210: * The rest of each buffer occupies virtual space,
211: * but has no physical memory allocated for it.
212: */
213:
214: thisbsize = page_size*(i < residual ? base+1 : base);
215: curbuf = (vm_offset_t)buffers + i * MAXBSIZE;
216: if (thisbsize) {
217:
218: ret = vm_map_enter(buffer_map, &curbuf, thisbsize,
219: (vm_offset_t) 0, FALSE,
220: VM_OBJECT_NULL, (vm_offset_t) 0, FALSE,
221: VM_PROT_DEFAULT, VM_PROT_ALL, VM_INHERIT_DEFAULT);
222: if (ret != KERN_SUCCESS) {
223: panic("Failed to allocate buffer cache pages\n");
224: }
225: ret = vm_map_wire(buffer_map, curbuf, curbuf+thisbsize, VM_PROT_READ | VM_PROT_WRITE, FALSE);
226: if (ret != KERN_SUCCESS)
227: panic("Failed to wire buffer cache pages\n");
228:
229: } else {
230: //printf("skipping allocating buffer page to buf %d\n",i);
231: }
232: }
233:
234:
235: #define MEG (1024*1024)
236: {
237: register int nbytes;
238:
239: nbytes = ptoa(bufpages);
240: printf("using %d buffers containing %d.%d%d megabytes of memory\n",
241: nbuf,
242: nbytes/MEG,
243: ((nbytes%MEG)*10)/MEG,
244: ((nbytes%(MEG/10))*100)/MEG);
245:
246: }
247:
248: ret = kmem_suballoc(kernel_map,
249: (vm_offset_t *)&mbutl,
250: (vm_size_t) (nmbclusters * MCLBYTES),
251: FALSE,
252: TRUE,
253: &mb_map);
254:
255: if (ret != KERN_SUCCESS)
256: panic("Failed to allocate mb_map\n");
257: /* embutl = ((unsigned char *)mbutl + (nmbclusters * MCLBYTES)); */
258:
259: /*
260: * Set up buffers, so they can be used to read disk labels.
261: */
262: bufinit();
263: }
264:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.