static struct ps_base *
rmt_ps_cas_create(struct rina_component * component)
{
struct rmt * rmt = rmt_from_component(component);
struct rmt_ps * ps = rkzalloc(sizeof(*ps), GFP_KERNEL);
struct cas_rmt_ps_data * data = rkzalloc(sizeof(*data), GFP_KERNEL);
if (!ps || !data) {
return NULL;
}
/* FIXME: to be configured using rmt_config */
data->q_max = 200;
ps->base.set_policy_set_param = rmt_cas_set_policy_set_param;
ps->dm = rmt;
ps->priv = data;
ps->rmt_q_create_policy = cas_rmt_q_create_policy;
ps->rmt_q_destroy_policy = cas_rmt_q_destroy_policy;
ps->rmt_enqueue_policy = cas_rmt_enqueue_policy;
ps->rmt_dequeue_policy = cas_rmt_dequeue_policy;
return &ps->base;
}
static struct pff * pff_create_gfp(struct robject * parent,
struct ipcp_instance * ipcp, gfp_t flags)
{
struct pff * tmp;
tmp = rkzalloc(sizeof(*tmp), flags);
if (!tmp)
return NULL;
tmp->rset = NULL;
rina_component_init(&tmp->base);
tmp->rset = rset_create_and_add("pff", parent);
if (!tmp->rset) {
LOG_ERR("Failed to create PFF sysfs entry");
pff_destroy(tmp);
return NULL;
}
tmp->ipcp = ipcp;
/* Try to select the default policy-set. */
if (pff_select_policy_set(tmp, "", RINA_PS_DEFAULT_NAME)) {
pff_destroy(tmp);
return NULL;
}
return tmp;
}
static struct cas_rmt_queue * cas_queue_create(port_id_t port_id)
{
struct cas_rmt_queue * tmp;
tmp = rkzalloc(sizeof(*tmp), GFP_ATOMIC);
if (!tmp)
return NULL;
tmp->queue = rfifo_create_ni();
if (!tmp->queue) {
rkfree(tmp);
return NULL;
}
tmp->port_id = port_id;
tmp->reg_cycles.prev_cycle.t_start.tv_sec = 0;
tmp->reg_cycles.prev_cycle.t_start.tv_nsec = 0;
tmp->reg_cycles.prev_cycle.t_last_start.tv_sec = 0;
tmp->reg_cycles.prev_cycle.t_last_start.tv_nsec = 0;
tmp->reg_cycles.prev_cycle.t_end.tv_sec = 0;
tmp->reg_cycles.prev_cycle.t_end.tv_nsec = 0;
tmp->reg_cycles.prev_cycle.sum_area = 0;
tmp->reg_cycles.prev_cycle.avg_len = 0;
tmp->reg_cycles.cur_cycle = tmp->reg_cycles.prev_cycle;
tmp->first_run = true;
return tmp;
}
static struct ps_base *
dtp_ps_default_create(struct rina_component * component)
{
struct dtp * dtp = dtp_from_component(component);
struct dtp_ps * ps = rkzalloc(sizeof(*ps), GFP_KERNEL);
if (!ps) {
return NULL;
}
ps->base.set_policy_set_param = dtp_ps_set_policy_set_param;
ps->dm = dtp;
ps->priv = NULL;
ps->transmission_control = default_transmission_control;
ps->closed_window = default_closed_window;
ps->flow_control_overrun = default_flow_control_overrun;
ps->initial_sequence_number = default_initial_sequence_number;
ps->receiver_inactivity_timer = default_receiver_inactivity_timer;
ps->sender_inactivity_timer = default_sender_inactivity_timer;
/* Just zero here. These fields are really initialized by
* dtp_select_policy_set. */
ps->dtcp_present = 0;
ps->seq_num_ro_th = 0;
ps->initial_a_timer = 0;
ps->partial_delivery = 0;
ps->incomplete_delivery = 0;
ps->in_order_delivery = 0;
ps->max_sdu_gap = 0;
return &ps->base;
}
struct connection * connection_create(void)
{
struct connection * tmp;
tmp = rkzalloc(sizeof(*tmp), GFP_KERNEL);
if (!tmp)
return NULL;
return tmp;
}
struct pci * pci_create_gfp(gfp_t flags)
{
struct pci * tmp;
tmp = rkzalloc(sizeof(*tmp), flags);
if (!tmp)
return NULL;
return tmp;
}
static struct ps_base *
rmt_ps_default_create(struct rina_component * component)
{
struct rmt * rmt = rmt_from_component(component);
struct rmt_ps * ps = rkzalloc(sizeof(*ps), GFP_KERNEL);
struct rmt_ps_data * data = rkzalloc(sizeof(*data), GFP_KERNEL);
if (!ps || !data) {
return NULL;
}
/* Allocate policy-set private data. */
data->ss = rkzalloc(sizeof(*data->ss), GFP_KERNEL);
if (!data->ss) {
rkfree(ps);
rkfree(data);
return NULL;
}
data->outqs = rmt_queue_set_create();
if (!data->outqs) {
rkfree(data->ss);
rkfree(ps);
rkfree(data);
return NULL;
}
ps->priv = data;
ps->base.set_policy_set_param = rmt_ps_set_policy_set_param;
ps->dm = rmt;
ps->max_q_policy_tx = default_max_q_policy_tx;
ps->max_q_policy_rx = default_max_q_policy_rx;
ps->rmt_q_monitor_policy_tx = default_rmt_q_monitor_policy_tx;
ps->rmt_q_monitor_policy_rx = default_rmt_q_monitor_policy_rx;
ps->rmt_next_scheduled_policy_tx = default_rmt_next_scheduled_policy_tx;
ps->rmt_enqueue_scheduling_policy_tx = default_rmt_enqueue_scheduling_policy_tx;
ps->rmt_scheduling_policy_rx = default_rmt_scheduling_policy_rx;
ps->rmt_scheduling_create_policy_tx = default_rmt_scheduling_create_policy_tx;
ps->rmt_scheduling_destroy_policy_tx = default_rmt_scheduling_destroy_policy_tx;
return &ps->base;
}
struct pdu * pdu_create_gfp(gfp_t flags)
{
struct pdu * tmp;
tmp = rkzalloc(sizeof(*tmp), flags);
if (!tmp)
return NULL;
tmp->pci = NULL;
tmp->buffer = NULL;
return tmp;
}
struct pdu_ser * pdu_ser_create_buffer_with_gfp(gfp_t flags,
struct buffer * buffer)
{
struct pdu_ser * tmp;
if (!buffer_is_ok(buffer))
return NULL;
tmp = rkzalloc(sizeof(*tmp), flags);
if (!tmp)
return NULL;
tmp->buf = buffer;
return tmp;
}
static struct serdes * serdes_create_gfp(gfp_t flags,
struct dt_cons * dt_cons)
{
struct serdes * tmp;
if (!dt_cons)
return NULL;
tmp = rkzalloc(sizeof(*tmp), flags);
if (!tmp)
return NULL;
tmp->dt_cons = dt_cons;
return tmp;
}
static struct rbmp * rbmp_create_gfp(gfp_t flags, size_t bits, ssize_t offset)
{
struct rbmp * tmp;
if (bits == 0)
return NULL;
tmp = rkzalloc(sizeof(*tmp), flags);
if (!tmp)
return NULL;
tmp->size = bits;
tmp->offset = offset;
bitmap_zero(tmp->bitmap, BITS_IN_BITMAP);
return tmp;
}
/*
* CREATE
*/
static struct ps_base * rmt_ps_deltaq_create(
struct rina_component * component) {
struct rmt * rmt = rmt_from_component(component);
rmtdata_p ps = rkzalloc(sizeof(*ps), GFP_KERNEL);
if (!ps) {
return NULL;
}
ps->base.base.set_policy_set_param = rmt_ps_set_policy_set_param;
ps->base.dm = rmt;
ps->base.priv = NULL;
ps->base.rmt_q_monitor_policy_rx = NULL;
ps->base.max_q_policy_rx = NULL;
/* Not used, in-drop at EFCP
/*
ps->base.rmt_scheduling_policy_rx = limiter_rx;
* instead
*/
ps->base.rmt_scheduling_policy_rx = NULL;
ps->base.rmt_q_monitor_policy_tx_enq = NULL;
ps->base.rmt_enqueue_scheduling_policy_tx = enqueue_tx;
ps->base.max_q_policy_tx = NULL;
ps->base.rmt_next_scheduled_policy_tx = dequeue_tx;
ps->base.rmt_q_monitor_policy_tx_deq = NULL;
ps->base.rmt_requeue_scheduling_policy_tx = requeue_tx;
ps->base.rmt_next_scheduled_policy_allownull = true;
ps->base.rmt_scheduling_create_policy_tx = rmt_ps_deltaq_create;
ps->base.rmt_scheduling_destroy_policy_tx = rmt_ps_deltaq_destroy;
ps->portvals_begin = NULL;
ps->qosparams_begin = NULL;
ps->bufferST_begin = NULL;
ps->bufferT_begin = NULL;
ps->bufferPDU_begin = NULL;
return &ps->base.base;
}
static struct ps_base *
pft_ps_default_create(struct rina_component * component)
{
struct pft * dtp = pft_from_component(component);
struct pft_ps * ps = rkzalloc(sizeof(*ps), GFP_KERNEL);
if (!ps) {
return NULL;
}
ps->base.set_policy_set_param = pft_ps_set_policy_set_param;
ps->dm = dtp;
ps->priv = NULL;
ps->next_hop = default_next_hop;
return &ps->base;
}
struct conn_policies * conn_policies_create(void)
{
struct conn_policies * tmp;
tmp = rkzalloc(sizeof(*tmp), GFP_KERNEL);
if (!tmp)
return NULL;
tmp->dtcp_cfg = dtcp_config_create();
if (!tmp->dtcp_cfg) {
LOG_ERR("Could not create dtcp_config");
rkfree(tmp);
return NULL;
}
tmp->initial_sequence_number = policy_create();
if (!tmp->initial_sequence_number) {
LOG_ERR("Could not create initial_sequence_number");
dtcp_config_destroy(tmp->dtcp_cfg);
rkfree(tmp);
return NULL;
}
tmp->receiver_inactivity_timer = policy_create();
if (!tmp->receiver_inactivity_timer) {
LOG_ERR("Could not create receiver_inactivity_timer policy");
dtcp_config_destroy(tmp->dtcp_cfg);
rkfree(tmp);
return NULL;
}
tmp->sender_inactivity_timer = policy_create();
if (!tmp->sender_inactivity_timer) {
LOG_ERR("Could not create sender_inactivity_timer policy");
dtcp_config_destroy(tmp->dtcp_cfg);
rkfree(tmp);
return NULL;
}
return tmp;
}
struct ipcp_factories * ipcpf_init(struct kobject * parent)
{
struct ipcp_factories * temp;
LOG_DBG("Initializing layer");
temp = rkzalloc(sizeof(*temp), GFP_KERNEL);
if (!temp)
return NULL;
temp->set = kset_create_and_add("ipcp-factories", NULL, parent);
if (!temp->set) {
LOG_ERR("Cannot initialize layer");
return NULL;
}
ASSERT(temp->set != NULL);
LOG_DBG("Layer initialized successfully");
return temp;
}
static struct ps_base *
rmt_ps_skeleton_create(struct rina_component * component)
{
struct rmt * rmt = rmt_from_component(component);
struct rmt_ps * ps = rkzalloc(sizeof(*ps), GFP_KERNEL);
if (!ps) {
return NULL;
}
ps->base.set_policy_set_param = rmt_ps_set_policy_set_param;
ps->dm = rmt;
ps->priv = NULL;
ps->max_q_policy_tx = skeleton_max_q_policy_tx;
ps->max_q_policy_rx = skeleton_max_q_policy_rx;
ps->rmt_q_monitor_policy_tx = skeleton_rmt_q_monitor_policy_tx;
ps->rmt_q_monitor_policy_rx = skeleton_rmt_q_monitor_policy_rx;
ps->rmt_next_scheduled_policy_tx = skeleton_rmt_next_scheduled_policy_tx;
ps->rmt_enqueue_scheduling_policy_tx = skeleton_rmt_enqueue_scheduling_policy_tx;
ps->rmt_scheduling_create_policy_tx = skeleton_rmt_scheduling_create_policy_tx;
ps->rmt_scheduling_destroy_policy_tx = skeleton_rmt_scheduling_destroy_policy_tx;
return &ps->base;
}
struct ipcp_factory * ipcpf_register(struct ipcp_factories * factories,
const char * name,
struct ipcp_factory_data * data,
const struct ipcp_factory_ops * ops)
{
struct ipcp_factory * factory;
LOG_DBG("Registering new factory");
if (!string_is_ok(name)) {
LOG_ERR("Name is bogus, cannot register factory");
return NULL;
}
if (!ops_are_ok(ops)) {
LOG_ERR("Cannot register factory '%s', ops are bogus", name);
return NULL;
}
if (!factories) {
LOG_ERR("Bogus parent, cannot register factory '%s", name);
return NULL;
}
factory = ipcpf_find(factories, name);
if (factory) {
LOG_ERR("Factory '%s' already registered", name);
return NULL;
}
LOG_DBG("Registering factory '%s'", name);
factory = rkzalloc(sizeof(*factory), GFP_KERNEL);
if (!factory)
return NULL;
factory->data = data;
factory->ops = ops;
factory->kobj.kset = factories->set;
if (kobject_init_and_add(&factory->kobj, &ipcp_factory_ktype, NULL,
"%s", name)) {
LOG_ERR("Cannot add factory '%s' to the set", name);
kobject_put(&factory->kobj);
rkfree(factory);
return NULL;
}
if (factory->ops->init(factory->data)) {
LOG_ERR("Cannot initialize factory '%s'", name);
kobject_put(&factory->kobj);
rkfree(factory);
return NULL;
}
/* Double checking for bugs */
LOG_INFO("Factory '%s' registered successfully",
kobject_name(&factory->kobj));
return factory;
}
