i86pc/os/ibft.c

	ibft.c revision 6cefaae1e90a413ba01560575bb3998e1a3df40e
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * This is the place to implement ld_ib_props()
 * For x86 it is to load iBFT and costruct the global ib props
 */

#include <sys/types.h>
#include <sys/cmn_err.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/mman.h>
#include <sys/bootprops.h>
#include <sys/kmem.h>
#include <sys/psm.h>

#ifndef NULL
#define NULL    0
#endif

typedef enum ibft_structure_type {
    Reserved    =   0,
    Control     =   1,
    Initiator   =   2,
    Nic     =   3,
    Target      =   4,
    Extensions  =   5,
    Type_End
}ibft_struct_type;

typedef enum _chap_type {
    NO_CHAP     =   0,
    CHAP        =   1,
    Mutual_CHAP =   2,
    TYPE_UNKNOWN
}chap_type;

typedef struct ibft_entry {
    int af;
    int e_port;
    char    target_name[224];
    char    target_addr[INET6_ADDRSTRLEN];
}ibft_entry_t;

typedef struct iSCSI_ibft_tbl_hdr {
    char        Signature[4];
    int     Length;
    char        Revision;
    char        Checksum;
    char        oem_id[6];
    char        oem_table_id[8];
    char        Reserved[24];
}iscsi_ibft_tbl_hdr_t;

typedef struct iSCSI_ibft_hdr {
    char        Structure_id;
    char        Version;
    ushort_t    Length;
    char        Index;
    char        Flags;
}iscsi_ibft_hdr_t;

typedef struct iSCSI_ibft_control {
    iscsi_ibft_hdr_t    header;
    ushort_t        Extensions;
    ushort_t        Initiator_offset;
    ushort_t        Nic0_offset;
    ushort_t        Target0_offset;
    ushort_t        Nic1_offset;
    ushort_t        Target1_offset;
}iscsi_ibft_ctl_t;

typedef struct iSCSI_ibft_initiator {
    iscsi_ibft_hdr_t    header;
    uchar_t         iSNS_Server[16];
    uchar_t         SLP_Server[16];
    uchar_t         Pri_Radius_Server[16];
    uchar_t         Sec_Radius_Server[16];
    ushort_t        ini_name_len;
    ushort_t        ini_name_offset;
}iscsi_ibft_initiator_t;

typedef struct iSCSI_ibft_nic {
    iscsi_ibft_hdr_t    header;
    uchar_t         ip_addr[16];
    char            Subnet_Mask_Prefix;
    char            Origin;
    uchar_t         Gateway[16];
    uchar_t         Primary_dns[16];
    uchar_t         Secondary_dns[16];
    uchar_t         dhcp[16];
    ushort_t        vlan;
    char            mac[6];
    ushort_t        pci_BDF;
    ushort_t        Hostname_len;
    ushort_t        Hostname_offset;
}iscsi_ibft_nic_t;

typedef struct iSCSI_ibft_target {
    iscsi_ibft_hdr_t    header;
    uchar_t         ip_addr[16];
    ushort_t        port;
    uchar_t         boot_lun[8];
    uchar_t         chap_type;
    uchar_t         nic_association;
    ushort_t        target_name_len;
    ushort_t        target_name_offset;
    ushort_t        chap_name_len;
    ushort_t        chap_name_offset;
    ushort_t        chap_secret_len;
    ushort_t        chap_secret_offset;
    ushort_t        rev_chap_name_len;
    ushort_t        rev_chap_name_offset;
    ushort_t        rev_chap_secret_len;
    ushort_t        rev_chap_secret_offset;
}iscsi_ibft_tgt_t;

#define ISCSI_IBFT_LOWER_ADDR       0x80000     /* 512K */
#define ISCSI_IBFT_HIGHER_ADDR      0x100000    /* 1024K */
#define ISCSI_IBFT_SIGNATRUE        "iBFT"
#define ISCSI_IBFT_SIGNATURE_LEN    4
#define ISCSI_IBFT_TBL_BUF_LEN      1024
#define ISCSI_IBFT_ALIGNED      16
#define ISCSI_IBFT_CTL_OFFSET       48

