module/zfs/vdev_file.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
  23  * Copyright (c) 2011, 2016 by Delphix. All rights reserved.
  24  */
  25
  26 #include <sys/zfs_context.h>
  27 #include <sys/spa.h>
  28 #include <sys/spa_impl.h>
  29 #include <sys/vdev_file.h>
  30 #include <sys/vdev_impl.h>
  31 #include <sys/vdev_trim.h>
  32 #include <sys/zio.h>
  33 #include <sys/fs/zfs.h>
  34 #include <sys/fm/fs/zfs.h>
  35 #include <sys/abd.h>
  36 #include <sys/fcntl.h>
  37 #include <sys/vnode.h>
  38
  39 /*
  40  * Virtual device vector for files.
  41  */
  42
  43 static taskq_t *vdev_file_taskq;
  44
  45 static void
  46 vdev_file_hold(vdev_t *vd)
  47 {
  48         ASSERT(vd->vdev_path != NULL);
  49 }
  50
  51 static void
  52 vdev_file_rele(vdev_t *vd)
  53 {
  54         ASSERT(vd->vdev_path != NULL);
  55 }
  56
  57 static int
  58 vdev_file_open(vdev_t *vd, uint64_t *psize, uint64_t *max_psize,
  59     uint64_t *ashift)
  60 {
  61         vdev_file_t *vf;
  62         vnode_t *vp;
  63         vattr_t vattr;
  64         int error;
  65
  66         /*
  67          * Rotational optimizations only make sense on block devices.
  68          */
  69         vd->vdev_nonrot = B_TRUE;
  70
  71         /*
  72          * Allow TRIM on file based vdevs.  This may not always be supported,
  73          * since it depends on your kernel version and underlying filesystem
  74          * type but it is always safe to attempt.
  75          */
  76         vd->vdev_has_trim = B_TRUE;
  77
  78         /*
  79          * Disable secure TRIM on file based vdevs.  There is no way to
  80          * request this behavior from the underlying filesystem.
  81          */
  82         vd->vdev_has_securetrim = B_FALSE;
  83
  84         /*
  85          * We must have a pathname, and it must be absolute.
  86          */
  87         if (vd->vdev_path == NULL || vd->vdev_path[0] != '/') {
  88                 vd->vdev_stat.vs_aux = VDEV_AUX_BAD_LABEL;
  89                 return (SET_ERROR(EINVAL));
  90         }
  91
  92         /*
  93          * Reopen the device if it's not currently open.  Otherwise,
  94          * just update the physical size of the device.
  95          */
  96         if (vd->vdev_tsd != NULL) {
  97                 ASSERT(vd->vdev_reopening);
  98                 vf = vd->vdev_tsd;
  99                 goto skip_open;
 100         }
 101
 102         vf = vd->vdev_tsd = kmem_zalloc(sizeof (vdev_file_t), KM_SLEEP);
 103
 104         /*
 105          * We always open the files from the root of the global zone, even if
 106          * we're in a local zone.  If the user has gotten to this point, the
 107          * administrator has already decided that the pool should be available
 108          * to local zone users, so the underlying devices should be as well.
 109          */
 110         ASSERT(vd->vdev_path != NULL && vd->vdev_path[0] == '/');
 111         error = vn_openat(vd->vdev_path + 1, UIO_SYSSPACE,
 112             spa_mode(vd->vdev_spa) | FOFFMAX, 0, &vp, 0, 0, rootdir, -1);
 113
 114         if (error) {
 115                 vd->vdev_stat.vs_aux = VDEV_AUX_OPEN_FAILED;
 116                 return (error);
 117         }
 118
 119         vf->vf_vnode = vp;
 120
 121 #ifdef _KERNEL
 122         /*
 123          * Make sure it's a regular file.
 124          */
 125         if (vp->v_type != VREG) {
 126                 vd->vdev_stat.vs_aux = VDEV_AUX_OPEN_FAILED;
 127                 return (SET_ERROR(ENODEV));
 128         }
 129 #endif
 130
 131 skip_open:
 132         /*
 133          * Determine the physical size of the file.
 134          */
 135         vattr.va_mask = AT_SIZE;
 136         error = VOP_GETATTR(vf->vf_vnode, &vattr, 0, kcred, NULL);
 137         if (error) {
 138                 vd->vdev_stat.vs_aux = VDEV_AUX_OPEN_FAILED;
 139                 return (error);
 140         }
 141
 142         *max_psize = *psize = vattr.va_size;
 143         *ashift = SPA_MINBLOCKSHIFT;
 144
 145         return (0);
 146 }
 147
 148 static void
 149 vdev_file_close(vdev_t *vd)
 150 {
 151         vdev_file_t *vf = vd->vdev_tsd;
 152
 153         if (vd->vdev_reopening || vf == NULL)
 154                 return;
 155
 156         if (vf->vf_vnode != NULL) {
 157                 (void) VOP_PUTPAGE(vf->vf_vnode, 0, 0, B_INVAL, kcred, NULL);
 158                 (void) VOP_CLOSE(vf->vf_vnode, spa_mode(vd->vdev_spa), 1, 0,
 159                     kcred, NULL);
 160         }
 161
 162         vd->vdev_delayed_close = B_FALSE;
 163         kmem_free(vf, sizeof (vdev_file_t));
 164         vd->vdev_tsd = NULL;
 165 }
 166
 167 static void
 168 vdev_file_io_strategy(void *arg)
 169 {
 170         zio_t *zio = (zio_t *)arg;
 171         vdev_t *vd = zio->io_vd;
 172         vdev_file_t *vf = vd->vdev_tsd;
 173         ssize_t resid;
 174         void *buf;
 175
 176         if (zio->io_type == ZIO_TYPE_READ)
 177                 buf = abd_borrow_buf(zio->io_abd, zio->io_size);
 178         else
 179                 buf = abd_borrow_buf_copy(zio->io_abd, zio->io_size);
 180
 181         zio->io_error = vn_rdwr(zio->io_type == ZIO_TYPE_READ ?
 182             UIO_READ : UIO_WRITE, vf->vf_vnode, buf, zio->io_size,
 183             zio->io_offset, UIO_SYSSPACE, 0, RLIM64_INFINITY, kcred, &resid);
 184
 185         if (zio->io_type == ZIO_TYPE_READ)
 186                 abd_return_buf_copy(zio->io_abd, buf, zio->io_size);
 187         else
 188                 abd_return_buf(zio->io_abd, buf, zio->io_size);
 189
 190         if (resid != 0 && zio->io_error == 0)
 191                 zio->io_error = SET_ERROR(ENOSPC);
 192
 193         zio_delay_interrupt(zio);
 194 }
 195
 196 static void
 197 vdev_file_io_fsync(void *arg)
 198 {
 199         zio_t *zio = (zio_t *)arg;
 200         vdev_file_t *vf = zio->io_vd->vdev_tsd;
 201
 202         zio->io_error = VOP_FSYNC(vf->vf_vnode, FSYNC | FDSYNC, kcred, NULL);
 203
 204         zio_interrupt(zio);
 205 }
 206
 207 static void
 208 vdev_file_io_start(zio_t *zio)
 209 {
 210         vdev_t *vd = zio->io_vd;
 211         vdev_file_t *vf = vd->vdev_tsd;
 212
 213         if (zio->io_type == ZIO_TYPE_IOCTL) {
 214                 /* XXPOLICY */
 215                 if (!vdev_readable(vd)) {
 216                         zio->io_error = SET_ERROR(ENXIO);
 217                         zio_interrupt(zio);
 218                         return;
 219                 }
 220
 221                 switch (zio->io_cmd) {
 222                 case DKIOCFLUSHWRITECACHE:
 223
 224                         if (zfs_nocacheflush)
 225                                 break;
 226
 227                         /*
 228                          * We cannot safely call vfs_fsync() when PF_FSTRANS
 229                          * is set in the current context.  Filesystems like
 230                          * XFS include sanity checks to verify it is not
 231                          * already set, see xfs_vm_writepage().  Therefore
 232                          * the sync must be dispatched to a different context.
 233                          */
 234                         if (__spl_pf_fstrans_check()) {
 235                                 VERIFY3U(taskq_dispatch(vdev_file_taskq,
 236                                     vdev_file_io_fsync, zio, TQ_SLEEP), !=,
 237                                     TASKQID_INVALID);
 238                                 return;
 239                         }
 240
 241                         zio->io_error = VOP_FSYNC(vf->vf_vnode, FSYNC | FDSYNC,
 242                             kcred, NULL);
 243                         break;
 244                 default:
 245                         zio->io_error = SET_ERROR(ENOTSUP);
 246                 }
 247
 248                 zio_execute(zio);
 249                 return;
 250         } else if (zio->io_type == ZIO_TYPE_TRIM) {
 251                 struct flock flck;
 252
 253                 ASSERT3U(zio->io_size, !=, 0);
 254                 bzero(&flck, sizeof (flck));
 255                 flck.l_type = F_FREESP;
 256                 flck.l_start = zio->io_offset;
 257                 flck.l_len = zio->io_size;
 258                 flck.l_whence = SEEK_SET;
 259
 260                 zio->io_error = VOP_SPACE(vf->vf_vnode, F_FREESP, &flck,
 261                     0, 0, kcred, NULL);
 262
 263                 zio_execute(zio);
 264                 return;
 265         }
 266
 267         zio->io_target_timestamp = zio_handle_io_delay(zio);
 268
 269         VERIFY3U(taskq_dispatch(vdev_file_taskq, vdev_file_io_strategy, zio,
 270             TQ_SLEEP), !=, TASKQID_INVALID);
 271 }
 272
 273 /* ARGSUSED */
 274 static void
 275 vdev_file_io_done(zio_t *zio)
 276 {
 277 }
 278
 279 vdev_ops_t vdev_file_ops = {
 280         vdev_file_open,
 281         vdev_file_close,
 282         vdev_default_asize,
 283         vdev_file_io_start,
 284         vdev_file_io_done,
 285         NULL,
 286         NULL,
 287         vdev_file_hold,
 288         vdev_file_rele,
 289         NULL,
 290         vdev_default_xlate,
 291         VDEV_TYPE_FILE,         /* name of this vdev type */
 292         B_TRUE                  /* leaf vdev */
 293 };
 294
 295 void
 296 vdev_file_init(void)
 297 {
 298         vdev_file_taskq = taskq_create("z_vdev_file", MAX(boot_ncpus, 16),
 299             minclsyspri, boot_ncpus, INT_MAX, TASKQ_DYNAMIC);
 300
 301         VERIFY(vdev_file_taskq);
 302 }
 303
 304 void
 305 vdev_file_fini(void)
 306 {
 307         taskq_destroy(vdev_file_taskq);
 308 }
 309
 310 /*
 311  * From userland we access disks just like files.
 312  */
 313 #ifndef _KERNEL
 314
 315 vdev_ops_t vdev_disk_ops = {
 316         vdev_file_open,
 317         vdev_file_close,
 318         vdev_default_asize,
 319         vdev_file_io_start,
 320         vdev_file_io_done,
 321         NULL,
 322         NULL,
 323         vdev_file_hold,
 324         vdev_file_rele,
 325         NULL,
 326         vdev_default_xlate,
 327         VDEV_TYPE_DISK,         /* name of this vdev type */
 328         B_TRUE                  /* leaf vdev */
 329 };
 330
 331 #endif