Lines Matching refs:entry
46 /* Durations between this GCL entry and the GCL entry where the
117 struct sched_entry *entry, *cur;
120 list_for_each_entry(entry, &sched->entries, list) {
121 u32 gates_still_open = entry->gate_mask;
124 * starting at this schedule entry and ending at the schedule
125 * entry containing a gate close event for that TC.
127 cur = entry;
138 entry->gate_duration[tc] += cur->interval;
144 } while (cur != entry);
151 if (entry->gate_duration[tc] &&
152 sched->max_open_gate_duration[tc] < entry->gate_duration[tc])
153 sched->max_open_gate_duration[tc] = entry->gate_duration[tc];
158 struct sched_entry *entry, int tc)
160 return ktime_before(skb_end_time, entry->gate_close_time[tc]);
192 struct sched_entry *entry, *n;
194 list_for_each_entry_safe(entry, n, &sched->entries, list) {
195 list_del(&entry->list);
196 kfree(entry);
230 struct sched_entry *entry,
237 intv_end = ktime_add_ns(intv_start, entry->interval);
312 /* Returns the entry corresponding to next available interval. If
327 struct sched_entry *entry = NULL, *entry_found = NULL;
348 list_for_each_entry(entry, &sched->entries, list) {
350 curr_intv_end = get_interval_end_time(sched, admin, entry,
356 if (!(entry->gate_mask & BIT(tc)) ||
357 packet_transmit_time > entry->interval)
360 txtime = entry->next_txtime;
367 entry_found = entry;
376 entry_found = entry;
383 entry_found = entry;
398 struct sched_entry *entry;
404 entry = find_entry_to_transmit(skb, sch, sched, admin, skb->tstamp,
408 return entry;
481 struct sched_entry *entry;
508 entry = find_entry_to_transmit(skb, sch, sched, admin,
512 if (!entry) {
517 txtime = entry->next_txtime;
531 /* Update the txtime of current entry to the next time it's
535 entry->next_txtime = ktime_add(interval_start, sched->cycle_time);
538 entry->next_txtime = transmit_end_time;
669 struct sched_entry *entry)
677 if (entry->gate_duration[tc] == sched->cycle_time)
680 budget = div64_u64((u64)entry->gate_duration[tc] * PSEC_PER_NSEC,
683 atomic_set(&entry->budget[tc], budget);
688 static int taprio_update_budgets(struct sched_entry *entry, size_t len,
694 budget = atomic_read(&entry->budget[tc]);
703 new_budget = atomic_sub_return(len, &entry->budget[tc]);
705 atomic_sub(len, &entry->budget[tc]);
712 struct sched_entry *entry,
744 /* In the case that there's no gate entry, there's no
748 !taprio_entry_allows_tx(guard, entry, tc))
753 taprio_update_budgets(entry, len, tc, num_tc) < 0)
782 struct sched_entry *entry,
799 entry, gate_mask);
818 struct sched_entry *entry,
826 skb = taprio_dequeue_from_txq(sch, i, entry, gate_mask);
841 struct sched_entry *entry;
845 entry = rcu_dereference(q->current_entry);
846 /* if there's no entry, it means that the schedule didn't
851 gate_mask = entry ? entry->gate_mask : TAPRIO_ALL_GATES_OPEN;
858 skb = taprio_dequeue_txq_priority(sch, entry, gate_mask);
862 skb = taprio_dequeue_tc_priority(sch, entry, gate_mask);
866 skb = taprio_dequeue_txq_priority(sch, entry, gate_mask);
868 skb = taprio_dequeue_tc_priority(sch, entry, gate_mask);
878 const struct sched_entry *entry)
880 if (list_is_last(&entry->list, &oper->entries))
883 if (ktime_compare(entry->end_time, oper->cycle_end_time) == 0)
930 struct sched_entry *entry, *next;
936 entry = rcu_dereference_protected(q->current_entry,
949 * entry of all schedules are pre-calculated during the
952 if (unlikely(!entry || entry->end_time == oper->base_time)) {
959 if (should_restart_cycle(oper, entry)) {
965 next = list_next_entry(entry, list);
968 end_time = ktime_add_ns(entry->end_time, next->interval);
975 next->gate_close_time[tc] = ktime_add_ns(entry->end_time,
1041 struct sched_entry *entry,
1048 entry->command = nla_get_u8(
1052 entry->gate_mask = nla_get_u32(
1063 NL_SET_ERR_MSG(extack, "Invalid interval for schedule entry");
1067 entry->interval = interval;
1073 struct sched_entry *entry, int index,
1082 NL_SET_ERR_MSG(extack, "Could not parse nested entry");
1086 entry->index = index;
1088 return fill_sched_entry(q, tb, entry, extack);
1103 struct sched_entry *entry;
1106 NL_SET_ERR_MSG(extack, "Attribute is not of type 'entry'");
1110 entry = kzalloc(sizeof(*entry), GFP_KERNEL);
1111 if (!entry) {
1112 NL_SET_ERR_MSG(extack, "Not enough memory for entry");
1116 err = parse_sched_entry(q, n, entry, i, extack);
1118 kfree(entry);
1122 list_add_tail(&entry->list, &sched->entries);
1138 NL_SET_ERR_MSG(extack, "Adding a single entry is not supported");
1158 struct sched_entry *entry;
1161 list_for_each_entry(entry, &new->entries, list)
1162 cycle = ktime_add_ns(cycle, entry->interval);
1232 * any entry must have 'interval' > 0. Thus if the cycle time is zero,
1361 struct sched_entry *entry;
1364 list_for_each_entry(entry, &sched->entries, list) {
1365 entry->next_txtime = ktime_add_ns(base, interval);
1366 interval += entry->interval;
1458 struct sched_entry *entry;
1465 list_for_each_entry(entry, &sched->entries, list) {
1468 e->command = entry->command;
1469 e->interval = entry->interval;
1472 entry->gate_mask);
1474 e->gate_mask = entry->gate_mask;
1713 NL_SET_ERR_MSG_MOD(extack, "TC entry index missing");
1719 NL_SET_ERR_MSG_MOD(extack, "TC entry index out of range");
1724 NL_SET_ERR_MSG_MOD(extack, "Duplicate TC entry");
1924 NL_SET_ERR_MSG(extack, "There should be at least one entry in the schedule");
2227 const struct sched_entry *entry)
2235 if (nla_put_u32(msg, TCA_TAPRIO_SCHED_ENTRY_INDEX, entry->index))
2238 if (nla_put_u8(msg, TCA_TAPRIO_SCHED_ENTRY_CMD, entry->command))
2242 entry->gate_mask))
2246 entry->interval))
2260 struct sched_entry *entry;
2279 list_for_each_entry(entry, &root->entries, list) {
2280 if (dump_entry(msg, entry) < 0)