static int npa_remote_cb(struct msm_rpc_client *client, struct msm_rpc_xdr *xdr)
{
	int err = 0;
	int array_length = 0;
	unsigned int status = RPC_ACCEPTSTAT_SYSTEM_ERR;
	struct npa_remote_cb_data arg;
	npa_remote_callback cb_fn = NULL;

	xdr_recv_uint32(xdr, &arg.cb_id);
	xdr_recv_uint32(xdr, &arg.context);
	xdr_recv_uint32(xdr, &arg.type);
	xdr_recv_array(xdr, (void **)&arg.buffer, &array_length, INT_MAX,
			sizeof(int32_t), (void *)xdr_recv_int32);
	xdr_recv_uint32(xdr, &arg.size);

	cb_fn = (npa_remote_callback) msm_rpc_get_cb_func(client, arg.cb_id);
	if (cb_fn) {
		cb_fn((void *)arg.context, arg.type, arg.buffer, arg.size);
		status = RPC_ACCEPTSTAT_SUCCESS;
	}

	xdr_start_accepted_reply(xdr, status);
	err = xdr_send_msg(xdr);
	if (err) {
		pr_err("NPA Remote callback %s: send accepted reply failed: "
				"%d\n", __func__, err);
		BUG();
	}

	kfree(arg.buffer);

	return 0;
}
Пример #2
0
static void
makdi_dump_nfv_groups_cmd(struct c_ofp_s_chain_nfv_group_info *nfv_group_info,
                          void *arg, void (*cb_fn)(void *arg, void *pbuf))
{
    char *pbuf = calloc(1, SERV_CHAIN_PBUF_SZ);
    struct c_ofp_s_chain_nfv_info *_nfv_info;
    int nfv_counter = 0;
    uint8_t len = 0;

    if (!pbuf) return;

    nfv_group_info->nfv_group[MAX_NFV_NAME - 1] = '\0';
    len += snprintf(pbuf + len, SERV_CHAIN_PBUF_SZ - len - 1,
                    "add makdi-nfv-group %s\r\n", nfv_group_info->nfv_group);
    while (nfv_counter < nfv_group_info->nfv_list.num_nfvs) {
        _nfv_info = &nfv_group_info->nfv_list.nfv_info[nfv_counter++];
        _nfv_info->nfv[MAX_NFV_NAME - 1] = '\0';
        len += snprintf(pbuf + len, SERV_CHAIN_PBUF_SZ - len - 1,
                        "add makdi-nfv group %s nfv %s switch 0x%llx "
                        "in-port %hu out-port %hu\r\n",
                        nfv_group_info->nfv_group,
                        _nfv_info->nfv,
                        U642ULL(ntohll(_nfv_info->dpid)),
                        ntohs(_nfv_info->iif),
                        ntohs(_nfv_info->oif));
    }
    assert(len < SERV_CHAIN_PBUF_SZ - 1);

    cb_fn(arg, pbuf);
    free(pbuf);
    return;
}
Пример #3
0
/**
 * mul_fabric_show_hosts -
 *
 */
void
mul_fabric_show_hosts(void *service, bool active, bool dump_cmd,
                      void *arg, void (*cb_fn)(void *arg, char *pbuf))
{
    struct cbuf *b;
    struct c_ofp_auxapp_cmd *cofp_auc;
    struct c_ofp_host_mod *cofp_hm;
    char *pbuf;

    b = of_prep_msg(sizeof(struct c_ofp_auxapp_cmd),
                    C_OFPT_AUX_CMD, 0);

    cofp_auc = (void *)(b->data);
    cofp_auc->cmd_code = active ?
                         htonl(C_AUX_CMD_FAB_SHOW_ACTIVE_HOSTS): 
                         htonl(C_AUX_CMD_FAB_SHOW_INACTIVE_HOSTS);
    c_service_send(service, b);
    while (1) {
        b = c_service_wait_response(service);
        if (b) {
            if (check_reply_type(b, C_AUX_CMD_SUCCESS) ||
                !check_reply_type(b, C_AUX_CMD_FAB_HOST_ADD)) {
                free_cbuf(b);
                break;
            }
            cofp_auc = (void *)(b->data);
            cofp_hm = (void *)(cofp_auc->data);

            if (ntohs(cofp_auc->header.length)  <
                sizeof(*cofp_auc) + sizeof(*cofp_hm)) {
                free_cbuf(b);
                break;

            }
            
            if (!dump_cmd) {
                pbuf = fab_dump_single_host_from_flow(
                                    ntohll(cofp_hm->switch_id.datapath_id),
                                    &cofp_hm->host_flow);
            } else {
                pbuf = fab_dump_add_host_cmd_from_flow(
                                    ntohll(cofp_hm->switch_id.datapath_id),
                                    &cofp_hm->host_flow);
            }
            if (pbuf) {
                cb_fn(arg, pbuf); 
                free(pbuf);
            }
            free_cbuf(b);
        } else {
            break;
        }
    }
}
Пример #4
0
/*
 *
 * mul_makdi_show_nfv_stats - return the nfv ingress/egress port statistics
 *
 */
