Return to io_req.h CVS log

Up to [GnuMach] / Gnu-Mach / device

Annotation of Gnu-Mach/device/io_req.h, revision 1.1.1.2

1.1.1.2 ! root        1: /*
1.1       root        2:  * Mach Operating System
                      3:  * Copyright (c) 1991,1990,1989,1988 Carnegie Mellon University
                      4:  * All Rights Reserved.
1.1.1.2 ! root        5:  *
1.1       root        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.
1.1.1.2 ! root       11:  *
1.1       root       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.
1.1.1.2 ! root       15:  *
1.1       root       16:  * Carnegie Mellon requests users of this software to return to
1.1.1.2 ! root       17:  *
1.1       root       18:  *  Software Distribution Coordinator  or  [email protected]
                     19:  *  School of Computer Science
                     20:  *  Carnegie Mellon University
                     21:  *  Pittsburgh PA 15213-3890
1.1.1.2 ! root       22:  *
1.1       root       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: 
1.1.1.2 ! root      141: #endif /* _IO_REQ_ */

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.