示例#1
0
文件: dtcp.c 项目: shinrs20/stack
/* FIXME: this should be completed with other parameters from the config */
static int dtcp_sv_init(struct dtcp * instance, struct dtcp_sv sv)
{
        struct dtcp_config * cfg;
        struct dtcp_ps * ps;

        if (!instance) {
                LOG_ERR("Bogus instance passed");
                return -1;
        }

        if (!instance->sv) {
                LOG_ERR("Bogus sv passed");
                return -1;
        }

        cfg = dtcp_config_get(instance);
        if (!cfg)
                return -1;

        *instance->sv = sv;
        spin_lock_init(&instance->sv->lock);

        rcu_read_lock();
        ps = container_of(rcu_dereference(instance->base.ps),
                          struct dtcp_ps, base);
        if (ps->rtx_ctrl)
                instance->sv->data_retransmit_max =
                        ps->rtx.data_retransmit_max;

        instance->sv->sndr_credit         = ps->flowctrl.window.initial_credit;
        instance->sv->snd_rt_wind_edge    = ps->flowctrl.window.initial_credit +
                        dtp_sv_last_nxt_seq_nr(dt_dtp(instance->parent));
        instance->sv->rcvr_credit         = ps->flowctrl.window.initial_credit;
        instance->sv->rcvr_rt_wind_edge   = ps->flowctrl.window.initial_credit;
        rcu_read_unlock();

        LOG_DBG("DTCP SV initialized with dtcp_conf:");
        LOG_DBG("  data_retransmit_max: %d",
                instance->sv->data_retransmit_max);
        LOG_DBG("  sndr_credit:         %u",
                instance->sv->sndr_credit);
        LOG_DBG("  snd_rt_wind_edge:    %u",
                instance->sv->snd_rt_wind_edge);
        LOG_DBG("  rcvr_credit:         %u",
                instance->sv->rcvr_credit);
        LOG_DBG("  rcvr_rt_wind_edge:   %u",
                instance->sv->rcvr_rt_wind_edge);

        return 0;
}
示例#2
0
static int
default_sender_inactivity_timer(struct dtp_ps * ps)
{
        struct dtp *         dtp = ps->dm;
        struct dt *          dt;
        struct dtcp *        dtcp;
        struct dtcp_ps *     dtcp_ps;
        struct dtcp_config * cfg;
        seq_num_t            max_sent, snd_rt_win, init_credit, next_send;

        LOG_DBG("default_sender_inactivity launched");

        if (!dtp) return 0;

        dt = dtp_dt(dtp);
        if (!dt)
                return -1;

        dtcp = dt_dtcp(dt);
        if (!dtp)
                return -1;

        dt_sv_drf_flag_set(dt, true);
        dtp_initial_sequence_number(dtp);

        cfg = dtcp_config_get(dtcp);
        if (!cfg)
                return -1;

        rcu_read_lock();
        dtcp_ps = dtcp_ps_get(dtcp);

        if (dtcp_ps->rtx_ctrl) {
                struct rtxq * q;

                q = dt_rtxq(dt);
                if (!q) {
                        rcu_read_unlock();
                        LOG_ERR("Couldn't find the Retransmission queue");
                        return -1;
                }
                rtxq_flush(q);
        }
        if (dtcp_ps->flow_ctrl) {
                struct cwq * cwq;

                cwq = dt_cwq(dt);
                ASSERT(cwq);
                if (cwq_flush(cwq)) {
                        rcu_read_unlock();
                        LOG_ERR("Coudln't flush cwq");
                        return -1;
                }
                dt_sv_window_closed_set(dt, false);
        }
        rcu_read_unlock();

        init_credit = dtcp_initial_credit(cfg);
        max_sent    = dtp_sv_max_seq_nr_sent(dtp);
        snd_rt_win  = dtcp_snd_rt_win(dtcp);
        next_send   = dtp_sv_last_nxt_seq_nr(dtp);

        LOG_DBG("Current values:\n\tinit_credit: %u "
                "max_sent: %u snd_rt_win: %u next_send: %u",
                init_credit, max_sent, snd_rt_win, next_send);

        dtcp_snd_rt_win_set(dtcp, next_send + init_credit);
        LOG_DBG("Resulting snd_rt_win_edge: %u", dtcp_snd_rt_win(dtcp));

        /*FIXME: Missing sending the control ack pdu */
        return 0;
}