usr/src/lib/libdiskmgt/common/slice.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 /*
  28  * Copyright 2017 Nexenta Systems, Inc.
  29  */
  30
  31 #include <fcntl.h>
  32 #include <libdevinfo.h>
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35 #include <string.h>
  36 #include <dirent.h>
  37 #include <sys/dkio.h>
  38 #include <sys/stat.h>
  39 #include <sys/sunddi.h>
  40 #include <sys/types.h>
  41 #include <sys/vtoc.h>
  42 #include <unistd.h>
  43 #include <devid.h>
  44 #include <dirent.h>
  45 #include <sys/dktp/fdisk.h>
  46 #include <sys/efi_partition.h>
  47
  48 #include "libdiskmgt.h"
  49 #include "disks_private.h"
  50 #include "partition.h"
  51 #ifndef VT_ENOTSUP
  52 #define VT_ENOTSUP      (-5)
  53 #endif
  54
  55 #define FMT_UNKNOWN     0
  56 #define FMT_VTOC        1
  57 #define FMT_EFI         2
  58
  59 typedef int (*detectorp)(char *, nvlist_t *, int *);
  60
  61 static detectorp detectors[] = {
  62         inuse_mnt,
  63         inuse_active_zpool,
  64         inuse_lu,
  65         inuse_dump,
  66         inuse_vxvm,
  67         inuse_exported_zpool,
  68         inuse_fs,  /* fs should always be last */
  69         NULL
  70 };
  71
  72 static int      add_inuse(char *name, nvlist_t *attrs);
  73 static int      desc_ok(descriptor_t *dp);
  74 static void     dsk2rdsk(char *dsk, char *rdsk, int size);
  75 static int      get_attrs(descriptor_t *dp, int fd,  nvlist_t *attrs);
  76 static descriptor_t **get_fixed_assocs(descriptor_t *desc, int *errp);
  77 static int      get_slice_num(slice_t *devp);
  78 static int      match_fixed_name(disk_t *dp, char *name, int *errp);
  79 static int      make_fixed_descriptors(disk_t *dp);
  80
  81 descriptor_t **
  82 slice_get_assoc_descriptors(descriptor_t *desc, dm_desc_type_t type,
  83     int *errp)
  84 {
  85         if (!desc_ok(desc)) {
  86                 *errp = ENODEV;
  87                 return (NULL);
  88         }
  89
  90         switch (type) {
  91         case DM_MEDIA:
  92                 return (media_get_assocs(desc, errp));
  93         case DM_PARTITION:
  94                 return (partition_get_assocs(desc, errp));
  95         }
  96
  97         *errp = EINVAL;
  98         return (NULL);
  99 }
 100
 101 /*
 102  * This is called by media/partition to get the slice descriptors for the given
 103  * media/partition descriptor.
 104  * For media, just get the slices, but for a partition, it must be a solaris
 105  * partition and if there are active partitions, it must be the active one.
 106  */
 107 descriptor_t **
 108 slice_get_assocs(descriptor_t *desc, int *errp)
 109 {
 110         /* Just check the first drive name. */
 111         if (desc->p.disk->aliases == NULL) {
 112                 *errp = 0;
 113                 return (libdiskmgt_empty_desc_array(errp));
 114         }
 115
 116         return (get_fixed_assocs(desc, errp));
 117 }
 118
 119 nvlist_t *
 120 slice_get_attributes(descriptor_t *dp, int *errp)
 121 {
 122         nvlist_t        *attrs = NULL;
 123         int             fd;
 124         char            devpath[MAXPATHLEN];
 125
 126         if (!desc_ok(dp)) {
 127                 *errp = ENODEV;
 128                 return (NULL);
 129         }
 130
 131         if (nvlist_alloc(&attrs, NVATTRS, 0) != 0) {
 132                 *errp = ENOMEM;
 133                 return (NULL);
 134         }
 135
 136         /* dp->name is /dev/dsk, need to convert back to /dev/rdsk */
 137         dsk2rdsk(dp->name, devpath, sizeof (devpath));
 138         fd = open(devpath, O_RDONLY|O_NDELAY);
 139
 140         if ((*errp = get_attrs(dp, fd, attrs)) != 0) {
 141                 nvlist_free(attrs);
 142                 attrs = NULL;
 143         }
 144
 145         if (fd >= 0) {
 146                 (void) close(fd);
 147         }
 148
 149         return (attrs);
 150 }
 151
 152 /*
 153  * Look for the slice by the slice devpath.
 154  */
 155 descriptor_t *
 156 slice_get_descriptor_by_name(char *name, int *errp)
 157 {
 158         int             found = 0;
 159         disk_t          *dp;
 160
 161         for (dp = cache_get_disklist(); dp != NULL; dp = dp->next) {
 162                 found = match_fixed_name(dp, name, errp);
 163
 164                 if (found) {
 165                         char    mname[MAXPATHLEN];
 166
 167                         if (*errp != 0) {
 168                                 return (NULL);
 169                         }
 170
 171                         mname[0] = 0;
 172                         (void) media_read_name(dp, mname, sizeof (mname));
 173
 174                         return (cache_get_desc(DM_SLICE, dp, name, mname,
 175                             errp));
 176                 }
 177         }
 178
 179         *errp = ENODEV;
 180         return (NULL);
 181 }
 182
 183 /* ARGSUSED */
 184 descriptor_t **
 185 slice_get_descriptors(int filter[], int *errp)
 186 {
 187         return (cache_get_descriptors(DM_SLICE, errp));
 188 }
 189
 190 char *
 191 slice_get_name(descriptor_t *desc)
 192 {
 193         return (desc->name);
 194 }
 195
 196 nvlist_t *
 197 slice_get_stats(descriptor_t *dp, int stat_type, int *errp)
 198 {
 199         nvlist_t        *stats;
 200
 201         if (stat_type != DM_SLICE_STAT_USE) {
 202                 *errp = EINVAL;
 203                 return (NULL);
 204         }
 205
 206         *errp = 0;
 207
 208         if (nvlist_alloc(&stats, NVATTRS_STAT, 0) != 0) {
 209                 *errp = ENOMEM;
 210                 return (NULL);
 211         }
 212
 213         if ((*errp = add_inuse(dp->name, stats)) != 0) {
 214                 nvlist_free(stats);
 215                 return (NULL);
 216         }
 217
 218         return (stats);
 219 }
 220
 221 /*
 222  * A slice descriptor points to a disk, the name is the devpath and the
 223  * secondary name is the media name.
 224  */
 225 int
 226 slice_make_descriptors()
 227 {
 228         disk_t          *dp;
 229
 230         dp = cache_get_disklist();
 231         while (dp != NULL) {
 232                 int     error;
 233
 234                 error = make_fixed_descriptors(dp);
 235                 if (error != 0) {
 236                         return (error);
 237                 }
 238
 239                 dp = dp->next;
 240         }
 241
 242         return (0);
 243 }
 244
 245 /* convert rdsk paths to dsk paths */
 246 void
 247 slice_rdsk2dsk(char *rdsk, char *dsk, int size)
 248 {
 249         char    *strp;
 250
 251         (void) strlcpy(dsk, rdsk, size);
 252
 253         if ((strp = strstr(dsk, "/rdsk/")) == NULL) {
 254                 /* not rdsk, check for floppy */
 255                 strp = strstr(dsk, "/rdiskette");
 256         }
 257
 258         if (strp != NULL) {
 259                 strp++; /* move ptr to the r in rdsk or rdiskette */
 260
 261                 /* move the succeeding chars over by one */
 262                 do {
 263                         *strp = *(strp + 1);
 264                         strp++;
 265                 } while (*strp);
 266         }
 267 }
 268
 269 /*
 270  * Check if/how the slice is used.
 271  */
 272 static int
 273 add_inuse(char *name, nvlist_t *attrs)
 274 {
 275         int     i;
 276         int     error;
 277
 278         for (i = 0; detectors[i] != NULL; i ++) {
 279                 if (detectors[i](name, attrs, &error) || error != 0) {
 280                         if (error != 0) {
 281                                 return (error);
 282                         }
 283                         break;
 284                 }
 285         }
 286
 287         return (0);
 288 }
 289
 290 /* return 1 if the slice descriptor is still valid, 0 if not. */
 291 static int
 292 desc_ok(descriptor_t *dp)
 293 {
 294         /* First verify the media name for removable media */
 295         if (dp->p.disk->removable) {
 296                 char    mname[MAXPATHLEN];
 297
 298                 if (!media_read_name(dp->p.disk, mname, sizeof (mname))) {
 299                         return (0);
 300                 }
 301
 302                 if (mname[0] == 0) {
 303                         return (libdiskmgt_str_eq(dp->secondary_name, NULL));
 304                 } else {
 305                         return (libdiskmgt_str_eq(dp->secondary_name, mname));
 306                 }
 307         }
 308
 309         /*
 310          * We could verify the slice is still there, but other code down the
 311          * line already does these checks (e.g. see get_attrs).
 312          */
 313
 314         return (1);
 315 }
 316
 317 /* convert dsk paths to rdsk paths */
 318 static void
 319 dsk2rdsk(char *dsk, char *rdsk, int size)
 320 {
 321         char    *slashp;
 322         size_t  len;
 323
 324         (void) strlcpy(rdsk, dsk, size);
 325
 326         /* make sure there is enough room to add the r to dsk */
 327         len = strlen(dsk);
 328         if (len + 2 > size) {
 329                 return;
 330         }
 331
 332         if ((slashp = strstr(rdsk, "/dsk/")) == NULL) {
 333                 /* not dsk, check for floppy */
 334                 slashp = strstr(rdsk, "/diskette");
 335         }
 336
 337         if (slashp != NULL) {
 338                 char    *endp;
 339
 340                 endp = rdsk + len;      /* point to terminating 0 */
 341                 /* move the succeeding chars over by one */
 342                 do {
 343                         *(endp + 1) = *endp;
 344                         endp--;
 345                 } while (endp != slashp);
 346
 347                 *(endp + 1) = 'r';
 348         }
 349 }
 350
 351 static int
 352 get_attrs(descriptor_t *dp, int fd,  nvlist_t *attrs)
 353 {
 354         struct dk_minfo minfo;
 355         int             status;
 356         int             data_format = FMT_UNKNOWN;
 357         int             snum = -1;
 358         int             error;
 359         struct extvtoc  vtoc;
 360         struct dk_gpt   *efip;
 361         struct dk_cinfo dkinfo;
 362         int             cooked_fd;
 363         struct stat     buf;
 364
 365         if (fd < 0) {
 366                 return (ENODEV);
 367         }
 368
 369         /* First make sure media is inserted and spun up. */
 370         if (!media_read_info(fd, &minfo)) {
 371                 return (ENODEV);
 372         }
 373
 374         if ((status = read_extvtoc(fd, &vtoc)) >= 0) {
 375                 data_format = FMT_VTOC;
 376         } else if (status == VT_ENOTSUP && efi_alloc_and_read(fd, &efip) >= 0) {
 377                 data_format = FMT_EFI;
 378                 if (nvlist_add_boolean(attrs, DM_EFI) != 0) {
 379                         efi_free(efip);
 380                         return (ENOMEM);
 381                 }
 382         }
 383
 384         if (data_format == FMT_UNKNOWN) {
 385                 return (ENODEV);
 386         }
 387
 388         if (ioctl(fd, DKIOCINFO, &dkinfo) >= 0) {
 389                 snum = dkinfo.dki_partition;
 390         }
 391
 392         /* check the slice */
 393         if (data_format == FMT_VTOC) {
 394                 if (snum < 0 || snum >= vtoc.v_nparts ||
 395                     vtoc.v_part[snum].p_size == 0) {
 396                         return (ENODEV);
 397                 }
 398         } else { /* data_format == FMT_EFI */
 399                 if (snum < 0 || snum >= efip->efi_nparts ||
 400                     efip->efi_parts[snum].p_size == 0) {
 401                         efi_free(efip);
 402                         return (ENODEV);
 403                 }
 404         }
 405
 406         /* the slice exists */
 407
 408         if (nvlist_add_uint32(attrs, DM_INDEX, snum) != 0) {
 409                 if (data_format == FMT_EFI) {
 410                         efi_free(efip);
 411                 }
 412                 return (ENOMEM);
 413         }
 414
 415         if (data_format == FMT_VTOC) {
 416                 if (nvlist_add_uint64(attrs, DM_START,
 417                     vtoc.v_part[snum].p_start) != 0) {
 418                         return (ENOMEM);
 419                 }
 420
 421                 if (nvlist_add_uint64(attrs, DM_SIZE,
 422                     vtoc.v_part[snum].p_size) != 0) {
 423                         return (ENOMEM);
 424                 }
 425
 426                 if (nvlist_add_uint32(attrs, DM_TAG,
 427                     vtoc.v_part[snum].p_tag) != 0) {
 428                         return (ENOMEM);
 429                 }
 430
 431                 if (nvlist_add_uint32(attrs, DM_FLAG,
 432                     vtoc.v_part[snum].p_flag) != 0) {
 433                         return (ENOMEM);
 434                 }
 435         } else { /* data_format == FMT_EFI */
 436                 if (nvlist_add_uint64(attrs, DM_START,
 437                     efip->efi_parts[snum].p_start) != 0) {
 438                         efi_free(efip);
 439                         return (ENOMEM);
 440                 }
 441
 442                 if (nvlist_add_uint64(attrs, DM_SIZE,
 443                     efip->efi_parts[snum].p_size) != 0) {
 444                         efi_free(efip);
 445                         return (ENOMEM);
 446                 }
 447
 448                 if (efip->efi_parts[snum].p_name[0] != 0) {
 449                         char    label[EFI_PART_NAME_LEN + 1];
 450
 451                         (void) snprintf(label, sizeof (label), "%.*s",
 452                             EFI_PART_NAME_LEN, efip->efi_parts[snum].p_name);
 453                         if (nvlist_add_string(attrs, DM_EFI_NAME, label) != 0) {
 454                                 efi_free(efip);
 455                                 return (ENOMEM);
 456                         }
 457                 }
 458         }
 459
 460         if (data_format == FMT_EFI) {
 461                 efi_free(efip);
 462         }
 463
 464         if (inuse_mnt(dp->name, attrs, &error)) {
 465                 if (error != 0)
 466                         return (error);
 467         }
 468
 469         if (fstat(fd, &buf) != -1) {
 470                 if (nvlist_add_uint64(attrs, DM_DEVT, buf.st_rdev) != 0) {
 471                         return (ENOMEM);
 472                 }
 473         }
 474
 475         /*
 476          * We need to open the cooked slice (not the raw one) to get the
 477          * correct devid.
 478          */
 479         cooked_fd = open(dp->name, O_RDONLY|O_NDELAY);
 480
 481         if (cooked_fd >= 0) {
 482                 int             no_mem = 0;
 483                 ddi_devid_t     devid;
 484
 485                 if (devid_get(cooked_fd, &devid) == 0) {
 486                         char    *minor;
 487
 488                         if (devid_get_minor_name(cooked_fd, &minor) == 0) {
 489                                 char    *devidstr;
 490
 491                                 devidstr = devid_str_encode(devid, minor);
 492                                 if (devidstr != NULL) {
 493
 494                                         if (nvlist_add_string(attrs,
 495                                             DM_DEVICEID, devidstr) != 0) {
 496                                                 no_mem = 1;
 497                                         }
 498
 499                                         devid_str_free(devidstr);
 500                                 }
 501                                 devid_str_free(minor);
 502                         }
 503                         devid_free(devid);
 504                 }
 505                 (void) close(cooked_fd);
 506
 507                 if (no_mem) {
 508                         return (ENOMEM);
 509                 }
 510         }
 511
 512         return (0);
 513 }
 514
 515 static descriptor_t **
 516 get_fixed_assocs(descriptor_t *desc, int *errp)
 517 {
 518         int             fd;
 519         int             status;
 520         int             data_format = FMT_UNKNOWN;
 521         int             cnt;
 522         struct extvtoc  vtoc;
 523         struct dk_gpt   *efip;
 524         int             pos;
 525         char            *media_name = NULL;
 526         slice_t         *devp;
 527         descriptor_t    **slices;
 528
 529         if ((fd = drive_open_disk(desc->p.disk, NULL, 0)) < 0) {
 530                 *errp = ENODEV;
 531                 return (NULL);
 532         }
 533
 534         if ((status = read_extvtoc(fd, &vtoc)) >= 0) {
 535                 data_format = FMT_VTOC;
 536         } else if (status == VT_ENOTSUP && efi_alloc_and_read(fd, &efip) >= 0) {
 537                 data_format = FMT_EFI;
 538         } else {
 539                 (void) close(fd);
 540                 *errp = 0;
 541                 return (libdiskmgt_empty_desc_array(errp));
 542         }
 543         (void) close(fd);
 544
 545         /* count the number of slices */
 546         devp = desc->p.disk->aliases->devpaths;
 547         for (cnt = 0; devp != NULL; devp = devp->next)
 548                 cnt++;
 549
 550         /* allocate the array for the descriptors */
 551         slices = (descriptor_t **)calloc(cnt + 1, sizeof (descriptor_t *));
 552         if (slices == NULL) {
 553                 if (data_format == FMT_EFI) {
 554                         efi_free(efip);
 555                 }
 556                 *errp = ENOMEM;
 557                 return (NULL);
 558         }
 559
 560         /* get the media name from the descriptor */
 561         if (desc->type == DM_MEDIA) {
 562                 media_name = desc->name;
 563         } else {
 564                 /* must be a DM_PARTITION */
 565                 media_name = desc->secondary_name;
 566         }
 567
 568         pos = 0;
 569         for (devp = desc->p.disk->aliases->devpaths; devp != NULL;
 570             devp = devp->next) {
 571
 572                 int             slice_num;
 573                 char    devpath[MAXPATHLEN];
 574
 575                 slice_num = get_slice_num(devp);
 576                 /* can't get slicenum, so no need to keep trying the drive */
 577                 if (slice_num == -1) {
 578                         break;
 579                 }
 580
 581                 if (data_format == FMT_VTOC) {
 582                         if (slice_num >= vtoc.v_nparts ||
 583                             vtoc.v_part[slice_num].p_size == 0) {
 584                                 continue;
 585                         }
 586                 } else { /* data_format == FMT_EFI */
 587                         if (slice_num >= efip->efi_nparts ||
 588                             efip->efi_parts[slice_num].p_size == 0) {
 589                                 continue;
 590                         }
 591                 }
 592
 593                 slice_rdsk2dsk(devp->devpath, devpath, sizeof (devpath));
 594                 slices[pos] = cache_get_desc(DM_SLICE, desc->p.disk, devpath,
 595                     media_name, errp);
 596                 if (*errp != 0) {
 597                         cache_free_descriptors(slices);
 598                         if (data_format == FMT_EFI) {
 599                                 efi_free(efip);
 600                         }
 601                         return (NULL);
 602                 }
 603                 pos++;
 604         }
 605         slices[pos] = NULL;
 606
 607         if (data_format == FMT_EFI) {
 608                 efi_free(efip);
 609         }
 610
 611         *errp = 0;
 612         return (slices);
 613 }
 614
 615 static int
 616 get_slice_num(slice_t *devp)
 617 {
 618         /* check if we already determined the devpath slice number */
 619         if (devp->slice_num == -1) {
 620                 int             fd;
 621
 622                 if ((fd = open(devp->devpath, O_RDONLY|O_NDELAY)) >= 0) {
 623                         struct dk_cinfo dkinfo;
 624                         if (ioctl(fd, DKIOCINFO, &dkinfo) >= 0) {
 625                                 devp->slice_num = dkinfo.dki_partition;
 626                         }
 627                         (void) close(fd);
 628                 }
 629         }
 630
 631         return (devp->slice_num);
 632 }
 633
 634 static int
 635 make_fixed_descriptors(disk_t *dp)
 636 {
 637         int             error = 0;
 638         alias_t         *ap;
 639         slice_t         *devp;
 640         char            mname[MAXPATHLEN];
 641         int             data_format = FMT_UNKNOWN;
 642         struct extvtoc  vtoc;
 643         struct dk_gpt   *efip;
 644
 645         /* Just check the first drive name. */
 646         if ((ap = dp->aliases) == NULL) {
 647                 return (0);
 648         }
 649
 650         mname[0] = 0;
 651         (void) media_read_name(dp, mname, sizeof (mname));
 652
 653         for (devp = ap->devpaths; devp != NULL; devp = devp->next) {
 654                 int             slice_num;
 655                 char    devpath[MAXPATHLEN];
 656
 657                 slice_num = get_slice_num(devp);
 658                 /* can't get slicenum, so no need to keep trying the drive */
 659                 if (slice_num == -1) {
 660                         break;
 661                 }
 662
 663                 if (data_format == FMT_UNKNOWN) {
 664                         int     fd;
 665                         int     status;
 666
 667                         if ((fd = drive_open_disk(dp, NULL, 0)) >= 0) {
 668                                 if ((status = read_extvtoc(fd, &vtoc)) >= 0) {
 669                                         data_format = FMT_VTOC;
 670                                 } else if (status == VT_ENOTSUP &&
 671                                     efi_alloc_and_read(fd, &efip) >= 0) {
 672                                         data_format = FMT_EFI;
 673                                 }
 674                                 (void) close(fd);
 675                         }
 676                 }
 677
 678                 /* can't get slice data, so no need to keep trying the drive */
 679                 if (data_format == FMT_UNKNOWN) {
 680                         break;
 681                 }
 682
 683                 if (data_format == FMT_VTOC) {
 684                         if (slice_num >= vtoc.v_nparts ||
 685                             vtoc.v_part[slice_num].p_size == 0) {
 686                                 continue;
 687                         }
 688                 } else { /* data_format == FMT_EFI */
 689                         if (slice_num >= efip->efi_nparts ||
 690                             efip->efi_parts[slice_num].p_size == 0) {
 691                                 continue;
 692                         }
 693                 }
 694
 695                 slice_rdsk2dsk(devp->devpath, devpath, sizeof (devpath));
 696                 cache_load_desc(DM_SLICE, dp, devpath, mname, &error);
 697                 if (error != 0) {
 698                         break;
 699                 }
 700         }
 701
 702         if (data_format == FMT_EFI) {
 703                 efi_free(efip);
 704         }
 705
 706         return (error);
 707 }
 708
 709 /*
 710  * Just look for the name on the devpaths we have cached. Return 1 if we
 711  * find the name and the size of that slice is non-zero.
 712  */
 713 static int
 714 match_fixed_name(disk_t *diskp, char *name, int *errp)
 715 {
 716         slice_t         *dp = NULL;
 717         alias_t         *ap;
 718         int             slice_num;
 719         int             fd;
 720         int             status;
 721         int             data_format = FMT_UNKNOWN;
 722         struct extvtoc  vtoc;
 723         struct dk_gpt   *efip;
 724
 725         ap = diskp->aliases;
 726         while (ap != NULL) {
 727                 slice_t *devp;
 728
 729                 devp = ap->devpaths;
 730                 while (devp != NULL) {
 731                         char    path[MAXPATHLEN];
 732
 733                         slice_rdsk2dsk(devp->devpath, path, sizeof (path));
 734                         if (libdiskmgt_str_eq(path, name)) {
 735                                 /* found it */
 736                                 dp = devp;
 737                                 break;
 738                         }
 739
 740                         devp = devp->next;
 741                 }
 742
 743                 if (dp != NULL) {
 744                         break;
 745                 }
 746
 747                 ap = ap->next;
 748         }
 749
 750         if (dp == NULL) {
 751                 *errp = 0;
 752                 return (0);
 753         }
 754
 755         /*
 756          * If we found a match on the name we now have to check that this
 757          * slice really exists (non-0 size).
 758          */
 759
 760         slice_num = get_slice_num(dp);
 761         /* can't get slicenum, so no slice */
 762         if (slice_num == -1) {
 763                 *errp = ENODEV;
 764                 return (1);
 765         }
 766
 767         if ((fd = drive_open_disk(diskp, NULL, 0)) < 0) {
 768                 *errp = ENODEV;
 769                 return (1);
 770         }
 771
 772         if ((status = read_extvtoc(fd, &vtoc)) >= 0) {
 773                 data_format = FMT_VTOC;
 774         } else if (status == VT_ENOTSUP) {
 775                 status = efi_alloc_and_read(fd, &efip);
 776                 if (status >= 0) {
 777                         data_format = FMT_EFI;
 778                 } else if (status == VT_ERROR && errno == ENOTTY) {
 779                         *errp = 0;
 780                         return (1);
 781                 }
 782         } else {
 783                 (void) close(fd);
 784                 *errp = ENODEV;
 785                 return (1);
 786         }
 787         (void) close(fd);
 788
 789         if (data_format == FMT_VTOC) {
 790                 if (slice_num < vtoc.v_nparts &&
 791                     vtoc.v_part[slice_num].p_size > 0) {
 792                         *errp = 0;
 793                         return (1);
 794                 }
 795         } else { /* data_format == FMT_EFI */
 796                 if (slice_num < efip->efi_nparts &&
 797                     efip->efi_parts[slice_num].p_size > 0) {
 798                         efi_free(efip);
 799                         *errp = 0;
 800                         return (1);
 801                 }
 802                 efi_free(efip);
 803         }
 804
 805         *errp = ENODEV;
 806         return (1);
 807 }