rport.c

/*
 * Copyright (c) 2008, Intel Corporation.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU Lesser General Public License,
 * version 2.1, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
 * for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
 *
 */

#include "utils.h"
#include "api_lib.h"
#include "adapt_impl.h"

static int sys_read_port_state(const char *, const char *, u_int32_t *);
static int sys_read_classes(const char *, const char *, u_int32_t *);

static struct sa_table rports_table;          /* table of discovered ports */

/*
 * Handle a single remote port from the /sys directory entry.
 * The return value is 0 unless an error is detected which should stop the
 * directory read.
 */
static int
sysfs_get_rport(struct dirent *dp, void *arg)
{
	struct port_info *rp;
	HBA_PORTATTRIBUTES *rpa;
	int rc;
	u_int32_t hba;
	u_int32_t port;
	u_int32_t rp_index;
	char *rport_dir;
	char buf[256];

	/*
	 * Parse name into bus number, channel number, and remote port number.
	 */
	hba = ~0;
	port = ~0;
	rp_index = ~0;
	rc = sscanf(dp->d_name, SYSFS_RPORT_DIR, &hba, &port, &rp_index);
	if (rc != 3) {
		fprintf(stderr,
			"%s: remote port %s didn't parse."
			" rc %d h 0x%x p 0x%x rp 0x%x\n", __func__,
			dp->d_name, rc, hba, port, rp_index);
		return 0;
	}

	/*
	 * Allocate a remote port.
	 */
	rp = malloc(sizeof(*rp));
	if (rp == NULL) {
		fprintf(stderr, "%s: malloc for remote port %s failed,"
			" errno=0x%x\n", __func__, dp->d_name, errno);
		return ENOMEM;
	}
	memset(rp, 0, sizeof(*rp));
	rp->ap_kern_hba = hba;
	rp->ap_index = port;
	rp->ap_disc_index = rp_index;
	rpa = &rp->ap_attr;

	snprintf(rpa->OSDeviceName, sizeof(rpa->OSDeviceName), "%s/%s",
		SYSFS_RPORT_ROOT, dp->d_name);
	rport_dir = rpa->OSDeviceName;
	rc = 0;
	rc |= sys_read_wwn(rport_dir, "node_name", &rpa->NodeWWN);
	rc |= sys_read_wwn(rport_dir, "port_name", &rpa->PortWWN);
	rc |= sa_sys_read_u32(rport_dir, "port_id", &rpa->PortFcId);
	rc |= sa_sys_read_u32(rport_dir, "scsi_target_id", &rp->ap_scsi_target);
	sa_sys_read_line(rport_dir, "maxframe_size", buf, sizeof(buf));
	sscanf(buf, "%d", &rpa->PortMaxFrameSize);
	rc |= sys_read_port_state(rport_dir, "port_state", &rpa->PortState);
	rc |= sys_read_classes(rport_dir, "supported_classes",
				   &rpa->PortSupportedClassofService);
	if (rc != 0 || sa_table_append(&rports_table, rp) < 0) {
		if (rc != 0)
			fprintf(stderr,
				"%s: errors (%x) from /sys reads in %s\n",
				__func__, rc, dp->d_name);
		else
			fprintf(stderr,
				"%s: sa_table_append error on rport %s\n",
				__func__, dp->d_name);
		free(rp);
	}
	return 0;
}

/*
 * Get remote port information from /sys.
 */
static void
sysfs_find_rports(void)
{
	sa_dir_read(SYSFS_RPORT_ROOT, sysfs_get_rport, NULL);
}

/*
 * Read port state as formatted by scsi_transport_fc.c in the linux kernel.
 */
static int
sys_read_port_state(const char *dir, const char *file, u_int32_t *statep)
{
	char buf[256];
	int rc;

	rc = sa_sys_read_line(dir, file, buf, sizeof(buf));
	if (rc == 0) {
		rc = sa_enum_encode(port_states_table, buf, statep);
		if (rc != 0)
			fprintf(stderr,
				"%s: parse error. file %s/%s line '%s'\n",
				__func__, dir, file, buf);
	}
	return rc;
}

/*
 * Read class list as formatted by scsi_transport_fc.c in the linux kernel.
 * Format is expected to be "Class 3[, Class 4]..."
 * Actually accepts "[Class ]3[,[ ][Class ]4]..." (i.e., "Class" and spaces
 * are optional).
 */
static int
sys_read_classes(const char *dir, const char *file, u_int32_t *classp)
{
	char buf[256];
	int rc;
	u_int32_t val;
	char *cp;
	char *ep;

	*classp = 0;
	rc = sa_sys_read_line(dir, file, buf, sizeof(buf));
	if (rc == 0 && strstr(buf, "unspecified") == NULL) {
		for (cp = buf; *cp != '\0'; cp = ep) {
			if (strncmp(cp, "Class ", 6) == 0)
				cp += 6;
			val = strtoul(cp, &ep, 10);
			*classp |= 1 << val;
			if (*ep == '\0')
				break;
			if (*ep == ',') {
				ep++;
				if (*ep == ' ')
					ep++;
			} else {
				fprintf(stderr, "%s: parse error. file %s/%s "
				       "line '%s' ep '%c'\n", __func__,
					dir, file, buf, *ep);
				rc = -1;
				break;
			}
		}
	}
	return rc;
}

/*
 * Get all discovered ports for a particular port using /sys.
 */
void
get_rport_info(struct port_info *pp)
{
	struct port_info *rp;
	int rp_count = 0;
	int ri;

	if (rports_table.st_size == 0)
		sysfs_find_rports();

	for (ri = 0; ri < rports_table.st_size; ri++) {
		rp = sa_table_lookup(&rports_table, ri);
		if (rp != NULL) {
			if (rp->ap_kern_hba == pp->ap_kern_hba &&
			    rp->ap_index == pp->ap_index &&
			    rp->ap_adapt == NULL) {
				rp->ap_adapt = pp->ap_adapt;
				if (sa_table_lookup(&pp->ap_rports,
						    rp->ap_disc_index)) {
					fprintf(stderr,
						"%s: discovered port exists. "
					       "hba %x port %x rport %x\n",
					       __func__, pp->ap_kern_hba,
					       pp->ap_index, rp->ap_disc_index);
				}
				sa_table_insert(&pp->ap_rports,
						rp->ap_disc_index, rp);
			}
			rp_count++;
		}
	}
}