#define IBFT_BLOCK_VALID_YES        0x01    /* bit 0 */
#define IBFT_FIRMWARE_BOOT_SELECTED 0x02    /* bit 1 */
#define IBFT_USE_RADIUS_CHAP        0x04    /* bit 2 */
#define IBFT_USE_GLOBLE         0x04    /* NIC structure */
#define IBFT_USE_RADIUS_RHCAP       0x08    /* bit 3 */

/*
 * Currently, we only support initiator offset, NIC0 offset, Target0 offset,
 * NIC1 offset and Target1 offset. So the length is 5. If we want to support
 * extensions, we should change this number.
 */
#define IBFT_OFFSET_BUF_LEN     5
#define IPV4_OFFSET         12

#define IBFT_INVALID_MSG        "Invalid iBFT table 0x%x"

typedef enum ibft_status {
    IBFT_STATUS_OK = 0,
    /* General error */
    IBFT_STATUS_ERR,
    /* Bad header */
    IBFT_STATUS_BADHDR,
    /* Bad control ID */
    IBFT_STATUS_BADCID,
    /* Bad ip addr */
    IBFT_STATUS_BADIP,
    /* Bad af */
    IBFT_STATUS_BADAF,
    /* Bad chap name */
    IBFT_STATUS_BADCHAPNAME,
    /* Bad chap secret */
    IBFT_STATUS_BADCHAPSEC,
    /* Bad checksum */
    IBFT_STATUS_BADCHECKSUM,
    /* Low memory */
    IBFT_STATUS_LOWMEM,
    /* No table */
    IBFT_STATUS_NOTABLE
} ibft_status_t;

extern void *memset(void *s, int c, size_t n);
extern int memcmp(const void *s1, const void *s2, size_t n);
extern void bcopy(const void *s1, void *s2, size_t n);
extern void iscsi_print_boot_property();

ib_boot_prop_t boot_property;       /* static allocated */
extern ib_boot_prop_t *iscsiboot_prop;  /* to be filled */

static ibft_status_t iscsi_parse_ibft_control(iscsi_ibft_ctl_t *ctl_hdr,
    ushort_t *iscsi_offset_buf);

static ibft_status_t iscsi_parse_ibft_initiator(char *begin_of_ibft,
    iscsi_ibft_initiator_t *initiator);

static ibft_status_t iscsi_parse_ibft_NIC(iscsi_ibft_nic_t *nicp);

static ibft_status_t iscsi_parse_ibft_target(char *begin_of_ibft,
    iscsi_ibft_tgt_t *tgtp);


/*
 * Return value:
 * Success: IBFT_STATUS_OK
 * Fail: IBFT_STATUS_BADCHECKSUM
 */
static ibft_status_t
iscsi_ibft_hdr_checksum(iscsi_ibft_tbl_hdr_t *tbl_hdr)
{
    uchar_t checksum    =   0;
    uchar_t *start      =   NULL;
    int length      =   0;
    int i       =   0;

    if (tbl_hdr == NULL) {
        return (IBFT_STATUS_BADHDR);
    }

    length = tbl_hdr->Length;
    start = (uchar_t *)tbl_hdr;

    for (i = 0; i < length; i++) {
        checksum = checksum + start[i];
    }

    if (!checksum)
        return (IBFT_STATUS_OK);
    else
        return (IBFT_STATUS_BADCHECKSUM);
}

/*
 * Now we only support one control structure in the IBFT.
 * So there is no Control ID here.
 */
static ibft_status_t
iscsi_parse_ibft_structure(char *begin_of_ibft, char *buf)
{
    iscsi_ibft_hdr_t    *hdr    =   NULL;
    ibft_status_t       ret =   IBFT_STATUS_OK;

    if (buf == NULL) {
        return (IBFT_STATUS_ERR);
    }

    hdr = (iscsi_ibft_hdr_t *)buf;
    switch (hdr->Structure_id) {
        case Initiator:
            ret = iscsi_parse_ibft_initiator(
                begin_of_ibft,
                (iscsi_ibft_initiator_t *)buf);
            break;
        case Nic:
            ret = iscsi_parse_ibft_NIC(
                (iscsi_ibft_nic_t *)buf);
            break;
        case Target:
            ret = iscsi_parse_ibft_target(
                begin_of_ibft,
                (iscsi_ibft_tgt_t *)buf);
            break;
        default:
            ret = IBFT_STATUS_BADHDR;
            break;
    }

    return (ret);
}

