static struct nlattr *
nla_next(struct nlattr *nla, size_t *rem)
{
*rem -= (size_t)NLA_ALIGN(nla->nla_len);
return (void *)((char *)nla + NLA_ALIGN(nla->nla_len));
}
int set_hw_app0(char *ifname, appgroup_attribs *app_data)
{
struct nlmsghdr *nlh;
struct rtattr *rta_parent, *rta_child;
printf("set_hw_app0: %s\n", ifname);
nlh = start_msg(RTM_SETDCB, DCB_CMD_SAPP);
if (NULL == nlh)
return -EIO;
add_rta(nlh, DCB_ATTR_IFNAME, (void *)ifname, strlen(ifname) + 1);
rta_parent = add_rta(nlh, DCB_ATTR_APP, NULL, 0);
rta_child = add_rta(nlh, DCB_APP_ATTR_IDTYPE,
(void *)&app_data->dcb_app_idtype, sizeof(__u8));
rta_parent->rta_len += NLA_ALIGN(rta_child->rta_len);
rta_child = add_rta(nlh, DCB_APP_ATTR_ID,
(void *)&app_data->dcb_app_id, sizeof(__u16));
rta_parent->rta_len += NLA_ALIGN(rta_child->rta_len);
rta_child = add_rta(nlh, DCB_APP_ATTR_PRIORITY,
(void *)&app_data->dcb_app_priority, sizeof(__u8));
rta_parent->rta_len += NLA_ALIGN(rta_child->rta_len);
if (send_msg(nlh))
return -EIO;
return(recv_msg(DCB_CMD_SAPP, DCB_ATTR_APP));
}
void cputimer_get(int tid, long long int *times, xbt_cpu_timer_t timer)
{
struct msgtemplate msg;
int rep_len;
struct nlattr *na;
struct taskstats *stats;
netlink_sock_send(timer->_id, TASKSTATS_CMD_GET, TASKSTATS_CMD_ATTR_PID, &tid, sizeof(__u32), timer);
rep_len = recv(timer->_nl_sd, &msg, sizeof(msg), 0);
xbt_assert(rep_len >= 0, "error while receiving the answer from netlink socket: %s", strerror(errno));
xbt_assert((msg.n.nlmsg_type != NLMSG_ERROR && NLMSG_OK((&msg.n), rep_len)),
"received a fatal error from the netlink socket: %s", strerror(errno));
rep_len = GENLMSG_PAYLOAD(&msg.n);
na = (struct nlattr *) GENLMSG_DATA(&msg);
int len = 0;
int aggr_len, len2;
while (len < rep_len) {
len += NLA_ALIGN(na->nla_len);
switch (na->nla_type) {
case TASKSTATS_TYPE_AGGR_PID:
aggr_len = NLA_PAYLOAD(na->nla_len);
len2 = 0;
/* For nested attributes, na follows */
na = (struct nlattr *) NLA_DATA(na);
while (len2 < aggr_len) {
switch (na->nla_type) {
case TASKSTATS_TYPE_PID:
break;
case TASKSTATS_TYPE_STATS:
/* here we collect info */
stats = (struct taskstats *) NLA_DATA(na);
//times[0] = (long long int)stats->ac_etime;
times[1] = (long long int) stats->ac_utime; /* User CPU time [usec] */
times[2] = (long long int) stats->ac_stime; /* SYstem CPU time [usec] */
break;
default:
XBT_ERROR("Unknown nested" " nla_type %d\n", na->nla_type);
break;
}
len2 += NLA_ALIGN(na->nla_len);
na = (struct nlattr *) ((char *) na + len2);
}
break;
default:
XBT_ERROR("Unknown nla_type %d\n", na->nla_type);
break;
}
na = (struct nlattr *) ((char *) GENLMSG_DATA(&msg) + len);
}
}
static void
parse_groups(struct nlattr *na, int tot_len)
{
int len;
int grp_len;
int aggr_len;
struct nlattr *grp_na;
int find = 0;
char group_name[GENL_NAMSIZ] = {0};
int group_id = -1;
len = 0;
while (len < tot_len) {
len += NLA_ALIGN(na->nla_len);
printf("grp #%02d\n", na->nla_type);
#if 0
if (na->nla_type > 1) {
/* only one group supported for now */
//na = (struct nlattr *) ((char *) na + len);
//continue;
printf("!!multi group, loop to find!!\n");
}
#endif
aggr_len = NLA_PAYLOAD_LEN(na->nla_len);
grp_na = (struct nlattr *) NLA_DATA(na);
grp_len = 0;
while (grp_len < aggr_len) {
grp_len += NLA_ALIGN(grp_na->nla_len);
switch (grp_na->nla_type) {
case CTRL_ATTR_MCAST_GRP_ID:
group_id = *(uint32_t *) NLA_DATA(grp_na);
printf("grp id = %d\n", nl_grp_id);
break;
case CTRL_ATTR_MCAST_GRP_NAME:
strcpy(group_name, (char *)NLA_DATA(grp_na));
printf("grp name %s\n", group_name);
break;
default:
printf("Unknown grp nested attr %d\n", grp_na->nla_type);
break;
}
grp_na = (struct nlattr *) ((char *) grp_na + grp_len);
}
if (-1 != group_id && strlen(group_name) > 0) {
if (0 == strcmp(group_name, nl_grp_name)) {
printf("find grp name:%s, id=%d\n", group_name, group_id);
nl_grp_id = group_id;
break;
}
}
na = (struct nlattr *) ((char *) na + len);
}
}
static int parse_attr(struct nlattr *tb[], int maxtype, struct nlattr *nla,
const struct nla_policy *policy, int len)
{
int nested_len = nla_len(nla) - NLA_ALIGN(len);
if (nested_len < 0)
return -EINVAL;
if (nested_len >= nla_attr_size(0))
return nla_parse(tb, maxtype, nla_data(nla) + NLA_ALIGN(len),
nested_len, policy);
memset(tb, 0, sizeof(struct nlattr *) * (maxtype + 1));
return 0;
}
static struct taskstats *
wait_taskstats (void)
{
static struct msgtemplate msg;
int rep_len;
for (;;) {
while ((rep_len = recv (netlink_socket, &msg, sizeof(msg), 0)) < 0 && errno == EINTR);
if (msg.n.nlmsg_type == NLMSG_ERROR ||
!NLMSG_OK((&msg.n), rep_len)) {
/* process died before we got to it or somesuch */
/* struct nlmsgerr *err = NLMSG_DATA(&msg);
fprintf (stderr, "fatal reply error, errno %d\n", err->error); */
return NULL;
}
int rep_len = GENLMSG_PAYLOAD(&msg.n);
struct nlattr *na = (struct nlattr *) GENLMSG_DATA(&msg);
int len = 0;
while (len < rep_len) {
len += NLA_ALIGN(na->nla_len);
switch (na->nla_type) {
case TASKSTATS_TYPE_AGGR_PID: {
int aggr_len = NLA_PAYLOAD(na->nla_len);
int len2 = 0;
/* For nested attributes, na follows */
na = (struct nlattr *) NLA_DATA(na);
/* find the record we care about */
while (na->nla_type != TASKSTATS_TYPE_STATS) {
len2 += NLA_ALIGN(na->nla_len);
if (len2 >= aggr_len)
goto next_attr;
na = (struct nlattr *) ((char *) na + len2);
}
return (struct taskstats *) NLA_DATA(na);
}
}
next_attr:
na = (struct nlattr *) (GENLMSG_DATA(&msg) + len);
}
}
return NULL;
}
static int flashnode_fill_isid(struct flashnode_rec *fnode, struct iovec *iov)
{
struct iscsi_flashnode_param_info *fnode_param;
struct nlattr *attr;
int len;
uint8_t isid[6];
len = sizeof(struct iscsi_flashnode_param_info) + 6;
iov->iov_base = iscsi_nla_alloc(ISCSI_FLASHNODE_ISID, len);
if (!iov->iov_base)
return 1;
attr = iov->iov_base;
iov->iov_len = NLA_ALIGN(attr->nla_len);
fnode_param = (struct iscsi_flashnode_param_info *)ISCSI_NLA_DATA(attr);
fnode_param->param = ISCSI_FLASHNODE_ISID;
fnode_param->len = 6;
sscanf(fnode->sess.isid, "%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx",
&isid[0], &isid[1], &isid[2], &isid[3], &isid[4], &isid[5]);
memcpy(fnode_param->value, isid, fnode_param->len);
return 0;
}
/*
* Probe the controller in genetlink to find the family id
* for the TASKSTATS family
*/
static int get_family_id(int sd)
{
struct {
struct nlmsghdr n;
struct genlmsghdr g;
char buf[256];
} ans;
int id = 0, rc;
struct nlattr *na;
int rep_len;
char name[100];
strcpy(name, TASKSTATS_GENL_NAME);
rc = send_cmd (sd, GENL_ID_CTRL, getpid(), CTRL_CMD_GETFAMILY,
CTRL_ATTR_FAMILY_NAME, (void *)name,
strlen(TASKSTATS_GENL_NAME)+1);
rep_len = recv(sd, &ans, sizeof(ans), 0);
if (ans.n.nlmsg_type == NLMSG_ERROR ||
(rep_len < 0) || !NLMSG_OK((&ans.n), rep_len))
return -1;
na = (struct nlattr *) GENLMSG_DATA(&ans);
na = (struct nlattr *) ((char *) na + NLA_ALIGN(na->nla_len));
if (na->nla_type == CTRL_ATTR_FAMILY_ID) {
id = *(__u16 *) NLA_DATA(na);
}
return id;
}
static void test_nfacct_del(struct netlink_info *netlink, const char *name)
{
struct nfgenmsg *hdr;
size_t len, name_len;
name_len = strlen(name) + 1;
len = NLMSG_ALIGN(sizeof(struct nfgenmsg)) +
NLA_ALIGN(sizeof(struct nlattr)) +
name_len;
hdr = g_malloc0(len);
hdr->nfgen_family = AF_UNSPEC;
hdr->version = NFNETLINK_V0;
hdr->res_id = 0;
append_attr_str(NLA_DATA(hdr), NFACCT_NAME, name_len, name);
netlink_send(netlink,
NFNL_SUBSYS_ACCT << 8 | NFNL_MSG_ACCT_DEL,
NLM_F_ACK, hdr, len,
test_nfacct_callback, NULL, NULL);
g_free(hdr);
}
/**
* Return next attribute in a stream of attributes.
* @arg nla Attribute of any kind.
* @arg remaining Variable to count remaining bytes in stream.
*
* Calculates the offset to the next attribute based on the attribute
* given. The attribute provided is assumed to be accessible, the
* caller is responsible to use nla_ok() beforehand. The offset (length
* of specified attribute including padding) is then subtracted from
* the remaining bytes variable and a pointer to the next attribute is
* returned.
*
* nla_next() can be called as long as remainig is >0.
*
* @return Pointer to next attribute.
*/
struct nlattr *nla_next(const struct nlattr *nla, int *remaining)
{
int totlen = NLA_ALIGN(nla->nla_len);
*remaining -= totlen;
return (struct nlattr *) ((char *) nla + totlen);
}
/*
* Probe the controller in genetlink to find the family id
* for the TASKSTATS family
*/
static int get_family_id(xbt_cpu_timer_t timer)
{
struct {
struct nlmsghdr n;
struct genlmsghdr g;
char buf[256];
} ans;
int id = 0;
struct nlattr *na;
int rep_len;
char name[100];
int sd = timer->_nl_sd;
strcpy(name, TASKSTATS_GENL_NAME);
netlink_sock_send(GENL_ID_CTRL, CTRL_CMD_GETFAMILY,
CTRL_ATTR_FAMILY_NAME, (void *) name, strlen(TASKSTATS_GENL_NAME) + 1, timer);
rep_len = recv(sd, &ans, sizeof(ans), 0);
xbt_assert(rep_len >= 0, "Answer to request on the family id is zero-sized");
xbt_assert(ans.n.nlmsg_type != NLMSG_ERROR && NLMSG_OK((&ans.n), rep_len),
"Error while retrieving the family id thru netlink: %s", strerror(errno));
na = (struct nlattr *) GENLMSG_DATA(&ans);
na = (struct nlattr *) ((char *) na + NLA_ALIGN(na->nla_len));
if (na->nla_type == CTRL_ATTR_FAMILY_ID) {
id = *(__u16 *) NLA_DATA(na);
}
return id;
}
/*
* ---------------------------------------------------------------------------
* Returns alligned length of the attribute.
* ---------------------------------------------------------------------------
*/
UINT32
NlAttrLenPad(const PNL_ATTR nla, UINT32 maxlen)
{
UINT32 len = NLA_ALIGN(nla->nlaLen);
return len <= maxlen ? len : nla->nlaLen;
}
int
nl_build_attr_linkinfo(struct nl_client *cl, struct vn_if *ifp)
{
char *link_info_buf;
int len;
struct nlattr *nla = (struct nlattr *)
((char *)cl->cl_buf + cl->cl_buf_offset);
len = NLA_HDRLEN + NLA_HDRLEN +
NLA_ALIGN(strlen(ifp->if_kind) + 1);
if (cl->cl_buf_offset + len > cl->cl_buf_len)
return -ENOMEM;
nla->nla_len = len;
nla->nla_type = IFLA_LINKINFO;
link_info_buf = (char *)nla + NLA_HDRLEN;
nla = (struct nlattr *)link_info_buf;
nla->nla_len = len - NLA_HDRLEN;
nla->nla_type = IFLA_INFO_KIND;
link_info_buf += NLA_HDRLEN;
strcpy(link_info_buf, ifp->if_kind);
cl->cl_buf_offset += len;
return 0;
}
int get_family_id(int sd)
{
struct msgtemplate msg;
int len;
int recv_len;
int rc;
struct nlattr *na;
rc = send_cmd(sd, GENL_ID_CTRL, CTRL_CMD_GETFAMILY,
CTRL_ATTR_FAMILY_NAME, SAMPLE_NETLINK_NL_FAMILY_NAME,
strlen(SAMPLE_NETLINK_NL_FAMILY_NAME)+1, NLM_F_REQUEST);
if (rc < 0) {
printf("Error sending family cmd (%d:%s)\n",
errno, strerror(errno));
return -1;
}
recv_len = recv(sd, &msg, sizeof(msg), 0);
if (msg.n.nlmsg_type == NLMSG_ERROR) {
printf("Error: recv family error msg\n");
return -1;
}
if (recv_len < 0) {
printf("Error: recv family (%d)\n", recv_len);
return -1;
}
if (!NLMSG_OK((&msg.n), recv_len)) {
printf("Error: recv family msg nok\n");
return -1;
}
len = 0;
recv_len = GENLMSG_PAYLOAD(&msg.n);
na = (struct nlattr *) GENLMSG_DATA(&msg);
while (len < recv_len) {
len += NLA_ALIGN(na->nla_len);
switch (na->nla_type) {
case CTRL_ATTR_FAMILY_ID:
nl_family_id = *(uint16_t *) NLA_DATA(na);
printf("family id:%d\n", nl_family_id);
break;
case CTRL_ATTR_MCAST_GROUPS:
parse_groups(NLA_DATA(na),
NLA_PAYLOAD_LEN(na->nla_len));
break;
case CTRL_ATTR_FAMILY_NAME:
case CTRL_ATTR_VERSION:
case CTRL_ATTR_HDRSIZE:
case CTRL_ATTR_MAXATTR:
case CTRL_ATTR_OPS:
printf("Unused family attr %d\n", na->nla_type);
break;
default:
printf("Unknown family attr %d\n", na->nla_type);
break;
}
na = (struct nlattr *) (GENLMSG_DATA(&msg) + len);
}
return nl_family_id;
}
static inline int nla_put_string(struct nlattr *nla, int type, const char *str)
{
int attrlen = strlen(str) + 1;
nla->nla_len = NLA_HDRLEN + attrlen;
nla->nla_type = type;
memcpy(nla_data(nla), str, attrlen);
return NLA_HDRLEN + NLA_ALIGN(attrlen);
}
struct nl_response *
nl_parse_gen_ctrl(struct nl_client *cl)
{
int len;
struct nlattr *nla;
struct genl_ctrl_message *msg;
char *buf = cl->cl_buf + cl->cl_buf_offset;
struct nl_response *resp = &cl->resp;
msg = (struct genl_ctrl_message *)cl->cl_resp_buf;
resp->nl_data = (uint8_t *)(msg);
memset(msg, 0, sizeof(*msg));
msg->family_id = -1;
len = cl->cl_msg_len - (cl->cl_buf_offset - cl->cl_msg_start);
nla = (struct nlattr *)buf;
while (len > 0 && len > NLA_HDRLEN) {
if (len < NLA_ALIGN(nla->nla_len))
return nl_set_resp_err(cl, -EINVAL);
switch (nla->nla_type) {
case CTRL_ATTR_FAMILY_NAME:
strncpy(msg->family_name, NLA_DATA(nla), sizeof(msg->family_name) - 1);
break;
case CTRL_ATTR_FAMILY_ID:
msg->family_id = *(unsigned short *)NLA_DATA(nla);
break;
default:
break;
}
cl->cl_buf_offset += NLA_ALIGN(nla->nla_len);
len -= NLA_ALIGN(nla->nla_len);
nla = (struct nlattr *)((char *)nla + NLA_ALIGN(nla->nla_len));
}
return resp;
}
void
parse_nl_attrs ()
{
unsigned int n_attrs = 0;
struct nlattr *na;
unsigned int data_len = GENLMSG_DATALEN (&ans.n);
reset_nl_attrs ();
na = (struct nlattr *) GENLMSG_DATA (&ans);
nl_attr[na->nla_type] = na;
data_len -= NLA_ALIGN (na->nla_len);
while (data_len > 0)
{
n_attrs++;
na = (struct nlattr *) GENLMSG_NLA_NEXT (na);
nl_attr[na->nla_type] = na;
data_len -= NLA_ALIGN (na->nla_len);
}
}
static int chap_fill_param_uint(struct iovec *iov, int param,
uint32_t param_val, int param_len)
{
struct iscsi_param_info *param_info;
struct nlattr *attr;
int len;
uint8_t val8 = 0;
uint16_t val16 = 0;
uint32_t val32 = 0;
char *val = NULL;
len = sizeof(struct iscsi_param_info) + param_len;
iov->iov_base = iscsi_nla_alloc(param, len);
if (!iov->iov_base)
return 1;
attr = iov->iov_base;
iov->iov_len = NLA_ALIGN(attr->nla_len);
param_info = (struct iscsi_param_info *)ISCSI_NLA_DATA(attr);
param_info->param = param;
param_info->len = param_len;
switch (param_len) {
case 1:
val8 = (uint8_t)param_val;
val = (char *)&val8;
break;
case 2:
val16 = (uint16_t)param_val;
val = (char *)&val16;
break;
case 4:
val32 = (uint32_t)param_val;
val = (char *)&val32;
break;
default:
goto free;
}
memcpy(param_info->value, val, param_len);
return 0;
free:
free(iov->iov_base);
iov->iov_base = NULL;
iov->iov_len = 0;
return 1;
}
/*
* Probe the controller in genetlink to find the family id
*/
int ResetManager::get_family_id(int sk, const char *family_name)
{
struct nlattr *na;
int rep_len;
int id = -1;
GENERIC_NETLINK_PACKET family_req, ans;
/* Get family name */
family_req.n.nlmsg_type = GENL_ID_CTRL;
family_req.n.nlmsg_flags = NLM_F_REQUEST;
family_req.n.nlmsg_seq = 0;
family_req.n.nlmsg_pid = getpid();
family_req.n.nlmsg_len = NLMSG_LENGTH(GENL_HDRLEN);
family_req.g.cmd = CTRL_CMD_GETFAMILY;
family_req.g.version = 0x1;
na = (struct nlattr *) GENLMSG_DATA(&family_req);
na->nla_type = CTRL_ATTR_FAMILY_NAME;
na->nla_len = strlen(family_name) + 1 + NLA_HDRLEN;
strcpy((char *)NLA_DATA(na), family_name);
family_req.n.nlmsg_len += NLMSG_ALIGN(na->nla_len);
if (sendto_fd(sk, (char *) &family_req, family_req.n.nlmsg_len) < 0) {
return -1;
}
rep_len = recv(sk, &ans, sizeof(ans), 0);
if (rep_len < 0){
LOGE("no response\n");
return -1;
}
/* Validate response message */
else if (!NLMSG_OK((&ans.n), (unsigned int)rep_len)){
LOGE("invalid reply message\n");
return -1;
}
else if (ans.n.nlmsg_type == NLMSG_ERROR) { /* error */
LOGE("received error\n");
return -1;
}
na = (struct nlattr *) GENLMSG_DATA(&ans);
na = (struct nlattr *) ((char *) na + NLA_ALIGN(na->nla_len));
if (na->nla_type == CTRL_ATTR_FAMILY_ID) {
id = *(__u16 *) NLA_DATA(na);
}
return id;
}
static int flashnode_fill_ipv6_addr(struct flashnode_rec *fnode,
struct iovec *iov, int param_type)
{
struct iscsi_flashnode_param_info *fnode_param;
struct nlattr *attr;
int len;
int rc;
len = sizeof(struct iscsi_flashnode_param_info) + 16;
iov->iov_base = iscsi_nla_alloc(param_type, len);
if (!iov->iov_base)
return 1;
attr = iov->iov_base;
iov->iov_len = NLA_ALIGN(attr->nla_len);
fnode_param = (struct iscsi_flashnode_param_info *)ISCSI_NLA_DATA(attr);
fnode_param->param = param_type;
fnode_param->len = 16;
switch (param_type) {
case ISCSI_FLASHNODE_IPADDR:
rc = inet_pton(AF_INET6, (char *)fnode->conn[0].ipaddress,
fnode_param->value);
break;
case ISCSI_FLASHNODE_REDIRECT_IPADDR:
rc = inet_pton(AF_INET6, (char *)fnode->conn[0].redirect_ipaddr,
fnode_param->value);
break;
case ISCSI_FLASHNODE_LINK_LOCAL_IPV6:
rc = inet_pton(AF_INET6, (char *)fnode->conn[0].link_local_ipv6,
fnode_param->value);
break;
default:
goto free;
}
if (rc <= 0)
goto free;
return 0;
free:
free(iov->iov_base);
iov->iov_base = NULL;
iov->iov_len = 0;
return 1;
}
/* Encapsulates 'msg', which must contain an OpenFlow message, in a Netlink
* message, and sends it to the OpenFlow local datapath numbered 'dp_idx' via
* 'sock'.
*
* Returns 0 if successful, otherwise a positive errno value. Returns EAGAIN
* if the 'sock' send buffer is full.
*
* If the send is successful, then the kernel module will receive it, but there
* is no guarantee that any reply will not be dropped (see nl_sock_transact()
* for details).
*/
int
dpif_send_openflow(struct dpif *dp, int dp_idx, struct ofpbuf *buffer)
{
struct ofp_header *oh;
unsigned int dump_flag;
struct ofpbuf hdr;
struct nlattr *nla;
uint32_t fixed_buffer[64 / 4];
struct iovec iov[3];
int pad_bytes;
int n_iov;
int retval;
/* The reply to OFPT_STATS_REQUEST may be multiple segments long, so we
* need to specify NLM_F_DUMP in the request. */
oh = ofpbuf_at_assert(buffer, 0, sizeof *oh);
dump_flag = oh->type == OFPT_STATS_REQUEST ? NLM_F_DUMP : 0;
ofpbuf_use(&hdr, fixed_buffer, sizeof fixed_buffer);
nl_msg_put_genlmsghdr(&hdr, dp->sock, 32, openflow_family,
NLM_F_REQUEST | dump_flag, DP_GENL_C_OPENFLOW, 1);
nl_msg_put_u32(&hdr, DP_GENL_A_DP_IDX, dp_idx);
nla = ofpbuf_put_uninit(&hdr, sizeof *nla);
nla->nla_len = sizeof *nla + buffer->size;
nla->nla_type = DP_GENL_A_OPENFLOW;
pad_bytes = NLA_ALIGN(nla->nla_len) - nla->nla_len;
nl_msg_nlmsghdr(&hdr)->nlmsg_len = hdr.size + buffer->size + pad_bytes;
n_iov = 2;
iov[0].iov_base = hdr.data;
iov[0].iov_len = hdr.size;
iov[1].iov_base = buffer->data;
iov[1].iov_len = buffer->size;
if (pad_bytes) {
static char zeros[NLA_ALIGNTO];
n_iov++;
iov[2].iov_base = zeros;
iov[2].iov_len = pad_bytes;
}
retval = nl_sock_sendv(dp->sock, iov, n_iov, false);
if (retval && retval != EAGAIN) {
VLOG_WARN_RL(&rl, "dpif_send_openflow: %s", strerror(retval));
}
return retval;
}
static int flashnode_fill_uint8(struct flashnode_rec *fnode, struct iovec *iov,
int param_type, uint8_t val)
{
struct iscsi_flashnode_param_info *fnode_param;
struct nlattr *attr;
int len;
len = sizeof(struct iscsi_flashnode_param_info) + 1;
iov->iov_base = iscsi_nla_alloc(param_type, len);
if (!iov->iov_base)
return 1;
attr = iov->iov_base;
iov->iov_len = NLA_ALIGN(attr->nla_len);
fnode_param = (struct iscsi_flashnode_param_info *)ISCSI_NLA_DATA(attr);
fnode_param->param = param_type;
fnode_param->len = 1;
fnode_param->value[0] = val;
return 0;
}
static int
nla_put_32(struct nlmsghdr *n, unsigned short maxlen,
unsigned short type, uint32_t data)
{
unsigned short len;
struct nlattr *nla;
len = NLA_ALIGN(NLA_HDRLEN + sizeof(data));
if (NLMSG_ALIGN(n->nlmsg_len) + len > maxlen) {
errno = ENOBUFS;
return -1;
}
nla = (struct nlattr *)NLMSG_TAIL(n);
nla->nla_type = type;
nla->nla_len = len;
memcpy(NLA_DATA(nla), &data, sizeof(data));
n->nlmsg_len = NLMSG_ALIGN(n->nlmsg_len) + len;
return 0;
}
static int flashnode_fill_str(struct flashnode_rec *fnode, struct iovec *iov,
int param_type, char *buf, int buflen)
{
struct iscsi_flashnode_param_info *fnode_param;
struct nlattr *attr;
int len;
len = sizeof(struct iscsi_flashnode_param_info) + buflen;
iov->iov_base = iscsi_nla_alloc(param_type, len);
if (!iov->iov_base)
return 1;
attr = iov->iov_base;
iov->iov_len = NLA_ALIGN(attr->nla_len);
fnode_param = (struct iscsi_flashnode_param_info *)ISCSI_NLA_DATA(attr);
fnode_param->param = param_type;
fnode_param->len = buflen;
memcpy(fnode_param->value, buf, fnode_param->len);
return 0;
}
/* returns: 0 on success
* 1 on failure
*/
static int set_numtcs(char *ifname, int tcid, __u8 numtcs)
{
struct nlmsghdr *nlh;
struct rtattr *rta_parent, *rta_child;
printf("set_numtcs_cfg: %s\n", ifname);
nlh = start_msg(RTM_SETDCB, DCB_CMD_SNUMTCS);
if (NULL == nlh)
return -EIO;
add_rta(nlh, DCB_ATTR_IFNAME, (void *)ifname, strlen(ifname) + 1);
rta_parent = add_rta(nlh, DCB_ATTR_NUMTCS, NULL, 0);
rta_child = add_rta(nlh, tcid, &numtcs, sizeof(__u8));
rta_parent->rta_len += NLA_ALIGN(rta_child->rta_len);
if (send_msg(nlh))
return -EIO;
return(recv_msg(DCB_CMD_SNUMTCS, DCB_ATTR_NUMTCS));
}
static int
nla_put_string(struct nlmsghdr *n, unsigned short maxlen,
unsigned short type, const char *data)
{
struct nlattr *nla;
size_t len, sl;
sl = strlen(data) + 1;
len = NLA_ALIGN(NLA_HDRLEN + sl);
if (NLMSG_ALIGN(n->nlmsg_len) + len > maxlen) {
errno = ENOBUFS;
return -1;
}
nla = (struct nlattr *)NLMSG_TAIL(n);
nla->nla_type = type;
nla->nla_len = (unsigned short)len;
memcpy(NLA_DATA(nla), data, sl);
n->nlmsg_len = NLMSG_ALIGN(n->nlmsg_len) + (unsigned short)len;
return 0;
}
static int chap_fill_param_str(struct iovec *iov, int param, char *param_val,
int param_len)
{
struct iscsi_param_info *param_info;
struct nlattr *attr;
int len;
len = sizeof(struct iscsi_param_info) + param_len;
iov->iov_base = iscsi_nla_alloc(param, len);
if (!iov->iov_base)
return 1;
attr = iov->iov_base;
iov->iov_len = NLA_ALIGN(attr->nla_len);
param_info = (struct iscsi_param_info *)ISCSI_NLA_DATA(attr);
param_info->param = param;
param_info->len = param_len;
memcpy(param_info->value, param_val, param_len);
return 0;
}
int
nl_build_mac_address(struct nl_client *cl, struct vn_if *ifp)
{
int len;
char *mac_buf;
struct nlattr *nla = (struct nlattr *)
((char *)cl->cl_buf + cl->cl_buf_offset);
len = NLA_HDRLEN + NLA_ALIGN(6);
if (cl->cl_buf_offset + len > cl->cl_buf_len)
return -ENOMEM;
nla->nla_len = len;
nla->nla_type = IFLA_ADDRESS;
mac_buf = (char *)nla + NLA_HDRLEN;
memcpy(mac_buf, ifp->if_mac, sizeof(ifp->if_mac));
cl->cl_buf_offset += nla->nla_len;
return 0;
}
int
nl_build_family_name_attr(struct nl_client *cl, char *family)
{
char *buf;
int len;
struct nlattr *nla = (struct nlattr *)
((char *)cl->cl_buf + cl->cl_buf_offset);
len = nl_family_name_attr_length(family);
if (cl->cl_buf_offset + len > cl->cl_buf_len)
return -ENOMEM;
nla->nla_len = len;
nla->nla_type = CTRL_ATTR_FAMILY_NAME;
cl->cl_buf_offset += NLA_HDRLEN;
buf = (char *)cl->cl_buf + cl->cl_buf_offset;
strcpy(buf, family);
cl->cl_buf_offset += NLA_ALIGN(strlen(family) + 1);
return 0;
}
int
nl_build_attr_ifname(struct nl_client *cl, struct vn_if *ifp)
{
char *if_name_buf;
int len;
struct nlattr *nla = (struct nlattr *)
((char *)cl->cl_buf + cl->cl_buf_offset);
len = NLA_HDRLEN + NLA_ALIGN(strlen(ifp->if_name) + 1);
if (cl->cl_buf_offset + len > cl->cl_buf_len)
return -ENOMEM;
nla->nla_len = len;
nla->nla_type = IFLA_IFNAME;
if_name_buf = (char *)nla + NLA_HDRLEN;
strcpy(if_name_buf, ifp->if_name);
cl->cl_buf_offset += nla->nla_len;
return 0;
}
