elxu_linux.c

Go to the documentation of this file.

/*
 * Copyright (c) 2011-2015, Emulex
 * All rights reserved.
 *
 * 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. Neither the name of the copyright holder nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 THE COPYRIGHT HOLDER OR CONTRIBUTORS 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.
 *
 */

#define _GNU_SOURCE
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <stdarg.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <assert.h>
#include <string.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <dirent.h>
#include <unistd.h>
#include <fts.h>
#include <errno.h>

#include <ocs_ioctl.h>

#include <elxu_device.h>
#include <elxu_sli4.h>
#include <elxu_mbox.h>
#include "elxu_common.h"
#include "elx_pt_ioctl.h"

#include <ocsu_io.h>

#define MAXDEVS 1024
#define ELX_PT_SERIAL_NUM_SIZE 32

/*
 * This file contains functions specific to Linux.
 * Any non-static functions here should:
 *  - be declared in elxu_common.h
 *  - have an equivalent in elxu_bsd.c, even if it's a stub
 */

static char* format_ip_address(uint8_t *address, uint8_t address_type);
static void pt_device_init(elxu_device_t *device);

static int os_create_device_files(char *driver_path)
{
    int major;
    int count;
    int total;
    int rc;
    FILE *proc_file;
    int idx;
    char path[FILENAME_MAX];
    FTS *ftsp;
    FTSENT *ftsent;
    FTSENT *chp;
    char  *dirs[2];
    char *drv;
    char *p;

    if (driver_path)
        dirs[0] = driver_path;
    else
        dirs[0] = "/proc";

    dirs[1] = NULL;

    ftsp = fts_open(dirs, FTS_COMFOLLOW | FTS_NOCHDIR, NULL);
    if (ftsp == NULL) {
        // can't initialize fts
        return -1;
    }
    chp = fts_children(ftsp, 0);
    if (chp == NULL) {
        // child initialization failed
        return -1;
    }

    /*
     * Bug 181400 - Remove any device special files before creating new ones.
     *              Since drivers can be unloaded, then we must walk the /dev/ocs_XX and remove
     *              all that exist and then recreate them.
     */
    total = 0;
    do {
        snprintf(path, sizeof(path), "/dev/%s_%d", "ocs", total);
        rc = remove(path);
        if (rc != 0 && errno != ENOENT) {
            perror("Error removing /dev/ocs*\n");
        }
        total++;
    } while (rc == 0);

    total = 0;
    while((ftsent = fts_read(ftsp)) != NULL) {
        if (ftsent->fts_info != FTS_F) {
            continue;
        }
        if (strncmp(ftsent->fts_path, "/proc/ocs", strlen("/proc/ocs"))) {
            continue;
        }

        /*
         * Don't process /proc/ocsu.  That's for the user space shim, and
         * we don't want to access those directly.
         */
        if (strncmp(ftsent->fts_path, "/proc/ocsu", strlen("/proc/ocsu")) == 0) {
            continue;
        }

        proc_file = fopen(ftsent->fts_path, "r");

        if (proc_file == NULL) {
            // Can't open /proc/ocs to get driver info
            return -1;
        }

        rc = fscanf(proc_file, "%d,%d", &major, &count);
        fclose(proc_file);

        if (rc != 2) {
            // Didn't get major and count from /proc/ocs
            return -1;
        }
        drv = strdup(ftsent->fts_path + strlen("/proc/"));
        if (drv == NULL)  {
            // Allocation failed
            return -1;
        }

        if ((p = strchr(drv, '_'))) {
            *p = 0;
        }

        for (idx = 0; idx < count; idx ++) {
            snprintf(path, sizeof(path), "/dev/%s_%d", drv, total);
            // Try to make the device file.  If it fails, ignore the error and continue.
            rc = mknod(path, S_IFCHR | 0644, makedev(major, idx));
            if (rc) {
                printf("Failed creating %s\n", path);
                perror("Error =\n");
            }
            total++;
        }
        free(drv);
    }
    return 0;
}

/**
 * @ingroup dev_mgmt
 * @brief  Build a list of devices
 *
 * @par Description
 * This function locates all devices on the system that the utility can manage
 * and builds the device list.  It is only concerned with devices accessed directly
 * through the PCI bus, not with user space devices accessed through sockets.
 *
 * For each Emulex device found on the bus it will determine the driver controlling
 * the device, and will only add the device to the list if the driver is either one
 * of the ocs_* drivers or is elx_pt.
 *
 * @return Returns a pointer to the first device in the list.  May be NULL if no
 * devices are found.
 */