/*
 * Parse the iBFT table
 * return IBFT_STATUS_OK upon sucess
 */
static ibft_status_t
iscsi_parse_ibft_tbl(iscsi_ibft_tbl_hdr_t *tbl_hdr)
{
    char        *outbuf     =   NULL;
    int     i       =   0;
    ibft_status_t   ret     =   IBFT_STATUS_OK;
    ushort_t    iscsi_offset_buf[IBFT_OFFSET_BUF_LEN] = {0};

    if (tbl_hdr == NULL) {
        return (IBFT_STATUS_ERR);
    }

    if (iscsi_ibft_hdr_checksum(tbl_hdr) != IBFT_STATUS_OK) {
        return (IBFT_STATUS_BADCHECKSUM);
    }

    outbuf = (char *)tbl_hdr;

    ret = iscsi_parse_ibft_control(
        (iscsi_ibft_ctl_t *)&outbuf[ISCSI_IBFT_CTL_OFFSET],
        iscsi_offset_buf);

    if (ret == IBFT_STATUS_OK) {
        ret = IBFT_STATUS_ERR;
        for (i = 0; i < IBFT_OFFSET_BUF_LEN; i++) {
            if (iscsi_offset_buf[i] != 0) {
                ret = iscsi_parse_ibft_structure(
                    (char *)tbl_hdr,
                    (char *)tbl_hdr +
                    iscsi_offset_buf[i]);
                if (ret != IBFT_STATUS_OK) {
                    return (ret);
                }
            }
        }
    }

    return (ret);
}

static ibft_status_t
iscsi_parse_ibft_control(iscsi_ibft_ctl_t *ctl_hdr,
    ushort_t    *iscsi_offset_buf)
{
    int     i       =   0;
    ushort_t    *offsetp    =   NULL;

    if (ctl_hdr == NULL) {
        return (IBFT_STATUS_BADHDR);
    }

    if (ctl_hdr->header.Structure_id != Control) {
        return (IBFT_STATUS_BADCID);
    }

    /*
     * Copy the offsets to offset buffer.
     */
    for (offsetp = &(ctl_hdr->Initiator_offset); i < IBFT_OFFSET_BUF_LEN;
        offsetp++) {
        iscsi_offset_buf[i++] = *offsetp;
    }

    return (IBFT_STATUS_OK);
}

/*
 * We only copy the "Firmare Boot Selseted" and valid initiator
 * to the boot property.
 */
static ibft_status_t
iscsi_parse_ibft_initiator(char *begin_of_ibft,
    iscsi_ibft_initiator_t *initiator)
{
    if (initiator == NULL) {
        return (IBFT_STATUS_ERR);
    }

    if (initiator->header.Structure_id != Initiator) {
        return (IBFT_STATUS_BADHDR);
    }

    if ((initiator->header.Flags & IBFT_FIRMWARE_BOOT_SELECTED) &&
        (initiator->header.Flags & IBFT_BLOCK_VALID_YES)) {
        /*
         * If the initiator name exists, we will copy it to our own
         * property structure
         */
        if (initiator->ini_name_len != 0) {
            boot_property.boot_init.ini_name =
                (uchar_t *)kmem_zalloc(
                initiator->ini_name_len + 1, KM_SLEEP);
            (void) snprintf(
                (char *)boot_property.boot_init.ini_name,
                initiator->ini_name_len + 1, "%s",
                begin_of_ibft + initiator->ini_name_offset);
        }
    }
    return (IBFT_STATUS_OK);
}

