diff --git a/sbin/geom/Makefile b/sbin/geom/Makefile new file mode 100644 index 000000000000..95f00d914756 --- /dev/null +++ b/sbin/geom/Makefile @@ -0,0 +1,5 @@ +# $FreeBSD$ + +SUBDIR= core class + +.include diff --git a/sbin/geom/Makefile.inc b/sbin/geom/Makefile.inc new file mode 100644 index 000000000000..7803210e1e71 --- /dev/null +++ b/sbin/geom/Makefile.inc @@ -0,0 +1,5 @@ +# $FreeBSD$ + +BINDIR?=/sbin +LIBDIR?=/lib/geom +WARNS?= 6 diff --git a/sbin/geom/class/Makefile b/sbin/geom/class/Makefile new file mode 100644 index 000000000000..71edcf7c0b25 --- /dev/null +++ b/sbin/geom/class/Makefile @@ -0,0 +1,7 @@ +# $FreeBSD$ + +SUBDIR= concat +SUBDIR+=nop +SUBDIR+=stripe + +.include diff --git a/sbin/geom/class/Makefile.inc b/sbin/geom/class/Makefile.inc new file mode 100644 index 000000000000..b927bca57ac8 --- /dev/null +++ b/sbin/geom/class/Makefile.inc @@ -0,0 +1,12 @@ +# $FreeBSD$ + +.include "../Makefile.inc" + +SHLIB_MAJOR=1 + +SRCS= geom_${CLASS}.c subr.c +SHLIB_NAME?=geom_${CLASS}.so.${SHLIB_MAJOR} +LINKS= ${BINDIR}/geom ${BINDIR}/g${CLASS} +MAN= g${CLASS}.8 + +CFLAGS+=-I${.CURDIR}/../.. diff --git a/sbin/geom/core/Makefile b/sbin/geom/core/Makefile new file mode 100644 index 000000000000..3c373429fb25 --- /dev/null +++ b/sbin/geom/core/Makefile @@ -0,0 +1,15 @@ +# $FreeBSD$ + +.PATH: ${.CURDIR}/../misc + +PROG= geom +SRCS= geom.c subr.c +#MAN= geom.8 +NOMAN= notyet +DPADD= ${LIBGEOM} ${LIBSBUF} ${LIBBSDXML} +LDADD= -lgeom -lsbuf -lbsdxml +WARNS?= 6 +CFLAGS+=-I${.CURDIR}/../../../sys -I${.CURDIR} -I${.CURDIR}/.. +CFLAGS+=-DCLASSDIR=\"${LIBDIR}\" + +.include diff --git a/sbin/geom/core/geom.c b/sbin/geom/core/geom.c new file mode 100644 index 000000000000..613eb4113bce --- /dev/null +++ b/sbin/geom/core/geom.c @@ -0,0 +1,755 @@ +/*- + * Copyright (c) 2004 Pawel Jakub Dawidek + * All rights reserved. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHORS 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 AUTHORS 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. + */ + +#include +__FBSDID("$FreeBSD$"); + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "misc/subr.h" + + +static char comm[MAXPATHLEN], *class_name = NULL, *gclass_name = NULL; +static uint32_t *version = NULL; +static int verbose = 0; +static struct g_command *class_commands = NULL; +static void (*usage)(const char *name); + +static struct g_command *find_command(const char *cmdstr, int all); +static int std_available(const char *name); + +static void std_list(struct gctl_req *req, unsigned flags); +static void std_load(struct gctl_req *req, unsigned flags); +static void std_unload(struct gctl_req *req, unsigned flags); + +struct g_command std_commands[] = { + { "list", 0, std_list, G_NULL_OPTS }, + { "load", G_FLAG_VERBOSE | G_FLAG_LOADKLD, std_load, G_NULL_OPTS }, + { "unload", G_FLAG_VERBOSE, std_unload, G_NULL_OPTS }, + G_CMD_SENTINEL +}; + +static void +std_usage(const char *name) +{ + struct g_command *cmd; + struct g_option *opt; + unsigned i, j; + + for (i = 0; ; i++) { + cmd = &class_commands[i]; + if (cmd->gc_name == NULL) + break; + fprintf(stderr, "%s %s %s %s", i == 0 ? "usage:" : " ", + name, class_name, cmd->gc_name); + if ((cmd->gc_flags & G_FLAG_VERBOSE) != 0) + fprintf(stderr, " [-v]"); + for (j = 0; ; j++) { + opt = &cmd->gc_options[j]; + if (opt->go_name == NULL) + break; + if (opt->go_val != NULL || opt->go_type == G_TYPE_NONE) + fprintf(stderr, " ["); + else + fprintf(stderr, " "); + fprintf(stderr, "-%c", opt->go_char); + if (opt->go_type != G_TYPE_NONE) + fprintf(stderr, " %s", opt->go_name); + if (opt->go_val != NULL || opt->go_type == G_TYPE_NONE) + fprintf(stderr, "]"); + } + fprintf(stderr, " ...\n"); + } + exit(EXIT_FAILURE); +} + +static void +geom_usage(void) +{ + + if (class_name == NULL) { + errx(EXIT_FAILURE, "usage: %s " + "[options]", "geom"); + } else { + const char *prefix; + unsigned i; + + if (usage == NULL) + prefix = "usage:"; + else { + usage(comm); + prefix = " "; + } + for (i = 0; ; i++) { + struct g_command *cmd; + + cmd = &std_commands[i]; + if (cmd->gc_name == NULL) + break; + if (find_command(cmd->gc_name, 0) != NULL) + continue; + if (!std_available(cmd->gc_name)) + continue; + fprintf(stderr, "%s %s %s", prefix, comm, cmd->gc_name); + if ((cmd->gc_flags & G_FLAG_VERBOSE) != 0) + fprintf(stderr, " [-v]"); + fprintf(stderr, "\n"); + prefix = " "; + } + exit(EXIT_FAILURE); + } +} + +static void +load_module(void) +{ + char name1[64], name2[64]; + + snprintf(name1, sizeof(name1), "g_%s", class_name); + snprintf(name2, sizeof(name2), "geom_%s", class_name); + if (modfind(name1) < 0) { + /* Not present in kernel, try loading it. */ + if (kldload(name2) < 0 || modfind(name1) < 0) { + if (errno != EEXIST) { + errx(EXIT_FAILURE, + "%s module not available!", name2); + } + } + } +} + +static int +strlcatf(char *str, size_t size, const char *format, ...) +{ + size_t len; + va_list ap; + int ret; + + len = strlen(str); + str += len; + size -= len; + + va_start(ap, format); + ret = vsnprintf(str, size, format, ap); + va_end(ap); + + return (ret); +} + +/* + * Find given option in options available for given command. + */ +static struct g_option * +find_option(struct g_command *cmd, char ch) +{ + struct g_option *opt; + unsigned i; + + for (i = 0; ; i++) { + opt = &cmd->gc_options[i]; + if (opt->go_name == NULL) + return (NULL); + if (opt->go_char == ch) + return (opt); + } + /* NOTREACHED */ + return (NULL); +} + +/* + * Add given option to gctl_req. + */ +static void +set_option(struct gctl_req *req, struct g_option *opt, const char *val) +{ + + if (opt->go_type == G_TYPE_NUMBER) { + intmax_t number; + + errno = 0; + number = strtoimax(optarg, NULL, 0); + if (errno != 0) { + err(EXIT_FAILURE, "Invalid value for '%c' argument.", + opt->go_char); + } + opt->go_val = malloc(sizeof(intmax_t)); + if (opt->go_val == NULL) + errx(EXIT_FAILURE, "No memory."); + *(intmax_t *)opt->go_val = number; + + gctl_ro_param(req, opt->go_name, sizeof(intmax_t), opt->go_val); + } else if (opt->go_type == G_TYPE_STRING) { + gctl_ro_param(req, opt->go_name, -1, optarg); + } else /* if (opt->go_type == G_TYPE_NONE) */ { + opt->go_val = malloc(sizeof(int)); + if (opt->go_val == NULL) + errx(EXIT_FAILURE, "No memory."); + *(int *)opt->go_val = *val - '0'; + + gctl_ro_param(req, opt->go_name, sizeof(int), + opt->go_val); + } +} + +/* + * 1. Add given argument by caller. + * 2. Add default values of not given arguments. + * 3. Add the rest of arguments. + */ +static void +parse_arguments(struct g_command *cmd, struct gctl_req *req, int *argc, + char ***argv) +{ + struct g_option *opt; + char opts[64]; + unsigned i; + int ch; + + *opts = '\0'; + if ((cmd->gc_flags & G_FLAG_VERBOSE) != 0) + strlcat(opts, "v", sizeof(opts)); + for (i = 0; ; i++) { + opt = &cmd->gc_options[i]; + if (opt->go_name == NULL) + break; + strlcatf(opts, sizeof(opts), "%c", opt->go_char); + if (opt->go_type != G_TYPE_NONE) + strlcat(opts, ":", sizeof(opts)); + } + + /* + * Add specified arguments. + */ + while ((ch = getopt(*argc, *argv, opts)) != -1) { + /* Standard (not passed to kernel) options. */ + switch (ch) { + case 'v': + verbose = 1; + continue; + } + /* Options passed to kernel. */ + opt = find_option(cmd, ch); + if (opt == NULL) + geom_usage(); + if (G_OPT_ISDONE(opt)) { + fprintf(stderr, "Flag '%c' specified twice.\n", + opt->go_char); + geom_usage(); + } + G_OPT_DONE(opt); + + if (opt->go_type == G_TYPE_NONE) + set_option(req, opt, "1"); + else + set_option(req, opt, optarg); + } + *argc -= optind; + *argv += optind; + + /* + * Add not specified arguments, but with default values. + */ + for (i = 0; ; i++) { + opt = &cmd->gc_options[i]; + if (opt->go_name == NULL) + break; + if (G_OPT_ISDONE(opt)) + continue; + + if (opt->go_type == G_TYPE_NONE) { + assert(opt->go_val == NULL); + set_option(req, opt, "0"); + } else { + if (opt->go_val == NULL) { + fprintf(stderr, "Flag '%c' not specified.\n", + opt->go_char); + geom_usage(); + } else { + if (opt->go_type == G_TYPE_NUMBER) { + gctl_ro_param(req, opt->go_name, + sizeof(intmax_t), opt->go_val); + } else /* if (opt->go_type == G_TYPE_STRING)*/ { + gctl_ro_param(req, opt->go_name, -1, + opt->go_val); + } + } + } + } + /* + * Add rest of given arguments. + */ + gctl_ro_param(req, "nargs", sizeof(int), argc); + for (i = 0; i < (unsigned)*argc; i++) { + char argname[16]; + + snprintf(argname, sizeof(argname), "arg%u", i); + gctl_ro_param(req, argname, -1, (*argv)[i]); + } +} + +/* + * Find given command in commands available for given class. + */ +static struct g_command * +find_command(const char *cmdstr, int all) +{ + struct g_command *cmd; + unsigned i; + + /* + * First try to find command defined by loaded library. + */ + if (class_commands != NULL) { + for (i = 0; ; i++) { + cmd = &class_commands[i]; + if (cmd->gc_name == NULL) + break; + if (strcmp(cmd->gc_name, cmdstr) == 0) + return (cmd); + } + } + if (!all) + return (NULL); + /* + * Now try to find in standard commands. + */ + for (i = 0; ; i++) { + cmd = &std_commands[i]; + if (cmd->gc_name == NULL) + break; + if (!std_available(cmd->gc_name)) + continue; + if (strcmp(cmd->gc_name, cmdstr) == 0) + return (cmd); + } + return (NULL); +} + +static unsigned +set_flags(struct g_command *cmd) +{ + unsigned flags = 0; + + if ((cmd->gc_flags & G_FLAG_VERBOSE) != 0 && verbose) + flags |= G_FLAG_VERBOSE; + + return (flags); +} + +/* + * Run command. + */ +static void +run_command(int argc, char *argv[]) +{ + struct g_command *cmd; + struct gctl_req *req; + const char *errstr; + char buf[4096]; + + cmd = find_command(argv[0], 1); + if (cmd == NULL) { + fprintf(stderr, "Unknown command: %s\n", argv[0]); + geom_usage(); + } + if ((cmd->gc_flags & G_FLAG_LOADKLD) != 0) + load_module(); + + req = gctl_get_handle(); + gctl_ro_param(req, "class", -1, gclass_name); + gctl_ro_param(req, "verb", -1, argv[0]); + if (version != NULL) + gctl_ro_param(req, "version", sizeof(*version), version); + parse_arguments(cmd, req, &argc, &argv); + + if (cmd->gc_func != NULL) { + unsigned flags; + + flags = set_flags(cmd); + cmd->gc_func(req, flags); + errstr = req->error; + } else { + bzero(buf, sizeof(buf)); + gctl_rw_param(req, "output", sizeof(buf), buf); + errstr = gctl_issue(req); + } + if (errstr != NULL) { + fprintf(stderr, "%s\n", errstr); + gctl_free(req); + exit(EXIT_FAILURE); + } + if (*buf != '\0') + printf("%s", buf); + gctl_free(req); + if (verbose) + printf("Done.\n"); + exit(EXIT_SUCCESS); +} + +static void +load_library(void) +{ + char path[MAXPATHLEN]; + uint32_t *lib_version; + void *dlh; + + snprintf(path, sizeof(path), "%s/geom_%s.so", CLASSDIR, class_name); + dlh = dlopen(path, RTLD_NOW); + if (dlh == NULL) { +#if 0 + fprintf(stderr, "Cannot open library %s, but continuing " + "anyway.\n", path); +#endif + /* + * Even if library cannot be loaded, standard commands are + * available, so don't panic! + */ + return; + } + lib_version = dlsym(dlh, "lib_version"); + if (lib_version == NULL) { + fprintf(stderr, "Cannot find symbol %s: %s.\n", "lib_version", + dlerror()); + dlclose(dlh); + exit(EXIT_FAILURE); + } + if (*lib_version != G_LIB_VERSION) { + dlclose(dlh); + errx(EXIT_FAILURE, "%s and %s are not synchronized.", comm, + path); + } + version = dlsym(dlh, "version"); + if (version == NULL) { + fprintf(stderr, "Cannot find symbol %s: %s.\n", "version", + dlerror()); + dlclose(dlh); + exit(EXIT_FAILURE); + } + class_commands = dlsym(dlh, "class_commands"); + if (class_commands == NULL) { + fprintf(stderr, "Cannot find symbol %s: %s.\n", + "class_commands", dlerror()); + dlclose(dlh); + exit(EXIT_FAILURE); + } + usage = dlsym(dlh, "usage"); + if (usage == NULL) + usage = std_usage; +} + +/* + * Class name should be all capital letters. + */ +static void +set_class_name(void) +{ + char *s1, *s2; + + gclass_name = malloc(strlen(class_name)); + if (gclass_name == NULL) + errx(EXIT_FAILURE, "No memory"); + s1 = gclass_name; + s2 = class_name; + for (; *s2 != '\0'; s2++) + *s1++ = toupper(*s2); + *s1 = '\0'; +} + +static void +get_class(int *argc, char ***argv) +{ + + snprintf(comm, sizeof(comm), "%s", basename((*argv)[0])); + if (strcmp(comm, "geom") == 0) { + if (*argc < 2) + geom_usage(); + strlcatf(comm, sizeof(comm), " %s", (*argv)[1]); + class_name = (*argv)[1]; + *argc -= 2; + *argv += 2; + } else if (*comm == 'g') { + class_name = comm + 1; + *argc -= 1; + *argv += 1; + } else { + errx(EXIT_FAILURE, "Invalid utility name."); + } + set_class_name(); + load_library(); + if (*argc < 1) + geom_usage(); +} + +int +main(int argc, char *argv[]) +{ + + get_class(&argc, &argv); + run_command(argc, argv); + /* NOTREACHED */ + + exit(EXIT_FAILURE); +} + +static struct gclass * +find_class(struct gmesh *mesh, const char *name) +{ + struct gclass *classp; + + LIST_FOREACH(classp, &mesh->lg_class, lg_class) { + if (strcmp(classp->lg_name, name) == 0) + return (classp); + } + return (NULL); +} + +static struct gprovider * +find_provider(struct gclass *classp, const char *name) +{ + struct ggeom *gp; + struct gprovider *pp; + + LIST_FOREACH(gp, &classp->lg_geom, lg_geom) { + LIST_FOREACH(pp, &gp->lg_provider, lg_provider) { + if (strcmp(pp->lg_name, name) == 0) + return (pp); + } + } + return (NULL); +} + +static char * +genspaces(const char *text, size_t len) +{ + static char spaces[256]; + size_t outlen; + + if (strlen(text) >= len) { + spaces[0] = '\0'; + return (spaces); + } + memset(spaces, ' ', sizeof(spaces)); + outlen = len - strlen(text); + if (outlen >= sizeof(spaces)) { + spaces[sizeof(spaces) - 1] = '\0'; + return (spaces); + } + spaces[outlen] = '\0'; + return (spaces); +} + +static void +show_one(struct gprovider *pp) +{ + struct gconfig *conf; + + printf(" NAME: %s\n", pp->lg_name); + printf(" geom name: %s\n", pp->lg_geom->lg_name); + printf(" mediasize: %jd\n", (intmax_t)pp->lg_mediasize); + printf(" sectorsize: %u\n", pp->lg_sectorsize); + printf(" mode: %s\n", pp->lg_mode); + LIST_FOREACH(conf, &pp->lg_config, lg_config) { + printf("%s%s: %s\n", genspaces(conf->lg_name, 11), + conf->lg_name, conf->lg_val); + } + printf("\n"); +} + +static int +std_list_available(void) +{ + struct gmesh mesh; + struct gclass *classp; + int error; + + error = geom_gettree(&mesh); + if (error != 0) + exit(EXIT_FAILURE); + classp = find_class(&mesh, gclass_name); + geom_deletetree(&mesh); + if (classp != NULL) + return (1); + return (0); +} + +static void +std_list(struct gctl_req *req, unsigned flags __unused) +{ + struct gmesh mesh; + struct gclass *classp; + struct gprovider *pp; + int error, *nargs; + + error = geom_gettree(&mesh); + if (error != 0) + exit(EXIT_FAILURE); + classp = find_class(&mesh, gclass_name); + if (classp == NULL) { + geom_deletetree(&mesh); + fprintf(stderr, "Class %s not found.\n", gclass_name); + return; + } + nargs = gctl_get_paraml(req, "nargs", sizeof(*nargs)); + if (nargs == NULL) { + gctl_error(req, "No '%s' argument.", "nargs"); + geom_deletetree(&mesh); + return; + } + if (*nargs > 0) { + int i; + + for (i = 0; i < *nargs; i++) { + const char *name; + char param[16]; + + snprintf(param, sizeof(param), "arg%d", i); + name = gctl_get_asciiparam(req, param); + assert(name != NULL); + pp = find_provider(classp, name); + if (pp != NULL) + show_one(pp); + else { + fprintf(stderr, "No such provider: %s.\n", + name); + } + } + } else { + struct ggeom *gp; + + LIST_FOREACH(gp, &classp->lg_geom, lg_geom) { + LIST_FOREACH(pp, &gp->lg_provider, lg_provider) { + show_one(pp); + } + } + } + geom_deletetree(&mesh); +} + +static int +std_load_available(void) +{ + char name[MAXPATHLEN], paths[MAXPATHLEN * 8], *p; + struct stat sb; + size_t len; + + snprintf(name, sizeof(name), "g_%s", class_name); + /* + * If already in kernel, "load" command is not available. + */ + if (modfind(name) >= 0) + return (0); + bzero(paths, sizeof(paths)); + len = sizeof(paths); + if (sysctlbyname("kern.module_path", paths, &len, NULL, 0) < 0) + err(EXIT_FAILURE, "sysctl(kern.module_path)"); + for (p = strtok(paths, ";"); p != NULL; p = strtok(NULL, ";")) { + snprintf(name, sizeof(name), "%s/geom_%s.ko", p, class_name); + /* + * If geom_.ko file exists, "load" command is available. + */ + if (stat(name, &sb) == 0) + return (1); + } + return (0); +} + +static void +std_load(struct gctl_req *req __unused, unsigned flags) +{ + + /* + * Do nothing special here, because of G_FLAG_LOADKLD flag, + * module is already loaded. + */ + if ((flags & G_FLAG_VERBOSE) != 0) + printf("Module available.\n"); +} + +static int +std_unload_available(void) +{ + char name[64]; + int id; + + snprintf(name, sizeof(name), "geom_%s", class_name); + id = kldfind(name); + if (id >= 0) + return (1); + return (0); +} + +static void +std_unload(struct gctl_req *req, unsigned flags __unused) +{ + char name[64]; + int id; + + snprintf(name, sizeof(name), "geom_%s", class_name); + id = kldfind(name); + if (id < 0) { + gctl_error(req, "Could not find module: %s.", strerror(errno)); + return; + } + if (kldunload(id) < 0) { + gctl_error(req, "Could not unload module: %s.", + strerror(errno)); + return; + } +} + +static int +std_available(const char *name) +{ + + if (strcmp(name, "list") == 0) + return (std_list_available()); + else if (strcmp(name, "load") == 0) + return (std_load_available()); + else if (strcmp(name, "unload") == 0) + return (std_unload_available()); + else + assert(!"Unknown standard command."); + return (0); +} diff --git a/sbin/geom/core/geom.h b/sbin/geom/core/geom.h new file mode 100644 index 000000000000..06b97a0c2154 --- /dev/null +++ b/sbin/geom/core/geom.h @@ -0,0 +1,62 @@ +/*- + * Copyright (c) 2004 Pawel Jakub Dawidek + * All rights reserved. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHORS 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 AUTHORS 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$ + */ + +#ifndef _GEOM_H_ +#define _GEOM_H_ +#define G_LIB_VERSION 0 + +#define G_FLAG_NONE 0x0000 +#define G_FLAG_VERBOSE 0x0001 +#define G_FLAG_LOADKLD 0x0002 + +#define G_TYPE_NONE 0 +#define G_TYPE_STRING 1 +#define G_TYPE_NUMBER 2 + +#define G_OPT_MAX 16 +#define G_OPT_DONE(opt) (opt)->go_char = '\0' +#define G_OPT_ISDONE(opt) ((opt)->go_char == '\0') + +#define G_OPT_SENTINEL { '\0', NULL, NULL, G_TYPE_NONE } +#define G_NULL_OPTS { G_OPT_SENTINEL } +#define G_CMD_SENTINEL { NULL, 0, NULL, G_NULL_OPTS } + +struct g_option { + char go_char; + const char *go_name; + void *go_val; + unsigned go_type; +}; + +struct g_command { + const char *gc_name; + unsigned gc_flags; + void (*gc_func)(struct gctl_req *, unsigned); + struct g_option gc_options[G_OPT_MAX]; +}; +#endif /* !_GEOM_H_ */ diff --git a/sbin/geom/misc/subr.c b/sbin/geom/misc/subr.c new file mode 100644 index 000000000000..9d72e3483442 --- /dev/null +++ b/sbin/geom/misc/subr.c @@ -0,0 +1,247 @@ +/*- + * Copyright (c) 2004 Pawel Jakub Dawidek + * All rights reserved. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHORS 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 AUTHORS 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. + */ + +#include +__FBSDID("$FreeBSD$"); + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "misc/subr.h" + + +struct std_metadata { + char md_magic[16]; + uint32_t md_version; +}; + +static void +std_metadata_decode(const u_char *data, struct std_metadata *md) +{ + + bcopy(data, md->md_magic, sizeof(md->md_magic)); + md->md_version = le32dec(data + 16); +} + +static void +pathgen(const char *name, char *path, size_t size) +{ + + if (strncmp(name, _PATH_DEV, strlen(_PATH_DEV)) != 0) + snprintf(path, size, "%s%s", _PATH_DEV, name); + else + strlcpy(path, name, size); +} + +int +g_metadata_store(const char *name, u_char *md, size_t size) +{ + char path[MAXPATHLEN]; + unsigned sectorsize; + off_t mediasize; + u_char *sector; + int error, fd; + + pathgen(name, path, sizeof(path)); + sector = NULL; + error = 0; + + fd = open(path, O_WRONLY); + if (fd == -1) + return (errno); + if (ioctl(fd, DIOCGMEDIASIZE, &mediasize) < 0) { + error = errno; + goto out; + } + if (ioctl(fd, DIOCGSECTORSIZE, §orsize) < 0) { + error = errno; + goto out; + } + assert(sectorsize >= size); + sector = malloc(sectorsize); + if (sector == NULL) { + error = ENOMEM; + goto out; + } + bcopy(md, sector, size); + if (pwrite(fd, sector, sectorsize, mediasize - sectorsize) != + (ssize_t)sectorsize) { + error = errno; + goto out; + } +out: + if (sector != NULL) + free(sector); + close(fd); + return (error); +} + +int +g_metadata_clear(const char *name, const char *magic) +{ + struct std_metadata md; + char path[MAXPATHLEN]; + unsigned sectorsize; + off_t mediasize; + u_char *sector; + int error, fd; + + pathgen(name, path, sizeof(path)); + sector = NULL; + error = 0; + + fd = open(path, O_RDWR); + if (fd == -1) + return (errno); + if (ioctl(fd, DIOCGMEDIASIZE, &mediasize) < 0) { + error = errno; + goto out; + } + if (ioctl(fd, DIOCGSECTORSIZE, §orsize) < 0) { + error = errno; + goto out; + } + sector = malloc(sectorsize); + if (sector == NULL) { + error = ENOMEM; + goto out; + } + if (magic != NULL) { + if (pread(fd, sector, sectorsize, mediasize - sectorsize) != + (ssize_t)sectorsize) { + error = errno; + goto out; + } + std_metadata_decode(sector, &md); + if (strcmp(md.md_magic, magic) != 0) { + error = EINVAL; + goto out; + } + } + bzero(sector, sectorsize); + if (pwrite(fd, sector, sectorsize, mediasize - sectorsize) != + (ssize_t)sectorsize) { + error = errno; + goto out; + } +out: + if (sector != NULL) + free(sector); + close(fd); + return (error); +} + +/* + * Set an error message, if one does not already exist. + */ +void +gctl_error(struct gctl_req *req, const char *error, ...) +{ + va_list ap; + + if (req->error != NULL) + return; + va_start(ap, error); + vasprintf(&req->error, error, ap); + va_end(ap); +} + +void * +gctl_get_param(struct gctl_req *req, const char *param, int *len) +{ + unsigned i; + void *p; + struct gctl_req_arg *ap; + + for (i = 0; i < req->narg; i++) { + ap = &req->arg[i]; + if (strcmp(param, ap->name)) + continue; + if (!(ap->flag & GCTL_PARAM_RD)) + continue; + p = ap->value; + if (len != NULL) + *len = ap->len; + return (p); + } + return (NULL); +} + +char const * +gctl_get_asciiparam(struct gctl_req *req, const char *param) +{ + unsigned i; + char const *p; + struct gctl_req_arg *ap; + + for (i = 0; i < req->narg; i++) { + ap = &req->arg[i]; + if (strcmp(param, ap->name)) + continue; + if (!(ap->flag & GCTL_PARAM_RD)) + continue; + p = ap->value; + if (ap->len < 1) { + gctl_error(req, "No length argument (%s)", param); + return (NULL); + } + if (p[ap->len - 1] != '\0') { + gctl_error(req, "Unterminated argument (%s)", param); + return (NULL); + } + return (p); + } + return (NULL); +} + +void * +gctl_get_paraml(struct gctl_req *req, const char *param, int len) +{ + int i; + void *p; + + p = gctl_get_param(req, param, &i); + if (p == NULL) + gctl_error(req, "Missing %s argument", param); + else if (i != len) { + p = NULL; + gctl_error(req, "Wrong length %s argument", param); + } + return (p); +} diff --git a/sbin/geom/misc/subr.h b/sbin/geom/misc/subr.h new file mode 100644 index 000000000000..487f3db5ceb8 --- /dev/null +++ b/sbin/geom/misc/subr.h @@ -0,0 +1,38 @@ +/*- + * Copyright (c) 2004 Pawel Jakub Dawidek + * All rights reserved. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHORS 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 AUTHORS 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$ + */ + +#ifndef _SUBR_H_ +#define _SUBR_H_ +int g_metadata_store(const char *name, u_char *md, size_t size); +int g_metadata_clear(const char *name, const char *magic); + +void gctl_error(struct gctl_req *req, const char *error, ...); +void *gctl_get_param(struct gctl_req *req, const char *param, int *len); +char const *gctl_get_asciiparam(struct gctl_req *req, const char *param); +void *gctl_get_paraml(struct gctl_req *req, const char *param, int len); +#endif /* !_SUBR_H_ */