void
mul_makdi_show_nfv_stats(void *service, char* nfv_name,
                         void *arg, bool nbapi UNUSED,
                         void (*cb_fn)(void *arg, void *pbuf))
{
    struct cbuf *b;
    struct c_ofp_auxapp_cmd *cofp_auc;
    struct c_ofp_nfv_stats_show *cofp_nfv_stats;
    char *pbuf;

    if (!service)
        return;

    b = of_prep_msg(sizeof(struct c_ofp_auxapp_cmd) +   
                    sizeof(struct c_ofp_nfv_stats_show), C_OFPT_AUX_CMD, 0);

    cofp_auc = (void *) (b->data);
    cofp_auc->cmd_code = htonl(C_AUX_CMD_MAKDI_NFV_STATS);
    cofp_nfv_stats = (void *) (cofp_auc->data);
    strncpy(cofp_nfv_stats->name, nfv_name, MAX_NFV_NAME);

    c_service_send(service, b);
    while (1) {
        b = c_service_wait_response(service);
        if (b) {
            if (check_reply_type(b, C_AUX_CMD_SUCCESS) ||
                !check_reply_type(b, C_AUX_CMD_MUL_SWITCH_PORT_QUERY)) {
                free_cbuf(b);
                break;
            }
            pbuf = mul_dump_port_stats(b, true);
            if (pbuf) {
                cb_fn(arg, pbuf);
                free(pbuf);
            }
            free_cbuf(b);
        } else {
            break;
        }
    }

}
Пример #5
0
/**
 * mul_makdi_show_service_chain_cmd -
 *
 * Dump service chain user information in command format
 */
static void
makdi_dump_service_chain_cmd(struct c_ofp_s_chain_show *sc_info,
                             void *arg,
                             void (*cb_fn)(void *arg, void *pbuf)) 
{
    char *pbuf = calloc(1, SERV_CHAIN_PBUF_SZ);
    struct c_ofp_s_chain_show *_chain_info;
    struct c_ofp_s_chain_nfv_info *_nfv_info;
    int nfv_counter = 0;
    uint8_t len = 0;
    struct in_addr in;

    if (!pbuf) return;
    
    _chain_info = sc_info;
    in.s_addr = _chain_info->nw_src;
    len += snprintf(pbuf + len, SERV_CHAIN_PBUF_SZ - len - 1,
                    "add makdi-service-chain switch 0x%llx service %s "
                    "host-ip %s",
                    U642ULL(ntohll(_chain_info->dpid)),
                    _chain_info->service,
                    inet_ntoa(in));

    while (nfv_counter < 6) { /* Max number allowed by CLI may change */
        _nfv_info = &_chain_info->nfv_list.nfv_info[nfv_counter];
        len += snprintf(pbuf + len, SERV_CHAIN_PBUF_SZ - len - 1,
                        " nfv-grp%d %s",
                        nfv_counter+1,
                        nfv_counter < _chain_info->nfv_list.num_nfvs ?
                        _nfv_info->nfv_group : "*");
        nfv_counter++;
        assert(len < SERV_CHAIN_PBUF_SZ - 1);
    }

    len += snprintf(pbuf + len, SERV_CHAIN_PBUF_SZ - len - 1, "\r\n");
    assert(len < SERV_CHAIN_PBUF_SZ - 1);

    cb_fn(arg, pbuf);
    free(pbuf);
    return;
}
Пример #6
0
/**
 * makdi_dump_services_cmd -
 */
