![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dev_lookup.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / device|
Return to dev_lookup.c CVS log | Up to [GnuMach] / Gnu-Mach / device |
1.1 root 1: /*
2: * Mach Operating System
3: * Copyright (c) 1991,1990,1989,1988 Carnegie Mellon University
4: * All Rights Reserved.
5: *
6: * Permission to use, copy, modify and distribute this software and its
7: * documentation is hereby granted, provided that both the copyright
8: * notice and this permission notice appear in all copies of the
9: * software, derivative works or modified versions, and any portions
10: * thereof, and that both notices appear in supporting documentation.
11: *
12: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
13: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
14: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
15: *
16: * Carnegie Mellon requests users of this software to return to
17: *
18: * Software Distribution Coordinator or [email protected]
19: * School of Computer Science
20: * Carnegie Mellon University
21: * Pittsburgh PA 15213-3890
22: *
23: * any improvements or extensions that they make and grant Carnegie Mellon
24: * the rights to redistribute these changes.
25: */
26: /*
27: * Author: David B. Golub, Carnegie Mellon University
28: * Date: 3/89
29: */
30:
31: #include <mach/port.h>
32: #include <mach/vm_param.h>
33:
34: #include <kern/queue.h>
35: #include <kern/zalloc.h>
36:
37: #include <device/device_types.h>
38: #include <device/dev_hdr.h>
39: #include <device/conf.h>
40: #include <device/param.h> /* DEV_BSIZE, as default */
41:
42: #include <ipc/ipc_port.h>
43: #include <kern/ipc_kobject.h>
44:
45: #ifdef i386
46: #include <i386at/device_emul.h>
47: #endif
48:
49: /*
50: * Device structure routines: reference counting, port->device.
51: */
52:
53: /*
54: * Lookup/enter by device number.
55: */
56: #define NDEVHASH 8
57: #define DEV_NUMBER_HASH(dev) ((dev) & (NDEVHASH-1))
58: queue_head_t dev_number_hash_table[NDEVHASH];
59:
60: /*
61: * Lock for device-number to device lookup.
62: * Must be held before device-ref_count lock.
63: */
64: decl_simple_lock_data(,
65: dev_number_lock)
66:
67: zone_t dev_hdr_zone;
68:
69: /*
70: * Enter device in the number lookup table.
71: * The number table lock must be held.
72: */
73: void
74: dev_number_enter(device)
75: register mach_device_t device;
76: {
77: register queue_t q;
78:
79: q = &dev_number_hash_table[DEV_NUMBER_HASH(device->dev_number)];
80: queue_enter(q, device, mach_device_t, number_chain);
81: }
82:
83: /*
84: * Remove device from the device-number lookup table.
85: * The device-number table lock must be held.
86: */
87: void
88: dev_number_remove(device)
89: register mach_device_t device;
90: {
91: register queue_t q;
92:
93: q = &dev_number_hash_table[DEV_NUMBER_HASH(device->dev_number)];
94: queue_remove(q, device, mach_device_t, number_chain);
95: }
96:
97: /*
98: * Lookup a device by device operations and minor number.
99: * The number table lock must be held.
100: */
101: mach_device_t
102: dev_number_lookup(ops, devnum)
103: dev_ops_t ops;
104: int devnum;
105: {
106: register queue_t q;
107: register mach_device_t device;
108:
109: q = &dev_number_hash_table[DEV_NUMBER_HASH(devnum)];
110: queue_iterate(q, device, mach_device_t, number_chain) {
111: if (device->dev_ops == ops && device->dev_number == devnum) {
112: return (device);
113: }
114: }
115: return (MACH_DEVICE_NULL);
116: }
117:
118: /*
119: * Look up a device by name, and create the device structure
120: * if it does not exist. Enter it in the dev_number lookup
121: * table.
122: */
123: mach_device_t
124: device_lookup(name)
125: char * name;
126: {
127: dev_ops_t dev_ops;
128: int dev_minor;
129: register mach_device_t device;
130: register mach_device_t new_device;
131:
132: /*
133: * Get the device and unit number from the name.
134: */
135: if (!dev_name_lookup(name, &dev_ops, &dev_minor))
136: return (MACH_DEVICE_NULL);
137:
138: /*
139: * Look up the device in the hash table. If it is
140: * not there, enter it.
141: */
142: new_device = MACH_DEVICE_NULL;
143: simple_lock(&dev_number_lock);
144: while ((device = dev_number_lookup(dev_ops, dev_minor))
145: == MACH_DEVICE_NULL) {
146: /*
147: * Must unlock to allocate the structure. If
148: * the structure has appeared after we have allocated,
149: * release the new structure.
150: */
151: if (new_device != MACH_DEVICE_NULL)
152: break; /* allocated */
153:
154: simple_unlock(&dev_number_lock);
155:
156: new_device = (mach_device_t) zalloc(dev_hdr_zone);
157: simple_lock_init(&new_device->ref_lock);
158: new_device->ref_count = 1;
159: simple_lock_init(&new_device->lock);
160: new_device->state = DEV_STATE_INIT;
161: new_device->flag = 0;
162: new_device->open_count = 0;
163: new_device->io_in_progress = 0;
164: new_device->io_wait = FALSE;
165: new_device->port = IP_NULL;
166: new_device->dev_ops = dev_ops;
167: new_device->dev_number = dev_minor;
168: new_device->bsize = DEV_BSIZE; /* change later */
169:
170: simple_lock(&dev_number_lock);
171: }
172:
173: if (device == MACH_DEVICE_NULL) {
174: /*
175: * No existing device structure. Insert the
176: * new one.
177: */
178: assert(new_device != MACH_DEVICE_NULL);
179: device = new_device;
180:
181: dev_number_enter(device);
182: simple_unlock(&dev_number_lock);
183: }
184: else {
185: /*
186: * Have existing device.
187: */
188: mach_device_reference(device);
189: simple_unlock(&dev_number_lock);
190:
191: if (new_device != MACH_DEVICE_NULL)
192: zfree(dev_hdr_zone, (vm_offset_t)new_device);
193: }
194:
195: return (device);
196: }
197:
198: /*
199: * Add a reference to the device.
200: */
201: void
202: mach_device_reference(device)
203: register mach_device_t device;
204: {
205: simple_lock(&device->ref_lock);
206: device->ref_count++;
207: simple_unlock(&device->ref_lock);
208: }
209:
210: /*
211: * Remove a reference to the device, and deallocate the
212: * structure if no references are left.
213: */
214: void
215: mach_device_deallocate(device)
216: register mach_device_t device;
217: {
218: simple_lock(&device->ref_lock);
219: if (--device->ref_count > 0) {
220: simple_unlock(&device->ref_lock);
221: return;
222: }
223: device->ref_count = 1;
224: simple_unlock(&device->ref_lock);
225:
226: simple_lock(&dev_number_lock);
227: simple_lock(&device->ref_lock);
228: if (--device->ref_count > 0) {
229: simple_unlock(&device->ref_lock);
230: simple_unlock(&dev_number_lock);
231: return;
232: }
233:
234: dev_number_remove(device);
235: simple_unlock(&device->ref_lock);
236: simple_unlock(&dev_number_lock);
237:
238: zfree(dev_hdr_zone, (vm_offset_t)device);
239: }
240:
241: /*
242:
243: */
244: /*
245: * port-to-device lookup routines.
246: */
247: decl_simple_lock_data(,
248: dev_port_lock)
249:
250: /*
251: * Enter a port-to-device mapping.
252: */
253: void
254: dev_port_enter(device)
255: register mach_device_t device;
256: {
257: mach_device_reference(device);
258: #ifdef i386
259: ipc_kobject_set(device->port,
260: (ipc_kobject_t) &device->dev, IKOT_DEVICE);
261: device->dev.emul_data = device;
262: {
263: extern struct device_emulation_ops mach_device_emulation_ops;
264:
265: device->dev.emul_ops = &mach_device_emulation_ops;
266: }
267: #else
268: ipc_kobject_set(device->port, (ipc_kobject_t) device, IKOT_DEVICE);
269: #endif
270: }
271:
272: /*
273: * Remove a port-to-device mapping.
274: */
275: void
276: dev_port_remove(device)
277: register mach_device_t device;
278: {
279: ipc_kobject_set(device->port, IKO_NULL, IKOT_NONE);
280: mach_device_deallocate(device);
281: }
282:
283: /*
284: * Lookup a device by its port.
285: * Doesn't consume the naked send right; produces a device reference.
286: */
287: device_t
288: dev_port_lookup(port)
289: ipc_port_t port;
290: {
291: register device_t device;
292:
293: if (!IP_VALID(port))
294: return (DEVICE_NULL);
295:
296: ip_lock(port);
297: if (ip_active(port) && (ip_kotype(port) == IKOT_DEVICE)) {
298: device = (device_t) port->ip_kobject;
299: #ifdef i386
300: if (device->emul_ops->reference)
301: (*device->emul_ops->reference)(device->emul_data);
302: #else
303: mach_device_reference(device);
304: #endif
305: }
306: else
307: device = DEVICE_NULL;
308:
309: ip_unlock(port);
310: return (device);
311: }
312:
313: /*
314: * Get the port for a device.
315: * Consumes a device reference; produces a naked send right.
316: */
317: ipc_port_t
318: convert_device_to_port(device)
319: register device_t device;
320: {
321: #ifndef i386
322: register ipc_port_t port;
323: #endif
324:
325: if (device == DEVICE_NULL)
326: return IP_NULL;
327:
328: #ifdef i386
329: return (*device->emul_ops->dev_to_port) (device->emul_data);
330: #else
331: device_lock(device);
332: if (device->state == DEV_STATE_OPEN)
333: port = ipc_port_make_send(device->port);
334: else
335: port = IP_NULL;
336: device_unlock(device);
337:
338: mach_device_deallocate(device);
339: return port;
340: #endif
341: }
342:
343: /*
344: * Call a supplied routine on each device, passing it
345: * the port as an argument. If the routine returns TRUE,
346: * stop the search and return TRUE. If none returns TRUE,
347: * return FALSE.
348: */
349: boolean_t
350: dev_map(routine, port)
351: boolean_t (*routine)();
352: mach_port_t port;
353: {
354: register int i;
355: register queue_t q;
356: register mach_device_t dev, prev_dev;
357:
358: for (i = 0, q = &dev_number_hash_table[0];
359: i < NDEVHASH;
360: i++, q++) {
361: prev_dev = MACH_DEVICE_NULL;
362: simple_lock(&dev_number_lock);
363: queue_iterate(q, dev, mach_device_t, number_chain) {
364: mach_device_reference(dev);
365: simple_unlock(&dev_number_lock);
366: if (prev_dev != MACH_DEVICE_NULL)
367: mach_device_deallocate(prev_dev);
368:
369: if ((*routine)(dev, port)) {
370: /*
371: * Done
372: */
373: mach_device_deallocate(dev);
374: return (TRUE);
375: }
376:
377: simple_lock(&dev_number_lock);
378: prev_dev = dev;
379: }
380: simple_unlock(&dev_number_lock);
381: if (prev_dev != MACH_DEVICE_NULL)
382: mach_device_deallocate(prev_dev);
383: }
384: return (FALSE);
385: }
386:
387: /*
388: * Initialization
389: */
390: #define NDEVICES 256
391:
392: void
393: dev_lookup_init()
394: {
395: register int i;
396:
397: simple_lock_init(&dev_number_lock);
398:
399: for (i = 0; i < NDEVHASH; i++)
400: queue_init(&dev_number_hash_table[i]);
401:
402: simple_lock_init(&dev_port_lock);
403:
404: dev_hdr_zone = zinit(sizeof(struct mach_device),
405: sizeof(struct mach_device) * NDEVICES,
406: PAGE_SIZE,
407: FALSE,
408: "open device entry");
409: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.