![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vol.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / dev|
Return to vol.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / dev |
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: /* @(#)vol.c 2.0 03/19/90 (c) 1990 NeXT */
26:
27: /*
28: * vol.c - volume insertion device
29: *
30: * HISTORY
31: * 03-19-90 Doug Mitchell at NeXT
32: * Created.
33: */
34:
35: #import <sys/types.h>
36: #import <sys/errno.h>
37: #import <sys/ioctl.h>
38: #import <sys/systm.h>
39: #import <sys/disktab.h>
40: #import <kern/kern_port.h>
41: #import <kern/thread.h>
42: #import <kern/lock.h>
43: #import <kernserv/insertmsg.h>
44: #import <bsd/dev/disk.h>
45: #import <kernserv/prototypes.h>
46: #import <bsd/dev/voldev.h>
47: #import <kern/queue.h>
48: #import <kernserv/kern_notify.h>
49: #import <mach/notify.h>
50: #if hppa
51: # import <bsd/dev/hppa/sdvol.h>
52: #endif hppa
53: #import "driverkit.h"
54:
55: /* #define VOL_DEBUG 1 /* */
56:
57: #ifdef VOL_DEBUG
58: #define vol_debug(x) printf x
59: #else VOL_DEBUG
60: #define vol_debug(x)
61: #endif VOL_DEBUG
62:
63: /*
64: * Struct used for queueing notifications prior to first DKIOCMNOTIFY
65: */
66: struct vol_notify_entry {
67: queue_chain_t link;
68: int dev_desc; /* IND_DD_DEV, IND_DD_PORT */
69: dev_t block_dev; /* for IND_DD_DEV */
70: dev_t raw_dev; /* ditto */
71: kern_port_t dev_port; /* for IND_DD_PORT */
72: int vol_state; /* IND_VS_LABEL, etc. */
73: char form_type[FORM_TYPE_LENGTH];
74: char dev_str[OID_DEVSTR_LEN];
75: int flags;
76: };
77:
78: typedef struct vol_notify_entry *vne_t;
79:
80: /*
81: * Struct for maintaining state of panel requests
82: */
83:
84: struct vol_panel_entry {
85: queue_chain_t link;
86: int tag;
87: vpt_func fnc; /* to be called upon receipt of
88: * vol_panel_resp message */
89: void *param;
90: };
91:
92: typedef struct vol_panel_entry *vpe_t;
93:
94:
95: /*
96: * Local functions.
97: */
98: static kern_return_t vol_notify_com(int in_dev_desc,
99: dev_t block_dev,
100: dev_t raw_dev,
101: kern_port_t dev_port,
102: int vol_state,
103: const char *form_type,
104: const char *dev_str,
105: int flags);
106: static void vol_thread();
107: static vpe_t vol_panel_get_entry(int tag);
108: static void vol_port_death(notification_t *nmsg);
109:
110: /*
111: * Prototypes for kernel functions.
112: */
113: msg_return_t msg_send_from_kernel(msg_header_t *msgptr, msg_option_t option,
114: msg_timeout_t tout);
115:
116: int volopen(dev_t dev);
117: int volclose(dev_t dev);
118: int volioctl(dev_t dev,
119: int cmd,
120: caddr_t data,
121: int flag);
122:
123: /*
124: * Globals.
125: */
126: static char vol_dev_open;
127: static char vol_dev_init_flag;
128: static kern_port_t vol_check_port=PORT_NULL;
129: /* port to which disk insertion
130: * messages are sent; usually allocated
131: * by autodiskmount. */
132: kern_port_t panel_req_port=PORT_NULL;
133: /* port to which Panel Requests are
134: * sent. */
135: static kern_port_t vol_local_port=PORT_NULL;
136: /* port on which vol_thread listens. */
137: static port_t vol_receive_port = PORT_NULL;
138: static queue_head_t vol_notify_q = {&vol_notify_q, &vol_notify_q};
139: /* hold notifications prior to
140: * first DKIOCMNOTIFY */
141: static lock_data_t vol_notify_lock; /* protects vol_notify_q */
142: static queue_head_t vol_panel_q = {&vol_panel_q, &vol_panel_q};
143: static int vol_panel_tag;
144: static vol_thread_alive=0;
145: #if DRIVERKIT
146: static int manual_poll;
147: #endif DRIVERKIT
148:
149: /*
150: * message templates.
151: */
152: static struct insert_notify insert_notify_temp = {
153: { /* in_header */
154: 0, /* msg_unused */
155: FALSE, /* msg_simple */
156: 0, /* msg_size */
157: MSG_TYPE_NORMAL, /* msg_type */
158: PORT_NULL, /* msg_local_port */
159: PORT_NULL, /* msg_remote_port */
160: VOL_CHECK_MSG_ID /* msg_id */
161: },
162: { /* in_vd_type */
163: MSG_TYPE_INTEGER_32, /* msg_type_name */
164: 32, /* msg_type_size */
165: 2, /* msg_type_number */
166: TRUE, /* msg_type_inline */
167: FALSE, /* msg_type_longform */
168: FALSE, /* msg_type_deallocate */
169: },
170: 0, /* in_vol_state */
171: 0, /* in_dev_desc */
172: { /* in_flags_type */
173: MSG_TYPE_INTEGER_32, /* msg_type_name */
174: 32, /* msg_type_size */
175: 1, /* msg_type_number */
176: TRUE, /* msg_type_inline */
177: FALSE, /* msg_type_longform */
178: FALSE, /* msg_type_deallocate */
179: },
180: 0, /* in_flags */
181: { /* in_form_type */
182: MSG_TYPE_CHAR, /* msg_type_name */
183: 8, /* msg_type_size */
184: FORM_TYPE_LENGTH, /* msg_type_number */
185: TRUE, /* msg_type_inline */
186: FALSE, /* msg_type_longform */
187: FALSE, /* msg_type_deallocate */
188: },
189: NULL /* in_form_type */
190: };
191:
192: static struct vol_panel_req vol_panel_req_temp = {
193: { /* pr_header */
194: 0, /* msg_unused */
195: TRUE, /* msg_simple */
196: sizeof(struct vol_panel_req), /* msg_size */
197: MSG_TYPE_NORMAL, /* msg_type */
198: PORT_NULL, /* msg_local_port */
199: PORT_NULL, /* msg_remote_port */
200: VOL_PANEL_REQ /* msg_id */
201: },
202: { /* pr_int_desc */
203: MSG_TYPE_INTEGER_32, /* msg_type_name */
204: 32, /* msg_type_size */
205: 7, /* msg_type_number */
206: TRUE, /* msg_type_inline */
207: FALSE, /* msg_type_longform */
208: FALSE, /* msg_type_deallocate */
209: },
210: 0, /* pr_panel_type */
211: 0, /* pr_resp_type */
212: 0, /* pr_tag */
213: 0, /* p1 */
214: 0, /* p2 */
215: 0, /* p3 */
216: 0, /* p4 */
217: { /* pr_string_desc */
218: MSG_TYPE_CHAR, /* msg_type_name */
219: 8, /* msg_type_size */
220: 2 * VP_STRING_LEN, /* msg_type_number */
221: TRUE, /* msg_type_inline */
222: FALSE, /* msg_type_longform */
223: FALSE /* msg_type_deallocate */
224: },
225: NULL, /* string1 */
226: NULL /* string2 */
227: };
228:
229: static struct vol_panel_cancel vol_panel_cancel_temp = {
230: { /* pc_header */
231: 0, /* msg_unused */
232: TRUE, /* msg_simple */
233: sizeof(struct vol_panel_cancel),/* msg_size */
234: MSG_TYPE_NORMAL, /* msg_type */
235: PORT_NULL, /* msg_local_port */
236: PORT_NULL, /* msg_remote_port */
237: VOL_PANEL_CANCEL /* msg_id */
238: },
239: { /* pc_int_desc */
240: MSG_TYPE_INTEGER_32, /* msg_type_name */
241: 32, /* msg_type_size */
242: 1, /* msg_type_number */
243: TRUE, /* msg_type_inline */
244: FALSE, /* msg_type_longform */
245: FALSE /* msg_type_deallocate */
246: },
247: 0 /* pc_tag */
248: };
249:
250: int volopen(dev_t dev)
251: {
252: if(vol_dev_open)
253: return(EBUSY);
254: else {
255: vol_dev_open = 1;
256: return(0);
257: }
258: }
259:
260: int volclose(dev_t dev)
261: {
262: vol_dev_open = 0;
263: return(0);
264: }
265:
266: int volioctl(dev_t dev,
267: int cmd,
268: caddr_t data,
269: int flag)
270: {
271: int rtn=0;
272: port_t remote_port;
273: dev_t mydev;
274:
275: switch (cmd) {
276: case DKIOCMNOTIFY:
277: /*
278: * Send disk insert notification to port specified in *data.
279: */
280: vol_debug(("volioctl: registering NOTIFY port\n"));
281: remote_port = *(port_t *)data;
282: if(get_kern_port(current_task(), remote_port, &vol_check_port))
283: rtn = EINVAL;
284: else {
285: /*
286: * Send notification for each entry in vol_notify_q.
287: */
288: vne_t vnep, vne_next_p;
289:
290: lock_write(&vol_notify_lock);
291: vnep = (vne_t)queue_first(&vol_notify_q);
292: while(!queue_end(&vol_notify_q, (queue_entry_t)vnep)) {
293: vne_next_p = (vne_t)vnep->link.next;
294: queue_remove(&vol_notify_q,
295: vnep,
296: vne_t,
297: link);
298: if(vnep->block_dev != rootdev) {
299: /*
300: * skip notification for root device
301: */
302: vol_notify_com(vnep->dev_desc,
303: vnep->block_dev,
304: vnep->raw_dev,
305: vnep->dev_port,
306: vnep->vol_state,
307: vnep->form_type,
308: vnep->dev_str,
309: vnep->flags);
310: }
311: kfree(vnep, sizeof(struct vol_notify_entry));
312: vnep = vne_next_p;
313: }
314: lock_done(&vol_notify_lock);
315: }
316: /*
317: * Register this port so we'll know when it dies.
318: */
319: if(rtn == 0)
320: port_request_notification(vol_check_port,
321: vol_local_port);
322: break;
323:
324: case DKIOCPANELPRT:
325: /*
326: * register port to which we send Panel request messages.
327: */
328: vol_debug(("volioctl: registering PANEL port\n"));
329: remote_port = *(port_t *)data;
330: if(get_kern_port(current_task(), remote_port, &panel_req_port))
331: rtn = EINVAL;
332: /*
333: * Register this port so we'll know when it dies.
334: */
335: port_request_notification(panel_req_port, vol_local_port);
336: break;
337:
338: #if DRIVERKIT
339: case DKIOCCHECKINSERT:
340: #if 0
341: #if hppa
342: sd_check_disks(SD_CHECK_DISKS);
343: #endif hppa
344: #endif 0
345: manual_poll = 1;
346: break;
347: #endif DRIVERKIT
348:
349: case DKIOCCANCELAUTOMOUNT:
350: mydev = *(dev_t *)data;
351: vol_notify_cancel(mydev);
352:
353: /* note: for hppa, if we go with the different vol driver behavior,
354: * this function needs to be taken from the 3.2 HP kernel
355: */
356: #if 0
357: #ifdef hppa
358: sd_ignore_vol(mydev);
359: #endif
360: #endif
361:
362: break;
363:
364: default:
365: rtn = EINVAL;
366: break;
367: }
368: return(rtn);
369: } /* volioctl() */
370:
371: /*
372: * Any driver may call these functions to notify appropriate user task of disk
373: * insertion. If no port has been registered via DKIOCMNOTIFY, no action
374: * is taken.
375: */
376:
377: kern_return_t vol_notify_dev(dev_t block_dev,
378: dev_t raw_dev,
379: const char *form_type,
380: int vol_state, /* IND_VS_LABEL, etc. */
381: const char *dev_str,
382: int flags)
383: {
384: return(vol_notify_com(IND_DD_DEV,
385: block_dev,
386: raw_dev,
387: 0,
388: vol_state,
389: form_type,
390: dev_str,
391: flags));
392: }
393:
394: #if SUPPORT_PORT_DEVICE
395:
396: kern_return_t vol_notify_port(kern_port_t dev_port,
397: char *const form_type,
398: int vol_state, /* IND_VS_LABEL, etc. */
399: int flags)
400: {
401: return(vol_notify_com(IND_DD_PORT,
402: 0,
403: 0,
404: dev_port,
405: vol_state,
406: form_type,
407: "",
408: flags));
409: }
410:
411: #endif SUPPORT_PORT_DEVICE
412:
413: static kern_return_t vol_notify_com(int in_dev_desc,
414: dev_t block_dev,
415: dev_t raw_dev,
416: kern_port_t dev_port,
417: int vol_state, /* IND_VS_LABEL, etc. */
418: const char *form_type,
419: const char *dev_str,
420: int flags)
421: {
422: struct insert_notify *notify_msg;
423: struct of_insert_notify_dev *dev_msg;
424: struct of_insert_notify_port *port_msg;
425: int size;
426: kern_return_t krtn;
427:
428: vol_debug(("vol_notify_com: block_dev=0x%x vol_state=0x%x\n",
429: block_dev, vol_state));
430: if(!vol_dev_init_flag) {
431: lock_init(&vol_notify_lock, TRUE);
432: vol_dev_init_flag = TRUE;
433: }
434: if(vol_check_port == (kern_port_t)NULL) {
435: vne_t vnep;
436:
437: /*
438: * nobody has registered yet. Queue up this request.
439: */
440: vnep = (vne_t)kalloc(sizeof(struct vol_notify_entry));
441: vnep->dev_desc = in_dev_desc;
442: vnep->block_dev = block_dev;
443: vnep->raw_dev = raw_dev;
444: vnep->dev_port = dev_port;
445: vnep->vol_state = vol_state;
446: vnep->flags = flags;
447: strcpy(vnep->form_type, form_type);
448: strcpy(vnep->dev_str, dev_str);
449: lock_write(&vol_notify_lock);
450: queue_enter(&vol_notify_q,
451: vnep,
452: struct vol_notify_entry *,
453: link);
454: lock_done(&vol_notify_lock);
455: return(KERN_SUCCESS);
456: }
457:
458: switch(in_dev_desc) {
459: case IND_DD_DEV:
460: size = sizeof(struct of_insert_notify_dev);
461: break;
462:
463: #if SUPPORT_PORT_DEVICE
464: case IND_DD_PORT:
465: size = sizeof(struct of_insert_notify_port);
466: #endif SUPPORT_PORT_DEVICE
467:
468: default:
469: return(KERN_INVALID_ARGUMENT);
470: }
471: notify_msg = (struct insert_notify *)kalloc(size);
472: *notify_msg = insert_notify_temp;
473: notify_msg->in_header.msg_simple = (in_dev_desc == IND_DD_PORT) ?
474: FALSE : TRUE;
475: notify_msg->in_header.msg_size = size;
476: notify_msg->in_header.msg_remote_port = (port_t)vol_check_port;
477: notify_msg->in_vol_state = vol_state;
478: notify_msg->in_dev_desc = in_dev_desc;
479: notify_msg->in_flags = flags;
480: strcpy(notify_msg->in_form_type, form_type);
481:
482: /*
483: * dev or port
484: */
485: switch(in_dev_desc) {
486: case IND_DD_DEV:
487: dev_msg = (struct of_insert_notify_dev *)notify_msg;
488: dev_msg->oid_dev_type.msg_type_name = MSG_TYPE_INTEGER_32;
489: dev_msg->oid_dev_type.msg_type_size = 32;
490: dev_msg->oid_dev_type.msg_type_number = 2;
491: dev_msg->oid_dev_type.msg_type_inline = TRUE;
492: dev_msg->oid_dev_type.msg_type_longform = FALSE;
493: dev_msg->oid_dev_type.msg_type_deallocate = FALSE;
494: dev_msg->oid_bdev_t = block_dev;
495: dev_msg->oid_cdev_t = raw_dev;
496: dev_msg->oid_ds_type.msg_type_name = MSG_TYPE_CHAR;
497: dev_msg->oid_ds_type.msg_type_size = 8;
498: dev_msg->oid_ds_type.msg_type_number = OID_DEVSTR_LEN;
499: dev_msg->oid_ds_type.msg_type_inline = TRUE;
500: dev_msg->oid_ds_type.msg_type_longform = FALSE;
501: dev_msg->oid_ds_type.msg_type_deallocate = FALSE;
502: strcpy(dev_msg->oid_dev_str, dev_str);
503: break;
504:
505: #if SUPPORT_PORT_DEVICE
506:
507: case IND_DD_PORT:
508: port_msg = (struct of_insert_notify_port *)notify_msg;
509: port_msg->oip_p_type.msg_type_name = MSG_TYPE_PORT;
510: port_msg->oip_p_type.msg_type_size = 32;
511: port_msg->oip_p_type.msg_type_number = 1;
512: port_msg->oip_p_type.msg_type_inline = TRUE;
513: port_msg->oip_p_type.msg_type_longform = FALSE;
514: port_msg->oip_p_type.msg_type_deallocate = FALSE;
515: port_msg->oip_port = (port_t)dev_port;
516:
517: #endif SUPPORT_PORT_DEVICE
518: default:
519: break; // can't happen, avoid compiler
520: // warning
521:
522: }
523: krtn = msg_send_from_kernel(¬ify_msg->in_header,
524: SEND_TIMEOUT,
525: 0); /* don't block if queue full */
526: #ifdef DEBUG
527: if(krtn)
528: printf("vol_check_notify: msg_send returned %d\n", krtn);
529: #endif DEBUG
530: return(krtn);
531: } /* vol_check_notify */
532:
533: /*
534: * Cancel a (possibly) queued notify message. Normally called when a device
535: * is mounted.
536: */
537: void vol_notify_cancel(dev_t device)
538: {
539: vne_t vnep, vne_next_p;
540:
541: /*
542: * Inserts are always registered for partition a; mounts can be
543: * on other partitions...
544: */
545: device &= ~(NPART - 1);
546:
547: if(!vol_dev_init_flag) {
548: lock_init(&vol_notify_lock, TRUE);
549: vol_dev_init_flag = TRUE;
550: }
551:
552: lock_write(&vol_notify_lock);
553: vnep = (vne_t)queue_first(&vol_notify_q);
554: while(!queue_end(&vol_notify_q, (queue_entry_t)vnep)) {
555: vne_next_p = (vne_t)vnep->link.next;
556: if((vnep->block_dev == device) ||
557: (vnep->raw_dev == device)) {
558: queue_remove(&vol_notify_q,
559: vnep,
560: vne_t,
561: link);
562: kfree(vnep, sizeof(struct vol_notify_entry));
563: }
564: vnep = vne_next_p;
565: }
566: lock_done(&vol_notify_lock);
567: }
568:
569: /*
570: * Functions to request and cancel alert panels via WSM
571: */
572:
573: /*
574: * Generic panel request.
575: */
576: kern_return_t vol_panel_request(vpt_func fnc,
577: int panel_type, /* PR_PT_DISK_NUM, etc. */
578: int response_type, /* PR_RT_ACK, etc. */
579: int p1,
580: int p2,
581: int p3,
582: int p4,
583: char *string1,
584: char *string2,
585: void *param,
586: int *tag) { /* RETURNED */
587:
588: kern_return_t krtn;
589: vpe_t vpe;
590: struct vol_panel_req *panel_msgp;
591:
592: vol_debug(("vol_panel_request: panel_type=%d\n", panel_type));
593: if(panel_req_port == (kern_port_t)NULL) {
594: char *disk_string;
595:
596: /*
597: * Nobody registered to deal with these requests yet. Punt
598: * and send notification to the console; no ack is possible.
599: *
600: * For some panels, this switch is meaningless (but harmless).
601: */
602: switch(p2) {
603: case PR_DRIVE_FLOPPY:
604: disk_string = "Floppy";
605: break;
606: case PR_DRIVE_OPTICAL:
607: disk_string = "Optical";
608: break;
609: case PR_DRIVE_SCSI:
610: disk_string = "SCSI";
611: break;
612: default:
613: disk_string = "";
614: break;
615: }
616: switch(panel_type) {
617: case PR_PT_DISK_NUM:
618: printf("Please Insert %s Disk %d in Drive %d\n",
619: disk_string, p1, p3);
620: break;
621: case PR_PT_DISK_LABEL:
622: printf("Please Insert %s Disk \'%s\' in Drive %d\n",
623: disk_string, string1, p3);
624: break;
625: case PR_PT_DISK_NUM_W:
626: printf("Wrong Disk: Please Insert %s Disk %d in Drive "
627: "%d\n", disk_string, p1, p3);
628: break;
629: case PR_PT_DISK_LABEL_W:
630: printf("Wrong Disk: Please Insert %s Disk \'%s\' in "
631: "Drive %d\n", disk_string, string1, p3);
632: break;
633: case PR_PT_SWAPDEV_FULL:
634: printf("***Swap Device Full***\n");
635: break;
636: case PR_PT_FILESYS_FULL:
637: printf("***File System %s Full***\n", string1);
638: break;
639: case PR_RT_EJECT_REQ:
640: printf("Please Eject %s Disk %d\n", disk_string, p3);
641: break;
642: default:
643: /* FIXME: what do we do here? */
644: printf("vol_panel_request: bogus panel_type (%d)\n",
645: panel_type);
646: break;
647: }
648: return(0);
649: }
650: /*
651: * Build a panel request message.
652: */
653: panel_msgp = (struct vol_panel_req *)kalloc(sizeof(*panel_msgp));
654: *panel_msgp = vol_panel_req_temp;
655: panel_msgp->pr_header.msg_local_port = (port_t)vol_local_port;
656: panel_msgp->pr_header.msg_remote_port = (port_t)panel_req_port;
657: panel_msgp->pr_panel_type = panel_type;
658: panel_msgp->pr_resp_type = response_type;
659: panel_msgp->pr_tag = vol_panel_tag++;
660: panel_msgp->pr_p1 = p1;
661: panel_msgp->pr_p2 = p2;
662: panel_msgp->pr_p3 = p3;
663: panel_msgp->pr_p4 = p4;
664: if(strlen(string1) >= VP_STRING_LEN)
665: string1[VP_STRING_LEN-1] = '\0';
666: if(strlen(string2) >= VP_STRING_LEN)
667: string2[VP_STRING_LEN-1] = '\0';
668: strcpy(panel_msgp->pr_string1, string1);
669: strcpy(panel_msgp->pr_string2, string2);
670: /*
671: * send the message.
672: */
673: krtn = msg_send_from_kernel(&panel_msgp->pr_header,
674: SEND_TIMEOUT,
675: 0); /* don't block if queue full */
676: #ifdef DEBUG
677: if(krtn)
678: printf("vol_panel_request: msg_send returned %d\n", krtn);
679: #endif DEBUG
680: if(krtn)
681: return(krtn);
682: *tag = panel_msgp->pr_tag;
683: /*
684: * Enqueue this event on vol_panel_q if we expect an ack
685: */
686: if(response_type == PR_RT_NONE)
687: return(KERN_SUCCESS);
688: vpe = (vpe_t)kalloc(sizeof(struct vol_panel_entry));
689: if(vpe == NULL)
690: return(KERN_RESOURCE_SHORTAGE);
691: vpe->tag = panel_msgp->pr_tag;
692: vpe->fnc = fnc;
693: vpe->param = param;
694: queue_enter(&vol_panel_q, vpe, struct vol_panel_entry *, link);
695: return(KERN_SUCCESS);
696:
697: } /* vol_panel_request */
698:
699: /*
700: * remove an existing panel.
701: */
702: kern_return_t vol_panel_remove(int tag) {
703: struct vol_panel_cancel *msgp;
704: kern_return_t krtn = KERN_SUCCESS;
705: vpe_t vpe;
706:
707: vol_debug(("vol_panel_remove\n"));
708: if(panel_req_port != (kern_port_t)NULL) {
709: msgp = (struct vol_panel_cancel *)kalloc(sizeof(*msgp));
710: *msgp = vol_panel_cancel_temp;
711: msgp->pc_header.msg_local_port = (port_t)vol_local_port;
712: msgp->pc_header.msg_remote_port = (port_t)panel_req_port;
713: msgp->pc_tag = tag;
714: krtn = msg_send_from_kernel(&msgp->pc_header,
715: SEND_TIMEOUT,
716: 0); /* don't block if queue full */
717: if(krtn)
718: printf("vol_panel_remove: msg_send returned %d\n",
719: krtn);
720: }
721: /*
722: * Remove entry in vol_panel_q for this panel.
723: */
724: vpe = vol_panel_get_entry(tag);
725: if(vpe)
726: kfree(vpe, sizeof(*vpe));
727: else {
728: /*
729: * This is not an error; it could happen in a race condition in
730: * which this function were called just after we received a
731: * vol_panel_cancel message.
732: */
733: vol_debug(("vol_panel_remove: panel resp, tag not found\n"));
734: }
735: return(krtn);
736: }
737:
738: /*
739: * Panel requests specifically for disk drivers.
740: */
741: kern_return_t vol_panel_disk_num(vpt_func fnc,
742: int volume_num,
743: int drive_type, /* PR_DRIVE_FLOPPY, etc. */
744: int drive_num,
745: void *param,
746: boolean_t wrong_disk,
747: int *tag) { /* RETURNED */
748:
749: return(vol_panel_request(fnc,
750: wrong_disk ? PR_PT_DISK_NUM_W : PR_PT_DISK_NUM,
751: PR_RT_ACK,
752: volume_num,
753: drive_type,
754: drive_num,
755: 0,
756: "",
757: "",
758: param,
759: tag));
760: }
761:
762: kern_return_t vol_panel_disk_label(vpt_func fnc,
763: char *label,
764: int drive_type, /* PR_DRIVE_FLOPPY, etc. */
765: int drive_num,
766: void *param,
767: boolean_t wrong_disk,
768: int *tag) { /* RETURNED */
769:
770: return(vol_panel_request(fnc,
771: wrong_disk ? PR_PT_DISK_LABEL_W : PR_PT_DISK_LABEL,
772: PR_RT_ACK,
773: 0,
774: drive_type,
775: drive_num,
776: 0,
777: label,
778: "",
779: param,
780: tag));
781: }
782:
783: void vol_thread() {
784: /*
785: * The job here is to receive and handle two kinds of messages:
786: *
787: * -- messages from the Workspace (like vol_panel_resp messages).
788: * -- port death messages, forwarded to us from voltask. The death of
789: * panel_req_port will cause all pending panels in vol_panel_q to be
790: * acked and removed. The death of vol_check_port isn't very
791: * interesting; we just NULL it out so we don't send any more
792: * insertion events.
793: */
794:
795: struct vol_panel_resp *msgp;
796: kern_return_t krtn;
797: vpe_t vpe;
798:
799: msgp = (struct vol_panel_resp *)kalloc(MSG_SIZE_MAX);
800:
801: while(1) {
802: msgp->ps_header.msg_local_port = vol_receive_port;
803: msgp->ps_header.msg_size = MSG_SIZE_MAX;
804: krtn = msg_receive(&msgp->ps_header, MSG_OPTION_NONE, 0);
805: if(krtn) {
806: printf("vol_thread: msg_receive() returned %d\n",
807: krtn);
808: continue;
809: }
810: vol_debug(("vol_thread: msg_id = 0x%x\n",
811: msgp->ps_header.msg_id));
812: switch(msgp->ps_header.msg_id) {
813: case VOL_PANEL_RESP:
814: /*
815: * First we have to see if we know about a panel with
816: * this tag.
817: */
818: vpe = vol_panel_get_entry(msgp->ps_tag);
819: if(vpe == NULL) {
820: /*
821: * This is not an error; it could happen
822: * in a race condition in which this message
823: * came in just after a driver sent a
824: * vol_panel_cancel message.
825: */
826: vol_debug(("vol_thread: panel resp, tag not"
827: " found\n"));
828: break;
829: }
830: /*
831: * Perform callout if necessary, then dispose of
832: * entry.
833: */
834: vol_debug(("vol_thread: doing VOL_PANEL_RESP "
835: "callout\n"));
836: if(vpe->fnc) {
837: (*vpe->fnc)(vpe->param,
838: vpe->tag,
839: msgp->ps_value);
840: }
841: kfree(vpe, sizeof(*vpe));
842: break;
843:
844: case NOTIFY_PORT_DELETED:
845: vol_debug(("vol_thread: port death\n"));
846: vol_port_death((notification_t *)msgp);
847: break;
848:
849: default:
850: printf("vol_thread: bogus message rec'd (msg_id = "
851: "%d)\n", msgp->ps_header.msg_id);
852: break;
853: }
854: }
855: } /* vol_thread() */
856:
857: static vpe_t vol_panel_get_entry(int tag) {
858: /*
859: * get vol_panel_entry associated with 'tag' from vol_panel_q. Removes
860: * entry from vol_panel_q. Returns NULL if entry not found.
861: */
862: vpe_t vpe;
863:
864: vpe = (vpe_t)queue_first(&vol_panel_q);
865: while(!queue_end(&vol_panel_q, (queue_entry_t)vpe)) {
866: if(vpe->tag == tag) {
867: /*
868: * Found it.
869: */
870: queue_remove(&vol_panel_q,
871: vpe,
872: struct vol_panel_entry *,
873: link);
874: return(vpe);
875: }
876: vpe = (vpe_t)vpe->link.next;
877: }
878: /*
879: * Not found.
880: */
881: return((vpe_t)NULL);
882: }
883:
884: static void vol_port_death(notification_t *nmsg)
885: {
886: /*
887: * voltask has detected port death of one of our ports.
888: */
889: vol_debug(("vol_port_death: "));
890: if((kern_port_t)nmsg->notify_port == vol_check_port) {
891: vol_debug(("vol_check_port dead\n"));
892: vol_check_port = PORT_NULL;
893: }
894: else if ((kern_port_t)nmsg->notify_port == panel_req_port) {
895: vpe_t vpe, vpe_next;
896:
897: vol_debug(("panel_req_port dead\n"));
898: /*
899: * Ack and dispose of every vol_panel_entry in vol_panel_q.
900: */
901: vpe = (vpe_t)queue_first(&vol_panel_q);
902: while(!queue_end(&vol_panel_q, (queue_entry_t)vpe)) {
903: vol_debug(("vol_port_death: doing VOL_PANEL_RESP "
904: "callout\n"));
905: vpe_next = (vpe_t)vpe->link.next;
906: if(vpe->fnc) {
907: (*vpe->fnc)(vpe->param,
908: vpe->tag,
909: 0); /* as in "disk not
910: * available" */
911: }
912: queue_remove(&vol_panel_q,
913: vpe,
914: struct vol_panel_entry *,
915: link);
916: kfree(vpe, sizeof(*vpe));
917: vpe = vpe_next;
918: }
919: /*
920: * Finally, inhibit further panel request messages.
921: */
922: panel_req_port = PORT_NULL;
923: }
924: else
925: vol_debug(("bogus notification\n"));
926: }
927:
928: void vol_start_thread()
929: {
930: kern_return_t krtn;
931:
932: mach_port_t name;
933:
934: krtn = ipc_port_alloc(kernel_task->itk_space, &name, &vol_local_port);
935: if(krtn) {
936: printf("vol_start_thread: port_alloc returned %d\n",
937: krtn);
938: return;
939: }
940: vol_receive_port = vol_local_port->ip_receiver_name;
941: ip_unlock(vol_local_port);
942: kernel_thread(kernel_task, vol_thread, (void *)0);
943: queue_init(&vol_panel_q);
944: vol_thread_alive = 1;
945: if(!vol_dev_init_flag) {
946: lock_init(&vol_notify_lock, TRUE);
947: vol_dev_init_flag = TRUE;
948: }
949: }
950:
951: #if DRIVERKIT
952: /*
953: * Returns 1 if DKIOCCHECKINSERT has been executed since the last call,
954: * else returns 0.
955: */
956: int vol_check_manual_poll()
957: {
958: if(manual_poll) {
959: manual_poll = 0;
960: return(1);
961: }
962: else {
963: return(0);
964: }
965: }
966:
967: /*
968: * Internal version of ioctl(DKIOCCHECKINSERT).
969: */
970: void vol_check_set_poll()
971: {
972: manual_poll = 1;
973: }
974:
975: #endif DRIVERKIT
976:
977: /* end of vol.c */
978:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.