static ibft_status_t
iscsi_parse_ipaddr(uchar_t *source, char *dest, int *af)
{
    int i = 0;

    if (source == NULL) {
        return (IBFT_STATUS_ERR);
    }

    if (source[0] == 0x00 && source[1] == 0x00 &&
        source[2] == 0x00 && source[3] == 0x00 &&
        source[4] == 0x00 && source[5] == 0x00 &&
        source[6] == 0x00 && source[7] == 0x00 &&
        source[8] == 0x00 && source[9] == 0x00 &&
        (source[10] == 0xff) && (source[11] == 0xff)) {
        /*
         * IPv4 address
         */
        if (dest != NULL) {
            (void) sprintf(dest, "%d.%d.%d.%d",
                source[12], source[13], source[14], source[15]);
        }
        if (af != NULL) {
            *af = AF_INET;
        }
    } else {
        if (dest != NULL) {
            for (i = 0; i < 14; i = i + 2) {
                (void) sprintf(dest, "%02x%02x:", source[i],
                    source[i+1]);
                dest = dest + 5;
            }
            (void) sprintf(dest, "%02x%02x",
                source[i], source[i+1]);
        }
        if (af != NULL) {
            *af = AF_INET6;
        }
    }

    return (IBFT_STATUS_OK);
}

/*
 * Copy the ip address from ibft. If IPv4 is used, we should copy
 * the address from 12th byte.
 */
static ibft_status_t
iscsi_copy_ibft_ipaddr(uchar_t *source, void *dest, int *af)
{
    ibft_status_t   ret     =   IBFT_STATUS_OK;
    int     sin_family  =   0;

    if (source == NULL || dest == NULL) {
        return (IBFT_STATUS_ERR);
    }
    ret = iscsi_parse_ipaddr(source, NULL, &sin_family);
    if (ret != 0) {
        return (IBFT_STATUS_BADIP);
    }

    if (sin_family == AF_INET) {
        bcopy(source+IPV4_OFFSET, dest, sizeof (struct in_addr));
    } else if (sin_family == AF_INET6) {
        bcopy(source, dest, sizeof (struct in6_addr));
    } else {
        return (IBFT_STATUS_BADAF);
    }

    if (af != NULL) {
        *af = sin_family;
    }
    return (IBFT_STATUS_OK);
}

/*
 * Maybe there are multiply NICs are available. We only copy the
 * "Firmare Boot Selseted" and valid one to the boot property.
 */
static ibft_status_t
iscsi_parse_ibft_NIC(iscsi_ibft_nic_t *nicp)
{
    ibft_status_t   ret =   IBFT_STATUS_OK;
    int     af  =   0;

    if (nicp == NULL) {
        return (IBFT_STATUS_ERR);
    }

    if (nicp->header.Structure_id != Nic) {
        return (IBFT_STATUS_ERR);
    }

    if ((nicp->header.Flags & IBFT_FIRMWARE_BOOT_SELECTED) &&
        (nicp->header.Flags & IBFT_BLOCK_VALID_YES)) {
        ret = iscsi_copy_ibft_ipaddr(nicp->ip_addr,
            &boot_property.boot_nic.nic_ip_u, &af);
        if (ret != IBFT_STATUS_OK) {
            return (ret);
        }

        boot_property.boot_nic.sin_family = af;

        ret = iscsi_copy_ibft_ipaddr(nicp->Gateway,
            &boot_property.boot_nic.nic_gw_u, NULL);
        if (ret != IBFT_STATUS_OK) {
            return (ret);
        }

        ret = iscsi_copy_ibft_ipaddr(nicp->dhcp,
            &boot_property.boot_nic.nic_dhcp_u, NULL);
        if (ret != IBFT_STATUS_OK) {
            return (ret);
        }

        bcopy(nicp->mac, boot_property.boot_nic.nic_mac, 6);
        boot_property.boot_nic.sub_mask_prefix =
            nicp->Subnet_Mask_Prefix;
    }

    return (IBFT_STATUS_OK);
}

/*
 * Maybe there are multiply targets are available. We only copy the
 * "Firmare Boot Selseted" and valid one to the boot property.
 */
