sp_ioctl.c revision ff5ca3bd17dee7e2bf2e4f2e3a2b354e0ecbd00d
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* Soft partitioning metadevice driver (md_sp), administrative routines.
*
* This file contains the administrative routines for the soft partitioning
* metadevice driver. All administration is done through the use of ioctl's.
*
* The primary ioctl's supported by soft partitions are as follows:
*
* MD_IOCSET - set up a new soft partition.
* MD_IOCGET - get the unit structure of a soft partition.
* MD_IOCRESET - delete a soft partition.
* MD_IOCGROW - add space to a soft partition.
* MD_IOCGETDEVS - get the device the soft partition is built on.
* MD_IOC_SPSTATUS - set the status (un_status field in the soft
* partition unit structure) for one or more soft
* partitions.
*
* Note that, as with other metadevices, the majority of the work for
* building/growing/deleting soft partitions is performed in userland
* (specifically in libmeta, see meta_sp.c). The driver's main administrative
* function is to maintain the in-core & metadb entries associated with a soft
* partition.
*
* In addition, a few other ioctl's are supported via helper routines in
* the md driver. These are:
*
* DKIOCINFO - get "disk" information.
* DKIOCGEOM - get geometry information.
* DKIOCGVTOC - get vtoc information.
*/
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/conf.h>
#include <sys/file.h>
#include <sys/user.h>
#include <sys/uio.h>
#include <sys/t_lock.h>
#include <sys/buf.h>
#include <sys/dkio.h>
#include <sys/vtoc.h>
#include <sys/kmem.h>
#include <vm/page.h>
#include <sys/sysmacros.h>
#include <sys/types.h>
#include <sys/mkdev.h>
#include <sys/stat.h>
#include <sys/open.h>
#include <sys/lvm/mdvar.h>
#include <sys/lvm/md_sp.h>
#include <sys/lvm/md_notify.h>
#include <sys/modctl.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/debug.h>
#include <sys/model.h>
#include <sys/sysevent/eventdefs.h>
#include <sys/sysevent/svm.h>
extern int md_status;
extern unit_t md_nunits;
extern set_t md_nsets;
extern md_set_t md_set[];
extern md_ops_t sp_md_ops;
extern md_krwlock_t md_unit_array_rw;
extern major_t md_major;
/*
* FUNCTION: sp_getun()
* INPUT: mnum - minor number of soft partition to get.
* OUTPUT: mde - return error pointer.
* RETURNS: mp_unit_t * - ptr to unit structure requested
* NULL - error
* PURPOSE: Returns a reference to the soft partition unit structure
* indicated by the passed-in minor number.
*/
static mp_unit_t *
sp_getun(minor_t mnum, md_error_t *mde)
{
mp_unit_t *un;
mdi_unit_t *ui;
set_t setno = MD_MIN2SET(mnum);
/* check set */
if ((setno >= md_nsets) || (MD_MIN2UNIT(mnum) >= md_nunits)) {
(void) mdmderror(mde, MDE_INVAL_UNIT, mnum);
return (NULL);
}
if (md_get_setstatus(setno) & MD_SET_STALE) {
(void) mdmddberror(mde, MDE_DB_STALE, mnum, setno);
return (NULL);
}
ui = MDI_UNIT(mnum);
if (ui == NULL) {
(void) mdmderror(mde, MDE_UNIT_NOT_SETUP, mnum);
return (NULL);
}
un = (mp_unit_t *)MD_UNIT(mnum);
if (un->c.un_type != MD_METASP) {
(void) mdmderror(mde, MDE_NOT_SP, mnum);
return (NULL);
}
return (un);
}
/*
* FUNCTION: sp_setstatus()
* INPUT: d - data ptr passed in from ioctl.
* mode - pass-through to ddi_copyin.
* lockp - lock ptr.
* OUTPUT: none.
* RETURNS: 0 - success.
* non-zero - error.
* PURPOSE: Set the status of one or more soft partitions atomically.
* this implements the MD_IOC_SPSTATUS ioctl. Soft partitions
* are passed in as an array of minor numbers. The un_status
* field in the unit structure of each soft partition is set to
* the status passed in and all unit structures are recommitted
* to the metadb at once.
*/
static int
sp_setstatus(void *d, int mode, IOLOCK *lockp)
{
minor_t *minors;
mp_unit_t *un;
mddb_recid_t *recids;
int i, nunits, sz;
int err = 0;
sp_status_t status;
md_error_t *mdep;
md_sp_statusset_t *msp = (md_sp_statusset_t *)d;
nunits = msp->num_units;
sz = msp->size;
status = msp->new_status;
mdep = &msp->mde;
mdclrerror(mdep);
/* allocate minor number and recids arrays */
minors = kmem_alloc(sz, KM_SLEEP);
recids = kmem_alloc((nunits + 1) * sizeof (mddb_recid_t), KM_SLEEP);
/* copyin minor number array */
if (err = ddi_copyin((void *)(uintptr_t)msp->minors, minors, sz, mode))
goto out;
/* check to make sure all units are valid first */
for (i = 0; i < nunits; i++) {
if ((un = sp_getun(minors[i], mdep)) == NULL) {
err = mdmderror(mdep, MDE_INVAL_UNIT, minors[i]);
goto out;
}
}
/* update state for all units */
for (i = 0; i < nunits; i++) {
un = sp_getun(minors[i], mdep);
(void) md_ioctl_writerlock(lockp, MDI_UNIT(minors[i]));
un->un_status = status;
recids[i] = un->c.un_record_id;
md_ioctl_writerexit(lockp);
}
recids[i] = 0;
mddb_commitrecs_wrapper(recids);
out:
kmem_free(minors, sz);
kmem_free(recids, ((nunits + 1) * sizeof (mddb_recid_t)));
return (err);
}
/*
* FUNCTION: sp_update_watermarks()
* INPUT: d - data ptr passed in from ioctl.
* mode - pass-through to ddi_copyin.
* OUTPUT: none.
* RETURNS: 0 - success.
* non-zero - error.
* PURPOSE: This implements the MD_IOC_SPUPDATEWM ioctl.
* Watermarks are passed in an array.
*/
static int
sp_update_watermarks(void *d, int mode)
{
minor_t mnum;
set_t setno;
md_error_t *mdep;
mp_unit_t *un;
int err = 0;
size_t wsz;
size_t osz;
mp_watermark_t *watermarks;
sp_ext_offset_t *offsets;
md_dev64_t device;
buf_t *bp;
int i;
md_sp_update_wm_t *mup = (md_sp_update_wm_t *)d;
side_t side;
mnum = mup->mnum;
setno = MD_MIN2SET(mnum);
side = mddb_getsidenum(setno);
un = MD_UNIT(mnum);
if (un == NULL)
return (EFAULT);
mdep = &mup->mde;
mdclrerror(mdep);
/* Validate the set */
if ((setno >= md_nsets) || (MD_MIN2UNIT(mnum) >= md_nunits))
return (mdmderror(mdep, MDE_INVAL_UNIT, mnum));
if (md_get_setstatus(setno) & MD_SET_STALE)
return (mdmddberror(mdep, MDE_DB_STALE, mnum, setno));
wsz = mup->count * sizeof (mp_watermark_t);
watermarks = kmem_alloc(wsz, KM_SLEEP);
osz = mup->count * sizeof (sp_ext_offset_t);
offsets = kmem_alloc(osz, KM_SLEEP);
/*
* Once we're here, we are no longer stateless: we cannot
* return without first freeing the watermarks and offset
* arrays we just allocated. So use the "out" label instead
* of "return."
*/
/* Retrieve the watermark and offset arrays from user land */
if (ddi_copyin((void *)(uintptr_t)mup->wmp, watermarks, wsz, mode)) {
err = EFAULT;
goto out;
}
if (ddi_copyin((void *)(uintptr_t)mup->osp, offsets, osz, mode)) {
err = EFAULT;
goto out;
}
/*
* NOTE: For multi-node sets we only commit the watermarks if we are
* the master node. This avoids an ioctl-within-ioctl deadlock if the
* underlying device is a mirror.
*/
if (MD_MNSET_SETNO(setno) && !md_set[setno].s_am_i_master) {
goto out;
}
device = un->un_dev;
if ((md_getmajor(device) != md_major) &&
(md_devid_found(setno, side, un->un_key) == 1)) {
device = md_resolve_bydevid(mnum, device, un->un_key);
}
/*
* Flag the fact that we're coming from an ioctl handler to the
* underlying device so that it can take appropriate action if needed.
* This is necessary for multi-owner mirrors as they may need to
* update the metadevice state as a result of the layered open.
*/
if (md_layered_open(mnum, &device, MD_OFLG_FROMIOCTL)) {
err = mdcomperror(mdep, MDE_SP_COMP_OPEN_ERR,
mnum, device);
goto out;
}
bp = kmem_alloc(biosize(), KM_SLEEP);
bioinit(bp);
for (i = 0; i < mup->count; i++) {
/*
* Even the "constant" fields should be initialized
* here, since bioreset() below will clear them.
*/
bp->b_flags = B_WRITE;
bp->b_bcount = sizeof (mp_watermark_t);
bp->b_bufsize = sizeof (mp_watermark_t);
bp->b_un.b_addr = (caddr_t)&watermarks[i];
bp->b_lblkno = offsets[i];
bp->b_edev = md_dev64_to_dev(device);
/*
* For MN sets only:
* Use a special flag MD_STR_WMUPDATE, for the following case:
* If the watermarks reside on a mirror disk and a switch
* of ownership is triggered by this IO,
* the message that is generated by that request must be
* processed even if the commd subsystem is currently suspended.
*
* For non-MN sets or non-mirror metadevices,
* this flag has no meaning and is not checked.
*/
md_call_strategy(bp, MD_NOBLOCK | MD_STR_WMUPDATE, NULL);
if (biowait(bp)) {
err = mdmderror(mdep,
MDE_SP_BADWMWRITE, mnum);
break;
}
/* Get the buf_t ready for the next iteration */
bioreset(bp);
}
biofini(bp);
kmem_free(bp, biosize());
md_layered_close(device, MD_OFLG_NULL);
out:
kmem_free(watermarks, wsz);
kmem_free(offsets, osz);
return (err);
}
/*
* FUNCTION: sp_read_watermark()
* INPUT: d - data ptr passed in from ioctl.
* mode - pass-through to ddi_copyin.
* OUTPUT: none.
* RETURNS: 0 - success.
* non-zero - error.
* PURPOSE: This implements the MD_IOC_SPREADWM ioctl.
*/
static int
sp_read_watermark(void *d, int mode)
{
md_error_t *mdep;
mp_watermark_t watermark;
md_dev64_t device;
buf_t *bp;
md_sp_read_wm_t *mrp = (md_sp_read_wm_t *)d;
mdep = &mrp->mde;
mdclrerror(mdep);
device = mrp->rdev;
/*
* Flag the fact that we are being called from ioctl context so that
* the underlying device can take any necessary extra steps to handle
* this scenario.
*/
if (md_layered_open((minor_t)-1, &device, MD_OFLG_FROMIOCTL)) {
return (mdcomperror(mdep, MDE_SP_COMP_OPEN_ERR,
(minor_t)NODEV, device));
}
bp = kmem_alloc(biosize(), KM_SLEEP);
bioinit(bp);
bp->b_flags = B_READ;
bp->b_bcount = sizeof (mp_watermark_t);
bp->b_bufsize = sizeof (mp_watermark_t);
bp->b_un.b_addr = (caddr_t)&watermark;
bp->b_lblkno = mrp->offset;
bp->b_edev = md_dev64_to_dev(device);
md_call_strategy(bp, MD_NOBLOCK, NULL);
if (biowait(bp)) {
/*
* Taking advantage of the knowledge that mdmderror()
* returns 0, so we don't really need to keep track of
* an error code other than in the error struct.
*/
(void) mdmderror(mdep, MDE_SP_BADWMREAD,
getminor(device));
}
biofini(bp);
kmem_free(bp, biosize());
md_layered_close(device, MD_OFLG_NULL);
if (ddi_copyout(&watermark, (void *)(uintptr_t)mrp->wmp,
sizeof (mp_watermark_t), mode)) {
return (EFAULT);
}
return (0);
}
/*
* FUNCTION: sp_set()
* INPUT: d - data ptr passed in from ioctl.
* mode - pass-through to ddi_copyin.
* OUTPUT: none.
* RETURNS: 0 - success.
* non-zero - error.
* PURPOSE: Create a soft partition. The unit structure representing
* the soft partiton is passed down from userland. We allocate
* a metadb entry, copyin the unit the structure, handle any
* metadevice parenting issues, then commit the record to the
* metadb. Once the record is in the metadb, we must also
* build the associated in-core structures. This is done via
* sp_build_incore() (see sp.c).
*/
static int
sp_set(void *d, int mode)
{
minor_t mnum;
mp_unit_t *un;
void *rec_addr;
mddb_recid_t recids[3];
mddb_type_t rec_type;
int err;
set_t setno;
md_error_t *mdep;
md_unit_t *child_un;
md_set_params_t *msp = (md_set_params_t *)d;
mnum = msp->mnum;
setno = MD_MIN2SET(mnum);
mdep = &msp->mde;
mdclrerror(mdep);
/* validate set */
if ((setno >= md_nsets) || (MD_MIN2UNIT(mnum) >= md_nunits))
return (mdmderror(mdep, MDE_INVAL_UNIT, mnum));
if (md_get_setstatus(setno) & MD_SET_STALE)
return (mdmddberror(mdep, MDE_DB_STALE, mnum, setno));
/* get the record type */
rec_type = (mddb_type_t)md_getshared_key(setno,
sp_md_ops.md_driver.md_drivername);
/* check if there is already a device with this minor number */
un = MD_UNIT(mnum);
if (un != NULL)
return (mdmderror(mdep, MDE_UNIT_ALREADY_SETUP, mnum));
/* create the db record for this soft partition */
if (msp->options & MD_CRO_64BIT) {
#if defined(_ILP32)
return (mdmderror(mdep, MDE_UNIT_TOO_LARGE, mnum));
#else
recids[0] = mddb_createrec((size_t)msp->size, rec_type, 0,
MD_CRO_64BIT | MD_CRO_SOFTPART | MD_CRO_FN, setno);
#endif
} else {
recids[0] = mddb_createrec((size_t)msp->size, rec_type, 0,
MD_CRO_32BIT | MD_CRO_SOFTPART | MD_CRO_FN, setno);
}
/* set initial value for possible child record */
recids[1] = 0;
if (recids[0] < 0)
return (mddbstatus2error(mdep, recids[0], mnum, setno));
/* get the address of the soft partition db record */
rec_addr = (void *) mddb_getrecaddr(recids[0]);
/*
* at this point we can happily mess with the soft partition
* db record since we haven't committed it to the metadb yet.
* if we crash before we commit, the uncommitted record will be
* automatically purged.
*/
/* copy in the user's soft partition unit struct */
if (err = ddi_copyin((void *)(uintptr_t)msp->mdp,
rec_addr, (size_t)msp->size, mode)) {
mddb_deleterec_wrapper(recids[0]);
return (EFAULT);
}
/* fill in common unit structure fields which aren't set in userland */
un = (mp_unit_t *)rec_addr;
/* All 64 bit metadevices only support EFI labels. */
if (msp->options & MD_CRO_64BIT) {
un->c.un_flag |= MD_EFILABEL;
}
MD_SID(un) = mnum;
MD_RECID(un) = recids[0];
MD_PARENT(un) = MD_NO_PARENT;
un->c.un_revision |= MD_FN_META_DEV;
/* if we are parenting a metadevice, set our child's parent field */
if (md_getmajor(un->un_dev) == md_major) {
/* it's a metadevice, need to parent it */
child_un = MD_UNIT(md_getminor(un->un_dev));
if (child_un == NULL) {
mddb_deleterec_wrapper(recids[0]);
return (mdmderror(mdep, MDE_INVAL_UNIT,
md_getminor(un->un_dev)));
}
md_set_parent(un->un_dev, MD_SID(un));
/* set child recid and recids end marker */
recids[1] = MD_RECID(child_un);
recids[2] = 0;
}
/*
* build the incore structures.
*/
if (err = sp_build_incore(rec_addr, 0)) {
md_nblocks_set(mnum, -1ULL);
MD_UNIT(mnum) = NULL;
mddb_deleterec_wrapper(recids[0]);
return (err);
}
/*
* Update unit availability
*/
md_set[setno].s_un_avail--;
/*
* commit the record.
* if we had to update a child record, it will get commited
* as well.
*/
mddb_commitrecs_wrapper(recids);
/* create the mdi_unit struct for this soft partition */
md_create_unit_incore(mnum, &sp_md_ops, 0);
SE_NOTIFY(EC_SVM_CONFIG, ESC_SVM_CREATE, TAG_METADEVICE, MD_UN2SET(un),
MD_SID(un));
return (0);
}
/*
* FUNCTION: sp_get()
* INPUT: d - data ptr.
* mode - pass-through to ddi_copyout.
* lock - lock ptr.
* OUTPUT: none.
* RETURNS: 0 - success.
* non-zero - error.
* PURPOSE: Get the soft partition unit structure specified by the
* minor number. the in-core unit structure is obtained
* and copied into the md_i_get structure passed down from
* userland.
*/
static int
sp_get(void *d, int mode, IOLOCK *lock)
{
minor_t mnum;
mdi_unit_t *ui;
mp_unit_t *un;
md_error_t *mdep;
md_i_get_t *migp = d;
mnum = migp->id;
mdep = &migp->mde;
mdclrerror(mdep);
/* make sure this is a valid unit structure */
if ((MD_MIN2SET(mnum) >= md_nsets) || (MD_MIN2UNIT(mnum) >= md_nunits))
return (mdmderror(mdep, MDE_INVAL_UNIT, mnum));
/* get the mdi_unit */
if ((ui = MDI_UNIT(mnum)) == NULL) {
return (mdmderror(mdep, MDE_UNIT_NOT_SETUP, mnum));
}
/*
* md_ioctl_readerlock returns a reference to the in-core
* unit structure. this lock will be dropped by
* md_ioctl_lock_exit() before the ioctl returns.
*/
un = (mp_unit_t *)md_ioctl_readerlock(lock, ui);
/* verify the md_i_get structure */
if (migp->size == 0) {
migp->size = un->c.un_size;
return (0);
}
if (migp->size < un->c.un_size) {
return (EFAULT);
}
/* copyout unit */
if (ddi_copyout(un, (void *)(uintptr_t)migp->mdp,
un->c.un_size, mode))
return (EFAULT);
return (0);
}
/*
* FUNCTION: sp_reset()
* INPUT: reset_params - soft partitioning reset parameters.
* OUTPUT: none.
* RETURNS: 0 - success.
* non-zero - error.
* PURPOSE: Do the setup work needed to delete a soft partition.
* note that the actual removal of both in-core and metadb
* structures is done in the reset_sp() routine (see sp.c).
* In addition, since multiple soft partitions may exist
* on top of a single metadevice, the soft partition reset
* parameters (md_sp_reset_t) contains information about
* how the soft partition should deparent/reparent the
* underlying metadevice. If the underlying metadevice is
* to be deparented, the new_parent field will be MD_NO_PARENT,
* otherwise it will be contain the minor number of another
* soft partition built on top of the underlying metadevice.
*/
static int
sp_reset(md_sp_reset_t *softp)
{
minor_t mnum = softp->mnum;
mdi_unit_t *ui;
mp_unit_t *un;
md_unit_t *child_un;
set_t setno = MD_MIN2SET(mnum);
mdclrerror(&softp->mde);
/* get the unit structure */
if ((un = sp_getun(mnum, &softp->mde)) == NULL) {
return (mdmderror(&softp->mde, MDE_INVAL_UNIT, mnum));
}
/* don't delete if we have a parent */
if (MD_HAS_PARENT(un->c.un_parent)) {
return (mdmderror(&softp->mde, MDE_IN_USE, mnum));
}
rw_enter(&md_unit_array_rw.lock, RW_WRITER);
ui = MDI_UNIT(mnum);
(void) md_unit_openclose_enter(ui);
/* don't delete if we are currently open */
if (md_unit_isopen(ui)) {
md_unit_openclose_exit(ui);
rw_exit(&md_unit_array_rw.lock);
return (mdmderror(&softp->mde, MDE_IS_OPEN, mnum));
}
md_unit_openclose_exit(ui);
/*
* if we are built on metadevice, we need to deparent
* or reparent that metadevice.
*/
if (md_getmajor(un->un_dev) == md_major) {
child_un = MD_UNIT(md_getminor(un->un_dev));
md_set_parent(un->un_dev, softp->new_parent);
mddb_commitrec_wrapper(MD_RECID(child_un));
}
/* remove the soft partition */
reset_sp(un, mnum, 1);
/*
* Update unit availability
*/
md_set[setno].s_un_avail++;
/*
* If MN set, reset s_un_next so all nodes can have
* the same view of the next available slot when
* nodes are -w and -j
*/
if (MD_MNSET_SETNO(setno)) {
md_upd_set_unnext(setno, MD_MIN2UNIT(mnum));
}
/* release locks and return */
out:
rw_exit(&md_unit_array_rw.lock);
return (0);
}
/*
* FUNCTION: sp_grow()
* INPUT: d - data ptr.
* mode - pass-through to ddi_copyin.
* lockp - lock ptr.
* OUTPUT: none.
* RETURNS: 0 - success.
* non-zero - error.
* PURPOSE: Attach more space to a soft partition. We are passed in
* a new unit structure with the new extents and other updated
* information. The new unit structure essentially replaces
* the old unit for this soft partition. We place the new
* unit into the metadb, delete the old metadb record, and
* then update the in-core unit structure array to point to
* the new unit.
*/
static int
sp_grow(void *d, int mode, IOLOCK *lockp)
{
minor_t mnum;
mp_unit_t *un, *new_un;
mdi_unit_t *ui;
minor_t *par = NULL;
IOLOCK *plock = NULL;
int i;
mddb_recid_t recid;
mddb_type_t rec_type;
mddb_recid_t old_vtoc = 0;
md_create_rec_option_t options;
int err;
int rval = 0;
set_t setno;
md_error_t *mdep;
int npar;
md_grow_params_t *mgp = (md_grow_params_t *)d;
mnum = mgp->mnum;
mdep = &mgp->mde;
setno = MD_MIN2SET(mnum);
npar = mgp->npar;
mdclrerror(mdep);
/* validate set */
if ((setno >= md_nsets) || (MD_MIN2UNIT(mnum) >= md_nunits))
return (mdmderror(mdep, MDE_INVAL_UNIT, mnum));
if (md_get_setstatus(setno) & MD_SET_STALE)
return (mdmddberror(mdep, MDE_DB_STALE, mnum, setno));
/* make sure this soft partition already exists */
ui = MDI_UNIT(mnum);
if (ui == NULL)
return (mdmderror(mdep, MDE_UNIT_NOT_SETUP, mnum));
/* handle any parents */
if (npar >= 1) {
ASSERT((minor_t *)(uintptr_t)mgp->par != NULL);
par = kmem_alloc(npar * sizeof (*par), KM_SLEEP);
plock = kmem_alloc(npar * sizeof (*plock), KM_SLEEP);
if (ddi_copyin((void *)(uintptr_t)mgp->par, par,
(npar * sizeof (*par)), mode) != 0) {
kmem_free(par, npar * sizeof (*par));
kmem_free(plock, npar * sizeof (*plock));
return (EFAULT);
}
}
/*
* handle parent locking. grab the unit writer lock,
* then all parent ioctl locks, and then finally our own.
* parents should be sorted to avoid deadlock.
*/
rw_enter(&md_unit_array_rw.lock, RW_WRITER);
for (i = 0; i < npar; ++i) {
(void) md_ioctl_writerlock(&plock[i],
MDI_UNIT(par[i]));
}
un = (mp_unit_t *)md_ioctl_writerlock(lockp, ui);
rec_type = (mddb_type_t)md_getshared_key(setno,
sp_md_ops.md_driver.md_drivername);
/*
* Preserve the friendly name nature of the unit that is growing.
*/
options = MD_CRO_SOFTPART;
if (un->c.un_revision & MD_FN_META_DEV)
options |= MD_CRO_FN;
if (mgp->options & MD_CRO_64BIT) {
#if defined(_ILP32)
rval = mdmderror(mdep, MDE_UNIT_TOO_LARGE, mnum);
goto out;
#else
recid = mddb_createrec((size_t)mgp->size, rec_type, 0,
MD_CRO_64BIT | options, setno);
#endif
} else {
recid = mddb_createrec((size_t)mgp->size, rec_type, 0,
MD_CRO_32BIT | options, setno);
}
if (recid < 0) {
rval = mddbstatus2error(mdep, (int)recid, mnum, setno);
goto out;
}
/* get the address of the new unit */
new_un = (mp_unit_t *)mddb_getrecaddr(recid);
/* copy in the user's unit struct */
err = ddi_copyin((void *)(uintptr_t)mgp->mdp, new_un,
(size_t)mgp->size, mode);
if (err) {
mddb_deleterec_wrapper(recid);
rval = EFAULT;
goto out;
}
if (options & MD_CRO_FN)
new_un->c.un_revision |= MD_FN_META_DEV;
/* All 64 bit metadevices only support EFI labels. */
if (mgp->options & MD_CRO_64BIT) {
new_un->c.un_flag |= MD_EFILABEL;
/*
* If the device was previously smaller than a terabyte,
* and had a vtoc record attached to it, we remove the
* vtoc record, because the layout has changed completely.
*/
if (((un->c.un_revision & MD_64BIT_META_DEV) == 0) &&
(un->c.un_vtoc_id != 0)) {
old_vtoc = un->c.un_vtoc_id;
new_un->c.un_vtoc_id =
md_vtoc_to_efi_record(old_vtoc, setno);
}
}
/* commit new unit struct */
MD_RECID(new_un) = recid;
mddb_commitrec_wrapper(recid);
/*
* delete old unit struct.
*/
mddb_deleterec_wrapper(MD_RECID(un));
/* place new unit in in-core array */
md_nblocks_set(mnum, new_un->c.un_total_blocks);
MD_UNIT(mnum) = new_un;
SE_NOTIFY(EC_SVM_CONFIG, ESC_SVM_GROW, TAG_METADEVICE,
MD_UN2SET(new_un), MD_SID(new_un));
/*
* If old_vtoc has a non zero value, we know:
* - This unit crossed the border from smaller to larger one TB
* - There was a vtoc record for the unit,
* - This vtoc record is no longer needed, because
* a new efi record has been created for this un.
*/
if (old_vtoc != 0) {
mddb_deleterec_wrapper(old_vtoc);
}
/* release locks, return success */
out:
for (i = npar - 1; (i >= 0); --i)
md_ioctl_writerexit(&plock[i]);
rw_exit(&md_unit_array_rw.lock);
if (plock != NULL)
kmem_free(plock, npar * sizeof (*plock));
if (par != NULL)
kmem_free(par, npar * sizeof (*par));
return (rval);
}
/*
* FUNCTION: sp_getdevs()
* INPUT: d - data ptr.
* mode - pass-through to ddi_copyout.
* lockp - lock ptr.
* OUTPUT: none.
* RETURNS: 0 - success.
* non-zero - error.
* PURPOSE: Get the device on which the soft partition is built.
* This is simply a matter of copying out the md_dev64_t stored
* in the soft partition unit structure.
*/
static int
sp_getdevs(
void *d,
int mode,
IOLOCK *lockp
)
{
minor_t mnum;
mdi_unit_t *ui;
mp_unit_t *un;
md_error_t *mdep;
md_dev64_t *devsp;
md_dev64_t unit_dev;
md_getdevs_params_t *mgdp = (md_getdevs_params_t *)d;
mnum = mgdp->mnum;
mdep = &(mgdp->mde);
mdclrerror(mdep);
/* check set */
if ((MD_MIN2SET(mnum) >= md_nsets) || (MD_MIN2UNIT(mnum) >= md_nunits))
return (mdmderror(mdep, MDE_INVAL_UNIT, mnum));
/* check unit */
if ((ui = MDI_UNIT(mnum)) == NULL) {
return (mdmderror(mdep, MDE_UNIT_NOT_SETUP, mnum));
}
/* get unit */
un = (mp_unit_t *)md_ioctl_readerlock(lockp, ui);
devsp = (md_dev64_t *)(uintptr_t)mgdp->devs;
/* only ever 1 device for a soft partition */
if (mgdp->cnt != 0) {
/* do miniroot->target device translation */
unit_dev = un->un_dev;
if (md_getmajor(unit_dev) != md_major) {
if ((unit_dev = md_xlate_mini_2_targ(unit_dev))
== NODEV64)
return (ENODEV);
}
/* copyout dev information */
if (ddi_copyout(&unit_dev, devsp, sizeof (*devsp), mode) != 0)
return (EFAULT);
}
mgdp->cnt = 1;
return (0);
}
/*
* sp_set_capability:
* ------------------
* Called to set or clear a capability for a softpart
* called by the MD_MN_SET_CAP ioctl.
*/
static int
sp_set_capability(md_mn_setcap_params_t *p, IOLOCK *lockp)
{
set_t setno;
mdi_unit_t *ui;
mp_unit_t *un;
int err = 0;
if ((un = sp_getun(p->mnum, &p->mde)) == NULL)
return (EINVAL);
/* This function is only valid for a multi-node set */
setno = MD_MIN2SET(p->mnum);
if (!MD_MNSET_SETNO(setno)) {
return (EINVAL);
}
ui = MDI_UNIT(p->mnum);
(void) md_ioctl_readerlock(lockp, ui);
if (p->sc_set & DKV_ABR_CAP) {
void (*inc_abr_count)();
ui->ui_tstate |= MD_ABR_CAP; /* Set ABR capability */
/* Increment abr count in underlying metadevice */
inc_abr_count = (void(*)())md_get_named_service(un->un_dev,
0, MD_INC_ABR_COUNT, 0);
if (inc_abr_count != NULL)
(void) (*inc_abr_count)(un->un_dev);
} else {
void (*dec_abr_count)();
ui->ui_tstate &= ~MD_ABR_CAP; /* Clear ABR capability */
/* Decrement abr count in underlying metadevice */
dec_abr_count = (void(*)())md_get_named_service(un->un_dev,
0, MD_DEC_ABR_COUNT, 0);
if (dec_abr_count != NULL)
(void) (*dec_abr_count)(un->un_dev);
}
if (p->sc_set & DKV_DMR_CAP) {
ui->ui_tstate |= MD_DMR_CAP; /* Set DMR capability */
} else {
ui->ui_tstate &= ~MD_DMR_CAP; /* Clear DMR capability */
}
md_ioctl_readerexit(lockp);
return (err);
}
/*
* FUNCTION: sp_admin_ioctl().
* INPUT: cmd - ioctl to be handled.
* data - data ptr.
* mode - pass-through to copyin/copyout routines.
* lockp - lock ptr.
* OUTPUT: none.
* RETURNS: 0 - success.
* non-zero - error.
* PURPOSE: Handle administrative ioctl's. Essentially a large
* switch statement to dispatch the ioctl's to their
* handlers. See comment at beginning of file for specifics
* on which ioctl's are handled.
*/
static int
sp_admin_ioctl(int cmd, void *data, int mode, IOLOCK *lockp)
{
size_t sz = 0;
void *d = NULL;
int err = 0;
/* We can only handle 32-bit clients for internal commands */
if ((mode & DATAMODEL_MASK) != DATAMODEL_ILP32) {
return (EINVAL);
}
/* handle ioctl */
switch (cmd) {
case MD_IOCSET:
{
/* create new soft partition */
if (! (mode & FWRITE))
return (EACCES);
sz = sizeof (md_set_params_t);
d = kmem_alloc(sz, KM_SLEEP);
if (ddi_copyin(data, d, sz, mode)) {
err = EFAULT;
break;
}
err = sp_set(d, mode);
break;
}
case MD_IOCGET:
{
/* get soft partition unit structure */
if (! (mode & FREAD))
return (EACCES);
sz = sizeof (md_i_get_t);
d = kmem_alloc(sz, KM_SLEEP);
if (ddi_copyin(data, d, sz, mode)) {
err = EFAULT;
break;
}
err = sp_get(d, mode, lockp);
break;
}
case MD_IOCRESET:
{
/* delete soft partition */
if (! (mode & FWRITE))
return (EACCES);
sz = sizeof (md_sp_reset_t);
d = kmem_alloc(sz, KM_SLEEP);
if (ddi_copyin(data, d, sz, mode)) {
err = EFAULT;
break;
}
err = sp_reset((md_sp_reset_t *)d);
break;
}
case MD_IOCGROW:
{
/* grow soft partition */
if (! (mode & FWRITE))
return (EACCES);
sz = sizeof (md_grow_params_t);
d = kmem_alloc(sz, KM_SLEEP);
if (ddi_copyin(data, d, sz, mode)) {
err = EFAULT;
break;
}
err = sp_grow(d, mode, lockp);
break;
}
case MD_IOCGET_DEVS:
{
/* get underlying device */
if (! (mode & FREAD))
return (EACCES);
sz = sizeof (md_getdevs_params_t);
d = kmem_alloc(sz, KM_SLEEP);
if (ddi_copyin(data, d, sz, mode)) {
err = EFAULT;
break;
}
err = sp_getdevs(d, mode, lockp);
break;
}
case MD_IOC_SPSTATUS:
{
/* set the status field of one or more soft partitions */
if (! (mode & FWRITE))
return (EACCES);
sz = sizeof (md_sp_statusset_t);
d = kmem_alloc(sz, KM_SLEEP);
if (ddi_copyin(data, d, sz, mode)) {
err = EFAULT;
break;
}
err = sp_setstatus(d, mode, lockp);
break;
}
case MD_IOC_SPUPDATEWM:
case MD_MN_IOC_SPUPDATEWM:
{
if (! (mode & FWRITE))
return (EACCES);
sz = sizeof (md_sp_update_wm_t);
d = kmem_alloc(sz, KM_SLEEP);
if (ddi_copyin(data, d, sz, mode)) {
err = EFAULT;
break;
}
err = sp_update_watermarks(d, mode);
break;
}
case MD_IOC_SPREADWM:
{
if (! (mode & FREAD))
return (EACCES);
sz = sizeof (md_sp_read_wm_t);
d = kmem_alloc(sz, KM_SLEEP);
if (ddi_copyin(data, d, sz, mode)) {
err = EFAULT;
break;
}
err = sp_read_watermark(d, mode);
break;
}
case MD_MN_SET_CAP:
{
if (! (mode & FWRITE))
return (EACCES);
sz = sizeof (md_mn_setcap_params_t);
d = kmem_alloc(sz, KM_SLEEP);
if (ddi_copyin(data, d, sz, mode)) {
err = EFAULT;
break;
}
err = sp_set_capability((md_mn_setcap_params_t *)d, lockp);
break;
}
default:
return (ENOTTY);
}
/*
* copyout and free any args
*/
if (sz != 0) {
if (err == 0) {
if (ddi_copyout(d, data, sz, mode) != 0) {
err = EFAULT;
}
}
kmem_free(d, sz);
}
return (err);
}
/*
* FUNCTION: md_sp_ioctl()
* INPUT: dev - device we are operating on.
* cmd - ioctl to be handled.
* data - data ptr.
* mode - pass-through to copyin/copyout routines.
* lockp - lock ptr.
* OUTPUT: none.
* RETURNS: 0 - success.
* non-zero - error.
* PURPOSE: Dispatch ioctl's. Administrative ioctl's are handled
* by sp_admin_ioctl. All others (see comment at beginning
* of this file) are handled in-line here.
*/
int
md_sp_ioctl(dev_t dev, int cmd, void *data, int mode, IOLOCK *lockp)
{
minor_t mnum = getminor(dev);
mp_unit_t *un;
mdi_unit_t *ui;
int err = 0;
/* handle admin ioctls */
if (mnum == MD_ADM_MINOR)
return (sp_admin_ioctl(cmd, data, mode, lockp));
/* check unit */
if ((MD_MIN2SET(mnum) >= md_nsets) ||
(MD_MIN2UNIT(mnum) >= md_nunits) ||
((ui = MDI_UNIT(mnum)) == NULL) ||
((un = MD_UNIT(mnum)) == NULL))
return (ENXIO);
/* is this a supported ioctl? */
err = md_check_ioctl_against_unit(cmd, un->c);
if (err != 0) {
return (err);
}
/* handle ioctl */
switch (cmd) {
case DKIOCINFO:
{
/* "disk" info */
struct dk_cinfo *p;
if (! (mode & FREAD))
return (EACCES);
p = kmem_alloc(sizeof (*p), KM_SLEEP);
get_info(p, mnum);
if (ddi_copyout((caddr_t)p, data, sizeof (*p), mode) != 0)
err = EFAULT;
kmem_free(p, sizeof (*p));
return (err);
}
case DKIOCGMEDIAINFO:
{
struct dk_minfo p;
if (! (mode & FREAD))
return (EACCES);
get_minfo(&p, mnum);
if (ddi_copyout(&p, data, sizeof (struct dk_minfo), mode) != 0)
err = EFAULT;
return (err);
}
case DKIOCGGEOM:
{
/* geometry information */
struct dk_geom *p;
if (! (mode & FREAD))
return (EACCES);
p = kmem_alloc(sizeof (*p), KM_SLEEP);
md_get_geom((md_unit_t *)un, p);
if (ddi_copyout((caddr_t)p, data, sizeof (*p),
mode) != 0)
err = EFAULT;
kmem_free(p, sizeof (*p));
return (err);
}
case DKIOCGAPART:
{
struct dk_map dmp;
err = 0;
md_get_cgapart((md_unit_t *)un, &dmp);
if ((mode & DATAMODEL_MASK) == DATAMODEL_NATIVE) {
if (ddi_copyout((caddr_t)&dmp, data, sizeof (dmp),
mode) != 0)
err = EFAULT;
}
#ifdef _SYSCALL32
else {
struct dk_map32 dmp32;
dmp32.dkl_cylno = dmp.dkl_cylno;
dmp32.dkl_nblk = dmp.dkl_nblk;
if (ddi_copyout((caddr_t)&dmp32, data, sizeof (dmp32),
mode) != 0)
err = EFAULT;
}
#endif /* _SYSCALL32 */
return (err);
}
case DKIOCGVTOC:
{
/* vtoc information */
struct vtoc *vtoc;
if (! (mode & FREAD))
return (EACCES);
vtoc = kmem_zalloc(sizeof (*vtoc), KM_SLEEP);
md_get_vtoc((md_unit_t *)un, vtoc);
if ((mode & DATAMODEL_MASK) == DATAMODEL_NATIVE) {
if (ddi_copyout(vtoc, data, sizeof (*vtoc), mode))
err = EFAULT;
}
#ifdef _SYSCALL32
else {
struct vtoc32 *vtoc32;
vtoc32 = kmem_zalloc(sizeof (*vtoc32), KM_SLEEP);
vtoctovtoc32((*vtoc), (*vtoc32));
if (ddi_copyout(vtoc32, data, sizeof (*vtoc32), mode))
err = EFAULT;
kmem_free(vtoc32, sizeof (*vtoc32));
}
#endif /* _SYSCALL32 */
kmem_free(vtoc, sizeof (*vtoc));
return (err);
}
case DKIOCSVTOC:
{
struct vtoc *vtoc;
if (! (mode & FWRITE))
return (EACCES);
vtoc = kmem_zalloc(sizeof (*vtoc), KM_SLEEP);
if ((mode & DATAMODEL_MASK) == DATAMODEL_NATIVE) {
if (ddi_copyin(data, vtoc, sizeof (*vtoc), mode)) {
err = EFAULT;
}
}
#ifdef _SYSCALL32
else {
struct vtoc32 *vtoc32;
vtoc32 = kmem_zalloc(sizeof (*vtoc32), KM_SLEEP);
if (ddi_copyin(data, vtoc32, sizeof (*vtoc32), mode)) {
err = EFAULT;
} else {
vtoc32tovtoc((*vtoc32), (*vtoc));
}
kmem_free(vtoc32, sizeof (*vtoc32));
}
#endif /* _SYSCALL32 */
if (err == 0)
err = md_set_vtoc((md_unit_t *)un, vtoc);
kmem_free(vtoc, sizeof (*vtoc));
return (err);
}
case DKIOCGEXTVTOC:
{
/* extended vtoc information */
struct extvtoc *extvtoc;
if (! (mode & FREAD))
return (EACCES);
extvtoc = kmem_zalloc(sizeof (*extvtoc), KM_SLEEP);
md_get_extvtoc((md_unit_t *)un, extvtoc);
if (ddi_copyout(extvtoc, data, sizeof (*extvtoc), mode))
err = EFAULT;
kmem_free(extvtoc, sizeof (*extvtoc));
return (err);
}
case DKIOCSEXTVTOC:
{
struct extvtoc *extvtoc;
if (! (mode & FWRITE))
return (EACCES);
extvtoc = kmem_zalloc(sizeof (*extvtoc), KM_SLEEP);
if (ddi_copyin(data, extvtoc, sizeof (*extvtoc), mode)) {
err = EFAULT;
}
if (err == 0)
err = md_set_extvtoc((md_unit_t *)un, extvtoc);
kmem_free(extvtoc, sizeof (*extvtoc));
return (err);
}
case DKIOCGETEFI:
{
/*
* This one can be done centralized,
* no need to put in the same code for all types of metadevices
*/
return (md_dkiocgetefi(mnum, data, mode));
}
case DKIOCSETEFI:
{
/*
* This one can be done centralized,
* no need to put in the same code for all types of metadevices
*/
return (md_dkiocsetefi(mnum, data, mode));
}
case DKIOCPARTITION:
{
return (md_dkiocpartition(mnum, data, mode));
}
case DKIOCGETVOLCAP:
{
/*
* Return the supported capabilities for the soft-partition.
* We can only support those caps that are provided by the
* underlying device.
*/
volcap_t vc;
if (!MD_MNSET_SETNO(MD_MIN2SET(mnum)))
return (EINVAL);
if (! (mode & FREAD))
return (EACCES);
bzero(&vc, sizeof (vc));
/* Send ioctl to underlying driver */
err = md_call_ioctl(un->un_dev, cmd, &vc, (mode | FKIOCTL),
lockp);
if (err == 0)
ui->ui_capab = vc.vc_info;
if (ddi_copyout(&vc, data, sizeof (vc), mode))
err = EFAULT;
return (err);
}
case DKIOCSETVOLCAP:
{
/*
* Enable a supported capability (as returned by DKIOCGETVOLCAP)
* Do not pass the request down as we're the top-level device
* handler for the application.
* If the requested capability is supported (set in ui_capab),
* set the corresponding bit in ui_tstate so that we can pass
* the appropriate flag when performing i/o.
* This request is propagated to all nodes.
*/
volcap_t vc, vc1;
volcapset_t volcap = 0;
void (*check_offline)();
int offline_status = 0;
if (!MD_MNSET_SETNO(MD_MIN2SET(mnum)))
return (EINVAL);
if (! (mode & FWRITE))
return (EACCES);
if (ddi_copyin(data, &vc, sizeof (vc), mode))
return (EFAULT);
/*
* Send DKIOCGETVOLCAP to underlying driver to see if
* capability supported
*/
vc1.vc_info = 0;
err = md_call_ioctl(un->un_dev, DKIOCGETVOLCAP, &vc1,
(mode | FKIOCTL), lockp);
if (err != 0)
return (err);
/* Save capabilities */
ui->ui_capab = vc1.vc_info;
/*
* Error if required capability not supported by underlying
* driver
*/
if ((vc1.vc_info & vc.vc_set) == 0)
return (ENOTSUP);
/*
* Check if underlying mirror has an offline submirror,
* fail if there is on offline submirror
*/
check_offline = (void(*)())md_get_named_service(un->un_dev,
0, MD_CHECK_OFFLINE, 0);
if (check_offline != NULL)
(void) (*check_offline)(un->un_dev, &offline_status);
if (offline_status)
return (EINVAL);
if (ui->ui_tstate & MD_ABR_CAP)
volcap |= DKV_ABR_CAP;
/* Only send capability message if there is a change */
if ((vc.vc_set & (DKV_ABR_CAP)) != volcap)
err = mdmn_send_capability_message(mnum, vc, lockp);
return (err);
}
case DKIOCDMR:
{
/*
* Only valid for MN sets. We need to pass it down to the
* underlying driver if its a metadevice, after we've modified
* the offsets to pick up the correct lower-level device
* position.
*/
vol_directed_rd_t *vdr;
#ifdef _MULTI_DATAMODEL
vol_directed_rd32_t *vdr32;
#endif /* _MULTI_DATAMODEL */
if (!MD_MNSET_SETNO(MD_MIN2SET(mnum)))
return (EINVAL);
if (! (ui->ui_capab & DKV_DMR_CAP))
return (EINVAL);
vdr = kmem_zalloc(sizeof (vol_directed_rd_t), KM_NOSLEEP);
if (vdr == NULL)
return (ENOMEM);
/*
* Underlying device supports directed mirror read, so update
* the user-supplied offset to pick the correct block from the
* partitioned metadevice.
*/
#ifdef _MULTI_DATAMODEL
vdr32 = kmem_zalloc(sizeof (vol_directed_rd32_t), KM_NOSLEEP);
if (vdr32 == NULL) {
kmem_free(vdr, sizeof (vol_directed_rd_t));
return (ENOMEM);
}
switch (ddi_model_convert_from(mode & FMODELS)) {
case DDI_MODEL_ILP32:
if (ddi_copyin(data, vdr32, sizeof (*vdr32), mode)) {
kmem_free(vdr, sizeof (*vdr));
return (EFAULT);
}
vdr->vdr_flags = vdr32->vdr_flags;
vdr->vdr_offset = vdr32->vdr_offset;
vdr->vdr_nbytes = vdr32->vdr_nbytes;
vdr->vdr_data = (void *)(uintptr_t)vdr32->vdr_data;
vdr->vdr_side = vdr32->vdr_side;
break;
case DDI_MODEL_NONE:
if (ddi_copyin(data, vdr, sizeof (*vdr), mode)) {
kmem_free(vdr32, sizeof (*vdr32));
kmem_free(vdr, sizeof (*vdr));
return (EFAULT);
}
break;
default:
kmem_free(vdr32, sizeof (*vdr32));
kmem_free(vdr, sizeof (*vdr));
return (EFAULT);
}
#else /* ! _MULTI_DATAMODEL */
if (ddi_copyin(data, vdr, sizeof (*vdr), mode)) {
kmem_free(vdr, sizeof (*vdr));
return (EFAULT);
}
#endif /* _MULTI_DATA_MODEL */
err = sp_directed_read(mnum, vdr, mode);
#ifdef _MULTI_DATAMODEL
switch (ddi_model_convert_from(mode & FMODELS)) {
case DDI_MODEL_ILP32:
vdr32->vdr_flags = vdr->vdr_flags;
vdr32->vdr_offset = vdr->vdr_offset;
vdr32->vdr_side = vdr->vdr_side;
vdr32->vdr_bytesread = vdr->vdr_bytesread;
bcopy(vdr->vdr_side_name, vdr32->vdr_side_name,
sizeof (vdr32->vdr_side_name));
if (ddi_copyout(vdr32, data, sizeof (*vdr32), mode))
err = EFAULT;
break;
case DDI_MODEL_NONE:
if (ddi_copyout(&vdr, data, sizeof (vdr), mode))
err = EFAULT;
break;
}
#else /* ! _MULTI_DATA_MODEL */
if (ddi_copyout(&vdr, data, sizeof (vdr), mode))
err = EFAULT;
#endif /* _MULTI_DATA_MODEL */
#ifdef _MULTI_DATAMODEL
kmem_free(vdr32, sizeof (*vdr32));
#endif /* _MULTI_DATAMODEL */
kmem_free(vdr, sizeof (*vdr));
return (err);
}
}
/* Option not handled */
return (ENOTTY);
}