static void
makdi_dump_services_cmd(struct c_ofp_service_info *service_info,
                        void *arg,
                        void (*cb_fn)(void *arg, void *pbuf))
{
    char *pbuf = calloc(1, SERV_CHAIN_PBUF_SZ);
    struct c_ofp_service_info *_service_info;
    uint8_t len = 0;

    if (!pbuf) return;

    /*Dumping Service list*/
    _service_info = service_info;
    _service_info->service[MAX_NFV_NAME - 1] = '\0';
    len += snprintf(pbuf + len, SERV_CHAIN_PBUF_SZ - len - 1,
                    "add makdi-service %s vlan %hu\r\n",
                    _service_info->service,
                    ntohs(_service_info->vlan));
    assert(len < SERV_CHAIN_PBUF_SZ - 1);
    cb_fn(arg, pbuf);
    free(pbuf);
    return;
}
Пример #7
0
int dispc_gralloc_queue(setup_dispc_data_t *psDispcData, int ui32DispcDataLength, void (*cb_fn)(void *, int), void *cb_arg)
{
	__disp_layer_info_t         layer_info;
	int i,disp,hdl;
	int start_idx, layer_num = 0;
	__u32 num_screens;

	num_screens = bsp_disp_feat_get_num_screens();

	bsp_disp_cmd_cache(0);
	bsp_disp_cmd_cache(1);
	for(disp = 0; disp < num_screens; disp++)	{
		if(disp == 0)	{
			start_idx = 0;
			layer_num = psDispcData->primary_display_layer_num;
		}	else {
			start_idx = psDispcData->primary_display_layer_num;
			layer_num = psDispcData->post2_layers - psDispcData->primary_display_layer_num;
		}

		for(i=0; i<4; i++) {
			hdl = 100 + i;

			bsp_disp_layer_get_para(disp, hdl, &layer_info);
			if(layer_info.mode == DISP_LAYER_WORK_MODE_SCALER) {
				if((i >= layer_num) || (psDispcData->layer_info[start_idx + i].mode == DISP_LAYER_WORK_MODE_NORMAL)) {
					bsp_disp_layer_release(disp, hdl);
					bsp_disp_layer_request(disp, DISP_LAYER_WORK_MODE_NORMAL);
				}
			}
		}
	}

	for(disp = 0; disp < num_screens; disp++) {
		int haveFbTarget = 0;

		if(disp == 0)	{
			start_idx = 0;
			layer_num = psDispcData->primary_display_layer_num;
		}	else {
			start_idx = psDispcData->primary_display_layer_num;
			layer_num = psDispcData->post2_layers - psDispcData->primary_display_layer_num;
		}

		for(i=0; i<4; i++) {
			hdl = 100 + i;

			if(i < layer_num)	{
				memcpy(&layer_info, &psDispcData->layer_info[start_idx + i], sizeof(__disp_layer_info_t));

				if(layer_info.fb.mode == DISP_MOD_NON_MB_PLANAR) {
					if(layer_info.fb.format == DISP_FORMAT_YUV420) {
						layer_info.fb.addr[2] = layer_info.fb.addr[0] + layer_info.fb.size.width * layer_info.fb.size.height;
						layer_info.fb.addr[1] = layer_info.fb.addr[2] + (layer_info.fb.size.width * layer_info.fb.size.height)/4;
					}
				}
				bsp_disp_layer_set_para(disp, hdl, &layer_info);
				bsp_disp_layer_open(disp, hdl);
				bsp_disp_layer_set_top(disp, hdl);

				if(i==1 && (psDispcData->layer_info[start_idx + 1].prio < psDispcData->layer_info[start_idx].prio))	{
					haveFbTarget = 1;
				}
			}	else {
				bsp_disp_layer_close(disp, hdl);
			}

			if(haveFbTarget) {
				bsp_disp_layer_set_top(disp, 100);
			}
		}
	}

	bsp_disp_cmd_submit(0);
	bsp_disp_cmd_submit(1);

	mutex_lock(&g_fbi.runtime_lock);
	if(g_fbi.b_no_output) {
		cb_fn(cb_arg, 1);
	}	else {
		g_fbi.cb_fn = cb_fn;
		if(g_fbi.cb_w_conut >= 9)	{
			g_fbi.cb_w_conut = 0;
		}	else {
			g_fbi.cb_w_conut++;
		}
		g_fbi.cb_arg[g_fbi.cb_w_conut] = cb_arg;
		//printk(KERN_WARNING "##w_conut:%d %x %d\n", g_fbi.cb_w_conut, (unsigned int)cb_arg, psDispcData->post2_layers);
	}

	/* have external display */
	if(psDispcData->post2_layers > psDispcData->primary_display_layer_num) {
		g_fbi.reg_active[0] = 0;
		g_fbi.reg_active[1] = 0;
	} else {
		g_fbi.reg_active[0] = 0;
		g_fbi.reg_active[1] = 1;
	}
	mutex_unlock(&g_fbi.runtime_lock);

	return 0;
}
Пример #8
0
/*
 *
 * mul_makdi_show_nfv_stats_all - return the every nfv ingress/egress port statistics
 *
 */
