lib/util/sys_rw.c

   1 /*
   2  * Unix SMB/CIFS implementation.
   3  * Samba system utilities
   4  * Copyright (C) Andrew Tridgell 1992-1998
   5  * Copyright (C) Jeremy Allison  1998-2005
   6  * Copyright (C) Timur Bakeyev        2005
   7  * Copyright (C) Bjoern Jacke    2006-2007
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 3 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21  */
  22
  23 #include "replace.h"
  24 #include "system/filesys.h"
  25 #include "lib/util/sys_rw.h"
  26 #include <assert.h>
  27
  28 bool sys_valid_io_range(off_t offset, size_t length)
  29 {
  30         uint64_t last_byte_ofs;
  31
  32         if (offset < 0) {
  33                 return false;
  34         }
  35
  36         if (offset > INT64_MAX) {
  37                 return false;
  38         }
  39
  40         if (length > UINT32_MAX) {
  41                 return false;
  42         }
  43
  44         last_byte_ofs = (uint64_t)offset + (uint64_t)length;
  45         if (last_byte_ofs > INT64_MAX) {
  46                 return false;
  47         }
  48
  49         return true;
  50 }
  51
  52 bool sys_io_ranges_overlap(size_t c1, off_t o1,
  53                            size_t c2, off_t o2)
  54 {
  55         if (c1 == 0 || c2 == 0) {
  56                 return false;
  57         }
  58         if (o2 < o1) {
  59                 /*
  60                  *          o1
  61                  *          |····c1····|
  62                  *  o2
  63                  *  |····c2···| ?
  64                  */
  65                 return (o2 + c2 > o1);
  66         } else {
  67                 /*
  68                  *  o1
  69                  *  |····c1···|
  70                  *          o2
  71                  *          |····c2····| ?
  72                  */
  73                 return (o1 + c1 > o2);
  74         }
  75 }
  76
  77 off_t sys_block_align_truncate(off_t len, off_t align)
  78 {
  79         assert(align > 1);
  80         assert(((align - 1) & align) == 0);
  81         return len & (~align + 1);
  82 }
  83
  84 off_t sys_block_align(off_t len, off_t align)
  85 {
  86         assert(align > 1);
  87         assert(((align - 1) & align) == 0);
  88         return (len + (align - 1)) & ~(align - 1);
  89 }
  90
  91 /*******************************************************************
  92 A read wrapper that will deal with EINTR/EWOULDBLOCK
  93 ********************************************************************/
  94
  95 ssize_t sys_read(int fd, void *buf, size_t count)
  96 {
  97         ssize_t ret;
  98
  99         do {
 100                 ret = read(fd, buf, count);
 101         } while (ret == -1 && (errno == EINTR || errno == EAGAIN ||
 102                                errno == EWOULDBLOCK));
 103
 104         return ret;
 105 }
 106
 107 /**
 108  * read wrapper, void variant:
 109  * This is intended to be used as a void variant of
 110  * read in situations where the caller wants to ignore
 111  * the result. Hence not checking for EAGAIN|EWOULDBLOCK.
 112  */
 113 void sys_read_v(int fd, void *buf, size_t count)
 114 {
 115         ssize_t ret;
 116
 117         do {
 118                 ret = read(fd, buf, count);
 119         } while (ret == -1 && errno == EINTR);
 120 }
 121
 122
 123 /*******************************************************************
 124 A write wrapper that will deal with EINTR/EWOULDBLOCK.
 125 ********************************************************************/
 126
 127 ssize_t sys_write(int fd, const void *buf, size_t count)
 128 {
 129         ssize_t ret;
 130
 131         do {
 132                 ret = write(fd, buf, count);
 133         } while (ret == -1 && (errno == EINTR || errno == EAGAIN ||
 134                                errno == EWOULDBLOCK));
 135
 136         return ret;
 137 }
 138
 139 /**
 140  * write wrapper to deal with EINTR and friends.
 141  * void-variant that ignores the number of bytes written.
 142  * This is intended to be used as a void variant of
 143  * write in situations where the caller wants to ignore
 144  * the result. Hence not checking for EAGAIN|EWOULDBLOCK.
 145  */
 146 void sys_write_v(int fd, const void *buf, size_t count)
 147 {
 148         ssize_t ret;
 149
 150         do {
 151                 ret = write(fd, buf, count);
 152         } while (ret == -1 && errno == EINTR);
 153 }
 154
 155
 156 /*******************************************************************
 157 A writev wrapper that will deal with EINTR.
 158 ********************************************************************/
 159
 160 ssize_t sys_writev(int fd, const struct iovec *iov, int iovcnt)
 161 {
 162         ssize_t ret;
 163
 164         do {
 165                 ret = writev(fd, iov, iovcnt);
 166         } while (ret == -1 && (errno == EINTR || errno == EAGAIN ||
 167                                errno == EWOULDBLOCK));
 168
 169         return ret;
 170 }
 171
 172 /*******************************************************************
 173 A pread wrapper that will deal with EINTR
 174 ********************************************************************/
 175
 176 ssize_t sys_pread(int fd, void *buf, size_t count, off_t off)
 177 {
 178         ssize_t ret;
 179
 180         do {
 181                 ret = pread(fd, buf, count, off);
 182         } while (ret == -1 && errno == EINTR);
 183         return ret;
 184 }
 185
 186 /*******************************************************************
 187  A pread wrapper that will deal with EINTR and never return a short
 188  read unless pread returns zero meaning EOF.
 189 ********************************************************************/
 190
 191 ssize_t sys_pread_full(int fd, void *buf, size_t count, off_t off)
 192 {
 193         ssize_t total_read = 0;
 194         uint8_t *curr_buf = (uint8_t *)buf;
 195         size_t curr_count = count;
 196         off_t curr_off = off;
 197         bool ok;
 198
 199         ok = sys_valid_io_range(off, count);
 200         if (!ok) {
 201                 errno = EINVAL;
 202                 return -1;
 203         }
 204
 205         while (curr_count != 0) {
 206                 ssize_t ret = sys_pread(fd,
 207                                         curr_buf,
 208                                         curr_count,
 209                                         curr_off);
 210
 211                 if (ret == -1) {
 212                         return -1;
 213                 }
 214                 if (ret == 0) {
 215                         /* EOF */
 216                         break;
 217                 }
 218
 219                 if (ret > curr_count) {
 220                         errno = EIO;
 221                         return -1;
 222                 }
 223
 224                 curr_buf += ret;
 225                 curr_count -= ret;
 226                 curr_off += ret;
 227
 228                 total_read += ret;
 229         }
 230
 231         return total_read;
 232 }
 233
 234 /*******************************************************************
 235 A write wrapper that will deal with EINTR
 236 ********************************************************************/
 237
 238 ssize_t sys_pwrite(int fd, const void *buf, size_t count, off_t off)
 239 {
 240         ssize_t ret;
 241
 242         do {
 243                 ret = pwrite(fd, buf, count, off);
 244         } while (ret == -1 && errno == EINTR);
 245         return ret;
 246 }
 247
 248 /*******************************************************************
 249  A pwrite wrapper that will deal with EINTR and never allow a short
 250  write unless the file system returns an error.
 251 ********************************************************************/
 252
 253 ssize_t sys_pwrite_full(int fd, const void *buf, size_t count, off_t off)
 254 {
 255         ssize_t total_written = 0;
 256         const uint8_t *curr_buf = (const uint8_t *)buf;
 257         size_t curr_count = count;
 258         off_t curr_off = off;
 259         bool ok;
 260
 261         ok = sys_valid_io_range(off, count);
 262         if (!ok) {
 263                 errno = EINVAL;
 264                 return -1;
 265         }
 266
 267         while (curr_count != 0) {
 268                 ssize_t ret = sys_pwrite(fd,
 269                                          curr_buf,
 270                                          curr_count,
 271                                          curr_off);
 272
 273                 if (ret == -1) {
 274                         return -1;
 275                 }
 276                 if (ret == 0) {
 277                         /* Ensure we can never spin. */
 278                         errno = ENOSPC;
 279                         return -1;
 280                 }
 281
 282                 if (ret > curr_count) {
 283                         errno = EIO;
 284                         return -1;
 285                 }
 286
 287                 curr_buf += ret;
 288                 curr_count -= ret;
 289                 curr_off += ret;
 290
 291                 total_written += ret;
 292         }
 293
 294         return total_written;
 295 }
 296
 297 /*******************************************************************
 298  A write wrapper that will deal with EINTR and never allow a short
 299  write unless the file system returns an error.
 300 ********************************************************************/
 301
 302 ssize_t sys_write_full(int fd, const void *buf, size_t count)
 303 {
 304         ssize_t total_written = 0;
 305         const uint8_t *curr_buf = (const uint8_t *)buf;
 306         size_t curr_count = count;
 307
 308         while (curr_count != 0) {
 309                 ssize_t ret = sys_write(fd,
 310                                         curr_buf,
 311                                         curr_count);
 312                 if (ret == -1) {
 313                         return -1;
 314                 }
 315                 if (ret == 0) {
 316                         /* Ensure we can never spin. */
 317                         errno = ENOSPC;
 318                         return -1;
 319                 }
 320
 321                 if (ret > curr_count) {
 322                         errno = EIO;
 323                         return -1;
 324                 }
 325
 326                 curr_buf += ret;
 327                 curr_count -= ret;
 328
 329                 total_written += ret;
 330         }
 331
 332         return total_written;
 333 }