![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to io_req.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / device|
Return to io_req.h 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: 10/88
29: */
30:
31: #ifndef _IO_REQ_
32: #define _IO_REQ_
33:
34: #include <mach/boolean.h>
35: #include <mach/port.h>
36: #include <mach/message.h>
37: #include <mach/vm_param.h>
38: #include <kern/kalloc.h>
39: #include <kern/lock.h>
40: #include <vm/vm_page.h>
41: #include <device/device_types.h>
42: #include <device/dev_hdr.h>
43:
44: #include <kern/macro_help.h>
45:
46: /*
47: * IO request element, queued on device for delayed replies.
48: */
49: struct io_req {
50: struct io_req * io_next; /* next, ... */
51: struct io_req * io_prev; /* prev pointers: link in done,
52: defered, or in-progress list */
53: mach_device_t io_device; /* pointer to open-device structure */
54: char * io_dev_ptr; /* pointer to driver structure -
55: filled in by driver if necessary */
56: int io_unit; /* unit number ('minor') of device */
57: int io_op; /* IO operation */
58: dev_mode_t io_mode; /* operation mode (wait, truncate) */
59: recnum_t io_recnum; /* starting record number for
60: random-access devices */
61:
62: union io_un {
63: io_buf_ptr_t data; /* data, for IO requests */
64: } io_un;
65: #define io_data io_un.data
66:
67: long io_count; /* amount requested */
68: long io_alloc_size; /* amount allocated */
69: long io_residual; /* amount NOT done */
70: io_return_t io_error; /* error code */
71: boolean_t (*io_done)(); /* call when done - returns TRUE
72: if IO really finished */
73: struct ipc_port *io_reply_port; /* reply port, for asynchronous
74: messages */
75: mach_msg_type_name_t io_reply_port_type;
76: /* send or send-once right? */
77: struct io_req * io_link; /* forward link (for driver header) */
78: struct io_req * io_rlink; /* reverse link (for driver header) */
79: vm_map_copy_t io_copy; /* vm_map_copy obj. for this op. */
80: long io_total; /* total op size, for write */
81: decl_simple_lock_data(,io_req_lock)
82: /* Lock for this structure */
83: long io_physrec; /* mapping to the physical block
84: number */
85: long io_rectotal; /* total number of blocks to move */
86: };
87: typedef struct io_req * io_req_t;
88:
89: /*
90: * LOCKING NOTE: Operations on io_req's are in general single threaded by
91: * the invoking code, obviating the need for a lock. The usual IO_CALL
92: * path through the code is: Initiating thread hands io_req to device driver,
93: * driver passes it to io_done thread, io_done thread sends reply message. No
94: * locking is needed in this sequence. Unfortunately, a synchronous wait
95: * for a buffer requires a lock to avoid problems if the wait and interrupt
96: * happen simultaneously on different processors.
97: */
98:
99: #define ior_lock(ior) simple_lock(&(ior)->io_req_lock)
100: #define ior_unlock(ior) simple_unlock(&(ior)->io_req_lock)
101:
102: /*
103: * Flags and operations
104: */
105:
106: #define IO_WRITE 0x00000000 /* operation is write */
107: #define IO_READ 0x00000001 /* operation is read */
108: #define IO_OPEN 0x00000002 /* operation is open */
109: #define IO_DONE 0x00000100 /* operation complete */
110: #define IO_ERROR 0x00000200 /* error on operation */
111: #define IO_BUSY 0x00000400 /* operation in progress */
112: #define IO_WANTED 0x00000800 /* wakeup when no longer BUSY */
113: #define IO_BAD 0x00001000 /* bad disk block */
114: #define IO_CALL 0x00002000 /* call io_done_thread when done */
115: #define IO_INBAND 0x00004000 /* mig call was inband */
116: #define IO_INTERNAL 0x00008000 /* internal, device-driver specific */
117: #define IO_LOANED 0x00010000 /* ior loaned by another module */
118:
119: #define IO_SPARE_START 0x00020000 /* start of spare flags */
120:
121: /*
122: * Standard completion routine for io_requests.
123: */
124: void iodone(/* io_req_t */);
125:
126: /*
127: * Macros to allocate and free IORs - will convert to zones later.
128: */
129: #define io_req_alloc(ior,size) \
130: MACRO_BEGIN \
131: (ior) = (io_req_t)kalloc(sizeof(struct io_req)); \
132: simple_lock_init(&(ior)->io_req_lock); \
133: MACRO_END
134:
135: #define io_req_free(ior) \
136: (kfree((vm_offset_t)(ior), sizeof(struct io_req)))
137:
138:
139: zone_t io_inband_zone; /* for inband reads */
140:
141: #endif _IO_REQ_
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.