static char * get_dm_uuid (const char *os_dev) { struct dm_tree *tree; struct dm_tree_node *node; const char *node_uuid; char *ret; if (!grub_util_open_dm (os_dev, &tree, &node)) return NULL; node_uuid = dm_tree_node_get_uuid (node); if (! node_uuid) { grub_dprintf ("hostdisk", "%s has no DM uuid\n", os_dev); dm_tree_free (tree); return NULL; } ret = grub_strdup (node_uuid); dm_tree_free (tree); return ret; }
int dm_device_remove_all(uint64_t *dev) { struct bl_dm_tree *p; struct dm_tree_node *node; const char *uuid; int ret = 0; uint32_t major, minor; uint64_t bl_dev; memcpy(&major, dev, sizeof(uint32_t)); memcpy(&minor, (void *)dev + sizeof(uint32_t), sizeof(uint32_t)); bl_dev = MKDEV(major, minor); p = find_bl_dm_tree(bl_dev); if (!p) return ret; node = dm_tree_find_node(p->tree, MAJOR(bl_dev), MINOR(bl_dev)); if (!node) return ret; uuid = dm_tree_node_get_uuid(node); if (!uuid) return ret; dm_device_remove(bl_dev); ret = dm_tree_deactivate_children(node, uuid, strlen(uuid)); dm_task_update_nodes(); bl_dm_remove_tree(bl_dev); return ret; }
void grub_util_iterate_devices (int NESTED_FUNC_ATTR (*hook) (const char *, int), int floppy_disks) { int i; clear_seen_devices (); /* Floppies. */ for (i = 0; i < floppy_disks; i++) { char name[16]; struct stat st; get_floppy_disk_name (name, i); if (stat (name, &st) < 0) break; /* In floppies, write the map, whether check_device_readable_unique succeeds or not, because the user just may not insert floppies. */ if (hook (name, 1)) goto out; } #ifdef __linux__ { DIR *dir = opendir ("/dev/disk/by-id"); if (dir) { struct dirent *entry; struct device *devs; size_t devs_len = 0, devs_max = 1024, i; devs = xmalloc (devs_max * sizeof (*devs)); /* Dump all the directory entries into names, resizing if necessary. */ for (entry = readdir (dir); entry; entry = readdir (dir)) { /* Skip current and parent directory entries. */ if (strcmp (entry->d_name, ".") == 0 || strcmp (entry->d_name, "..") == 0) continue; /* Skip partition entries. */ if (strstr (entry->d_name, "-part")) continue; /* Skip device-mapper entries; we'll handle the ones we want later. */ if (strncmp (entry->d_name, "dm-", sizeof ("dm-") - 1) == 0) continue; /* Skip RAID entries; they are handled by upper layers. */ if (strncmp (entry->d_name, "md-", sizeof ("md-") - 1) == 0) continue; if (devs_len >= devs_max) { devs_max *= 2; devs = xrealloc (devs, devs_max * sizeof (*devs)); } devs[devs_len].stable = xasprintf ("/dev/disk/by-id/%s", entry->d_name); devs[devs_len].kernel = canonicalize_file_name (devs[devs_len].stable); devs_len++; } qsort (devs, devs_len, sizeof (*devs), &compare_devices); closedir (dir); /* Now add all the devices in sorted order. */ for (i = 0; i < devs_len; ++i) { if (check_device_readable_unique (devs[i].stable)) { if (hook (devs[i].stable, 0)) goto out; } free (devs[i].stable); free (devs[i].kernel); } free (devs); } } if (have_devfs ()) { i = 0; while (1) { char discn[32]; char name[PATH_MAX]; struct stat st; /* Linux creates symlinks "/dev/discs/discN" for convenience. The way to number disks is the same as GRUB's. */ sprintf (discn, "/dev/discs/disc%d", i++); if (stat (discn, &st) < 0) break; if (realpath (discn, name)) { strcat (name, "/disc"); if (hook (name, 0)) goto out; } } goto out; } #endif /* __linux__ */ /* IDE disks. */ for (i = 0; i < 96; i++) { char name[16]; get_ide_disk_name (name, i); if (check_device_readable_unique (name)) { if (hook (name, 0)) goto out; } } #ifdef __FreeBSD_kernel__ /* IDE disks using ATA Direct Access driver. */ if (get_kfreebsd_version () >= 800000) for (i = 0; i < 96; i++) { char name[16]; get_ada_disk_name (name, i); if (check_device_readable_unique (name)) { if (hook (name, 0)) goto out; } } /* ATARAID disks. */ for (i = 0; i < 8; i++) { char name[20]; get_ataraid_disk_name (name, i); if (check_device_readable_unique (name)) { if (hook (name, 0)) goto out; } } #endif #ifdef __linux__ /* Virtio disks. */ for (i = 0; i < 26; i++) { char name[16]; get_virtio_disk_name (name, i); if (check_device_readable_unique (name)) { if (hook (name, 0)) goto out; } } /* ATARAID disks. */ for (i = 0; i < 8; i++) { char name[20]; get_ataraid_disk_name (name, i); if (check_device_readable_unique (name)) { if (hook (name, 0)) goto out; } } /* Xen virtual block devices. */ for (i = 0; i < 26; i++) { char name[16]; get_xvd_disk_name (name, i); if (check_device_readable_unique (name)) { if (hook (name, 0)) goto out; } } #endif /* __linux__ */ /* The rest is SCSI disks. */ for (i = 0; i < 48; i++) { char name[16]; get_scsi_disk_name (name, i); if (check_device_readable_unique (name)) { if (hook (name, 0)) goto out; } } #ifdef __linux__ /* This is for DAC960 - we have /dev/rd/c<controller>d<logical drive>p<partition>. DAC960 driver currently supports up to 8 controllers, 32 logical drives, and 7 partitions. */ { int controller, drive; for (controller = 0; controller < 8; controller++) { for (drive = 0; drive < 15; drive++) { char name[24]; get_dac960_disk_name (name, controller, drive); if (check_device_readable_unique (name)) { if (hook (name, 0)) goto out; } } } } /* This is for Mylex Acceleraid - we have /dev/rd/c<controller>d<logical drive>p<partition>. */ { int controller, drive; for (controller = 0; controller < 8; controller++) { for (drive = 0; drive < 15; drive++) { char name[24]; get_acceleraid_disk_name (name, controller, drive); if (check_device_readable_unique (name)) { if (hook (name, 0)) goto out; } } } } /* This is for CCISS - we have /dev/cciss/c<controller>d<logical drive>p<partition>. */ { int controller, drive; for (controller = 0; controller < 3; controller++) { for (drive = 0; drive < 16; drive++) { char name[24]; get_cciss_disk_name (name, controller, drive); if (check_device_readable_unique (name)) { if (hook (name, 0)) goto out; } } } } /* This is for Compaq Intelligent Drive Array - we have /dev/ida/c<controller>d<logical drive>p<partition>. */ { int controller, drive; for (controller = 0; controller < 3; controller++) { for (drive = 0; drive < 16; drive++) { char name[24]; get_ida_disk_name (name, controller, drive); if (check_device_readable_unique (name)) { if (hook (name, 0)) goto out; } } } } /* This is for I2O - we have /dev/i2o/hd<logical drive><partition> */ { char unit; for (unit = 'a'; unit < 'f'; unit++) { char name[24]; get_i2o_disk_name (name, unit); if (check_device_readable_unique (name)) { if (hook (name, 0)) goto out; } } } /* MultiMediaCard (MMC). */ for (i = 0; i < 10; i++) { char name[16]; get_mmc_disk_name (name, i); if (check_device_readable_unique (name)) { if (hook (name, 0)) goto out; } } # ifdef HAVE_DEVICE_MAPPER # define dmraid_check(cond, ...) \ if (! (cond)) \ { \ grub_dprintf ("deviceiter", __VA_ARGS__); \ goto dmraid_end; \ } /* DM-RAID. */ if (grub_device_mapper_supported ()) { struct dm_tree *tree = NULL; struct dm_task *task = NULL; struct dm_names *names = NULL; unsigned int next = 0; void *top_handle, *second_handle; struct dm_tree_node *root, *top, *second; /* Build DM tree for all devices. */ tree = dm_tree_create (); dmraid_check (tree, "dm_tree_create failed\n"); task = dm_task_create (DM_DEVICE_LIST); dmraid_check (task, "dm_task_create failed\n"); dmraid_check (dm_task_run (task), "dm_task_run failed\n"); names = dm_task_get_names (task); dmraid_check (names, "dm_task_get_names failed\n"); dmraid_check (names->dev, "No DM devices found\n"); do { names = (void *) names + next; dmraid_check (dm_tree_add_dev (tree, MAJOR (names->dev), MINOR (names->dev)), "dm_tree_add_dev (%s) failed\n", names->name); next = names->next; } while (next); /* Walk the second-level children of the inverted tree; that is, devices which are directly composed of non-DM devices such as hard disks. This class includes all DM-RAID disks and excludes all DM-RAID partitions. */ root = dm_tree_find_node (tree, 0, 0); top_handle = NULL; top = dm_tree_next_child (&top_handle, root, 1); while (top) { second_handle = NULL; second = dm_tree_next_child (&second_handle, top, 1); while (second) { const char *node_name, *node_uuid; char *name; node_name = dm_tree_node_get_name (second); dmraid_check (node_name, "dm_tree_node_get_name failed\n"); node_uuid = dm_tree_node_get_uuid (second); dmraid_check (node_uuid, "dm_tree_node_get_uuid failed\n"); if (strncmp (node_uuid, "DMRAID-", 7) != 0) { grub_dprintf ("deviceiter", "%s is not DM-RAID\n", node_name); goto dmraid_next_child; } name = xasprintf ("/dev/mapper/%s", node_name); if (check_device_readable_unique (name)) { if (hook (name, 0)) { free (name); if (task) dm_task_destroy (task); if (tree) dm_tree_free (tree); goto out; } } free (name); dmraid_next_child: second = dm_tree_next_child (&second_handle, top, 1); } top = dm_tree_next_child (&top_handle, root, 1); } dmraid_end: if (task) dm_task_destroy (task); if (tree) dm_tree_free (tree); } # endif /* HAVE_DEVICE_MAPPER */ #endif /* __linux__ */ out: clear_seen_devices (); }