/*
* Copyright (c) 2006-2008 Voltaire, Inc. All rights reserved.
* Copyright (c) 2012-2015 Mellanox Technologies LTD. All rights reserved.
*
* This software is available to you under a choice of one of two
* licenses. You may choose to be licensed under the terms of the GNU
* General Public License (GPL) Version 2, available from the file
* COPYING in the main directory of this source tree, or the
* OpenIB.org BSD license below:
*
* Redistribution and use in source and binary forms, with or
* without modification, are permitted provided that the following
* conditions are met:
*
* - Redistributions of source code must retain the above
* copyright notice, this list of conditions and the following
* disclaimer.
*
* - 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.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
*/
/*
* Abstract:
* Implementation of opensm partition management configuration
*/
#if HAVE_CONFIG_H
# include <config.h>
#endif /* HAVE_CONFIG_H */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <ctype.h>
#include <iba/ib_types.h>
#include <opensm/osm_file_ids.h>
#define FILE_ID OSM_FILE_PRTN_CONFIG_C
#include <opensm/osm_base.h>
#include <opensm/osm_partition.h>
#include <opensm/osm_subnet.h>
#include <opensm/osm_log.h>
#include <arpa/inet.h>
typedef enum {
LIMITED,
FULL,
BOTH
} membership_t;
const ib_gid_t osm_ipoib_broadcast_mgid = {
{
0xff, /* multicast field */
0x12, /* non-permanent bit, link local scope */
0x40, 0x1b, /* IPv4 signature */
0xff, 0xff, /* 16 bits of P_Key (to be filled in) */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 48 bits of zeros */
0xff, 0xff, 0xff, 0xff, /* 32 bit IPv4 broadcast address */
},
};
struct group_flags {
unsigned mtu, rate, sl, scope_mask;
uint32_t Q_Key;
uint8_t TClass;
uint32_t FlowLabel;
};
struct precreate_mgroup {
ib_gid_t mgid;
struct group_flags flags;
};
struct part_conf {
osm_log_t *p_log;
osm_subn_t *p_subn;
osm_prtn_t *p_prtn;
unsigned is_ipoib;
struct group_flags flags;
membership_t membership;
boolean_t indx0;
};
extern osm_prtn_t *osm_prtn_make_new(osm_log_t * p_log, osm_subn_t * p_subn,
const char *name, uint16_t pkey);
extern ib_api_status_t osm_prtn_add_all(osm_log_t * p_log, osm_subn_t * p_subn,
osm_prtn_t * p, unsigned type,
boolean_t full, boolean_t indx0);
extern ib_api_status_t osm_prtn_add_port(osm_log_t * p_log,
osm_subn_t * p_subn, osm_prtn_t * p,
ib_net64_t guid, boolean_t full,
boolean_t indx0);
ib_api_status_t osm_prtn_add_mcgroup(osm_log_t * p_log, osm_subn_t * p_subn,
osm_prtn_t * p, uint8_t rate, uint8_t mtu,
uint8_t sl, uint8_t scope, uint32_t Q_Key,
uint8_t TClass, uint32_t FlowLabel,
const ib_gid_t *mgid);
static inline boolean_t mgid_is_broadcast(const ib_gid_t *mgid)
{
return (memcmp(mgid, &osm_ipoib_broadcast_mgid,
sizeof(osm_ipoib_broadcast_mgid)) == 0);
}
static inline boolean_t mgid_is_ip(const ib_gid_t *mgid)
{
ib_net16_t ipsig = mgid->ip_multicast.signature;
return (ipsig == cl_hton16(0x401b) || ipsig == cl_hton16(0x601b));
}
static inline boolean_t ip_mgroup_pkey_ok(struct part_conf *conf,
struct precreate_mgroup *group)
{
ib_net16_t mpkey = group->mgid.ip_multicast.p_key;
char gid_str[INET6_ADDRSTRLEN];
if (mgid_is_broadcast(&group->mgid)
/* user requested "wild card" of pkey */
|| mpkey == 0x0000
/* user was smart enough to match */
|| mpkey == (conf->p_prtn->pkey | cl_hton16(0x8000)))
return (TRUE);
OSM_LOG(conf->p_log, OSM_LOG_ERROR,
"IP MC group (%s) specified with invalid pkey 0x%04x "
"for partition pkey = 0x%04x (%s)\n",
inet_ntop(AF_INET6, group->mgid.raw, gid_str, sizeof gid_str),
cl_ntoh16(mpkey), cl_ntoh16(conf->p_prtn->pkey), conf->p_prtn->name);
return (FALSE);
}
static inline boolean_t ip_mgroup_rate_ok(struct part_conf *conf,
struct precreate_mgroup *group)
{
char gid_str[INET6_ADDRSTRLEN];
if (group->flags.rate == conf->flags.rate)
return (TRUE);
OSM_LOG(conf->p_log, OSM_LOG_ERROR,
"IP MC group (%s) specified with invalid rate (%d): "
"partition pkey = 0x%04x (%s) "
"[Partition broadcast group rate = %d]\n",
inet_ntop(AF_INET6, group->mgid.raw, gid_str, sizeof gid_str),
group->flags.rate, cl_ntoh16(conf->p_prtn->pkey),
conf->p_prtn->name, conf->flags.rate);
return (FALSE);
}
static inline boolean_t ip_mgroup_mtu_ok(struct part_conf *conf,
struct precreate_mgroup *group)
{
char gid_str[INET6_ADDRSTRLEN];
if (group->flags.mtu == conf->flags.mtu)
return (TRUE);
OSM_LOG(conf->p_log, OSM_LOG_ERROR,
"IP MC group (%s) specified with invalid mtu (%d): "
"partition pkey = 0x%04x (%s) "
"[Partition broadcast group mtu = %d]\n",
inet_ntop(AF_INET6, group->mgid.raw, gid_str, sizeof gid_str),
group->flags.mtu, cl_ntoh16(conf->p_prtn->pkey),
conf->p_prtn->name, conf->flags.mtu);
return (FALSE);
}
static void __create_mgrp(struct part_conf *conf, struct precreate_mgroup *group)
{
unsigned int scope;
if (!group->flags.scope_mask) {
osm_prtn_add_mcgroup(conf->p_log, conf->p_subn, conf->p_prtn,
(uint8_t) group->flags.rate,
(uint8_t) group->flags.mtu,
group->flags.sl,
0,
group->flags.Q_Key,
group->flags.TClass,
group->flags.FlowLabel,
&group->mgid);
} else {
for (scope = 0; scope < 16; scope++) {
if (((1<<scope) & group->flags.scope_mask) == 0)
continue;
osm_prtn_add_mcgroup(conf->p_log, conf->p_subn, conf->p_prtn,
(uint8_t)group->flags.rate,
(uint8_t)group->flags.mtu,
(uint8_t)group->flags.sl,
(uint8_t)scope,
group->flags.Q_Key,
group->flags.TClass,
group->flags.FlowLabel,
&group->mgid);
}
}
}
static int partition_create(unsigned lineno, struct part_conf *conf,
char *name, char *id, char *flag, char *flag_val)
{
ib_net16_t pkey;
if (!id && name && isdigit(*name)) {
id = name;
name = NULL;
}
if (id) {
char *end;
pkey = cl_hton16((uint16_t)strtoul(id, &end, 0));
if (end == id || *end)
return -1;
} else
pkey = 0;
conf->p_prtn = osm_prtn_make_new(conf->p_log, conf->p_subn,
name, pkey);
if (!conf->p_prtn)
return -1;
if (!conf->p_subn->opt.qos && conf->flags.sl != OSM_DEFAULT_SL) {
OSM_LOG(conf->p_log, OSM_LOG_DEBUG, "Overriding SL %d"
" to default SL %d on partition %s"
" as QoS is not enabled.\n",
conf->flags.sl, OSM_DEFAULT_SL, name);
conf->flags.sl = OSM_DEFAULT_SL;
}
conf->p_prtn->sl = (uint8_t) conf->flags.sl;
if (conf->is_ipoib) {
struct precreate_mgroup broadcast_mgroup;
memset(&broadcast_mgroup, 0, sizeof(broadcast_mgroup));
broadcast_mgroup.mgid = osm_ipoib_broadcast_mgid;
pkey = CL_HTON16(0x8000) | conf->p_prtn->pkey;
memcpy(&broadcast_mgroup.mgid.raw[4], &pkey , sizeof(pkey));
broadcast_mgroup.flags.mtu = conf->flags.mtu;
broadcast_mgroup.flags.rate = conf->flags.rate;
broadcast_mgroup.flags.sl = conf->flags.sl;
broadcast_mgroup.flags.Q_Key = conf->flags.Q_Key ?
conf->flags.Q_Key :
OSM_IPOIB_BROADCAST_MGRP_QKEY;
broadcast_mgroup.flags.TClass = conf->flags.TClass;
broadcast_mgroup.flags.FlowLabel = conf->flags.FlowLabel;
__create_mgrp(conf, &broadcast_mgroup);
}
return 0;
}
static unsigned long int verify_val(unsigned lineno, osm_log_t *p_log,
char *flag, char *val)
{
char *end;
unsigned long int ret = strtoul(val, &end, 0);
if (val && *end)
OSM_LOG(p_log, OSM_LOG_VERBOSE,
"PARSE WARN: line %d: "
"suspicious val=(%s) detected. "
"flag=(%s)\n", lineno, val, flag);
return ret;
}
/* returns 1 if processed 0 if _not_ */
static int parse_group_flag(unsigned lineno, osm_log_t * p_log,
struct group_flags *flags,
char *flag, char *val)
{
int rc = 0;
int len = strlen(flag);
if (!strncmp(flag, "mtu", len)) {
rc = 1;
if (!val || (flags->mtu = verify_val(lineno, p_log, flag, val)) == 0)
OSM_LOG(p_log, OSM_LOG_VERBOSE,
"PARSE WARN: line %d: "
"flag \'mtu\' requires valid value"
" - skipped\n", lineno);
} else if (!strncmp(flag, "rate", len)) {
rc = 1;
if (!val || (flags->rate = verify_val(lineno, p_log, flag, val)) == 0)
OSM_LOG(p_log, OSM_LOG_VERBOSE,
"PARSE WARN: line %d: "
"flag \'rate\' requires valid value"
" - skipped\n", lineno);
} else if (!strncmp(flag, "scope", len)) {
unsigned int scope;
rc = 1;
if (!val || (scope = verify_val(lineno, p_log, flag, val)) == 0 || scope > 0xF)
OSM_LOG(p_log, OSM_LOG_VERBOSE,
"PARSE WARN: line %d: "
"flag \'scope\' requires valid value"
" - skipped\n", lineno);
else
flags->scope_mask |= (1<<scope);
} else if (!strncmp(flag, "Q_Key", strlen(flag))) {
rc = 1;
if (!val || (flags->Q_Key = verify_val(lineno, p_log, flag, val)) == 0)
OSM_LOG(p_log, OSM_LOG_VERBOSE,
"PARSE WARN: line %d: "
"flag \'Q_Key\' requires valid value"
" - using '0'\n", lineno);
} else if (!strncmp(flag, "TClass", strlen(flag))) {
rc = 1;
if (!val || (flags->TClass = verify_val(lineno, p_log, flag, val)) == 0)
OSM_LOG(p_log, OSM_LOG_VERBOSE,
"PARSE WARN: line %d: "
"flag \'TClass\' requires valid value"
" - using '0'\n", lineno);
} else if (!strncmp(flag, "sl", len)) {
unsigned sl;
char *end;
rc = 1;
if (!val || !*val || (sl = strtoul(val, &end, 0)) > 15 ||
(*end && !isspace(*end)))
OSM_LOG(p_log, OSM_LOG_VERBOSE,
"PARSE WARN: line %d: "
"flag \'sl\' requires valid value"
" - skipped\n", lineno);
else
flags->sl = sl;
} else if (!strncmp(flag, "FlowLabel", len)) {
uint32_t FlowLabel;
char *end;
rc = 1;
if (!val || !*val ||
(FlowLabel = strtoul(val, &end, 0)) > 0xFFFFF ||
(*end && !isspace(*end)))
OSM_LOG(p_log, OSM_LOG_VERBOSE,
"PARSE WARN: line %d: "
"flag \'FlowLabel\' requires valid value"
" - skipped\n", lineno);
else
flags->FlowLabel = FlowLabel;
}
return rc;
}
static int partition_add_flag(unsigned lineno, struct part_conf *conf,
char *flag, char *val)
{
int len = strlen(flag);
/* ipoib gc group flags are processed here. */
if (parse_group_flag(lineno, conf->p_log, &conf->flags, flag, val))
return 0;
/* partition flags go here. */
if (!strncmp(flag, "ipoib", len)) {
conf->is_ipoib = 1;
} else if (!strncmp(flag, "defmember", len)) {
if (!val || (strncmp(val, "limited", strlen(val))
&& strncmp(val, "both", strlen(val))
&& strncmp(val, "full", strlen(val))))
OSM_LOG(conf->p_log, OSM_LOG_VERBOSE,
"PARSE WARN: line %d: "
"flag \'defmember\' requires valid value (limited or full or both)"
" - skipped\n", lineno);
else {
if (!strncmp(val, "full", strlen(val)))
conf->membership = FULL;
else if (!strncmp(val, "both", strlen(val)))
conf->membership = BOTH;
else
conf->membership = LIMITED;
}
} else if (!strcmp(flag, "indx0"))
conf->indx0 = TRUE;
else {
OSM_LOG(conf->p_log, OSM_LOG_VERBOSE,
"PARSE WARN: line %d: "
"unrecognized partition flag \'%s\'"
" - ignored\n", lineno, flag);
}
return 0;
}
static void manage_membership_change(struct part_conf *conf, osm_prtn_t * p,
unsigned type, membership_t membership,
ib_net64_t guid)
{
cl_map_t *p_tbl;
cl_map_iterator_t p_next, p_item;
osm_physp_t *p_physp;
/* In allow_both_pkeys mode */
/* if membership of the PKEY is set to FULL */
/* need to clean up the part_guid_tbl table entry for this guid */
/* if membership of the PKEY is set to LIMITED */
/* need to clean up the full_guid_tbl table entry for this guid */
/* as it could be populated because of previous definitions */
if (!conf->p_subn->opt.allow_both_pkeys || membership == BOTH)
return;
switch (type){
/* ALL = 0 */
case 0:
cl_map_remove_all(membership == LIMITED ?
&p->full_guid_tbl : &p->part_guid_tbl);
break;
/* specific GUID */
case 0xFF:
cl_map_remove(membership == LIMITED ?
&p->full_guid_tbl : &p->part_guid_tbl,
cl_hton64(guid));
break;
case IB_NODE_TYPE_CA:
case IB_NODE_TYPE_SWITCH:
case IB_NODE_TYPE_ROUTER:
p_tbl = (membership == LIMITED) ?
&p->full_guid_tbl : &p->part_guid_tbl;
p_next = cl_map_head(p_tbl);
while (p_next != cl_map_end(p_tbl)) {
p_item = p_next;
p_next = cl_map_next(p_item);
p_physp = (osm_physp_t *) cl_map_obj(p_item);
if (osm_node_get_type(p_physp->p_node) == type)
cl_map_remove_item(p_tbl, p_item);
}
break;
default:
break;
}
}
static int partition_add_all(struct part_conf *conf, osm_prtn_t * p,
unsigned type, membership_t membership)
{
manage_membership_change(conf, p, type, membership, 0);
if (membership != LIMITED &&
osm_prtn_add_all(conf->p_log, conf->p_subn, p, type, TRUE, conf->indx0) != IB_SUCCESS)
return -1;
if ((membership == LIMITED ||
(membership == BOTH && conf->p_subn->opt.allow_both_pkeys)) &&
osm_prtn_add_all(conf->p_log, conf->p_subn, p, type, FALSE, conf->indx0) != IB_SUCCESS)
return -1;
return 0;
}
static int partition_add_port(unsigned lineno, struct part_conf *conf,
char *name, char *flag)
{
osm_prtn_t *p = conf->p_prtn;
ib_net64_t guid;
membership_t membership = conf->membership;
if (!name || !*name || !strncmp(name, "NONE", strlen(name)))
return 0;
if (flag) {
/* reset default membership to limited */
membership = LIMITED;
if (!strncmp(flag, "full", strlen(flag)))
membership = FULL;
else if (!strncmp(flag, "both", strlen(flag)))
membership = BOTH;
else if (strncmp(flag, "limited", strlen(flag))) {
OSM_LOG(conf->p_log, OSM_LOG_VERBOSE,
"PARSE WARN: line %d: "
"unrecognized port flag \'%s\'."
" Assume \'limited\'\n", lineno, flag);
}
}
if (!strncmp(name, "ALL", strlen(name)))
return partition_add_all(conf, p, 0, membership);
else if (!strncmp(name, "ALL_CAS", strlen(name)))
return partition_add_all(conf, p, IB_NODE_TYPE_CA, membership);
else if (!strncmp(name, "ALL_SWITCHES", strlen(name)))
return partition_add_all(conf, p, IB_NODE_TYPE_SWITCH,
membership);
else if (!strncmp(name, "ALL_ROUTERS", strlen(name)))
return partition_add_all(conf, p, IB_NODE_TYPE_ROUTER,
membership);
else if (!strncmp(name, "SELF", strlen(name))) {
guid = cl_ntoh64(conf->p_subn->sm_port_guid);
} else {
char *end;
guid = strtoull(name, &end, 0);
if (!guid || *end)
return -1;
}
manage_membership_change(conf, p, 0xFF, membership, guid);
if (membership != LIMITED &&
osm_prtn_add_port(conf->p_log, conf->p_subn, p,
cl_hton64(guid), TRUE, conf->indx0) != IB_SUCCESS)
return -1;
if ((membership == LIMITED ||
(membership == BOTH && conf->p_subn->opt.allow_both_pkeys)) &&
osm_prtn_add_port(conf->p_log, conf->p_subn, p,
cl_hton64(guid), FALSE, conf->indx0) != IB_SUCCESS)
return -1;
return 0;
}
/* conf file parser */
#define STRIP_HEAD_SPACES(p) while (*(p) == ' ' || *(p) == '\t' || \
*(p) == '\n') { (p)++; }
#define STRIP_TAIL_SPACES(p) { char *q = (p) + strlen(p); \
while ( q != (p) && ( *q == '\0' || \
*q == ' ' || *q == '\t' || \
*q == '\n')) { *q-- = '\0'; }; }
static int parse_name_token(char *str, char **name, char **val)
{
int len = 0;
char *p, *q;
*name = *val = NULL;
p = str;
while (*p == ' ' || *p == '\t' || *p == '\n')
p++;
q = strchr(p, '=');
if (q)
*q++ = '\0';
len = strlen(str) + 1;
str = q;
q = p + strlen(p);
while (q != p && (*q == '\0' || *q == ' ' || *q == '\t' || *q == '\n'))
*q-- = '\0';
*name = p;
p = str;
if (!p)
return len;
while (*p == ' ' || *p == '\t' || *p == '\n')
p++;
q = p + strlen(p);
len += (int)(q - str) + 1;
while (q != p && (*q == '\0' || *q == ' ' || *q == '\t' || *q == '\n'))
*q-- = '\0';
*val = p;
return len;
}
static int parse_mgroup_flags(osm_log_t * p_log,
struct precreate_mgroup *mgroup,
char *p, unsigned lineno)
{
int ret, len = 0;
char *flag, *val, *q;
do {
flag = val = NULL;
q = strchr(p, ',');
if (q)
*q++ = '\0';
ret = parse_name_token(p, &flag, &val);
if (!parse_group_flag(lineno, p_log, &mgroup->flags,
flag, val)) {
OSM_LOG(p_log, OSM_LOG_VERBOSE,
"PARSE WARN: line %d: "
"unrecognized mgroup flag \'%s\'"
" - ignored\n", lineno, flag);
}
p += ret;
len += ret;
} while (q);
return (len);
}
static int mgroup_create(char *p, char *mgid, unsigned lineno, struct part_conf *conf)
{
int ret = 0;
struct precreate_mgroup mgroup;
memset(&mgroup, 0, sizeof(mgroup));
if (inet_pton(AF_INET6, mgid, &mgroup.mgid) != 1
|| mgroup.mgid.raw[0] != 0xff) {
OSM_LOG(conf->p_log, OSM_LOG_ERROR,
"PARSE ERROR partition conf file line %d: "
"mgid \"%s\": gid is not multicast\n", lineno, mgid);
return 0;
}
/* inherit partition flags */
mgroup.flags.mtu = conf->flags.mtu;
mgroup.flags.rate = conf->flags.rate;
mgroup.flags.sl = conf->flags.sl;
mgroup.flags.Q_Key = conf->flags.Q_Key;
mgroup.flags.FlowLabel = conf->flags.FlowLabel;
mgroup.flags.scope_mask = conf->flags.scope_mask;
/* override with user specified flags */
ret = parse_mgroup_flags(conf->p_log, &mgroup, p, lineno);
/* check/verify special IP group parameters */
if (mgid_is_ip(&mgroup.mgid)) {
ib_net16_t pkey = conf->p_prtn->pkey | cl_hton16(0x8000);
if (!ip_mgroup_pkey_ok(conf, &mgroup)
|| !ip_mgroup_rate_ok(conf, &mgroup)
|| !ip_mgroup_mtu_ok(conf, &mgroup))
goto error;
/* set special IP settings */
memcpy(&mgroup.mgid.raw[4], &pkey, sizeof(pkey));
if (mgroup.flags.Q_Key == 0)
mgroup.flags.Q_Key = OSM_IPOIB_BROADCAST_MGRP_QKEY;
}
/* don't create multiple copies of the group */
if (osm_get_mgrp_by_mgid(conf->p_subn, &mgroup.mgid))
goto error;
/* create the group */
__create_mgrp(conf, &mgroup);
error:
return ret;
}
static struct part_conf *new_part_conf(osm_log_t * p_log, osm_subn_t * p_subn)
{
static struct part_conf part;
struct part_conf *conf = ∂
memset(conf, 0, sizeof(*conf));
conf->p_log = p_log;
conf->p_subn = p_subn;
conf->p_prtn = NULL;
conf->is_ipoib = 0;
conf->flags.sl = OSM_DEFAULT_SL;
conf->flags.rate = OSM_DEFAULT_MGRP_RATE;
conf->flags.mtu = OSM_DEFAULT_MGRP_MTU;
conf->membership = LIMITED;
conf->indx0 = FALSE;
return conf;
}
static int flush_part_conf(struct part_conf *conf)
{
memset(conf, 0, sizeof(*conf));
return 0;
}
static int parse_part_conf(struct part_conf *conf, char *str, int lineno)
{
int ret, len = 0;
char *name, *id, *flag, *flval;
char *q, *p;
p = str;
if (*p == '\t' || *p == '\0' || *p == '\n')
p++;
len += (int)(p - str);
str = p;
if (conf->p_prtn)
goto skip_header;
q = strchr(p, ':');
if (!q) {
OSM_LOG(conf->p_log, OSM_LOG_ERROR, "PARSE ERROR: line %d: "
"no partition definition found\n", lineno);
fprintf(stderr, "\nPARSE ERROR: line %d: "
"no partition definition found\n", lineno);
return -1;
}
*q++ = '\0';
str = q;
name = id = flag = flval = NULL;
q = strchr(p, ',');
if (q)
*q = '\0';
ret = parse_name_token(p, &name, &id);
p += ret;
len += ret;
while (q) {
flag = flval = NULL;
q = strchr(p, ',');
if (q)
*q++ = '\0';
ret = parse_name_token(p, &flag, &flval);
if (!flag) {
OSM_LOG(conf->p_log, OSM_LOG_ERROR,
"PARSE ERROR: line %d: "
"bad partition flags\n", lineno);
fprintf(stderr, "\nPARSE ERROR: line %d: "
"bad partition flags\n", lineno);
return -1;
}
p += ret;
len += ret;
partition_add_flag(lineno, conf, flag, flval);
}
if (p != str || (partition_create(lineno, conf,
name, id, flag, flval) < 0)) {
OSM_LOG(conf->p_log, OSM_LOG_ERROR, "PARSE ERROR: line %d: "
"bad partition definition\n", lineno);
fprintf(stderr, "\nPARSE ERROR: line %d: "
"bad partition definition\n", lineno);
return -1;
}
skip_header:
do {
name = flag = NULL;
q = strchr(p, ',');
if (q)
*q++ = '\0';
ret = parse_name_token(p, &name, &flag);
len += ret;
if (strcmp(name, "mgid") == 0) {
/* parse an mgid line if specified. */
len += mgroup_create(p+ret, flag, lineno, conf);
goto done; /* We're done: this consumes the line */
}
if (partition_add_port(lineno, conf, name, flag) < 0) {
OSM_LOG(conf->p_log, OSM_LOG_ERROR,
"PARSE ERROR: line %d: "
"bad PortGUID\n", lineno);
fprintf(stderr, "PARSE ERROR: line %d: "
"bad PortGUID\n", lineno);
return -1;
}
p += ret;
} while (q);
done:
return len;
}
/**
* @return 1 on error, 0 on success
*/
int osm_prtn_config_parse_file(osm_log_t * p_log, osm_subn_t * p_subn,
const char *file_name)
{
char line[4096];
struct part_conf *conf = NULL;
FILE *file;
int lineno;
int is_parse_success;
line[0] = '\0';
file = fopen(file_name, "r");
if (!file) {
OSM_LOG(p_log, OSM_LOG_VERBOSE,
"Cannot open config file \'%s\': %s\n",
file_name, strerror(errno));
return -1;
}
lineno = 0;
is_parse_success = 0;
while (fgets(line, sizeof(line) - 1, file) != NULL) {
char *q, *p = line;
lineno++;
p = line;
q = strchr(p, '#');
if (q)
*q = '\0';
do {
int len;
while (*p == ' ' || *p == '\t' || *p == '\n')
p++;
if (*p == '\0')
break;
if (!conf && !(conf = new_part_conf(p_log, p_subn))) {
OSM_LOG(p_log, OSM_LOG_ERROR,
"PARSE ERROR: line %d: "
"internal: cannot create config\n",
lineno);
fprintf(stderr,
"PARSE ERROR: line %d: "
"internal: cannot create config\n",
lineno);
is_parse_success = -1;
break;
}
q = strchr(p, ';');
if (q)
*q = '\0';
len = parse_part_conf(conf, p, lineno);
if (len < 0) {
is_parse_success = -1;
break;
}
is_parse_success = 1;
p += len;
if (q) {
flush_part_conf(conf);
conf = NULL;
}
} while (q);
if (is_parse_success == -1)
break;
}
fclose(file);
return (is_parse_success == 1) ? 0 : 1;
}