static ibft_status_t
iscsi_parse_ibft_target(char *begin_of_ibft, iscsi_ibft_tgt_t *tgtp)
{
    char        *tmp    =   NULL;
    int     af  =   0;
    ibft_status_t   ret =   IBFT_STATUS_OK;

    if (tgtp == NULL) {
        return (IBFT_STATUS_ERR);
    }

    if (tgtp->header.Structure_id != Target) {
        return (IBFT_STATUS_BADHDR);
    }

    if ((tgtp->header.Flags & IBFT_FIRMWARE_BOOT_SELECTED) &&
        (tgtp->header.Flags & IBFT_BLOCK_VALID_YES)) {
        /*
         * Get Target Address
         */
        ret = iscsi_copy_ibft_ipaddr(tgtp->ip_addr,
            &boot_property.boot_tgt.tgt_ip_u, &af);
        if (ret != IBFT_STATUS_OK) {
            return (ret);
        }
        boot_property.boot_tgt.sin_family = af;
        /*
         * Get Target Name
         */
        if (tgtp->target_name_len != 0) {
            boot_property.boot_tgt.tgt_name =
                (uchar_t *)kmem_zalloc(tgtp->target_name_len + 1,
                KM_SLEEP);
            (void) snprintf(
                (char *)boot_property.boot_tgt.tgt_name,
                tgtp->target_name_len + 1, "%s",
                begin_of_ibft + tgtp->target_name_offset);
        } else {
            boot_property.boot_tgt.tgt_name = NULL;
        }

        /* Get Dest Port */
        boot_property.boot_tgt.tgt_port = tgtp->port;

        boot_property.boot_tgt.lun_online = 0;

        /*
         * Get CHAP secret and name.
         */
        if (tgtp->chap_type != NO_CHAP) {
            if (tgtp->chap_name_len != 0) {
                boot_property.boot_init.ini_chap_name =
                    (uchar_t *)kmem_zalloc(
                    tgtp->chap_name_len + 1,
                    KM_SLEEP);
                tmp = (char *)
                    boot_property.boot_init.ini_chap_name;
                (void) snprintf(
                    tmp,
                    tgtp->chap_name_len + 1, "%s",
                    begin_of_ibft + tgtp->chap_name_offset);
            } else {
                /*
                 * Just set NULL, initiator is able to deal
                 * with this
                 */
                boot_property.boot_init.ini_chap_name = NULL;
            }

            if (tgtp->chap_secret_len != 0) {
                boot_property.boot_init.ini_chap_sec =
                    (uchar_t *)kmem_zalloc(
                    tgtp->chap_secret_len + 1,
                    KM_SLEEP);
                bcopy(begin_of_ibft +
                    tgtp->chap_secret_offset,
                    boot_property.boot_init.ini_chap_sec,
                    tgtp->chap_secret_len);
            } else {
                boot_property.boot_init.ini_chap_sec = NULL;
                return (IBFT_STATUS_ERR);
            }

            if (tgtp->chap_type == Mutual_CHAP) {
                if (tgtp->rev_chap_name_len != 0) {
                    boot_property.boot_tgt.tgt_chap_name =
                        (uchar_t *)kmem_zalloc(
                        tgtp->chap_name_len + 1,
                        KM_SLEEP);
#define TGT_CHAP_NAME   boot_property.boot_tgt.tgt_chap_name
                    tmp = (char *)TGT_CHAP_NAME;
#undef  TGT_CHAP_NAME
                    (void) snprintf(
                        tmp,
                        tgtp->chap_name_len + 1,
                        "%s",
                        begin_of_ibft +
                        tgtp->rev_chap_name_offset);
                } else {
                    /*
                     * Just set NULL, initiator is able
                     * to deal with this
                     */
                    boot_property.boot_tgt.tgt_chap_name =
                        NULL;
                }

                if (tgtp->rev_chap_secret_len != 0) {
                    boot_property.boot_tgt.tgt_chap_sec =
                        (uchar_t *)kmem_zalloc(
                        tgtp->rev_chap_secret_len + 1,
                        KM_SLEEP);
                    tmp = (char *)
                        boot_property.boot_tgt.tgt_chap_sec;
                    (void) snprintf(
                        tmp,
                        tgtp->rev_chap_secret_len + 1,
                        "%s",
                        begin_of_ibft +
                        tgtp->chap_secret_offset);
                } else {
                    boot_property.boot_tgt.tgt_chap_sec =
                        NULL;
                    return (IBFT_STATUS_BADCHAPSEC);
                }
            }
        } else {
            boot_property.boot_init.ini_chap_name = NULL;
            boot_property.boot_init.ini_chap_sec = NULL;
        }

        /*
         * Get Boot LUN
         */
        (void) bcopy(tgtp->boot_lun,
            boot_property.boot_tgt.tgt_boot_lun, 8);
    }

    return (IBFT_STATUS_OK);
}

