version 1.4.2.1, 2014/08/08 20:24:27 |
version 1.4.2.2, 2014/08/10 07:00:24 |
|
|
|
/* $NetBSD$ */ |
|
|
|
/* |
|
* Copyright 1997 Piermont Information Systems Inc. |
|
* All rights reserved. |
|
* |
|
* Written by Philip A. Nelson for Piermont Information Systems Inc. |
|
* |
|
* Redistribution and use in source and binary forms, with or without |
|
* modification, are permitted provided that the following conditions |
|
* are met: |
|
* 1. Redistributions of source code must retain the above copyright |
|
* notice, this list of conditions and the following disclaimer. |
|
* 2. Redistributions in binary form must reproduce the above copyright |
|
* notice, this list of conditions and the following disclaimer in the |
|
* documentation and/or other materials provided with the distribution. |
|
* 3. The name of Piermont Information Systems Inc. may not be used to endorse |
|
* or promote products derived from this software without specific prior |
|
* written permission. |
|
* |
|
* THIS SOFTWARE IS PROVIDED BY PIERMONT INFORMATION SYSTEMS INC. ``AS IS'' |
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
|
* ARE DISCLAIMED. IN NO EVENT SHALL PIERMONT INFORMATION SYSTEMS INC. BE |
|
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF |
|
* THE POSSIBILITY OF SUCH DAMAGE. |
|
* |
|
*/ |
|
|
|
/* disks.c -- routines to deal with finding disks and labeling disks. */ |
|
|
|
|
|
#include <errno.h> |
|
#include <stdio.h> |
|
#include <stdlib.h> |
|
#include <unistd.h> |
|
#include <fcntl.h> |
|
#include <util.h> |
|
#include <uuid.h> |
|
|
|
#include <sys/param.h> |
|
#include <sys/sysctl.h> |
|
#include <sys/swap.h> |
|
#include <ufs/ufs/dinode.h> |
|
#include <ufs/ffs/fs.h> |
|
#define FSTYPENAMES |
|
#include <sys/disklabel.h> |
|
#include <sys/disklabel_gpt.h> |
|
|
|
#include <dev/scsipi/scsipi_all.h> |
|
#include <sys/scsiio.h> |
|
|
|
#include <dev/ata/atareg.h> |
|
#include <sys/ataio.h> |
|
|
|
#include "defs.h" |
|
#include "md.h" |
|
#include "msg_defs.h" |
|
#include "menu_defs.h" |
|
#include "txtwalk.h" |
|
|
|
/* Disk descriptions */ |
|
struct disk_desc { |
|
char dd_name[SSTRSIZE]; |
|
char dd_descr[70]; |
|
uint dd_no_mbr; |
|
uint dd_cyl; |
|
uint dd_head; |
|
uint dd_sec; |
|
uint dd_secsize; |
|
uint dd_totsec; |
|
}; |
|
|
|
/* gpt(8) use different filesystem names. |
|
So, we cant use ./common/lib/libutil/getfstypename.c */ |
|
struct gptfs_t { |
|
const char *name; |
|
int id; |
|
uuid_t uuid; |
|
}; |
|
static const struct gptfs_t gpt_filesystems[] = { |
|
{ "swap", FS_SWAP, GPT_ENT_TYPE_NETBSD_SWAP, }, |
|
{ "ffs", FS_BSDFFS, GPT_ENT_TYPE_NETBSD_FFS, }, |
|
{ "lfs", FS_BSDLFS, GPT_ENT_TYPE_NETBSD_LFS, }, |
|
{ "linux", FS_EX2FS, GPT_ENT_TYPE_LINUX_DATA, }, |
|
{ "windows,", FS_MSDOS, GPT_ENT_TYPE_MS_BASIC_DATA, }, |
|
{ "hfs", FS_HFS, GPT_ENT_TYPE_APPLE_HFS, }, |
|
{ "ufs", FS_OTHER, GPT_ENT_TYPE_APPLE_UFS, }, |
|
{ "ccd", FS_CCD, GPT_ENT_TYPE_NETBSD_CCD, }, |
|
{ "raid", FS_RAID, GPT_ENT_TYPE_NETBSD_RAIDFRAME, }, |
|
{ "cgd", FS_CGD, GPT_ENT_TYPE_NETBSD_CGD, }, |
|
{ "efi", FS_OTHER, GPT_ENT_TYPE_EFI, }, |
|
{ "bios", FS_OTHER, GPT_ENT_TYPE_BIOS, }, |
|
{ NULL, -1, GPT_ENT_TYPE_UNUSED, }, |
|
}; |
|
|
|
/* Local prototypes */ |
|
static int foundffs(struct data *, size_t); |
|
#ifdef USE_SYSVBFS |
|
static int foundsysvbfs(struct data *, size_t); |
|
#endif |
|
static int fsck_preen(const char *, int, const char *); |
|
static void fixsb(const char *, const char *, char); |
|
static int is_gpt(const char *); |
|
static int incoregpt(pm_devs_t *, partinfo *); |
|
|
|
#ifndef DISK_NAMES |
|
#define DISK_NAMES "wd", "sd", "ld", "raid" |
|
#endif |
|
|
|
static const char *disk_names[] = { DISK_NAMES, "vnd", "cgd", NULL }; |
|
|
|
static bool tmpfs_on_var_shm(void); |
|
|
|
const char * |
|
getfslabelname(uint8_t f) |
|
{ |
|
if (f >= __arraycount(fstypenames) || fstypenames[f] == NULL) |
|
return "invalid"; |
|
return fstypenames[f]; |
|
} |
|
|
|
/* |
|
* Decide wether we want to mount a tmpfs on /var/shm: we do this always |
|
* when the machine has more than 16 MB of user memory. On smaller machines, |
|
* shm_open() and friends will not perform well anyway. |
|
*/ |
|
static bool |
|
tmpfs_on_var_shm() |
|
{ |
|
uint64_t ram; |
|
size_t len; |
|
|
|
len = sizeof(ram); |
|
if (sysctlbyname("hw.usermem64", &ram, &len, NULL, 0)) |
|
return false; |
|
|
|
return ram > 16UL*1024UL*1024UL; |
|
} |
|
|
|
/* from src/sbin/atactl/atactl.c |
|
* extract_string: copy a block of bytes out of ataparams and make |
|
* a proper string out of it, truncating trailing spaces and preserving |
|
* strict typing. And also, not doing unaligned accesses. |
|
*/ |
|
static void |
|
ata_extract_string(char *buf, size_t bufmax, |
|
uint8_t *bytes, unsigned numbytes, |
|
int needswap) |
|
{ |
|
unsigned i; |
|
size_t j; |
|
unsigned char ch1, ch2; |
|
|
|
for (i = 0, j = 0; i < numbytes; i += 2) { |
|
ch1 = bytes[i]; |
|
ch2 = bytes[i+1]; |
|
if (needswap && j < bufmax-1) { |
|
buf[j++] = ch2; |
|
} |
|
if (j < bufmax-1) { |
|
buf[j++] = ch1; |
|
} |
|
if (!needswap && j < bufmax-1) { |
|
buf[j++] = ch2; |
|
} |
|
} |
|
while (j > 0 && buf[j-1] == ' ') { |
|
j--; |
|
} |
|
buf[j] = '\0'; |
|
} |
|
|
|
/* |
|
* from src/sbin/scsictl/scsi_subr.c |
|
*/ |
|
#define STRVIS_ISWHITE(x) ((x) == ' ' || (x) == '\0' || (x) == (u_char)'\377') |
|
|
|
static void |
|
scsi_strvis(char *sdst, size_t dlen, const char *ssrc, size_t slen) |
|
{ |
|
u_char *dst = (u_char *)sdst; |
|
const u_char *src = (const u_char *)ssrc; |
|
|
|
/* Trim leading and trailing blanks and NULs. */ |
|
while (slen > 0 && STRVIS_ISWHITE(src[0])) |
|
++src, --slen; |
|
while (slen > 0 && STRVIS_ISWHITE(src[slen - 1])) |
|
--slen; |
|
|
|
while (slen > 0) { |
|
if (*src < 0x20 || *src >= 0x80) { |
|
/* non-printable characters */ |
|
dlen -= 4; |
|
if (dlen < 1) |
|
break; |
|
*dst++ = '\\'; |
|
*dst++ = ((*src & 0300) >> 6) + '0'; |
|
*dst++ = ((*src & 0070) >> 3) + '0'; |
|
*dst++ = ((*src & 0007) >> 0) + '0'; |
|
} else if (*src == '\\') { |
|
/* quote characters */ |
|
dlen -= 2; |
|
if (dlen < 1) |
|
break; |
|
*dst++ = '\\'; |
|
*dst++ = '\\'; |
|
} else { |
|
/* normal characters */ |
|
if (--dlen < 1) |
|
break; |
|
*dst++ = *src; |
|
} |
|
++src, --slen; |
|
} |
|
|
|
*dst++ = 0; |
|
} |
|
|
|
|
|
static int |
|
get_descr_scsi(struct disk_desc *dd, int fd) |
|
{ |
|
struct scsipi_inquiry_data inqbuf; |
|
struct scsipi_inquiry cmd; |
|
scsireq_t req; |
|
/* x4 in case every character is escaped, +1 for NUL. */ |
|
char vendor[(sizeof(inqbuf.vendor) * 4) + 1], |
|
product[(sizeof(inqbuf.product) * 4) + 1], |
|
revision[(sizeof(inqbuf.revision) * 4) + 1]; |
|
char size[5]; |
|
int error; |
|
|
|
memset(&inqbuf, 0, sizeof(inqbuf)); |
|
memset(&cmd, 0, sizeof(cmd)); |
|
memset(&req, 0, sizeof(req)); |
|
|
|
cmd.opcode = INQUIRY; |
|
cmd.length = sizeof(inqbuf); |
|
memcpy(req.cmd, &cmd, sizeof(cmd)); |
|
req.cmdlen = sizeof(cmd); |
|
req.databuf = &inqbuf; |
|
req.datalen = sizeof(inqbuf); |
|
req.timeout = 10000; |
|
req.flags = SCCMD_READ; |
|
req.senselen = SENSEBUFLEN; |
|
|
|
error = ioctl(fd, SCIOCCOMMAND, &req); |
|
if (error == -1 || req.retsts != SCCMD_OK) |
|
return 0; |
|
|
|
scsi_strvis(vendor, sizeof(vendor), inqbuf.vendor, |
|
sizeof(inqbuf.vendor)); |
|
scsi_strvis(product, sizeof(product), inqbuf.product, |
|
sizeof(inqbuf.product)); |
|
scsi_strvis(revision, sizeof(revision), inqbuf.revision, |
|
sizeof(inqbuf.revision)); |
|
|
|
humanize_number(size, sizeof(size), |
|
(uint64_t)dd->dd_secsize * (uint64_t)dd->dd_totsec, |
|
"", HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL); |
|
|
|
snprintf(dd->dd_descr, sizeof(dd->dd_descr), |
|
"%s (%s, %s %s)", |
|
dd->dd_name, size, vendor, product); |
|
|
|
return 1; |
|
} |
|
|
|
static int |
|
get_descr_ata(struct disk_desc *dd, int fd) |
|
{ |
|
struct atareq req; |
|
static union { |
|
unsigned char inbuf[DEV_BSIZE]; |
|
struct ataparams inqbuf; |
|
} inbuf; |
|
struct ataparams *inqbuf = &inbuf.inqbuf; |
|
char model[sizeof(inqbuf->atap_model)+1]; |
|
char size[5]; |
|
int error, needswap = 0; |
|
|
|
memset(&inbuf, 0, sizeof(inbuf)); |
|
memset(&req, 0, sizeof(req)); |
|
|
|
req.flags = ATACMD_READ; |
|
req.command = WDCC_IDENTIFY; |
|
req.databuf = (void *)&inbuf; |
|
req.datalen = sizeof(inbuf); |
|
req.timeout = 1000; |
|
|
|
error = ioctl(fd, ATAIOCCOMMAND, &req); |
|
if (error == -1 || req.retsts != ATACMD_OK) |
|
return 0; |
|
|
|
#if BYTE_ORDER == LITTLE_ENDIAN |
|
/* |
|
* On little endian machines, we need to shuffle the string |
|
* byte order. However, we don't have to do this for NEC or |
|
* Mitsumi ATAPI devices |
|
*/ |
|
|
|
if (!(inqbuf->atap_config != WDC_CFG_CFA_MAGIC && |
|
(inqbuf->atap_config & WDC_CFG_ATAPI) && |
|
((inqbuf->atap_model[0] == 'N' && |
|
inqbuf->atap_model[1] == 'E') || |
|
(inqbuf->atap_model[0] == 'F' && |
|
inqbuf->atap_model[1] == 'X')))) { |
|
needswap = 1; |
|
} |
|
#endif |
|
|
|
ata_extract_string(model, sizeof(model), |
|
inqbuf->atap_model, sizeof(inqbuf->atap_model), needswap); |
|
humanize_number(size, sizeof(size), |
|
(uint64_t)dd->dd_secsize * (uint64_t)dd->dd_totsec, |
|
"", HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL); |
|
|
|
snprintf(dd->dd_descr, sizeof(dd->dd_descr), "%s (%s, %s)", |
|
dd->dd_name, size, model); |
|
|
|
return 1; |
|
} |
|
|
|
static void |
|
get_descr(struct disk_desc *dd) |
|
{ |
|
char diskpath[MAXPATHLEN]; |
|
int fd = -1; |
|
|
|
fd = opendisk(dd->dd_name, O_RDONLY, diskpath, sizeof(diskpath), 0); |
|
if (fd < 0) |
|
goto done; |
|
|
|
dd->dd_descr[0] = '\0'; |
|
|
|
/* try ATA */ |
|
if (get_descr_ata(dd, fd)) |
|
goto done; |
|
/* try SCSI */ |
|
if (get_descr_scsi(dd, fd)) |
|
goto done; |
|
/* XXX: get description from raid, cgd, vnd... */ |
|
|
|
done: |
|
if (fd >= 0) |
|
close(fd); |
|
if (strlen(dd->dd_descr) == 0) |
|
strcpy(dd->dd_descr, dd->dd_name); |
|
} |
|
|
|
/* disknames - contains device names without partition letters |
|
* cdrom_devices - contains devices including partition letters |
|
* returns the first entry in hw.disknames matching a cdrom_device, or |
|
* first entry on error or no match |
|
*/ |
|
const char * |
|
get_default_cdrom(void) |
|
{ |
|
static const char *cdrom_devices[] = { CD_NAMES, 0}; |
|
static const char mib_name[] = "hw.disknames"; |
|
size_t len; |
|
char *disknames; |
|
char *last; |
|
char *name; |
|
const char **arg; |
|
const char *cd_dev; |
|
|
|
/* On error just use first entry in cdrom_devices */ |
|
if (sysctlbyname(mib_name, NULL, &len, NULL, 0) == -1) |
|
return cdrom_devices[0]; |
|
if ((disknames = malloc(len + 2)) == 0) /* skip on malloc fail */ |
|
return cdrom_devices[0]; |
|
|
|
(void)sysctlbyname(mib_name, disknames, &len, NULL, 0); |
|
for ((name = strtok_r(disknames, " ", &last)); name; |
|
(name = strtok_r(NULL, " ", &last))) { |
|
for (arg = cdrom_devices; *arg; ++arg) { |
|
cd_dev = *arg; |
|
/* skip unit and partition */ |
|
if (strncmp(cd_dev, name, strlen(cd_dev) - 2) != 0) |
|
continue; |
|
if (name != disknames) |
|
strcpy(disknames, name); |
|
strcat(disknames, "a"); |
|
/* XXX: leaks, but so what? */ |
|
return disknames; |
|
} |
|
} |
|
free(disknames); |
|
return cdrom_devices[0]; |
|
} |
|
|
|
static int |
|
get_disks(struct disk_desc *dd) |
|
{ |
|
const char **xd; |
|
char *cp; |
|
struct disklabel l; |
|
int i; |
|
int numdisks; |
|
|
|
/* initialize */ |
|
numdisks = 0; |
|
|
|
for (xd = disk_names; *xd != NULL; xd++) { |
|
for (i = 0; i < MAX_DISKS; i++) { |
|
strlcpy(dd->dd_name, *xd, sizeof dd->dd_name - 2); |
|
cp = strchr(dd->dd_name, ':'); |
|
if (cp != NULL) |
|
dd->dd_no_mbr = !strcmp(cp, ":no_mbr"); |
|
else { |
|
dd->dd_no_mbr = 0; |
|
cp = strchr(dd->dd_name, 0); |
|
} |
|
|
|
snprintf(cp, 2 + 1, "%d", i); |
|
if (!get_geom(dd->dd_name, &l)) { |
|
if (errno == ENOENT) |
|
break; |
|
continue; |
|
} |
|
|
|
/* |
|
* Exclude a disk mounted as root partition, |
|
* in case of install-image on a USB memstick. |
|
*/ |
|
if (is_active_rootpart(dd->dd_name, 0)) |
|
continue; |
|
|
|
dd->dd_cyl = l.d_ncylinders; |
|
dd->dd_head = l.d_ntracks; |
|
dd->dd_sec = l.d_nsectors; |
|
dd->dd_secsize = l.d_secsize; |
|
dd->dd_totsec = l.d_secperunit; |
|
get_descr(dd); |
|
dd++; |
|
numdisks++; |
|
if (numdisks >= MAX_DISKS) |
|
return numdisks; |
|
} |
|
} |
|
return numdisks; |
|
} |
|
|
|
int |
|
find_disks(const char *doingwhat) |
|
{ |
|
struct disk_desc disks[MAX_DISKS]; |
|
menu_ent dsk_menu[nelem(disks) + 1]; // + 1 for extended partitioning entry |
|
struct disk_desc *disk; |
|
int i, already_found; |
|
int numdisks, selected_disk = -1; |
|
int menu_no; |
|
pm_devs_t *pm_i, *pm_last = NULL; |
|
|
|
/* Find disks. */ |
|
numdisks = get_disks(disks); |
|
|
|
/* need a redraw here, kernel messages hose everything */ |
|
touchwin(stdscr); |
|
refresh(); |
|
/* Kill typeahead, it won't be what the user had in mind */ |
|
fpurge(stdin); |
|
|
|
/* partman_go: <0 - we want to see menu with extended partitioning |
|
==0 - we want to see simple select disk menu |
|
>0 - we do not want to see any menus, just detect all disks */ |
|
if (partman_go <= 0) { |
|
if (numdisks == 0) { |
|
/* No disks found! */ |
|
msg_display(MSG_nodisk); |
|
process_menu(MENU_ok, NULL); |
|
/*endwin();*/ |
|
return -1; |
|
} else { |
|
/* One or more disks found! */ |
|
for (i = 0; i < numdisks; i++) { |
|
dsk_menu[i].opt_name = disks[i].dd_descr; |
|
dsk_menu[i].opt_menu = OPT_NOMENU; |
|
dsk_menu[i].opt_flags = OPT_EXIT; |
|
dsk_menu[i].opt_action = set_menu_select; |
|
} |
|
if (partman_go < 0) { |
|
dsk_menu[i].opt_name = MSG_partman; |
|
dsk_menu[i].opt_menu = OPT_NOMENU; |
|
dsk_menu[i].opt_flags = OPT_EXIT; |
|
dsk_menu[i].opt_action = set_menu_select; |
|
} |
|
menu_no = new_menu(MSG_Available_disks, |
|
dsk_menu, numdisks + ((partman_go<0)?1:0), -1, 4, 0, 0, MC_SCROLL, |
|
NULL, NULL, NULL, NULL, NULL); |
|
if (menu_no == -1) |
|
return -1; |
|
msg_display(MSG_ask_disk, doingwhat); |
|
process_menu(menu_no, &selected_disk); |
|
free_menu(menu_no); |
|
} |
|
if (partman_go < 0 && selected_disk == numdisks) { |
|
partman_go = 1; |
|
return -2; |
|
} else |
|
partman_go = 0; |
|
if (selected_disk < 0 || selected_disk >= numdisks) |
|
return -1; |
|
} |
|
|
|
/* Fill pm struct with device(s) info */ |
|
for (i = 0; i < numdisks; i++) { |
|
if (! partman_go) |
|
disk = disks + selected_disk; |
|
else { |
|
disk = disks + i; |
|
already_found = 0; |
|
SLIST_FOREACH(pm_i, &pm_head, l) { |
|
pm_last = pm_i; |
|
if (!already_found && |
|
strcmp(pm_i->diskdev, disk->dd_name) == 0) { |
|
pm_i->found = 1; |
|
break; |
|
} |
|
} |
|
if (pm_i != NULL && pm_i->found) |
|
/* We already added this device, skipping */ |
|
continue; |
|
} |
|
pm = pm_new; |
|
pm->found = 1; |
|
pm->bootable = 0; |
|
pm->pi.menu_no = -1; |
|
pm->disktype = "unknown"; |
|
pm->doessf = ""; |
|
strlcpy(pm->diskdev, disk->dd_name, sizeof pm->diskdev); |
|
strlcpy(pm->diskdev_descr, disk->dd_descr, sizeof pm->diskdev_descr); |
|
/* Use as a default disk if the user has the sets on a local disk */ |
|
strlcpy(localfs_dev, disk->dd_name, sizeof localfs_dev); |
|
|
|
pm->gpt = is_gpt(pm->diskdev); |
|
pm->no_mbr = disk->dd_no_mbr || pm->gpt; |
|
pm->sectorsize = disk->dd_secsize; |
|
pm->dlcyl = disk->dd_cyl; |
|
pm->dlhead = disk->dd_head; |
|
pm->dlsec = disk->dd_sec; |
|
pm->dlsize = disk->dd_totsec; |
|
if (pm->dlsize == 0) |
|
pm->dlsize = disk->dd_cyl * disk->dd_head * disk->dd_sec; |
|
if (pm->dlsize > UINT32_MAX && ! partman_go) { |
|
if (logfp) |
|
fprintf(logfp, "Cannot process disk %s: too big size (%d)\n", |
|
pm->diskdev, (int)pm->dlsize); |
|
msg_display(MSG_toobigdisklabel); |
|
process_menu(MENU_ok, NULL); |
|
return -1; |
|
} |
|
pm->dlcylsize = pm->dlhead * pm->dlsec; |
|
|
|
label_read(); |
|
if (partman_go) { |
|
pm_getrefdev(pm_new); |
|
if (SLIST_EMPTY(&pm_head) || pm_last == NULL) |
|
SLIST_INSERT_HEAD(&pm_head, pm_new, l); |
|
else |
|
SLIST_INSERT_AFTER(pm_last, pm_new, l); |
|
pm_new = malloc(sizeof (pm_devs_t)); |
|
memset(pm_new, 0, sizeof *pm_new); |
|
} else |
|
/* We is not in partman and do not want to process all devices, exit */ |
|
break; |
|
} |
|
|
|
return numdisks; |
|
} |
|
|
|
void |
|
label_read(void) |
|
{ |
|
/* Get existing/default label */ |
|
memset(&pm->oldlabel, 0, sizeof pm->oldlabel); |
|
if (! pm->gpt) |
|
incorelabel(pm->diskdev, pm->oldlabel); |
|
else |
|
incoregpt(pm, pm->oldlabel); |
|
/* Set 'target' label to current label in case we don't change it */ |
|
memcpy(&pm->bsdlabel, &pm->oldlabel, sizeof pm->bsdlabel); |
|
#ifndef NO_DISKLABEL |
|
if (! pm->gpt) |
|
savenewlabel(pm->oldlabel, getmaxpartitions()); |
|
#endif |
|
} |
|
|
|
void |
|
fmt_fspart(menudesc *m, int ptn, void *arg) |
|
{ |
|
unsigned int poffset, psize, pend; |
|
const char *desc; |
|
static const char *Yes; |
|
partinfo *p = pm->bsdlabel + ptn; |
|
|
|
if (Yes == NULL) |
|
Yes = msg_string(MSG_Yes); |
|
|
|
poffset = p->pi_offset / sizemult; |
|
psize = p->pi_size / sizemult; |
|
if (psize == 0) |
|
pend = 0; |
|
else |
|
pend = (p->pi_offset + p->pi_size) / sizemult - 1; |
|
|
|
if (p->pi_fstype == FS_BSDFFS) |
|
if (p->pi_flags & PIF_FFSv2) |
|
desc = "FFSv2"; |
|
else |
|
desc = "FFSv1"; |
|
else |
|
desc = getfslabelname(p->pi_fstype); |
|
|
|
#ifdef PART_BOOT |
|
if (ptn == PART_BOOT) |
|
desc = msg_string(MSG_Boot_partition_cant_change); |
|
#endif |
|
if (ptn == getrawpartition()) |
|
desc = msg_string(MSG_Whole_disk_cant_change); |
|
else { |
|
if (ptn == PART_C) |
|
desc = msg_string(MSG_NetBSD_partition_cant_change); |
|
} |
|
|
|
wprintw(m->mw, msg_string(MSG_fspart_row), |
|
poffset, pend, psize, desc, |
|
p->pi_flags & PIF_NEWFS ? Yes : "", |
|
p->pi_flags & PIF_MOUNT ? Yes : "", |
|
p->pi_mount); |
|
} |
|
|
|
/* |
|
* Label a disk using an MD-specific string DISKLABEL_CMD for |
|
* to invoke disklabel. |
|
* if MD code does not define DISKLABEL_CMD, this is a no-op. |
|
* |
|
* i386 port uses "/sbin/disklabel -w -r", just like i386 |
|
* miniroot scripts, though this may leave a bogus incore label. |
|
* |
|
* Sun ports should use DISKLABEL_CMD "/sbin/disklabel -w" |
|
* to get incore to ondisk inode translation for the Sun proms. |
|
*/ |
|
int |
|
write_disklabel (void) |
|
{ |
|
|
|
#ifdef DISKLABEL_CMD |
|
/* disklabel the disk */ |
|
return run_program(RUN_DISPLAY, "%s -f /tmp/disktab %s '%s'", |
|
DISKLABEL_CMD, pm->diskdev, pm->bsddiskname); |
|
#else |
|
return 0; |
|
#endif |
|
} |
|
|
|
|
|
static int |
|
ptn_sort(const void *a, const void *b) |
|
{ |
|
return strcmp(pm->bsdlabel[*(const int *)a].pi_mount, |
|
pm->bsdlabel[*(const int *)b].pi_mount); |
|
} |
|
|
|
int |
|
make_filesystems(void) |
|
{ |
|
unsigned int i; |
|
int ptn; |
|
int ptn_order[nelem(pm->bsdlabel)]; |
|
int error = 0; |
|
unsigned int maxpart = getmaxpartitions(); |
|
char *newfs = NULL, *dev = NULL, *devdev = NULL; |
|
partinfo *lbl; |
|
|
|
if (maxpart > nelem(pm->bsdlabel)) |
|
maxpart = nelem(pm->bsdlabel); |
|
|
|
/* Making new file systems and mounting them */ |
|
|
|
/* sort to ensure /usr/local is mounted after /usr (etc) */ |
|
for (i = 0; i < maxpart; i++) |
|
ptn_order[i] = i; |
|
qsort(ptn_order, maxpart, sizeof ptn_order[0], ptn_sort); |
|
|
|
for (i = 0; i < maxpart; i++) { |
|
/* |
|
* newfs and mount. For now, process only BSD filesystems. |
|
* but if this is the mounted-on root, has no mount |
|
* point defined, or is marked preserve, don't touch it! |
|
*/ |
|
ptn = ptn_order[i]; |
|
lbl = pm->bsdlabel + ptn; |
|
|
|
if (is_active_rootpart(pm->diskdev, ptn)) |
|
continue; |
|
|
|
if (*lbl->pi_mount == 0) |
|
/* No mount point */ |
|
continue; |
|
|
|
if (pm->isspecial) { |
|
asprintf(&dev, "%s", pm->diskdev); |
|
ptn = 0 - 'a'; |
|
} else { |
|
asprintf(&dev, "%s%c", pm->diskdev, 'a' + ptn); |
|
} |
|
if (dev == NULL) |
|
return (ENOMEM); |
|
asprintf(&devdev, "/dev/%s", dev); |
|
if (devdev == NULL) |
|
return (ENOMEM); |
|
|
|
newfs = NULL; |
|
lbl->mnt_opts = NULL; |
|
lbl->fsname = NULL; |
|
switch (lbl->pi_fstype) { |
|
case FS_APPLEUFS: |
|
asprintf(&newfs, "/sbin/newfs %s%.0d", |
|
lbl->pi_isize != 0 ? "-i" : "", lbl->pi_isize); |
|
lbl->mnt_opts = "-tffs -o async"; |
|
lbl->fsname = "ffs"; |
|
break; |
|
case FS_BSDFFS: |
|
asprintf(&newfs, |
|
"/sbin/newfs -V2 -O %d -b %d -f %d%s%.0d", |
|
lbl->pi_flags & PIF_FFSv2 ? 2 : 1, |
|
lbl->pi_fsize * lbl->pi_frag, lbl->pi_fsize, |
|
lbl->pi_isize != 0 ? " -i " : "", lbl->pi_isize); |
|
if (lbl->pi_flags & PIF_LOG) |
|
lbl->mnt_opts = "-tffs -o log"; |
|
else |
|
lbl->mnt_opts = "-tffs -o async"; |
|
lbl->fsname = "ffs"; |
|
break; |
|
case FS_BSDLFS: |
|
asprintf(&newfs, "/sbin/newfs_lfs -b %d", |
|
lbl->pi_fsize * lbl->pi_frag); |
|
lbl->mnt_opts = "-tlfs"; |
|
lbl->fsname = "lfs"; |
|
break; |
|
case FS_MSDOS: |
|
#ifdef USE_NEWFS_MSDOS |
|
asprintf(&newfs, "/sbin/newfs_msdos"); |
|
#endif |
|
lbl->mnt_opts = "-tmsdos"; |
|
lbl->fsname = "msdos"; |
|
break; |
|
#ifdef USE_SYSVBFS |
|
case FS_SYSVBFS: |
|
asprintf(&newfs, "/sbin/newfs_sysvbfs"); |
|
lbl->mnt_opts = "-tsysvbfs"; |
|
lbl->fsname = "sysvbfs"; |
|
break; |
|
#endif |
|
#ifdef USE_EXT2FS |
|
case FS_EX2FS: |
|
asprintf(&newfs, "/sbin/newfs_ext2fs"); |
|
lbl->mnt_opts = "-text2fs"; |
|
lbl->fsname = "ext2fs"; |
|
break; |
|
#endif |
|
} |
|
if (lbl->pi_flags & PIF_NEWFS && newfs != NULL) { |
|
#ifdef USE_NEWFS_MSDOS |
|
if (lbl->pi_fstype == FS_MSDOS) { |
|
/* newfs only if mount fails */ |
|
if (run_program(RUN_SILENT | RUN_ERROR_OK, |
|
"mount -rt msdos /dev/%s /mnt2", dev) != 0) |
|
error = run_program( |
|
RUN_DISPLAY | RUN_PROGRESS, |
|
"%s /dev/r%s", |
|
newfs, dev); |
|
else { |
|
run_program(RUN_SILENT | RUN_ERROR_OK, |
|
"umount /mnt2"); |
|
error = 0; |
|
} |
|
} else |
|
#endif |
|
error = run_program(RUN_DISPLAY | RUN_PROGRESS, |
|
"%s /dev/r%s", newfs, dev); |
|
} else { |
|
/* We'd better check it isn't dirty */ |
|
error = fsck_preen(pm->diskdev, ptn, lbl->fsname); |
|
} |
|
free(newfs); |
|
if (error != 0) |
|
return error; |
|
|
|
lbl->pi_flags ^= PIF_NEWFS; |
|
md_pre_mount(); |
|
|
|
if (partman_go == 0 && lbl->pi_flags & PIF_MOUNT && |
|
lbl->mnt_opts != NULL) { |
|
make_target_dir(lbl->pi_mount); |
|
error = target_mount_do(lbl->mnt_opts, devdev, lbl->pi_mount); |
|
if (error) { |
|
msg_display(MSG_mountfail, dev, ' ', lbl->pi_mount); |
|
process_menu(MENU_ok, NULL); |
|
return error; |
|
} |
|
} |
|
free(devdev); |
|
free(dev); |
|
} |
|
return 0; |
|
} |
|
|
|
int |
|
make_fstab(void) |
|
{ |
|
FILE *f; |
|
int i, swap_dev = -1; |
|
const char *dump_dev; |
|
char *dev = NULL; |
|
pm_devs_t *pm_i; |
|
#ifndef HAVE_TMPFS |
|
pm_devs_t *pm_with_swap = NULL; |
|
#endif |
|
|
|
/* Create the fstab. */ |
|
make_target_dir("/etc"); |
|
f = target_fopen("/etc/fstab", "w"); |
|
scripting_fprintf(NULL, "cat <<EOF >%s/etc/fstab\n", target_prefix()); |
|
|
|
if (logfp) |
|
(void)fprintf(logfp, |
|
"Making %s/etc/fstab (%s).\n", target_prefix(), pm->diskdev); |
|
|
|
if (f == NULL) { |
|
msg_display(MSG_createfstab); |
|
if (logfp) |
|
(void)fprintf(logfp, "Failed to make /etc/fstab!\n"); |
|
process_menu(MENU_ok, NULL); |
|
#ifndef DEBUG |
|
return 1; |
|
#else |
|
f = stdout; |
|
#endif |
|
} |
|
|
|
scripting_fprintf(f, "# NetBSD %s/etc/fstab\n# See /usr/share/examples/" |
|
"fstab/ for more examples.\n", target_prefix()); |
|
if (! partman_go) { |
|
/* We want to process only one disk... */ |
|
pm_i = pm; |
|
goto onlyonediskinfstab; |
|
} |
|
SLIST_FOREACH(pm_i, &pm_head, l) { |
|
onlyonediskinfstab: |
|
for (i = 0; i < getmaxpartitions(); i++) { |
|
const char *s = ""; |
|
const char *mp = pm_i->bsdlabel[i].pi_mount; |
|
const char *fstype = "ffs"; |
|
int fsck_pass = 0, dump_freq = 0; |
|
|
|
if (dev != NULL) |
|
free(dev); |
|
if (pm_i->isspecial) |
|
asprintf(&dev, "%s", pm_i->diskdev); |
|
else |
|
asprintf(&dev, "%s%c", pm_i->diskdev, 'a' + i); |
|
if (dev == NULL) |
|
return (ENOMEM); |
|
|
|
if (!*mp) { |
|
/* |
|
* No mount point specified, comment out line and |
|
* use /mnt as a placeholder for the mount point. |
|
*/ |
|
s = "# "; |
|
mp = "/mnt"; |
|
} |
|
|
|
switch (pm_i->bsdlabel[i].pi_fstype) { |
|
case FS_UNUSED: |
|
continue; |
|
case FS_BSDLFS: |
|
/* If there is no LFS, just comment it out. */ |
|
if (!check_lfs_progs()) |
|
s = "# "; |
|
fstype = "lfs"; |
|
/* FALLTHROUGH */ |
|
case FS_BSDFFS: |
|
fsck_pass = (strcmp(mp, "/") == 0) ? 1 : 2; |
|
dump_freq = 1; |
|
break; |
|
case FS_MSDOS: |
|
fstype = "msdos"; |
|
break; |
|
case FS_SWAP: |
|
if (pm_i->isspecial) |
|
continue; |
|
if (swap_dev == -1) { |
|
swap_dev = i; |
|
dump_dev = ",dp"; |
|
#ifndef HAVE_TMPFS |
|
pm_with_swap = pm_i; |
|
#endif |
|
} else { |
|
dump_dev = ""; |
|
} |
|
scripting_fprintf(f, "/dev/%s\t\tnone\tswap\tsw%s\t\t 0 0\n", |
|
dev, dump_dev); |
|
continue; |
|
#ifdef USE_SYSVBFS |
|
case FS_SYSVBFS: |
|
fstype = "sysvbfs"; |
|
make_target_dir("/stand"); |
|
break; |
|
#endif |
|
default: |
|
fstype = "???"; |
|
s = "# "; |
|
break; |
|
} |
|
/* The code that remounts root rw doesn't check the partition */ |
|
if (strcmp(mp, "/") == 0 && !(pm_i->bsdlabel[i].pi_flags & PIF_MOUNT)) |
|
s = "# "; |
|
|
|
scripting_fprintf(f, |
|
"%s/dev/%s\t\t%s\t%s\trw%s%s%s%s%s%s%s%s\t\t %d %d\n", |
|
s, dev, mp, fstype, |
|
pm_i->bsdlabel[i].pi_flags & PIF_LOG ? ",log" : "", |
|
pm_i->bsdlabel[i].pi_flags & PIF_MOUNT ? "" : ",noauto", |
|
pm_i->bsdlabel[i].pi_flags & PIF_ASYNC ? ",async" : "", |
|
pm_i->bsdlabel[i].pi_flags & PIF_NOATIME ? ",noatime" : "", |
|
pm_i->bsdlabel[i].pi_flags & PIF_NODEV ? ",nodev" : "", |
|
pm_i->bsdlabel[i].pi_flags & PIF_NODEVMTIME ? ",nodevmtime" : "", |
|
pm_i->bsdlabel[i].pi_flags & PIF_NOEXEC ? ",noexec" : "", |
|
pm_i->bsdlabel[i].pi_flags & PIF_NOSUID ? ",nosuid" : "", |
|
dump_freq, fsck_pass); |
|
if (pm_i->isspecial) |
|
/* Special device (such as dk*) have only one partition */ |
|
break; |
|
} |
|
/* Simple install, only one disk */ |
|
if (!partman_go) |
|
break; |
|
} |
|
if (tmp_ramdisk_size != 0) { |
|
#ifdef HAVE_TMPFS |
|
scripting_fprintf(f, "tmpfs\t\t/tmp\ttmpfs\trw,-m=1777,-s=%" |
|
PRIi64 "\n", |
|
tmp_ramdisk_size * 512); |
|
#else |
|
if (swap_dev != -1 && pm_with_swap != NULL) |
|
scripting_fprintf(f, "/dev/%s%c\t\t/tmp\tmfs\trw,-s=%" |
|
PRIi64 "\n", |
|
pm_with_swap->diskdev, 'a' + swap_dev, tmp_ramdisk_size); |
|
else |
|
scripting_fprintf(f, "swap\t\t/tmp\tmfs\trw,-s=%" |
|
PRIi64 "\n", |
|
tmp_ramdisk_size); |
|
#endif |
|
} |
|
|
|
/* Add /kern, /proc and /dev/pts to fstab and make mountpoint. */ |
|
scripting_fprintf(f, "kernfs\t\t/kern\tkernfs\trw\n"); |
|
scripting_fprintf(f, "ptyfs\t\t/dev/pts\tptyfs\trw\n"); |
|
scripting_fprintf(f, "procfs\t\t/proc\tprocfs\trw\n"); |
|
scripting_fprintf(f, "/dev/%s\t\t/cdrom\tcd9660\tro,noauto\n", |
|
get_default_cdrom()); |
|
scripting_fprintf(f, "%stmpfs\t\t/var/shm\ttmpfs\trw,-m1777,-sram%%25\n", |
|
tmpfs_on_var_shm() ? "" : "#"); |
|
make_target_dir("/kern"); |
|
make_target_dir("/proc"); |
|
make_target_dir("/dev/pts"); |
|
make_target_dir("/cdrom"); |
|
make_target_dir("/var/shm"); |
|
|
|
scripting_fprintf(NULL, "EOF\n"); |
|
|
|
if (dev != NULL) |
|
free(dev); |
|
fclose(f); |
|
fflush(NULL); |
|
return 0; |
|
} |
|
|
|
|
|
|
|
static int |
|
/*ARGSUSED*/ |
|
foundffs(struct data *list, size_t num) |
|
{ |
|
int error; |
|
|
|
if (num < 2 || strcmp(list[1].u.s_val, "/") == 0 || |
|
strstr(list[2].u.s_val, "noauto") != NULL) |
|
return 0; |
|
|
|
error = fsck_preen(list[0].u.s_val, ' '-'a', "ffs"); |
|
if (error != 0) |
|
return error; |
|
|
|
error = target_mount("", list[0].u.s_val, ' '-'a', list[1].u.s_val); |
|
if (error != 0) { |
|
msg_display(MSG_mount_failed, list[0].u.s_val); |
|
process_menu(MENU_noyes, NULL); |
|
if (!yesno) |
|
return error; |
|
} |
|
return 0; |
|
} |
|
|
|
#ifdef USE_SYSVBFS |
|
static int |
|
/*ARGSUSED*/ |
|
foundsysvbfs(struct data *list, size_t num) |
|
{ |
|
int error; |
|
|
|
if (num < 2 || strcmp(list[1].u.s_val, "/") == 0 || |
|
strstr(list[2].u.s_val, "noauto") != NULL) |
|
return 0; |
|
|
|
error = target_mount("", list[0].u.s_val, ' '-'a', list[1].u.s_val); |
|
if (error != 0) |
|
return error; |
|
return 0; |
|
} |
|
#endif |
|
|
|
/* |
|
* Do an fsck. On failure, inform the user by showing a warning |
|
* message and doing menu_ok() before proceeding. |
|
* Returns 0 on success, or nonzero return code from fsck() on failure. |
|
*/ |
|
static int |
|
fsck_preen(const char *disk, int ptn, const char *fsname) |
|
{ |
|
char *prog; |
|
int error; |
|
|
|
ptn = (ptn < 0)? 0 : 'a' + ptn; |
|
if (fsname == NULL) |
|
return 0; |
|
/* first, check if fsck program exists, if not, assume ok */ |
|
asprintf(&prog, "/sbin/fsck_%s", fsname); |
|
if (prog == NULL) |
|
return 0; |
|
if (access(prog, X_OK) != 0) |
|
return 0; |
|
if (!strcmp(fsname,"ffs")) |
|
fixsb(prog, disk, ptn); |
|
error = run_program(0, "%s -p -q /dev/r%s%c", prog, disk, ptn); |
|
free(prog); |
|
if (error != 0) { |
|
msg_display(MSG_badfs, disk, ptn, error); |
|
process_menu(MENU_noyes, NULL); |
|
if (yesno) |
|
error = 0; |
|
/* XXX at this point maybe we should run a full fsck? */ |
|
} |
|
return error; |
|
} |
|
|
|
/* This performs the same function as the etc/rc.d/fixsb script |
|
* which attempts to correct problems with ffs1 filesystems |
|
* which may have been introduced by booting a netbsd-current kernel |
|
* from between April of 2003 and January 2004. For more information |
|
* This script was developed as a response to NetBSD pr install/25138 |
|
* Additional prs regarding the original issue include: |
|
* bin/17910 kern/21283 kern/21404 port-macppc/23925 port-macppc/23926 |
|
*/ |
|
static void |
|
fixsb(const char *prog, const char *disk, char ptn) |
|
{ |
|
int fd; |
|
int rval; |
|
union { |
|
struct fs fs; |
|
char buf[SBLOCKSIZE]; |
|
} sblk; |
|
struct fs *fs = &sblk.fs; |
|
|
|
snprintf(sblk.buf, sizeof(sblk.buf), "/dev/r%s%c", |
|
disk, ptn == ' ' ? 0 : ptn); |
|
fd = open(sblk.buf, O_RDONLY); |
|
if (fd == -1) |
|
return; |
|
|
|
/* Read ffsv1 main superblock */ |
|
rval = pread(fd, sblk.buf, sizeof sblk.buf, SBLOCK_UFS1); |
|
close(fd); |
|
if (rval != sizeof sblk.buf) |
|
return; |
|
|
|
if (fs->fs_magic != FS_UFS1_MAGIC && |
|
fs->fs_magic != FS_UFS1_MAGIC_SWAPPED) |
|
/* Not FFSv1 */ |
|
return; |
|
if (fs->fs_old_flags & FS_FLAGS_UPDATED) |
|
/* properly updated fslevel 4 */ |
|
return; |
|
if (fs->fs_bsize != fs->fs_maxbsize) |
|
/* not messed up */ |
|
return; |
|
|
|
/* |
|
* OK we have a munged fs, first 'upgrade' to fslevel 4, |
|
* We specify -b16 in order to stop fsck bleating that the |
|
* sb doesn't match the first alternate. |
|
*/ |
|
run_program(RUN_DISPLAY | RUN_PROGRESS, |
|
"%s -p -b 16 -c 4 /dev/r%s%c", prog, disk, ptn); |
|
/* Then downgrade to fslevel 3 */ |
|
run_program(RUN_DISPLAY | RUN_PROGRESS, |
|
"%s -p -c 3 /dev/r%s%c", prog, disk, ptn); |
|
} |
|
|
|
/* |
|
* fsck and mount the root partition. |
|
*/ |
|
static int |
|
mount_root(void) |
|
{ |
|
int error; |
|
int ptn = (pm->isspecial)? 0 - 'a' : pm->rootpart; |
|
|
|
error = fsck_preen(pm->diskdev, ptn, "ffs"); |
|
if (error != 0) |
|
return error; |
|
|
|
md_pre_mount(); |
|
|
|
/* Mount /dev/<diskdev>a on target's "". |
|
* If we pass "" as mount-on, Prefixing will DTRT. |
|
* for now, use no options. |
|
* XXX consider -o remount in case target root is |
|
* current root, still readonly from single-user? |
|
*/ |
|
return target_mount("", pm->diskdev, ptn, ""); |
|
} |
|
|
|
/* Get information on the file systems mounted from the root filesystem. |
|
* Offer to convert them into 4.4BSD inodes if they are not 4.4BSD |
|
* inodes. Fsck them. Mount them. |
|
*/ |
|
|
|
int |
|
mount_disks(void) |
|
{ |
|
char *fstab; |
|
int fstabsize; |
|
int error; |
|
|
|
static struct lookfor fstabbuf[] = { |
|
{"/dev/", "/dev/%s %s ffs %s", "c", NULL, 0, 0, foundffs}, |
|
{"/dev/", "/dev/%s %s ufs %s", "c", NULL, 0, 0, foundffs}, |
|
#ifdef USE_SYSVBFS |
|
{"/dev/", "/dev/%s %s sysvbfs %s", "c", NULL, 0, 0, |
|
foundsysvbfs}, |
|
#endif |
|
}; |
|
static size_t numfstabbuf = sizeof(fstabbuf) / sizeof(struct lookfor); |
|
|
|
/* First the root device. */ |
|
if (target_already_root()) |
|
/* avoid needing to call target_already_root() again */ |
|
targetroot_mnt[0] = 0; |
|
else { |
|
error = mount_root(); |
|
if (error != 0 && error != EBUSY) |
|
return -1; |
|
} |
|
|
|
/* Check the target /etc/fstab exists before trying to parse it. */ |
|
if (target_dir_exists_p("/etc") == 0 || |
|
target_file_exists_p("/etc/fstab") == 0) { |
|
msg_display(MSG_noetcfstab, pm->diskdev); |
|
process_menu(MENU_ok, NULL); |
|
return -1; |
|
} |
|
|
|
|
|
/* Get fstab entries from the target-root /etc/fstab. */ |
|
fstabsize = target_collect_file(T_FILE, &fstab, "/etc/fstab"); |
|
if (fstabsize < 0) { |
|
/* error ! */ |
|
msg_display(MSG_badetcfstab, pm->diskdev); |
|
process_menu(MENU_ok, NULL); |
|
return -2; |
|
} |
|
error = walk(fstab, (size_t)fstabsize, fstabbuf, numfstabbuf); |
|
free(fstab); |
|
|
|
return error; |
|
} |
|
|
|
int |
|
set_swap(const char *disk, partinfo *pp) |
|
{ |
|
int i; |
|
char *cp; |
|
int rval; |
|
|
|
if (pp == NULL) |
|
pp = pm->oldlabel; |
|
|
|
for (i = 0; i < MAXPARTITIONS; i++) { |
|
if (pp[i].pi_fstype != FS_SWAP) |
|
continue; |
|
asprintf(&cp, "/dev/%s%c", disk, 'a' + i); |
|
rval = swapctl(SWAP_ON, cp, 0); |
|
free(cp); |
|
if (rval != 0) |
|
return -1; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
int |
|
check_swap(const char *disk, int remove_swap) |
|
{ |
|
struct swapent *swap; |
|
char *cp; |
|
int nswap; |
|
int l; |
|
int rval = 0; |
|
|
|
nswap = swapctl(SWAP_NSWAP, 0, 0); |
|
if (nswap <= 0) |
|
return 0; |
|
|
|
swap = malloc(nswap * sizeof *swap); |
|
if (swap == NULL) |
|
return -1; |
|
|
|
nswap = swapctl(SWAP_STATS, swap, nswap); |
|
if (nswap < 0) |
|
goto bad_swap; |
|
|
|
l = strlen(disk); |
|
while (--nswap >= 0) { |
|
/* Should we check the se_dev or se_path? */ |
|
cp = swap[nswap].se_path; |
|
if (memcmp(cp, "/dev/", 5) != 0) |
|
continue; |
|
if (memcmp(cp + 5, disk, l) != 0) |
|
continue; |
|
if (!isalpha(*(unsigned char *)(cp + 5 + l))) |
|
continue; |
|
if (cp[5 + l + 1] != 0) |
|
continue; |
|
/* ok path looks like it is for this device */ |
|
if (!remove_swap) { |
|
/* count active swap areas */ |
|
rval++; |
|
continue; |
|
} |
|
if (swapctl(SWAP_OFF, cp, 0) == -1) |
|
rval = -1; |
|
} |
|
|
|
done: |
|
free(swap); |
|
return rval; |
|
|
|
bad_swap: |
|
rval = -1; |
|
goto done; |
|
} |
|
|
|
#ifdef HAVE_BOOTXX_xFS |
|
char * |
|
bootxx_name(void) |
|
{ |
|
int fstype; |
|
const char *bootxxname; |
|
char *bootxx; |
|
|
|
/* check we have boot code for the root partition type */ |
|
fstype = pm->bsdlabel[pm->rootpart].pi_fstype; |
|
switch (fstype) { |
|
#if defined(BOOTXX_FFSV1) || defined(BOOTXX_FFSV2) |
|
case FS_BSDFFS: |
|
if (pm->bsdlabel[pm->rootpart].pi_flags & PIF_FFSv2) { |
|
#ifdef BOOTXX_FFSV2 |
|
bootxxname = BOOTXX_FFSV2; |
|
#else |
|
bootxxname = NULL; |
|
#endif |
|
} else { |
|
#ifdef BOOTXX_FFSV1 |
|
bootxxname = BOOTXX_FFSV1; |
|
#else |
|
bootxxname = NULL; |
|
#endif |
|
} |
|
break; |
|
#endif |
|
#ifdef BOOTXX_LFS |
|
case FS_BSDLFS: |
|
bootxxname = BOOTXX_LFS; |
|
break; |
|
#endif |
|
default: |
|
bootxxname = NULL; |
|
break; |
|
} |
|
|
|
if (bootxxname == NULL) |
|
return NULL; |
|
|
|
asprintf(&bootxx, "%s/%s", BOOTXXDIR, bootxxname); |
|
return bootxx; |
|
} |
|
#endif |
|
|
|
static int |
|
get_fsid_by_gptuuid(const char *str) |
|
{ |
|
int i; |
|
uuid_t uuid; |
|
uint32_t status; |
|
|
|
uuid_from_string(str, &uuid, &status); |
|
if (status == uuid_s_ok) { |
|
for (i = 0; gpt_filesystems[i].id > 0; i++) |
|
if (uuid_equal(&uuid, &(gpt_filesystems[i].uuid), NULL)) |
|
return gpt_filesystems[i].id; |
|
} |
|
return FS_OTHER; |
|
} |
|
|
|
const char * |
|
get_gptfs_by_id(int filesystem) |
|
{ |
|
int i; |
|
for (i = 0; gpt_filesystems[i].id > 0; i++) |
|
if (filesystem == gpt_filesystems[i].id) |
|
return gpt_filesystems[i].name; |
|
return NULL; |
|
} |
|
|
|
/* from dkctl.c */ |
|
static int |
|
get_dkwedges_sort(const void *a, const void *b) |
|
{ |
|
const struct dkwedge_info *dkwa = a, *dkwb = b; |
|
const daddr_t oa = dkwa->dkw_offset, ob = dkwb->dkw_offset; |
|
return (oa < ob) ? -1 : (oa > ob) ? 1 : 0; |
|
} |
|
|
|
int |
|
get_dkwedges(struct dkwedge_info **dkw, const char *diskdev) |
|
{ |
|
int fd; |
|
char buf[STRSIZE]; |
|
size_t bufsize; |
|
struct dkwedge_list dkwl; |
|
|
|
*dkw = NULL; |
|
dkwl.dkwl_buf = *dkw; |
|
dkwl.dkwl_bufsize = 0; |
|
fd = opendisk(diskdev, O_RDONLY, buf, STRSIZE, 0); |
|
if (fd < 0) |
|
return -1; |
|
|
|
for (;;) { |
|
if (ioctl(fd, DIOCLWEDGES, &dkwl) == -1) |
|
return -2; |
|
if (dkwl.dkwl_nwedges == dkwl.dkwl_ncopied) |
|
break; |
|
bufsize = dkwl.dkwl_nwedges * sizeof(**dkw); |
|
if (dkwl.dkwl_bufsize < bufsize) { |
|
*dkw = realloc(dkwl.dkwl_buf, bufsize); |
|
if (*dkw == NULL) |
|
return -3; |
|
dkwl.dkwl_buf = *dkw; |
|
dkwl.dkwl_bufsize = bufsize; |
|
} |
|
} |
|
|
|
if (dkwl.dkwl_nwedges > 0) |
|
qsort(*dkw, dkwl.dkwl_nwedges, sizeof(**dkw), get_dkwedges_sort); |
|
|
|
close(fd); |
|
return dkwl.dkwl_nwedges; |
|
} |
|
|
|
/* XXX: rewrite */ |
|
static int |
|
incoregpt(pm_devs_t *pm_cur, partinfo *lp) |
|
{ |
|
int i, num; |
|
unsigned int p_num; |
|
uint64_t p_start, p_size; |
|
char *textbuf, *t, *tt, p_type[STRSIZE]; |
|
struct dkwedge_info *dkw; |
|
|
|
num = get_dkwedges(&dkw, pm_cur->diskdev); |
|
if (dkw != NULL) { |
|
for (i = 0; i < num && i < MAX_WEDGES; i++) |
|
run_program(RUN_SILENT, "dkctl %s delwedge %s", |
|
pm_cur->diskdev, dkw[i].dkw_devname); |
|
free (dkw); |
|
} |
|
|
|
if (collect(T_OUTPUT, &textbuf, "gpt show -u %s 2>/dev/null", pm_cur->diskdev) < 1) |
|
return -1; |
|
|
|
(void)strtok(textbuf, "\n"); /* ignore first line */ |
|
while ((t = strtok(NULL, "\n")) != NULL) { |
|
i = 0; p_start = 0; p_size = 0; p_num = 0; strcpy(p_type, ""); /* init */ |
|
while ((tt = strsep(&t, " \t")) != NULL) { |
|
if (strlen(tt) == 0) |
|
continue; |
|
if (i == 0) |
|
p_start = strtouq(tt, NULL, 10); |
|
if (i == 1) |
|
p_size = strtouq(tt, NULL, 10); |
|
if (i == 2) |
|
p_num = strtouq(tt, NULL, 10); |
|
if (i > 2 || (i == 2 && p_num == 0)) |
|
if ( |
|
strcmp(tt, "GPT") && |
|
strcmp(tt, "part") && |
|
strcmp(tt, "-") |
|
) |
|
strncat(p_type, tt, STRSIZE); |
|
i++; |
|
} |
|
if (p_start == 0 || p_size == 0) |
|
continue; |
|
else if (! strcmp(p_type, "Pritable")) |
|
pm_cur->ptstart = p_start + p_size; |
|
else if (! strcmp(p_type, "Sectable")) |
|
pm_cur->ptsize = p_start - pm_cur->ptstart - 1; |
|
else if (p_num == 0 && strlen(p_type) > 0) |
|
/* Utilitary entry (PMBR, etc) */ |
|
continue; |
|
else if (p_num == 0) { |
|
/* Free space */ |
|
continue; |
|
} else { |
|
/* Usual partition */ |
|
lp[p_num].pi_size = p_size; |
|
lp[p_num].pi_offset = p_start; |
|
lp[p_num].pi_fstype = get_fsid_by_gptuuid(p_type); |
|
} |
|
} |
|
free(textbuf); |
|
|
|
return 0; |
|
} |
|
|
|
static int |
|
is_gpt(const char *dev) |
|
{ |
|
return ! run_program(RUN_SILENT | RUN_ERROR_OK, |
|
"sh -c 'gpt show %s |grep -e Pri\\ GPT\\ table'", dev); |
|
} |