elxu_device_t *os_build_device_list(char *path)
{
    DIR *pci_dir;
    struct dirent *entry;
    elxu_device_t *new_device;
    elxu_device_t *list;
    char config_file_name[1024];
    int config_file;
    char driver_link_name[1024];
    char driver_path[1024];
    char *driver_name;
    uint16_t vendor_id;
    uint16_t device_id;
    int n;
    int next_index;
    int ocs_index;

    pci_dir = opendir("/sys/bus/pci/devices");
    if (pci_dir == NULL) {
        return NULL;
    }

    /* Create device files for OCS drivers, if needed */
    os_create_device_files(path);

    list = NULL;
    next_index=0;

    /*
     * Find OCS devices first, so that instance numbers agree with
     * /dev/ocs_* filenames (for backwards compatibility).
     */
    ocs_index = 0;
    while (1) {
        char device_file_name[256];
        int fd;
        int rc;
        ocs_ioctl_driver_info_t info;

        sprintf(device_file_name, "/dev/ocs_%d", ocs_index);
        fd = open(device_file_name, O_RDONLY);
        if (fd < 0) {
            break;
        }

        rc = ioctl(fd, OCS_IOCTL_CMD_DRIVER_INFO, &info);
        if (rc == 0) {
            new_device = malloc(sizeof(elxu_device_t));
            /* Should check for malloc failure here */
            bzero(new_device, sizeof(*new_device));

            /* Add the device to the global list */
            new_device->next = list;
            list = new_device;

            new_device->driver = DEVICE_DRIVER_OCS;
            strcpy(new_device->device_file_name, device_file_name);
            new_device->vendor = info.pci_vendor;
            new_device->device = info.pci_device;
            strcpy(new_device->bus_addr, info.businfo);
            new_device->type = DEVICE_TYPE_UNKNOWN;
            set_protocol(new_device);
            new_device->deviceIndex = next_index++;
        }

        ++ocs_index;
        close(fd);
    }

    /*
     * Now scan the PCI devices for any other devices we want to manage.
     */
    while ((entry = readdir(pci_dir))) {
        snprintf(config_file_name, sizeof(config_file_name),
             "/sys/bus/pci/devices/%s/config", entry->d_name);
        config_file = open(config_file_name, O_RDWR);
        if (config_file < 0) {
            continue;
        }
        if ((read(config_file, &vendor_id, sizeof(vendor_id)) < sizeof(vendor_id)) ||
            (read(config_file, &device_id, sizeof(device_id)) < sizeof(device_id))) {
            fprintf(stderr , "couldn't read vendor ID or device ID");
        }
        if (vendor_id == PCI_VENDOR_ID_EMULEX) {
            new_device = malloc(sizeof(elxu_device_t));
            /* Should check for malloc failure here */
            bzero(new_device, sizeof(*new_device));

            /* Add the device to the global list */
            new_device->next = list;
            list = new_device;

            /* Fill in information which applies to all drivers */
            new_device->vendor = vendor_id;
            new_device->device = device_id;
            strcpy(new_device->bus_addr, entry->d_name);
            set_protocol(new_device);
            new_device->deviceIndex = next_index++;

            /* Figure out the driver */
            snprintf(driver_link_name, sizeof(driver_link_name),
                 "/sys/bus/pci/devices/%s/driver", entry->d_name);
            n = readlink(driver_link_name, driver_path, sizeof(driver_path) - 1);

            /*
             * Take driver specific actions, including possibly removing the
             * device from the list if it's not a driver we handle.
             */
            if (n < 0) {
                /*
                 * If we support CSII (mailbox access with no driver) in the
                 * future then we'll keep this device and mark it with
                 * DEVICE_DRIVER_NONE.  For now we'll just take it off the list.
                 */
                list = new_device->next;
                --next_index;
                free(new_device);
            } else {
                driver_path[n] = '\0';
                driver_name = strrchr(driver_path, '/') + 1;
                if (strncmp(driver_name, "ocs_", 4) == 0) {
                    /* OCS drivers were handled already */
                    list = new_device->next;
                    --next_index;
                    free(new_device);
                } else if (strcmp(driver_name, "elx_pt") == 0) {
                    pt_device_init(new_device);
                } else if (strcmp(driver_name, "be2net") == 0) {
                    /*
                     * If we support be2net passthrough in the future
                     * we'll keep this device and mark it with DEVICE_DRIVER_BE2NET.
                     * For now we'll just take it off the list.
                     */
                    list = new_device->next;
                    --next_index;
                    free(new_device);
                } else {
                    /*
                     * If it has a driver we don't recognize (lpfc?) we just
                     * ignore it.
                     */
                    list = new_device->next;
                    --next_index;
                    free(new_device);
                }
            }
        }
    }
    closedir(pci_dir);
    return list;
}