void
mul_makdi_show_nfv_stats_all(void *service,  void *arg, bool nbapi, 
                             void (*cb_fn)(void *arg, void *pbuf))
{
    struct cbuf *b;
    struct c_ofp_auxapp_cmd *cofp_auc;
    struct c_ofp_switch_port_query *cofp_pq;
    int n_nfvs = 0;
    struct cbuf_head bufs;
    int retries = 0;
    char *pbuf;

    if (!service)
        return;
    
    cbuf_list_head_init(&bufs);


try_again:
    b = of_prep_msg(sizeof(struct c_ofp_auxapp_cmd), C_OFPT_AUX_CMD, 0);

    cofp_auc = (void *) (b->data);
    cofp_auc->cmd_code = htonl(C_AUX_CMD_MAKDI_NFV_STATS_ALL);

    c_service_send(service, b);
    while (1) {
        b = c_service_wait_response(service);
        if (b) {
            if (check_reply_type(b, C_AUX_CMD_SUCCESS) ||
                !check_reply_type(b, C_AUX_CMD_MUL_SWITCH_PORT_QUERY)) {
                free_cbuf(b);
                break;
            }
            cofp_auc = (void *) (b->data);
            cofp_pq = (void *) (cofp_auc->data);
            if (ntohs(cofp_auc->header.length) <
                    sizeof(*cofp_pq) + sizeof(*cofp_auc)) {
                free_cbuf(b);
                goto try_restart;
            }
            b = cbuf_realloc_headroom(b, 0, true);
            cbuf_list_queue_tail(&bufs, b);
            n_nfvs++;
        } else {
            goto try_restart;
        }
    }
    
    while ((b = cbuf_list_dequeue(&bufs))) {
        cofp_auc = (void *) (b->data);
        cofp_pq = (void *) (cofp_auc->data);
        if (nbapi) {
            cb_fn(arg, cofp_pq);
        } else {
            pbuf = makdi_dump_port_stats(cofp_auc, cofp_pq);
            if (pbuf) {
                cb_fn(arg, pbuf);
                free(pbuf);
            }
            free_cbuf(b);
        }
    }
    return;

try_restart:
    cbuf_list_purge(&bufs);
    if (retries++ >= C_SERV_RETRY_CNT) {
        cbuf_list_purge(&bufs);
        c_log_err("%s: Restarting serv msg", FN);
        goto try_again;
    }
    c_log_err("%s: Can't restart serv msg", FN);
    return;
}
Пример #9
0
/**
 * mul_makdi_show_nfv -
 */
