int grub_ieee1275_instance_to_path (grub_ieee1275_ihandle_t ihandle, char *path, grub_size_t len, grub_ssize_t *actual) { struct instance_to_path_args { struct grub_ieee1275_common_hdr common; grub_ieee1275_ihandle_t ihandle; grub_ieee1275_cell_t buf; grub_ieee1275_cell_t buflen; grub_ieee1275_cell_t actual; } args; INIT_IEEE1275_COMMON (&args.common, "instance-to-path", 3, 1); args.ihandle = ihandle; args.buf = (grub_ieee1275_cell_t) path; args.buflen = (grub_ieee1275_cell_t) len; if (IEEE1275_CALL_ENTRY_FN (&args) == -1) return -1; if (actual) *actual = args.actual; if (args.actual == IEEE1275_CELL_INVALID) return -1; return 0; }
/* Call the "map" method of /chosen/mmu. */ static int grub_map (grub_addr_t phys, grub_addr_t virt, grub_uint32_t size, grub_uint8_t mode) { struct map_args { struct grub_ieee1275_common_hdr common; char *method; grub_ieee1275_ihandle_t ihandle; grub_uint32_t mode; grub_uint32_t size; grub_uint32_t virt; grub_uint32_t phys; int catch_result; } args; INIT_IEEE1275_COMMON (&args.common, "call-method", 6, 1); args.method = "map"; args.ihandle = grub_ieee1275_mmu; args.phys = phys; args.virt = virt; args.size = size; args.mode = mode; /* Format is WIMG0PP. */ if (IEEE1275_CALL_ENTRY_FN (&args) == -1) return -1; return args.catch_result; }
grub_uint64_t grub_ieee1275_num_blocks (grub_ieee1275_ihandle_t ihandle) { struct nblocks_args_ieee1275 { struct grub_ieee1275_common_hdr common; grub_ieee1275_cell_t method; grub_ieee1275_cell_t ihandle; grub_ieee1275_cell_t catch_result; grub_ieee1275_cell_t blocks; } args; INIT_IEEE1275_COMMON (&args.common, "call-method", 2, 2); args.method = (grub_ieee1275_cell_t) "#blocks"; args.ihandle = ihandle; args.catch_result = 1; if ((IEEE1275_CALL_ENTRY_FN (&args) == -1) || (args.catch_result != 0)) return -1; /* * If the number of blocks exceeds the range of an unsigned number, * return 0 to alert the caller to try the #blocks64 command. */ if (args.blocks >= 0xffffffffULL) return 0; return args.blocks; }
int grub_ieee1275_seek (grub_ieee1275_ihandle_t ihandle, int pos_hi, int pos_lo, grub_ssize_t *result) { struct write_args { struct grub_ieee1275_common_hdr common; grub_ieee1275_ihandle_t ihandle; grub_ieee1275_cell_t pos_hi; grub_ieee1275_cell_t pos_lo; grub_ieee1275_cell_t result; } args; INIT_IEEE1275_COMMON (&args.common, "seek", 3, 1); args.ihandle = ihandle; args.pos_hi = (grub_ieee1275_cell_t) pos_hi; args.pos_lo = (grub_ieee1275_cell_t) pos_lo; if (IEEE1275_CALL_ENTRY_FN (&args) == -1) return -1; if (result) *result = args.result; return 0; }
int grub_ieee1275_claim_vaddr (grub_addr_t vaddr, grub_size_t size) { struct claim_vaddr_args { struct grub_ieee1275_common_hdr common; grub_ieee1275_cell_t method; grub_ieee1275_cell_t ihandle; grub_ieee1275_cell_t align; grub_ieee1275_cell_t size; grub_ieee1275_cell_t virt; grub_ieee1275_cell_t catch_result; } args; INIT_IEEE1275_COMMON (&args.common, "call-method", 5, 2); args.method = (grub_ieee1275_cell_t) "claim"; args.ihandle = grub_ieee1275_mmu; args.align = 0; args.size = size; args.virt = vaddr; args.catch_result = (grub_ieee1275_cell_t) -1; if (IEEE1275_CALL_ENTRY_FN (&args) == -1) return -1; return args.catch_result; }
int grub_ieee1275_get_property_length (grub_ieee1275_phandle_t phandle, const char *prop, grub_ssize_t *length) { struct get_property_args { struct grub_ieee1275_common_hdr common; grub_ieee1275_phandle_t phandle; grub_ieee1275_cell_t prop; grub_ieee1275_cell_t length; } args; INIT_IEEE1275_COMMON (&args.common, "getproplen", 2, 1); args.phandle = phandle; args.prop = (grub_ieee1275_cell_t) prop; args.length = (grub_ieee1275_cell_t) -1; if (IEEE1275_CALL_ENTRY_FN (&args) == -1) return -1; *length = args.length; if (args.length == IEEE1275_CELL_INVALID) return -1; return 0; }
int grub_ieee1275_get_property (grub_ieee1275_phandle_t phandle, const char *property, void *buf, grub_size_t size, grub_ssize_t *actual) { struct get_property_args { struct grub_ieee1275_common_hdr common; grub_ieee1275_phandle_t phandle; grub_ieee1275_cell_t prop; grub_ieee1275_cell_t buf; grub_ieee1275_cell_t buflen; grub_ieee1275_cell_t size; } args; INIT_IEEE1275_COMMON (&args.common, "getprop", 4, 1); args.phandle = phandle; args.prop = (grub_ieee1275_cell_t) property; args.buf = (grub_ieee1275_cell_t) buf; args.buflen = (grub_ieee1275_cell_t) size; if (IEEE1275_CALL_ENTRY_FN (&args) == -1) return -1; if (actual) *actual = (grub_ssize_t) args.size; if (args.size == IEEE1275_CELL_INVALID) return -1; return 0; }
int grub_ieee1275_read (grub_ieee1275_ihandle_t ihandle, void *buffer, grub_size_t len, grub_ssize_t *actualp) { struct write_args { struct grub_ieee1275_common_hdr common; grub_ieee1275_ihandle_t ihandle; grub_ieee1275_cell_t buf; grub_ieee1275_cell_t len; grub_ieee1275_cell_t actual; } args; INIT_IEEE1275_COMMON (&args.common, "read", 3, 1); args.ihandle = ihandle; args.buf = (grub_ieee1275_cell_t) buffer; args.len = (grub_ieee1275_cell_t) len; if (IEEE1275_CALL_ENTRY_FN (&args) == -1) return -1; if (actualp) *actualp = args.actual; return 0; }
static grub_err_t grub_ofdisk_get_block_size (const char *device, grub_uint32_t *block_size, struct ofdisk_hash_ent *op) { struct size_args_ieee1275 { struct grub_ieee1275_common_hdr common; grub_ieee1275_cell_t method; grub_ieee1275_cell_t ihandle; grub_ieee1275_cell_t result; grub_ieee1275_cell_t size1; grub_ieee1275_cell_t size2; } args_ieee1275; if (last_ihandle) grub_ieee1275_close (last_ihandle); last_ihandle = 0; last_devpath = NULL; grub_ieee1275_open (device, &last_ihandle); if (! last_ihandle) return grub_error (GRUB_ERR_UNKNOWN_DEVICE, "can't open device"); *block_size = 0; if (op->block_size_fails >= 2) return GRUB_ERR_NONE; INIT_IEEE1275_COMMON (&args_ieee1275.common, "call-method", 2, 2); args_ieee1275.method = (grub_ieee1275_cell_t) "block-size"; args_ieee1275.ihandle = last_ihandle; args_ieee1275.result = 1; if (IEEE1275_CALL_ENTRY_FN (&args_ieee1275) == -1) { grub_dprintf ("disk", "can't get block size: failed call-method\n"); op->block_size_fails++; } else if (args_ieee1275.result) { grub_dprintf ("disk", "can't get block size: %lld\n", (long long) args_ieee1275.result); op->block_size_fails++; } else if (args_ieee1275.size1 && !(args_ieee1275.size1 & (args_ieee1275.size1 - 1)) && args_ieee1275.size1 >= 512 && args_ieee1275.size1 <= 16384) { op->block_size_fails = 0; *block_size = args_ieee1275.size1; } return 0; }
grub_err_t grub_get_datetime (struct grub_datetime *datetime) { struct get_time_args { struct grub_ieee1275_common_hdr common; grub_ieee1275_cell_t method; grub_ieee1275_cell_t device; grub_ieee1275_cell_t catch_result; grub_ieee1275_cell_t year; grub_ieee1275_cell_t month; grub_ieee1275_cell_t day; grub_ieee1275_cell_t hour; grub_ieee1275_cell_t minute; grub_ieee1275_cell_t second; } args; int status; grub_ieee1275_ihandle_t ihandle; if (no_ieee1275_rtc) return grub_get_datetime_cmos (datetime); if (!rtc) find_rtc (); if (!rtc) return grub_get_datetime_cmos (datetime); status = grub_ieee1275_open (rtc, &ihandle); if (status == -1) return grub_error (GRUB_ERR_IO, "couldn't open RTC"); INIT_IEEE1275_COMMON (&args.common, "call-method", 2, 7); args.device = (grub_ieee1275_cell_t) ihandle; args.method = (grub_ieee1275_cell_t) "get-time"; status = IEEE1275_CALL_ENTRY_FN (&args); grub_ieee1275_close (ihandle); if (status == -1 || args.catch_result) return grub_error (GRUB_ERR_IO, "get-time failed"); datetime->year = args.year; datetime->month = args.month; datetime->day = args.day; datetime->hour = args.hour; datetime->minute = args.minute; datetime->second = args.second; return GRUB_ERR_NONE; }
/* Resolve aliases. */ char * grub_ieee1275_canonicalise_devname (const char *path) { struct canon_args { struct grub_ieee1275_common_hdr common; grub_ieee1275_cell_t path; grub_ieee1275_cell_t buf; grub_ieee1275_cell_t inlen; grub_ieee1275_cell_t outlen; } args; char *buf = NULL; grub_size_t bufsize = 64; int i; for (i = 0; i < 2; i++) { grub_free (buf); buf = grub_malloc (bufsize); if (!buf) return NULL; INIT_IEEE1275_COMMON (&args.common, "canon", 3, 1); args.path = (grub_ieee1275_cell_t) path; args.buf = (grub_ieee1275_cell_t) buf; args.inlen = (grub_ieee1275_cell_t) (bufsize - 1); if (IEEE1275_CALL_ENTRY_FN (&args) == -1) return 0; if (args.outlen > bufsize - 1) { bufsize = args.outlen + 2; continue; } return buf; } /* Shouldn't reach here. */ grub_free (buf); return NULL; }
/* Call the "map" method of /chosen/mmu. */ int grub_ieee1275_map (grub_addr_t phys, grub_addr_t virt, grub_size_t size, grub_uint32_t mode) { struct map_args { struct grub_ieee1275_common_hdr common; grub_ieee1275_cell_t method; grub_ieee1275_cell_t ihandle; grub_ieee1275_cell_t mode; grub_ieee1275_cell_t size; grub_ieee1275_cell_t virt; #ifdef GRUB_MACHINE_SPARC64 grub_ieee1275_cell_t phys_high; #endif grub_ieee1275_cell_t phys_low; grub_ieee1275_cell_t catch_result; } args; INIT_IEEE1275_COMMON (&args.common, "call-method", #ifdef GRUB_MACHINE_SPARC64 7, #else 6, #endif 1); args.method = (grub_ieee1275_cell_t) "map"; args.ihandle = grub_ieee1275_mmu; #ifdef GRUB_MACHINE_SPARC64 args.phys_high = 0; #endif args.phys_low = phys; args.virt = virt; args.size = size; args.mode = mode; /* Format is WIMG0PP. */ args.catch_result = (grub_ieee1275_cell_t) -1; if (IEEE1275_CALL_ENTRY_FN (&args) == -1) return -1; return args.catch_result; }
int grub_ieee1275_finddevice (char *name, grub_ieee1275_phandle_t *phandlep) { struct find_device_args { struct grub_ieee1275_common_hdr common; grub_ieee1275_cell_t device; grub_ieee1275_phandle_t phandle; } args; INIT_IEEE1275_COMMON (&args.common, "finddevice", 1, 1); args.device = (grub_ieee1275_cell_t) name; if (IEEE1275_CALL_ENTRY_FN (&args) == -1) return -1; *phandlep = args.phandle; if (args.phandle == IEEE1275_PHANDLE_INVALID) return -1; return 0; }
int grub_ieee1275_parent (grub_ieee1275_phandle_t node, grub_ieee1275_phandle_t *result) { struct parent_args { struct grub_ieee1275_common_hdr common; grub_ieee1275_phandle_t node; grub_ieee1275_phandle_t result; } args; INIT_IEEE1275_COMMON (&args.common, "parent", 1, 1); args.node = node; args.result = IEEE1275_PHANDLE_INVALID; if (IEEE1275_CALL_ENTRY_FN (&args) == -1) return -1; *result = args.result; return 0; }
int grub_ieee1275_alloc_physmem (grub_addr_t *paddr, grub_size_t size, grub_uint32_t align) { grub_uint32_t memory_ihandle; struct alloc_physmem_args { struct grub_ieee1275_common_hdr common; grub_ieee1275_cell_t method; grub_ieee1275_cell_t ihandle; grub_ieee1275_cell_t align; grub_ieee1275_cell_t size; grub_ieee1275_cell_t catch_result; grub_ieee1275_cell_t phys_high; grub_ieee1275_cell_t phys_low; } args; grub_ssize_t actual = 0; grub_ieee1275_get_property (grub_ieee1275_chosen, "memory", &memory_ihandle, sizeof (memory_ihandle), &actual); if (actual != sizeof (memory_ihandle)) return -1; if (!align) align = 1; INIT_IEEE1275_COMMON (&args.common, "call-method", 4, 3); args.method = (grub_ieee1275_cell_t) "claim"; args.ihandle = memory_ihandle; args.align = (align ? align : 1); args.size = size; if (IEEE1275_CALL_ENTRY_FN (&args) == -1) return -1; *paddr = args.phys_low; return args.catch_result; }
grub_err_t grub_ofdisk_get_block_size (const char *device, grub_uint32_t *block_size) { struct size_args_ieee1275 { struct grub_ieee1275_common_hdr common; grub_ieee1275_cell_t method; grub_ieee1275_cell_t ihandle; grub_ieee1275_cell_t result; grub_ieee1275_cell_t size1; grub_ieee1275_cell_t size2; } args_ieee1275; if (last_ihandle) grub_ieee1275_close (last_ihandle); last_ihandle = 0; last_devpath = NULL; grub_ieee1275_open (device, &last_ihandle); if (! last_ihandle) return grub_error (GRUB_ERR_UNKNOWN_DEVICE, "can't open device"); INIT_IEEE1275_COMMON (&args_ieee1275.common, "call-method", 2, 2); args_ieee1275.method = (grub_ieee1275_cell_t) "block-size"; args_ieee1275.ihandle = last_ihandle; args_ieee1275.result = 1; *block_size = GRUB_DISK_SECTOR_SIZE; if ((IEEE1275_CALL_ENTRY_FN (&args_ieee1275) == -1) || (args_ieee1275.result)) grub_dprintf ("disk", "can't get block size\n"); else if (args_ieee1275.size1 && !(args_ieee1275.size1 & (args_ieee1275.size1 - 1)) && args_ieee1275.size1 >= 512 && args_ieee1275.size1 <= 16384) *block_size = args_ieee1275.size1; return 0; }
int grub_ieee1275_instance_to_package (grub_ieee1275_ihandle_t ihandle, grub_ieee1275_phandle_t *phandlep) { struct instance_to_package_args { struct grub_ieee1275_common_hdr common; grub_ieee1275_ihandle_t ihandle; grub_ieee1275_phandle_t phandle; } args; INIT_IEEE1275_COMMON (&args.common, "instance-to-package", 1, 1); args.ihandle = ihandle; if (IEEE1275_CALL_ENTRY_FN (&args) == -1) return -1; *phandlep = args.phandle; if (args.phandle == IEEE1275_PHANDLE_INVALID) return -1; return 0; }
int grub_ieee1275_peer (grub_ieee1275_phandle_t node, grub_ieee1275_phandle_t *result) { struct peer_args { struct grub_ieee1275_common_hdr common; grub_ieee1275_phandle_t node; grub_ieee1275_phandle_t result; } args; INIT_IEEE1275_COMMON (&args.common, "peer", 1, 1); args.node = node; if (IEEE1275_CALL_ENTRY_FN (&args) == -1) return -1; *result = args.result; if (args.result == 0) return -1; return 0; }
grub_uint64_t grub_ieee1275_num_blocks64 (grub_ieee1275_ihandle_t ihandle) { struct nblocks_args_ieee1275 { struct grub_ieee1275_common_hdr common; grub_ieee1275_cell_t method; grub_ieee1275_cell_t ihandle; grub_ieee1275_cell_t catch_result; grub_ieee1275_cell_t hi_blocks; grub_ieee1275_cell_t lo_blocks; } args; INIT_IEEE1275_COMMON (&args.common, "call-method", 2, 3); args.method = (grub_ieee1275_cell_t) "#blocks64"; args.ihandle = ihandle; args.catch_result = 1; if ((IEEE1275_CALL_ENTRY_FN (&args) == -1) || (args.catch_result != 0)) return -1; return ((args.hi_blocks << 32) | (args.lo_blocks)); }
int grub_ieee1275_next_property (grub_ieee1275_phandle_t phandle, char *prev_prop, char *prop) { struct get_property_args { struct grub_ieee1275_common_hdr common; grub_ieee1275_phandle_t phandle; grub_ieee1275_cell_t prev_prop; grub_ieee1275_cell_t next_prop; grub_ieee1275_cell_t flags; } args; INIT_IEEE1275_COMMON (&args.common, "nextprop", 3, 1); args.phandle = phandle; args.prev_prop = (grub_ieee1275_cell_t) prev_prop; args.next_prop = (grub_ieee1275_cell_t) prop; args.flags = (grub_ieee1275_cell_t) -1; if (IEEE1275_CALL_ENTRY_FN (&args) == -1) return -1; return (int) args.flags; }
static void dev_iterate (const struct grub_ieee1275_devalias *alias) { if (grub_strcmp (alias->type, "vscsi") == 0) { static grub_ieee1275_ihandle_t ihandle; struct set_color_args { struct grub_ieee1275_common_hdr common; grub_ieee1275_cell_t method; grub_ieee1275_cell_t ihandle; grub_ieee1275_cell_t catch_result; grub_ieee1275_cell_t nentries; grub_ieee1275_cell_t table; } args; char *buf, *bufptr; unsigned i; if (grub_ieee1275_open (alias->path, &ihandle)) return; INIT_IEEE1275_COMMON (&args.common, "call-method", 2, 3); args.method = (grub_ieee1275_cell_t) "vscsi-report-luns"; args.ihandle = ihandle; args.table = 0; args.nentries = 0; if (IEEE1275_CALL_ENTRY_FN (&args) == -1 || args.catch_result) { grub_ieee1275_close (ihandle); return; } buf = grub_malloc (grub_strlen (alias->path) + 32); if (!buf) return; bufptr = grub_stpcpy (buf, alias->path); for (i = 0; i < args.nentries; i++) { grub_uint64_t *ptr; ptr = *(grub_uint64_t **) (args.table + 4 + 8 * i); while (*ptr) { grub_snprintf (bufptr, 32, "/disk@%" PRIxGRUB_UINT64_T, *ptr++); dev_iterate_real (buf, buf); } } grub_ieee1275_close (ihandle); grub_free (buf); return; } if (!grub_ieee1275_test_flag (GRUB_IEEE1275_FLAG_NO_TREE_SCANNING_FOR_DISKS) && grub_strcmp (alias->type, "block") == 0) { dev_iterate_real (alias->path, alias->path); return; } { struct grub_ieee1275_devalias child; FOR_IEEE1275_DEVCHILDREN(alias->path, child) dev_iterate (&child); } }
static void dev_iterate (const struct grub_ieee1275_devalias *alias) { if (grub_strcmp (alias->type, "vscsi") == 0) { static grub_ieee1275_ihandle_t ihandle; struct set_color_args { struct grub_ieee1275_common_hdr common; grub_ieee1275_cell_t method; grub_ieee1275_cell_t ihandle; grub_ieee1275_cell_t catch_result; grub_ieee1275_cell_t nentries; grub_ieee1275_cell_t table; } args; char *buf, *bufptr; unsigned i; if (grub_ieee1275_open (alias->path, &ihandle)) return; /* This method doesn't need memory allocation for the table. Open firmware takes care of all memory management and the result table stays in memory and is never freed. */ INIT_IEEE1275_COMMON (&args.common, "call-method", 2, 3); args.method = (grub_ieee1275_cell_t) "vscsi-report-luns"; args.ihandle = ihandle; args.table = 0; args.nentries = 0; if (IEEE1275_CALL_ENTRY_FN (&args) == -1 || args.catch_result) { grub_ieee1275_close (ihandle); return; } buf = grub_malloc (grub_strlen (alias->path) + 32); if (!buf) return; bufptr = grub_stpcpy (buf, alias->path); for (i = 0; i < args.nentries; i++) { grub_uint64_t *ptr; ptr = *(grub_uint64_t **) (args.table + 4 + 8 * i); while (*ptr) { grub_snprintf (bufptr, 32, "/disk@%" PRIxGRUB_UINT64_T, *ptr++); dev_iterate_real (buf, buf); } } grub_ieee1275_close (ihandle); grub_free (buf); return; } else if (grub_strcmp (alias->type, "sas_ioa") == 0) { /* The method returns the number of disks and a table where * each ID is 64-bit long. Example of sas paths: * /pci@80000002000001f/pci1014,034A@0/sas/disk@c05db70800 * /pci@80000002000001f/pci1014,034A@0/sas/disk@a05db70800 * /pci@80000002000001f/pci1014,034A@0/sas/disk@805db70800 */ struct sas_children { struct grub_ieee1275_common_hdr common; grub_ieee1275_cell_t method; grub_ieee1275_cell_t ihandle; grub_ieee1275_cell_t max; grub_ieee1275_cell_t table; grub_ieee1275_cell_t catch_result; grub_ieee1275_cell_t nentries; } args; char *buf, *bufptr; unsigned i; grub_uint64_t *table; grub_uint16_t table_size; grub_ieee1275_ihandle_t ihandle; buf = grub_malloc (grub_strlen (alias->path) + sizeof ("/disk@7766554433221100")); if (!buf) return; bufptr = grub_stpcpy (buf, alias->path); /* Power machines documentation specify 672 as maximum SAS disks in one system. Using a slightly larger value to be safe. */ table_size = 768; table = grub_malloc (table_size * sizeof (grub_uint64_t)); if (!table) { grub_free (buf); return; } if (grub_ieee1275_open (alias->path, &ihandle)) { grub_free (buf); grub_free (table); return; } INIT_IEEE1275_COMMON (&args.common, "call-method", 4, 2); args.method = (grub_ieee1275_cell_t) "get-sas-children"; args.ihandle = ihandle; args.max = table_size; args.table = (grub_ieee1275_cell_t) table; args.catch_result = 0; args.nentries = 0; if (IEEE1275_CALL_ENTRY_FN (&args) == -1) { grub_ieee1275_close (ihandle); grub_free (table); grub_free (buf); return; } for (i = 0; i < args.nentries; i++) { grub_snprintf (bufptr, sizeof ("/disk@7766554433221100"), "/disk@%" PRIxGRUB_UINT64_T, table[i]); dev_iterate_real (buf, buf); } grub_ieee1275_close (ihandle); grub_free (table); grub_free (buf); } if (!grub_ieee1275_test_flag (GRUB_IEEE1275_FLAG_NO_TREE_SCANNING_FOR_DISKS) && grub_strcmp (alias->type, "block") == 0) { dev_iterate_real (alias->path, alias->path); return; } { struct grub_ieee1275_devalias child; FOR_IEEE1275_DEVCHILDREN(alias->path, child) dev_iterate (&child); } }
static void scan (void) { auto int dev_iterate_real (const char *name, const char *path); int dev_iterate_real (const char *name, const char *path) { struct ofdisk_hash_ent *op; grub_dprintf ("disk", "disk name = %s, path = %s\n", name, path); op = ofdisk_hash_find (path); if (!op) { char *name_dup = grub_strdup (name); char *can = grub_strdup (path); if (!name_dup || !can) { grub_errno = GRUB_ERR_NONE; grub_free (name_dup); grub_free (can); return 0; } op = ofdisk_hash_add (name_dup, can); } return 0; } auto int dev_iterate_alias (struct grub_ieee1275_devalias *alias); int dev_iterate_alias (struct grub_ieee1275_devalias *alias) { if (grub_strcmp (alias->type, "block") != 0) return 0; return dev_iterate_real (alias->name, alias->path); } auto int dev_iterate (struct grub_ieee1275_devalias *alias); int dev_iterate (struct grub_ieee1275_devalias *alias) { if (grub_strcmp (alias->type, "vscsi") == 0) { static grub_ieee1275_ihandle_t ihandle; struct set_color_args { struct grub_ieee1275_common_hdr common; grub_ieee1275_cell_t method; grub_ieee1275_cell_t ihandle; grub_ieee1275_cell_t catch_result; grub_ieee1275_cell_t nentries; grub_ieee1275_cell_t table; } args; char *buf, *bufptr; unsigned i; if (grub_ieee1275_open (alias->path, &ihandle)) return 0; INIT_IEEE1275_COMMON (&args.common, "call-method", 2, 3); args.method = (grub_ieee1275_cell_t) "vscsi-report-luns"; args.ihandle = ihandle; args.table = 0; args.nentries = 0; if (IEEE1275_CALL_ENTRY_FN (&args) == -1) { grub_ieee1275_close (ihandle); return 0; } buf = grub_malloc (grub_strlen (alias->path) + 32); if (!buf) return 0; bufptr = grub_stpcpy (buf, alias->path); for (i = 0; i < args.nentries; i++) { grub_uint64_t *ptr; ptr = *(grub_uint64_t **) (args.table + 4 + 8 * i); while (*ptr) { grub_snprintf (bufptr, 32, "/disk@%" PRIxGRUB_UINT64_T, *ptr++); if (dev_iterate_real (buf, buf)) return 1; } } grub_ieee1275_close (ihandle); grub_free (buf); return 0; } if (!grub_ieee1275_test_flag (GRUB_IEEE1275_FLAG_NO_TREE_SCANNING_FOR_DISKS) && grub_strcmp (alias->type, "block") == 0) return dev_iterate_real (alias->path, alias->path); return grub_children_iterate (alias->path, dev_iterate); } grub_devalias_iterate (dev_iterate_alias); grub_children_iterate ("/", dev_iterate); }