elxu_device_t *os_build_device_list_uspace(char *hostname)
{
    int devidx = 0;
    elxu_device_t *device_p;
    elxu_device_t *list;
    void *desc;

    list = NULL;

    while(1) {
        ocs_ioctl_driver_info_t info;
        int rc;

        desc = ocsu_open(hostname, devidx);
        if (desc == NULL) {
            break;
        }

        device_p = malloc(sizeof(elxu_device_t));
        /* Should check for malloc failure here */
        memset(device_p, '\0', sizeof(*device_p));

        snprintf(device_p->device_file_name, sizeof(device_p->device_file_name),
              "%s[%d]", hostname, devidx);
        device_p->desc = desc;
        device_p->driver = DEVICE_DRIVER_OCS;
        rc = ocsu_ioctl(desc, OCS_IOCTL_CMD_DRIVER_INFO, &info);
        if (rc == 0) {
            device_p->vendor = info.pci_vendor;
            device_p->device = info.pci_device;
            strncpy(device_p->bus_addr, info.businfo, sizeof(device_p->bus_addr));
        }

        device_p->type = DEVICE_TYPE_UNKNOWN;
        set_protocol(device_p);
        fill_device_details(device_p);

        device_p->next = list;
        list = device_p;
        device_p->deviceIndex = devidx;
        ++devidx;

        ocsu_close(device_p->desc);
    }

    return list;
}

static void pt_device_init(elxu_device_t *device)
{
    int major;
    int minor;
    char driver_name[80];
    char line[80];
    FILE *proc_file;
    char dev_file_name[80];
    int i;
    int fd;
    int rc;
    elx_pt_ioctl_info_t info;
    char *serial_num = NULL;

    /* Get major number from /proc/devices */
    proc_file = fopen("/proc/devices", "r");
    if (proc_file == NULL) {
        return;
    }

    major = -1;
    while (fgets(line, sizeof(line), proc_file)) {
        if (strstr(line, "elx_pt")) {
            sscanf(line, "%d %s", &i, driver_name);
            if (strcmp(driver_name, "elx_pt") == 0) {
                major = i;
                break;
            }
        }
    }
    fclose(proc_file);
    if (major == -1) {
        return;
    }

    /* Try each minor number */
    for (minor=0; minor<MAXDEVS; minor++) {
        /* Open the device file, creating it if necessary */
        snprintf(dev_file_name, sizeof(dev_file_name), "/dev/elx_pt%d", minor);
        fd = open(dev_file_name, O_RDWR);       
        if (fd < 0) {
            if (errno == EBUSY) {
                perror("Device");
                device->fd = -1;
                return;
            }
            rc = mknod(dev_file_name, S_IFCHR, makedev(major, minor));
            if (rc != 0) {
                return;
            }
            fd = open(dev_file_name, O_RDWR);
            if (fd < 0) {
                return;
            }
        }

        device->fd = fd;

        /* Get driver info from the device file */
        bzero(&info, sizeof(info));
        rc = ioctl(fd, IOCTL_CMD_ELX_PT_GET_INFO, &info);
        if (rc != 0) {
            close(fd);
            device->fd = -1;
            continue;
        }

        /* See if this device is the correct one */
        if (strcmp(info.bus_addr, device->bus_addr) == 0) {
            sli4_res_common_get_cntl_attributes_t attr;
            elx_pt_ioctl_mbox_t mbox;

            strcpy(device->device_file_name, dev_file_name);
            device->vendor = info.vendor;
            device->device = info.device;
            device->asic_id = info.asic_id;
            device->sli_intf = info.sli_intf;
            device->driver = DEVICE_DRIVER_PT;

            bzero(&attr, sizeof(attr));
            attr.hdr.req.subsystem = MBOX_SUBSYSTEM_COMMON;
            attr.hdr.req.opcode = OPCODE_COMMON_GET_CNTL_ATTRIBUTES;
            attr.hdr.req.request_length = sizeof(attr);

            mbox.words = (uint32_t *)&attr;
            mbox.num_words = (sizeof(attr) + 3) / 4;

            rc = ioctl(fd, IOCTL_CMD_ELX_PT_MBOX, &mbox);
            if (rc == 0) {
                device->modeldesc = strdup((char *)attr.controller_description);
                strcpy(device->fwrev, (char *)attr.firmware_version_string);
                if (is_iscsi(device) || is_nic(device)) {
                    device->serialnum = strdup((char *)attr.controller_serial_number);
                }
                if (is_fc(device)) {
                    serial_num = zmalloc(ELX_PT_SERIAL_NUM_SIZE);
                    if (serial_num) {
                        mbox_get_serialnum_pt(device, serial_num, ELX_PT_SERIAL_NUM_SIZE);
                        device->serialnum = strdup((char *)serial_num);
                    } else {
                        device->serialnum = NULL;
                    }
                }
            }

            if (is_iscsi(device) || is_nic(device)) {
                mbox_get_mac_pt(device, device->mac_addr);
            }
            if (is_fc(device)) {
                mbox_get_wwn_pt(fd, device->wwnn, device->wwpn);
            }

            device->fd = -1;
            if (serial_num)
                free(serial_num);
            close(fd);
            return;
        }

        device->fd = -1;
        close(fd);
        if (serial_num)
            free(serial_num);
    }
}

