libexfat/io.c

   1 /*
   2         io.c (02.09.09)
   3         exFAT file system implementation library.
   4
   5         Free exFAT implementation.
   6         Copyright (C) 2010-2018  Andrew Nayenko
   7
   8         This program is free software; you can redistribute it and/or modify
   9         it under the terms of the GNU General Public License as published by
  10         the Free Software Foundation, either version 2 of the License, or
  11         (at your option) any later version.
  12
  13         This program is distributed in the hope that it will be useful,
  14         but WITHOUT ANY WARRANTY; without even the implied warranty of
  15         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16         GNU General Public License for more details.
  17
  18         You should have received a copy of the GNU General Public License along
  19         with this program; if not, write to the Free Software Foundation, Inc.,
  20         51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  21 */
  22
  23 #include "exfat.h"
  24 #include <inttypes.h>
  25 #include <sys/types.h>
  26 #include <sys/stat.h>
  27 #include <fcntl.h>
  28 #include <unistd.h>
  29 #include <string.h>
  30 #include <errno.h>
  31 #if defined(__APPLE__)
  32 #include <sys/disk.h>
  33 #elif defined(__OpenBSD__)
  34 #include <sys/param.h>
  35 #include <sys/disklabel.h>
  36 #include <sys/dkio.h>
  37 #include <sys/ioctl.h>
  38 #elif __linux__
  39 #include <sys/mount.h>
  40 #endif
  41 #ifdef USE_UBLIO
  42 #include <sys/uio.h>
  43 #include <ublio.h>
  44 #endif
  45
  46 struct exfat_dev
  47 {
  48         int fd;
  49         enum exfat_mode mode;
  50         off_t size; /* in bytes */
  51 #ifdef USE_UBLIO
  52         off_t pos;
  53         ublio_filehandle_t ufh;
  54 #endif
  55 };
  56
  57 static bool is_open(int fd)
  58 {
  59         return fcntl(fd, F_GETFD) != -1;
  60 }
  61
  62 static int open_ro(const char* spec)
  63 {
  64         return open(spec, O_RDONLY);
  65 }
  66
  67 static int open_rw(const char* spec)
  68 {
  69         int fd = open(spec, O_RDWR);
  70 #ifdef __linux__
  71         int ro = 0;
  72
  73         /*
  74            This ioctl is needed because after "blockdev --setro" kernel still
  75            allows to open the device in read-write mode but fails writes.
  76         */
  77         if (fd != -1 && ioctl(fd, BLKROGET, &ro) == 0 && ro)
  78         {
  79                 close(fd);
  80                 errno = EROFS;
  81                 return -1;
  82         }
  83 #endif
  84         return fd;
  85 }
  86
  87 struct exfat_dev* exfat_open(const char* spec, enum exfat_mode mode)
  88 {
  89         struct exfat_dev* dev;
  90         struct stat stbuf;
  91 #ifdef USE_UBLIO
  92         struct ublio_param up;
  93 #endif
  94
  95         /* The system allocates file descriptors sequentially. If we have been
  96            started with stdin (0), stdout (1) or stderr (2) closed, the system
  97            will give us descriptor 0, 1 or 2 later when we open block device,
  98            FUSE communication pipe, etc. As a result, functions using stdin,
  99            stdout or stderr will actually work with a different thing and can
 100            corrupt it. Protect descriptors 0, 1 and 2 from such misuse. */
 101         while (!is_open(STDIN_FILENO)
 102                 || !is_open(STDOUT_FILENO)
 103                 || !is_open(STDERR_FILENO))
 104         {
 105                 /* we don't need those descriptors, let them leak */
 106                 if (open("/dev/null", O_RDWR) == -1)
 107                 {
 108                         exfat_error("failed to open /dev/null");
 109                         return NULL;
 110                 }
 111         }
 112
 113         dev = malloc(sizeof(struct exfat_dev));
 114         if (dev == NULL)
 115         {
 116                 exfat_error("failed to allocate memory for device structure");
 117                 return NULL;
 118         }
 119
 120         switch (mode)
 121         {
 122         case EXFAT_MODE_RO:
 123                 dev->fd = open_ro(spec);
 124                 if (dev->fd == -1)
 125                 {
 126                         free(dev);
 127                         exfat_error("failed to open '%s' in read-only mode: %s", spec,
 128                                         strerror(errno));
 129                         return NULL;
 130                 }
 131                 dev->mode = EXFAT_MODE_RO;
 132                 break;
 133         case EXFAT_MODE_RW:
 134                 dev->fd = open_rw(spec);
 135                 if (dev->fd == -1)
 136                 {
 137                         free(dev);
 138                         exfat_error("failed to open '%s' in read-write mode: %s", spec,
 139                                         strerror(errno));
 140                         return NULL;
 141                 }
 142                 dev->mode = EXFAT_MODE_RW;
 143                 break;
 144         case EXFAT_MODE_ANY:
 145                 dev->fd = open_rw(spec);
 146                 if (dev->fd != -1)
 147                 {
 148                         dev->mode = EXFAT_MODE_RW;
 149                         break;
 150                 }
 151                 dev->fd = open_ro(spec);
 152                 if (dev->fd != -1)
 153                 {
 154                         dev->mode = EXFAT_MODE_RO;
 155                         exfat_warn("'%s' is write-protected, mounting read-only", spec);
 156                         break;
 157                 }
 158                 free(dev);
 159                 exfat_error("failed to open '%s': %s", spec, strerror(errno));
 160                 return NULL;
 161         }
 162
 163         if (fstat(dev->fd, &stbuf) != 0)
 164         {
 165                 close(dev->fd);
 166                 free(dev);
 167                 exfat_error("failed to fstat '%s'", spec);
 168                 return NULL;
 169         }
 170         if (!S_ISBLK(stbuf.st_mode) &&
 171                 !S_ISCHR(stbuf.st_mode) &&
 172                 !S_ISREG(stbuf.st_mode))
 173         {
 174                 close(dev->fd);
 175                 free(dev);
 176                 exfat_error("'%s' is neither a device, nor a regular file", spec);
 177                 return NULL;
 178         }
 179
 180 #if defined(__APPLE__)
 181         if (!S_ISREG(stbuf.st_mode))
 182         {
 183                 uint32_t block_size = 0;
 184                 uint64_t blocks = 0;
 185
 186                 if (ioctl(dev->fd, DKIOCGETBLOCKSIZE, &block_size) != 0)
 187                 {
 188                         close(dev->fd);
 189                         free(dev);
 190                         exfat_error("failed to get block size");
 191                         return NULL;
 192                 }
 193                 if (ioctl(dev->fd, DKIOCGETBLOCKCOUNT, &blocks) != 0)
 194                 {
 195                         close(dev->fd);
 196                         free(dev);
 197                         exfat_error("failed to get blocks count");
 198                         return NULL;
 199                 }
 200                 dev->size = blocks * block_size;
 201         }
 202         else
 203 #elif defined(__OpenBSD__)
 204         if (!S_ISREG(stbuf.st_mode))
 205         {
 206                 struct disklabel lab;
 207                 struct partition* pp;
 208                 char* partition;
 209
 210                 if (ioctl(dev->fd, DIOCGDINFO, &lab) == -1)
 211                 {
 212                         close(dev->fd);
 213                         free(dev);
 214                         exfat_error("failed to get disklabel");
 215                         return NULL;
 216                 }
 217
 218                 /* Don't need to check that partition letter is valid as we won't get
 219                    this far otherwise. */
 220                 partition = strchr(spec, '\0') - 1;
 221                 pp = &(lab.d_partitions[*partition - 'a']);
 222                 dev->size = DL_GETPSIZE(pp) * lab.d_secsize;
 223
 224                 if (pp->p_fstype != FS_NTFS)
 225                         exfat_warn("partition type is not 0x07 (NTFS/exFAT); "
 226                                         "you can fix this with fdisk(8)");
 227         }
 228         else
 229 #endif
 230         {
 231                 /* works for Linux, FreeBSD, Solaris */
 232                 dev->size = exfat_seek(dev, 0, SEEK_END);
 233                 if (dev->size <= 0)
 234                 {
 235                         close(dev->fd);
 236                         free(dev);
 237                         exfat_error("failed to get size of '%s'", spec);
 238                         return NULL;
 239                 }
 240                 if (exfat_seek(dev, 0, SEEK_SET) == -1)
 241                 {
 242                         close(dev->fd);
 243                         free(dev);
 244                         exfat_error("failed to seek to the beginning of '%s'", spec);
 245                         return NULL;
 246                 }
 247         }
 248
 249 #ifdef USE_UBLIO
 250         memset(&up, 0, sizeof(struct ublio_param));
 251         up.up_blocksize = 256 * 1024;
 252         up.up_items = 64;
 253         up.up_grace = 32;
 254         up.up_priv = &dev->fd;
 255
 256         dev->pos = 0;
 257         dev->ufh = ublio_open(&up);
 258         if (dev->ufh == NULL)
 259         {
 260                 close(dev->fd);
 261                 free(dev);
 262                 exfat_error("failed to initialize ublio");
 263                 return NULL;
 264         }
 265 #endif
 266
 267         return dev;
 268 }
 269
 270 int exfat_close(struct exfat_dev* dev)
 271 {
 272         int rc = 0;
 273
 274 #ifdef USE_UBLIO
 275         if (ublio_close(dev->ufh) != 0)
 276         {
 277                 exfat_error("failed to close ublio");
 278                 rc = -EIO;
 279         }
 280 #endif
 281         if (close(dev->fd) != 0)
 282         {
 283                 exfat_error("failed to close device: %s", strerror(errno));
 284                 rc = -EIO;
 285         }
 286         free(dev);
 287         return rc;
 288 }
 289
 290 int exfat_fsync(struct exfat_dev* dev)
 291 {
 292         int rc = 0;
 293
 294 #ifdef USE_UBLIO
 295         if (ublio_fsync(dev->ufh) != 0)
 296         {
 297                 exfat_error("ublio fsync failed");
 298                 rc = -EIO;
 299         }
 300 #endif
 301         if (fsync(dev->fd) != 0)
 302         {
 303                 exfat_error("fsync failed: %s", strerror(errno));
 304                 rc = -EIO;
 305         }
 306         return rc;
 307 }
 308
 309 enum exfat_mode exfat_get_mode(const struct exfat_dev* dev)
 310 {
 311         return dev->mode;
 312 }
 313
 314 off_t exfat_get_size(const struct exfat_dev* dev)
 315 {
 316         return dev->size;
 317 }
 318
 319 off_t exfat_seek(struct exfat_dev* dev, off_t offset, int whence)
 320 {
 321 #ifdef USE_UBLIO
 322         /* XXX SEEK_CUR will be handled incorrectly */
 323         return dev->pos = lseek(dev->fd, offset, whence);
 324 #else
 325         return lseek(dev->fd, offset, whence);
 326 #endif
 327 }
 328
 329 ssize_t exfat_read(struct exfat_dev* dev, void* buffer, size_t size)
 330 {
 331 #ifdef USE_UBLIO
 332         ssize_t result = ublio_pread(dev->ufh, buffer, size, dev->pos);
 333         if (result >= 0)
 334                 dev->pos += size;
 335         return result;
 336 #else
 337         return read(dev->fd, buffer, size);
 338 #endif
 339 }
 340
 341 ssize_t exfat_write(struct exfat_dev* dev, const void* buffer, size_t size)
 342 {
 343 #ifdef USE_UBLIO
 344         ssize_t result = ublio_pwrite(dev->ufh, buffer, size, dev->pos);
 345         if (result >= 0)
 346                 dev->pos += size;
 347         return result;
 348 #else
 349         return write(dev->fd, buffer, size);
 350 #endif
 351 }
 352
 353 ssize_t exfat_pread(struct exfat_dev* dev, void* buffer, size_t size,
 354                 off_t offset)
 355 {
 356 #ifdef USE_UBLIO
 357         return ublio_pread(dev->ufh, buffer, size, offset);
 358 #else
 359         return pread(dev->fd, buffer, size, offset);
 360 #endif
 361 }
 362
 363 ssize_t exfat_pwrite(struct exfat_dev* dev, const void* buffer, size_t size,
 364                 off_t offset)
 365 {
 366 #ifdef USE_UBLIO
 367         return ublio_pwrite(dev->ufh, buffer, size, offset);
 368 #else
 369         return pwrite(dev->fd, buffer, size, offset);
 370 #endif
 371 }
 372
 373 ssize_t exfat_generic_pread(const struct exfat* ef, struct exfat_node* node,
 374                 void* buffer, size_t size, off_t offset)
 375 {
 376         cluster_t cluster;
 377         char* bufp = buffer;
 378         off_t lsize, loffset, remainder;
 379
 380         if (offset >= node->size)
 381                 return 0;
 382         if (size == 0)
 383                 return 0;
 384
 385         cluster = exfat_advance_cluster(ef, node, offset / CLUSTER_SIZE(*ef->sb));
 386         if (CLUSTER_INVALID(*ef->sb, cluster))
 387         {
 388                 exfat_error("invalid cluster 0x%x while reading", cluster);
 389                 return -EIO;
 390         }
 391
 392         loffset = offset % CLUSTER_SIZE(*ef->sb);
 393         remainder = MIN(size, node->size - offset);
 394         while (remainder > 0)
 395         {
 396                 if (CLUSTER_INVALID(*ef->sb, cluster))
 397                 {
 398                         exfat_error("invalid cluster 0x%x while reading", cluster);
 399                         return -EIO;
 400                 }
 401                 lsize = MIN(CLUSTER_SIZE(*ef->sb) - loffset, remainder);
 402                 if (exfat_pread(ef->dev, bufp, lsize,
 403                                         exfat_c2o(ef, cluster) + loffset) < 0)
 404                 {
 405                         exfat_error("failed to read cluster %#x", cluster);
 406                         return -EIO;
 407                 }
 408                 bufp += lsize;
 409                 loffset = 0;
 410                 remainder -= lsize;
 411                 cluster = exfat_next_cluster(ef, node, cluster);
 412         }
 413         if (!(node->attrib & EXFAT_ATTRIB_DIR) && !ef->ro && !ef->noatime)
 414                 exfat_update_atime(node);
 415         return MIN(size, node->size - offset) - remainder;
 416 }
 417
 418 ssize_t exfat_generic_pwrite(struct exfat* ef, struct exfat_node* node,
 419                 const void* buffer, size_t size, off_t offset)
 420 {
 421         int rc;
 422         cluster_t cluster;
 423         const char* bufp = buffer;
 424         off_t lsize, loffset, remainder;
 425
 426         if (offset > node->size)
 427         {
 428                 rc = exfat_truncate(ef, node, offset, true);
 429                 if (rc != 0)
 430                         return rc;
 431         }
 432         if (offset + size > node->size)
 433         {
 434                 rc = exfat_truncate(ef, node, offset + size, false);
 435                 if (rc != 0)
 436                         return rc;
 437         }
 438         if (size == 0)
 439                 return 0;
 440
 441         cluster = exfat_advance_cluster(ef, node, offset / CLUSTER_SIZE(*ef->sb));
 442         if (CLUSTER_INVALID(*ef->sb, cluster))
 443         {
 444                 exfat_error("invalid cluster 0x%x while writing", cluster);
 445                 return -EIO;
 446         }
 447
 448         loffset = offset % CLUSTER_SIZE(*ef->sb);
 449         remainder = size;
 450         while (remainder > 0)
 451         {
 452                 if (CLUSTER_INVALID(*ef->sb, cluster))
 453                 {
 454                         exfat_error("invalid cluster 0x%x while writing", cluster);
 455                         return -EIO;
 456                 }
 457                 lsize = MIN(CLUSTER_SIZE(*ef->sb) - loffset, remainder);
 458                 if (exfat_pwrite(ef->dev, bufp, lsize,
 459                                 exfat_c2o(ef, cluster) + loffset) < 0)
 460                 {
 461                         exfat_error("failed to write cluster %#x", cluster);
 462                         return -EIO;
 463                 }
 464                 bufp += lsize;
 465                 loffset = 0;
 466                 remainder -= lsize;
 467                 cluster = exfat_next_cluster(ef, node, cluster);
 468         }
 469         if (!(node->attrib & EXFAT_ATTRIB_DIR))
 470                 /* directory's mtime should be updated by the caller only when it
 471                    creates or removes something in this directory */
 472                 exfat_update_mtime(node);
 473         return size - remainder;
 474 }