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 2006 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 #pragma ident "%Z%%M% %I% %E% SMI" 27 28 #include <sys/zfs_context.h> 29 #include <sys/spa.h> 30 #include <sys/vdev_file.h> 31 #include <sys/vdev_impl.h> 32 #include <sys/zio.h> 33 #include <sys/fs/zfs.h> 34 35 /* 36 * Virtual device vector for files. 37 */ 38 39 static int 40 vdev_file_open(vdev_t *vd, uint64_t *psize, uint64_t *ashift) 41 { 42 vdev_file_t *vf; 43 vnode_t *vp; 44 vattr_t vattr; 45 int error; 46 47 /* 48 * We must have a pathname, and it must be absolute. 49 */ 50 if (vd->vdev_path == NULL || vd->vdev_path[0] != '/') { 51 vd->vdev_stat.vs_aux = VDEV_AUX_BAD_LABEL; 52 return (EINVAL); 53 } 54 55 vf = vd->vdev_tsd = kmem_zalloc(sizeof (vdev_file_t), KM_SLEEP); 56 57 #ifdef _KERNEL 58 /* 59 * When using a file vdev in kernel context, the underlying filesystem 60 * will already be caching the data. Don't cache it again here. 61 */ 62 vd->vdev_cache.vc_size = 0; 63 #endif 64 65 /* 66 * We always open the files from the root of the global zone, even if 67 * we're in a local zone. If the user has gotten to this point, the 68 * administrator has already decided that the pool should be available 69 * to local zone users, so the underlying devices should be as well. 70 */ 71 ASSERT(vd->vdev_path != NULL && vd->vdev_path[0] == '/'); 72 error = vn_openat(vd->vdev_path + 1, UIO_SYSSPACE, spa_mode | FOFFMAX, 73 0, &vp, 0, 0, rootdir); 74 75 if (error) { 76 vd->vdev_stat.vs_aux = VDEV_AUX_OPEN_FAILED; 77 return (error); 78 } 79 80 vf->vf_vnode = vp; 81 82 #ifdef _KERNEL 83 /* 84 * Make sure it's a regular file. 85 */ 86 if (vp->v_type != VREG) { 87 vd->vdev_stat.vs_aux = VDEV_AUX_OPEN_FAILED; 88 return (ENODEV); 89 } 90 #endif 91 92 /* 93 * Determine the physical size of the file. 94 */ 95 vattr.va_mask = AT_SIZE; 96 error = VOP_GETATTR(vp, &vattr, 0, kcred); 97 if (error) { 98 vd->vdev_stat.vs_aux = VDEV_AUX_OPEN_FAILED; 99 return (error); 100 } 101 102 *psize = vattr.va_size; 103 *ashift = SPA_MINBLOCKSHIFT; 104 105 return (0); 106 } 107 108 static void 109 vdev_file_close(vdev_t *vd) 110 { 111 vdev_file_t *vf = vd->vdev_tsd; 112 113 if (vf == NULL) 114 return; 115 116 if (vf->vf_vnode != NULL) { 117 (void) VOP_PUTPAGE(vf->vf_vnode, 0, 0, B_INVAL, kcred); 118 (void) VOP_CLOSE(vf->vf_vnode, spa_mode, 1, 0, kcred); 119 VN_RELE(vf->vf_vnode); 120 } 121 122 kmem_free(vf, sizeof (vdev_file_t)); 123 vd->vdev_tsd = NULL; 124 } 125 126 static void 127 vdev_file_io_start(zio_t *zio) 128 { 129 vdev_t *vd = zio->io_vd; 130 vdev_file_t *vf = vd->vdev_tsd; 131 ssize_t resid; 132 int error; 133 134 if (zio->io_type == ZIO_TYPE_IOCTL) { 135 zio_vdev_io_bypass(zio); 136 137 /* XXPOLICY */ 138 if (vdev_is_dead(vd)) { 139 zio->io_error = ENXIO; 140 zio_next_stage_async(zio); 141 return; 142 } 143 144 switch (zio->io_cmd) { 145 case DKIOCFLUSHWRITECACHE: 146 zio->io_error = VOP_FSYNC(vf->vf_vnode, FSYNC | FDSYNC, 147 kcred); 148 dprintf("fsync(%s) = %d\n", vdev_description(vd), 149 zio->io_error); 150 break; 151 default: 152 zio->io_error = ENOTSUP; 153 } 154 155 zio_next_stage_async(zio); 156 return; 157 } 158 159 if (zio->io_type == ZIO_TYPE_READ && vdev_cache_read(zio) == 0) 160 return; 161 162 if ((zio = vdev_queue_io(zio)) == NULL) 163 return; 164 165 /* XXPOLICY */ 166 error = vdev_is_dead(vd) ? ENXIO : vdev_error_inject(vd, zio); 167 if (error) { 168 zio->io_error = error; 169 zio_next_stage_async(zio); 170 return; 171 } 172 173 zio->io_error = vn_rdwr(zio->io_type == ZIO_TYPE_READ ? 174 UIO_READ : UIO_WRITE, vf->vf_vnode, zio->io_data, 175 zio->io_size, zio->io_offset, UIO_SYSSPACE, 176 0, RLIM64_INFINITY, kcred, &resid); 177 178 if (resid != 0 && zio->io_error == 0) 179 zio->io_error = ENOSPC; 180 181 zio_next_stage_async(zio); 182 } 183 184 static void 185 vdev_file_io_done(zio_t *zio) 186 { 187 vdev_queue_io_done(zio); 188 189 if (zio->io_type == ZIO_TYPE_WRITE) 190 vdev_cache_write(zio); 191 192 if (zio_injection_enabled && zio->io_error == 0) 193 zio->io_error = zio_handle_device_injection(zio->io_vd, EIO); 194 195 zio_next_stage(zio); 196 } 197 198 vdev_ops_t vdev_file_ops = { 199 vdev_file_open, 200 vdev_file_close, 201 vdev_default_asize, 202 vdev_file_io_start, 203 vdev_file_io_done, 204 NULL, 205 VDEV_TYPE_FILE, /* name of this vdev type */ 206 B_TRUE /* leaf vdev */ 207 }; 208 209 /* 210 * From userland we access disks just like files. 211 */ 212 #ifndef _KERNEL 213 214 vdev_ops_t vdev_disk_ops = { 215 vdev_file_open, 216 vdev_file_close, 217 vdev_default_asize, 218 vdev_file_io_start, 219 vdev_file_io_done, 220 NULL, 221 VDEV_TYPE_DISK, /* name of this vdev type */ 222 B_TRUE /* leaf vdev */ 223 }; 224 225 #endif 226