elxu_device_t *os_open_device(elxu_device_name_t *devname)
{
    elxu_device_t *device = NULL;
    char path[FILENAME_MAX];

    device = elxu_device_by_index(devname->devidx);

    if (device == NULL) {
        /* Device index not found in list */
        return NULL;
    }

    /* if devname->hostname is non-null, then open device special file, otherwise
     * open a socket.
     */

    if (devname->hostname == NULL) {
        /* Open device */
        device->fd = open(device->device_file_name, O_RDWR);

        if (device->fd < 0) {
            return NULL;
        }
    } else {
        device->desc = ocsu_open(devname->hostname, devname->devidx);
        if (device->desc == NULL) {
            return NULL;
        }
        snprintf(path, sizeof(path), "%s[%d]", devname->hostname, devname->devidx);
        strncpy(device->device_file_name, path , sizeof(device->device_file_name) - 1);
    }

    return device;
}

int os_ioctl_device(elxu_device_t *device, int req, void *arg)
{
    int rc;

    if (device->desc != NULL) {
        rc = ocsu_ioctl(device->desc, req, arg);
    } else {
        rc = ioctl(device->fd, req, arg);
    }
    return rc;
}

void os_close_device(elxu_device_t *device)
{
    if (device->desc != NULL) {
        ocsu_close(device->desc);
    } else {
        close(device->fd);
    }
}

int os_remove_device(elxu_device_t *device)
{
    return remove(device->device_file_name);
}

void elxu_get_connection_info(elxu_device_t *device)
{
#define MAX_CONNECTIONS 256
        ocs_ioctl_connection_info_t *info = calloc(MAX_CONNECTIONS, sizeof(*info));
        ocs_ioctl_connections_t req;
        int rval;
        int i;

        req.connections = info;
        req.max_connections = MAX_CONNECTIONS;

        rval = elxu_ioctl_device(device, OCS_IOCTL_CMD_CONNECTION_INFO, &req);

        if (rval < 0) {
                perror("ioctl");
                return;
        }

        if (req.num_connections == 0) {
                printf("No connections found\n");
                return;
        }

        for (i=0; i<req.num_connections; i++) {
                printf("[%d]\n", i);
                printf("  Connection ID: 0x%x\n", info[i].connection_id);
                printf("  Connection Handle: 0x%x\n", info[i].connection_handle);
                printf("  Source Address: %s\n",
                                format_ip_address(info[i].source_ip, info[i].source_ip_type));
                printf("  Source Port: %d\n", info[i].source_port);
                printf("  Dest Address: %s\n",
                                format_ip_address(info[i].dest_ip, info[i].dest_ip_type));
                printf("  Dest Port: %d\n", info[i].dest_port);
        }
}

static char* format_ip_address(uint8_t *address, uint8_t address_type)
{
        static char ret[40];

        // TODO:  These IP type numbers should be #defines somewhere
        if (address_type < 3) {
                /* Print the IP address in IPV4 format */
                sprintf(ret, "%d.%d.%d.%d",
                                address[0],
                                address[1],
                                address[2],
                                address[3]);
        } else {
                /* Print the IP address in IPV6 format */
                sprintf(ret,"%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x",
                                 address[0], address[1],
                                 address[2], address[3],
                                 address[4], address[5],
                                 address[6], address[7],
                                 address[8], address[9],
                                 address[10], address[11],
                                 address[12], address[13],
                                 address[14], address[15]);
        }

        return ret;
}