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