/*- * Copyright (c) 2002 Poul-Henning Kamp * Copyright (c) 2002 Networks Associates Technology, Inc. * All rights reserved. * * This software was developed for the FreeBSD Project by Poul-Henning Kamp * and NAI Labs, the Security Research Division of Network Associates, Inc. * under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), as part of the * DARPA CHATS research program. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. The names of the authors may not be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $FreeBSD$ */ #include "opt_geom.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define GEOM_CTL_TABLE 1 #include #include static d_ioctl_t g_ctl_ioctl; static struct cdevsw g_ctl_cdevsw = { .d_open = nullopen, .d_close = nullclose, .d_ioctl = g_ctl_ioctl, .d_name = "g_ctl", }; void g_ctl_init(void) { make_dev(&g_ctl_cdevsw, 0, UID_ROOT, GID_OPERATOR, 0640, PATH_GEOM_CTL); } static int g_ctl_ioctl_configgeom(dev_t dev, u_long cmd, caddr_t data, int fflag, struct thread *td) { struct geomconfiggeom *gcp; struct g_configargs ga; int error; error = 0; bzero(&ga, sizeof ga); gcp = (struct geomconfiggeom *)data; ga.class = g_idclass(&gcp->class); if (ga.class == NULL) return (EINVAL); if (ga.class->config == NULL) return (EOPNOTSUPP); ga.geom = g_idgeom(&gcp->geom); ga.provider = g_idprovider(&gcp->provider); ga.len = gcp->len; if (gcp->len > 64 * 1024) return (EINVAL); else if (gcp->len == 0) { ga.ptr = NULL; } else { ga.ptr = g_malloc(gcp->len, M_WAITOK); error = copyin(gcp->ptr, ga.ptr, gcp->len); if (error) { g_free(ga.ptr); return (error); } } ga.flag = gcp->flag; error = ga.class->config(&ga); if (gcp->len != 0) copyout(ga.ptr, gcp->ptr, gcp->len); /* Ignore error */ gcp->class.u.id = (uintptr_t)ga.class; gcp->class.len = 0; gcp->geom.u.id = (uintptr_t)ga.geom; gcp->geom.len = 0; gcp->provider.u.id = (uintptr_t)ga.provider; gcp->provider.len = 0; return(error); } /* * Report an error back to the user in ascii format. Return whatever copyout * returned, or EINVAL if it succeeded. * XXX: should not be static. * XXX: should take printf like args. */ static int g_ctl_seterror(struct geom_ctl_req *req, const char *errtxt) { int error; error = copyout(errtxt, req->error, imin(req->lerror, strlen(errtxt) + 1)); if (!error) error = EINVAL; return (error); } /* * Allocate space and copyin() something. * XXX: this should really be a standard function in the kernel. */ static void * geom_alloc_copyin(void *uaddr, size_t len, int *errp) { int error; void *ptr; ptr = g_malloc(len, M_WAITOK); if (ptr == NULL) error = ENOMEM; else error = copyin(uaddr, ptr, len); if (!error) return (ptr); *errp = error; if (ptr != NULL) g_free(ptr); return (NULL); } /* * XXX: This function is a nightmare. It walks through the request and * XXX: makes sure that the various bits and pieces are there and copies * XXX: some of them into kernel memory to make things easier. * XXX: I really wish we had a standard marshalling layer somewhere. */ static int geom_ctl_copyin(struct geom_ctl_req *req) { int error, i, j; struct geom_ctl_req_arg *ap; char *p; error = 0; if (!useracc(req->error, req->lerror, VM_PROT_WRITE)) return (g_ctl_seterror(req, "No access to error field")); ap = geom_alloc_copyin(req->arg, req->narg * sizeof(*ap), &error); if (ap == NULL) return (error); for (i = 0; !error && i < req->narg; i++) { if (ap[i].len < 0 && !useracc(ap[i].value, 1 + -ap[i].len, VM_PROT_READ)) error = g_ctl_seterror(req, "No access to param data"); else if (ap[i].len > 0 && !useracc(ap[i].value, ap[i].len, VM_PROT_READ | VM_PROT_WRITE)) error = g_ctl_seterror(req, "No access to param data"); if (ap[i].name == NULL) continue; p = NULL; if (ap[i].nlen < 1 || ap[i].nlen > SPECNAMELEN) error = EINVAL; if (error) break; p = geom_alloc_copyin(ap[i].name, ap[i].nlen + 1, &error); if (error) break; if (p[ap[i].nlen] != '\0') error = EINVAL; if (!error) { ap[i].name = p; ap[i].nlen = 0; } else { g_free(p); break; } } if (!error) { req->arg = ap; return (0); } for (j = 0; j < i; j++) if (ap[j].nlen == 0 && ap[j].name != NULL) g_free(ap[j].name); g_free(ap); return (error); } static void geom_ctl_dump(struct geom_ctl_req *req) { u_int i; int j, error; struct geom_ctl_req_arg *ap; void *p; printf("Dump of geom_ctl %s request at %p:\n", req->reqt->name, req); if (req->lerror > 0) { p = geom_alloc_copyin(req->error, req->lerror, &error); if (p != NULL) { ((char *)p)[req->lerror - 1] = '\0'; printf(" error:\t\"%s\"\n", (char *)p); g_free(p); } } for (i = 0; i < req->narg; i++) { ap = &req->arg[i]; if (ap->name != NULL) printf(" param:\t\"%s\"", ap->name); else printf(" meta:\t@%jd", (intmax_t)ap->offset); printf(" [%d] = ", ap->len); if (ap->len < 0) { p = geom_alloc_copyin(ap->value, 1 + -ap->len, &error); ((char *)p)[-ap->len] = '\0'; if (p != NULL) printf("\"%s\"", (char *)p); g_free(p); } else if (ap->len > 0) { p = geom_alloc_copyin(ap->value, ap->len, &error); for (j = 0; j < ap->len; j++) printf(" %02x", ((u_char *)p)[j]); g_free(p); } else { printf(" = %p", ap->value); } printf("\n"); } } /* * Handle ioctl from libgeom::geom_ctl.c */ static int g_ctl_ioctl_ctl(dev_t dev, u_long cmd, caddr_t data, int fflag, struct thread *td) { int error; int i; struct geom_ctl_req *req; req = (void *)data; if (req->lerror < 1) return (EINVAL); if (req->version != GEOM_CTL_VERSION) return (g_ctl_seterror(req, "Kernel and libgeom version skew.")); for (i = 0; gcrt[i].request != GEOM_INVALID_REQUEST; i++) if (gcrt[i].request == req->request) { req->reqt = &gcrt[i]; break; } if (gcrt[i].request == GEOM_INVALID_REQUEST) return (g_ctl_seterror(req, "Invalid request")); error = geom_ctl_copyin(req); if (error) return (error); req->reqt = &gcrt[i]; g_stall_events(); geom_ctl_dump(req); g_release_events(); return (0); } static int g_ctl_ioctl(dev_t dev, u_long cmd, caddr_t data, int fflag, struct thread *td) { int error; switch(cmd) { case GEOMCONFIGGEOM: DROP_GIANT(); g_topology_lock(); error = g_ctl_ioctl_configgeom(dev, cmd, data, fflag, td); g_topology_unlock(); PICKUP_GIANT(); break; case GEOM_CTL: error = g_ctl_ioctl_ctl(dev, cmd, data, fflag, td); break; default: error = ENOTTY; break; } return (error); }