1 /** 2 * unix_io.c - Unix style disk io functions. Originated from the Linux-NTFS project. 3 * 4 * Copyright (c) 2000-2006 Anton Altaparmakov 5 * 6 * This program/include file is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License as published 8 * by the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program/include file is distributed in the hope that it will be 12 * useful, but WITHOUT ANY WARRANTY; without even the implied warranty 13 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program (in the main directory of the NTFS-3G 18 * distribution in the file COPYING); if not, write to the Free Software 19 * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 20 */ 21 22 #ifdef HAVE_CONFIG_H 23 #include "config.h" 24 #endif 25 26 #ifdef HAVE_UNISTD_H 27 #include <unistd.h> 28 #endif 29 #ifdef HAVE_STDLIB_H 30 #include <stdlib.h> 31 #endif 32 #ifdef HAVE_STRING_H 33 #include <string.h> 34 #endif 35 #ifdef HAVE_ERRNO_H 36 #include <errno.h> 37 #endif 38 #ifdef HAVE_STDIO_H 39 #include <stdio.h> 40 #endif 41 #ifdef HAVE_SYS_TYPES_H 42 #include <sys/types.h> 43 #endif 44 #ifdef HAVE_SYS_STAT_H 45 #include <sys/stat.h> 46 #endif 47 #ifdef HAVE_FCNTL_H 48 #include <fcntl.h> 49 #endif 50 #ifdef HAVE_SYS_IOCTL_H 51 #include <sys/ioctl.h> 52 #endif 53 #ifdef HAVE_LINUX_FD_H 54 #include <linux/fd.h> 55 #endif 56 #ifdef HAVE_LINUX_FS_H 57 #include <linux/fs.h> 58 #endif 59 60 #include "types.h" 61 #include "mst.h" 62 #include "debug.h" 63 #include "device.h" 64 #include "logging.h" 65 #include "misc.h" 66 67 #define DEV_FD(dev) (*(int *)dev->d_private) 68 69 /* Define to nothing if not present on this system. */ 70 #ifndef O_EXCL 71 # define O_EXCL 0 72 #endif 73 74 /** 75 * fsync replacement which makes every effort to try to get the data down to 76 * disk, using different means for different operating systems. Specifically, 77 * it issues the proper fcntl for Mac OS X or does fsync where it is available 78 * or as a last resort calls the fsync function. Information on this problem 79 * was retrieved from: 80 * http://mirror.linux.org.au/pub/linux.conf.au/2007/video/talks/278.pdf 81 */ 82 static int ntfs_fsync(int fildes) 83 { 84 int ret = -1; 85 #if defined(__APPLE__) || defined(__DARWIN__) 86 # ifndef F_FULLFSYNC 87 # error "Mac OS X: F_FULLFSYNC is not defined. Either you didn't include fcntl.h or you're using an older, unsupported version of Mac OS X (pre-10.3)." 88 # endif 89 /* 90 * Apple has disabled fsync() for internal disk drives in OS X. 91 * To force a synchronization of disk contents, we use a Mac OS X 92 * specific fcntl, F_FULLFSYNC. 93 */ 94 ret = fcntl(fildes, F_FULLFSYNC, NULL); 95 if (ret) { 96 /* 97 * If we are not on a file system that supports this, 98 * then fall back to a plain fsync. 99 */ 100 ret = fsync(fildes); 101 } 102 #else 103 ret = fsync(fildes); 104 #endif 105 return ret; 106 } 107 108 /** 109 * ntfs_device_unix_io_open - Open a device and lock it exclusively 110 * @dev: 111 * @flags: 112 * 113 * Description... 114 * 115 * Returns: 116 */ 117 static int ntfs_device_unix_io_open(struct ntfs_device *dev, int flags) 118 { 119 struct flock flk; 120 struct stat sbuf; 121 int err; 122 123 if (NDevOpen(dev)) { 124 errno = EBUSY; 125 return -1; 126 } 127 if (stat(dev->d_name, &sbuf)) { 128 ntfs_log_perror("Failed to access '%s'", dev->d_name); 129 return -1; 130 } 131 if (S_ISBLK(sbuf.st_mode)) 132 NDevSetBlock(dev); 133 134 dev->d_private = ntfs_malloc(sizeof(int)); 135 if (!dev->d_private) 136 return -1; 137 /* 138 * Open file for exclusive access if mounting r/w. 139 * Fuseblk takes care about block devices. 140 */ 141 if (!NDevBlock(dev) && (flags & O_RDWR) == O_RDWR) 142 flags |= O_EXCL; 143 *(int*)dev->d_private = open(dev->d_name, flags); 144 if (*(int*)dev->d_private == -1) { 145 err = errno; 146 /* if permission error and rw, retry read-only */ 147 if ((err == EACCES) && ((flags & O_RDWR) == O_RDWR)) 148 err = EROFS; 149 goto err_out; 150 } 151 #ifdef HAVE_LINUX_FS_H 152 /* Check whether the device was forced read-only */ 153 if (NDevBlock(dev) && ((flags & O_RDWR) == O_RDWR)) { 154 int r; 155 int state; 156 157 r = ioctl(DEV_FD(dev), BLKROGET, &state); 158 if (!r && state) { 159 err = EROFS; 160 if (close(DEV_FD(dev))) 161 err = errno; 162 goto err_out; 163 } 164 } 165 #endif 166 167 if ((flags & O_RDWR) != O_RDWR) 168 NDevSetReadOnly(dev); 169 170 memset(&flk, 0, sizeof(flk)); 171 if (NDevReadOnly(dev)) 172 flk.l_type = F_RDLCK; 173 else 174 flk.l_type = F_WRLCK; 175 flk.l_whence = SEEK_SET; 176 flk.l_start = flk.l_len = 0LL; 177 if (fcntl(DEV_FD(dev), F_SETLK, &flk)) { 178 err = errno; 179 ntfs_log_perror("Failed to %s lock '%s'", NDevReadOnly(dev) ? 180 "read" : "write", dev->d_name); 181 if (close(DEV_FD(dev))) 182 ntfs_log_perror("Failed to close '%s'", dev->d_name); 183 goto err_out; 184 } 185 186 NDevSetOpen(dev); 187 return 0; 188 err_out: 189 free(dev->d_private); 190 dev->d_private = NULL; 191 errno = err; 192 return -1; 193 } 194 195 /** 196 * ntfs_device_unix_io_close - Close the device, releasing the lock 197 * @dev: 198 * 199 * Description... 200 * 201 * Returns: 202 */ 203 static int ntfs_device_unix_io_close(struct ntfs_device *dev) 204 { 205 struct flock flk; 206 207 if (!NDevOpen(dev)) { 208 errno = EBADF; 209 ntfs_log_perror("Device %s is not open", dev->d_name); 210 return -1; 211 } 212 if (NDevDirty(dev)) 213 if (ntfs_fsync(DEV_FD(dev))) { 214 ntfs_log_perror("Failed to fsync device %s", dev->d_name); 215 return -1; 216 } 217 218 memset(&flk, 0, sizeof(flk)); 219 flk.l_type = F_UNLCK; 220 flk.l_whence = SEEK_SET; 221 flk.l_start = flk.l_len = 0LL; 222 if (fcntl(DEV_FD(dev), F_SETLK, &flk)) 223 ntfs_log_perror("Could not unlock %s", dev->d_name); 224 if (close(DEV_FD(dev))) { 225 ntfs_log_perror("Failed to close device %s", dev->d_name); 226 return -1; 227 } 228 NDevClearOpen(dev); 229 free(dev->d_private); 230 dev->d_private = NULL; 231 return 0; 232 } 233 234 /** 235 * ntfs_device_unix_io_seek - Seek to a place on the device 236 * @dev: 237 * @offset: 238 * @whence: 239 * 240 * Description... 241 * 242 * Returns: 243 */ 244 static s64 ntfs_device_unix_io_seek(struct ntfs_device *dev, s64 offset, 245 int whence) 246 { 247 return lseek(DEV_FD(dev), offset, whence); 248 } 249 250 /** 251 * ntfs_device_unix_io_read - Read from the device, from the current location 252 * @dev: 253 * @buf: 254 * @count: 255 * 256 * Description... 257 * 258 * Returns: 259 */ 260 static s64 ntfs_device_unix_io_read(struct ntfs_device *dev, void *buf, 261 s64 count) 262 { 263 return read(DEV_FD(dev), buf, count); 264 } 265 266 /** 267 * ntfs_device_unix_io_write - Write to the device, at the current location 268 * @dev: 269 * @buf: 270 * @count: 271 * 272 * Description... 273 * 274 * Returns: 275 */ 276 static s64 ntfs_device_unix_io_write(struct ntfs_device *dev, const void *buf, 277 s64 count) 278 { 279 if (NDevReadOnly(dev)) { 280 errno = EROFS; 281 return -1; 282 } 283 NDevSetDirty(dev); 284 return write(DEV_FD(dev), buf, count); 285 } 286 287 /** 288 * ntfs_device_unix_io_pread - Perform a positioned read from the device 289 * @dev: 290 * @buf: 291 * @count: 292 * @offset: 293 * 294 * Description... 295 * 296 * Returns: 297 */ 298 static s64 ntfs_device_unix_io_pread(struct ntfs_device *dev, void *buf, 299 s64 count, s64 offset) 300 { 301 return pread(DEV_FD(dev), buf, count, offset); 302 } 303 304 /** 305 * ntfs_device_unix_io_pwrite - Perform a positioned write to the device 306 * @dev: 307 * @buf: 308 * @count: 309 * @offset: 310 * 311 * Description... 312 * 313 * Returns: 314 */ 315 static s64 ntfs_device_unix_io_pwrite(struct ntfs_device *dev, const void *buf, 316 s64 count, s64 offset) 317 { 318 if (NDevReadOnly(dev)) { 319 errno = EROFS; 320 return -1; 321 } 322 NDevSetDirty(dev); 323 return pwrite(DEV_FD(dev), buf, count, offset); 324 } 325 326 /** 327 * ntfs_device_unix_io_sync - Flush any buffered changes to the device 328 * @dev: 329 * 330 * Description... 331 * 332 * Returns: 333 */ 334 static int ntfs_device_unix_io_sync(struct ntfs_device *dev) 335 { 336 int res = 0; 337 338 if (!NDevReadOnly(dev)) { 339 res = ntfs_fsync(DEV_FD(dev)); 340 if (res) 341 ntfs_log_perror("Failed to sync device %s", dev->d_name); 342 else 343 NDevClearDirty(dev); 344 } 345 return res; 346 } 347 348 /** 349 * ntfs_device_unix_io_stat - Get information about the device 350 * @dev: 351 * @buf: 352 * 353 * Description... 354 * 355 * Returns: 356 */ 357 static int ntfs_device_unix_io_stat(struct ntfs_device *dev, struct stat *buf) 358 { 359 return fstat(DEV_FD(dev), buf); 360 } 361 362 /** 363 * ntfs_device_unix_io_ioctl - Perform an ioctl on the device 364 * @dev: 365 * @request: 366 * @argp: 367 * 368 * Description... 369 * 370 * Returns: 371 */ 372 static int ntfs_device_unix_io_ioctl(struct ntfs_device *dev, 373 unsigned long request, void *argp) 374 { 375 return ioctl(DEV_FD(dev), request, argp); 376 } 377 378 /** 379 * Device operations for working with unix style devices and files. 380 */ 381 struct ntfs_device_operations ntfs_device_unix_io_ops = { 382 .open = ntfs_device_unix_io_open, 383 .close = ntfs_device_unix_io_close, 384 .seek = ntfs_device_unix_io_seek, 385 .read = ntfs_device_unix_io_read, 386 .write = ntfs_device_unix_io_write, 387 .pread = ntfs_device_unix_io_pread, 388 .pwrite = ntfs_device_unix_io_pwrite, 389 .sync = ntfs_device_unix_io_sync, 390 .stat = ntfs_device_unix_io_stat, 391 .ioctl = ntfs_device_unix_io_ioctl, 392 }; 393