/*
* Copyright (C) IBM Corporation. 2007
* Author: Doug Maxey <dwm@austin.ibm.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#define _XOPEN_SOURCE 500
#include <ftw.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include "fwparam.h"
#include "fw_context.h"
#include "iscsi_obp.h"
#include "prom_parse.h"
#include "sysdeps.h"
#include "iscsi_err.h"
void* yy_scan_string(const char *str);
int yyparse(struct ofw_dev *ofwdev);
#define BOOTPATH "/chosen/bootpath"
#define DT_TOP "/proc/device-tree"
#define LOCAL_MAC_FILE "/local-mac-address"
static int devtree_offset;
static char *bootpath_val;
static int bytes_read;
#define OFWDEV_MAX (10)
static struct ofw_dev *ofwdevs[OFWDEV_MAX];
static char *niclist[OFWDEV_MAX];
static int nic_count;
static int debug;
static int dev_count;
static void cp_param(char *dest, const char *name, struct ofw_dev *dev,
enum obp_param item, int len)
{
if (dev->param[item])
strlcpy(dest, dev->param[item]->val, len);
}
static void cp_int_param(int *dest, const char *name, struct ofw_dev *dev,
enum obp_param item)
{
if (dev->param[item])
*dest = strtol(dev->param[item]->val, NULL, 10);
}
static char *find_devtree(const char *filename)
{
char *devtree = strdup(filename);
char *chop_at;
struct stat dt_stat;
int error;
/*
* What is the path to the device-tree? The only valid
* directories to locate the property are under /aliases or
* /chosen.
*/
chop_at = strstr(devtree, "/chosen");
if (!chop_at)
chop_at = strstr(devtree, "/aliases");
if (!chop_at) {
char *vdev = malloc(strlen(filename) + strlen("/vdevice") + 1);
/*
* test to see if there is /vdevice dir
*/
if (vdev) {
sprintf(vdev, "%s%s", filename, "/vdevice");
error = stat(vdev, &dt_stat);
free(vdev);
if (error) {
free(devtree);
return NULL;
}
}
} else
devtree[chop_at - devtree] = 0;
if (devtree)
devtree_offset = strlen(devtree);
return devtree;
}
/*
* Take the path to the property under chosen, and swizzle to make that
* the base for the device path discovered.
*/
static int locate_mac(const char *devtree, struct ofw_dev *ofwdev)
{
int error = 0;
int mac_path_len = strlen(ofwdev->dev_path) + strlen(LOCAL_MAC_FILE) +
2;
char *mac_file;
int mac_fd;
mac_path_len += strlen(devtree);
mac_file = malloc(mac_path_len);
if (!mac_file) {
error = ENOMEM;
fprintf(stderr, "%s: malloc , %s\n", __func__,
strerror(errno));
goto lpm_bail;
}
snprintf(mac_file, mac_path_len, "%s%s%s", devtree, ofwdev->dev_path,
LOCAL_MAC_FILE);
mac_fd = open(mac_file, O_RDONLY);
if (mac_fd < 0) {
error = errno;
fprintf(stderr, "%s: open %s, %s\n", __func__, mac_file,
strerror(errno));
free(mac_file);
goto lpm_bail;
}
bytes_read = read(mac_fd, ofwdev->mac, 6);
if (bytes_read != 6) {
error = EIO;
fprintf(stderr, "%s: read %s, %s\n", __func__, mac_file,
strerror(errno));
}
free(mac_file);
close(mac_fd);
lpm_bail:
return error;
}
const char *obp_qual_set(struct ofw_dev *ofwdev, const char *qual)
{
if (!strcmp("bootp", qual))
ofwdev->quals[ofwdev->qual_count++] = OBP_QUAL_BOOTP;
else if (!strcmp("dhcpv6", qual))
ofwdev->quals[ofwdev->qual_count++] = OBP_QUAL_DHCPV6;
else if (!strcmp("ipv6", qual))
ofwdev->quals[ofwdev->qual_count++] = OBP_QUAL_IPV6;
else if (!strcmp("iscsi", qual)) {
ofwdev->type = OFW_DT_ISCSI;
ofwdev->quals[ofwdev->qual_count++] = OBP_QUAL_ISCSI;
} else if (!strcmp("ping", qual))
ofwdev->quals[ofwdev->qual_count++] = OBP_QUAL_PING;
else
printf("%s: %s UNKNOWN\n", __func__, qual);
return qual;
}
void add_obp_parm(struct ofw_dev *ofwdev, enum obp_param parm, const char *str)
{
int psz = sizeof(struct ofw_obp_param) + strlen(str);
ofwdev->param[parm] = malloc(psz);
if (ofwdev->param[parm] == NULL) {
printf("%s: ENOMEM!\n", __func__);
return;
}
memset(ofwdev->param[parm], 0, psz);
ofwdev->param[parm]->len = psz;
strcpy(ofwdev->param[parm]->val, str);
}
void obp_parm_addr(struct ofw_dev *ofwdev, const char *parm, const char *addr)
{
if (!strcmp("ciaddr", parm))
add_obp_parm(ofwdev, OBP_PARAM_CIADDR, addr);
else if (!strcmp("dhcp", parm))
add_obp_parm(ofwdev, OBP_PARAM_DHCP, addr);
else if (!strcmp("giaddr", parm))
add_obp_parm(ofwdev, OBP_PARAM_GIADDR, addr);
else if (!strcmp("isns", parm))
add_obp_parm(ofwdev, OBP_PARAM_ISNS, addr);
else if (!strcmp("siaddr", parm))
add_obp_parm(ofwdev, OBP_PARAM_SIADDR, addr);
else if (!strcmp("slp", parm))
add_obp_parm(ofwdev, OBP_PARAM_SLP, addr);
else if (!strcmp("subnet-mask", parm))
add_obp_parm(ofwdev, OBP_PARAM_SUBNET_MASK, addr);
else
printf("%s: %s UNKNOWN\n", __func__, parm);
}
void obp_parm_iqn(struct ofw_dev *ofwdev, const char *parm, const char *iqn)
{
if (!strcmp("itname", parm))
add_obp_parm(ofwdev, OBP_PARAM_ITNAME, iqn);
else if (!strcmp("iname", parm))
add_obp_parm(ofwdev, OBP_PARAM_INAME, iqn);
else
printf("%s: %s UNKNOWN\n", __func__, parm);
}
void obp_parm_hexnum(struct ofw_dev *ofwdev, const char *parm,
const char *numstr)
{
if (!strcmp("bootp-retries", parm))
add_obp_parm(ofwdev, OBP_PARAM_BOOTP_RETRIES, numstr);
else if (!strcmp("tftp-retries", parm))
add_obp_parm(ofwdev, OBP_PARAM_TFTP_RETRIES, numstr);
else if (!strcmp("iport", parm))
add_obp_parm(ofwdev, OBP_PARAM_IPORT, numstr);
else if (!strcmp("ilun", parm))
add_obp_parm(ofwdev, OBP_PARAM_ILUN, numstr);
else if (!strcmp("isid", parm))
add_obp_parm(ofwdev, OBP_PARAM_ISID, numstr);
else
printf("%s: %s UNKNOWN <%s>\n", __func__, parm, numstr);
}
void obp_parm_str(struct ofw_dev *ofwdev, const char *parm, const char *str)
{
if (!strcmp("filename", parm))
add_obp_parm(ofwdev, OBP_PARAM_FILENAME, str);
else if (!strcmp("ichapid", parm))
add_obp_parm(ofwdev, OBP_PARAM_ICHAPID, str);
else if (!strcmp("ichappw", parm))
add_obp_parm(ofwdev, OBP_PARAM_ICHAPPW, str);
else if (!strcmp("chapid", parm))
add_obp_parm(ofwdev, OBP_PARAM_CHAPID, str);
else if (!strcmp("chappw", parm))
add_obp_parm(ofwdev, OBP_PARAM_CHAPPW, str);
else
printf("%s: %s UNKNOWN <%s>\n", __func__, parm, str);
}
void yyerror(struct ofw_dev *ofwdev, const char *msg)
{
fprintf(stderr, "%s: error in <%s> at l%d.c%d\n", "fwparam_ppc",
ofwdev->prop_path, yylloc.last_line, yylloc.last_column);
}
static int parse_params(const char *buf, struct ofw_dev *ofwdev)
{
int error = 0;
#if YYDEBUG
yydebug = 1;
#endif
if (yy_scan_string(buf))
error = yyparse(ofwdev);
return error;
}
static int find_file(const char *filename)
{
int error, fd;
struct stat bootpath_stat;
error = stat(filename, &bootpath_stat);
if (error < 0) {
fprintf(stderr, "%s: stat %s, %s\n", __func__, filename,
strerror(errno));
return error;
}
bootpath_val = malloc(bootpath_stat.st_size);
if (!bootpath_val) {
error = ENOMEM;
fprintf(stderr, "%s: Could not open %s: %s (%d)\n",
__func__, filename, strerror(error), error);
return -1;
}
fd = open(filename, O_RDONLY);
if (fd < 0) {
fprintf(stderr, "%s: Could not open %s: %s (%d)\n",
__func__, filename, strerror(errno), errno);
free(bootpath_val);
return -1;
}
bytes_read = read(fd, bootpath_val, bootpath_stat.st_size);
close(fd);
free(bootpath_val);
if (bytes_read != bootpath_stat.st_size) {
fprintf(stderr, "%s: Could not open %s: %s (%d)\n",
__func__, filename, strerror(EIO), EIO);
return -1;
}
return 1;
}
static int find_nics(const char *fpath, const struct stat *sb, int tflag,
struct FTW *ftw)
{
if (tflag == FTW_D &&
(strstr(fpath + ftw->base, "iscsi-toe") ||
strstr(fpath + ftw->base, "ethernet"))) {
if (nic_count < OFWDEV_MAX)
niclist[nic_count++] = strdup(fpath + devtree_offset);
}
return 0;
}
static int nic_cmp(const void *a, const void *b)
{
return strcmp(a, b);
}
static int find_initiator(const char *fpath, const struct stat *sb, int tflag,
struct FTW *ftw)
{
struct ofw_dev *dev;
if (tflag == FTW_F && (strstr(fpath + ftw->base,
"/aliases/iscsi-disk"))) {
if (dev_count < OFWDEV_MAX) {
ofwdevs[dev_count++] = dev =
calloc(sizeof(struct ofw_dev), 1);
dev->prop_path = strdup(fpath + devtree_offset);
}
}
return 0;
}
static int loop_devs(const char *devtree)
{
int error;
int i;
char prefix[256];
nic_count = 0;
error = nftw(devtree, find_nics, 20, 0);
if (error)
return error;
/*
* Sort the nics into "natural" order. The proc fs
* device-tree has them in somewhat random, or reversed order.
*/
qsort(niclist, nic_count, sizeof(char *), nic_cmp);
snprintf(prefix, sizeof(prefix), "%s/%s", devtree, "aliases");
dev_count = 0;
error = nftw(prefix, find_initiator, 20, 0);
if (error)
return error;
for (i = 0; i < dev_count; i++) {
snprintf(prefix, sizeof(prefix), "%s%s", devtree,
ofwdevs[i]->prop_path);
if (find_file(prefix) > 0) {
error = parse_params(bootpath_val, ofwdevs[i]);
if (!error)
error = locate_mac(devtree, ofwdevs[i]);
}
}
return error;
}
#define set_context(fld,abrv,item) \
cp_param(context->fld, (abrv), ofwdev, (item), sizeof(context->fld))
#define set_int_context(fld,abrv,item) \
cp_int_param(&context->fld, (abrv), ofwdev, (item))
static void fill_context(struct boot_context *context, struct ofw_dev *ofwdev)
{
int ndx;
memset(context, 0, sizeof(*context));
set_context(initiatorname, "NAME", OBP_PARAM_ITNAME);
snprintf(context->mac, sizeof(context->mac),
"%02x:%02x:%02x:%02x:%02x:%02x",
ofwdev->mac[0], ofwdev->mac[1], ofwdev->mac[2],
ofwdev->mac[3], ofwdev->mac[4], ofwdev->mac[5]);
/*
* nic parameters
*/
for (ndx = 0; ndx < nic_count; ndx++) {
if (!strcmp(niclist[ndx], ofwdev->dev_path)) {
snprintf(context->iface, sizeof(context->iface),
"eth%d", ndx);
break;
}
}
set_context(ipaddr, "IPADDR", OBP_PARAM_CIADDR);
set_context(mask, "MASK", OBP_PARAM_SUBNET_MASK);
/*
* target parameters
*/
set_context(target_ipaddr, "IPADDR", OBP_PARAM_SIADDR);
set_int_context(target_port, "PORT", OBP_PARAM_IPORT);
set_context(lun, "LUN", OBP_PARAM_ILUN);
set_context(targetname, "NAME", OBP_PARAM_INAME);
set_context(isid, "ISID", OBP_PARAM_ISID);
/*
* chap stuff is always associated with the target
*/
set_context(chap_name, "CHAP_NAME", OBP_PARAM_ICHAPID);
set_context(chap_password, "CHAP_PASSWORD", OBP_PARAM_ICHAPPW);
set_context(chap_name_in, "CHAP_NAME_IN", OBP_PARAM_CHAPID);
set_context(chap_password_in, "CHAP_PASSWORD_IN", OBP_PARAM_CHAPPW);
}
int fwparam_ppc_boot_info(struct boot_context *context)
{
char filename[FILENAMESZ];
int error;
char *devtree;
/*
* For powerpc, our operations are fundamentally to locate
* either the one boot target (the singleton disk), or to find
* the nics that support iscsi boot. The only nics in IBM
* systems that can support iscsi are the ones that provide
* the appropriate FCODE with a load method.
*/
memset(filename, 0, FILENAMESZ);
snprintf(filename, FILENAMESZ, "%s%s", DT_TOP, BOOTPATH);
if (debug)
fprintf(stderr, "%s: file:%s; debug:%d\n", __func__, filename,
debug);
devtree = find_devtree(filename);
if (!devtree)
return ISCSI_ERR_INVAL;
/*
* Always search the device-tree to find the capable nic devices.
*/
error = loop_devs(devtree);
if (error)
goto free_devtree;
if (find_file(filename) < 1)
error = ISCSI_ERR_NO_OBJS_FOUND;
else {
if (debug)
printf("%s:\n%s\n\n", filename, bootpath_val);
/*
* We find *almost* everything we need in the
* bootpath, save the mac-address.
*/
if (!strstr(bootpath_val, "iscsi")) {
error = ISCSI_ERR_INVAL;
goto free_devtree;
}
ofwdevs[0] = calloc(1, sizeof(struct ofw_dev));
if (!ofwdevs[0]) {
error = ISCSI_ERR_NOMEM;
goto free_devtree;
}
error = parse_params(bootpath_val, ofwdevs[0]);
if (!error)
error = locate_mac(devtree, ofwdevs[0]);
if (!error) {
if (!context)
error = ISCSI_ERR_NOMEM;
else
fill_context(context, ofwdevs[0]);
}
free(ofwdevs[0]);
}
free_devtree:
free(devtree);
return error;
}
/*
* Due to lack of time this is just fwparam_ppc_boot_info which
* adds the target used for boot to the list. It does not add
* all possible targets (IBM please add).
*/
int fwparam_ppc_get_targets(struct list_head *list)
{
char filename[FILENAMESZ];
struct boot_context *context;
int error;
char *devtree;
/*
* For powerpc, our operations are fundamentally to locate
* either the one boot target (the singleton disk), or to find
* the nics that support iscsi boot. The only nics in IBM
* systems that can support iscsi are the ones that provide
* the appropriate FCODE with a load method.
*/
memset(filename, 0, FILENAMESZ);
snprintf(filename, FILENAMESZ, "%s%s", DT_TOP, BOOTPATH);
if (debug)
fprintf(stderr, "%s: file:%s; debug:%d\n", __func__, filename,
debug);
devtree = find_devtree(filename);
if (!devtree)
return ISCSI_ERR_INVAL;
/*
* Always search the device-tree to find the capable nic devices.
*/
error = loop_devs(devtree);
if (error)
goto free_devtree;
if (find_file(filename) < 1)
error = ISCSI_ERR_NO_OBJS_FOUND;
else {
if (debug)
printf("%s:\n%s\n\n", filename, bootpath_val);
/*
* We find *almost* everything we need in the
* bootpath, save the mac-address.
*/
if (!strstr(bootpath_val, "iscsi")) {
error = ISCSI_ERR_INVAL;
goto free_devtree;
}
ofwdevs[0] = calloc(1, sizeof(struct ofw_dev));
if (!ofwdevs[0]) {
error = ISCSI_ERR_NOMEM;
goto free_devtree;
}
error = parse_params(bootpath_val, ofwdevs[0]);
if (!error)
error = locate_mac(devtree, ofwdevs[0]);
if (!error) {
context = calloc(1, sizeof(*context));
if (!context)
error = ISCSI_ERR_NOMEM;
else {
fill_context(context, ofwdevs[0]);
list_add_tail(&context->list, list);
}
}
free(ofwdevs[0]);
}
free_devtree:
free(devtree);
return error;
}