meta_nameinfo.c revision bf85a12b7c81d0745d5a8aff65baeff50006cde9
1N/A/*
1N/A * CDDL HEADER START
1N/A *
1N/A * The contents of this file are subject to the terms of the
1N/A * Common Development and Distribution License (the "License").
1N/A * You may not use this file except in compliance with the License.
1N/A *
1N/A * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
1N/A * or http://www.opensolaris.org/os/licensing.
1N/A * See the License for the specific language governing permissions
1N/A * and limitations under the License.
1N/A *
1N/A * When distributing Covered Code, include this CDDL HEADER in each
1N/A * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
1N/A * If applicable, add the following below this CDDL HEADER, with the
1N/A * fields enclosed by brackets "[]" replaced with your own identifying
1N/A * information: Portions Copyright [yyyy] [name of copyright owner]
1N/A *
1N/A * CDDL HEADER END
1N/A */
1N/A
1N/A/*
1N/A * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
1N/A * Use is subject to license terms.
1N/A */
1N/A
1N/A#include <dlfcn.h>
1N/A#include <meta.h>
1N/A#include <metadyn.h>
1N/A#include <ctype.h>
1N/A#include <dirent.h>
1N/A#include <devid.h>
1N/A#include <sys/param.h>
1N/A#include <sys/scsi/impl/uscsi.h>
1N/A#include <sys/scsi/generic/commands.h>
1N/A#include <sys/scsi/generic/inquiry.h>
1N/A#include <sys/efi_partition.h>
1N/A
1N/Atypedef struct ctlr_cache {
1N/A char *ctlr_nm;
1N/A int ctlr_ty;
1N/A struct ctlr_cache *ctlr_nx;
1N/A} ctlr_cache_t;
1N/A
1N/Astatic ctlr_cache_t *ctlr_cache = NULL;
1N/A
1N/A
1N/A/*
1N/A * return set for a device
1N/A */
1N/Amdsetname_t *
1N/Ametagetset(
1N/A mdname_t *np,
1N/A int bypass_daemon,
1N/A md_error_t *ep
1N/A)
1N/A{
1N/A mdsetname_t *sp;
1N/A
1N/A /* metadevice */
1N/A if (metaismeta(np))
1N/A return (metasetnosetname(MD_MIN2SET(meta_getminor(np->dev)),
1N/A ep));
1N/A
1N/A /* regular device */
1N/A if (meta_is_drive_in_anyset(np->drivenamep, &sp, bypass_daemon,
1N/A ep) != 0)
1N/A return (NULL);
1N/A
1N/A if (sp != NULL)
1N/A return (sp);
1N/A
1N/A return (metasetnosetname(MD_LOCAL_SET, ep));
1N/A}
1N/A
1N/A/*
1N/A * convert system to md types
1N/A */
1N/Astatic void
1N/Ameta_geom_to_md(
1N/A struct dk_geom *gp,
1N/A mdgeom_t *mdgp
1N/A)
1N/A{
1N/A (void) memset(mdgp, '\0', sizeof (*mdgp));
1N/A mdgp->ncyl = gp->dkg_ncyl;
1N/A mdgp->nhead = gp->dkg_nhead;
1N/A mdgp->nsect = gp->dkg_nsect;
1N/A mdgp->rpm = gp->dkg_rpm;
1N/A mdgp->write_reinstruct = gp->dkg_write_reinstruct;
1N/A mdgp->read_reinstruct = gp->dkg_read_reinstruct;
1N/A mdgp->blk_sz = DEV_BSIZE;
1N/A}
1N/A
1N/A/*
1N/A * convert efi to md types
1N/A */
1N/Astatic void
1N/Ameta_efi_to_mdgeom(struct dk_gpt *gpt, mdgeom_t *mdgp)
1N/A{
1N/A (void) memset(mdgp, '\0', sizeof (*mdgp));
1N/A mdgp->ncyl = (gpt->efi_last_u_lba - gpt->efi_first_u_lba) /
1N/A (MD_EFI_FG_HEADS * MD_EFI_FG_SECTORS);
1N/A mdgp->nhead = MD_EFI_FG_HEADS;
1N/A mdgp->nsect = MD_EFI_FG_SECTORS;
1N/A mdgp->rpm = MD_EFI_FG_RPM;
1N/A mdgp->write_reinstruct = MD_EFI_FG_WRI;
1N/A mdgp->read_reinstruct = MD_EFI_FG_RRI;
1N/A mdgp->blk_sz = DEV_BSIZE;
1N/A}
1N/A
1N/Astatic void
1N/Ameta_efi_to_mdvtoc(struct dk_gpt *gpt, mdvtoc_t *mdvp)
1N/A{
1N/A char typename[EFI_PART_NAME_LEN];
1N/A uint_t i;
1N/A
1N/A (void) memset(mdvp, '\0', sizeof (*mdvp));
1N/A mdvp->nparts = gpt->efi_nparts;
1N/A if (mdvp->nparts > MD_MAX_PARTS)
1N/A return;
1N/A
1N/A mdvp->first_lba = gpt->efi_first_u_lba;
1N/A mdvp->last_lba = gpt->efi_last_u_lba;
1N/A mdvp->lbasize = gpt->efi_lbasize;
1N/A
1N/A for (i = 0; (i < gpt->efi_nparts); ++i) {
1N/A mdvp->parts[i].start = gpt->efi_parts[i].p_start;
1N/A mdvp->parts[i].size = gpt->efi_parts[i].p_size;
1N/A mdvp->parts[i].tag = gpt->efi_parts[i].p_tag;
1N/A mdvp->parts[i].flag = gpt->efi_parts[i].p_flag;
1N/A /*
1N/A * It is possible to present an efi label but be using vtoc
1N/A * disks to create a > 1 TB metadevice. In case the first
1N/A * disk in the underlying metadevice is a vtoc disk and starts
1N/A * at the beginning of the disk it is necessary to convey this
1N/A * information to the user.
1N/A */
1N/A if (mdvp->parts[i].size > 0 &&
1N/A mdvp->parts[i].start != 0 && mdvp->nparts == 1) {
1N/A mdvp->parts[i].label = btodb(DK_LABEL_SIZE);
1N/A mdvp->parts[i].start = 0;
1N/A }
1N/A
1N/A /*
1N/A * Due to the lack of a label for the entire partition table,
1N/A * we use p_name of the reserved partition
1N/A */
1N/A if ((gpt->efi_parts[i].p_tag == V_RESERVED) &&
1N/A (gpt->efi_parts[i].p_name != NULL)) {
1N/A (void) strlcpy(typename, gpt->efi_parts[i].p_name,
1N/A EFI_PART_NAME_LEN);
1N/A /* Stop at first (if any) space or tab */
1N/A (void) strtok(typename, " \t");
1N/A mdvp->typename = Strdup(typename);
1N/A }
1N/A }
1N/A}
1N/A
1N/Astatic void
1N/Ameta_mdvtoc_to_efi(mdvtoc_t *mdvp, struct dk_gpt **gpt)
1N/A{
1N/A char typename[EFI_PART_NAME_LEN];
1N/A uint_t i;
1N/A uint_t lastpart;
1N/A size_t size;
1N/A
1N/A /* first we count how many partitions we have to send */
1N/A for (i = 0; i < MD_MAX_PARTS; i++) {
1N/A if ((mdvp->parts[i].start == 0) &&
1N/A (mdvp->parts[i].size == 0) &&
1N/A (mdvp->parts[i].tag != V_RESERVED)) {
1N/A continue;
1N/A }
1N/A /* if we are here, we know the partition is really used */
1N/A lastpart = i;
1N/A }
1N/A size = sizeof (struct dk_gpt) + (sizeof (struct dk_part) * lastpart);
1N/A *gpt = calloc(size, sizeof (char));
1N/A
1N/A (*gpt)->efi_nparts = lastpart + 1;
1N/A (*gpt)->efi_first_u_lba = mdvp->first_lba;
1N/A (*gpt)->efi_last_u_lba = mdvp->last_lba;
1N/A (*gpt)->efi_lbasize = mdvp->lbasize;
1N/A for (i = 0; (i < (*gpt)->efi_nparts); ++i) {
1N/A (*gpt)->efi_parts[i].p_start = mdvp->parts[i].start;
1N/A (*gpt)->efi_parts[i].p_size = mdvp->parts[i].size;
1N/A (*gpt)->efi_parts[i].p_tag = mdvp->parts[i].tag;
1N/A (*gpt)->efi_parts[i].p_flag = mdvp->parts[i].flag;
1N/A /*
1N/A * Due to the lack of a label for the entire partition table,
1N/A * we use p_name of the reserved partition
1N/A */
1N/A if (((*gpt)->efi_parts[i].p_tag == V_RESERVED) &&
1N/A (mdvp->typename != NULL)) {
1N/A (void) strlcpy((*gpt)->efi_parts[i].p_name, typename,
1N/A EFI_PART_NAME_LEN);
1N/A }
1N/A }
1N/A}
1N/A
1N/A
1N/Avoid
1N/Actlr_cache_add(char *nm, int ty)
1N/A{
1N/A ctlr_cache_t **ccpp;
1N/A
1N/A for (ccpp = &ctlr_cache; *ccpp != NULL; ccpp = &(*ccpp)->ctlr_nx)
1N/A if (strcmp((*ccpp)->ctlr_nm, nm) == 0)
1N/A return;
1N/A
1N/A *ccpp = Zalloc(sizeof (ctlr_cache_t));
1N/A (*ccpp)->ctlr_nm = Strdup(nm);
1N/A (*ccpp)->ctlr_ty = ty;
1N/A}
1N/A
1N/Aint
1N/Actlr_cache_look(char *nm)
1N/A{
1N/A ctlr_cache_t *tcp;
1N/A
1N/A for (tcp = ctlr_cache; tcp != NULL; tcp = tcp->ctlr_nx)
1N/A if (strcmp(tcp->ctlr_nm, nm) == 0)
1N/A return (tcp->ctlr_ty);
1N/A
1N/A return (-1);
1N/A}
1N/A
1N/A
1N/Avoid
1N/Ametaflushctlrcache(void)
1N/A{
1N/A ctlr_cache_t *cp, *np;
1N/A
1N/A for (cp = ctlr_cache, np = NULL; cp != NULL; cp = np) {
1N/A np = cp->ctlr_nx;
1N/A Free(cp->ctlr_nm);
1N/A Free(cp);
1N/A }
1N/A ctlr_cache = NULL;
1N/A}
1N/A
1N/A/*
1N/A * getdrvnode -- return the driver name based on mdname_t->bname
1N/A * Need to free pointer when finished.
1N/A */
1N/Achar *
1N/Agetdrvnode(mdname_t *np, md_error_t *ep)
1N/A{
1N/A char *devicespath;
1N/A char *drvnode;
1N/A char *cp;
1N/A
1N/A if ((devicespath = metagetdevicesname(np, ep)) == NULL)
1N/A return (NULL);
1N/A
1N/A /*
1N/A * At this point devicespath should be like the following
1N/A * "/devices/<unknow_and_dont_care>/xxxx@vvvv"
1N/A *
1N/A * There's a couple of 'if' statements below which could
1N/A * return an error condition, but I've decide to allow
1N/A * a more open approach regarding the mapping so as to
1N/A * not restrict possible future projects.
1N/A */
1N/A if (drvnode = strrchr(devicespath, '/'))
1N/A /*
1N/A * drvnode now just "xxxx@vvvv"
1N/A */
1N/A drvnode++;
1N/A
1N/A if (cp = strrchr(drvnode, '@'))
1N/A /*
1N/A * Now drvnode is just the driver name "xxxx"
1N/A */
1N/A *cp = '\0';
1N/A
1N/A cp = Strdup(drvnode);
1N/A Free(devicespath);
1N/A np->devicesname = NULL;
1N/A
1N/A return (cp);
1N/A}
1N/A
1N/A/*
1N/A * meta_load_dl -- open dynamic library using LDLIBRARYPATH, a debug
1N/A * environment variable METALDPATH, or the default location.
1N/A */
1N/Astatic void *
1N/Ameta_load_dl(mdname_t *np, md_error_t *ep)
1N/A{
1N/A char *drvnode;
1N/A char newpath[MAXPATHLEN];
1N/A char *p;
1N/A void *cookie;
1N/A
1N/A if ((drvnode = getdrvnode(np, ep)) != NULL) {
1N/A
1N/A /*
1N/A * Library seach algorithm:
1N/A * 1) Use LDLIBRARYPATH which is implied when a non-absolute
1N/A * path name is passed to dlopen()
1N/A * 2) Use the value of METALDPATH as the directory. Mainly
1N/A * used for debugging
1N/A * 3) Last search the default location of "/usr/lib"
1N/A */
1N/A (void) snprintf(newpath, sizeof (newpath), "lib%s.so.1",
1N/A drvnode);
1N/A if ((cookie = dlopen(newpath, RTLD_LAZY)) == NULL) {
1N/A if ((p = getenv("METALDPATH")) == NULL)
1N/A p = METALDPATH_DEFAULT;
1N/A (void) snprintf(newpath, sizeof (newpath),
1N/A "%s/lib%s.so.1", p, drvnode);
1N/A Free(drvnode);
1N/A if ((cookie = dlopen(newpath, RTLD_LAZY)) != NULL) {
1N/A /*
1N/A * Common failure here would be failing to
1N/A * find a libXX.so.1 such as libsd.so.1
1N/A * Some controllers will not have a library
1N/A * because there's no enclosure or name
1N/A * translation required.
1N/A */
1N/A return (cookie);
1N/A }
1N/A } else {
1N/A Free(drvnode);
1N/A return (cookie);
1N/A }
1N/A }
1N/A return (NULL);
1N/A}
1N/A
1N/A/*
1N/A * meta_match_names -- possibly convert the driver names returned by CINFO
1N/A */
1N/Astatic void
1N/Ameta_match_names(mdname_t *np, struct dk_cinfo *cp, mdcinfo_t *mdcp,
1N/A md_error_t *ep)
1N/A{
1N/A void *cookie;
1N/A meta_convert_e ((*fptr)(mdname_t *, struct dk_cinfo *, mdcinfo_t *,
1N/A md_error_t *));
1N/A
1N/A if ((cookie = meta_load_dl(np, ep)) != NULL) {
1N/A fptr = (meta_convert_e (*)(mdname_t *, struct dk_cinfo *,
1N/A mdcinfo_t *, md_error_t *))dlsym(cookie, "convert_path");
1N/A if (fptr != NULL)
1N/A (void) (*fptr)(np, cp, mdcp, ep);
1N/A (void) dlclose(cookie);
1N/A }
1N/A}
1N/A
1N/A/*
1N/A * meta_match_enclosure -- return any enclosure info if found
1N/A */
1N/Aint
1N/Ameta_match_enclosure(mdname_t *np, mdcinfo_t *mdcp, md_error_t *ep)
1N/A{
1N/A meta_enclosure_e e;
1N/A meta_enclosure_e ((*fptr)(mdname_t *, mdcinfo_t *,
1N/A md_error_t *));
1N/A void *cookie;
1N/A
1N/A if ((cookie = meta_load_dl(np, ep)) != NULL) {
1N/A fptr = (meta_enclosure_e (*)(mdname_t *, mdcinfo_t *,
1N/A md_error_t *))dlsym(cookie, "get_enclosure");
1N/A if (fptr != NULL) {
1N/A e = (*fptr)(np, mdcp, ep);
1N/A switch (e) {
1N/A case Enclosure_Error:
1N/A /*
1N/A * Looks like this library wanted to handle
1N/A * our device and had an internal error.
1N/A */
1N/A return (1);
1N/A
1N/A case Enclosure_Okay:
1N/A /*
1N/A * Found a library to handle the request so
1N/A * just return with data provided.
1N/A */
1N/A return (0);
1N/A
1N/A case Enclosure_Noop:
1N/A /*
1N/A * Need to continue the search
1N/A */
1N/A break;
1N/A }
1N/A }
1N/A (void) dlclose(cookie);
1N/A }
1N/A return (0);
1N/A}
1N/A
1N/Astatic int
1N/Ameta_cinfo_to_md(mdname_t *np, struct dk_cinfo *cp, mdcinfo_t *mdcp,
1N/A md_error_t *ep)
1N/A{
1N/A /* default */
1N/A (void) memset(mdcp, '\0', sizeof (*mdcp));
1N/A (void) strncpy(mdcp->cname, cp->dki_cname,
1N/A min((sizeof (mdcp->cname) - 1), sizeof (cp->dki_cname)));
1N/A mdcp->ctype = MHD_CTLR_GENERIC;
1N/A mdcp->cnum = cp->dki_cnum;
1N/A (void) strncpy(mdcp->dname, cp->dki_dname,
1N/A min((sizeof (mdcp->dname) - 1), sizeof (cp->dki_dname)));
1N/A mdcp->unit = cp->dki_unit;
1N/A mdcp->maxtransfer = cp->dki_maxtransfer;
1N/A
1N/A /*
1N/A * See if the driver name returned from DKIOCINFO
1N/A * is valid or not. In somecases, such as the ap_dmd
1N/A * driver, we need to modify the name that's return
1N/A * for everything to work.
1N/A */
1N/A meta_match_names(np, cp, mdcp, ep);
1N/A
1N/A if (meta_match_enclosure(np, mdcp, ep))
1N/A return (-1);
1N/A
1N/A /* return success */
1N/A return (0);
1N/A}
1N/A
1N/Astatic void
1N/Ameta_vtoc_to_md(
1N/A struct extvtoc *vp,
1N/A mdvtoc_t *mdvp
1N/A)
1N/A{
1N/A char typename[sizeof (vp->v_asciilabel) + 1];
1N/A uint_t i;
1N/A
1N/A (void) memset(mdvp, '\0', sizeof (*mdvp));
1N/A (void) strncpy(typename, vp->v_asciilabel,
1N/A sizeof (vp->v_asciilabel));
1N/A typename[sizeof (typename) - 1] = '\0';
1N/A for (i = 0; ((i < sizeof (typename)) && (typename[i] != '\0')); ++i) {
1N/A if ((typename[i] == ' ') || (typename[i] == '\t')) {
1N/A typename[i] = '\0';
1N/A break;
1N/A }
1N/A }
1N/A mdvp->typename = Strdup(typename);
1N/A mdvp->nparts = vp->v_nparts;
1N/A for (i = 0; (i < vp->v_nparts); ++i) {
1N/A mdvp->parts[i].start = vp->v_part[i].p_start;
1N/A mdvp->parts[i].size = vp->v_part[i].p_size;
1N/A mdvp->parts[i].tag = vp->v_part[i].p_tag;
1N/A mdvp->parts[i].flag = vp->v_part[i].p_flag;
1N/A if (vp->v_part[i].p_start == 0 && vp->v_part[i].p_size > 0)
1N/A mdvp->parts[i].label = btodb(DK_LABEL_SIZE);
1N/A }
1N/A}
1N/A
1N/A/*
1N/A * free allocations in vtoc
1N/A */
1N/Avoid
1N/Ametafreevtoc(
1N/A mdvtoc_t *vtocp
1N/A)
1N/A{
1N/A if (vtocp->typename != NULL)
1N/A Free(vtocp->typename);
1N/A (void) memset(vtocp, 0, sizeof (*vtocp));
1N/A}
1N/A
1N/A/*
1N/A * return md types
1N/A */
1N/Amdvtoc_t *
1N/Ametagetvtoc(
1N/A mdname_t *np, /* only rname, drivenamep, are setup */
1N/A int nocache,
1N/A uint_t *partnop,
1N/A md_error_t *ep
1N/A)
1N/A{
1N/A mddrivename_t *dnp = np->drivenamep;
1N/A struct dk_geom geom;
1N/A char *minor_name = NULL;
1N/A char *rname = np->rname;
1N/A int fd;
1N/A int partno;
1N/A int err = 0; /* saves errno from ioctl */
1N/A ddi_devid_t devid;
1N/A char *p;
1N/A
1N/A /* short circuit */
1N/A if ((! nocache) && (dnp->vtoc.nparts != 0)) {
1N/A if (partnop != NULL) {
1N/A /*
1N/A * the following assigment works because the
1N/A * mdname_t structs are always created as part
1N/A * of the drivenamep struct. When a user
1N/A * creates an mdname_t struct it either
1N/A * uses an existing drivenamep struct or creates
1N/A * a new one and then adds the mdname_t struct
1N/A * as part of its parts_val array. So what is
1N/A * being computed below is the slice offset in
1N/A * the parts_val array.
1N/A */
1N/A *partnop = np - np->drivenamep->parts.parts_val;
1N/A assert(*partnop < dnp->parts.parts_len);
1N/A }
1N/A return (&dnp->vtoc);
1N/A }
1N/A
1N/A /* can't get vtoc */
1N/A if (! nocache) {
1N/A switch (dnp->type) {
1N/A case MDT_ACCES:
1N/A case MDT_UNKNOWN:
1N/A (void) mdsyserror(ep, dnp->errnum, rname);
1N/A return (NULL);
1N/A }
1N/A }
1N/A
1N/A /* get all the info */
1N/A if ((fd = open(rname, (O_RDONLY|O_NDELAY), 0)) < 0) {
1N/A (void) mdsyserror(ep, errno, rname);
1N/A return (NULL);
1N/A }
1N/A
1N/A /*
1N/A * The disk is open so this is a good point to get the devid
1N/A * otherwise it will need to be done at another time which
1N/A * means reopening it.
1N/A */
1N/A if (devid_get(fd, &devid) != 0) {
1N/A /* there is no devid for the disk */
1N/A if (((p = getenv("MD_DEBUG")) != NULL) &&
1N/A (strstr(p, "DEVID") != NULL)) {
1N/A (void) fprintf(stderr, dgettext(TEXT_DOMAIN,
1N/A "%s has no device id\n"), np->rname);
1N/A }
1N/A np->minor_name = (char *)NULL;
1N/A dnp->devid = NULL;
1N/A } else {
1N/A (void) devid_get_minor_name(fd, &minor_name);
1N/A /*
1N/A * The minor name could be NULL if the underlying
1N/A * device driver does not support 'minor names'.
1N/A * This means we do not use devid's for this device.
1N/A * SunCluster did driver does not support minor names.
1N/A */
1N/A if (minor_name != NULL) {
1N/A np->minor_name = Strdup(minor_name);
1N/A devid_str_free(minor_name);
1N/A dnp->devid = devid_str_encode(devid, NULL);
1N/A } else {
1N/A np->minor_name = (char *)NULL;
1N/A dnp->devid = NULL;
1N/A
1N/A if (((p = getenv("MD_DEBUG")) != NULL) &&
1N/A (strstr(p, "DEVID") != NULL)) {
1N/A (void) fprintf(stderr, dgettext(TEXT_DOMAIN,
1N/A "%s no minor name (no devid)\n"),
1N/A np->rname);
1N/A }
1N/A }
1N/A devid_free(devid);
1N/A }
1N/A
1N/A /*
1N/A * if our drivenamep points to a device not supporting DKIOCGGEOM,
1N/A * it's likely to have an EFI label.
1N/A */
1N/A (void) memset(&geom, 0, sizeof (geom));
1N/A if (ioctl(fd, DKIOCGGEOM, &geom) != 0) {
1N/A err = errno;
1N/A if (err == ENOTTY) {
1N/A (void) mddeverror(ep, MDE_NOT_DISK, NODEV, rname);
1N/A (void) close(fd);
1N/A return (NULL);
1N/A } else if (err != ENOTSUP) {
1N/A (void) mdsyserror(ep, err, rname);
1N/A (void) close(fd);
1N/A return (NULL);
1N/A }
1N/A
1N/A }
1N/A /*
1N/A * If we are here, there was either no failure on DKIOCGGEOM or
1N/A * the failure was ENOTSUP
1N/A */
1N/A if (err == ENOTSUP) {
1N/A /* DKIOCGGEOM yielded ENOTSUP => try efi_alloc_and_read */
1N/A struct dk_gpt *gpt;
1N/A int save_errno;
1N/A
1N/A /* this also sets errno */
1N/A partno = efi_alloc_and_read(fd, &gpt);
1N/A save_errno = errno;
1N/A (void) close(fd);
1N/A if (partno < 0) {
1N/A efi_free(gpt);
1N/A (void) mdsyserror(ep, save_errno, rname);
1N/A return (NULL);
1N/A }
1N/A if (partno >= gpt->efi_nparts) {
1N/A efi_free(gpt);
1N/A (void) mddeverror(ep, MDE_INVALID_PART, NODEV64,
1N/A rname);
1N/A return (NULL);
1N/A }
1N/A
1N/A /* convert to our format */
1N/A metafreevtoc(&dnp->vtoc);
1N/A meta_efi_to_mdvtoc(gpt, &dnp->vtoc);
1N/A if (dnp->vtoc.nparts > MD_MAX_PARTS) {
1N/A (void) mddeverror(ep, MDE_TOO_MANY_PARTS, NODEV64,
1N/A rname);
1N/A return (NULL);
1N/A }
1N/A /*
1N/A * libmeta needs at least V_NUMPAR partitions.
1N/A * If we have an EFI partition with less than V_NUMPAR slices,
1N/A * we nevertheless reserve space for V_NUMPAR
1N/A */
1N/A
1N/A if (dnp->vtoc.nparts < V_NUMPAR) {
1N/A dnp->vtoc.nparts = V_NUMPAR;
1N/A }
1N/A meta_efi_to_mdgeom(gpt, &dnp->geom);
1N/A efi_free(gpt);
1N/A } else {
1N/A /* no error on DKIOCGGEOM, try meta_getvtoc */
1N/A struct extvtoc vtoc;
1N/A
1N/A if (meta_getvtoc(fd, np->cname, &vtoc, &partno, ep) < 0) {
1N/A (void) close(fd);
1N/A return (NULL);
1N/A }
1N/A (void) close(fd);
1N/A
1N/A /* convert to our format */
1N/A meta_geom_to_md(&geom, &dnp->geom);
1N/A metafreevtoc(&dnp->vtoc);
1N/A meta_vtoc_to_md(&vtoc, &dnp->vtoc);
1N/A }
1N/A
1N/A /* fix up any drives which are now accessible */
1N/A if ((nocache) && (dnp->type == MDT_ACCES) &&
1N/A (dnp->vtoc.nparts == dnp->parts.parts_len)) {
1N/A dnp->type = MDT_COMP;
1N/A dnp->errnum = 0;
1N/A }
1N/A
1N/A /* save partno */
1N/A assert(partno < dnp->vtoc.nparts);
1N/A if (partnop != NULL)
1N/A *partnop = partno;
1N/A
1N/A /* return info */
1N/A return (&dnp->vtoc);
1N/A}
1N/A
1N/Astatic void
1N/Ameta_mdvtoc_to_vtoc(
1N/A mdvtoc_t *mdvp,
1N/A struct extvtoc *vp
1N/A)
1N/A{
1N/A uint_t i;
1N/A
1N/A (void) memset(&vp->v_part, '\0', sizeof (vp->v_part));
1N/A vp->v_nparts = (ushort_t)mdvp->nparts;
1N/A for (i = 0; (i < mdvp->nparts); ++i) {
1N/A vp->v_part[i].p_start = mdvp->parts[i].start;
1N/A vp->v_part[i].p_size = mdvp->parts[i].size;
1N/A vp->v_part[i].p_tag = mdvp->parts[i].tag;
1N/A vp->v_part[i].p_flag = mdvp->parts[i].flag;
1N/A }
1N/A}
1N/A
1N/A/*
1N/A * Set the vtoc, but use the cached copy to get the info from.
1N/A * We write np->drivenamep->vtoc to disk.
1N/A * Before we can do this we read the vtoc in.
1N/A * if we're dealing with a metadevice and this metadevice is a 64 bit device
1N/A * we can use meta_getmdvtoc/meta_setmdvtoc
1N/A * else
1N/A * we use meta_getvtoc/meta_setvtoc but than we first have to convert
1N/A * dnp->vtoc (actually being a mdvtoc_t) into a vtoc_t
1N/A */
1N/Aint
1N/Ametasetvtoc(
1N/A mdname_t *np,
1N/A md_error_t *ep
1N/A)
1N/A{
1N/A char *rname = np->rname;
1N/A mddrivename_t *dnp = np->drivenamep;
1N/A int fd;
1N/A int err;
1N/A int save_errno;
1N/A struct dk_geom geom;
1N/A
1N/A if ((fd = open(rname, (O_RDONLY | O_NDELAY), 0)) < 0)
1N/A return (mdsyserror(ep, errno, rname));
1N/A
1N/A err = ioctl(fd, DKIOCGGEOM, &geom);
1N/A save_errno = errno;
1N/A if (err == 0) {
1N/A struct extvtoc vtoc;
1N/A
1N/A if (meta_getvtoc(fd, np->cname, &vtoc, NULL, ep) < 0) {
1N/A (void) close(fd);
1N/A return (-1);
1N/A }
1N/A
1N/A meta_mdvtoc_to_vtoc(&dnp->vtoc, &vtoc);
1N/A
1N/A if (meta_setvtoc(fd, np->cname, &vtoc, ep) < 0) {
1N/A (void) close(fd);
1N/A return (-1);
1N/A }
1N/A } else if (save_errno == ENOTSUP) {
1N/A struct dk_gpt *gpt;
1N/A int ret;
1N/A
1N/A /* allocation of gpt is done in meta_mdvtoc_to_efi */
1N/A meta_mdvtoc_to_efi(&dnp->vtoc, &gpt);
1N/A
1N/A ret = efi_write(fd, gpt);
1N/A save_errno = errno;
1N/A free(gpt);
1N/A if (ret != 0) {
1N/A (void) close(fd);
1N/A return (mdsyserror(ep, save_errno, rname));
1N/A } else {
1N/A (void) close(fd);
1N/A return (0);
1N/A }
1N/A
1N/A } else {
1N/A (void) close(fd);
1N/A return (mdsyserror(ep, save_errno, rname));
1N/A }
1N/A
1N/A (void) close(fd);
1N/A
1N/A return (0);
}
mdgeom_t *
metagetgeom(
mdname_t *np, /* only rname, drivenamep, are setup */
md_error_t *ep
)
{
if (metagetvtoc(np, FALSE, NULL, ep) == NULL)
return (NULL);
return (&np->drivenamep->geom);
}
mdcinfo_t *
metagetcinfo(
mdname_t *np, /* only rname, drivenamep, are setup */
md_error_t *ep
)
{
char *rname = np->rname;
mddrivename_t *dnp = np->drivenamep;
int fd;
struct dk_cinfo cinfo;
/* short circuit */
if (dnp->cinfo.cname[0] != '\0')
return (&dnp->cinfo);
/* get controller info */
if ((fd = open(rname, (O_RDONLY|O_NDELAY), 0)) < 0) {
(void) mdsyserror(ep, errno, rname);
return (NULL);
}
if (ioctl(fd, DKIOCINFO, &cinfo) != 0) {
int save = errno;
(void) close(fd);
if (save == ENOTTY) {
(void) mddeverror(ep, MDE_NOT_DISK, NODEV64, rname);
} else {
(void) mdsyserror(ep, save, rname);
}
return (NULL);
}
(void) close(fd); /* sd/ssd bug */
/* convert to our format */
if (meta_cinfo_to_md(np, &cinfo, &dnp->cinfo, ep) != 0)
return (NULL);
/* return info */
return (&dnp->cinfo);
}
/*
* get partition number
*/
int
metagetpartno(
mdname_t *np,
md_error_t *ep
)
{
mdvtoc_t *vtocp;
uint_t partno;
if ((vtocp = metagetvtoc(np, FALSE, &partno, ep)) == NULL)
return (-1);
assert(partno < vtocp->nparts);
return (partno);
}
/*
* get size of device
*/
diskaddr_t
metagetsize(
mdname_t *np,
md_error_t *ep
)
{
mdvtoc_t *vtocp;
uint_t partno;
if ((vtocp = metagetvtoc(np, FALSE, &partno, ep)) == NULL)
return (MD_DISKADDR_ERROR);
assert(partno < vtocp->nparts);
return (vtocp->parts[partno].size);
}
/*
* get label of device
*/
diskaddr_t
metagetlabel(
mdname_t *np,
md_error_t *ep
)
{
mdvtoc_t *vtocp;
uint_t partno;
if ((vtocp = metagetvtoc(np, FALSE, &partno, ep)) == NULL)
return (MD_DISKADDR_ERROR);
assert(partno < vtocp->nparts);
return (vtocp->parts[partno].label);
}
/*
* find out where database replicas end
*/
static int
mddb_getendblk(
mdsetname_t *sp,
mdname_t *np,
diskaddr_t *endblkp,
md_error_t *ep
)
{
md_replicalist_t *rlp = NULL;
md_replicalist_t *rl;
/* make sure we have a component */
*endblkp = 0;
if (metaismeta(np))
return (0);
/* get replicas, quit if none */
if (metareplicalist(sp, MD_BASICNAME_OK | PRINT_FAST, &rlp, ep) < 0) {
if (! mdismddberror(ep, MDE_DB_NODB))
return (-1);
mdclrerror(ep);
return (0);
} else if (rlp == NULL)
return (0);
/* go through all the replicas */
for (rl = rlp; (rl != NULL); rl = rl->rl_next) {
md_replica_t *rp = rl->rl_repp;
mdname_t *repnamep = rp->r_namep;
diskaddr_t dbend;
if (np->dev != repnamep->dev)
continue;
dbend = rp->r_blkno + rp->r_nblk - 1;
if (dbend > *endblkp)
*endblkp = dbend;
}
/* cleanup, return success */
metafreereplicalist(rlp);
return (0);
}
/*
* return cached start block
*/
static diskaddr_t
metagetend(
mdsetname_t *sp,
mdname_t *np,
md_error_t *ep
)
{
diskaddr_t end_blk = MD_DISKADDR_ERROR;
/* short circuit */
if (np->end_blk != MD_DISKADDR_ERROR)
return (np->end_blk);
/* look for database locations */
if (mddb_getendblk(sp, np, &end_blk, ep) != 0)
return (MD_DISKADDR_ERROR);
/* success */
np->end_blk = end_blk;
return (end_blk);
}
/*
* does device have a metadb
*/
int
metahasmddb(
mdsetname_t *sp,
mdname_t *np,
md_error_t *ep
)
{
if (metagetend(sp, np, ep) == MD_DISKADDR_ERROR)
return (-1);
else if (np->end_blk > 0)
return (1);
else
return (0);
}
/*
* return cached start block
*/
diskaddr_t
metagetstart(
mdsetname_t *sp,
mdname_t *np,
md_error_t *ep
)
{
diskaddr_t start_blk = MD_DISKADDR_ERROR;
/* short circuit */
if (np->start_blk != MD_DISKADDR_ERROR)
return (np->start_blk);
/* look for database locations */
if ((start_blk = metagetend(sp, np, ep)) == MD_DISKADDR_ERROR)
return (MD_DISKADDR_ERROR);
/* check for label */
if (start_blk == 0) {
start_blk = metagetlabel(np, ep);
if (start_blk == MD_DISKADDR_ERROR) {
return (MD_DISKADDR_ERROR);
}
}
/* roundup to next cylinder */
if (start_blk != 0) {
mdgeom_t *geomp;
if ((geomp = metagetgeom(np, ep)) == NULL)
return (MD_DISKADDR_ERROR);
start_blk = roundup(start_blk, (geomp->nhead * geomp->nsect));
}
/* success */
np->start_blk = start_blk;
return (start_blk);
}
/*
* return cached devices name
*/
char *
metagetdevicesname(
mdname_t *np,
md_error_t *ep
)
{
char path[MAXPATHLEN + 1];
int len;
/* short circuit */
if (np->devicesname != NULL)
return (np->devicesname);
/* follow symlink */
if ((len = readlink(np->bname, path, (sizeof (path) - 1))) < 0) {
(void) mdsyserror(ep, errno, np->bname);
return (NULL);
} else if (len >= sizeof (path)) {
(void) mdsyserror(ep, ENAMETOOLONG, np->bname);
return (NULL);
}
path[len] = '\0';
if ((len = strfind(path, "/devices/")) < 0) {
(void) mddeverror(ep, MDE_DEVICES_NAME, np->dev, np->bname);
return (NULL);
}
/* return name */
np->devicesname = Strdup(path + len + strlen("/devices"));
return (np->devicesname);
}
/*
* get metadevice misc name
*/
char *
metagetmiscname(
mdname_t *np,
md_error_t *ep
)
{
mddrivename_t *dnp = np->drivenamep;
md_i_driverinfo_t mid;
/* short circuit */
if (dnp->miscname != NULL)
return (dnp->miscname);
if (metachkmeta(np, ep) != 0)
return (NULL);
/* get misc module from driver */
(void) memset(&mid, 0, sizeof (mid));
mid.mnum = meta_getminor(np->dev);
if (metaioctl(MD_IOCGET_DRVNM, &mid, &mid.mde, np->cname) != 0) {
(void) mdstealerror(ep, &mid.mde);
return (NULL);
}
/* return miscname */
dnp->miscname = Strdup(MD_PNTDRIVERNAME(&mid));
return (dnp->miscname);
}
/*
* get unit structure from driver
*/
md_unit_t *
meta_get_mdunit(
mdsetname_t *sp,
mdname_t *np,
md_error_t *ep
)
{
md_i_get_t mig;
char *miscname = NULL;
/* should have a set */
assert(sp != NULL);
assert(sp->setno == MD_MIN2SET(meta_getminor(np->dev)));
/* get size of unit structure */
if (metachkmeta(np, ep) != 0)
return (NULL);
if ((miscname = metagetmiscname(np, ep)) == NULL)
return (NULL);
(void) memset(&mig, '\0', sizeof (mig));
MD_SETDRIVERNAME(&mig, miscname, sp->setno);
mig.id = meta_getminor(np->dev);
if (metaioctl(MD_IOCGET, &mig, &mig.mde, np->cname) != 0) {
(void) mdstealerror(ep, &mig.mde);
return (NULL);
}
/* get actual unit structure */
assert(mig.size > 0);
mig.mdp = (uintptr_t)Zalloc(mig.size);
if (metaioctl(MD_IOCGET, &mig, &mig.mde, np->cname) != 0) {
(void) mdstealerror(ep, &mig.mde);
Free((void *)(uintptr_t)mig.mdp);
return (NULL);
}
return ((md_unit_t *)(uintptr_t)mig.mdp);
}
/*
* free metadevice unit
*/
void
meta_free_unit(
mddrivename_t *dnp
)
{
if (dnp->unitp != NULL) {
switch (dnp->unitp->type) {
case MD_DEVICE:
meta_free_stripe((md_stripe_t *)dnp->unitp);
break;
case MD_METAMIRROR:
meta_free_mirror((md_mirror_t *)dnp->unitp);
break;
case MD_METATRANS:
meta_free_trans((md_trans_t *)dnp->unitp);
break;
case MD_METARAID:
meta_free_raid((md_raid_t *)dnp->unitp);
break;
case MD_METASP:
meta_free_sp((md_sp_t *)dnp->unitp);
break;
default:
assert(0);
break;
}
dnp->unitp = NULL;
}
}
/*
* free metadevice name info
*/
void
meta_invalidate_name(
mdname_t *namep
)
{
mddrivename_t *dnp = namep->drivenamep;
/* get rid of cached name info */
if (namep->devicesname != NULL) {
Free(namep->devicesname);
namep->devicesname = NULL;
}
namep->key = MD_KEYBAD;
namep->start_blk = -1;
namep->end_blk = -1;
/* get rid of cached drivename info */
(void) memset(&dnp->geom, 0, sizeof (dnp->geom));
(void) memset(&dnp->cinfo, 0, sizeof (dnp->cinfo));
metafreevtoc(&dnp->vtoc);
metaflushsidenames(dnp);
dnp->side_names_key = MD_KEYBAD;
if (dnp->miscname != NULL) {
Free(dnp->miscname);
dnp->miscname = NULL;
}
meta_free_unit(dnp);
}
/*
* get metadevice unit
*/
md_common_t *
meta_get_unit(
mdsetname_t *sp,
mdname_t *np,
md_error_t *ep
)
{
char *miscname;
/* short circuit */
if (np->drivenamep->unitp != NULL)
return (np->drivenamep->unitp);
if (metachkmeta(np, ep) != 0)
return (NULL);
/* dispatch */
if ((miscname = metagetmiscname(np, ep)) == NULL)
return (NULL);
else if (strcmp(miscname, MD_STRIPE) == 0)
return ((md_common_t *)meta_get_stripe(sp, np, ep));
else if (strcmp(miscname, MD_MIRROR) == 0)
return ((md_common_t *)meta_get_mirror(sp, np, ep));
else if (strcmp(miscname, MD_TRANS) == 0)
return ((md_common_t *)meta_get_trans(sp, np, ep));
else if (strcmp(miscname, MD_RAID) == 0)
return ((md_common_t *)meta_get_raid(sp, np, ep));
else if (strcmp(miscname, MD_SP) == 0)
return ((md_common_t *)meta_get_sp(sp, np, ep));
else {
(void) mdmderror(ep, MDE_UNKNOWN_TYPE, meta_getminor(np->dev),
np->cname);
return (NULL);
}
}
int
meta_isopen(
mdsetname_t *sp,
mdname_t *np,
md_error_t *ep,
mdcmdopts_t options
)
{
md_isopen_t d;
if (metachkmeta(np, ep) != 0)
return (-1);
(void) memset(&d, '\0', sizeof (d));
d.dev = np->dev;
if (metaioctl(MD_IOCISOPEN, &d, &d.mde, np->cname) != 0)
return (mdstealerror(ep, &d.mde));
/*
* shortcut: if the device is open, no need to check on other nodes,
* even in case of a mn metadevice
* Also return in case we're told not to check on other nodes.
*/
if ((d.isopen != 0) || ((options & MDCMD_MN_OPEN_CHECK) == 0)) {
return (d.isopen);
}
/*
* If the device is closed locally, but it's a mn device,
* check on all other nodes, too
*/
if (sp->setno != MD_LOCAL_SET) {
(void) metaget_setdesc(sp, ep); /* not supposed to fail */
if (sp->setdesc->sd_flags & MD_SR_MN) {
int err = 0;
md_mn_result_t *resp;
/*
* This message is never directly issued.
* So we launch it with a suspend override flag.
* If the commd is suspended, and this message comes
* along it must be sent due to replaying a metainit or
* similar. In that case we don't want this message to
* be blocked.
* If the commd is not suspended, the flag does no harm.
* Additionally we don't want the result of the message
* cached in the MCT, because we want uptodate results,
* and the message doesn't need being logged either.
* Hence NO_LOG and NO_MCT
*/
err = mdmn_send_message(sp->setno,
MD_MN_MSG_CLU_CHECK, MD_MSGF_NO_MCT |
MD_MSGF_STOP_ON_ERROR | MD_MSGF_NO_LOG |
MD_MSGF_OVERRIDE_SUSPEND, 0, (char *)&d,
sizeof (md_isopen_t), &resp, ep);
if (err == 0) {
d.isopen = resp->mmr_exitval;
} else {
/*
* in case some error occurred,
* we better say the device is open
*/
d.isopen = 1;
}
if (resp != (md_mn_result_t *)NULL) {
free_result(resp);
}
}
}
return (d.isopen);
}