/*
 * This function is used for scanning iBFT from the physical memory.
 * Return Value:
 * IBFT_STATUS_OK
 * IBFT_STATUS_ERR
 */
static ibft_status_t
iscsi_scan_ibft_tbl(char *ibft_tbl_buf)
{
    int     start;
    void        *va     = NULL;
    int     *len        = NULL;
    ibft_status_t   ret     = IBFT_STATUS_NOTABLE;

    for (start = ISCSI_IBFT_LOWER_ADDR; start < ISCSI_IBFT_HIGHER_ADDR;
        start = start + ISCSI_IBFT_ALIGNED) {
        va = (void *)psm_map((paddr_t)(start&0xffffffff),
            ISCSI_IBFT_SIGNATURE_LEN,
            PROT_READ);

        if (va == NULL) {
            continue;
        }
        if (memcmp(va, ISCSI_IBFT_SIGNATRUE,
            ISCSI_IBFT_SIGNATURE_LEN) == 0) {
            ret = IBFT_STATUS_ERR;
            /* Acquire table length */
            len = (int *)psm_map(
                (paddr_t)((start+\
                ISCSI_IBFT_SIGNATURE_LEN)&0xffffffff),
                ISCSI_IBFT_SIGNATURE_LEN, PROT_READ);
            if (len == NULL) {
                psm_unmap((caddr_t)va,
                    ISCSI_IBFT_SIGNATURE_LEN);
                continue;
            }
            if (ISCSI_IBFT_LOWER_ADDR + *len <
                ISCSI_IBFT_HIGHER_ADDR - 1) {
                psm_unmap(va,
                    ISCSI_IBFT_SIGNATURE_LEN);
                va = psm_map((paddr_t)(start&0xffffffff),
                    *len,
                    PROT_READ);
                if (va != NULL) {
                    /*
                     * Copy data to our own buffer
                     */
                    bcopy(va, ibft_tbl_buf, *len);
                    ret = IBFT_STATUS_OK;
                }
                psm_unmap((caddr_t)va, *len);
                psm_unmap((caddr_t)len,
                    ISCSI_IBFT_SIGNATURE_LEN);
                break;
            } else {
                psm_unmap((caddr_t)va,
                    ISCSI_IBFT_SIGNATURE_LEN);
                psm_unmap((caddr_t)len,
                    ISCSI_IBFT_SIGNATURE_LEN);
            }
        } else {
            psm_unmap((caddr_t)va, ISCSI_IBFT_SIGNATURE_LEN);
        }
    }

    return (ret);
}

/*
 * Scan the ibft table and store the iSCSI boot properties
 * If there is a valid table then set the iscsiboot_prop
 * iBF should be off if the host is not intended
 * to be booted from iSCSI disk
 */
void
ld_ib_prop()
{
    ibft_status_t   ret =   IBFT_STATUS_OK;
    char        *ibft_tbl_buf;

    ibft_tbl_buf = (char *)kmem_zalloc(ISCSI_IBFT_TBL_BUF_LEN,
        KM_SLEEP);

    if (!ibft_tbl_buf) {
        /* Unlikely to happen */
        cmn_err(CE_NOTE, IBFT_INVALID_MSG,
            IBFT_STATUS_LOWMEM);
        return;
    }

    (void) memset(&boot_property, 0, sizeof (boot_property));
    if ((ret = iscsi_scan_ibft_tbl(ibft_tbl_buf)) ==
        IBFT_STATUS_OK) {
        ret = iscsi_parse_ibft_tbl(
            (iscsi_ibft_tbl_hdr_t *)ibft_tbl_buf);
        if (ret == IBFT_STATUS_OK) {
            iscsiboot_prop = &boot_property;
            iscsi_print_boot_property();
        } else {
            cmn_err(CE_NOTE, IBFT_INVALID_MSG, ret);
        }
    } else if (ret != IBFT_STATUS_NOTABLE) {
        cmn_err(CE_NOTE, IBFT_INVALID_MSG, ret);
    }

    kmem_free(ibft_tbl_buf, ISCSI_IBFT_TBL_BUF_LEN);
}