Projectname large_stringclasses 15
values | Filepath large_stringlengths 4 106 ⌀ | Function large_stringlengths 11 3.45k | Label list |
|---|---|---|---|
Linux Kernel | net/sched/sch_red.c |
static void red_reset(struct Qdisc *sch) {
struct red_sched_data *q = qdisc_priv(sch);
qdisc_reset(q->qdisc);
red_restart(&q->vars);
} | [
0,
0
] |
Linux Kernel | net/sched/sch_red.c |
static void red_destroy(struct Qdisc *sch) {
struct red_sched_data *q = qdisc_priv(sch);
tcf_qevent_destroy(&q->qe_mark, sch);
tcf_qevent_destroy(&q->qe_early_drop, sch);
del_timer_sync(&q->adapt_timer);
red_offload(sch, false);
qdisc_put(q->qdisc);
} | [
0,
0
] |
Linux Kernel | net/sched/sch_red.c |
static inline void red_adaptative_timer(struct timer_list *t) {
struct red_sched_data *q = from_timer(q, t, adapt_timer);
struct Qdisc *sch = q->sch;
spinlock_t *root_lock = qdisc_lock(qdisc_root_sleeping(sch));
spin_lock(root_lock);
red_adaptative_algo(&q->parms, &q->vars);
mod_timer(&q->adapt_timer, jif... | [
0,
0
] |
Linux Kernel | net/sched/sch_red.c |
static int red_init(struct Qdisc *sch, struct nlattr *opt,
struct netlink_ext_ack *extack) {
struct red_sched_data *q = qdisc_priv(sch);
struct nlattr *tb[TCA_RED_MAX + 1];
int err;
q->qdisc = &noop_qdisc;
q->sch = sch;
timer_setup(&q->adapt_timer, red_adaptative_timer, 0);
if (!opt... | [
0,
0
] |
Linux Kernel | net/sched/sch_red.c |
static int red_change(struct Qdisc *sch, struct nlattr *opt,
struct netlink_ext_ack *extack) {
struct red_sched_data *q = qdisc_priv(sch);
struct nlattr *tb[TCA_RED_MAX + 1];
int err;
err = nla_parse_nested_deprecated(tb, TCA_RED_MAX, opt, red_policy, extack);
if (err < 0)
return e... | [
0,
0
] |
Linux Kernel | net/sched/sch_red.c |
static int red_dump(struct Qdisc *sch, struct sk_buff *skb) {
struct red_sched_data *q = qdisc_priv(sch);
struct nlattr *opts = NULL;
struct tc_red_qopt opt = {
.limit = q->limit,
.flags = (q->flags & TC_RED_HISTORIC_FLAGS) | q->userbits,
.qth_min = q->parms.qth_min >> q->parms.Wlog,
.qth... | [
1,
0
] |
Linux Kernel | net/sched/sch_red.c |
static int red_dump_stats(struct Qdisc *sch, struct gnet_dump *d) {
struct red_sched_data *q = qdisc_priv(sch);
struct net_device *dev = qdisc_dev(sch);
struct tc_red_xstats st = {0};
if (sch->flags & TCQ_F_OFFLOADED) {
struct tc_red_qopt_offload hw_stats_request = {
.command = TC_RED_XSTATS,
... | [
1,
0
] |
Linux Kernel | net/sched/sch_red.c |
static void red_graft_offload(struct Qdisc *sch, struct Qdisc *new,
struct Qdisc *old,
struct netlink_ext_ack *extack) {
struct tc_red_qopt_offload graft_offload = {
.handle = sch->handle,
.parent = sch->parent,
.child_handle = new->handle... | [
0,
0
] |
Linux Kernel | net/sched/sch_red.c |
static int red_graft(struct Qdisc *sch, unsigned long arg, struct Qdisc *new,
struct Qdisc **old, struct netlink_ext_ack *extack) {
struct red_sched_data *q = qdisc_priv(sch);
if (new == NULL)
new = &noop_qdisc;
*old = qdisc_replace(sch, new, &q->qdisc);
red_graft_offload(sch, new, ... | [
0,
0
] |
Linux Kernel | net/sched/sch_red.c |
static struct Qdisc *red_leaf(struct Qdisc *sch, unsigned long arg) {
struct red_sched_data *q = qdisc_priv(sch);
return q->qdisc;
} | [
0,
0
] |
Linux Kernel | net/sched/sch_red.c |
static void __exit red_module_exit(void) { unregister_qdisc(&red_qdisc_ops); } | [
0,
0
] |
Linux Kernel | net/sched/sch_sfb.c |
static inline struct sfb_skb_cb *sfb_skb_cb(const struct sk_buff *skb) {
qdisc_cb_private_validate(skb, sizeof(struct sfb_skb_cb));
return (struct sfb_skb_cb *)qdisc_skb_cb(skb)->data;
} | [
1,
0
] |
Linux Kernel | net/sched/sch_sfb.c | static u32 sfb_hash(const struct sk_buff *skb, u32 slot) {
return sfb_skb_cb(skb)->hashes[slot];
} | [
0,
0
] |
Linux Kernel | net/sched/sch_sfb.c |
static u32 prob_minus(u32 p1, u32 p2) { return p1 > p2 ? p1 - p2 : 0; } | [
0,
0
] |
Linux Kernel | net/sched/sch_sfb.c | static void increment_one_qlen(u32 sfbhash, u32 slot,
struct sfb_sched_data *q) {
int i;
struct sfb_bucket *b = &q->bins[slot].bins[0][0];
for (i = 0; i < SFB_LEVELS; i++) {
u32 hash = sfbhash & SFB_BUCKET_MASK;
sfbhash >>= SFB_BUCKET_SHIFT;
if (b[hash].qlen < 0xFFFF)
... | [
1,
0
] |
Linux Kernel | net/sched/sch_sfb.c |
static void increment_qlen(const struct sfb_skb_cb *cb,
struct sfb_sched_data *q) {
u32 sfbhash;
sfbhash = cb->hashes[0];
if (sfbhash)
increment_one_qlen(sfbhash, 0, q);
sfbhash = cb->hashes[1];
if (sfbhash)
increment_one_qlen(sfbhash, 1, q);
} | [
0,
0
] |
Linux Kernel | net/sched/sch_sfb.c | static u32 sfb_compute_qlen(u32 *prob_r, u32 *avgpm_r,
const struct sfb_sched_data *q) {
int i;
u32 qlen = 0, prob = 0, totalpm = 0;
const struct sfb_bucket *b = &q->bins[q->slot].bins[0][0];
for (i = 0; i < SFB_LEVELS * SFB_NUMBUCKETS; i++) {
if (qlen < b->qlen)
qlen = b-... | [
1,
0
] |
Linux Kernel | net/sched/sch_sfb.c |
static void sfb_swap_slot(struct sfb_sched_data *q) {
sfb_init_perturbation(q->slot, q);
q->slot ^= 1;
q->double_buffering = false;
} | [
0,
0
] |
Linux Kernel | net/sched/sch_sfb.c | static bool sfb_rate_limit(struct sk_buff *skb, struct sfb_sched_data *q) {
if (q->penalty_rate == 0 || q->penalty_burst == 0)
return true;
if (q->tokens_avail < 1) {
unsigned long age = min(10UL * HZ, jiffies - q->token_time);
q->tokens_avail = (age * q->penalty_rate) / HZ;
if (q->tokens_avail > ... | [
1,
0
] |
Linux Kernel | net/sched/sch_sfb.c |
static struct sk_buff *sfb_peek(struct Qdisc *sch) {
struct sfb_sched_data *q = qdisc_priv(sch);
struct Qdisc *child = q->qdisc;
return child->ops->peek(child);
} | [
0,
0
] |
Linux Kernel | net/sched/sch_sfb.c |
static int sfb_dump_stats(struct Qdisc *sch, struct gnet_dump *d) {
struct sfb_sched_data *q = qdisc_priv(sch);
struct tc_sfb_xstats st = {
.earlydrop = q->stats.earlydrop,
.penaltydrop = q->stats.penaltydrop,
.bucketdrop = q->stats.bucketdrop,
.queuedrop = q->stats.queuedrop,
.childd... | [
1,
0
] |
Linux Kernel | net/sched/sch_sfb.c |
static int sfb_dump_class(struct Qdisc *sch, unsigned long cl,
struct sk_buff *skb, struct tcmsg *tcm) {
return -ENOSYS;
} | [
0,
0
] |
Linux Kernel | net/sched/sch_sfb.c |
static void sfb_unbind(struct Qdisc *sch, unsigned long arg) {} | [
0,
0
] |
Linux Kernel | net/sched/sch_sfb.c |
static int sfb_change_class(struct Qdisc *sch, u32 classid, u32 parentid,
struct nlattr **tca, unsigned long *arg,
struct netlink_ext_ack *extack) {
return -ENOSYS;
} | [
0,
0
] |
Linux Kernel | net/sched/sch_sfq.c | static int sfq_hard_mark(const struct sfq_sched_data *q) {
return (q->flags & (TC_RED_ECN | TC_RED_HARDDROP)) == TC_RED_ECN;
} | [
0,
0
] |
Linux Kernel | net/sched/sch_sfq.c |
static int sfq_headdrop(const struct sfq_sched_data *q) { return q->headdrop; } | [
0,
0
] |
Linux Kernel | net/sched/sch_sfq.c | static struct sk_buff *sfq_dequeue(struct Qdisc *sch) {
struct sfq_sched_data *q = qdisc_priv(sch);
struct sk_buff *skb;
sfq_index a, next_a;
struct sfq_slot *slot;
if (q->tail == NULL)
return NULL;
next_slot:
a = q->tail->next;
slot = &q->slots[a];
if (slot->allot <= 0) {
q->tail = slot;
... | [
0,
0
] |
Linux Kernel | net/sched/sch_sfq.c |
static void *sfq_alloc(size_t sz) { return kvmalloc(sz, GFP_KERNEL); } | [
0,
0
] |
Linux Kernel | net/sched/sch_sfq.c |
static void sfq_destroy(struct Qdisc *sch) {
struct sfq_sched_data *q = qdisc_priv(sch);
tcf_block_put(q->block);
q->perturb_period = 0;
del_timer_sync(&q->perturb_timer);
sfq_free(q->ht);
sfq_free(q->slots);
kfree(q->red_parms);
} | [
0,
0
] |
Linux Kernel | net/sched/sch_sfq.c |
static int sfq_dump(struct Qdisc *sch, struct sk_buff *skb) {
struct sfq_sched_data *q = qdisc_priv(sch);
unsigned char *b = skb_tail_pointer(skb);
struct tc_sfq_qopt_v1 opt;
struct red_parms *p = q->red_parms;
memset(&opt, 0, sizeof(opt));
opt.v0.quantum = q->quantum;
opt.v0.perturb_period = q->perturb... | [
1,
0
] |
Linux Kernel | net/sched/sch_sfq.c |
static int __init sfq_module_init(void) {
return register_qdisc(&sfq_qdisc_ops);
} | [
0,
0
] |
Linux Kernel | net/sched/sch_skbprio.c | static u16 calc_new_low_prio(const struct skbprio_sched_data *q) {
int prio;
for (prio = q->lowest_prio + 1; prio <= q->highest_prio; prio++) {
if (!skb_queue_empty(&q->qdiscs[prio]))
return prio;
}
return SKBPRIO_MAX_PRIORITY - 1;
} | [
1,
0
] |
Linux Kernel | net/sched/sch_skbprio.c |
static int skbprio_change(struct Qdisc *sch, struct nlattr *opt,
struct netlink_ext_ack *extack) {
struct tc_skbprio_qopt *ctl = nla_data(opt);
if (opt->nla_len != nla_attr_size(sizeof(*ctl)))
return -EINVAL;
sch->limit = ctl->limit;
return 0;
} | [
0,
0
] |
Linux Kernel | net/sched/sch_skbprio.c |
static int skbprio_dump(struct Qdisc *sch, struct sk_buff *skb) {
struct tc_skbprio_qopt opt;
opt.limit = sch->limit;
if (nla_put(skb, TCA_OPTIONS, sizeof(opt), &opt))
return -1;
return skb->len;
} | [
1,
0
] |
Linux Kernel | net/sched/sch_skbprio.c |
static void skbprio_reset(struct Qdisc *sch) {
struct skbprio_sched_data *q = qdisc_priv(sch);
int prio;
for (prio = 0; prio < SKBPRIO_MAX_PRIORITY; prio++)
__skb_queue_purge(&q->qdiscs[prio]);
memset(&q->qstats, 0, sizeof(q->qstats));
q->highest_prio = 0;
q->lowest_prio = SKBPRIO_MAX_PRIORITY - 1;
} | [
1,
0
] |
Linux Kernel | net/sched/sch_skbprio.c |
static void skbprio_destroy(struct Qdisc *sch) {
struct skbprio_sched_data *q = qdisc_priv(sch);
int prio;
for (prio = 0; prio < SKBPRIO_MAX_PRIORITY; prio++)
__skb_queue_purge(&q->qdiscs[prio]);
} | [
0,
0
] |
Linux Kernel | net/sched/sch_skbprio.c |
static struct Qdisc *skbprio_leaf(struct Qdisc *sch, unsigned long arg) {
return NULL;
} | [
0,
0
] |
Linux Kernel | net/sched/sch_skbprio.c |
static int skbprio_dump_class_stats(struct Qdisc *sch, unsigned long cl,
struct gnet_dump *d) {
struct skbprio_sched_data *q = qdisc_priv(sch);
if (gnet_stats_copy_queue(d, NULL, &q->qstats[cl - 1],
q->qstats[cl - 1].qlen) < 0)
return -1;
return... | [
0,
0
] |
Linux Kernel | net/sched/sch_taprio.c |
static void switch_schedules(struct taprio_sched *q,
struct sched_gate_list **admin,
struct sched_gate_list **oper) {
rcu_assign_pointer(q->oper_sched, *admin);
rcu_assign_pointer(q->admin_sched, NULL);
if (*oper)
call_rcu(&(*oper)->rcu, taprio_free_... | [
0,
0
] |
Linux Kernel | net/sched/sch_taprio.c | static s32 get_cycle_time_elapsed(struct sched_gate_list *sched, ktime_t time) {
ktime_t time_since_sched_start;
s32 time_elapsed;
time_since_sched_start = ktime_sub(time, sched->base_time);
div_s64_rem(time_since_sched_start, sched->cycle_time, &time_elapsed);
return time_elapsed;
} | [
0,
0
] |
Linux Kernel | net/sched/sch_taprio.c | static int taprio_enqueue_one(struct sk_buff *skb, struct Qdisc *sch,
struct Qdisc *child, struct sk_buff **to_free) {
struct taprio_sched *q = qdisc_priv(sch);
struct net_device *dev = qdisc_dev(sch);
int prio = skb->priority;
u8 tc;
if (skb->sk && sk_fullsock(skb->sk) && sock_... | [
0,
0
] |
Linux Kernel | net/sched/sch_taprio.c | static int taprio_enqueue(struct sk_buff *skb, struct Qdisc *sch,
struct sk_buff **to_free) {
struct taprio_sched *q = qdisc_priv(sch);
struct Qdisc *child;
int queue;
queue = skb_get_queue_mapping(skb);
child = q->qdiscs[queue];
if (unlikely(!child))
return qdisc_drop(skb, s... | [
1,
0
] |
Linux Kernel | net/sched/sch_taprio.c | static struct sk_buff *taprio_peek(struct Qdisc *sch) {
struct taprio_sched *q = qdisc_priv(sch);
struct net_device *dev = qdisc_dev(sch);
struct sched_entry *entry;
struct sk_buff *skb;
u32 gate_mask;
int i;
rcu_read_lock();
entry = rcu_dereference(q->current_entry);
gate_mask = entry ? entry->gate_... | [
0,
0
] |
Linux Kernel | net/sched/sch_taprio.c | static struct sk_buff *taprio_dequeue(struct Qdisc *sch) {
struct taprio_sched *q = qdisc_priv(sch);
struct net_device *dev = qdisc_dev(sch);
struct sk_buff *skb = NULL;
struct sched_entry *entry;
u32 gate_mask;
int i;
rcu_read_lock();
entry = rcu_dereference(q->current_entry);
gate_mask = entry ? e... | [
1,
0
] |
Linux Kernel | net/sched/sch_taprio.c | static int fill_sched_entry(struct taprio_sched *q, struct nlattr **tb,
struct sched_entry *entry,
struct netlink_ext_ack *extack) {
int min_duration = length_to_duration(q, ETH_ZLEN);
u32 interval = 0;
if (tb[TCA_TAPRIO_SCHED_ENTRY_CMD])
entry->command... | [
0,
0
] |
Linux Kernel | net/sched/sch_taprio.c | static void setup_first_close_time(struct taprio_sched *q,
struct sched_gate_list *sched,
ktime_t base) {
struct sched_entry *first;
ktime_t cycle;
first = list_first_entry(&sched->entries, struct sched_entry, list);
cycle = sched->cycle_ti... | [
0,
1
] |
Linux Kernel | net/sched/sch_taprio.c |
static void setup_txtime(struct taprio_sched *q, struct sched_gate_list *sched,
ktime_t base) {
struct sched_entry *entry;
u32 interval = 0;
list_for_each_entry(entry, &sched->entries, list) {
entry->next_txtime = ktime_add_ns(base, interval);
interval += entry->interval;
}
} | [
0,
0
] |
Linux Kernel | net/sched/sch_taprio.c |
void taprio_offload_free(struct tc_taprio_qopt_offload *offload) {
struct __tc_taprio_qopt_offload *__offload;
__offload = container_of(offload, struct __tc_taprio_qopt_offload, offload);
if (!refcount_dec_and_test(&__offload->users))
return;
kfree(__offload);
} | [
0,
0
] |
Linux Kernel | net/sched/sch_taprio.c |
static int taprio_mqprio_cmp(const struct net_device *dev,
const struct tc_mqprio_qopt *mqprio) {
int i;
if (!mqprio || mqprio->num_tc != dev->num_tc)
return -1;
for (i = 0; i < mqprio->num_tc; i++)
if (dev->tc_to_txq[i].count != mqprio->count[i] ||
dev->tc_to_txq[i... | [
1,
0
] |
Linux Kernel | net/sched/sch_taprio.c | static void taprio_destroy(struct Qdisc *sch) {
struct taprio_sched *q = qdisc_priv(sch);
struct net_device *dev = qdisc_dev(sch);
struct sched_gate_list *oper, *admin;
unsigned int i;
list_del(&q->taprio_list);
hrtimer_cancel(&q->advance_timer);
taprio_disable_offload(dev, q, NULL);
if (q->qdiscs) ... | [
0,
0
] |
Linux Kernel | net/sched/sch_taprio.c | static int taprio_init(struct Qdisc *sch, struct nlattr *opt,
struct netlink_ext_ack *extack) {
struct taprio_sched *q = qdisc_priv(sch);
struct net_device *dev = qdisc_dev(sch);
int i;
spin_lock_init(&q->current_entry_lock);
hrtimer_init(&q->advance_timer, CLOCK_TAI, HRTIMER_MODE_ABS... | [
1,
0
] |
Linux Kernel | net/sched/sch_taprio.c |
static struct Qdisc *taprio_leaf(struct Qdisc *sch, unsigned long cl) {
struct netdev_queue *dev_queue = taprio_queue_get(sch, cl);
if (!dev_queue)
return NULL;
return dev_queue->qdisc_sleeping;
} | [
0,
0
] |
Linux Kernel | net/sched/sch_taprio.c |
static struct netdev_queue *taprio_select_queue(struct Qdisc *sch,
struct tcmsg *tcm) {
return taprio_queue_get(sch, TC_H_MIN(tcm->tcm_parent));
} | [
0,
0
] |
Linux Kernel | net/sched/sch_tbf.c | static u64 psched_ns_t2l(const struct psched_ratecfg *r, u64 time_in_ns) {
u64 len = time_in_ns * r->rate_bytes_ps;
do_div(len, NSEC_PER_SEC);
if (unlikely(r->linklayer == TC_LINKLAYER_ATM)) {
do_div(len, 53);
len = len * 48;
}
if (len > r->overhead)
len -= r->overhead;
else
len = 0;
... | [
0,
0
] |
Linux Kernel | net/sched/sch_tbf.c |
static int tbf_offload_dump(struct Qdisc *sch) {
struct tc_tbf_qopt_offload qopt;
qopt.command = TC_TBF_STATS;
qopt.handle = sch->handle;
qopt.parent = sch->parent;
qopt.stats.bstats = &sch->bstats;
qopt.stats.qstats = &sch->qstats;
return qdisc_offload_dump_helper(sch, TC_SETUP_QDISC_TBF, &qopt);
} | [
0,
0
] |
Linux Kernel | net/sched/sch_tbf.c | static int tbf_segment(struct sk_buff *skb, struct Qdisc *sch,
struct sk_buff **to_free) {
struct tbf_sched_data *q = qdisc_priv(sch);
struct sk_buff *segs, *nskb;
netdev_features_t features = netif_skb_features(skb);
unsigned int len = 0, prev_len = qdisc_pkt_len(skb);
int ret, nb;
... | [
1,
0
] |
Linux Kernel | net/sched/sch_tbf.c |
static int tbf_enqueue(struct sk_buff *skb, struct Qdisc *sch,
struct sk_buff **to_free) {
struct tbf_sched_data *q = qdisc_priv(sch);
unsigned int len = qdisc_pkt_len(skb);
int ret;
if (qdisc_pkt_len(skb) > q->max_size) {
if (skb_is_gso(skb) && skb_gso_validate_mac_len(skb, q->max_... | [
1,
0
] |
Linux Kernel | net/sched/sch_tbf.c |
static void tbf_destroy(struct Qdisc *sch) {
struct tbf_sched_data *q = qdisc_priv(sch);
qdisc_watchdog_cancel(&q->watchdog);
tbf_offload_destroy(sch);
qdisc_put(q->qdisc);
} | [
0,
0
] |
Linux Kernel | net/sched/sch_tbf.c |
static int tbf_dump_class(struct Qdisc *sch, unsigned long cl,
struct sk_buff *skb, struct tcmsg *tcm) {
struct tbf_sched_data *q = qdisc_priv(sch);
tcm->tcm_handle |= TC_H_MIN(1);
tcm->tcm_info = q->qdisc->handle;
return 0;
} | [
0,
0
] |
Linux Kernel | net/sched/sch_tbf.c |
static void __exit tbf_module_exit(void) { unregister_qdisc(&tbf_qdisc_ops); } | [
0,
0
] |
Linux Kernel | net/sched/sch_teql.c |
static void teql_destroy(struct Qdisc *sch) {
struct Qdisc *q, *prev;
struct teql_sched_data *dat = qdisc_priv(sch);
struct teql_master *master = dat->m;
if (!master)
return;
prev = master->slaves;
if (prev) {
do {
q = NEXT_SLAVE(prev);
if (q == sch) {
NEXT_SLAVE(prev) = NEXT_... | [
0,
0
] |
Linux Kernel | net/sched/sch_teql.c |
static int __teql_resolve(struct sk_buff *skb, struct sk_buff *skb_res,
struct net_device *dev, struct netdev_queue *txq,
struct dst_entry *dst) {
struct neighbour *n;
int err = 0;
n = dst_neigh_lookup_skb(dst, skb);
if (!n)
return -ENOENT;
if (dst->... | [
0,
0
] |
Linux Kernel | net/sched/sch_teql.c | static int teql_master_open(struct net_device *dev) {
struct Qdisc *q;
struct teql_master *m = netdev_priv(dev);
int mtu = 0xFFFE;
unsigned int flags = IFF_NOARP | IFF_MULTICAST;
if (m->slaves == NULL)
return -EUNATCH;
flags = FMASK;
q = m->slaves;
do {
struct net_device *slave = qdisc_dev(q)... | [
1,
0
] |
Linux Kernel | net/sched/sch_teql.c |
static int __init teql_init(void) {
int i;
int err = -ENODEV;
for (i = 0; i < max_equalizers; i++) {
struct net_device *dev;
struct teql_master *master;
dev = alloc_netdev(sizeof(struct teql_master), "teql%d", NET_NAME_UNKNOWN,
teql_master_setup);
if (!dev) {
err = ... | [
0,
0
] |
Linux Kernel | net/sched/sch_teql.c |
static void __exit teql_exit(void) {
struct teql_master *master, *nxt;
list_for_each_entry_safe(master, nxt, &master_dev_list, master_list) {
list_del(&master->master_list);
unregister_qdisc(&master->qops);
unregister_netdev(master->dev);
free_netdev(master->dev);
}
} | [
0,
0
] |
Linux Kernel | net/sctp/associola.c | static void sctp_association_destroy(struct sctp_association *asoc) {
if (unlikely(!asoc->base.dead)) {
WARN(1, "Attempt to destroy undead association %p!\n", asoc);
return;
}
sctp_endpoint_put(asoc->ep);
sock_put(asoc->base.sk);
if (asoc->assoc_id != 0) {
spin_lock_bh(&sctp_assocs_id_lock);
... | [
0,
0
] |
Linux Kernel | net/sctp/associola.c | void sctp_assoc_del_nonprimary_peers(struct sctp_association *asoc,
struct sctp_transport *primary) {
struct sctp_transport *temp;
struct sctp_transport *t;
list_for_each_entry_safe(t, temp, &asoc->peer.transport_addr_list,
transports) {
if (t ... | [
0,
0
] |
Linux Kernel | net/sctp/associola.c | void sctp_association_put(struct sctp_association *asoc) {
if (refcount_dec_and_test(&asoc->base.refcnt))
sctp_association_destroy(asoc);
} | [
0,
0
] |
Linux Kernel | net/sctp/associola.c | struct sctp_chunk *sctp_get_ecne_prepend(struct sctp_association *asoc) {
if (!asoc->need_ecne)
return NULL;
return sctp_make_ecne(asoc, asoc->last_ecne_tsn);
} | [
0,
1
] |
Linux Kernel | net/sctp/associola.c | /*
* Find which transport this TSN was sent on.
*/
struct sctp_transport *sctp_assoc_lookup_tsn(struct sctp_association *asoc,
__u32 tsn) {
struct sctp_transport *active;
struct sctp_transport *match;
struct sctp_transport *transport;
struct sctp_chunk *chunk;
__... | [
0,
1
] |
Linux Kernel | net/sctp/associola.c | static u8 sctp_trans_score(const struct sctp_transport *trans) {
switch (trans->state) {
case SCTP_ACTIVE:
return 3;
case SCTP_UNKNOWN:
return 2;
case SCTP_PF:
return 1;
default: /* case SCTP_INACTIVE */
return 0; /* worst case */
}
} | [
0,
0
] |
Linux Kernel | net/sctp/associola.c |
void sctp_assoc_update_frag_point(struct sctp_association *asoc) {
int frag = sctp_mtu_payload(sctp_sk(asoc->base.sk), asoc->pathmtu,
sctp_datachk_len(&asoc->stream));
if (asoc->user_frag)
frag = min_t(int, frag, asoc->user_frag);
frag = min_t(int, frag, SCTP_MAX_CHUNK_LEN - s... | [
0,
0
] |
Linux Kernel | net/sctp/associola.c | int sctp_assoc_set_bind_addr_from_ep(struct sctp_association *asoc,
enum sctp_scope scope, gfp_t gfp) {
struct sock *sk = asoc->base.sk;
int flags;
flags = (PF_INET6 == sk->sk_family) ? SCTP_ADDR6_ALLOWED : 0;
if (!inet_v6_ipv6only(sk))
flags |= SCTP_ADDR4_ALLOWED;
if... | [
1,
0
] |
Linux Kernel | net/sctp/auth.c |
void sctp_auth_key_put(struct sctp_auth_bytes *key) {
if (!key)
return;
if (refcount_dec_and_test(&key->refcnt)) {
kfree_sensitive(key);
SCTP_DBG_OBJCNT_DEC(keys);
}
} | [
0,
0
] |
Linux Kernel | net/sctp/auth.c |
void sctp_auth_shkey_hold(struct sctp_shared_key *sh_key) {
refcount_inc(&sh_key->refcnt);
} | [
0,
0
] |
Linux Kernel | net/sctp/auth.c | int sctp_auth_asoc_init_active_key(struct sctp_association *asoc, gfp_t gfp) {
struct sctp_auth_bytes *secret;
struct sctp_shared_key *ep_key;
struct sctp_chunk *chunk;
if (!asoc->peer.auth_capable)
return 0;
/* If the key_id is non-zero and we couldn't find an
* endpoint pair shared key, we can't co... | [
0,
0
] |
Linux Kernel | net/sctp/auth.c | struct sctp_shared_key *sctp_auth_get_shkey(const struct sctp_association *asoc,
__u16 key_id) {
struct sctp_shared_key *key;
key_for_each(key, &asoc->endpoint_shared_keys) {
if (key->key_id == key_id) {
if (!key->deactivated)
return key;
break;
... | [
0,
0
] |
Linux Kernel | net/sctp/auth.c |
struct sctp_hmac *sctp_auth_get_hmac(__u16 hmac_id) {
return &sctp_hmac_list[hmac_id];
} | [
0,
0
] |
Linux Kernel | net/sctp/auth.c | int sctp_auth_asoc_verify_hmac_id(const struct sctp_association *asoc,
__be16 hmac_id) {
struct sctp_hmac_algo_param *hmacs;
__u16 n_elt;
if (!asoc)
return 0;
hmacs = (struct sctp_hmac_algo_param *)asoc->c.auth_hmacs;
n_elt = (ntohs(hmacs->param_hdr.length) - sizeof(str... | [
1,
0
] |
Linux Kernel | net/sctp/auth.c | void sctp_auth_asoc_set_default_hmac(struct sctp_association *asoc,
struct sctp_hmac_algo_param *hmacs) {
struct sctp_endpoint *ep;
__u16 id;
int i;
int n_params;
if (asoc->default_hmac_id)
return;
n_params =
(ntohs(hmacs->param_hdr.length) - sizeof(struct sc... | [
1,
0
] |
Linux Kernel | net/sctp/auth.c | static int __sctp_auth_cid(enum sctp_cid chunk,
struct sctp_chunks_param *param) {
unsigned short len;
int found = 0;
int i;
if (!param || param->param_hdr.length == 0)
return 0;
len = ntohs(param->param_hdr.length) - sizeof(struct sctp_paramhdr);
for (i = 0; !found && i < ... | [
1,
0
] |
Linux Kernel | net/sctp/auth.c | int sctp_auth_set_key(struct sctp_endpoint *ep, struct sctp_association *asoc,
struct sctp_authkey *auth_key) {
struct sctp_shared_key *cur_key, *shkey;
struct sctp_auth_bytes *key;
struct list_head *sh_keys;
int replace = 0;
if (asoc) {
if (!asoc->peer.auth_capable)
return -E... | [
1,
0
] |
Linux Kernel | net/sctp/auth.c | int sctp_auth_del_key_id(struct sctp_endpoint *ep,
struct sctp_association *asoc, __u16 key_id) {
struct sctp_shared_key *key;
struct list_head *sh_keys;
int found = 0;
if (asoc) {
if (!asoc->peer.auth_capable)
return -EACCES;
if (asoc->active_key_id == key_id)
retu... | [
0,
0
] |
Linux Kernel | net/sctp/auth.c | int sctp_auth_init(struct sctp_endpoint *ep, gfp_t gfp) {
int err = -ENOMEM;
if (!ep->auth_hmacs_list) {
struct sctp_hmac_algo_param *auth_hmacs;
auth_hmacs =
kzalloc(struct_size(auth_hmacs, hmac_ids, SCTP_AUTH_NUM_HMACS), gfp);
if (!auth_hmacs)
goto nomem;
/* Initialize the HMACS pa... | [
0,
0
] |
Linux Kernel | net/sctp/auth.c |
void sctp_auth_free(struct sctp_endpoint *ep) {
kfree(ep->auth_hmacs_list);
kfree(ep->auth_chunk_list);
ep->auth_hmacs_list = NULL;
ep->auth_chunk_list = NULL;
sctp_auth_destroy_hmacs(ep->auth_hmacs);
ep->auth_hmacs = NULL;
} | [
0,
0
] |
Linux Kernel | net/sctp/bind_addr.c | union sctp_params sctp_bind_addrs_to_raw(const struct sctp_bind_addr *bp,
int *addrs_len, gfp_t gfp) {
union sctp_params addrparms;
union sctp_params retval;
int addrparms_len;
union sctp_addr_param rawaddr;
int len;
struct sctp_sockaddr_entry *addr;
struct list_he... | [
1,
0
] |
Linux Kernel | net/sctp/bind_addr.c | int sctp_bind_addr_match(struct sctp_bind_addr *bp, const union sctp_addr *addr,
struct sctp_sock *opt) {
struct sctp_sockaddr_entry *laddr;
int match = 0;
rcu_read_lock();
list_for_each_entry_rcu(laddr, &bp->address_list, list) {
if (!laddr->valid)
continue;
if (opt->pf-... | [
0,
0
] |
Linux Kernel | net/sctp/bind_addr.c | int sctp_bind_addr_conflict(struct sctp_bind_addr *bp,
const union sctp_addr *addr,
struct sctp_sock *bp_sp,
struct sctp_sock *addr_sp) {
struct sctp_sockaddr_entry *laddr;
int conflict = 0;
struct sctp_sock *sp;
if (sctp_opt2s... | [
0,
0
] |
Linux Kernel | net/sctp/bind_addr.c | int sctp_bind_addr_state(const struct sctp_bind_addr *bp,
const union sctp_addr *addr) {
struct sctp_sockaddr_entry *laddr;
struct sctp_af *af;
af = sctp_get_af_specific(addr->sa.sa_family);
if (unlikely(!af))
return -1;
list_for_each_entry_rcu(laddr, &bp->address_list, list) {
... | [
0,
0
] |
Linux Kernel | net/sctp/bind_addr.c | union sctp_addr *sctp_find_unmatch_addr(struct sctp_bind_addr *bp,
const union sctp_addr *addrs,
int addrcnt, struct sctp_sock *opt) {
struct sctp_sockaddr_entry *laddr;
union sctp_addr *addr;
void *addr_buf;
struct sctp_af *af;
i... | [
0,
0
] |
Linux Kernel | net/sctp/bind_addr.c | int sctp_is_any(struct sock *sk, const union sctp_addr *addr) {
unsigned short fam = 0;
struct sctp_af *af;
if (addr->sa.sa_family != AF_UNSPEC)
fam = addr->sa.sa_family;
else if (sk)
fam = sk->sk_family;
af = sctp_get_af_specific(fam);
if (!af)
return 0;
return af->is_any(addr);
} | [
1,
0
] |
Linux Kernel | net/sctp/chunk.c | static struct sctp_datamsg *sctp_datamsg_new(gfp_t gfp) {
struct sctp_datamsg *msg;
msg = kmalloc(sizeof(struct sctp_datamsg), gfp);
if (msg) {
sctp_datamsg_init(msg);
SCTP_DBG_OBJCNT_INC(datamsg);
}
return msg;
} | [
0,
0
] |
Linux Kernel | net/sctp/chunk.c | void sctp_chunk_fail(struct sctp_chunk *chunk, int error) {
chunk->msg->send_failed = 1;
chunk->msg->send_error = error;
} | [
0,
0
] |
Linux Kernel | net/sctp/diag.c |
static size_t inet_assoc_attr_size(struct sctp_association *asoc) {
int addrlen = sizeof(struct sockaddr_storage);
int addrcnt = 0;
struct sctp_sockaddr_entry *laddr;
list_for_each_entry_rcu(laddr, &asoc->base.bind_addr.address_list, list)
addrcnt++;
return nla_total_size(sizeof(struct sctp_info)) +
... | [
1,
0
] |
Linux Kernel | net/sctp/diag.c | static void sctp_diag_get_info(struct sock *sk, struct inet_diag_msg *r,
void *info) {
struct sctp_infox *infox = (struct sctp_infox *)info;
if (infox->asoc) {
r->idiag_rqueue = atomic_read(&infox->asoc->rmem_alloc);
r->idiag_wqueue = infox->asoc->sndbuf_used;
} else {
... | [
0,
0
] |
Linux Kernel | net/sctp/diag.c |
static int sctp_diag_dump_one(struct netlink_callback *cb,
const struct inet_diag_req_v2 *req) {
struct sk_buff *skb = cb->skb;
struct net *net = sock_net(skb->sk);
const struct nlmsghdr *nlh = cb->nlh;
union sctp_addr laddr, paddr;
int dif = req->id.idiag_if;
struct sctp_comm... | [
1,
0
] |
Linux Kernel | net/sctp/diag.c |
static void __exit sctp_diag_exit(void) {
inet_diag_unregister(&sctp_diag_handler);
} | [
0,
0
] |
Linux Kernel | net/sctp/endpointola.c | struct sctp_endpoint *sctp_endpoint_new(struct sock *sk, gfp_t gfp) {
struct sctp_endpoint *ep;
ep = kzalloc(sizeof(*ep), gfp);
if (!ep)
goto fail;
if (!sctp_endpoint_init(ep, sk, gfp))
goto fail_init;
SCTP_DBG_OBJCNT_INC(ep);
return ep;
fail_init:
kfree(ep);
fail:
return NULL;
} | [
0,
0
] |
Linux Kernel | net/sctp/endpointola.c | int sctp_endpoint_hold(struct sctp_endpoint *ep) {
return refcount_inc_not_zero(&ep->base.refcnt);
} | [
0,
0
] |
Linux Kernel | net/sctp/endpointola.c | struct sctp_association *
sctp_endpoint_lookup_assoc(const struct sctp_endpoint *ep,
const union sctp_addr *paddr,
struct sctp_transport **transport) {
struct sctp_association *asoc = NULL;
struct sctp_transport *t;
*transport = NULL;
if (!ep->base.bind_ad... | [
0,
0
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.