int mul_makdi_show_servicechain_default(void *service, void *arg, bool nbapi,
        void (*cb_fn)(void *arg, void *pbuf)) {
    struct cbuf *b;
    struct c_ofp_auxapp_cmd *cofp_auc;
    struct c_ofp_default_rule_info *cofp_servicechain_default;
    char *pbuf;
    int n_services = 0;
    struct cbuf_head bufs;
    int retries = 0;

    if (!service)
        return -1;
    
    cbuf_list_head_init(&bufs);

try_again:
    b = of_prep_msg(sizeof(struct c_ofp_auxapp_cmd), C_OFPT_AUX_CMD, 0);

    cofp_auc = (void *) (b->data);
    cofp_auc->cmd_code = htonl(C_AUX_CMD_MAKDI_SHOW_DEFAULT_SERVICE);

    c_service_send(service, b);
    while (1) {
        b = c_service_wait_response(service);
        if (b) {
            if (check_reply_type(b, C_AUX_CMD_SUCCESS)
                    || !check_reply_type(b, C_AUX_CMD_MAKDI_SHOW_DEFAULT_SERVICE)) {
                free_cbuf(b);
                break;
            }
            cofp_auc = (void *) (b->data);
            cofp_servicechain_default = (void *) (cofp_auc->data);
            /*  FIXME : Length missmtach, header.length == 2050
                
            if (ntohs(cofp_nfv_group->header.length) < sizeof(*cofp_nfv_group))
            {   
                free_cbuf(b);
                goto try_restart;
            }
            */
            b = cbuf_realloc_headroom(b, 0, true);
            cbuf_list_queue_tail(&bufs, b);
            n_services++;
        } else {
            goto try_restart;
        }
    }

    while ((b = cbuf_list_dequeue(&bufs))) {
        cofp_auc = (void *) (b->data);
        cofp_servicechain_default = (void *)(cofp_auc->data);
        if (nbapi) {
            cb_fn(arg, cofp_servicechain_default);
        } else {
            pbuf = makdi_dump_servicechain_default(
                        cofp_servicechain_default);
            if (pbuf) {
                cb_fn(arg, pbuf);
                free(pbuf);
            }
            free_cbuf(b);
        }
    }
    return n_services;

try_restart:
    cbuf_list_purge(&bufs);
    if (retries++ >= C_SERV_RETRY_CNT) {
        cbuf_list_purge(&bufs);
        c_log_err("%s: Restarting serv msg", FN);
        goto try_again;
    }
    c_log_err("%s: Can't restart serv msg", FN);
    return 0;
}
Пример #10
0
/**
 * mul_makdi_show_nfv -
 */
int mul_makdi_show_nfv(void *service, void *arg, bool dump_cmd,
                       void (*cb_fn)(void *arg, void *pbuf))
{
    struct cbuf *b;
    struct c_ofp_auxapp_cmd *cofp_auc;
    struct c_ofp_s_chain_nfv_group_info *cofp_nfv_group;
    char *pbuf;
    int n_groups = 0;
    struct cbuf_head bufs;
    int retries = 0;

    if (!service)
        return -1;

    cbuf_list_head_init(&bufs);

try_again:
    b = of_prep_msg(sizeof(struct c_ofp_auxapp_cmd), C_OFPT_AUX_CMD, 0);

    cofp_auc = (void *) (b->data);
    cofp_auc->cmd_code = htonl(C_AUX_CMD_MAKDI_SHOW_NFV);

    c_service_send(service, b);
    while (1) {
        b = c_service_wait_response(service);
        if (b) {
            if (check_reply_type(b, C_AUX_CMD_SUCCESS) ||
                !check_reply_type(b, C_AUX_CMD_MAKDI_SHOW_NFV_GROUP)) {
                free_cbuf(b);
                break;
            }
            cofp_auc = (void *) (b->data);
            cofp_nfv_group = (void *) (cofp_auc->data);
            if (ntohs(cofp_auc->header.length)
                   < sizeof(*cofp_nfv_group) + sizeof(*cofp_auc)) {
                free_cbuf(b);
                goto try_restart;
            }
            b = cbuf_realloc_headroom(b, 0, true);
            cbuf_list_queue_tail(&bufs, b);
            n_groups++;
        } else {
            goto try_restart;
            break;
        }
    }
    
    while ((b = cbuf_list_dequeue(&bufs))) {
        cofp_auc = (void *) (b->data);
        cofp_nfv_group = (void *)(cofp_auc->data);
        if (dump_cmd) {
            makdi_dump_nfv_groups_cmd(cofp_nfv_group, arg, cb_fn);
        } else {
            pbuf = makdi_dump_nfv_groups(cofp_nfv_group);
            if (pbuf) {
                cb_fn(arg, pbuf);
                free(pbuf);
            }
        }
        free_cbuf(b);
    }
    return n_groups;

try_restart:
    cbuf_list_purge(&bufs);
    if (retries++ < C_SERV_RETRY_CNT) {
        cbuf_list_purge(&bufs);
        c_log_err("%s: Restarting serv msg", FN);
        goto try_again;
    }
    c_log_err("%s: Can't restart serv msg", FN);
    return 0;
}
Пример #11
0
/*
 * mul_makdi_show_user_stats_all - 
 * 
 * Return the every user statistics on service chain domain
 *
 */
