![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to Config.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / driverkit / Config|
Return to Config.c CVS log | Up to [Apple Darwin 0.x] / driverkit / Config |
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: /* Copyright (c) 1991 NeXT Computer, Inc. All rights reserved.
25: *
26: * Config.c - Config server.
27: *
28: * HISTORY
29: * 11-Apr-91 Doug Mitchell at NeXT
30: * Created.
31: */
32:
33: #import <bsd/sys/types.h>
34: #import <bsd/libc.h>
35: #import <mach/mach_types.h>
36: #import <driverkit/userConfigServer.h>
37: #import <driverkit/generalFuncs.h>
38: #import "ConfigPrivate.h"
39: #import "ConfigUtils.h"
40: #import "ConfigScan.h"
41: #import <mach/kern_return.h>
42: #import <mach/mach.h>
43: #import <servers/netname.h>
44: #import <mach/message.h>
45: #import <mach/mach_error.h>
46: #import <mach/cthreads.h>
47: #import <kernserv/queue.h>
48: #import <mach/notify.h>
49: #import <syslog.h>
50: #ifdef DEBUG
51: #import "ConfigUfs.h"
52: #endif DEBUG
53:
54: /*
55: * prototypes for private functions.
56: */
57: static void usage(char **argv);
58: static void server_loop();
59: boolean_t Config_server(msg_header_t *inp, msg_header_t *outp);
60: static void config_port_death(msg_header_t *inp);
61:
62: /*
63: * Static variables.
64: */
65: static port_t config_port; // we advertise this for all takers
66: static port_set_name_t config_port_set; // the set on which we listen
67: port_t device_master_port; // used to communicate with kernel
68: port_t notify_port; // that's ours
69: static boolean_t config_in_progress; // prevents hazardous operations
70: // during initial config
71: queue_head_t driver_list; // list of driver_entry_t's
72: mutex_t driver_list_lock; // protects driver_list during initial
73: // config
74: condition_t driver_list_cond;
75: boolean_t driver_list_locked;
76:
77: extern port_t device_master_self();
78:
79: /*
80: * User-specified variables.
81: */
82: int verbose = 0;
83:
84: void main(int argc, char **argv)
85: {
86: int arg;
87: kern_return_t krtn;
88: cthread_t server_thread;
89:
90: if(argc < 1)
91: usage(argv);
92: for(arg=1; arg<argc; arg++) {
93: switch(argv[arg][0]) {
94: case 'v':
95: verbose++;
96: break;
97: default:
98: usage(argv);
99: }
100: }
101:
102: #ifdef DDM_DEBUG
103: IOInitDDM(200, "ConfigXpr");
104: IOSetDDMMask(XPR_CONFIG_INDEX,
105: XPR_CONFIG | XPR_SERVER | XPR_COMMON | XPR_ERR);
106: #endif DDM_DEBUG
107:
108: /*
109: * Initialize global state.
110: */
111: queue_init(&driver_list);
112: driver_list_lock = mutex_alloc();
113: driver_list_cond = condition_alloc();
114: config_in_progress = TRUE;
115:
116: /*
117: * Set up various ports and start the server thread before initial
118: * autoconfig so device drivers have a place to send messages.
119: *
120: * config_port is how we advertise our exported services to all.
121: */
122: krtn = port_allocate(task_self(), &config_port);
123: if(krtn) {
124: mach_error("port_allocate", krtn);
125: exit(1);
126: }
127: krtn = port_set_allocate(task_self(), &config_port_set);
128: if(krtn) {
129: mach_error("port_set_allocate", krtn);
130: exit(1);
131: }
132: krtn = port_set_add(task_self(), config_port_set, config_port);
133: if(krtn) {
134: mach_error("port_set_add", krtn);
135: exit(1);
136: }
137:
138: /*
139: * we get port death notification on notify_port.
140: */
141: krtn = port_allocate(task_self(), ¬ify_port);
142: if(krtn) {
143: mach_error("port_allocate", krtn);
144: exit(1);
145: }
146: krtn = task_set_notify_port(task_self(), notify_port);
147: if(krtn) {
148: mach_error("task_set_notify_port", krtn);
149: exit(1);
150: }
151: krtn = port_set_add(task_self(), config_port_set, notify_port);
152: if(krtn) {
153: mach_error("port_set_add", krtn);
154: exit(1);
155: }
156: krtn = netname_check_in(name_server_port,
157: CONFIG_SERVER_NAME,
158: task_self(),
159: config_port);
160: if(krtn) {
161: mach_error("netname_check_in", krtn);
162: exit(1);
163: }
164: device_master_port = device_master_self();
165: if(device_master_port == PORT_NULL) {
166: syslog(LOG_ERR, "Config: Can't get device_master_port\n");
167: exit(1);
168: }
169:
170: server_thread = cthread_fork((cthread_fn_t)server_loop, (any_t)0);
171:
172: /*
173: * Do initial autoconfig.
174: */
175: config_scan(SCAN_ALL, IO_NULL_SLOT_ID, IO_NULL_DEVICE_TYPE);
176:
177: /*
178: * We're done; let the server_thread take it from here.
179: */
180: config_in_progress = FALSE;
181: cthread_exit(0);
182: }
183:
184: static void usage(char **argv)
185: {
186: printf("usage: %s [options]\n", argv[0]);
187: printf("Options:\n");
188: printf("\tv verbose mode\n");
189: exit(1);
190: }
191:
192:
193: /*
194: * Main server loop. This thread starts running before autoconfiguration
195: * takes place to allow servicing of IORegisterDriver() calls during
196: * autoconfig. The config_in_progress flag prevents us from servicing any
197: * hazardous calls during this time - like IORescanDriver(). Such calls will
198: * return a IO_CNF_BUSY status.
199: */
200: static void server_loop()
201: {
202: msg_header_t *inp, *outp;
203: kern_return_t krtn;
204: boolean_t return_msg;
205:
206: inp = (msg_header_t *)malloc(MSG_SIZE_MAX);
207: outp = (msg_header_t *)malloc(MSG_SIZE_MAX);
208: while (1) {
209: inp->msg_local_port = config_port_set;
210: inp->msg_size = MSG_SIZE_MAX;
211: krtn = msg_receive(inp, MSG_OPTION_NONE, 0);
212: if(krtn) {
213: mach_error("msg_receive", krtn);
214: continue;
215: }
216: xpr_server("msg_id %d received\n", inp->msg_id, 2,3,4,5);
217: return_msg = FALSE;
218: if(inp->msg_local_port == config_port) {
219: Config_server(inp, outp);
220: return_msg = TRUE;
221: }
222: else if(inp->msg_local_port == notify_port) {
223: config_port_death(inp);
224: }
225: else {
226: printf("Config server_loop: Bogus msg_local_port\n");
227: }
228:
229: if(return_msg) {
230: /*
231: * Return message to client. We don't deal with
232: * backed up port queues for now.
233: */
234: krtn = msg_send(outp, SEND_TIMEOUT, 0);
235: if(krtn) {
236: mach_error("msg_receive", krtn);
237: continue;
238: }
239: }
240: }
241: /* NOT REACHED */
242: }
243:
244: /*
245: * Handle port death notification. The only ports we're interested in are
246: * driver_ports.
247: */
248: static void config_port_death(msg_header_t *inp)
249: {
250: notification_t *msgp = (notification_t *)inp;
251: driver_entry_t *driver_entry;
252: queue_head_t dev_list;
253: dev_entry_t *dev_entry;
254: IOReturn drtn;
255:
256: /*
257: * FIXME: use NOTIFY_PORT_DESTOYED??
258: */
259: if(inp->msg_id != NOTIFY_PORT_DELETED) {
260: xpr_server("config_port_death: weird msg_id (%d)\n",
261: inp->msg_id, 2,3,4,5);
262: return;
263: }
264: xpr_server("config_port_death: port %d\n", msgp->notify_port, 2,3,4,5);
265: get_driver_list_lock();
266: driver_entry = get_driver_entry(
267: SK_DRIVER_PORT,
268: msgp->notify_port,
269: DEV_NUM_NULL,
270: FID_NULL,
271: IO_NULL_DEVICE_TYPE,
272: IO_NULL_SLOT_ID,
273: NULL);
274: release_driver_list_lock();
275: if(driver_entry == NULL) {
276: xpr_server("config_port_death: not sig port\n",
277: 1,2,3,4,5);
278: return;
279: }
280: driver_entry->driver_port = PORT_NULL;
281:
282: /*
283: * Shut down all devices associated with this driver.
284: * First, move all of this driver's dev_entry's to our local
285: * queue.
286: */
287: queue_init(&dev_list);
288: while(!queue_empty(&driver_entry->dev_list)) {
289: dev_entry = (dev_entry_t *)
290: queue_first(&driver_entry->dev_list);
291: queue_remove(&driver_entry->dev_list,
292: dev_entry,
293: dev_entry_t *,
294: link);
295: queue_enter(&dev_list,
296: dev_entry,
297: dev_entry_t *,
298: link);
299: }
300:
301: /*
302: * For each device, destroy the associated device port, then
303: * create a new one for the same physical device.
304: */
305: while(!queue_empty(&dev_list)) {
306: dev_entry = (dev_entry_t *)queue_first(&dev_list);
307: queue_remove(&dev_list,
308: dev_entry,
309: dev_entry_t *,
310: link);
311: if(dev_entry->dev_port) {
312: drtn = _IODestroyDevicePort(device_master_port,
313: dev_entry->dev_port);
314: if(drtn) {
315: xpr_common("config_port_death: "
316: "_IODestroyDevicePort() returned %s\n",
317: IOFindNameForValue(drtn, dev_returns),
318: 2,3,4,5);
319: /* but keep going... */
320: }
321: }
322: create_dev_entry(driver_entry,
323: dev_entry->dev_number,
324: dev_entry->dev_type,
325: dev_entry->slot_id);
326:
327: /*
328: * Our dev_entry is a useless copy...
329: */
330: free(dev_entry);
331: }
332:
333: /*
334: * Now restart the driver.
335: */
336: xpr_server("config_port_death: restarting driver %s\n",
337: IOCopyString(driver_entry->filename), 2,3,4,5);
338: if(exec_driver(driver_entry) != IO_CNF_SUCCESS) {
339: /*
340: * Couldn't exec this driver. Remove from driver_list.
341: */
342: get_driver_list_lock();
343: free_driver_entry(driver_entry);
344: release_driver_list_lock();
345: }
346: }
347:
348: /*
349: * These functions are called out from the mig-generated Config_server.
350: */
351:
352: /*
353: * Each driver which we exec calls this exactly once. The purpose is to
354: * register a driver_port for the driver's driver_entry so we can detect the
355: * death of the driver.
356: */
357: IOConfigReturn _IORegisterDriver(
358: port_t dev_config_port,
359: port_t driver_sig_port,
360: port_t driver_port)
361: {
362: driver_entry_t *driver_entry;
363: IOConfigReturn rtn = IO_CNF_SUCCESS;
364:
365: xpr_server("driver_register driver_port %d\n", driver_port, 2,3,4,5);
366: get_driver_list_lock();
367:
368: /*
369: * Make sure that this is a new registration for a device we
370: * know about.
371: */
372: driver_entry = get_driver_entry(
373: SK_SIG_PORT,
374: driver_sig_port,
375: DEV_NUM_NULL,
376: FID_NULL,
377: IO_NULL_DEVICE_TYPE,
378: IO_NULL_SLOT_ID,
379: NULL);
380: if(driver_entry == NULL) {
381: xpr_server("device_register: BAD driver_sig_port\n",
382: 1,2,3,4,5);
383: rtn = IO_CNF_NOT_REGISTERED;
384: goto done;
385: }
386: if(driver_entry->driver_port != PORT_NULL) {
387: xpr_server("device_register: REDUNDANT REGISTRATION\n",
388: 1,2,3,4,5);
389: rtn = IO_CNF_REGISTERED;
390: goto done;
391: }
392: driver_entry->driver_port = driver_port;
393: done:
394: release_driver_list_lock();
395: return rtn;
396: }
397:
398: /*
399: * Release all state associated with specified driver. Can only be called
400: * by drivers we exec.
401: */
402: IOConfigReturn _IODeleteDriver(
403: port_t dev_config_port,
404: port_t driver_sig_port)
405: {
406: driver_entry_t *driver_entry;
407: IOConfigReturn rtn = IO_CNF_SUCCESS;
408:
409: xpr_server("driver_delete\n", 1,2,3,4,5);
410:
411: get_driver_list_lock();
412: driver_entry = get_driver_entry(
413: SK_SIG_PORT,
414: driver_sig_port,
415: DEV_NUM_NULL,
416: FID_NULL,
417: IO_NULL_DEVICE_TYPE,
418: IO_NULL_SLOT_ID,
419: NULL);
420: if(driver_entry == NULL) {
421: xpr_server("driver_delete: BAD driver_sig_port\n",
422: 1,2,3,4,5);
423: rtn = IO_CNF_NOT_REGISTERED;
424: goto done;
425: }
426:
427: rtn = free_driver_entry(driver_entry);
428: done:
429: release_driver_list_lock();
430: return rtn;
431: }
432:
433: #if SUPPORT_DEVICE_DELETE
434: /*
435: * Release state associated with one device. Can only be called
436: * by drivers we exec.
437: *
438: * FIXME:
439: * problem - a driver deletes some ports via device_delete(), then crashes.
440: * On restart, should it have access to all of the dev_ports it initially
441: * had? Currently it won't because Config did device_destroy()'s on the
442: * dev_ports. Those dev_entry's will be missing from the driver_entry's
443: * dev_list...
444: *
445: * Also, how to assign a deleted device to another driver if the deletor
446: * keeps running? A config_scan() will just add it to that driver's
447: * dev_list and since that driver's already running, it won't get exec'd.
448: *
449: * SO...for now we don't support device_delete().
450: */
451: IOConfigReturn _IODeleteDevice(
452: port_t dev_config_port,
453: port_t driver_sig_port,
454: dev_port_t dev_port)
455: {
456: driver_entry_t *driver_entry;
457: dev_entry_t *dev_entry;
458: IOConfigReturn rtn = IO_CNF_SUCCESS;
459:
460: xpr_server("device_delete\n", 1,2,3,4,5);
461: get_driver_list_lock();
462: driver_entry = get_driver_entry(
463: SK_DEV_PORT,
464: dev_port,
465: DEV_NUM_NULL,
466: FID_NULL,
467: IO_NULL_DEVICE_TYPE,
468: IO_NULL_SLOT_ID,
469: &dev_entry);
470: if(driver_entry == NULL) {
471: rtn = IO_CNF_NOT_REGISTERED;
472: goto done;
473: }
474: if(dev_entry == NULL) {
475: /*
476: * Huh? This should not happen...
477: */
478: rtn = IO_CNF_NOT_REGISTERED;
479: goto done;
480: }
481: if(driver_entry->driver_sig_port != driver_sig_port) {
482: rtn = IO_CNF_NOT_REGISTERED;
483: goto done;
484: }
485: rtn = free_dev_entry(dev_entry);
486: done:
487: release_driver_list_lock();
488: xpr_server("device_delete: returning %s\n",
489: reg_text(*rtn, config_returns), 2,3,4,5);
490: return rtn;
491: }
492:
493: #endif SUPPORT_DEVICE_DELETE
494:
495: /*
496: * Do a complete rescan of all potential devices. Exec drivers for the
497: * devices which we don't currently have registered drivers. This can be
498: * called by anyone who can get dev_config_port. We return Busy status if
499: * initial config is still in progress.
500: */
501: IOConfigReturn _IORescanDriver(
502: port_t dev_config_port)
503: {
504: IOConfigReturn rtn;
505:
506: xpr_server("driver_rescan\n", 1,2,3,4,5);
507: if(config_in_progress) {
508: return(IO_CNF_BUSY);
509: }
510: rtn = config_scan(SCAN_ALL, IO_NULL_SLOT_ID, IO_NULL_DEVICE_TYPE);
511: return rtn;
512: }
513:
514: /*
515: * Attempt to start a driver for device specified by slot_id and dev_type.
516: * This can be called by anyone who can get dev_config_port. We return
517: * Busy status if initial config is still in progress.
518: */
519: IOConfigReturn _IOConfigDevice(
520: port_t dev_config_port,
521: IOSlotId slot_id,
522: IODeviceType dev_type)
523: {
524: IOConfigReturn rtn;
525:
526: xpr_server("driver_config\n", 1,2,3,4,5);
527: if(config_in_progress) {
528: return(IO_CNF_BUSY);
529: }
530: rtn = config_scan(SCAN_ONE, slot_id, dev_type);
531: return rtn;
532: }
533:
534: #ifdef DEBUG
535:
536: /*
537: * For debugging new drivers. Delete state associated with specified slot_id
538: * and device_type.
539: */
540: IOConfigReturn _IODeleteDeviceByType(
541: port_t configPort,
542: IOSlotId slot_id,
543: IODeviceType device_type)
544: {
545: IOConfigReturn rtn;
546: driver_entry_t *driver_entry;
547: dev_entry_t *dev_entry;
548:
549: xpr_server("IODeleteDeviceByType: slot_id 0x%x device_type 0x%x\n",
550: slot_id, device_type, 3,4,5);
551:
552: /*
553: * Get driver_entry associated with this slotId and deviceType.
554: */
555: get_driver_list_lock();
556: driver_entry = get_driver_entry(
557: SK_DEV_INDEX,
558: PORT_NULL,
559: DEV_NUM_NULL,
560: FID_NULL,
561: device_type,
562: slot_id,
563: &dev_entry);
564: if(driver_entry == NULL) {
565: rtn = IO_CNF_NOT_FOUND;
566: goto done;
567: }
568:
569: rtn = free_driver_entry(driver_entry);
570: done:
571: release_driver_list_lock();
572: return rtn;
573:
574: }
575: #endif DEBUG
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.