Lines Matching +full:min +full:- +full:len
1 // SPDX-License-Identifier: GPL-2.0-or-later
23 * MAC address typo fixed. 010417 --ro
24 * Integrated. 020301 --DaveM
25 * Added multiskb option 020301 --DaveM
26 * Scaling of results. 020417--sigurdur@linpro.no
27 * Significant re-work of the module:
31 * * Allow configuration of ranges, like min/max IP address, MACs,
32 * and UDP-ports, for both source and destination, and can
35 * * Place 12-byte packet in UDP payload with magic number,
37 * * Add receiver code that detects dropped pkts, re-ordered pkts, and
38 * latencies (with micro-second) precision.
40 * --Ben Greear <greearb@candelatech.com>
50 * --ro
52 * Sept 10: Fixed threading/locking. Lots of bone-headed and more clever
53 * mistakes. Also merged in DaveM's patch in the -pre6 patch.
54 * --Ben Greear <greearb@candelatech.com>
56 * Integrated to 2.5.x 021029 --Lucio Maciel (luciomaciel@zipmail.com.br)
64 * also the thread checks the thread->control which is used for inter-process
76 * /proc/irq/XX/smp_affinity so TX-interrupts gets bound to the same CPU.
77 * --ro
80 * memleak 030710- KJP
82 * First "ranges" functionality for ipv6 030726 --ro
86 * Fixed unaligned access on IA-64 Grant Grundler <grundler@parisc-linux.org>
107 * 802.1Q/Q-in-Q support by Francesco Fondelli (FF) <francesco.fondelli@gmail.com>
184 pf(IPSRC_RND) /* IP-Src Random */ \
185 pf(IPDST_RND) /* IP-Dst Random */ \
187 pf(UDPSRC_RND) /* UDP-Src Random */ \
188 pf(UDPDST_RND) /* UDP-Dst Random */ \
196 pf(MACSRC_RND) /* MAC-Src Random */ \
197 pf(MACDST_RND) /* MAC-Dst Random */ \
233 /* If lock -- protects updating of if_list */
234 #define if_lock(t) mutex_lock(&(t->if_lock))
235 #define if_unlock(t) mutex_unlock(&(t->if_lock))
244 #define VLAN_TAG_SIZE(x) ((x)->vlan_id == 0xffff ? 0 : 4)
245 #define SVLAN_TAG_SIZE(x) ((x)->svlan_id == 0xffff ? 0 : 4)
271 struct list_head list; /* chaining in the thread's run-queue */
276 /* If min != max, then we will either do a linear iteration, or
285 int removal_mark; /* non-zero => the device is marked for
290 u64 delay; /* nano-seconds */
307 u64 idle_acc; /* nano-seconds */
337 * defines the min/max for those ranges.
360 /* Maps 0-IMIX_PRECISION range to imix_entry based on probability*/
367 /* VLAN/SVLAN (802.1Q/Q-in-Q) */
407 struct net_device *odev; /* The out-going device.
411 * Set when the user specifies the out-going
522 struct pktgen_net *pn = net_generic(current->nsproxy->net_ns, pg_net_id);
525 return -EPERM;
528 return -EINVAL;
530 max = min(count, sizeof(data) - 1);
532 return -EFAULT;
534 if (data[max - 1] == '\n')
535 data[max - 1] = 0; /* strip trailing '\n', terminate string */
546 return -EINVAL;
566 const struct pktgen_dev *pkt_dev = seq->private;
573 (unsigned long long)pkt_dev->count, pkt_dev->min_pkt_size,
574 pkt_dev->max_pkt_size);
576 if (pkt_dev->n_imix_entries > 0) {
578 for (i = 0; i < pkt_dev->n_imix_entries; i++) {
580 pkt_dev->imix_entries[i].size,
581 pkt_dev->imix_entries[i].weight);
588 pkt_dev->nfrags, (unsigned long long) pkt_dev->delay,
589 pkt_dev->clone_skb, pkt_dev->odevname);
591 seq_printf(seq, " flows: %u flowlen: %u\n", pkt_dev->cflows,
592 pkt_dev->lflow);
596 pkt_dev->queue_map_min,
597 pkt_dev->queue_map_max);
599 if (pkt_dev->skb_priority)
601 pkt_dev->skb_priority);
603 if (pkt_dev->flags & F_IPV6) {
607 &pkt_dev->in6_saddr,
608 &pkt_dev->min_in6_saddr, &pkt_dev->max_in6_saddr,
609 &pkt_dev->in6_daddr,
610 &pkt_dev->min_in6_daddr, &pkt_dev->max_in6_daddr);
614 pkt_dev->dst_min, pkt_dev->dst_max);
617 pkt_dev->src_min, pkt_dev->src_max);
623 is_zero_ether_addr(pkt_dev->src_mac) ?
624 pkt_dev->odev->dev_addr : pkt_dev->src_mac);
627 seq_printf(seq, "%pM\n", pkt_dev->dst_mac);
631 pkt_dev->udp_src_min, pkt_dev->udp_src_max,
632 pkt_dev->udp_dst_min, pkt_dev->udp_dst_max);
636 pkt_dev->src_mac_count, pkt_dev->dst_mac_count);
638 if (pkt_dev->nr_labels) {
640 for (i = 0; i < pkt_dev->nr_labels; i++)
641 seq_printf(seq, "%08x%s", ntohl(pkt_dev->labels[i]),
642 i == pkt_dev->nr_labels-1 ? "\n" : ", ");
645 if (pkt_dev->vlan_id != 0xffff)
647 pkt_dev->vlan_id, pkt_dev->vlan_p,
648 pkt_dev->vlan_cfi);
650 if (pkt_dev->svlan_id != 0xffff)
652 pkt_dev->svlan_id, pkt_dev->svlan_p,
653 pkt_dev->svlan_cfi);
655 if (pkt_dev->tos)
656 seq_printf(seq, " tos: 0x%02x\n", pkt_dev->tos);
658 if (pkt_dev->traffic_class)
659 seq_printf(seq, " traffic_class: 0x%02x\n", pkt_dev->traffic_class);
661 if (pkt_dev->burst > 1)
662 seq_printf(seq, " burst: %d\n", pkt_dev->burst);
664 if (pkt_dev->node >= 0)
665 seq_printf(seq, " node: %d\n", pkt_dev->node);
667 if (pkt_dev->xmit_mode == M_NETIF_RECEIVE)
669 else if (pkt_dev->xmit_mode == M_QUEUE_XMIT)
676 if (!pkt_dev->cflows)
679 if (pkt_dev->flags & (1 << i)) {
682 if (i == IPSEC_SHIFT && pkt_dev->spi)
683 seq_printf(seq, "spi:%u ", pkt_dev->spi);
692 /* not really stopped, more like last-running-at */
693 stopped = pkt_dev->running ? ktime_get() : pkt_dev->stopped_at;
694 idle = pkt_dev->idle_acc;
698 "Current:\n pkts-sofar: %llu errors: %llu\n",
699 (unsigned long long)pkt_dev->sofar,
700 (unsigned long long)pkt_dev->errors);
702 if (pkt_dev->n_imix_entries > 0) {
706 for (i = 0; i < pkt_dev->n_imix_entries; i++) {
708 pkt_dev->imix_entries[i].size,
709 pkt_dev->imix_entries[i].count_so_far);
716 (unsigned long long) ktime_to_us(pkt_dev->started_at),
722 pkt_dev->seq_num, pkt_dev->cur_dst_mac_offset,
723 pkt_dev->cur_src_mac_offset);
725 if (pkt_dev->flags & F_IPV6) {
727 &pkt_dev->cur_in6_saddr,
728 &pkt_dev->cur_in6_daddr);
731 &pkt_dev->cur_saddr, &pkt_dev->cur_daddr);
734 pkt_dev->cur_udp_dst, pkt_dev->cur_udp_src);
736 seq_printf(seq, " cur_queue_map: %u\n", pkt_dev->cur_queue_map);
738 seq_printf(seq, " flows: %u\n", pkt_dev->nflows);
740 if (pkt_dev->result[0])
741 seq_printf(seq, "Result: %s\n", pkt_dev->result);
761 return -EFAULT;
781 return -EFAULT;
808 return -EFAULT;
811 *num += c - '0';
826 return -EFAULT;
853 ssize_t len;
856 pkt_dev->n_imix_entries = 0;
862 if (pkt_dev->n_imix_entries >= MAX_IMIX_ENTRIES)
863 return -E2BIG;
866 return -EINVAL;
868 max = min(10, maxlen - i);
869 len = num_arg(&buffer[i], max, &size);
870 if (len < 0)
871 return len;
872 i += len;
874 return -EINVAL;
876 return -EFAULT;
879 return -EINVAL;
882 return -EINVAL;
887 max = min(10, maxlen - i);
888 len = num_arg(&buffer[i], max, &weight);
889 if (len < 0)
890 return len;
892 return -EINVAL;
894 pkt_dev->imix_entries[pkt_dev->n_imix_entries].size = size;
895 pkt_dev->imix_entries[pkt_dev->n_imix_entries].weight = weight;
897 i += len;
898 pkt_dev->n_imix_entries++;
903 return -EFAULT;
915 ssize_t len;
918 pkt_dev->nr_labels = 0;
923 return -E2BIG;
926 return -EINVAL;
928 max = min(8, maxlen - i);
929 len = hex32_arg(&buffer[i], max, &tmp);
930 if (len < 0)
931 return len;
934 if (len == 0 || tmp == 0)
937 pkt_dev->labels[n] = htonl(tmp);
938 if (pkt_dev->labels[n] & MPLS_STACK_BOTTOM)
939 pkt_dev->flags |= F_MPLS_RND;
940 i += len;
945 return -EFAULT;
949 pkt_dev->nr_labels = n;
986 struct seq_file *seq = file->private_data;
987 struct pktgen_dev *pkt_dev = seq->private;
989 ssize_t len;
995 pg_result = &(pkt_dev->result[0]);
999 return -EINVAL;
1003 len = count_trail_chars(user_buffer, max);
1004 if (len < 0) {
1006 return len;
1008 i = len;
1011 max = min(sizeof(name) - 1, count - i);
1012 len = strn_len(&user_buffer[i], max);
1013 if (len < 0)
1014 return len;
1017 if (copy_from_user(name, &user_buffer[i], len))
1018 return -EFAULT;
1019 i += len;
1021 max = count - i;
1022 len = count_trail_chars(&user_buffer[i], max);
1023 if (len < 0)
1024 return len;
1026 i += len;
1035 pr_debug("%s,%zu buffer -:%s:-\n", name, count, tp);
1040 max = min(10, count - i);
1041 len = num_arg(&user_buffer[i], max, &value);
1042 if (len < 0)
1043 return len;
1047 if (value != pkt_dev->min_pkt_size) {
1048 pkt_dev->min_pkt_size = value;
1049 pkt_dev->cur_pkt_size = value;
1052 pkt_dev->min_pkt_size);
1057 max = min(10, count - i);
1058 len = num_arg(&user_buffer[i], max, &value);
1059 if (len < 0)
1060 return len;
1064 if (value != pkt_dev->max_pkt_size) {
1065 pkt_dev->max_pkt_size = value;
1066 pkt_dev->cur_pkt_size = value;
1069 pkt_dev->max_pkt_size);
1073 /* Shortcut for min = max */
1076 max = min(10, count - i);
1077 len = num_arg(&user_buffer[i], max, &value);
1078 if (len < 0)
1079 return len;
1083 if (value != pkt_dev->min_pkt_size) {
1084 pkt_dev->min_pkt_size = value;
1085 pkt_dev->max_pkt_size = value;
1086 pkt_dev->cur_pkt_size = value;
1088 sprintf(pg_result, "OK: pkt_size=%d", pkt_dev->min_pkt_size);
1093 if (pkt_dev->clone_skb > 0)
1094 return -EINVAL;
1096 max = count - i;
1097 len = get_imix_entries(&user_buffer[i], max, pkt_dev);
1098 if (len < 0)
1099 return len;
1107 max = min(10, count - i);
1108 len = num_arg(&user_buffer[i], max, &value);
1109 if (len < 0)
1110 return len;
1118 max = min(10, count - i);
1119 len = num_arg(&user_buffer[i], max, &value);
1120 if (len < 0)
1121 return len;
1123 pkt_dev->nfrags = value;
1124 sprintf(pg_result, "OK: frags=%d", pkt_dev->nfrags);
1128 max = min(10, count - i);
1129 len = num_arg(&user_buffer[i], max, &value);
1130 if (len < 0)
1131 return len;
1134 pkt_dev->delay = ULLONG_MAX;
1136 pkt_dev->delay = (u64)value;
1139 (unsigned long long) pkt_dev->delay);
1143 max = min(10, count - i);
1144 len = num_arg(&user_buffer[i], max, &value);
1145 if (len < 0)
1146 return len;
1149 return -EINVAL;
1150 pkt_dev->delay = pkt_dev->min_pkt_size*8*NSEC_PER_USEC/value;
1152 pr_info("Delay set at: %llu ns\n", pkt_dev->delay);
1158 max = min(10, count - i);
1159 len = num_arg(&user_buffer[i], max, &value);
1160 if (len < 0)
1161 return len;
1164 return -EINVAL;
1165 pkt_dev->delay = NSEC_PER_SEC/value;
1167 pr_info("Delay set at: %llu ns\n", pkt_dev->delay);
1173 max = min(10, count - i);
1174 len = num_arg(&user_buffer[i], max, &value);
1175 if (len < 0)
1176 return len;
1178 if (value != pkt_dev->udp_src_min) {
1179 pkt_dev->udp_src_min = value;
1180 pkt_dev->cur_udp_src = value;
1182 sprintf(pg_result, "OK: udp_src_min=%u", pkt_dev->udp_src_min);
1186 max = min(10, count - i);
1187 len = num_arg(&user_buffer[i], max, &value);
1188 if (len < 0)
1189 return len;
1191 if (value != pkt_dev->udp_dst_min) {
1192 pkt_dev->udp_dst_min = value;
1193 pkt_dev->cur_udp_dst = value;
1195 sprintf(pg_result, "OK: udp_dst_min=%u", pkt_dev->udp_dst_min);
1199 max = min(10, count - i);
1200 len = num_arg(&user_buffer[i], max, &value);
1201 if (len < 0)
1202 return len;
1204 if (value != pkt_dev->udp_src_max) {
1205 pkt_dev->udp_src_max = value;
1206 pkt_dev->cur_udp_src = value;
1208 sprintf(pg_result, "OK: udp_src_max=%u", pkt_dev->udp_src_max);
1212 max = min(10, count - i);
1213 len = num_arg(&user_buffer[i], max, &value);
1214 if (len < 0)
1215 return len;
1217 if (value != pkt_dev->udp_dst_max) {
1218 pkt_dev->udp_dst_max = value;
1219 pkt_dev->cur_udp_dst = value;
1221 sprintf(pg_result, "OK: udp_dst_max=%u", pkt_dev->udp_dst_max);
1225 max = min(10, count - i);
1226 len = num_arg(&user_buffer[i], max, &value);
1227 if (len < 0)
1228 return len;
1233 ((pkt_dev->xmit_mode == M_NETIF_RECEIVE) ||
1234 !(pkt_dev->odev->priv_flags & IFF_TX_SKB_SHARING)))
1235 return -EOPNOTSUPP;
1236 if (value > 0 && (pkt_dev->n_imix_entries > 0 ||
1237 !(pkt_dev->flags & F_SHARED)))
1238 return -EINVAL;
1240 pkt_dev->clone_skb = value;
1242 sprintf(pg_result, "OK: clone_skb=%d", pkt_dev->clone_skb);
1246 max = min(10, count - i);
1247 len = num_arg(&user_buffer[i], max, &value);
1248 if (len < 0)
1249 return len;
1251 pkt_dev->count = value;
1253 (unsigned long long)pkt_dev->count);
1257 max = min(10, count - i);
1258 len = num_arg(&user_buffer[i], max, &value);
1259 if (len < 0)
1260 return len;
1262 if (pkt_dev->src_mac_count != value) {
1263 pkt_dev->src_mac_count = value;
1264 pkt_dev->cur_src_mac_offset = 0;
1267 pkt_dev->src_mac_count);
1271 max = min(10, count - i);
1272 len = num_arg(&user_buffer[i], max, &value);
1273 if (len < 0)
1274 return len;
1276 if (pkt_dev->dst_mac_count != value) {
1277 pkt_dev->dst_mac_count = value;
1278 pkt_dev->cur_dst_mac_offset = 0;
1281 pkt_dev->dst_mac_count);
1285 max = min(10, count - i);
1286 len = num_arg(&user_buffer[i], max, &value);
1287 if (len < 0)
1288 return len;
1291 ((pkt_dev->xmit_mode == M_QUEUE_XMIT) ||
1292 ((pkt_dev->xmit_mode == M_START_XMIT) &&
1293 (!(pkt_dev->odev->priv_flags & IFF_TX_SKB_SHARING)))))
1294 return -EOPNOTSUPP;
1296 if (value > 1 && !(pkt_dev->flags & F_SHARED))
1297 return -EINVAL;
1299 pkt_dev->burst = value < 1 ? 1 : value;
1300 sprintf(pg_result, "OK: burst=%u", pkt_dev->burst);
1304 max = min(10, count - i);
1305 len = num_arg(&user_buffer[i], max, &value);
1306 if (len < 0)
1307 return len;
1310 pkt_dev->node = value;
1311 sprintf(pg_result, "OK: node=%d", pkt_dev->node);
1312 if (pkt_dev->page) {
1313 put_page(pkt_dev->page);
1314 pkt_dev->page = NULL;
1324 max = min(sizeof(f) - 1, count - i);
1325 len = strn_len(&user_buffer[i], max);
1326 if (len < 0)
1327 return len;
1330 if (copy_from_user(f, &user_buffer[i], len))
1331 return -EFAULT;
1334 pkt_dev->xmit_mode = M_START_XMIT;
1337 if (pkt_dev->clone_skb > 0)
1338 return -EOPNOTSUPP;
1340 pkt_dev->xmit_mode = M_NETIF_RECEIVE;
1345 pkt_dev->last_ok = 1;
1347 pkt_dev->xmit_mode = M_QUEUE_XMIT;
1348 pkt_dev->last_ok = 1;
1351 "xmit_mode -:%s:- unknown\nAvailable modes: %s",
1364 max = min(sizeof(f) - 1, count - i);
1365 len = strn_len(&user_buffer[i], max);
1366 if (len < 0)
1367 return len;
1370 if (copy_from_user(f, &user_buffer[i], len))
1371 return -EFAULT;
1381 if (flag == F_SHARED && (pkt_dev->clone_skb ||
1382 pkt_dev->burst > 1))
1383 return -EINVAL;
1384 pkt_dev->flags &= ~flag;
1386 pkt_dev->flags |= flag;
1389 sprintf(pg_result, "OK: flags=0x%x", pkt_dev->flags);
1394 end = pkt_dev->result + sizeof(pkt_dev->result);
1396 "Flag -:%s:- unknown\n"
1397 "Available flags, (prepend ! to un-set flag):\n", f);
1402 pg_result += snprintf(pg_result, end - pg_result,
1407 *(pg_result - 2) = '\0';
1413 max = min(sizeof(pkt_dev->dst_min) - 1, count - i);
1414 len = strn_len(&user_buffer[i], max);
1415 if (len < 0)
1416 return len;
1418 if (copy_from_user(buf, &user_buffer[i], len))
1419 return -EFAULT;
1420 buf[len] = 0;
1421 if (strcmp(buf, pkt_dev->dst_min) != 0) {
1422 strscpy_pad(pkt_dev->dst_min, buf);
1423 pkt_dev->daddr_min = in_aton(pkt_dev->dst_min);
1424 pkt_dev->cur_daddr = pkt_dev->daddr_min;
1427 pr_debug("dst_min set to: %s\n", pkt_dev->dst_min);
1429 sprintf(pg_result, "OK: dst_min=%s", pkt_dev->dst_min);
1433 max = min(sizeof(pkt_dev->dst_max) - 1, count - i);
1434 len = strn_len(&user_buffer[i], max);
1435 if (len < 0)
1436 return len;
1438 if (copy_from_user(buf, &user_buffer[i], len))
1439 return -EFAULT;
1440 buf[len] = 0;
1441 if (strcmp(buf, pkt_dev->dst_max) != 0) {
1442 strscpy_pad(pkt_dev->dst_max, buf);
1443 pkt_dev->daddr_max = in_aton(pkt_dev->dst_max);
1444 pkt_dev->cur_daddr = pkt_dev->daddr_max;
1447 pr_debug("dst_max set to: %s\n", pkt_dev->dst_max);
1449 sprintf(pg_result, "OK: dst_max=%s", pkt_dev->dst_max);
1453 max = min(sizeof(buf) - 1, count - i);
1454 len = strn_len(&user_buffer[i], max);
1455 if (len < 0)
1456 return len;
1458 pkt_dev->flags |= F_IPV6;
1460 if (copy_from_user(buf, &user_buffer[i], len))
1461 return -EFAULT;
1462 buf[len] = 0;
1464 in6_pton(buf, -1, pkt_dev->in6_daddr.s6_addr, -1, NULL);
1465 snprintf(buf, sizeof(buf), "%pI6c", &pkt_dev->in6_daddr);
1467 pkt_dev->cur_in6_daddr = pkt_dev->in6_daddr;
1476 max = min(sizeof(buf) - 1, count - i);
1477 len = strn_len(&user_buffer[i], max);
1478 if (len < 0)
1479 return len;
1481 pkt_dev->flags |= F_IPV6;
1483 if (copy_from_user(buf, &user_buffer[i], len))
1484 return -EFAULT;
1485 buf[len] = 0;
1487 in6_pton(buf, -1, pkt_dev->min_in6_daddr.s6_addr, -1, NULL);
1488 snprintf(buf, sizeof(buf), "%pI6c", &pkt_dev->min_in6_daddr);
1490 pkt_dev->cur_in6_daddr = pkt_dev->min_in6_daddr;
1498 max = min(sizeof(buf) - 1, count - i);
1499 len = strn_len(&user_buffer[i], max);
1500 if (len < 0)
1501 return len;
1503 pkt_dev->flags |= F_IPV6;
1505 if (copy_from_user(buf, &user_buffer[i], len))
1506 return -EFAULT;
1507 buf[len] = 0;
1509 in6_pton(buf, -1, pkt_dev->max_in6_daddr.s6_addr, -1, NULL);
1510 snprintf(buf, sizeof(buf), "%pI6c", &pkt_dev->max_in6_daddr);
1519 max = min(sizeof(buf) - 1, count - i);
1520 len = strn_len(&user_buffer[i], max);
1521 if (len < 0)
1522 return len;
1524 pkt_dev->flags |= F_IPV6;
1526 if (copy_from_user(buf, &user_buffer[i], len))
1527 return -EFAULT;
1528 buf[len] = 0;
1530 in6_pton(buf, -1, pkt_dev->in6_saddr.s6_addr, -1, NULL);
1531 snprintf(buf, sizeof(buf), "%pI6c", &pkt_dev->in6_saddr);
1533 pkt_dev->cur_in6_saddr = pkt_dev->in6_saddr;
1542 max = min(sizeof(pkt_dev->src_min) - 1, count - i);
1543 len = strn_len(&user_buffer[i], max);
1544 if (len < 0)
1545 return len;
1547 if (copy_from_user(buf, &user_buffer[i], len))
1548 return -EFAULT;
1549 buf[len] = 0;
1550 if (strcmp(buf, pkt_dev->src_min) != 0) {
1551 strscpy_pad(pkt_dev->src_min, buf);
1552 pkt_dev->saddr_min = in_aton(pkt_dev->src_min);
1553 pkt_dev->cur_saddr = pkt_dev->saddr_min;
1556 pr_debug("src_min set to: %s\n", pkt_dev->src_min);
1558 sprintf(pg_result, "OK: src_min=%s", pkt_dev->src_min);
1562 max = min(sizeof(pkt_dev->src_max) - 1, count - i);
1563 len = strn_len(&user_buffer[i], max);
1564 if (len < 0)
1565 return len;
1567 if (copy_from_user(buf, &user_buffer[i], len))
1568 return -EFAULT;
1569 buf[len] = 0;
1570 if (strcmp(buf, pkt_dev->src_max) != 0) {
1571 strscpy_pad(pkt_dev->src_max, buf);
1572 pkt_dev->saddr_max = in_aton(pkt_dev->src_max);
1573 pkt_dev->cur_saddr = pkt_dev->saddr_max;
1576 pr_debug("src_max set to: %s\n", pkt_dev->src_max);
1578 sprintf(pg_result, "OK: src_max=%s", pkt_dev->src_max);
1582 max = min(sizeof(valstr) - 1, count - i);
1583 len = strn_len(&user_buffer[i], max);
1584 if (len < 0)
1585 return len;
1588 if (copy_from_user(valstr, &user_buffer[i], len))
1589 return -EFAULT;
1591 if (!mac_pton(valstr, pkt_dev->dst_mac))
1592 return -EINVAL;
1594 ether_addr_copy(&pkt_dev->hh[0], pkt_dev->dst_mac);
1596 sprintf(pg_result, "OK: dstmac %pM", pkt_dev->dst_mac);
1600 max = min(sizeof(valstr) - 1, count - i);
1601 len = strn_len(&user_buffer[i], max);
1602 if (len < 0)
1603 return len;
1606 if (copy_from_user(valstr, &user_buffer[i], len))
1607 return -EFAULT;
1609 if (!mac_pton(valstr, pkt_dev->src_mac))
1610 return -EINVAL;
1612 ether_addr_copy(&pkt_dev->hh[6], pkt_dev->src_mac);
1614 sprintf(pg_result, "OK: srcmac %pM", pkt_dev->src_mac);
1625 max = min(10, count - i);
1626 len = num_arg(&user_buffer[i], max, &value);
1627 if (len < 0)
1628 return len;
1633 pkt_dev->cflows = value;
1634 sprintf(pg_result, "OK: flows=%u", pkt_dev->cflows);
1639 max = min(10, count - i);
1640 len = num_arg(&user_buffer[i], max, &value);
1641 if (len < 0)
1642 return len;
1644 pkt_dev->spi = value;
1645 sprintf(pg_result, "OK: spi=%u", pkt_dev->spi);
1650 max = min(10, count - i);
1651 len = num_arg(&user_buffer[i], max, &value);
1652 if (len < 0)
1653 return len;
1655 pkt_dev->lflow = value;
1656 sprintf(pg_result, "OK: flowlen=%u", pkt_dev->lflow);
1661 max = min(5, count - i);
1662 len = num_arg(&user_buffer[i], max, &value);
1663 if (len < 0)
1664 return len;
1666 pkt_dev->queue_map_min = value;
1667 sprintf(pg_result, "OK: queue_map_min=%u", pkt_dev->queue_map_min);
1672 max = min(5, count - i);
1673 len = num_arg(&user_buffer[i], max, &value);
1674 if (len < 0)
1675 return len;
1677 pkt_dev->queue_map_max = value;
1678 sprintf(pg_result, "OK: queue_map_max=%u", pkt_dev->queue_map_max);
1685 max = count - i;
1686 len = get_labels(&user_buffer[i], max, pkt_dev);
1687 if (len < 0)
1688 return len;
1691 for (n = 0; n < pkt_dev->nr_labels; n++)
1693 "%08x%s", ntohl(pkt_dev->labels[n]),
1694 n == pkt_dev->nr_labels-1 ? "" : ",");
1696 if (pkt_dev->nr_labels && pkt_dev->vlan_id != 0xffff) {
1697 pkt_dev->vlan_id = 0xffff; /* turn off VLAN/SVLAN */
1698 pkt_dev->svlan_id = 0xffff;
1707 max = min(4, count - i);
1708 len = num_arg(&user_buffer[i], max, &value);
1709 if (len < 0)
1710 return len;
1713 pkt_dev->vlan_id = value; /* turn on VLAN */
1718 if (debug && pkt_dev->nr_labels)
1721 pkt_dev->nr_labels = 0; /* turn off MPLS */
1722 sprintf(pg_result, "OK: vlan_id=%u", pkt_dev->vlan_id);
1724 pkt_dev->vlan_id = 0xffff; /* turn off VLAN/SVLAN */
1725 pkt_dev->svlan_id = 0xffff;
1734 max = min(1, count - i);
1735 len = num_arg(&user_buffer[i], max, &value);
1736 if (len < 0)
1737 return len;
1739 if ((value <= 7) && (pkt_dev->vlan_id != 0xffff)) {
1740 pkt_dev->vlan_p = value;
1741 sprintf(pg_result, "OK: vlan_p=%u", pkt_dev->vlan_p);
1743 sprintf(pg_result, "ERROR: vlan_p must be 0-7");
1749 max = min(1, count - i);
1750 len = num_arg(&user_buffer[i], max, &value);
1751 if (len < 0)
1752 return len;
1754 if ((value <= 1) && (pkt_dev->vlan_id != 0xffff)) {
1755 pkt_dev->vlan_cfi = value;
1756 sprintf(pg_result, "OK: vlan_cfi=%u", pkt_dev->vlan_cfi);
1758 sprintf(pg_result, "ERROR: vlan_cfi must be 0-1");
1764 max = min(4, count - i);
1765 len = num_arg(&user_buffer[i], max, &value);
1766 if (len < 0)
1767 return len;
1769 if ((value <= 4095) && ((pkt_dev->vlan_id != 0xffff))) {
1770 pkt_dev->svlan_id = value; /* turn on SVLAN */
1775 if (debug && pkt_dev->nr_labels)
1778 pkt_dev->nr_labels = 0; /* turn off MPLS */
1779 sprintf(pg_result, "OK: svlan_id=%u", pkt_dev->svlan_id);
1781 pkt_dev->vlan_id = 0xffff; /* turn off VLAN/SVLAN */
1782 pkt_dev->svlan_id = 0xffff;
1791 max = min(1, count - i);
1792 len = num_arg(&user_buffer[i], max, &value);
1793 if (len < 0)
1794 return len;
1796 if ((value <= 7) && (pkt_dev->svlan_id != 0xffff)) {
1797 pkt_dev->svlan_p = value;
1798 sprintf(pg_result, "OK: svlan_p=%u", pkt_dev->svlan_p);
1800 sprintf(pg_result, "ERROR: svlan_p must be 0-7");
1806 max = min(1, count - i);
1807 len = num_arg(&user_buffer[i], max, &value);
1808 if (len < 0)
1809 return len;
1811 if ((value <= 1) && (pkt_dev->svlan_id != 0xffff)) {
1812 pkt_dev->svlan_cfi = value;
1813 sprintf(pg_result, "OK: svlan_cfi=%u", pkt_dev->svlan_cfi);
1815 sprintf(pg_result, "ERROR: svlan_cfi must be 0-1");
1823 max = min(2, count - i);
1824 len = hex32_arg(&user_buffer[i], max, &tmp_value);
1825 if (len < 0)
1826 return len;
1828 if (len == 2) {
1829 pkt_dev->tos = tmp_value;
1830 sprintf(pg_result, "OK: tos=0x%02x", pkt_dev->tos);
1832 sprintf(pg_result, "ERROR: tos must be 00-ff");
1840 max = min(2, count - i);
1841 len = hex32_arg(&user_buffer[i], max, &tmp_value);
1842 if (len < 0)
1843 return len;
1845 if (len == 2) {
1846 pkt_dev->traffic_class = tmp_value;
1847 sprintf(pg_result, "OK: traffic_class=0x%02x", pkt_dev->traffic_class);
1849 sprintf(pg_result, "ERROR: traffic_class must be 00-ff");
1855 max = min(9, count - i);
1856 len = num_arg(&user_buffer[i], max, &value);
1857 if (len < 0)
1858 return len;
1860 pkt_dev->skb_priority = value;
1862 pkt_dev->skb_priority);
1866 sprintf(pkt_dev->result, "No such parameter \"%s\"", name);
1867 return -EINVAL;
1885 struct pktgen_thread *t = seq->private;
1893 list_for_each_entry_rcu(pkt_dev, &t->if_list, list)
1894 if (pkt_dev->running)
1895 seq_printf(seq, "%s ", pkt_dev->odevname);
1899 list_for_each_entry_rcu(pkt_dev, &t->if_list, list)
1900 if (!pkt_dev->running)
1901 seq_printf(seq, "%s ", pkt_dev->odevname);
1903 if (t->result[0])
1904 seq_printf(seq, "\nResult: %s\n", t->result);
1917 struct seq_file *seq = file->private_data;
1918 struct pktgen_thread *t = seq->private;
1920 ssize_t len, ret;
1926 return -EINVAL;
1930 len = count_trail_chars(user_buffer, max);
1931 if (len < 0)
1932 return len;
1934 i = len;
1937 max = min(sizeof(name) - 1, count - i);
1938 len = strn_len(&user_buffer[i], max);
1939 if (len < 0)
1940 return len;
1943 if (copy_from_user(name, &user_buffer[i], len))
1944 return -EFAULT;
1945 i += len;
1947 max = count - i;
1948 len = count_trail_chars(&user_buffer[i], max);
1949 if (len < 0)
1950 return len;
1952 i += len;
1959 ret = -EINVAL;
1963 pg_result = &(t->result[0]);
1969 max = min(sizeof(f) - 1, count - i);
1970 len = strn_len(&user_buffer[i], max);
1971 if (len < 0) {
1972 ret = len;
1975 if (copy_from_user(f, &user_buffer[i], len))
1976 return -EFAULT;
1991 t->control |= T_REMDEVALL;
1993 schedule_timeout_interruptible(msecs_to_jiffies(125)); /* Propagate thread->control */
2000 sprintf(pg_result, "OK: Note! max_before_softirq is obsoleted -- Do not use");
2005 ret = -EINVAL;
2031 list_for_each_entry(t, &pn->pktgen_threads, th_list) {
2035 pkt_dev->removal_mark = 1;
2036 t->control |= T_REMDEV;
2085 list_for_each_entry(t, &pn->pktgen_threads, th_list) {
2089 list_for_each_entry(pkt_dev, &t->if_list, list) {
2090 if (pkt_dev->odev != dev)
2093 proc_remove(pkt_dev->entry);
2095 pkt_dev->entry = proc_create_data(dev->name, 0600,
2096 pn->proc_dir,
2099 if (!pkt_dev->entry)
2101 dev->name);
2115 if (pn->pktgen_exiting)
2128 pktgen_mark_device(pn, dev->name);
2150 return dev_get_by_name(pn->net, b);
2163 if (pkt_dev->odev) {
2164 netdev_put(pkt_dev->odev, &pkt_dev->dev_tracker);
2165 pkt_dev->odev = NULL;
2171 return -ENODEV;
2174 if (odev->type != ARPHRD_ETHER && odev->type != ARPHRD_LOOPBACK) {
2176 err = -EINVAL;
2179 err = -ENETDOWN;
2181 pkt_dev->odev = odev;
2182 netdev_tracker_alloc(odev, &pkt_dev->dev_tracker, GFP_KERNEL);
2197 if (!pkt_dev->odev) {
2198 pr_err("ERROR: pkt_dev->odev == NULL in setup_inject\n");
2199 sprintf(pkt_dev->result,
2200 "ERROR: pkt_dev->odev == NULL in setup_inject.\n");
2204 /* make sure that we don't pick a non-existing transmit queue */
2205 ntxq = pkt_dev->odev->real_num_tx_queues;
2207 if (ntxq <= pkt_dev->queue_map_min) {
2208 pr_warn("WARNING: Requested queue_map_min (zero-based) (%d) exceeds valid range [0 - %d] for (%d) queues on %s, resetting\n",
2209 pkt_dev->queue_map_min, (ntxq ?: 1) - 1, ntxq,
2210 pkt_dev->odevname);
2211 pkt_dev->queue_map_min = (ntxq ?: 1) - 1;
2213 if (pkt_dev->queue_map_max >= ntxq) {
2214 pr_warn("WARNING: Requested queue_map_max (zero-based) (%d) exceeds valid range [0 - %d] for (%d) queues on %s, resetting\n",
2215 pkt_dev->queue_map_max, (ntxq ?: 1) - 1, ntxq,
2216 pkt_dev->odevname);
2217 pkt_dev->queue_map_max = (ntxq ?: 1) - 1;
2222 if (is_zero_ether_addr(pkt_dev->src_mac))
2223 ether_addr_copy(&(pkt_dev->hh[6]), pkt_dev->odev->dev_addr);
2226 ether_addr_copy(&(pkt_dev->hh[0]), pkt_dev->dst_mac);
2228 if (pkt_dev->flags & F_IPV6) {
2232 if (pkt_dev->min_pkt_size == 0) {
2233 pkt_dev->min_pkt_size = 14 + sizeof(struct ipv6hdr)
2236 + pkt_dev->pkt_overhead;
2240 if (pkt_dev->cur_in6_saddr.s6_addr[i]) {
2254 idev = __in6_dev_get(pkt_dev->odev);
2258 read_lock_bh(&idev->lock);
2259 list_for_each_entry(ifp, &idev->addr_list, if_list) {
2260 if ((ifp->scope & IFA_LINK) &&
2261 !(ifp->flags & IFA_F_TENTATIVE)) {
2262 pkt_dev->cur_in6_saddr = ifp->addr;
2267 read_unlock_bh(&idev->lock);
2274 if (pkt_dev->min_pkt_size == 0) {
2275 pkt_dev->min_pkt_size = 14 + sizeof(struct iphdr)
2278 + pkt_dev->pkt_overhead;
2281 pkt_dev->saddr_min = 0;
2282 pkt_dev->saddr_max = 0;
2283 if (strlen(pkt_dev->src_min) == 0) {
2288 in_dev = __in_dev_get_rcu(pkt_dev->odev);
2292 ifa = rcu_dereference(in_dev->ifa_list);
2294 pkt_dev->saddr_min = ifa->ifa_address;
2295 pkt_dev->saddr_max = pkt_dev->saddr_min;
2300 pkt_dev->saddr_min = in_aton(pkt_dev->src_min);
2301 pkt_dev->saddr_max = in_aton(pkt_dev->src_max);
2304 pkt_dev->daddr_min = in_aton(pkt_dev->dst_min);
2305 pkt_dev->daddr_max = in_aton(pkt_dev->dst_max);
2308 pkt_dev->cur_pkt_size = pkt_dev->min_pkt_size;
2309 if (pkt_dev->min_pkt_size > pkt_dev->max_pkt_size)
2310 pkt_dev->max_pkt_size = pkt_dev->min_pkt_size;
2312 pkt_dev->cur_dst_mac_offset = 0;
2313 pkt_dev->cur_src_mac_offset = 0;
2314 pkt_dev->cur_saddr = pkt_dev->saddr_min;
2315 pkt_dev->cur_daddr = pkt_dev->daddr_min;
2316 pkt_dev->cur_udp_dst = pkt_dev->udp_dst_min;
2317 pkt_dev->cur_udp_src = pkt_dev->udp_src_min;
2318 pkt_dev->nflows = 0;
2350 } while (t.task && pkt_dev->running && !signal_pending(current));
2355 pkt_dev->idle_acc += ktime_to_ns(ktime_sub(end_time, start_time));
2357 pkt_dev->next_tx = ktime_add_ns(spin_until, pkt_dev->delay);
2363 pkt_dev->pkt_overhead = 0;
2364 pkt_dev->pkt_overhead += pkt_dev->nr_labels*sizeof(u32);
2365 pkt_dev->pkt_overhead += VLAN_TAG_SIZE(pkt_dev);
2366 pkt_dev->pkt_overhead += SVLAN_TAG_SIZE(pkt_dev);
2371 return !!(pkt_dev->flows[flow].flags & F_INIT);
2376 int flow = pkt_dev->curfl;
2378 if (pkt_dev->flags & F_FLOW_SEQ) {
2379 if (pkt_dev->flows[flow].count >= pkt_dev->lflow) {
2381 pkt_dev->flows[flow].count = 0;
2382 pkt_dev->flows[flow].flags = 0;
2383 pkt_dev->curfl += 1;
2384 if (pkt_dev->curfl >= pkt_dev->cflows)
2385 pkt_dev->curfl = 0; /*reset */
2388 flow = get_random_u32_below(pkt_dev->cflows);
2389 pkt_dev->curfl = flow;
2391 if (pkt_dev->flows[flow].count > pkt_dev->lflow) {
2392 pkt_dev->flows[flow].count = 0;
2393 pkt_dev->flows[flow].flags = 0;
2397 return pkt_dev->curfl;
2408 struct xfrm_state *x = pkt_dev->flows[flow].x;
2409 struct pktgen_net *pn = net_generic(dev_net(pkt_dev->odev), pg_net_id);
2413 if (pkt_dev->spi) {
2417 x = xfrm_state_lookup_byspi(pn->net, htonl(pkt_dev->spi), AF_INET);
2420 x = xfrm_stateonly_find(pn->net, DUMMY_MARK, 0,
2421 (xfrm_address_t *)&pkt_dev->cur_daddr,
2422 (xfrm_address_t *)&pkt_dev->cur_saddr,
2424 pkt_dev->ipsmode,
2425 pkt_dev->ipsproto, 0);
2428 pkt_dev->flows[flow].x = x;
2430 pkt_dev->pkt_overhead += x->props.header_len;
2438 if (pkt_dev->flags & F_QUEUE_MAP_CPU)
2439 pkt_dev->cur_queue_map = smp_processor_id();
2441 else if (pkt_dev->queue_map_min <= pkt_dev->queue_map_max) {
2444 if (pkt_dev->flags & F_QUEUE_MAP_RND) {
2445 t = get_random_u32_inclusive(pkt_dev->queue_map_min,
2446 pkt_dev->queue_map_max);
2448 t = pkt_dev->cur_queue_map + 1;
2449 if (t > pkt_dev->queue_map_max)
2450 t = pkt_dev->queue_map_min;
2452 pkt_dev->cur_queue_map = t;
2454 pkt_dev->cur_queue_map = pkt_dev->cur_queue_map % pkt_dev->odev->real_num_tx_queues;
2458 * for IP src/dest, UDP src/dst port, MAC-Addr src/dst
2466 if (pkt_dev->cflows)
2470 if (pkt_dev->src_mac_count > 1) {
2474 if (pkt_dev->flags & F_MACSRC_RND)
2475 mc = get_random_u32_below(pkt_dev->src_mac_count);
2477 mc = pkt_dev->cur_src_mac_offset++;
2478 if (pkt_dev->cur_src_mac_offset >=
2479 pkt_dev->src_mac_count)
2480 pkt_dev->cur_src_mac_offset = 0;
2483 tmp = pkt_dev->src_mac[5] + (mc & 0xFF);
2484 pkt_dev->hh[11] = tmp;
2485 tmp = (pkt_dev->src_mac[4] + ((mc >> 8) & 0xFF) + (tmp >> 8));
2486 pkt_dev->hh[10] = tmp;
2487 tmp = (pkt_dev->src_mac[3] + ((mc >> 16) & 0xFF) + (tmp >> 8));
2488 pkt_dev->hh[9] = tmp;
2489 tmp = (pkt_dev->src_mac[2] + ((mc >> 24) & 0xFF) + (tmp >> 8));
2490 pkt_dev->hh[8] = tmp;
2491 tmp = (pkt_dev->src_mac[1] + (tmp >> 8));
2492 pkt_dev->hh[7] = tmp;
2496 if (pkt_dev->dst_mac_count > 1) {
2500 if (pkt_dev->flags & F_MACDST_RND)
2501 mc = get_random_u32_below(pkt_dev->dst_mac_count);
2504 mc = pkt_dev->cur_dst_mac_offset++;
2505 if (pkt_dev->cur_dst_mac_offset >=
2506 pkt_dev->dst_mac_count) {
2507 pkt_dev->cur_dst_mac_offset = 0;
2511 tmp = pkt_dev->dst_mac[5] + (mc & 0xFF);
2512 pkt_dev->hh[5] = tmp;
2513 tmp = (pkt_dev->dst_mac[4] + ((mc >> 8) & 0xFF) + (tmp >> 8));
2514 pkt_dev->hh[4] = tmp;
2515 tmp = (pkt_dev->dst_mac[3] + ((mc >> 16) & 0xFF) + (tmp >> 8));
2516 pkt_dev->hh[3] = tmp;
2517 tmp = (pkt_dev->dst_mac[2] + ((mc >> 24) & 0xFF) + (tmp >> 8));
2518 pkt_dev->hh[2] = tmp;
2519 tmp = (pkt_dev->dst_mac[1] + (tmp >> 8));
2520 pkt_dev->hh[1] = tmp;
2523 if (pkt_dev->flags & F_MPLS_RND) {
2526 for (i = 0; i < pkt_dev->nr_labels; i++)
2527 if (pkt_dev->labels[i] & MPLS_STACK_BOTTOM)
2528 pkt_dev->labels[i] = MPLS_STACK_BOTTOM |
2533 if ((pkt_dev->flags & F_VID_RND) && (pkt_dev->vlan_id != 0xffff)) {
2534 pkt_dev->vlan_id = get_random_u32_below(4096);
2537 if ((pkt_dev->flags & F_SVID_RND) && (pkt_dev->svlan_id != 0xffff)) {
2538 pkt_dev->svlan_id = get_random_u32_below(4096);
2541 if (pkt_dev->udp_src_min < pkt_dev->udp_src_max) {
2542 if (pkt_dev->flags & F_UDPSRC_RND)
2543 pkt_dev->cur_udp_src = get_random_u32_inclusive(pkt_dev->udp_src_min,
2544 pkt_dev->udp_src_max - 1);
2547 pkt_dev->cur_udp_src++;
2548 if (pkt_dev->cur_udp_src >= pkt_dev->udp_src_max)
2549 pkt_dev->cur_udp_src = pkt_dev->udp_src_min;
2553 if (pkt_dev->udp_dst_min < pkt_dev->udp_dst_max) {
2554 if (pkt_dev->flags & F_UDPDST_RND) {
2555 pkt_dev->cur_udp_dst = get_random_u32_inclusive(pkt_dev->udp_dst_min,
2556 pkt_dev->udp_dst_max - 1);
2558 pkt_dev->cur_udp_dst++;
2559 if (pkt_dev->cur_udp_dst >= pkt_dev->udp_dst_max)
2560 pkt_dev->cur_udp_dst = pkt_dev->udp_dst_min;
2564 if (!(pkt_dev->flags & F_IPV6)) {
2566 imn = ntohl(pkt_dev->saddr_min);
2567 imx = ntohl(pkt_dev->saddr_max);
2571 if (pkt_dev->flags & F_IPSRC_RND)
2572 t = get_random_u32_inclusive(imn, imx - 1);
2574 t = ntohl(pkt_dev->cur_saddr);
2580 pkt_dev->cur_saddr = htonl(t);
2583 if (pkt_dev->cflows && f_seen(pkt_dev, flow)) {
2584 pkt_dev->cur_daddr = pkt_dev->flows[flow].cur_daddr;
2586 imn = ntohl(pkt_dev->daddr_min);
2587 imx = ntohl(pkt_dev->daddr_max);
2592 if (pkt_dev->flags & F_IPDST_RND) {
2595 t = get_random_u32_inclusive(imn, imx - 1);
2602 pkt_dev->cur_daddr = s;
2604 t = ntohl(pkt_dev->cur_daddr);
2609 pkt_dev->cur_daddr = htonl(t);
2612 if (pkt_dev->cflows) {
2613 pkt_dev->flows[flow].flags |= F_INIT;
2614 pkt_dev->flows[flow].cur_daddr =
2615 pkt_dev->cur_daddr;
2616 if (pkt_dev->flags & F_IPSEC)
2618 pkt_dev->nflows++;
2623 if (!ipv6_addr_any(&pkt_dev->min_in6_daddr)) {
2629 pkt_dev->cur_in6_daddr.s6_addr32[i] =
2631 pkt_dev->min_in6_daddr.s6_addr32[i]) &
2632 pkt_dev->max_in6_daddr.s6_addr32[i]);
2637 if (pkt_dev->min_pkt_size < pkt_dev->max_pkt_size) {
2640 if (pkt_dev->flags & F_TXSIZE_RND) {
2641 t = get_random_u32_inclusive(pkt_dev->min_pkt_size,
2642 pkt_dev->max_pkt_size - 1);
2644 t = pkt_dev->cur_pkt_size + 1;
2645 if (t > pkt_dev->max_pkt_size)
2646 t = pkt_dev->min_pkt_size;
2648 pkt_dev->cur_pkt_size = t;
2649 } else if (pkt_dev->n_imix_entries > 0) {
2652 __u8 entry_index = pkt_dev->imix_distribution[t];
2654 entry = &pkt_dev->imix_entries[entry_index];
2655 entry->count_so_far++;
2656 pkt_dev->cur_pkt_size = entry->size;
2661 pkt_dev->flows[flow].count++;
2672 for (i = 0; i < pkt_dev->n_imix_entries; i++)
2673 total_weight += pkt_dev->imix_entries[i].weight;
2676 for (i = 0; i < pkt_dev->n_imix_entries - 1; i++) {
2677 cumulative_prob += div64_u64(pkt_dev->imix_entries[i].weight *
2682 cumulative_probabilites[pkt_dev->n_imix_entries - 1] = 100;
2687 pkt_dev->imix_distribution[i] = j;
2699 struct xfrm_state *x = pkt_dev->flows[pkt_dev->curfl].x;
2701 struct net *net = dev_net(pkt_dev->odev);
2708 if ((x->props.mode != XFRM_MODE_TRANSPORT) && (pkt_dev->spi == 0))
2714 if ((x->props.mode == XFRM_MODE_TUNNEL) && (pkt_dev->spi != 0))
2715 skb->_skb_refdst = (unsigned long)&pkt_dev->xdst.u.dst | SKB_DST_NOREF;
2724 err = x->type->output(x, skb);
2729 spin_lock_bh(&x->lock);
2730 x->curlft.bytes += skb->len;
2731 x->curlft.packets++;
2732 spin_unlock_bh(&x->lock);
2739 if (pkt_dev->cflows) {
2743 for (i = 0; i < pkt_dev->cflows; i++) {
2744 struct xfrm_state *x = pkt_dev->flows[i].x;
2748 pkt_dev->flows[i].x = NULL;
2757 if (pkt_dev->flags & F_IPSEC) {
2758 struct xfrm_state *x = pkt_dev->flows[pkt_dev->curfl].x;
2766 nhead = x->props.header_len - skb_headroom(skb);
2785 memcpy(eth, pkt_dev->hh, 2 * ETH_ALEN);
2786 eth->h_proto = protocol;
2788 /* Update IPv4 header len as well as checksum value */
2790 iph->tot_len = htons(skb->len - ETH_HLEN);
2805 for (i = 0; i < pkt_dev->nr_labels; i++)
2806 *mpls++ = pkt_dev->labels[i] & ~MPLS_STACK_BOTTOM;
2808 mpls--;
2825 datalen -= sizeof(*pgh);
2827 if (pkt_dev->nfrags <= 0) {
2830 int frags = pkt_dev->nfrags;
2831 int i, len;
2837 len = datalen - frags * PAGE_SIZE;
2838 if (len > 0) {
2839 skb_put_zero(skb, len);
2847 if (unlikely(!pkt_dev->page)) {
2850 if (pkt_dev->node >= 0 && (pkt_dev->flags & F_NODE))
2851 node = pkt_dev->node;
2852 pkt_dev->page = alloc_pages_node(node, GFP_KERNEL | __GFP_ZERO, 0);
2853 if (!pkt_dev->page)
2856 get_page(pkt_dev->page);
2859 if (i == (frags - 1))
2860 skb_frag_fill_page_desc(&skb_shinfo(skb)->frags[i],
2861 pkt_dev->page, 0,
2865 skb_frag_fill_page_desc(&skb_shinfo(skb)->frags[i],
2866 pkt_dev->page, 0, frag_len);
2868 datalen -= skb_frag_size(&skb_shinfo(skb)->frags[i]);
2869 skb->len += skb_frag_size(&skb_shinfo(skb)->frags[i]);
2870 skb->data_len += skb_frag_size(&skb_shinfo(skb)->frags[i]);
2872 skb_shinfo(skb)->nr_frags = i;
2879 pgh->pgh_magic = htonl(PKTGEN_MAGIC);
2880 pgh->seq_num = htonl(pkt_dev->seq_num);
2882 if (pkt_dev->flags & F_NO_TIMESTAMP) {
2883 pgh->tv_sec = 0;
2884 pgh->tv_usec = 0;
2887 * pgh->tv_sec wraps in y2106 when interpreted as unsigned
2890 * it, we could introduce a variant that puts 64-bit nanoseconds
2895 pgh->tv_sec = htonl(timestamp.tv_sec);
2896 pgh->tv_usec = htonl(timestamp.tv_nsec / NSEC_PER_USEC);
2907 size = pkt_dev->cur_pkt_size + 64 + extralen + pkt_dev->pkt_overhead;
2908 if (pkt_dev->flags & F_NODE) {
2909 int node = pkt_dev->node >= 0 ? pkt_dev->node : numa_node_id();
2914 skb->dev = dev;
2920 /* the caller pre-fetches from skb->data and reserves for the mac hdr */
2922 skb_reserve(skb, extralen - 16);
2938 __be16 *vlan_encapsulated_proto = NULL; /* packet type ID field (or len) for VLAN tag */
2940 __be16 *svlan_encapsulated_proto = NULL; /* packet type ID field (or len) for SVLAN tag */
2943 if (pkt_dev->nr_labels)
2946 if (pkt_dev->vlan_id != 0xffff)
2953 queue_map = pkt_dev->cur_queue_map;
2957 sprintf(pkt_dev->result, "No memory");
2961 prefetchw(skb->data);
2966 mpls = skb_put(skb, pkt_dev->nr_labels * sizeof(__u32));
2967 if (pkt_dev->nr_labels)
2970 if (pkt_dev->vlan_id != 0xffff) {
2971 if (pkt_dev->svlan_id != 0xffff) {
2973 *svlan_tci = build_tci(pkt_dev->svlan_id,
2974 pkt_dev->svlan_cfi,
2975 pkt_dev->svlan_p);
2981 *vlan_tci = build_tci(pkt_dev->vlan_id,
2982 pkt_dev->vlan_cfi,
2983 pkt_dev->vlan_p);
2989 skb_set_network_header(skb, skb->len);
2992 skb_set_transport_header(skb, skb->len);
2995 skb->priority = pkt_dev->skb_priority;
2997 memcpy(eth, pkt_dev->hh, 12);
3001 datalen = pkt_dev->cur_pkt_size - 14 - 20 - 8 -
3002 pkt_dev->pkt_overhead;
3006 udph->source = htons(pkt_dev->cur_udp_src);
3007 udph->dest = htons(pkt_dev->cur_udp_dst);
3008 udph->len = htons(datalen + 8); /* DATA + udphdr */
3009 udph->check = 0;
3011 iph->ihl = 5;
3012 iph->version = 4;
3013 iph->ttl = 32;
3014 iph->tos = pkt_dev->tos;
3015 iph->protocol = IPPROTO_UDP; /* UDP */
3016 iph->saddr = pkt_dev->cur_saddr;
3017 iph->daddr = pkt_dev->cur_daddr;
3018 iph->id = htons(pkt_dev->ip_id);
3019 pkt_dev->ip_id++;
3020 iph->frag_off = 0;
3022 iph->tot_len = htons(iplen);
3024 skb->protocol = protocol;
3025 skb->dev = odev;
3026 skb->pkt_type = PACKET_HOST;
3030 if (!(pkt_dev->flags & F_UDPCSUM)) {
3031 skb->ip_summed = CHECKSUM_NONE;
3032 } else if (odev->features & (NETIF_F_HW_CSUM | NETIF_F_IP_CSUM)) {
3033 skb->ip_summed = CHECKSUM_PARTIAL;
3034 skb->csum = 0;
3035 udp4_hwcsum(skb, iph->saddr, iph->daddr);
3039 /* add protocol-dependent pseudo-header */
3040 udph->check = csum_tcpudp_magic(iph->saddr, iph->daddr,
3043 if (udph->check == 0)
3044 udph->check = CSUM_MANGLED_0;
3066 __be16 *vlan_encapsulated_proto = NULL; /* packet type ID field (or len) for VLAN tag */
3068 __be16 *svlan_encapsulated_proto = NULL; /* packet type ID field (or len) for SVLAN tag */
3071 if (pkt_dev->nr_labels)
3074 if (pkt_dev->vlan_id != 0xffff)
3081 queue_map = pkt_dev->cur_queue_map;
3085 sprintf(pkt_dev->result, "No memory");
3089 prefetchw(skb->data);
3094 mpls = skb_put(skb, pkt_dev->nr_labels * sizeof(__u32));
3095 if (pkt_dev->nr_labels)
3098 if (pkt_dev->vlan_id != 0xffff) {
3099 if (pkt_dev->svlan_id != 0xffff) {
3101 *svlan_tci = build_tci(pkt_dev->svlan_id,
3102 pkt_dev->svlan_cfi,
3103 pkt_dev->svlan_p);
3109 *vlan_tci = build_tci(pkt_dev->vlan_id,
3110 pkt_dev->vlan_cfi,
3111 pkt_dev->vlan_p);
3117 skb_set_network_header(skb, skb->len);
3120 skb_set_transport_header(skb, skb->len);
3123 skb->priority = pkt_dev->skb_priority;
3125 memcpy(eth, pkt_dev->hh, 12);
3129 datalen = pkt_dev->cur_pkt_size - 14 -
3130 sizeof(struct ipv6hdr) - sizeof(struct udphdr) -
3131 pkt_dev->pkt_overhead;
3139 udph->source = htons(pkt_dev->cur_udp_src);
3140 udph->dest = htons(pkt_dev->cur_udp_dst);
3141 udph->len = htons(udplen);
3142 udph->check = 0;
3146 if (pkt_dev->traffic_class) {
3148 *(__be32 *)iph |= htonl(0x60000000 | (pkt_dev->traffic_class << 20));
3151 iph->hop_limit = 32;
3153 iph->payload_len = htons(udplen);
3154 iph->nexthdr = IPPROTO_UDP;
3156 iph->daddr = pkt_dev->cur_in6_daddr;
3157 iph->saddr = pkt_dev->cur_in6_saddr;
3159 skb->protocol = protocol;
3160 skb->dev = odev;
3161 skb->pkt_type = PACKET_HOST;
3165 if (!(pkt_dev->flags & F_UDPCSUM)) {
3166 skb->ip_summed = CHECKSUM_NONE;
3167 } else if (odev->features & (NETIF_F_HW_CSUM | NETIF_F_IPV6_CSUM)) {
3168 skb->ip_summed = CHECKSUM_PARTIAL;
3169 skb->csum_start = skb_transport_header(skb) - skb->head;
3170 skb->csum_offset = offsetof(struct udphdr, check);
3171 udph->check = ~csum_ipv6_magic(&iph->saddr, &iph->daddr, udplen, IPPROTO_UDP, 0);
3175 /* add protocol-dependent pseudo-header */
3176 udph->check = csum_ipv6_magic(&iph->saddr, &iph->daddr, udplen, IPPROTO_UDP, csum);
3178 if (udph->check == 0)
3179 udph->check = CSUM_MANGLED_0;
3188 if (pkt_dev->flags & F_IPV6)
3196 pkt_dev->seq_num = 1;
3197 pkt_dev->idle_acc = 0;
3198 pkt_dev->sofar = 0;
3199 pkt_dev->tx_bytes = 0;
3200 pkt_dev->errors = 0;
3213 list_for_each_entry_rcu(pkt_dev, &t->if_list, list) {
3220 if (pkt_dev->odev) {
3222 pkt_dev->skb = NULL;
3223 pkt_dev->started_at = pkt_dev->next_tx = ktime_get();
3227 strscpy(pkt_dev->result, "Starting");
3228 pkt_dev->running = 1; /* Cranke yeself! */
3231 strscpy(pkt_dev->result, "Error starting");
3235 t->control &= ~(T_STOP);
3244 list_for_each_entry(t, &pn->pktgen_threads, th_list)
3245 t->control |= (flags);
3262 list_for_each_entry_rcu(pkt_dev, &t->if_list, list)
3263 if (pkt_dev->running) {
3302 list_for_each_entry(t, &pn->pktgen_threads, th_list) {
3309 list_for_each_entry(t, &pn->pktgen_threads, th_list)
3310 t->control |= (T_STOP);
3323 /* Propagate thread->control */
3335 /* Propagate thread->control */
3344 char *p = pkt_dev->result;
3345 ktime_t elapsed = ktime_sub(pkt_dev->stopped_at,
3346 pkt_dev->started_at);
3347 ktime_t idle = ns_to_ktime(pkt_dev->idle_acc);
3353 (unsigned long long)pkt_dev->sofar,
3354 pkt_dev->cur_pkt_size, nr_frags);
3356 pps = div64_u64(pkt_dev->sofar * NSEC_PER_SEC,
3359 if (pkt_dev->n_imix_entries > 0) {
3364 for (i = 0; i < pkt_dev->n_imix_entries; i++) {
3365 entry = &pkt_dev->imix_entries[i];
3366 bps += entry->size * entry->count_so_far;
3370 bps = pps * 8 * pkt_dev->cur_pkt_size;
3379 (unsigned long long)pkt_dev->errors);
3382 /* Set stopped-at timer, remove from running list, do counters & statistics */
3385 int nr_frags = pkt_dev->skb ? skb_shinfo(pkt_dev->skb)->nr_frags : -1;
3387 if (!pkt_dev->running) {
3389 pkt_dev->odevname);
3390 return -EINVAL;
3393 pkt_dev->running = 0;
3394 kfree_skb(pkt_dev->skb);
3395 pkt_dev->skb = NULL;
3396 pkt_dev->stopped_at = ktime_get();
3408 list_for_each_entry_rcu(pkt_dev, &t->if_list, list) {
3409 if (!pkt_dev->running)
3413 else if (ktime_compare(pkt_dev->next_tx, best->next_tx) < 0)
3429 list_for_each_entry_rcu(pkt_dev, &t->if_list, list) {
3437 * one of our devices needs to be removed - find it
3447 list_for_each_safe(q, n, &t->if_list) {
3450 if (!cur->removal_mark)
3453 kfree_skb(cur->skb);
3454 cur->skb = NULL;
3471 list_for_each_safe(q, n, &t->if_list) {
3474 kfree_skb(cur->skb);
3475 cur->skb = NULL;
3484 remove_proc_entry(t->tsk->comm, t->net->proc_dir);
3492 pkt_dev->idle_acc += ktime_to_ns(ktime_sub(ktime_get(), idle_start));
3499 while (refcount_read(&(pkt_dev->skb->users)) != 1) {
3508 pkt_dev->idle_acc += ktime_to_ns(ktime_sub(ktime_get(), idle_start));
3513 bool skb_shared = !!(READ_ONCE(pkt_dev->flags) & F_SHARED);
3514 struct net_device *odev = pkt_dev->odev;
3527 burst = READ_ONCE(pkt_dev->burst);
3528 clone_skb = READ_ONCE(pkt_dev->clone_skb);
3540 if (unlikely(pkt_dev->delay == ULLONG_MAX)) {
3541 pkt_dev->next_tx = ktime_add_ns(ktime_get(), ULONG_MAX);
3546 if (!pkt_dev->skb || (pkt_dev->last_ok &&
3547 ++pkt_dev->clone_count >= clone_skb)) {
3549 kfree_skb(pkt_dev->skb);
3551 pkt_dev->skb = fill_packet(odev, pkt_dev);
3552 if (pkt_dev->skb == NULL) {
3555 pkt_dev->clone_count--; /* back out increment, OOM */
3558 pkt_dev->last_pkt_size = pkt_dev->skb->len;
3559 pkt_dev->clone_count = 0; /* reset counter */
3562 if (pkt_dev->delay && pkt_dev->last_ok)
3563 spin(pkt_dev, pkt_dev->next_tx);
3565 if (pkt_dev->xmit_mode == M_NETIF_RECEIVE) {
3566 skb = pkt_dev->skb;
3567 skb->protocol = eth_type_trans(skb, skb->dev);
3569 refcount_add(burst, &skb->users);
3574 pkt_dev->errors++;
3575 pkt_dev->sofar++;
3576 pkt_dev->seq_num++;
3578 pkt_dev->skb = NULL;
3581 if (refcount_read(&skb->users) != burst) {
3585 WARN_ON(refcount_sub_and_test(burst - 1, &skb->users));
3595 } while (--burst > 0);
3597 } else if (pkt_dev->xmit_mode == M_QUEUE_XMIT) {
3600 refcount_inc(&pkt_dev->skb->users);
3602 ret = dev_queue_xmit(pkt_dev->skb);
3605 pkt_dev->skb = NULL;
3609 pkt_dev->sofar++;
3610 pkt_dev->seq_num++;
3611 pkt_dev->tx_bytes += pkt_dev->last_pkt_size;
3626 pkt_dev->errors++;
3628 pkt_dev->odevname, ret);
3634 txq = skb_get_tx_queue(odev, pkt_dev->skb);
3641 pkt_dev->last_ok = 0;
3645 refcount_add(burst, &pkt_dev->skb->users);
3648 ret = netdev_start_xmit(pkt_dev->skb, odev, txq, --burst > 0);
3651 pkt_dev->skb = NULL;
3655 pkt_dev->last_ok = 1;
3656 pkt_dev->sofar++;
3657 pkt_dev->seq_num++;
3658 pkt_dev->tx_bytes += pkt_dev->last_pkt_size;
3665 pkt_dev->errors++;
3669 pkt_dev->odevname, ret);
3670 pkt_dev->errors++;
3675 refcount_dec(&pkt_dev->skb->users);
3676 pkt_dev->last_ok = 0;
3679 WARN_ON(refcount_sub_and_test(burst, &pkt_dev->skb->users));
3686 /* If pkt_dev->count is zero, then run forever */
3687 if ((pkt_dev->count != 0) && (pkt_dev->sofar >= pkt_dev->count)) {
3688 if (pkt_dev->skb)
3704 int cpu = t->cpu;
3708 init_waitqueue_head(&t->queue);
3709 complete(&t->start_done);
3718 if (unlikely(!pkt_dev && t->control == 0)) {
3719 if (t->net->pktgen_exiting)
3721 wait_event_freezable_timeout(t->queue,
3722 t->control != 0, HZ / 10);
3735 if (t->control & T_STOP) {
3737 t->control &= ~(T_STOP);
3740 if (t->control & T_RUN) {
3742 t->control &= ~(T_RUN);
3745 if (t->control & T_REMDEVALL) {
3747 t->control &= ~(T_REMDEVALL);
3750 if (t->control & T_REMDEV) {
3752 t->control &= ~(T_REMDEV);
3758 pr_debug("%s stopping all device\n", t->tsk->comm);
3761 pr_debug("%s removing all device\n", t->tsk->comm);
3764 pr_debug("%s removing thread\n", t->tsk->comm);
3774 size_t len = strlen(ifname);
3777 list_for_each_entry_rcu(p, &t->if_list, list)
3778 if (strncmp(p->odevname, ifname, len) == 0) {
3779 if (p->odevname[len]) {
3780 if (exact || p->odevname[len] != '@')
3810 if (pkt_dev->pg_thread) {
3812 rv = -EBUSY;
3816 pkt_dev->running = 0;
3817 pkt_dev->pg_thread = t;
3818 list_add_rcu(&pkt_dev->list, &t->if_list);
3831 int node = cpu_to_node(t->cpu);
3835 pkt_dev = __pktgen_NN_threads(t->net, ifname, FIND);
3838 return -EBUSY;
3843 return -ENOMEM;
3845 strscpy(pkt_dev->odevname, ifname);
3846 pkt_dev->flows = vzalloc_node(array_size(MAX_CFLOWS,
3849 if (pkt_dev->flows == NULL) {
3851 return -ENOMEM;
3854 pkt_dev->removal_mark = 0;
3855 pkt_dev->nfrags = 0;
3856 pkt_dev->delay = pg_delay_d;
3857 pkt_dev->count = pg_count_d;
3858 pkt_dev->sofar = 0;
3859 pkt_dev->udp_src_min = 9; /* sink port */
3860 pkt_dev->udp_src_max = 9;
3861 pkt_dev->udp_dst_min = 9;
3862 pkt_dev->udp_dst_max = 9;
3863 pkt_dev->vlan_p = 0;
3864 pkt_dev->vlan_cfi = 0;
3865 pkt_dev->vlan_id = 0xffff;
3866 pkt_dev->svlan_p = 0;
3867 pkt_dev->svlan_cfi = 0;
3868 pkt_dev->svlan_id = 0xffff;
3869 pkt_dev->burst = 1;
3870 pkt_dev->node = NUMA_NO_NODE;
3871 pkt_dev->flags = F_SHARED; /* SKB shared by default */
3873 err = pktgen_setup_dev(t->net, pkt_dev, ifname);
3876 if (pkt_dev->odev->priv_flags & IFF_TX_SKB_SHARING)
3877 pkt_dev->clone_skb = pg_clone_skb_d;
3879 pkt_dev->entry = proc_create_data(ifname, 0600, t->net->proc_dir,
3881 if (!pkt_dev->entry) {
3884 err = -EINVAL;
3888 pkt_dev->ipsmode = XFRM_MODE_TRANSPORT;
3889 pkt_dev->ipsproto = IPPROTO_ESP;
3896 pkt_dev->dstops.family = AF_INET;
3897 pkt_dev->xdst.u.dst.dev = pkt_dev->odev;
3898 dst_init_metrics(&pkt_dev->xdst.u.dst, pktgen_dst_metrics, false);
3899 pkt_dev->xdst.child = &pkt_dev->xdst.u.dst;
3900 pkt_dev->xdst.u.dst.ops = &pkt_dev->dstops;
3905 netdev_put(pkt_dev->odev, &pkt_dev->dev_tracker);
3910 vfree(pkt_dev->flows);
3925 return -ENOMEM;
3928 mutex_init(&t->if_lock);
3929 t->cpu = cpu;
3931 INIT_LIST_HEAD(&t->if_list);
3933 list_add_tail(&t->th_list, &pn->pktgen_threads);
3934 init_completion(&t->start_done);
3938 pr_err("kthread_create_on_node() failed for cpu %d\n", t->cpu);
3939 list_del(&t->th_list);
3944 t->tsk = p;
3946 pe = proc_create_data(t->tsk->comm, 0600, pn->proc_dir,
3950 PG_PROC_DIR, t->tsk->comm);
3952 list_del(&t->th_list);
3954 return -EINVAL;
3957 t->net = pn;
3960 wait_for_completion(&t->start_done);
3975 list_for_each_safe(q, n, &t->if_list) {
3978 list_del_rcu(&p->list);
3988 if (pkt_dev->running) {
3993 /* Dis-associate from the interface */
3995 if (pkt_dev->odev) {
3996 netdev_put(pkt_dev->odev, &pkt_dev->dev_tracker);
3997 pkt_dev->odev = NULL;
4004 proc_remove(pkt_dev->entry);
4012 vfree(pkt_dev->flows);
4013 if (pkt_dev->page)
4014 put_page(pkt_dev->page);
4025 pn->net = net;
4026 INIT_LIST_HEAD(&pn->pktgen_threads);
4027 pn->pktgen_exiting = false;
4028 pn->proc_dir = proc_mkdir(PG_PROC_DIR, pn->net->proc_net);
4029 if (!pn->proc_dir) {
4031 return -ENODEV;
4033 pe = proc_create(PGCTRL, 0600, pn->proc_dir, &pktgen_proc_ops);
4036 ret = -EINVAL;
4051 if (list_empty(&pn->pktgen_threads)) {
4053 ret = -ENODEV;
4060 remove_proc_entry(PGCTRL, pn->proc_dir);
4062 remove_proc_entry(PG_PROC_DIR, pn->net->proc_net);
4074 pn->pktgen_exiting = true;
4077 list_splice_init(&pn->pktgen_threads, &list);
4082 list_del(&t->th_list);
4083 kthread_stop_put(t->tsk);
4087 remove_proc_entry(PGCTRL, pn->proc_dir);
4088 remove_proc_entry(PG_PROC_DIR, pn->net->proc_net);