int mul_makdi_show_user_stats_all(void *service,
        void *arg, bool nbapi, void (*cb_fn)(void *arg, void *pbuf))
{
    struct cbuf *b;
    struct c_ofp_auxapp_cmd *cofp_auc;
    struct c_ofp_user_stats_show *cofp_user_stats;  
    struct cbuf_head bufs;
    int retries = 0;
    int n_chains = 0;

    if (!service)
        return n_chains;
    
    cbuf_list_head_init(&bufs);

try_again:
    b = of_prep_msg(sizeof(struct c_ofp_auxapp_cmd), C_OFPT_AUX_CMD, 0);

    cofp_auc = (void *) (b->data);
    cofp_auc->cmd_code = htonl(C_AUX_CMD_MAKDI_USER_STATS_ALL);

    c_service_send(service, b);
    while (1) {
    b = c_service_wait_response(service);
    if (b) {
        if (check_reply_type(b, C_AUX_CMD_SUCCESS)
                    || !check_reply_type(b, C_AUX_CMD_MAKDI_USER_STATS_ALL)) {
            free_cbuf(b);
            break;
        }
        cofp_auc = (void *) (b->data);
        cofp_user_stats  = (void *) (cofp_auc->data);
        
        n_chains++;   
   
        if (nbapi) {
            cb_fn(arg, &cofp_user_stats->stats);
        } else {
            char *pbuf = calloc(1, SERV_CHAIN_PBUF_SZ);
            uint8_t len = 0;
            len += snprintf(pbuf + len, SERV_CHAIN_PBUF_SZ - len - 1, "User Flow : %sPacket_Count(%llu) : Byte_Count(%llu) : Bps(%s) : PPS(%s) \r\n", 
                    of_dump_flow(&cofp_user_stats->stats.flow, 0),
                    U642ULL(ntohll(cofp_user_stats->stats.packet_count)), 
                    U642ULL(ntohll(cofp_user_stats->stats.byte_count)), 
                    cofp_user_stats->stats.bps, cofp_user_stats->stats.pps);
            cb_fn(arg, pbuf);
            free_cbuf(b);
            free(pbuf);
        }
    } else {
        goto try_restart;
    }
    }
    return n_chains;

try_restart:
    cbuf_list_purge(&bufs);
    if (retries++ >= C_SERV_RETRY_CNT) {
        cbuf_list_purge(&bufs);
        c_log_err("%s: Restarting serv msg", FN);
        goto try_again;
    }
    c_log_err("%s: Can't restart serv msg", FN);
    return -1;
}
Пример #12
0
/*
 * mul_makdi_show_service_stats_all -
 *
 * Return every service ingress/egress port statistics
 *
 */
