OpenSolaris_b135/lib/libdiskmgt/common/partition.c
/*
* 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.
*/
#include <fcntl.h>
#include <libdevinfo.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/sunddi.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <unistd.h>
#include <sys/dkio.h>
#if defined(i386) || defined(__amd64)
#include <sys/dktp/fdisk.h>
#include <libfdisk.h>
#endif
#include "libdiskmgt.h"
#include "disks_private.h"
#include "partition.h"
#ifdef sparc
#define les(val) ((((val)&0xFF)<<8)|(((val)>>8)&0xFF))
#define lel(val) (((unsigned)(les((val)&0x0000FFFF))<<16) | \
(les((unsigned)((val)&0xffff0000)>>16)))
#else
#define les(val) (val)
#define lel(val) (val)
#endif
#define TOTAL_NUMPART (FD_NUMPART + MAX_EXT_PARTS)
#define ISIZE FD_NUMPART * sizeof (struct ipart)
static int desc_ok(descriptor_t *dp);
static int get_attrs(descriptor_t *dp, struct ipart *iparts,
nvlist_t *attrs);
static int get_parts(disk_t *disk, struct ipart *iparts, char *opath,
int opath_len);
static int open_disk(disk_t *diskp, char *opath, int len);
static int has_slices(descriptor_t *desc, int *errp);
descriptor_t **
partition_get_assoc_descriptors(descriptor_t *desc, dm_desc_type_t type,
int *errp)
{
if (!desc_ok(desc)) {
*errp = ENODEV;
return (NULL);
}
switch (type) {
case DM_MEDIA:
return (media_get_assocs(desc, errp));
case DM_SLICE:
if (!has_slices(desc, errp)) {
if (*errp != 0) {
return (NULL);
}
return (libdiskmgt_empty_desc_array(errp));
}
return (slice_get_assocs(desc, errp));
}
*errp = EINVAL;
return (NULL);
}
/*
* This is called by media/slice to get the associated partitions.
* For a media desc. we just get all the partitions, but for a slice desc.
* we just get the active solaris partition.
*/
descriptor_t **
partition_get_assocs(descriptor_t *desc, int *errp)
{
descriptor_t **partitions;
int pos;
int i;
struct ipart iparts[TOTAL_NUMPART];
char pname[MAXPATHLEN];
int conv_flag = 0;
#if defined(i386) || defined(__amd64)
int len;
#endif
if (get_parts(desc->p.disk, iparts, pname, sizeof (pname)) != 0) {
return (libdiskmgt_empty_desc_array(errp));
}
/* allocate the array for the descriptors */
partitions = (descriptor_t **)calloc(TOTAL_NUMPART + 1,
sizeof (descriptor_t *));
if (partitions == NULL) {
*errp = ENOMEM;
return (NULL);
}
#if defined(i386) || defined(__amd64)
/* convert part. name (e.g. c0d0p1) */
len = strlen(pname);
if (len > 1 && *(pname + (len - 2)) == 'p') {
conv_flag = 1;
*(pname + (len - 1)) = 0;
}
#endif
/*
* If this is a slice desc. we need the first active solaris partition
* and if there isn't one then we need the first solaris partition.
*/
if (desc->type == DM_SLICE) {
for (i = 0; i < TOTAL_NUMPART; i++) {
if (iparts[i].bootid == ACTIVE &&
(iparts[i].systid == SUNIXOS ||
iparts[i].systid == SUNIXOS2)) {
break;
}
}
/*
* no active solaris part.,*try to get the first solaris part.
*/
if (i >= TOTAL_NUMPART) {
for (i = 0; i < TOTAL_NUMPART; i++) {
if (iparts[i].systid == SUNIXOS ||
iparts[i].systid == SUNIXOS2) {
break;
}
}
}
if (i < TOTAL_NUMPART) {
/* we found a solaris partition to use */
char part_name[MAXPATHLEN];
if (conv_flag) {
/* convert part. name (e.g. c0d0p1) */
(void) snprintf(part_name, sizeof (part_name),
"%s%d", pname, i+1);
} else {
(void) snprintf(part_name, sizeof (part_name),
"%d", i+1);
}
/* the media name comes from the slice desc. */
partitions[0] = cache_get_desc(DM_PARTITION,
desc->p.disk, part_name, desc->secondary_name,
errp);
if (*errp != 0) {
cache_free_descriptors(partitions);
return (NULL);
}
partitions[1] = NULL;
return (partitions);
}
return (libdiskmgt_empty_desc_array(errp));
}
/* Must be for media, so get all the parts. */
pos = 0;
for (i = 0; i < TOTAL_NUMPART; i++) {
if (iparts[i].systid != UNUSED) {
char part_name[MAXPATHLEN];
/*
* Process the descriptors and modify the cxdxpx
* format so that it refers to the fdisk partition
* number and not to the physical disk. This is
* achieved by i+1, where i is the number of the
* physical disk partition.
*/
if (conv_flag) {
/* convert part. name (e.g. c0d0p1) */
(void) snprintf(part_name, sizeof (part_name),
"%s%d", pname, i+1);
} else {
(void) snprintf(part_name, sizeof (part_name),
"%d", i+1);
}
/* the media name comes from the media desc. */
partitions[pos] = cache_get_desc(DM_PARTITION,
desc->p.disk, part_name, desc->name, errp);
if (*errp != 0) {
cache_free_descriptors(partitions);
return (NULL);
}
pos++;
}
}
partitions[pos] = NULL;
*errp = 0;
return (partitions);
}
nvlist_t *
partition_get_attributes(descriptor_t *dp, int *errp)
{
nvlist_t *attrs = NULL;
struct ipart iparts[TOTAL_NUMPART];
if (!desc_ok(dp)) {
*errp = ENODEV;
return (NULL);
}
if ((*errp = get_parts(dp->p.disk, iparts, NULL, 0)) != 0) {
return (NULL);
}
if (nvlist_alloc(&attrs, NVATTRS, 0) != 0) {
*errp = ENOMEM;
return (NULL);
}
if ((*errp = get_attrs(dp, iparts, attrs)) != 0) {
nvlist_free(attrs);
attrs = NULL;
}
return (attrs);
}
/*
* Look for the partition by the partition number (which is not too useful).
*/
descriptor_t *
partition_get_descriptor_by_name(char *name, int *errp)
{
descriptor_t **partitions;
int i;
descriptor_t *partition = NULL;
partitions = cache_get_descriptors(DM_PARTITION, errp);
if (*errp != 0) {
return (NULL);
}
for (i = 0; partitions[i]; i++) {
if (libdiskmgt_str_eq(name, partitions[i]->name)) {
partition = partitions[i];
} else {
/* clean up the unused descriptors */
cache_free_descriptor(partitions[i]);
}
}
free(partitions);
if (partition == NULL) {
*errp = ENODEV;
}
return (partition);
}
/* ARGSUSED */
descriptor_t **
partition_get_descriptors(int filter[], int *errp)
{
return (cache_get_descriptors(DM_PARTITION, errp));
}
char *
partition_get_name(descriptor_t *desc)
{
return (desc->name);
}
/* ARGSUSED */
nvlist_t *
partition_get_stats(descriptor_t *dp, int stat_type, int *errp)
{
/* There are no stat types defined for partitions */
*errp = EINVAL;
return (NULL);
}
/* ARGSUSED */
int
partition_has_fdisk(disk_t *dp, int fd)
{
char bootsect[512 * 3]; /* 3 sectors to be safe */
#ifdef sparc
if (dp->drv_type == DM_DT_FIXED) {
/* on sparc, only removable media can have fdisk parts. */
return (0);
}
#endif
/*
* We assume the caller already made sure media was inserted and
* spun up.
*/
if ((ioctl(fd, DKIOCGMBOOT, bootsect) < 0) && (errno != ENOTTY)) {
return (0);
}
return (1);
}
/*
* partition_make_descriptors
*
* A partition descriptor points to a disk, the name is the partition number
* and the secondary name is the media name. The iparts parameter returned
* by the get_parts function contains the structures of all of the identified
* partitions found on each disk on a system. These are processed into an array
* of descriptors. A descriptor contains all of the information about a
* specific partition.
*
* Parameters: none
*
* Returns: 0 on success
* Error value on failure
*
*/
int
partition_make_descriptors()
{
int error;
disk_t *dp;
dp = cache_get_disklist();
while (dp != NULL) {
struct ipart iparts[TOTAL_NUMPART];
char pname[MAXPATHLEN];
if (get_parts(dp, iparts, pname, sizeof (pname)) == 0) {
int i;
char mname[MAXPATHLEN];
int conv_flag = 0;
#if defined(i386) || defined(__amd64)
/* convert part. name (e.g. c0d0p1) */
int len;
len = strlen(pname);
if (len > 1 && *(pname + (len - 2)) == 'p') {
conv_flag = 1;
*(pname + (len - 1)) = 0;
}
#endif
mname[0] = 0;
(void) media_read_name(dp, mname, sizeof (mname));
/*
* Process the descriptors and modify the cxdxpx
* format so that it refers to the fdisk partition
* number and not to the physical disk. This is
* achieved by i+1, where i is the number of the
* physical disk partition.
*/
for (i = 0; i < TOTAL_NUMPART; i++) {
if (iparts[i].systid != UNUSED) {
char part_name[MAXPATHLEN];
if (conv_flag) {
/*
* convert partition name
* (e.g. c0d0p1)
*/
(void) snprintf(part_name,
sizeof (part_name),
"%s%d", pname, i+1);
} else {
(void) snprintf(part_name,
sizeof (part_name),
"%d", i+1);
}
cache_load_desc(DM_PARTITION, dp,
part_name, mname, &error);
if (error != 0) {
return (error);
}
}
}
}
dp = dp->next;
}
return (0);
}
static int
get_attrs(descriptor_t *dp, struct ipart *iparts, nvlist_t *attrs)
{
char *p;
int part_num;
/*
* We already made sure the media was loaded and ready in the
* get_parts call within partition_get_attributes.
*/
p = strrchr(dp->name, 'p');
if (p == NULL) {
p = dp->name;
} else {
p++;
}
part_num = atoi(p);
if (part_num > TOTAL_NUMPART ||
iparts[part_num - 1].systid == UNUSED) {
return (ENODEV);
}
/*
* A partition has been found. Determine what type of
* partition it is: logical, extended, or primary.
* Collect the information for the partition.
*/
#if defined(i386) || defined(__amd64)
if (part_num > FD_NUMPART) {
if (nvlist_add_uint32(attrs, DM_PARTITION_TYPE,
DM_LOGICAL) != 0) {
return (ENOMEM);
}
} else if (fdisk_is_dos_extended(iparts[part_num - 1].systid)) {
if (nvlist_add_uint32(attrs, DM_PARTITION_TYPE,
DM_EXTENDED) != 0) {
return (ENOMEM);
}
} else {
if (nvlist_add_uint32(attrs, DM_PARTITION_TYPE,
DM_PRIMARY) != 0) {
return (ENOMEM);
}
}
#endif
#ifdef sparc
if (nvlist_add_uint32(attrs, DM_PARTITION_TYPE,
DM_PRIMARY) != 0) {
return (ENOMEM);
}
#endif
if (nvlist_add_uint32(attrs, DM_BOOTID,
(unsigned int)iparts[part_num - 1].bootid) != 0) {
return (ENOMEM);
}
if (nvlist_add_uint32(attrs, DM_PTYPE,
(unsigned int)iparts[part_num - 1].systid) != 0) {
return (ENOMEM);
}
if (nvlist_add_uint32(attrs, DM_BHEAD,
(unsigned int)iparts[part_num - 1].beghead) != 0) {
return (ENOMEM);
}
if (nvlist_add_uint32(attrs, DM_BSECT,
(unsigned int)((iparts[part_num - 1].begsect) & 0x3f)) != 0) {
return (ENOMEM);
}
if (nvlist_add_uint32(attrs, DM_BCYL, (unsigned int)
((iparts[part_num - 1].begcyl & 0xff) |
((iparts[part_num - 1].begsect & 0xc0) << 2))) != 0) {
return (ENOMEM);
}
if (nvlist_add_uint32(attrs, DM_EHEAD,
(unsigned int)iparts[part_num - 1].endhead) != 0) {
return (ENOMEM);
}
if (nvlist_add_uint32(attrs, DM_ESECT,
(unsigned int)((iparts[part_num - 1].endsect) & 0x3f)) != 0) {
return (ENOMEM);
}
if (nvlist_add_uint32(attrs, DM_ECYL, (unsigned int)
((iparts[part_num - 1].endcyl & 0xff) |
((iparts[part_num - 1].endsect & 0xc0) << 2))) != 0) {
return (ENOMEM);
}
if (nvlist_add_uint32(attrs, DM_RELSECT,
(unsigned int)iparts[part_num - 1].relsect) != 0) {
return (ENOMEM);
}
if (nvlist_add_uint32(attrs, DM_NSECTORS,
(unsigned int)iparts[part_num - 1].numsect) != 0) {
return (ENOMEM);
}
return (0);
}
/*
* get_parts
* Discovers the primary, extended, and logical partitions that have
* been created on a disk. get_parts loops through the partitions,
* collects the information on each partition and stores it in a
* partition table.
*
* Parameters;
* disk -The disk device to be evaluated for partitions
* iparts -The structure that holds information about
* the partitions
* opath -The device path
* opath_len -Buffer size used with opath
* Returns:
* 0 on Successful completion
* Error Value on failure
*
*/
static int
get_parts(disk_t *disk, struct ipart *iparts, char *opath, int opath_len)
{
int fd;
struct dk_minfo minfo;
struct mboot bootblk;
char bootsect[512];
int i;
#if defined(i386) || defined(__amd64)
int j, ret;
ext_part_t *epp; /* extended partition structure */
char *device; /* name of fixed disk drive */
size_t len;
logical_drive_t *log_drv; /* logical drive structure */
uint64_t tmpsect;
#endif
/* Can't use drive_open_disk since we need the partition dev name. */
if ((fd = open_disk(disk, opath, opath_len)) < 0) {
return (ENODEV);
}
/* First make sure media is inserted and spun up. */
if (!media_read_info(fd, &minfo)) {
(void) close(fd);
return (ENODEV);
}
if (!partition_has_fdisk(disk, fd)) {
(void) close(fd);
return (ENOTTY);
}
if (lseek(fd, 0, 0) == -1) {
(void) close(fd);
return (ENODEV);
}
if (read(fd, bootsect, 512) != 512) {
(void) close(fd);
return (ENODEV);
}
(void) close(fd);
(void) memcpy(&bootblk, bootsect, sizeof (bootblk));
if (les(bootblk.signature) != MBB_MAGIC) {
return (ENOTTY);
}
/*
* Initialize the memory space to clear unknown garbage
* that might create confusing results.
*/
for (i = 0; i < TOTAL_NUMPART; i++) {
(void) memset(&iparts[i], 0, sizeof (struct ipart));
iparts[i].systid = UNUSED;
}
(void) memcpy(iparts, bootblk.parts, ISIZE);
/*
* Check to see if a valid partition exists. If a valid partition
* exists, check to see if it is an extended partition.
* If an extended partition exists, collect the logical partition
* data.
*/
for (i = 0; i < FD_NUMPART; i++) {
if (iparts[i].systid == UNUSED)
continue;
iparts[i].relsect = lel(iparts[i].relsect);
iparts[i].numsect = lel(iparts[i].numsect);
#if defined(i386) || defined(__amd64)
if (!fdisk_is_dos_extended(iparts[i].systid))
continue;
len = strlen(disk->aliases->alias) + 1;
if ((device = malloc(len)) == NULL) {
if (device)
free(device);
continue;
}
(void) snprintf(device, len, "%s", disk->aliases->alias);
if ((ret = libfdisk_init(&epp, device, &iparts[i],
FDISK_READ_DISK)) != FDISK_SUCCESS) {
switch (ret) {
/*
* The first 2 error cases indicate that
* there is no Solaris logical partition,
* which is a valid condition,
* so iterating through the disk continues.
* Any other error cases indicate there is
* a potential problem with the disk, so
* don't continue iterating through the disk
* and return an error.
*/
case FDISK_EBADLOGDRIVE:
case FDISK_ENOLOGDRIVE:
free(device);
libfdisk_fini(&epp);
continue;
case FDISK_EBADMAGIC:
free(device);
libfdisk_fini(&epp);
return (ENOTTY);
default:
free(device);
libfdisk_fini(&epp);
return (ENODEV);
}
}
/*
* Collect logical drive information
*/
for (log_drv = fdisk_get_ld_head(epp), j = FD_NUMPART,
tmpsect = 0; (j < TOTAL_NUMPART) && (log_drv != NULL);
log_drv = log_drv->next, j++) {
iparts[j].bootid = log_drv->parts[0].bootid;
iparts[j].beghead = log_drv->parts[0].beghead;
iparts[j].begsect = log_drv->parts[0].begsect;
iparts[j].begcyl = log_drv->parts[0].begcyl;
iparts[j].systid = log_drv->parts[0].systid;
iparts[j].endhead = log_drv->parts[0].endhead;
iparts[j].endsect = log_drv->parts[0].endsect;
iparts[j].endcyl = log_drv->parts[0].endcyl;
iparts[j].relsect = (tmpsect +
lel(log_drv->parts[0].relsect) + epp->ext_beg_sec);
iparts[j].numsect = lel(log_drv->parts[0].numsect);
tmpsect = lel(log_drv->parts[1].relsect);
}
/* free the device and the epp memory. */
free(device);
libfdisk_fini(&epp);
#endif
}
return (0);
}
/* return 1 if the partition descriptor is still valid, 0 if not. */
static int
desc_ok(descriptor_t *dp)
{
/* First verify the media name for removable media */
if (dp->p.disk->removable) {
char mname[MAXPATHLEN];
if (!media_read_name(dp->p.disk, mname, sizeof (mname))) {
return (0);
}
if (mname[0] == 0) {
return (libdiskmgt_str_eq(dp->secondary_name, NULL));
} else {
return (libdiskmgt_str_eq(dp->secondary_name, mname));
}
}
/*
* We could verify the partition is still there but this is kind of
* expensive and other code down the line will do that (e.g. see
* get_attrs).
*/
return (1);
}
/*
* Return 1 if partition has slices, 0 if not.
*/
static int
has_slices(descriptor_t *desc, int *errp)
{
int pnum;
int i;
char *p;
struct ipart iparts[TOTAL_NUMPART];
if (get_parts(desc->p.disk, iparts, NULL, 0) != 0) {
*errp = ENODEV;
return (0);
}
p = strrchr(desc->name, 'p');
if (p == NULL) {
p = desc->name;
} else {
p++;
}
pnum = atoi(p);
/*
* Slices are associated with the active solaris partition or if there
* is no active solaris partition, then the first solaris partition.
*/
*errp = 0;
if (iparts[pnum].bootid == ACTIVE &&
(iparts[pnum].systid == SUNIXOS ||
iparts[pnum].systid == SUNIXOS2)) {
return (1);
} else {
int active = 0;
/* Check if there are no active solaris partitions. */
for (i = 0; i < TOTAL_NUMPART; i++) {
if (iparts[i].bootid == ACTIVE &&
(iparts[i].systid == SUNIXOS ||
iparts[i].systid == SUNIXOS2)) {
active = 1;
break;
}
}
if (!active) {
/* Check if this is the first solaris partition. */
for (i = 0; i < TOTAL_NUMPART; i++) {
if (iparts[i].systid == SUNIXOS ||
iparts[i].systid == SUNIXOS2) {
break;
}
}
if (i < TOTAL_NUMPART && i == pnum) {
return (1);
}
}
}
return (0);
}
static int
open_disk(disk_t *diskp, char *opath, int len)
{
/*
* Just open the first devpath.
*/
if (diskp->aliases != NULL && diskp->aliases->devpaths != NULL) {
#ifdef sparc
if (opath != NULL) {
(void) strlcpy(opath, diskp->aliases->devpaths->devpath, len);
}
return (open(diskp->aliases->devpaths->devpath, O_RDONLY|O_NDELAY));
#else
/* On intel we need to open partition device (e.g. c0d0p1). */
char part_dev[MAXPATHLEN];
char *p;
(void) strlcpy(part_dev, diskp->aliases->devpaths->devpath,
sizeof (part_dev));
p = strrchr(part_dev, '/');
if (p == NULL) {
p = strrchr(part_dev, 's');
if (p != NULL) {
*p = 'p';
}
} else {
char *ps;
*p = 0;
ps = strrchr((p + 1), 's');
if (ps != NULL) {
*ps = 'p';
}
*p = '/';
}
if (opath != NULL) {
(void) strlcpy(opath, part_dev, len);
}
return (open(part_dev, O_RDONLY|O_NDELAY));
#endif
}
return (-1);
}