free_super after assembling a container

[thirdparty/mdadm.git] / platform-intel.c

diff --git a/platform-intel.c b/platform-intel.c
index 03e4ba79608ba694d6e80c1733bbf1ffaba80d8b..3516a1b68f5c74cc7cf7ae853dbd98932605f729 100644 (file)
--- a/platform-intel.c
+++ b/platform-intel.c
@@ -44,32 +44,51 @@ void free_sys_dev(struct sys_dev **list)
 struct sys_dev *find_driver_devices(const char *bus, const char *driver)
 {
        /* search sysfs for devices driven by 'driver' */
-       char path[256];
+       char path[292];
        char link[256];
        char *c;
        DIR *driver_dir;
        struct dirent *de;
        struct sys_dev *head = NULL;
        struct sys_dev *list = NULL;
+       enum sys_dev_type type;
+
+       if (strcmp(driver, "isci") == 0)
+               type = SYS_DEV_SAS;
+       else if (strcmp(driver, "ahci") == 0)
+               type = SYS_DEV_SATA;
+       else
+               type = SYS_DEV_UNKNOWN;
 
        sprintf(path, "/sys/bus/%s/drivers/%s", bus, driver);
        driver_dir = opendir(path);
        if (!driver_dir)
                return NULL;
        for (de = readdir(driver_dir); de; de = readdir(driver_dir)) {
+               int n;
+
                /* is 'de' a device? check that the 'subsystem' link exists and
                 * that its target matches 'bus'
                 */
                sprintf(path, "/sys/bus/%s/drivers/%s/%s/subsystem",
                        bus, driver, de->d_name);
-               if (readlink(path, link, sizeof(link)) < 0)
+               n = readlink(path, link, sizeof(link));
+               if (n < 0 || n >= (int)sizeof(link))
                        continue;
+               link[n] = '\0';
                c = strrchr(link, '/');
                if (!c)
                        continue;
                if (strncmp(bus, c+1, strlen(bus)) != 0)
                        continue;
 
+               sprintf(path, "/sys/bus/%s/drivers/%s/%s",
+                       bus, driver, de->d_name);
+
+               /* if it's not Intel device skip it. */
+               if (devpath_to_vendor(path) != 0x8086)
+                       continue;
+
                /* start / add list entry */
                if (!head) {
                        head = malloc(sizeof(*head));
@@ -84,13 +103,13 @@ struct sys_dev *find_driver_devices(const char *bus, const char *driver)
                        break;
                }
 
-               /* generate canonical path name for the device */
-               sprintf(path, "/sys/bus/%s/drivers/%s/%s",
-                       bus, driver, de->d_name);
+               list->type = type;
                list->path = canonicalize_file_name(path);
                list->next = NULL;
+               if ((list->pci_id = strrchr(list->path, '/')) != NULL)
+                       list->pci_id++;
        }
-
+       closedir(driver_dir);
        return head;
 }
 
@@ -118,23 +137,34 @@ __u16 devpath_to_vendor(const char *dev_path)
        return id;
 }
 
-static int platform_has_intel_ahci(void)
+struct sys_dev *find_intel_devices(void)
 {
-       struct sys_dev *devices = find_driver_devices("pci", "ahci");
-       struct sys_dev *dev;
-       int ret = 0;
-
-       for (dev = devices; dev; dev = dev->next)
-               if (devpath_to_vendor(dev->path) == 0x8086) {
-                       ret = 1;
-                       break;
-               }
-
-       free_sys_dev(&devices);
-
-       return ret;
+       struct sys_dev *ahci, *isci;
+
+       isci = find_driver_devices("pci", "isci");
+       ahci = find_driver_devices("pci", "ahci");
+
+       if (!ahci) {
+               ahci = isci;
+       } else {
+               struct sys_dev *elem = ahci;
+               while (elem->next)
+                       elem = elem->next;
+               elem->next = isci;
+       }
+       return ahci;
 }
 
+static int platform_has_intel_devices(void)
+{
+       struct sys_dev *devices;
+       devices = find_intel_devices();
+       if (devices) {
+               free_sys_dev(&devices);
+               return 1;
+       }
+       return 0;
+}
 
 static struct imsm_orom imsm_orom;
 static int scan(const void *start, const void *end)
@@ -157,16 +187,39 @@ static int scan(const void *start, const void *end)
 const struct imsm_orom *find_imsm_orom(void)
 {
        static int populated = 0;
+       unsigned long align;
 
        /* it's static data so we only need to read it once */
        if (populated)
                return &imsm_orom;
 
-       if (!platform_has_intel_ahci())
+       if (check_env("IMSM_TEST_OROM")) {
+               memset(&imsm_orom, 0, sizeof(imsm_orom));
+               imsm_orom.rlc = IMSM_OROM_RLC_RAID0 | IMSM_OROM_RLC_RAID1 |
+                               IMSM_OROM_RLC_RAID10 | IMSM_OROM_RLC_RAID5;
+               imsm_orom.sss = IMSM_OROM_SSS_4kB | IMSM_OROM_SSS_8kB |
+                               IMSM_OROM_SSS_16kB | IMSM_OROM_SSS_32kB |
+                               IMSM_OROM_SSS_64kB | IMSM_OROM_SSS_128kB |
+                               IMSM_OROM_SSS_256kB | IMSM_OROM_SSS_512kB |
+                               IMSM_OROM_SSS_1MB | IMSM_OROM_SSS_2MB;
+               imsm_orom.dpa = 6;
+               imsm_orom.tds = 6;
+               imsm_orom.vpa = 2;
+               imsm_orom.vphba = 4;
+               imsm_orom.attr = imsm_orom.rlc | IMSM_OROM_ATTR_ChecksumVerify;
+               populated = 1;
+               return &imsm_orom;
+       }
+
+       if (!platform_has_intel_devices())
                return NULL;
 
        /* scan option-rom memory looking for an imsm signature */
-       if (probe_roms_init() != 0)
+       if (check_env("IMSM_SAFE_OROM_SCAN"))
+               align = 2048;
+       else
+               align = 512;
+       if (probe_roms_init(align) != 0)
                return NULL;
        probe_roms();
        populated = scan_adapter_roms(scan);
@@ -179,13 +232,13 @@ const struct imsm_orom *find_imsm_orom(void)
 
 char *devt_to_devpath(dev_t dev)
 {
-       char device[40];
+       char device[46];
 
        sprintf(device, "/sys/dev/block/%d:%d/device", major(dev), minor(dev));
        return canonicalize_file_name(device);
 }
 
-static char *diskfd_to_devpath(int fd)
+char *diskfd_to_devpath(int fd)
 {
        /* return the device path for a disk, return NULL on error or fd
         * refers to a partition
@@ -206,7 +259,7 @@ int path_attached_to_hba(const char *disk_path, const char *hba_path)
 
        if (!disk_path || !hba_path)
                return 0;
-
+       dprintf("hba: %s - disk: %s\n", hba_path, disk_path);
        if (strncmp(disk_path, hba_path, strlen(hba_path)) == 0)
                rc = 1;
        else
@@ -236,4 +289,3 @@ int disk_attached_to_hba(int fd, const char *hba_path)
 
        return rc;
 }
-