1 /* 2 * Copyright (c) 2020 iXsystems, Inc. 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 * 26 */ 27 28 #include <sys/cdefs.h> 29 __FBSDID("$FreeBSD$"); 30 31 #include <sys/param.h> 32 #include <sys/buf.h> 33 #include <sys/cmn_err.h> 34 #include <sys/conf.h> 35 #include <sys/dmu.h> 36 #include <sys/dmu_impl.h> 37 #include <sys/dmu_objset.h> 38 #include <sys/dmu_send.h> 39 #include <sys/dmu_tx.h> 40 #include <sys/dsl_bookmark.h> 41 #include <sys/dsl_crypt.h> 42 #include <sys/dsl_dataset.h> 43 #include <sys/dsl_deleg.h> 44 #include <sys/dsl_destroy.h> 45 #include <sys/dsl_dir.h> 46 #include <sys/dsl_prop.h> 47 #include <sys/dsl_scan.h> 48 #include <sys/dsl_userhold.h> 49 #include <sys/errno.h> 50 #include <sys/eventhandler.h> 51 #include <sys/file.h> 52 #include <sys/fm/util.h> 53 #include <sys/fs/zfs.h> 54 #include <sys/kernel.h> 55 #include <sys/kmem.h> 56 #include <sys/lock.h> 57 #include <sys/malloc.h> 58 #include <sys/mount.h> 59 #include <sys/mutex.h> 60 #include <sys/nvpair.h> 61 #include <sys/policy.h> 62 #include <sys/proc.h> 63 #include <sys/sdt.h> 64 #include <sys/spa.h> 65 #include <sys/spa_impl.h> 66 #include <sys/stat.h> 67 #include <sys/sunddi.h> 68 #include <sys/systm.h> 69 #include <sys/taskqueue.h> 70 #include <sys/uio.h> 71 #include <sys/vdev.h> 72 #include <sys/vdev_removal.h> 73 #include <sys/zap.h> 74 #include <sys/zcp.h> 75 #include <sys/zfeature.h> 76 #include <sys/zfs_context.h> 77 #include <sys/zfs_ctldir.h> 78 #include <sys/zfs_dir.h> 79 #include <sys/zfs_ioctl.h> 80 #include <sys/zfs_ioctl_compat.h> 81 #include <sys/zfs_ioctl_impl.h> 82 #include <sys/zfs_onexit.h> 83 #include <sys/zfs_vfsops.h> 84 #include <sys/zfs_znode.h> 85 #include <sys/zio_checksum.h> 86 #include <sys/zone.h> 87 #include <sys/zvol.h> 88 89 #include "zfs_comutil.h" 90 #include "zfs_deleg.h" 91 #include "zfs_namecheck.h" 92 #include "zfs_prop.h" 93 94 SYSCTL_DECL(_vfs_zfs); 95 SYSCTL_DECL(_vfs_zfs_vdev); 96 97 extern uint_t rrw_tsd_key; 98 static int zfs_version_ioctl = ZFS_IOCVER_OZFS; 99 SYSCTL_DECL(_vfs_zfs_version); 100 SYSCTL_INT(_vfs_zfs_version, OID_AUTO, ioctl, CTLFLAG_RD, &zfs_version_ioctl, 101 0, "ZFS_IOCTL_VERSION"); 102 103 static struct cdev *zfsdev; 104 105 static struct root_hold_token *zfs_root_token; 106 107 extern uint_t rrw_tsd_key; 108 extern uint_t zfs_allow_log_key; 109 extern uint_t zfs_geom_probe_vdev_key; 110 111 static int zfs__init(void); 112 static int zfs__fini(void); 113 static void zfs_shutdown(void *, int); 114 115 static eventhandler_tag zfs_shutdown_event_tag; 116 117 #define ZFS_MIN_KSTACK_PAGES 4 118 119 static int 120 zfsdev_ioctl(struct cdev *dev, ulong_t zcmd, caddr_t arg, int flag, 121 struct thread *td) 122 { 123 uint_t len; 124 int vecnum; 125 zfs_iocparm_t *zp; 126 zfs_cmd_t *zc; 127 zfs_cmd_legacy_t *zcl; 128 int rc, error; 129 void *uaddr; 130 131 len = IOCPARM_LEN(zcmd); 132 vecnum = zcmd & 0xff; 133 zp = (void *)arg; 134 uaddr = (void *)(uintptr_t)zp->zfs_cmd; 135 error = 0; 136 zcl = NULL; 137 138 if (len != sizeof (zfs_iocparm_t)) { 139 printf("len %d vecnum: %d sizeof (zfs_cmd_t) %ju\n", 140 len, vecnum, (uintmax_t)sizeof (zfs_cmd_t)); 141 return (EINVAL); 142 } 143 144 zc = kmem_zalloc(sizeof (zfs_cmd_t), KM_SLEEP); 145 /* 146 * Remap ioctl code for legacy user binaries 147 */ 148 if (zp->zfs_ioctl_version == ZFS_IOCVER_LEGACY) { 149 vecnum = zfs_ioctl_legacy_to_ozfs(vecnum); 150 if (vecnum < 0) { 151 kmem_free(zc, sizeof (zfs_cmd_t)); 152 return (ENOTSUP); 153 } 154 zcl = kmem_zalloc(sizeof (zfs_cmd_legacy_t), KM_SLEEP); 155 if (copyin(uaddr, zcl, sizeof (zfs_cmd_legacy_t))) { 156 error = SET_ERROR(EFAULT); 157 goto out; 158 } 159 zfs_cmd_legacy_to_ozfs(zcl, zc); 160 } else if (copyin(uaddr, zc, sizeof (zfs_cmd_t))) { 161 error = SET_ERROR(EFAULT); 162 goto out; 163 } 164 error = zfsdev_ioctl_common(vecnum, zc, 0); 165 if (zcl) { 166 zfs_cmd_ozfs_to_legacy(zc, zcl); 167 rc = copyout(zcl, uaddr, sizeof (*zcl)); 168 } else { 169 rc = copyout(zc, uaddr, sizeof (*zc)); 170 } 171 if (error == 0 && rc != 0) 172 error = SET_ERROR(EFAULT); 173 out: 174 if (zcl) 175 kmem_free(zcl, sizeof (zfs_cmd_legacy_t)); 176 kmem_free(zc, sizeof (zfs_cmd_t)); 177 MPASS(tsd_get(rrw_tsd_key) == NULL); 178 return (error); 179 } 180 181 static void 182 zfsdev_close(void *data) 183 { 184 zfsdev_state_destroy(data); 185 } 186 187 void 188 zfsdev_private_set_state(void *priv __unused, zfsdev_state_t *zs) 189 { 190 devfs_set_cdevpriv(zs, zfsdev_close); 191 } 192 193 zfsdev_state_t * 194 zfsdev_private_get_state(void *priv) 195 { 196 return (priv); 197 } 198 199 static int 200 zfsdev_open(struct cdev *devp __unused, int flag __unused, int mode __unused, 201 struct thread *td __unused) 202 { 203 int error; 204 205 mutex_enter(&zfsdev_state_lock); 206 error = zfsdev_state_init(NULL); 207 mutex_exit(&zfsdev_state_lock); 208 209 return (error); 210 } 211 212 static struct cdevsw zfs_cdevsw = { 213 .d_version = D_VERSION, 214 .d_open = zfsdev_open, 215 .d_ioctl = zfsdev_ioctl, 216 .d_name = ZFS_DRIVER 217 }; 218 219 int 220 zfsdev_attach(void) 221 { 222 struct make_dev_args args; 223 224 make_dev_args_init(&args); 225 args.mda_flags = MAKEDEV_CHECKNAME | MAKEDEV_WAITOK; 226 args.mda_devsw = &zfs_cdevsw; 227 args.mda_cr = NULL; 228 args.mda_uid = UID_ROOT; 229 args.mda_gid = GID_OPERATOR; 230 args.mda_mode = 0666; 231 return (make_dev_s(&args, &zfsdev, ZFS_DRIVER)); 232 } 233 234 void 235 zfsdev_detach(void) 236 { 237 if (zfsdev != NULL) 238 destroy_dev(zfsdev); 239 } 240 241 int 242 zfs__init(void) 243 { 244 int error; 245 246 #if KSTACK_PAGES < ZFS_MIN_KSTACK_PAGES 247 printf("ZFS NOTICE: KSTACK_PAGES is %d which could result in stack " 248 "overflow panic!\nPlease consider adding " 249 "'options KSTACK_PAGES=%d' to your kernel config\n", KSTACK_PAGES, 250 ZFS_MIN_KSTACK_PAGES); 251 #endif 252 zfs_root_token = root_mount_hold("ZFS"); 253 if ((error = zfs_kmod_init()) != 0) { 254 printf("ZFS: Failed to Load ZFS Filesystem" 255 ", rc = %d\n", error); 256 root_mount_rel(zfs_root_token); 257 return (error); 258 } 259 260 261 tsd_create(&zfs_geom_probe_vdev_key, NULL); 262 263 printf("ZFS storage pool version: features support (" 264 SPA_VERSION_STRING ")\n"); 265 root_mount_rel(zfs_root_token); 266 ddi_sysevent_init(); 267 return (0); 268 } 269 270 int 271 zfs__fini(void) 272 { 273 if (zfs_busy() || zvol_busy() || 274 zio_injection_enabled) { 275 return (EBUSY); 276 } 277 zfs_kmod_fini(); 278 tsd_destroy(&zfs_geom_probe_vdev_key); 279 return (0); 280 } 281 282 static void 283 zfs_shutdown(void *arg __unused, int howto __unused) 284 { 285 286 /* 287 * ZFS fini routines can not properly work in a panic-ed system. 288 */ 289 if (panicstr == NULL) 290 zfs__fini(); 291 } 292 293 static int 294 zfs_modevent(module_t mod, int type, void *unused __unused) 295 { 296 int err; 297 298 switch (type) { 299 case MOD_LOAD: 300 err = zfs__init(); 301 if (err == 0) 302 zfs_shutdown_event_tag = EVENTHANDLER_REGISTER( 303 shutdown_post_sync, zfs_shutdown, NULL, 304 SHUTDOWN_PRI_FIRST); 305 return (err); 306 case MOD_UNLOAD: 307 err = zfs__fini(); 308 if (err == 0 && zfs_shutdown_event_tag != NULL) 309 EVENTHANDLER_DEREGISTER(shutdown_post_sync, 310 zfs_shutdown_event_tag); 311 return (err); 312 case MOD_SHUTDOWN: 313 return (0); 314 default: 315 break; 316 } 317 return (EOPNOTSUPP); 318 } 319 320 static moduledata_t zfs_mod = { 321 "zfsctrl", 322 zfs_modevent, 323 0 324 }; 325 326 #ifdef _KERNEL 327 EVENTHANDLER_DEFINE(mountroot, spa_boot_init, NULL, 0); 328 #endif 329 330 DECLARE_MODULE(zfsctrl, zfs_mod, SI_SUB_CLOCKS, SI_ORDER_ANY); 331 MODULE_VERSION(zfsctrl, 1); 332 #if __FreeBSD_version > 1300092 333 MODULE_DEPEND(zfsctrl, xdr, 1, 1, 1); 334 #else 335 MODULE_DEPEND(zfsctrl, krpc, 1, 1, 1); 336 #endif 337 MODULE_DEPEND(zfsctrl, acl_nfs4, 1, 1, 1); 338 MODULE_DEPEND(zfsctrl, crypto, 1, 1, 1); 339 MODULE_DEPEND(zfsctrl, zlib, 1, 1, 1); 340