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_INTERNAL_CLASS_DECL(operation);
  70 DISPATCH_INTERNAL_CLASS_DECL(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 struct dispatch_disk_s {
  98         DISPATCH_OBJECT_HEADER(disk);
  99         TAILQ_HEAD(dispatch_disk_operations_s, dispatch_operation_s) operations;
 100         dispatch_operation_t cur_rq;
 101         dispatch_queue_t pick_queue;
 102
 103         size_t free_idx;
 104         size_t req_idx;
 105         size_t advise_idx;
 106         dev_t dev;
 107         bool io_active;
 108         TAILQ_ENTRY(dispatch_disk_s) disk_list;
 109         size_t advise_list_depth;
 110         dispatch_operation_t advise_list[];
 111 };
 112
 113 struct dispatch_fd_entry_s {
 114         dispatch_fd_t fd;
 115         dispatch_io_path_data_t path_data;
 116         int orig_flags, orig_nosigpipe, err;
 117 #if DISPATCH_USE_GUARDED_FD_CHANGE_FDGUARD
 118         int orig_fd_flags;
 119 #endif
 120 #if DISPATCH_USE_GUARDED_FD
 121         unsigned int guard_flags;
 122 #endif
 123         struct dispatch_stat_s stat;
 124         dispatch_stream_t streams[2];
 125         dispatch_disk_t disk;
 126         dispatch_queue_t close_queue, barrier_queue;
 127         dispatch_group_t barrier_group;
 128         dispatch_io_t convenience_channel;
 129         TAILQ_HEAD(, dispatch_operation_s) stream_ops;
 130         TAILQ_ENTRY(dispatch_fd_entry_s) fd_list;
 131 };
 132
 133 typedef struct dispatch_fd_entry_s *dispatch_fd_entry_t;
 134
 135 typedef struct dispatch_io_param_s {
 136         dispatch_io_type_t type; // STREAM OR RANDOM
 137         size_t low;
 138         size_t high;
 139         uint64_t interval;
 140         unsigned long interval_flags;
 141 } dispatch_io_param_s;
 142
 143 struct dispatch_operation_s {
 144         DISPATCH_OBJECT_HEADER(operation);
 145         dispatch_queue_t op_q;
 146         dispatch_op_direction_t direction; // READ OR WRITE
 147         dispatch_io_param_s params;
 148         off_t offset;
 149         size_t length;
 150         int err;
 151         dispatch_io_handler_t handler;
 152         dispatch_io_t channel;
 153         dispatch_fd_entry_t fd_entry;
 154         dispatch_source_t timer;
 155         bool active;
 156         off_t advise_offset;
 157         void* buf;
 158         dispatch_op_flags_t flags;
 159         size_t buf_siz, buf_len, undelivered, total;
 160         dispatch_data_t buf_data, data;
 161         TAILQ_ENTRY(dispatch_operation_s) operation_list;
 162         // the request list in the fd_entry stream_ops
 163         TAILQ_ENTRY(dispatch_operation_s) stream_list;
 164 };
 165
 166 DISPATCH_CLASS_DECL(io);
 167 struct dispatch_io_s {
 168         DISPATCH_OBJECT_HEADER(io);
 169         dispatch_queue_t queue, barrier_queue;
 170         dispatch_group_t barrier_group;
 171         dispatch_io_param_s params;
 172         dispatch_fd_entry_t fd_entry;
 173         unsigned int atomic_flags;
 174         dispatch_fd_t fd, fd_actual;
 175         off_t f_ptr;
 176         int err; // contains creation errors only
 177 };
 178
 179 void _dispatch_io_set_target_queue(dispatch_io_t channel, dispatch_queue_t dq);
 180 size_t _dispatch_io_debug(dispatch_io_t channel, char* buf, size_t bufsiz);
 181 void _dispatch_io_dispose(dispatch_io_t channel);
 182 size_t _dispatch_operation_debug(dispatch_operation_t op, char* buf,
 183                 size_t bufsiz);
 184 void _dispatch_operation_dispose(dispatch_operation_t operation);
 185 void _dispatch_disk_dispose(dispatch_disk_t disk);
 186
 187 #endif // __DISPATCH_IO_INTERNAL__