src/io_internal.h

   1 /*
   2  * Copyright (c) 2009-2013 Apple Inc. All rights reserved.
   3  *
   4  * @APPLE_APACHE_LICENSE_HEADER_START@
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *     http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  * @APPLE_APACHE_LICENSE_HEADER_END@
  19  */
  20
  21 /*
  22  * IMPORTANT: This header file describes INTERNAL interfaces to libdispatch
  23  * which are subject to change in future releases of Mac OS X. Any applications
  24  * relying on these interfaces WILL break.
  25  */
  26
  27 #ifndef __DISPATCH_IO_INTERNAL__
  28 #define __DISPATCH_IO_INTERNAL__
  29
  30 #ifndef __DISPATCH_INDIRECT__
  31 #error "Please #include <dispatch/dispatch.h> instead of this file directly."
  32 #include <dispatch/base.h> // for HeaderDoc
  33 #endif
  34
  35 #define _DISPATCH_IO_LABEL_SIZE 16
  36
  37 #if TARGET_OS_EMBEDDED // rdar://problem/9032036
  38 #define DIO_MAX_CHUNK_SIZE                              (512u * 1024)
  39 #define DIO_HASH_SIZE                                   64u  // must be a power of two
  40 #else
  41 #define DIO_MAX_CHUNK_SIZE                              (1024u * 1024)
  42 #define DIO_HASH_SIZE                                   256u // must be a power of two
  43 #endif
  44
  45 #define DIO_HASH(x) ((uintptr_t)(x) & (DIO_HASH_SIZE - 1))
  46
  47 #define DIO_DEFAULT_LOW_WATER_CHUNKS      1u // default low-water mark
  48 #define DIO_MAX_PENDING_IO_REQS                   6u // Pending I/O read advises
  49
  50 typedef unsigned int dispatch_op_direction_t;
  51 enum {
  52         DOP_DIR_READ = 0,
  53         DOP_DIR_WRITE,
  54         DOP_DIR_MAX,
  55         DOP_DIR_IGNORE = UINT_MAX,
  56 };
  57
  58 typedef unsigned int dispatch_op_flags_t;
  59 #define DOP_DEFAULT             0u // check conditions to determine delivery
  60 #define DOP_DELIVER             1u // always deliver operation
  61 #define DOP_DONE                2u // operation is done (implies deliver)
  62 #define DOP_STOP                4u // operation interrupted by chan stop (implies done)
  63 #define DOP_NO_EMPTY    8u // don't deliver empty data
  64
  65 // dispatch_io_t atomic_flags
  66 #define DIO_CLOSED              1u // channel has been closed
  67 #define DIO_STOPPED             2u // channel has been stopped (implies closed)
  68
  69 DISPATCH_DECL_INTERNAL(dispatch_operation);
  70 DISPATCH_DECL_INTERNAL(dispatch_disk);
  71
  72 struct dispatch_stream_s {
  73         dispatch_queue_t dq;
  74         dispatch_source_t source;
  75         dispatch_operation_t op;
  76         bool source_running;
  77         TAILQ_HEAD(, dispatch_operation_s) operations[2];
  78 };
  79
  80 typedef struct dispatch_stream_s *dispatch_stream_t;
  81
  82 struct dispatch_io_path_data_s {
  83         dispatch_io_t channel;
  84         int oflag;
  85         mode_t mode;
  86         size_t pathlen;
  87         char path[];
  88 };
  89
  90 typedef struct dispatch_io_path_data_s *dispatch_io_path_data_t;
  91
  92 struct dispatch_stat_s {
  93         dev_t dev;
  94         mode_t mode;
  95 };
  96
  97 DISPATCH_CLASS_DECL(disk);
  98 struct dispatch_disk_s {
  99         DISPATCH_STRUCT_HEADER(disk);
 100         TAILQ_HEAD(dispatch_disk_operations_s, dispatch_operation_s) operations;
 101         dispatch_operation_t cur_rq;
 102         dispatch_queue_t pick_queue;
 103
 104         size_t free_idx;
 105         size_t req_idx;
 106         size_t advise_idx;
 107         dev_t dev;
 108         bool io_active;
 109         TAILQ_ENTRY(dispatch_disk_s) disk_list;
 110         size_t advise_list_depth;
 111         dispatch_operation_t advise_list[];
 112 };
 113
 114 struct dispatch_fd_entry_s {
 115         dispatch_fd_t fd;
 116         dispatch_io_path_data_t path_data;
 117         int orig_flags, orig_nosigpipe, err;
 118 #if DISPATCH_USE_GUARDED_FD_CHANGE_FDGUARD
 119         int orig_fd_flags;
 120 #endif
 121 #if DISPATCH_USE_GUARDED_FD
 122         unsigned int guard_flags;
 123 #endif
 124         struct dispatch_stat_s stat;
 125         dispatch_stream_t streams[2];
 126         dispatch_disk_t disk;
 127         dispatch_queue_t close_queue, barrier_queue;
 128         dispatch_group_t barrier_group;
 129         dispatch_io_t convenience_channel;
 130         TAILQ_HEAD(, dispatch_operation_s) stream_ops;
 131         TAILQ_ENTRY(dispatch_fd_entry_s) fd_list;
 132 };
 133
 134 typedef struct dispatch_fd_entry_s *dispatch_fd_entry_t;
 135
 136 typedef struct dispatch_io_param_s {
 137         dispatch_io_type_t type; // STREAM OR RANDOM
 138         size_t low;
 139         size_t high;
 140         uint64_t interval;
 141         unsigned long interval_flags;
 142 } dispatch_io_param_s;
 143
 144 DISPATCH_CLASS_DECL(operation);
 145 struct dispatch_operation_s {
 146         DISPATCH_STRUCT_HEADER(operation);
 147         dispatch_queue_t op_q;
 148         dispatch_op_direction_t direction; // READ OR WRITE
 149         dispatch_io_param_s params;
 150         off_t offset;
 151         size_t length;
 152         int err;
 153         dispatch_io_handler_t handler;
 154         dispatch_io_t channel;
 155         dispatch_fd_entry_t fd_entry;
 156         dispatch_source_t timer;
 157         bool active;
 158         off_t advise_offset;
 159         void* buf;
 160         dispatch_op_flags_t flags;
 161         size_t buf_siz, buf_len, undelivered, total;
 162         dispatch_data_t buf_data, data;
 163         TAILQ_ENTRY(dispatch_operation_s) operation_list;
 164         // the request list in the fd_entry stream_ops
 165         TAILQ_ENTRY(dispatch_operation_s) stream_list;
 166 };
 167
 168 DISPATCH_CLASS_DECL(io);
 169 struct dispatch_io_s {
 170         DISPATCH_STRUCT_HEADER(io);
 171         dispatch_queue_t queue, barrier_queue;
 172         dispatch_group_t barrier_group;
 173         dispatch_io_param_s params;
 174         dispatch_fd_entry_t fd_entry;
 175         unsigned int atomic_flags;
 176         dispatch_fd_t fd, fd_actual;
 177         off_t f_ptr;
 178         int err; // contains creation errors only
 179 };
 180
 181 void _dispatch_io_set_target_queue(dispatch_io_t channel, dispatch_queue_t dq);
 182 size_t _dispatch_io_debug(dispatch_io_t channel, char* buf, size_t bufsiz);
 183 void _dispatch_io_dispose(dispatch_io_t channel);
 184 size_t _dispatch_operation_debug(dispatch_operation_t op, char* buf,
 185                 size_t bufsiz);
 186 void _dispatch_operation_dispose(dispatch_operation_t operation);
 187 void _dispatch_disk_dispose(dispatch_disk_t disk);
 188
 189 #endif // __DISPATCH_IO_INTERNAL__