From 6e7a315eb67cb6c113cf37e1d66c4f11a51a2b3e Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 18:29:51 +0200 Subject: Adding upstream version 2.06. Signed-off-by: Daniel Baumann --- grub-core/osdep/linux/ofpath.c | 769 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 769 insertions(+) create mode 100644 grub-core/osdep/linux/ofpath.c (limited to 'grub-core/osdep/linux/ofpath.c') diff --git a/grub-core/osdep/linux/ofpath.c b/grub-core/osdep/linux/ofpath.c new file mode 100644 index 0000000..a6153d3 --- /dev/null +++ b/grub-core/osdep/linux/ofpath.c @@ -0,0 +1,769 @@ +/* ofpath.c - calculate OpenFirmware path names given an OS device */ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 2009, 2011,2012, 2013 Free Software Foundation, Inc. + * + * GRUB is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GRUB is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GRUB. If not, see . + */ + +#undef OFPATH_STANDALONE + +#ifndef OFPATH_STANDALONE +#include +#include +#include +#include +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __sparc__ +typedef enum + { + GRUB_OFPATH_SPARC_WWN_ADDR = 1, + GRUB_OFPATH_SPARC_TGT_LUN, + } ofpath_sparc_addressing; + +struct ofpath_sparc_hba +{ + grub_uint32_t device_id; + ofpath_sparc_addressing addressing; +}; + +static struct ofpath_sparc_hba sparc_lsi_hba[] = { + /* Rhea, Jasper 320, LSI53C1020/1030. */ + {0x30, GRUB_OFPATH_SPARC_TGT_LUN}, + /* SAS-1068E. */ + {0x50, GRUB_OFPATH_SPARC_TGT_LUN}, + /* SAS-1064E. */ + {0x56, GRUB_OFPATH_SPARC_TGT_LUN}, + /* Pandora SAS-1068E. */ + {0x58, GRUB_OFPATH_SPARC_TGT_LUN}, + /* Aspen, Invader, LSI SAS-3108. */ + {0x5d, GRUB_OFPATH_SPARC_TGT_LUN}, + /* Niwot, SAS 2108. */ + {0x79, GRUB_OFPATH_SPARC_TGT_LUN}, + /* Erie, Falcon, LSI SAS 2008. */ + {0x72, GRUB_OFPATH_SPARC_WWN_ADDR}, + /* LSI WarpDrive 6203. */ + {0x7e, GRUB_OFPATH_SPARC_WWN_ADDR}, + /* LSI SAS 2308. */ + {0x87, GRUB_OFPATH_SPARC_WWN_ADDR}, + /* LSI SAS 3008. */ + {0x97, GRUB_OFPATH_SPARC_WWN_ADDR}, + {0, 0} +}; + +static const int LSI_VENDOR_ID = 0x1000; +#endif + +#ifdef OFPATH_STANDALONE +#define xmalloc malloc +void +grub_util_error (const char *fmt, ...) +{ + va_list ap; + + fprintf (stderr, "ofpath: error: "); + va_start (ap, fmt); + vfprintf (stderr, fmt, ap); + va_end (ap); + fputc ('\n', stderr); + exit (1); +} + +void +grub_util_info (const char *fmt, ...) +{ + va_list ap; + + fprintf (stderr, "ofpath: info: "); + va_start (ap, fmt); + vfprintf (stderr, fmt, ap); + va_end (ap); + fputc ('\n', stderr); +} + +#define grub_util_warn grub_util_info +#define _(x) x +#define xstrdup strdup +#endif + +static void +kill_trailing_dir(char *path) +{ + char *end = path + strlen(path) - 1; + + while (end >= path) + { + if (*end != '/') + { + end--; + continue; + } + *end = '\0'; + break; + } +} + +static void +trim_newline (char *path) +{ + char *end = path + strlen(path) - 1; + + while (*end == '\n') + *end-- = '\0'; +} + +#define MAX_DISK_CAT 64 + +static char * +find_obppath (const char *sysfs_path_orig) +{ + char *sysfs_path, *path; + size_t path_size = strlen (sysfs_path_orig) + sizeof ("/obppath"); + + sysfs_path = xstrdup (sysfs_path_orig); + path = xmalloc (path_size); + + while (1) + { + int fd; + char *of_path; + struct stat st; + size_t size; + + snprintf(path, path_size, "%s/obppath", sysfs_path); +#if 0 + printf("Trying %s\n", path); +#endif + + fd = open(path, O_RDONLY); + +#ifndef __sparc__ + if (fd < 0 || fstat (fd, &st) < 0) + { + if (fd >= 0) + close (fd); + snprintf(path, path_size, "%s/devspec", sysfs_path); + fd = open(path, O_RDONLY); + } +#endif + + if (fd < 0 || fstat (fd, &st) < 0) + { + if (fd >= 0) + close (fd); + kill_trailing_dir(sysfs_path); + if (!strcmp(sysfs_path, "/sys")) + { + grub_util_info (_("`obppath' not found in parent dirs of `%s'," + " no IEEE1275 name discovery"), + sysfs_path_orig); + free (path); + free (sysfs_path); + return NULL; + } + continue; + } + size = st.st_size; + of_path = xmalloc (size + MAX_DISK_CAT + 1); + memset(of_path, 0, size + MAX_DISK_CAT + 1); + if (read(fd, of_path, size) < 0) + { + grub_util_info (_("cannot read `%s': %s"), path, strerror (errno)); + close(fd); + free (path); + free (of_path); + free (sysfs_path); + return NULL; + } + close(fd); + + trim_newline(of_path); + free (path); + free (sysfs_path); + return of_path; + } +} + +static char * +xrealpath (const char *in) +{ + char *out; +#ifdef PATH_MAX + out = xmalloc (PATH_MAX); + out = realpath (in, out); +#else + out = realpath (in, NULL); +#endif + if (!out) + grub_util_error (_("failed to get canonical path of `%s'"), in); + return out; +} + +static char * +block_device_get_sysfs_path_and_link(const char *devicenode) +{ + char *rpath; + char *rpath2; + char *ret; + size_t tmp_size = strlen (devicenode) + sizeof ("/sys/block/"); + char *tmp = xmalloc (tmp_size); + + memcpy (tmp, "/sys/block/", sizeof ("/sys/block/")); + strcat (tmp, devicenode); + + rpath = xrealpath (tmp); + rpath2 = xmalloc (strlen (rpath) + sizeof ("/device")); + strcpy (rpath2, rpath); + strcat (rpath2, "/device"); + + ret = xrealpath (rpath2); + + free (tmp); + free (rpath); + free (rpath2); + return ret; +} + +static inline int +my_isdigit (int c) +{ + return (c >= '0' && c <= '9'); +} + +static const char * +trailing_digits (const char *p) +{ + const char *end; + + end = p + strlen(p) - 1; + while (end >= p) + { + if (! my_isdigit(*end)) + break; + end--; + } + + return end + 1; +} + +static char * +__of_path_common(char *sysfs_path, + const char *device, int devno) +{ + const char *digit_string; + char disk[MAX_DISK_CAT]; + char *of_path = find_obppath(sysfs_path); + + if (!of_path) + return NULL; + + digit_string = trailing_digits (device); + if (*digit_string == '\0') + { + snprintf(disk, sizeof (disk), "/disk@%d", devno); + } + else + { + int part; + + sscanf(digit_string, "%d", &part); + snprintf(disk, sizeof (disk), "/disk@%d:%c", devno, 'a' + (part - 1)); + } + strcat(of_path, disk); + return of_path; +} + +static char * +get_basename(char *p) +{ + char *ret = p; + + while (*p) + { + if (*p == '/') + ret = p + 1; + p++; + } + + return ret; +} + +static char * +of_path_of_vdisk(const char *sys_devname __attribute__((unused)), + const char *device, + const char *devnode __attribute__((unused)), + const char *devicenode) +{ + char *sysfs_path, *p; + int devno, junk; + char *ret; + + sysfs_path = block_device_get_sysfs_path_and_link(devicenode); + p = get_basename (sysfs_path); + sscanf(p, "vdc-port-%d-%d", &devno, &junk); + ret = __of_path_common (sysfs_path, device, devno); + + free (sysfs_path); + return ret; +} + +static char * +of_path_of_ide(const char *sys_devname __attribute__((unused)), const char *device, + const char *devnode __attribute__((unused)), + const char *devicenode) +{ + char *sysfs_path, *p; + int chan, devno; + char *ret; + + sysfs_path = block_device_get_sysfs_path_and_link(devicenode); + p = get_basename (sysfs_path); + sscanf(p, "%d.%d", &chan, &devno); + + ret = __of_path_common(sysfs_path, device, 2 * chan + devno); + + free (sysfs_path); + return ret; +} + +#ifdef __sparc__ +static char * +of_path_of_nvme(const char *sys_devname __attribute__((unused)), + const char *device, + const char *devnode __attribute__((unused)), + const char *devicenode) +{ + char *sysfs_path, *of_path, disk[MAX_DISK_CAT]; + const char *digit_string, *part_end; + + digit_string = trailing_digits (device); + part_end = devicenode + strlen (devicenode) - 1; + + if ((*digit_string != '\0') && (*part_end == 'p')) + { + /* We have a partition number, strip it off. */ + int part; + char *nvmedev, *end; + + nvmedev = strdup (devicenode); + + if (!nvmedev) + return NULL; + + end = nvmedev + strlen (nvmedev) - 1; + /* Remove the p. */ + *end = '\0'; + sscanf (digit_string, "%d", &part); + snprintf (disk, sizeof (disk), "/disk@1:%c", 'a' + (part - 1)); + sysfs_path = block_device_get_sysfs_path_and_link (nvmedev); + free (nvmedev); + } + else + { + /* We do not have the parition. */ + snprintf (disk, sizeof (disk), "/disk@1"); + sysfs_path = block_device_get_sysfs_path_and_link (device); + } + + of_path = find_obppath (sysfs_path); + + if (of_path) + strcat (of_path, disk); + + free (sysfs_path); + return of_path; +} +#endif + +static int +vendor_is_ATA(const char *path) +{ + int fd, err; + char *bufname; + char bufcont[3]; + size_t path_size; + + path_size = strlen (path) + sizeof ("/vendor"); + + bufname = xmalloc (path_size); + + snprintf (bufname, path_size, "%s/vendor", path); + fd = open (bufname, O_RDONLY); + if (fd < 0) + grub_util_error (_("cannot open `%s': %s"), bufname, strerror (errno)); + + memset(bufcont, 0, sizeof (bufcont)); + err = read(fd, bufcont, sizeof (bufcont)); + if (err < 0) + grub_util_error (_("cannot open `%s': %s"), bufname, strerror (errno)); + + close(fd); + free (bufname); + + return (memcmp(bufcont, "ATA", 3) == 0); +} + +#ifdef __sparc__ +static void +check_hba_identifiers (const char *sysfs_path, int *vendor, int *device_id) +{ + char *ed = strstr (sysfs_path, "host"); + size_t path_size; + char *p, *path; + char buf[8]; + int fd; + + if (!ed) + return; + + p = xstrdup (sysfs_path); + ed = strstr (p, "host"); + + *ed = '\0'; + + path_size = (strlen (p) + sizeof ("vendor")); + path = xmalloc (path_size); + + if (!path) + goto out; + + snprintf (path, path_size, "%svendor", p); + fd = open (path, O_RDONLY); + + if (fd < 0) + goto out; + + memset (buf, 0, sizeof (buf)); + + if (read (fd, buf, sizeof (buf) - 1) < 0) + goto out; + + close (fd); + sscanf (buf, "%x", vendor); + + snprintf (path, path_size, "%sdevice", p); + fd = open (path, O_RDONLY); + + if (fd < 0) + goto out; + + memset (buf, 0, sizeof (buf)); + + if (read (fd, buf, sizeof (buf) - 1) < 0) + goto out; + + close (fd); + sscanf (buf, "%x", device_id); + + out: + free (path); + free (p); +} +#endif + +static void +check_sas (const char *sysfs_path, int *tgt, unsigned long int *sas_address) +{ + char *ed = strstr (sysfs_path, "end_device"); + char *p, *q, *path; + char phy[21]; + int fd; + size_t path_size; + + if (!ed) + return; + + /* SAS devices are identified using disk@$PHY_ID */ + p = xstrdup (sysfs_path); + ed = strstr(p, "end_device"); + if (!ed) + return; + + q = ed; + while (*q && *q != '/') + q++; + *q = '\0'; + + path_size = (strlen (p) + strlen (ed) + + sizeof ("%s/sas_device/%s/phy_identifier")); + path = xmalloc (path_size); + snprintf (path, path_size, "%s/sas_device/%s/phy_identifier", p, ed); + fd = open (path, O_RDONLY); + if (fd < 0) + grub_util_error (_("cannot open `%s': %s"), path, strerror (errno)); + + memset (phy, 0, sizeof (phy)); + if (read (fd, phy, sizeof (phy) - 1) < 0) + grub_util_error (_("cannot read `%s': %s"), path, strerror (errno)); + + close (fd); + + sscanf (phy, "%d", tgt); + + snprintf (path, path_size, "%s/sas_device/%s/sas_address", p, ed); + fd = open (path, O_RDONLY); + if (fd < 0) + grub_util_error (_("cannot open `%s': %s"), path, strerror (errno)); + + memset (phy, 0, sizeof (phy)); + if (read (fd, phy, sizeof (phy) - 1) < 0) + grub_util_error (_("cannot read `%s': %s"), path, strerror (errno)); + sscanf (phy, "%lx", sas_address); + + free (path); + free (p); + close (fd); +} + +static char * +of_path_of_scsi(const char *sys_devname __attribute__((unused)), const char *device, + const char *devnode __attribute__((unused)), + const char *devicenode) +{ + const char *p, *digit_string, *disk_name; + int host, bus, tgt, lun; + unsigned long int sas_address = 0; + char *sysfs_path, disk[MAX_DISK_CAT - sizeof ("/fp@0,0")]; + char *of_path; + + sysfs_path = block_device_get_sysfs_path_and_link(devicenode); + p = get_basename (sysfs_path); + sscanf(p, "%d:%d:%d:%d", &host, &bus, &tgt, &lun); + check_sas (sysfs_path, &tgt, &sas_address); + + if (vendor_is_ATA(sysfs_path)) + { + of_path = __of_path_common(sysfs_path, device, tgt); + free (sysfs_path); + return of_path; + } + + of_path = find_obppath(sysfs_path); + if (!of_path) + goto out; + + if (strstr (of_path, "qlc")) + strcat (of_path, "/fp@0,0"); + + if (strstr (of_path, "sbus")) + disk_name = "sd"; + else + disk_name = "disk"; + + digit_string = trailing_digits (device); + if (strncmp (of_path, "/vdevice/", sizeof ("/vdevice/") - 1) == 0) + { + unsigned long id = 0x8000 | (tgt << 8) | (bus << 5) | lun; + if (*digit_string == '\0') + { + snprintf(disk, sizeof (disk), "/%s@%04lx000000000000", disk_name, id); + } + else + { + int part; + + sscanf(digit_string, "%d", &part); + snprintf(disk, sizeof (disk), + "/%s@%04lx000000000000:%c", disk_name, id, 'a' + (part - 1)); + } + } + else + { +#ifdef __sparc__ + ofpath_sparc_addressing addressing = GRUB_OFPATH_SPARC_TGT_LUN; + int vendor = 0, device_id = 0; + char *optr = disk; + + check_hba_identifiers (sysfs_path, &vendor, &device_id); + + if (vendor == LSI_VENDOR_ID) + { + struct ofpath_sparc_hba *lsi_hba; + + /* + * Over time different OF addressing schemes have been supported. + * There is no generic addressing scheme that works across + * every HBA. + */ + for (lsi_hba = sparc_lsi_hba; lsi_hba->device_id; lsi_hba++) + if (lsi_hba->device_id == device_id) + { + addressing = lsi_hba->addressing; + break; + } + } + + if (addressing == GRUB_OFPATH_SPARC_WWN_ADDR) + optr += snprintf (disk, sizeof (disk), "/%s@w%lx,%x", disk_name, + sas_address, lun); + else + optr += snprintf (disk, sizeof (disk), "/%s@%x,%x", disk_name, tgt, + lun); + + if (*digit_string != '\0') + { + int part; + + sscanf (digit_string, "%d", &part); + snprintf (optr, sizeof (disk) - (optr - disk - 1), ":%c", 'a' + + (part - 1)); + } +#else + if (lun == 0) + { + int sas_id = 0; + sas_id = bus << 16 | tgt << 8 | lun; + + if (*digit_string == '\0') + { + snprintf(disk, sizeof (disk), "/sas/%s@%x", disk_name, sas_id); + } + else + { + int part; + + sscanf(digit_string, "%d", &part); + snprintf(disk, sizeof (disk), + "/sas/%s@%x:%c", disk_name, sas_id, 'a' + (part - 1)); + } + } + else + { + char *lunstr; + int lunpart[4]; + + lunstr = xmalloc (20); + + lunpart[0] = (lun >> 8) & 0xff; + lunpart[1] = lun & 0xff; + lunpart[2] = (lun >> 24) & 0xff; + lunpart[3] = (lun >> 16) & 0xff; + + sprintf(lunstr, "%02x%02x%02x%02x00000000", lunpart[0], lunpart[1], lunpart[2], lunpart[3]); + long int longlun = atol(lunstr); + + if (*digit_string == '\0') + { + snprintf(disk, sizeof (disk), "/sas/%s@%lx,%lu", disk_name, sas_address, longlun); + } + else + { + int part; + + sscanf(digit_string, "%d", &part); + snprintf(disk, sizeof (disk), + "/sas/%s@%lx,%lu:%c", disk_name, sas_address, longlun, 'a' + (part - 1)); + } + free (lunstr); + } +#endif + } + strcat(of_path, disk); + + out: + free (sysfs_path); + return of_path; +} + +static char * +strip_trailing_digits (const char *p) +{ + char *new, *end; + + new = strdup (p); + end = new + strlen(new) - 1; + while (end >= new) + { + if (! my_isdigit(*end)) + break; + *end-- = '\0'; + } + + return new; +} + +char * +grub_util_devname_to_ofpath (const char *sys_devname) +{ + char *name_buf, *device, *devnode, *devicenode, *ofpath; + + name_buf = xrealpath (sys_devname); + + device = get_basename (name_buf); + devnode = strip_trailing_digits (name_buf); + devicenode = strip_trailing_digits (device); + + if (device[0] == 'h' && device[1] == 'd') + ofpath = of_path_of_ide(name_buf, device, devnode, devicenode); + else if (device[0] == 's' + && (device[1] == 'd' || device[1] == 'r')) + ofpath = of_path_of_scsi(name_buf, device, devnode, devicenode); + else if (device[0] == 'v' && device[1] == 'd' && device[2] == 'i' + && device[3] == 's' && device[4] == 'k') + ofpath = of_path_of_vdisk(name_buf, device, devnode, devicenode); + else if (device[0] == 'f' && device[1] == 'd' + && device[2] == '0' && device[3] == '\0') + /* All the models I've seen have a devalias "floppy". + New models have no floppy at all. */ + ofpath = xstrdup ("floppy"); +#ifdef __sparc__ + else if (device[0] == 'n' && device[1] == 'v' && device[2] == 'm' + && device[3] == 'e') + ofpath = of_path_of_nvme (name_buf, device, devnode, devicenode); +#endif + else + { + grub_util_warn (_("unknown device type %s"), device); + ofpath = NULL; + } + + free (devnode); + free (devicenode); + free (name_buf); + + return ofpath; +} + +#ifdef OFPATH_STANDALONE +int main(int argc, char **argv) +{ + char *of_path; + + if (argc != 2) + { + printf(_("Usage: %s DEVICE\n"), argv[0]); + return 1; + } + + of_path = grub_util_devname_to_ofpath (argv[1]); + if (of_path) + printf("%s\n", of_path); + free (of_path); + + return 0; +} +#endif -- cgit v1.2.3