int mul_makdi_show_service_stats_all(void *service,
                                      void *arg, bool nbapi,
                                      void (*cb_fn)(void *arg, void *pbuf))
{
    struct cbuf *b;
    struct c_ofp_auxapp_cmd *cofp_auc;
    struct c_ofp_service_stats_show *cofp_services;
    struct cbuf_head bufs;
    int retries = 0;
    int n_chains = 0;

    if (!service)
        return n_chains;
    
    cbuf_list_head_init(&bufs);

try_again:
    b = of_prep_msg(sizeof(struct c_ofp_auxapp_cmd), C_OFPT_AUX_CMD, 0);

    cofp_auc = (void *) (b->data);
    cofp_auc->cmd_code = htonl(C_AUX_CMD_MAKDI_SERVICE_STATS_ALL);

    c_service_send(service, b);
    
    while (1) {
        b = c_service_wait_response(service);
        if (b) {
            if (check_reply_type(b, C_AUX_CMD_SUCCESS) ||
                !check_reply_type(b, C_AUX_CMD_MAKDI_SERVICE_STATS_ALL)) {
                free_cbuf(b);
                break;
            }
            cofp_auc = (void *) (b->data);
            cofp_services = (void *) (cofp_auc->data);

            if (ntohs(cofp_auc->header.length) <
                    sizeof(*cofp_services) + sizeof(*cofp_auc)) {
                free_cbuf(b);
                goto try_restart;
            }
            n_chains++;
 
            if (nbapi) {
                cb_fn(arg, &cofp_services->stats);
            } else {
                char *pbuf = calloc(1, SERV_CHAIN_PBUF_SZ);
                uint8_t len = 0;
                len += snprintf(pbuf + len, SERV_CHAIN_PBUF_SZ - len - 1, 
                            "Service(%s) : User IP(0x%04x) : dpid(0x%016llx) :"
                            " vlan(%hu) : Packet_Count(%llu) : Byte_Count(%llu)"
                            " : Bps(%s) : PPS(%s) : Inport(%hu) \r\n", 
                    cofp_services->service_name,
                    ntohl(cofp_services->stats.flow.ip.nw_src & 0xffffffff), 
                    U642ULL(ntohll(cofp_services->stats.datapath_id)), 
                    ntohs(cofp_services->stats.flow.dl_vlan), 
                    U642ULL(ntohll(cofp_services->stats.packet_count)), 
                    U642ULL(ntohll(cofp_services->stats.byte_count)), 
                    cofp_services->stats.bps,
                    cofp_services->stats.pps,
                    ntohl(cofp_services->stats.flow.in_port));
                cb_fn(arg, pbuf);
                free_cbuf(b);
                free(pbuf);
            }
        } else {
            goto try_restart;
        }
    }
        
    return n_chains;

try_restart:
    cbuf_list_purge(&bufs);
    if (retries++ >= C_SERV_RETRY_CNT) {
        cbuf_list_purge(&bufs);
        c_log_err("%s: Restarting serv msg", FN);
        goto try_again;
    }
    c_log_err("%s: Can't restart serv msg", FN);
    return 0;
}
Пример #13
0
void LearnEngine::LearnList::buffer_transmit()
{
  milliseconds time_to_sleep;
  size_t num_samples_to_send;
  std::unique_lock<std::mutex> lock(mutex);
  clock::time_point now = clock::now();
  while(!stop_transmit_thread &&
	buffer_tmp.size() == 0 &&
	(!with_timeout || num_samples == 0 || now < (buffer_started + timeout))) {
    if(with_timeout && num_samples > 0) {
      b_can_send.wait_until(lock, buffer_started + timeout);
    }
    else {
      b_can_send.wait(lock);
    }
    now = clock::now();
  }

  if(stop_transmit_thread) return;

  if(buffer_tmp.size() == 0) { // timeout -> we need to swap here
    num_samples_to_send = num_samples;
    swap_buffers();
  }
  else { // buffer full -> swapping was already done
    num_samples_to_send = max_samples;
  }

  last_sent = now;
  writer_busy = true;
  
  lock.unlock();

  msg_hdr_t msg_hdr = {0, list_id, buffer_id - 1,
		       (unsigned int) num_samples_to_send};

  if(learn_mode == LearnMode::WRITER) {
    // do not forget the -1 !!!
    // swap_buffers() is in charge of incrementing the count
    TransportIface::MsgBuf buf_hdr = {(char *) &msg_hdr, sizeof(msg_hdr)};
    TransportIface::MsgBuf buf_samples = {buffer_tmp.data(),
					  (unsigned int) buffer_tmp.size()};
    
    writer->send_msgs({buf_hdr, buf_samples}); // no lock for I/O
  }
  else if(learn_mode == LearnMode::CB) {
    std::unique_ptr<char []> buf(new char[buffer_tmp.size()]);
    std::copy(buffer_tmp.begin(), buffer_tmp.end(), &buf[0]);
    cb_fn(msg_hdr, buffer_tmp.size(), std::move(buf), cb_cookie); 
  }
  else {
    assert(learn_mode == LearnMode::NONE);
  }

  lock.lock();

  writer_busy = false;
  can_change_writer.notify_all();

  buffer_tmp.clear();

  b_can_swap.notify_one();
}