Lines Matching +full:max +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>
175 #define MAX_MPLS_LABELS 16 /* This is the max label stack depth */
177 /* Max number of internet mix entries that can be specified in imix_weights. */
185 pf(IPSRC_RND) /* IP-Src Random */ \
186 pf(IPDST_RND) /* IP-Dst Random */ \
188 pf(UDPSRC_RND) /* UDP-Src Random */ \
189 pf(UDPDST_RND) /* UDP-Dst Random */ \
197 pf(MACSRC_RND) /* MAC-Src Random */ \
198 pf(MACDST_RND) /* MAC-Dst Random */ \
234 /* If lock -- protects updating of if_list */
235 #define if_lock(t) mutex_lock(&(t->if_lock))
236 #define if_unlock(t) mutex_unlock(&(t->if_lock))
245 #define VLAN_TAG_SIZE(x) ((x)->vlan_id == 0xffff ? 0 : 4)
246 #define SVLAN_TAG_SIZE(x) ((x)->svlan_id == 0xffff ? 0 : 4)
272 struct list_head list; /* chaining in the thread's run-queue */
277 /* If min != max, then we will either do a linear iteration, or
286 int removal_mark; /* non-zero => the device is marked for
291 u64 delay; /* nano-seconds */
308 u64 idle_acc; /* nano-seconds */
338 * defines the min/max for those ranges.
361 /* Maps 0-IMIX_PRECISION range to imix_entry based on probability*/
368 /* VLAN/SVLAN (802.1Q/Q-in-Q) */
408 struct net_device *odev; /* The out-going device.
412 * Set when the user specifies the out-going
522 size_t max;
523 struct pktgen_net *pn = net_generic(current->nsproxy->net_ns, pg_net_id);
526 return -EPERM;
529 return -EINVAL;
531 max = min(count, sizeof(data) - 1);
532 if (copy_from_user(data, buf, max))
533 return -EFAULT;
535 if (data[max - 1] == '\n')
536 data[max - 1] = 0; /* strip trailing '\n', terminate string */
538 data[max] = 0; /* terminate string */
547 return -EINVAL;
567 const struct pktgen_dev *pkt_dev = seq->private;
574 (unsigned long long)pkt_dev->count, pkt_dev->min_pkt_size,
575 pkt_dev->max_pkt_size);
577 if (pkt_dev->n_imix_entries > 0) {
579 for (i = 0; i < pkt_dev->n_imix_entries; i++) {
581 pkt_dev->imix_entries[i].size,
582 pkt_dev->imix_entries[i].weight);
589 pkt_dev->nfrags, (unsigned long long) pkt_dev->delay,
590 pkt_dev->clone_skb, pkt_dev->odevname);
592 seq_printf(seq, " flows: %u flowlen: %u\n", pkt_dev->cflows,
593 pkt_dev->lflow);
597 pkt_dev->queue_map_min,
598 pkt_dev->queue_map_max);
600 if (pkt_dev->skb_priority)
602 pkt_dev->skb_priority);
604 if (pkt_dev->flags & F_IPV6) {
608 &pkt_dev->in6_saddr,
609 &pkt_dev->min_in6_saddr, &pkt_dev->max_in6_saddr,
610 &pkt_dev->in6_daddr,
611 &pkt_dev->min_in6_daddr, &pkt_dev->max_in6_daddr);
615 pkt_dev->dst_min, pkt_dev->dst_max);
618 pkt_dev->src_min, pkt_dev->src_max);
624 is_zero_ether_addr(pkt_dev->src_mac) ?
625 pkt_dev->odev->dev_addr : pkt_dev->src_mac);
628 seq_printf(seq, "%pM\n", pkt_dev->dst_mac);
632 pkt_dev->udp_src_min, pkt_dev->udp_src_max,
633 pkt_dev->udp_dst_min, pkt_dev->udp_dst_max);
637 pkt_dev->src_mac_count, pkt_dev->dst_mac_count);
639 if (pkt_dev->nr_labels) {
641 for (i = 0; i < pkt_dev->nr_labels; i++)
642 seq_printf(seq, "%08x%s", ntohl(pkt_dev->labels[i]),
643 i == pkt_dev->nr_labels-1 ? "\n" : ", ");
646 if (pkt_dev->vlan_id != 0xffff)
648 pkt_dev->vlan_id, pkt_dev->vlan_p,
649 pkt_dev->vlan_cfi);
651 if (pkt_dev->svlan_id != 0xffff)
653 pkt_dev->svlan_id, pkt_dev->svlan_p,
654 pkt_dev->svlan_cfi);
656 if (pkt_dev->tos)
657 seq_printf(seq, " tos: 0x%02x\n", pkt_dev->tos);
659 if (pkt_dev->traffic_class)
660 seq_printf(seq, " traffic_class: 0x%02x\n", pkt_dev->traffic_class);
662 if (pkt_dev->burst > 1)
663 seq_printf(seq, " burst: %d\n", pkt_dev->burst);
665 if (pkt_dev->node >= 0)
666 seq_printf(seq, " node: %d\n", pkt_dev->node);
668 if (pkt_dev->xmit_mode == M_NETIF_RECEIVE)
670 else if (pkt_dev->xmit_mode == M_QUEUE_XMIT)
677 if (!pkt_dev->cflows)
680 if (pkt_dev->flags & (1 << i)) {
683 if (i == IPSEC_SHIFT && pkt_dev->spi)
684 seq_printf(seq, "spi:%u ", pkt_dev->spi);
693 /* not really stopped, more like last-running-at */
694 stopped = pkt_dev->running ? ktime_get() : pkt_dev->stopped_at;
695 idle = pkt_dev->idle_acc;
699 "Current:\n pkts-sofar: %llu errors: %llu\n",
700 (unsigned long long)pkt_dev->sofar,
701 (unsigned long long)pkt_dev->errors);
703 if (pkt_dev->n_imix_entries > 0) {
707 for (i = 0; i < pkt_dev->n_imix_entries; i++) {
709 pkt_dev->imix_entries[i].size,
710 pkt_dev->imix_entries[i].count_so_far);
717 (unsigned long long) ktime_to_us(pkt_dev->started_at),
723 pkt_dev->seq_num, pkt_dev->cur_dst_mac_offset,
724 pkt_dev->cur_src_mac_offset);
726 if (pkt_dev->flags & F_IPV6) {
728 &pkt_dev->cur_in6_saddr,
729 &pkt_dev->cur_in6_daddr);
732 &pkt_dev->cur_saddr, &pkt_dev->cur_daddr);
735 pkt_dev->cur_udp_dst, pkt_dev->cur_udp_src);
737 seq_printf(seq, " cur_queue_map: %u\n", pkt_dev->cur_queue_map);
739 seq_printf(seq, " flows: %u\n", pkt_dev->nflows);
741 if (pkt_dev->result[0])
742 seq_printf(seq, "Result: %s\n", pkt_dev->result);
762 return -EFAULT;
782 return -EFAULT;
809 return -EFAULT;
812 *num += c - '0';
827 return -EFAULT;
853 size_t i = 0, max;
854 ssize_t len;
857 pkt_dev->n_imix_entries = 0;
863 if (pkt_dev->n_imix_entries >= MAX_IMIX_ENTRIES)
864 return -E2BIG;
867 return -EINVAL;
869 max = min(10, maxlen - i);
870 len = num_arg(&buffer[i], max, &size);
871 if (len < 0)
872 return len;
873 i += len;
875 return -EINVAL;
877 return -EFAULT;
880 return -EINVAL;
883 return -EINVAL;
888 max = min(10, maxlen - i);
889 len = num_arg(&buffer[i], max, &weight);
890 if (len < 0)
891 return len;
893 return -EINVAL;
895 pkt_dev->imix_entries[pkt_dev->n_imix_entries].size = size;
896 pkt_dev->imix_entries[pkt_dev->n_imix_entries].weight = weight;
898 i += len;
899 pkt_dev->n_imix_entries++;
904 return -EFAULT;
915 size_t i = 0, max;
916 ssize_t len;
919 pkt_dev->nr_labels = 0;
924 return -E2BIG;
927 return -EINVAL;
929 max = min(8, maxlen - i);
930 len = hex32_arg(&buffer[i], max, &tmp);
931 if (len < 0)
932 return len;
935 if (len == 0 || tmp == 0)
938 pkt_dev->labels[n] = htonl(tmp);
939 if (pkt_dev->labels[n] & MPLS_STACK_BOTTOM)
940 pkt_dev->flags |= F_MPLS_RND;
941 i += len;
946 return -EFAULT;
950 pkt_dev->nr_labels = n;
987 struct seq_file *seq = file->private_data;
988 struct pktgen_dev *pkt_dev = seq->private;
989 size_t i, max;
990 ssize_t len;
996 pg_result = &(pkt_dev->result[0]);
1000 return -EINVAL;
1003 max = count;
1004 len = count_trail_chars(user_buffer, max);
1005 if (len < 0) {
1007 return len;
1009 i = len;
1012 max = min(sizeof(name) - 1, count - i);
1013 len = strn_len(&user_buffer[i], max);
1014 if (len < 0)
1015 return len;
1018 if (copy_from_user(name, &user_buffer[i], len))
1019 return -EFAULT;
1020 i += len;
1022 max = count - i;
1023 len = count_trail_chars(&user_buffer[i], max);
1024 if (len < 0)
1025 return len;
1027 i += len;
1036 pr_debug("%s,%zu buffer -:%s:-\n", name, count, tp);
1041 max = min(10, count - i);
1042 len = num_arg(&user_buffer[i], max, &value);
1043 if (len < 0)
1044 return len;
1048 if (value != pkt_dev->min_pkt_size) {
1049 pkt_dev->min_pkt_size = value;
1050 pkt_dev->cur_pkt_size = value;
1053 pkt_dev->min_pkt_size);
1058 max = min(10, count - i);
1059 len = num_arg(&user_buffer[i], max, &value);
1060 if (len < 0)
1061 return len;
1065 if (value != pkt_dev->max_pkt_size) {
1066 pkt_dev->max_pkt_size = value;
1067 pkt_dev->cur_pkt_size = value;
1070 pkt_dev->max_pkt_size);
1074 /* Shortcut for min = max */
1077 max = min(10, count - i);
1078 len = num_arg(&user_buffer[i], max, &value);
1079 if (len < 0)
1080 return len;
1084 if (value != pkt_dev->min_pkt_size) {
1085 pkt_dev->min_pkt_size = value;
1086 pkt_dev->max_pkt_size = value;
1087 pkt_dev->cur_pkt_size = value;
1089 sprintf(pg_result, "OK: pkt_size=%d", pkt_dev->min_pkt_size);
1094 if (pkt_dev->clone_skb > 0)
1095 return -EINVAL;
1097 max = count - i;
1098 len = get_imix_entries(&user_buffer[i], max, pkt_dev);
1099 if (len < 0)
1100 return len;
1108 max = min(10, count - i);
1109 len = num_arg(&user_buffer[i], max, &value);
1110 if (len < 0)
1111 return len;
1119 max = min(10, count - i);
1120 len = num_arg(&user_buffer[i], max, &value);
1121 if (len < 0)
1122 return len;
1124 pkt_dev->nfrags = value;
1125 sprintf(pg_result, "OK: frags=%d", pkt_dev->nfrags);
1129 max = min(10, count - i);
1130 len = num_arg(&user_buffer[i], max, &value);
1131 if (len < 0)
1132 return len;
1135 pkt_dev->delay = ULLONG_MAX;
1137 pkt_dev->delay = (u64)value;
1140 (unsigned long long) pkt_dev->delay);
1144 max = min(10, count - i);
1145 len = num_arg(&user_buffer[i], max, &value);
1146 if (len < 0)
1147 return len;
1150 return -EINVAL;
1151 pkt_dev->delay = pkt_dev->min_pkt_size*8*NSEC_PER_USEC/value;
1153 pr_info("Delay set at: %llu ns\n", pkt_dev->delay);
1159 max = min(10, count - i);
1160 len = num_arg(&user_buffer[i], max, &value);
1161 if (len < 0)
1162 return len;
1165 return -EINVAL;
1166 pkt_dev->delay = NSEC_PER_SEC/value;
1168 pr_info("Delay set at: %llu ns\n", pkt_dev->delay);
1174 max = min(10, count - i);
1175 len = num_arg(&user_buffer[i], max, &value);
1176 if (len < 0)
1177 return len;
1179 if (value != pkt_dev->udp_src_min) {
1180 pkt_dev->udp_src_min = value;
1181 pkt_dev->cur_udp_src = value;
1183 sprintf(pg_result, "OK: udp_src_min=%u", pkt_dev->udp_src_min);
1187 max = min(10, count - i);
1188 len = num_arg(&user_buffer[i], max, &value);
1189 if (len < 0)
1190 return len;
1192 if (value != pkt_dev->udp_dst_min) {
1193 pkt_dev->udp_dst_min = value;
1194 pkt_dev->cur_udp_dst = value;
1196 sprintf(pg_result, "OK: udp_dst_min=%u", pkt_dev->udp_dst_min);
1200 max = min(10, count - i);
1201 len = num_arg(&user_buffer[i], max, &value);
1202 if (len < 0)
1203 return len;
1205 if (value != pkt_dev->udp_src_max) {
1206 pkt_dev->udp_src_max = value;
1207 pkt_dev->cur_udp_src = value;
1209 sprintf(pg_result, "OK: udp_src_max=%u", pkt_dev->udp_src_max);
1213 max = min(10, count - i);
1214 len = num_arg(&user_buffer[i], max, &value);
1215 if (len < 0)
1216 return len;
1218 if (value != pkt_dev->udp_dst_max) {
1219 pkt_dev->udp_dst_max = value;
1220 pkt_dev->cur_udp_dst = value;
1222 sprintf(pg_result, "OK: udp_dst_max=%u", pkt_dev->udp_dst_max);
1226 max = min(10, count - i);
1227 len = num_arg(&user_buffer[i], max, &value);
1228 if (len < 0)
1229 return len;
1234 ((pkt_dev->xmit_mode == M_NETIF_RECEIVE) ||
1235 !(pkt_dev->odev->priv_flags & IFF_TX_SKB_SHARING)))
1236 return -EOPNOTSUPP;
1237 if (value > 0 && (pkt_dev->n_imix_entries > 0 ||
1238 !(pkt_dev->flags & F_SHARED)))
1239 return -EINVAL;
1241 pkt_dev->clone_skb = value;
1243 sprintf(pg_result, "OK: clone_skb=%d", pkt_dev->clone_skb);
1247 max = min(10, count - i);
1248 len = num_arg(&user_buffer[i], max, &value);
1249 if (len < 0)
1250 return len;
1252 pkt_dev->count = value;
1254 (unsigned long long)pkt_dev->count);
1258 max = min(10, count - i);
1259 len = num_arg(&user_buffer[i], max, &value);
1260 if (len < 0)
1261 return len;
1263 if (pkt_dev->src_mac_count != value) {
1264 pkt_dev->src_mac_count = value;
1265 pkt_dev->cur_src_mac_offset = 0;
1268 pkt_dev->src_mac_count);
1272 max = min(10, count - i);
1273 len = num_arg(&user_buffer[i], max, &value);
1274 if (len < 0)
1275 return len;
1277 if (pkt_dev->dst_mac_count != value) {
1278 pkt_dev->dst_mac_count = value;
1279 pkt_dev->cur_dst_mac_offset = 0;
1282 pkt_dev->dst_mac_count);
1286 max = min(10, count - i);
1287 len = num_arg(&user_buffer[i], max, &value);
1288 if (len < 0)
1289 return len;
1292 ((pkt_dev->xmit_mode == M_QUEUE_XMIT) ||
1293 ((pkt_dev->xmit_mode == M_START_XMIT) &&
1294 (!(pkt_dev->odev->priv_flags & IFF_TX_SKB_SHARING)))))
1295 return -EOPNOTSUPP;
1297 if (value > 1 && !(pkt_dev->flags & F_SHARED))
1298 return -EINVAL;
1300 pkt_dev->burst = value < 1 ? 1 : value;
1301 sprintf(pg_result, "OK: burst=%u", pkt_dev->burst);
1305 max = min(10, count - i);
1306 len = num_arg(&user_buffer[i], max, &value);
1307 if (len < 0)
1308 return len;
1311 pkt_dev->node = value;
1312 sprintf(pg_result, "OK: node=%d", pkt_dev->node);
1313 if (pkt_dev->page) {
1314 put_page(pkt_dev->page);
1315 pkt_dev->page = NULL;
1325 max = min(sizeof(f) - 1, count - i);
1326 len = strn_len(&user_buffer[i], max);
1327 if (len < 0)
1328 return len;
1331 if (copy_from_user(f, &user_buffer[i], len))
1332 return -EFAULT;
1335 pkt_dev->xmit_mode = M_START_XMIT;
1338 if (pkt_dev->clone_skb > 0)
1339 return -EOPNOTSUPP;
1341 pkt_dev->xmit_mode = M_NETIF_RECEIVE;
1346 pkt_dev->last_ok = 1;
1348 pkt_dev->xmit_mode = M_QUEUE_XMIT;
1349 pkt_dev->last_ok = 1;
1352 "xmit_mode -:%s:- unknown\nAvailable modes: %s",
1365 max = min(sizeof(f) - 1, count - i);
1366 len = strn_len(&user_buffer[i], max);
1367 if (len < 0)
1368 return len;
1371 if (copy_from_user(f, &user_buffer[i], len))
1372 return -EFAULT;
1382 if (flag == F_SHARED && (pkt_dev->clone_skb ||
1383 pkt_dev->burst > 1))
1384 return -EINVAL;
1385 pkt_dev->flags &= ~flag;
1387 pkt_dev->flags |= flag;
1390 sprintf(pg_result, "OK: flags=0x%x", pkt_dev->flags);
1395 end = pkt_dev->result + sizeof(pkt_dev->result);
1397 "Flag -:%s:- unknown\n"
1398 "Available flags, (prepend ! to un-set flag):\n", f);
1403 pg_result += snprintf(pg_result, end - pg_result,
1408 *(pg_result - 2) = '\0';
1414 max = min(sizeof(pkt_dev->dst_min) - 1, count - i);
1415 len = strn_len(&user_buffer[i], max);
1416 if (len < 0)
1417 return len;
1419 if (copy_from_user(buf, &user_buffer[i], len))
1420 return -EFAULT;
1421 buf[len] = 0;
1422 if (strcmp(buf, pkt_dev->dst_min) != 0) {
1423 strscpy_pad(pkt_dev->dst_min, buf);
1424 pkt_dev->daddr_min = in_aton(pkt_dev->dst_min);
1425 pkt_dev->cur_daddr = pkt_dev->daddr_min;
1428 pr_debug("dst_min set to: %s\n", pkt_dev->dst_min);
1430 sprintf(pg_result, "OK: dst_min=%s", pkt_dev->dst_min);
1434 max = min(sizeof(pkt_dev->dst_max) - 1, count - i);
1435 len = strn_len(&user_buffer[i], max);
1436 if (len < 0)
1437 return len;
1439 if (copy_from_user(buf, &user_buffer[i], len))
1440 return -EFAULT;
1441 buf[len] = 0;
1442 if (strcmp(buf, pkt_dev->dst_max) != 0) {
1443 strscpy_pad(pkt_dev->dst_max, buf);
1444 pkt_dev->daddr_max = in_aton(pkt_dev->dst_max);
1445 pkt_dev->cur_daddr = pkt_dev->daddr_max;
1448 pr_debug("dst_max set to: %s\n", pkt_dev->dst_max);
1450 sprintf(pg_result, "OK: dst_max=%s", pkt_dev->dst_max);
1454 max = min(sizeof(buf) - 1, count - i);
1455 len = strn_len(&user_buffer[i], max);
1456 if (len < 0)
1457 return len;
1459 pkt_dev->flags |= F_IPV6;
1461 if (copy_from_user(buf, &user_buffer[i], len))
1462 return -EFAULT;
1463 buf[len] = 0;
1465 in6_pton(buf, -1, pkt_dev->in6_daddr.s6_addr, -1, NULL);
1466 snprintf(buf, sizeof(buf), "%pI6c", &pkt_dev->in6_daddr);
1468 pkt_dev->cur_in6_daddr = pkt_dev->in6_daddr;
1477 max = min(sizeof(buf) - 1, count - i);
1478 len = strn_len(&user_buffer[i], max);
1479 if (len < 0)
1480 return len;
1482 pkt_dev->flags |= F_IPV6;
1484 if (copy_from_user(buf, &user_buffer[i], len))
1485 return -EFAULT;
1486 buf[len] = 0;
1488 in6_pton(buf, -1, pkt_dev->min_in6_daddr.s6_addr, -1, NULL);
1489 snprintf(buf, sizeof(buf), "%pI6c", &pkt_dev->min_in6_daddr);
1491 pkt_dev->cur_in6_daddr = pkt_dev->min_in6_daddr;
1499 max = min(sizeof(buf) - 1, count - i);
1500 len = strn_len(&user_buffer[i], max);
1501 if (len < 0)
1502 return len;
1504 pkt_dev->flags |= F_IPV6;
1506 if (copy_from_user(buf, &user_buffer[i], len))
1507 return -EFAULT;
1508 buf[len] = 0;
1510 in6_pton(buf, -1, pkt_dev->max_in6_daddr.s6_addr, -1, NULL);
1511 snprintf(buf, sizeof(buf), "%pI6c", &pkt_dev->max_in6_daddr);
1520 max = min(sizeof(buf) - 1, count - i);
1521 len = strn_len(&user_buffer[i], max);
1522 if (len < 0)
1523 return len;
1525 pkt_dev->flags |= F_IPV6;
1527 if (copy_from_user(buf, &user_buffer[i], len))
1528 return -EFAULT;
1529 buf[len] = 0;
1531 in6_pton(buf, -1, pkt_dev->in6_saddr.s6_addr, -1, NULL);
1532 snprintf(buf, sizeof(buf), "%pI6c", &pkt_dev->in6_saddr);
1534 pkt_dev->cur_in6_saddr = pkt_dev->in6_saddr;
1543 max = min(sizeof(pkt_dev->src_min) - 1, count - i);
1544 len = strn_len(&user_buffer[i], max);
1545 if (len < 0)
1546 return len;
1548 if (copy_from_user(buf, &user_buffer[i], len))
1549 return -EFAULT;
1550 buf[len] = 0;
1551 if (strcmp(buf, pkt_dev->src_min) != 0) {
1552 strscpy_pad(pkt_dev->src_min, buf);
1553 pkt_dev->saddr_min = in_aton(pkt_dev->src_min);
1554 pkt_dev->cur_saddr = pkt_dev->saddr_min;
1557 pr_debug("src_min set to: %s\n", pkt_dev->src_min);
1559 sprintf(pg_result, "OK: src_min=%s", pkt_dev->src_min);
1563 max = min(sizeof(pkt_dev->src_max) - 1, count - i);
1564 len = strn_len(&user_buffer[i], max);
1565 if (len < 0)
1566 return len;
1568 if (copy_from_user(buf, &user_buffer[i], len))
1569 return -EFAULT;
1570 buf[len] = 0;
1571 if (strcmp(buf, pkt_dev->src_max) != 0) {
1572 strscpy_pad(pkt_dev->src_max, buf);
1573 pkt_dev->saddr_max = in_aton(pkt_dev->src_max);
1574 pkt_dev->cur_saddr = pkt_dev->saddr_max;
1577 pr_debug("src_max set to: %s\n", pkt_dev->src_max);
1579 sprintf(pg_result, "OK: src_max=%s", pkt_dev->src_max);
1583 max = min(sizeof(valstr) - 1, count - i);
1584 len = strn_len(&user_buffer[i], max);
1585 if (len < 0)
1586 return len;
1589 if (copy_from_user(valstr, &user_buffer[i], len))
1590 return -EFAULT;
1592 if (!mac_pton(valstr, pkt_dev->dst_mac))
1593 return -EINVAL;
1595 ether_addr_copy(&pkt_dev->hh[0], pkt_dev->dst_mac);
1597 sprintf(pg_result, "OK: dstmac %pM", pkt_dev->dst_mac);
1601 max = min(sizeof(valstr) - 1, count - i);
1602 len = strn_len(&user_buffer[i], max);
1603 if (len < 0)
1604 return len;
1607 if (copy_from_user(valstr, &user_buffer[i], len))
1608 return -EFAULT;
1610 if (!mac_pton(valstr, pkt_dev->src_mac))
1611 return -EINVAL;
1613 ether_addr_copy(&pkt_dev->hh[6], pkt_dev->src_mac);
1615 sprintf(pg_result, "OK: srcmac %pM", pkt_dev->src_mac);
1626 max = min(10, count - i);
1627 len = num_arg(&user_buffer[i], max, &value);
1628 if (len < 0)
1629 return len;
1634 pkt_dev->cflows = value;
1635 sprintf(pg_result, "OK: flows=%u", pkt_dev->cflows);
1640 max = min(10, count - i);
1641 len = num_arg(&user_buffer[i], max, &value);
1642 if (len < 0)
1643 return len;
1645 pkt_dev->spi = value;
1646 sprintf(pg_result, "OK: spi=%u", pkt_dev->spi);
1651 max = min(10, count - i);
1652 len = num_arg(&user_buffer[i], max, &value);
1653 if (len < 0)
1654 return len;
1656 pkt_dev->lflow = value;
1657 sprintf(pg_result, "OK: flowlen=%u", pkt_dev->lflow);
1662 max = min(5, count - i);
1663 len = num_arg(&user_buffer[i], max, &value);
1664 if (len < 0)
1665 return len;
1667 pkt_dev->queue_map_min = value;
1668 sprintf(pg_result, "OK: queue_map_min=%u", pkt_dev->queue_map_min);
1673 max = min(5, count - i);
1674 len = num_arg(&user_buffer[i], max, &value);
1675 if (len < 0)
1676 return len;
1678 pkt_dev->queue_map_max = value;
1679 sprintf(pg_result, "OK: queue_map_max=%u", pkt_dev->queue_map_max);
1686 max = count - i;
1687 len = get_labels(&user_buffer[i], max, pkt_dev);
1688 if (len < 0)
1689 return len;
1692 for (n = 0; n < pkt_dev->nr_labels; n++)
1694 "%08x%s", ntohl(pkt_dev->labels[n]),
1695 n == pkt_dev->nr_labels-1 ? "" : ",");
1697 if (pkt_dev->nr_labels && pkt_dev->vlan_id != 0xffff) {
1698 pkt_dev->vlan_id = 0xffff; /* turn off VLAN/SVLAN */
1699 pkt_dev->svlan_id = 0xffff;
1708 max = min(4, count - i);
1709 len = num_arg(&user_buffer[i], max, &value);
1710 if (len < 0)
1711 return len;
1714 pkt_dev->vlan_id = value; /* turn on VLAN */
1719 if (debug && pkt_dev->nr_labels)
1722 pkt_dev->nr_labels = 0; /* turn off MPLS */
1723 sprintf(pg_result, "OK: vlan_id=%u", pkt_dev->vlan_id);
1725 pkt_dev->vlan_id = 0xffff; /* turn off VLAN/SVLAN */
1726 pkt_dev->svlan_id = 0xffff;
1735 max = min(1, count - i);
1736 len = num_arg(&user_buffer[i], max, &value);
1737 if (len < 0)
1738 return len;
1740 if ((value <= 7) && (pkt_dev->vlan_id != 0xffff)) {
1741 pkt_dev->vlan_p = value;
1742 sprintf(pg_result, "OK: vlan_p=%u", pkt_dev->vlan_p);
1744 sprintf(pg_result, "ERROR: vlan_p must be 0-7");
1750 max = min(1, count - i);
1751 len = num_arg(&user_buffer[i], max, &value);
1752 if (len < 0)
1753 return len;
1755 if ((value <= 1) && (pkt_dev->vlan_id != 0xffff)) {
1756 pkt_dev->vlan_cfi = value;
1757 sprintf(pg_result, "OK: vlan_cfi=%u", pkt_dev->vlan_cfi);
1759 sprintf(pg_result, "ERROR: vlan_cfi must be 0-1");
1765 max = min(4, count - i);
1766 len = num_arg(&user_buffer[i], max, &value);
1767 if (len < 0)
1768 return len;
1770 if ((value <= 4095) && ((pkt_dev->vlan_id != 0xffff))) {
1771 pkt_dev->svlan_id = value; /* turn on SVLAN */
1776 if (debug && pkt_dev->nr_labels)
1779 pkt_dev->nr_labels = 0; /* turn off MPLS */
1780 sprintf(pg_result, "OK: svlan_id=%u", pkt_dev->svlan_id);
1782 pkt_dev->vlan_id = 0xffff; /* turn off VLAN/SVLAN */
1783 pkt_dev->svlan_id = 0xffff;
1792 max = min(1, count - i);
1793 len = num_arg(&user_buffer[i], max, &value);
1794 if (len < 0)
1795 return len;
1797 if ((value <= 7) && (pkt_dev->svlan_id != 0xffff)) {
1798 pkt_dev->svlan_p = value;
1799 sprintf(pg_result, "OK: svlan_p=%u", pkt_dev->svlan_p);
1801 sprintf(pg_result, "ERROR: svlan_p must be 0-7");
1807 max = min(1, count - i);
1808 len = num_arg(&user_buffer[i], max, &value);
1809 if (len < 0)
1810 return len;
1812 if ((value <= 1) && (pkt_dev->svlan_id != 0xffff)) {
1813 pkt_dev->svlan_cfi = value;
1814 sprintf(pg_result, "OK: svlan_cfi=%u", pkt_dev->svlan_cfi);
1816 sprintf(pg_result, "ERROR: svlan_cfi must be 0-1");
1824 max = min(2, count - i);
1825 len = hex32_arg(&user_buffer[i], max, &tmp_value);
1826 if (len < 0)
1827 return len;
1829 if (len == 2) {
1830 pkt_dev->tos = tmp_value;
1831 sprintf(pg_result, "OK: tos=0x%02x", pkt_dev->tos);
1833 sprintf(pg_result, "ERROR: tos must be 00-ff");
1841 max = min(2, count - i);
1842 len = hex32_arg(&user_buffer[i], max, &tmp_value);
1843 if (len < 0)
1844 return len;
1846 if (len == 2) {
1847 pkt_dev->traffic_class = tmp_value;
1848 sprintf(pg_result, "OK: traffic_class=0x%02x", pkt_dev->traffic_class);
1850 sprintf(pg_result, "ERROR: traffic_class must be 00-ff");
1856 max = min(9, count - i);
1857 len = num_arg(&user_buffer[i], max, &value);
1858 if (len < 0)
1859 return len;
1861 pkt_dev->skb_priority = value;
1863 pkt_dev->skb_priority);
1867 sprintf(pkt_dev->result, "No such parameter \"%s\"", name);
1868 return -EINVAL;
1886 struct pktgen_thread *t = seq->private;
1894 list_for_each_entry_rcu(pkt_dev, &t->if_list, list)
1895 if (pkt_dev->running)
1896 seq_printf(seq, "%s ", pkt_dev->odevname);
1900 list_for_each_entry_rcu(pkt_dev, &t->if_list, list)
1901 if (!pkt_dev->running)
1902 seq_printf(seq, "%s ", pkt_dev->odevname);
1904 if (t->result[0])
1905 seq_printf(seq, "\nResult: %s\n", t->result);
1918 struct seq_file *seq = file->private_data;
1919 struct pktgen_thread *t = seq->private;
1920 size_t i, max;
1921 ssize_t len, ret;
1927 return -EINVAL;
1930 max = count;
1931 len = count_trail_chars(user_buffer, max);
1932 if (len < 0)
1933 return len;
1935 i = len;
1938 max = min(sizeof(name) - 1, count - i);
1939 len = strn_len(&user_buffer[i], max);
1940 if (len < 0)
1941 return len;
1944 if (copy_from_user(name, &user_buffer[i], len))
1945 return -EFAULT;
1946 i += len;
1948 max = count - i;
1949 len = count_trail_chars(&user_buffer[i], max);
1950 if (len < 0)
1951 return len;
1953 i += len;
1960 ret = -EINVAL;
1964 pg_result = &(t->result[0]);
1970 max = min(sizeof(f) - 1, count - i);
1971 len = strn_len(&user_buffer[i], max);
1972 if (len < 0) {
1973 ret = len;
1976 if (copy_from_user(f, &user_buffer[i], len))
1977 return -EFAULT;
1992 t->control |= T_REMDEVALL;
1994 schedule_timeout_interruptible(msecs_to_jiffies(125)); /* Propagate thread->control */
2001 sprintf(pg_result, "OK: Note! max_before_softirq is obsoleted -- Do not use");
2006 ret = -EINVAL;
2032 list_for_each_entry(t, &pn->pktgen_threads, th_list) {
2036 pkt_dev->removal_mark = 1;
2037 t->control |= T_REMDEV;
2086 list_for_each_entry(t, &pn->pktgen_threads, th_list) {
2090 list_for_each_entry(pkt_dev, &t->if_list, list) {
2091 if (pkt_dev->odev != dev)
2094 proc_remove(pkt_dev->entry);
2096 pkt_dev->entry = proc_create_data(dev->name, 0600,
2097 pn->proc_dir,
2100 if (!pkt_dev->entry)
2102 dev->name);
2116 if (pn->pktgen_exiting)
2129 pktgen_mark_device(pn, dev->name);
2151 return dev_get_by_name(pn->net, b);
2164 if (pkt_dev->odev) {
2165 netdev_put(pkt_dev->odev, &pkt_dev->dev_tracker);
2166 pkt_dev->odev = NULL;
2172 return -ENODEV;
2175 if (odev->type != ARPHRD_ETHER && odev->type != ARPHRD_LOOPBACK) {
2177 err = -EINVAL;
2180 err = -ENETDOWN;
2182 pkt_dev->odev = odev;
2183 netdev_tracker_alloc(odev, &pkt_dev->dev_tracker, GFP_KERNEL);
2198 if (!pkt_dev->odev) {
2199 pr_err("ERROR: pkt_dev->odev == NULL in setup_inject\n");
2200 sprintf(pkt_dev->result,
2201 "ERROR: pkt_dev->odev == NULL in setup_inject.\n");
2205 /* make sure that we don't pick a non-existing transmit queue */
2206 ntxq = pkt_dev->odev->real_num_tx_queues;
2208 if (ntxq <= pkt_dev->queue_map_min) {
2209 pr_warn("WARNING: Requested queue_map_min (zero-based) (%d) exceeds valid range [0 - %d] for (%d) queues on %s, resetting\n",
2210 pkt_dev->queue_map_min, (ntxq ?: 1) - 1, ntxq,
2211 pkt_dev->odevname);
2212 pkt_dev->queue_map_min = (ntxq ?: 1) - 1;
2214 if (pkt_dev->queue_map_max >= ntxq) {
2215 pr_warn("WARNING: Requested queue_map_max (zero-based) (%d) exceeds valid range [0 - %d] for (%d) queues on %s, resetting\n",
2216 pkt_dev->queue_map_max, (ntxq ?: 1) - 1, ntxq,
2217 pkt_dev->odevname);
2218 pkt_dev->queue_map_max = (ntxq ?: 1) - 1;
2223 if (is_zero_ether_addr(pkt_dev->src_mac))
2224 ether_addr_copy(&(pkt_dev->hh[6]), pkt_dev->odev->dev_addr);
2227 ether_addr_copy(&(pkt_dev->hh[0]), pkt_dev->dst_mac);
2229 if (pkt_dev->flags & F_IPV6) {
2233 if (pkt_dev->min_pkt_size == 0) {
2234 pkt_dev->min_pkt_size = 14 + sizeof(struct ipv6hdr)
2237 + pkt_dev->pkt_overhead;
2241 if (pkt_dev->cur_in6_saddr.s6_addr[i]) {
2255 idev = __in6_dev_get(pkt_dev->odev);
2259 read_lock_bh(&idev->lock);
2260 list_for_each_entry(ifp, &idev->addr_list, if_list) {
2261 if ((ifp->scope & IFA_LINK) &&
2262 !(ifp->flags & IFA_F_TENTATIVE)) {
2263 pkt_dev->cur_in6_saddr = ifp->addr;
2268 read_unlock_bh(&idev->lock);
2275 if (pkt_dev->min_pkt_size == 0) {
2276 pkt_dev->min_pkt_size = 14 + sizeof(struct iphdr)
2279 + pkt_dev->pkt_overhead;
2282 pkt_dev->saddr_min = 0;
2283 pkt_dev->saddr_max = 0;
2284 if (strlen(pkt_dev->src_min) == 0) {
2289 in_dev = __in_dev_get_rcu(pkt_dev->odev);
2293 ifa = rcu_dereference(in_dev->ifa_list);
2295 pkt_dev->saddr_min = ifa->ifa_address;
2296 pkt_dev->saddr_max = pkt_dev->saddr_min;
2301 pkt_dev->saddr_min = in_aton(pkt_dev->src_min);
2302 pkt_dev->saddr_max = in_aton(pkt_dev->src_max);
2305 pkt_dev->daddr_min = in_aton(pkt_dev->dst_min);
2306 pkt_dev->daddr_max = in_aton(pkt_dev->dst_max);
2309 pkt_dev->cur_pkt_size = pkt_dev->min_pkt_size;
2310 if (pkt_dev->min_pkt_size > pkt_dev->max_pkt_size)
2311 pkt_dev->max_pkt_size = pkt_dev->min_pkt_size;
2313 pkt_dev->cur_dst_mac_offset = 0;
2314 pkt_dev->cur_src_mac_offset = 0;
2315 pkt_dev->cur_saddr = pkt_dev->saddr_min;
2316 pkt_dev->cur_daddr = pkt_dev->daddr_min;
2317 pkt_dev->cur_udp_dst = pkt_dev->udp_dst_min;
2318 pkt_dev->cur_udp_src = pkt_dev->udp_src_min;
2319 pkt_dev->nflows = 0;
2351 } while (t.task && pkt_dev->running && !signal_pending(current));
2356 pkt_dev->idle_acc += ktime_to_ns(ktime_sub(end_time, start_time));
2358 pkt_dev->next_tx = ktime_add_ns(spin_until, pkt_dev->delay);
2364 pkt_dev->pkt_overhead = 0;
2365 pkt_dev->pkt_overhead += pkt_dev->nr_labels*sizeof(u32);
2366 pkt_dev->pkt_overhead += VLAN_TAG_SIZE(pkt_dev);
2367 pkt_dev->pkt_overhead += SVLAN_TAG_SIZE(pkt_dev);
2372 return !!(pkt_dev->flows[flow].flags & F_INIT);
2377 int flow = pkt_dev->curfl;
2379 if (pkt_dev->flags & F_FLOW_SEQ) {
2380 if (pkt_dev->flows[flow].count >= pkt_dev->lflow) {
2382 pkt_dev->flows[flow].count = 0;
2383 pkt_dev->flows[flow].flags = 0;
2384 pkt_dev->curfl += 1;
2385 if (pkt_dev->curfl >= pkt_dev->cflows)
2386 pkt_dev->curfl = 0; /*reset */
2389 flow = get_random_u32_below(pkt_dev->cflows);
2390 pkt_dev->curfl = flow;
2392 if (pkt_dev->flows[flow].count > pkt_dev->lflow) {
2393 pkt_dev->flows[flow].count = 0;
2394 pkt_dev->flows[flow].flags = 0;
2398 return pkt_dev->curfl;
2409 struct xfrm_state *x = pkt_dev->flows[flow].x;
2410 struct pktgen_net *pn = net_generic(dev_net(pkt_dev->odev), pg_net_id);
2414 if (pkt_dev->spi) {
2418 x = xfrm_state_lookup_byspi(pn->net, htonl(pkt_dev->spi), AF_INET);
2421 x = xfrm_stateonly_find(pn->net, DUMMY_MARK, 0,
2422 (xfrm_address_t *)&pkt_dev->cur_daddr,
2423 (xfrm_address_t *)&pkt_dev->cur_saddr,
2425 pkt_dev->ipsmode,
2426 pkt_dev->ipsproto, 0);
2429 pkt_dev->flows[flow].x = x;
2431 pkt_dev->pkt_overhead += x->props.header_len;
2439 if (pkt_dev->flags & F_QUEUE_MAP_CPU)
2440 pkt_dev->cur_queue_map = smp_processor_id();
2442 else if (pkt_dev->queue_map_min <= pkt_dev->queue_map_max) {
2445 if (pkt_dev->flags & F_QUEUE_MAP_RND) {
2446 t = get_random_u32_inclusive(pkt_dev->queue_map_min,
2447 pkt_dev->queue_map_max);
2449 t = pkt_dev->cur_queue_map + 1;
2450 if (t > pkt_dev->queue_map_max)
2451 t = pkt_dev->queue_map_min;
2453 pkt_dev->cur_queue_map = t;
2455 pkt_dev->cur_queue_map = pkt_dev->cur_queue_map % pkt_dev->odev->real_num_tx_queues;
2459 * for IP src/dest, UDP src/dst port, MAC-Addr src/dst
2467 if (pkt_dev->cflows)
2471 if (pkt_dev->src_mac_count > 1) {
2475 if (pkt_dev->flags & F_MACSRC_RND)
2476 mc = get_random_u32_below(pkt_dev->src_mac_count);
2478 mc = pkt_dev->cur_src_mac_offset++;
2479 if (pkt_dev->cur_src_mac_offset >=
2480 pkt_dev->src_mac_count)
2481 pkt_dev->cur_src_mac_offset = 0;
2484 tmp = pkt_dev->src_mac[5] + (mc & 0xFF);
2485 pkt_dev->hh[11] = tmp;
2486 tmp = (pkt_dev->src_mac[4] + ((mc >> 8) & 0xFF) + (tmp >> 8));
2487 pkt_dev->hh[10] = tmp;
2488 tmp = (pkt_dev->src_mac[3] + ((mc >> 16) & 0xFF) + (tmp >> 8));
2489 pkt_dev->hh[9] = tmp;
2490 tmp = (pkt_dev->src_mac[2] + ((mc >> 24) & 0xFF) + (tmp >> 8));
2491 pkt_dev->hh[8] = tmp;
2492 tmp = (pkt_dev->src_mac[1] + (tmp >> 8));
2493 pkt_dev->hh[7] = tmp;
2497 if (pkt_dev->dst_mac_count > 1) {
2501 if (pkt_dev->flags & F_MACDST_RND)
2502 mc = get_random_u32_below(pkt_dev->dst_mac_count);
2505 mc = pkt_dev->cur_dst_mac_offset++;
2506 if (pkt_dev->cur_dst_mac_offset >=
2507 pkt_dev->dst_mac_count) {
2508 pkt_dev->cur_dst_mac_offset = 0;
2512 tmp = pkt_dev->dst_mac[5] + (mc & 0xFF);
2513 pkt_dev->hh[5] = tmp;
2514 tmp = (pkt_dev->dst_mac[4] + ((mc >> 8) & 0xFF) + (tmp >> 8));
2515 pkt_dev->hh[4] = tmp;
2516 tmp = (pkt_dev->dst_mac[3] + ((mc >> 16) & 0xFF) + (tmp >> 8));
2517 pkt_dev->hh[3] = tmp;
2518 tmp = (pkt_dev->dst_mac[2] + ((mc >> 24) & 0xFF) + (tmp >> 8));
2519 pkt_dev->hh[2] = tmp;
2520 tmp = (pkt_dev->dst_mac[1] + (tmp >> 8));
2521 pkt_dev->hh[1] = tmp;
2524 if (pkt_dev->flags & F_MPLS_RND) {
2527 for (i = 0; i < pkt_dev->nr_labels; i++)
2528 if (pkt_dev->labels[i] & MPLS_STACK_BOTTOM)
2529 pkt_dev->labels[i] = MPLS_STACK_BOTTOM |
2534 if ((pkt_dev->flags & F_VID_RND) && (pkt_dev->vlan_id != 0xffff)) {
2535 pkt_dev->vlan_id = get_random_u32_below(4096);
2538 if ((pkt_dev->flags & F_SVID_RND) && (pkt_dev->svlan_id != 0xffff)) {
2539 pkt_dev->svlan_id = get_random_u32_below(4096);
2542 if (pkt_dev->udp_src_min < pkt_dev->udp_src_max) {
2543 if (pkt_dev->flags & F_UDPSRC_RND)
2544 pkt_dev->cur_udp_src = get_random_u32_inclusive(pkt_dev->udp_src_min,
2545 pkt_dev->udp_src_max - 1);
2548 pkt_dev->cur_udp_src++;
2549 if (pkt_dev->cur_udp_src >= pkt_dev->udp_src_max)
2550 pkt_dev->cur_udp_src = pkt_dev->udp_src_min;
2554 if (pkt_dev->udp_dst_min < pkt_dev->udp_dst_max) {
2555 if (pkt_dev->flags & F_UDPDST_RND) {
2556 pkt_dev->cur_udp_dst = get_random_u32_inclusive(pkt_dev->udp_dst_min,
2557 pkt_dev->udp_dst_max - 1);
2559 pkt_dev->cur_udp_dst++;
2560 if (pkt_dev->cur_udp_dst >= pkt_dev->udp_dst_max)
2561 pkt_dev->cur_udp_dst = pkt_dev->udp_dst_min;
2565 if (!(pkt_dev->flags & F_IPV6)) {
2567 imn = ntohl(pkt_dev->saddr_min);
2568 imx = ntohl(pkt_dev->saddr_max);
2572 if (pkt_dev->flags & F_IPSRC_RND)
2573 t = get_random_u32_inclusive(imn, imx - 1);
2575 t = ntohl(pkt_dev->cur_saddr);
2581 pkt_dev->cur_saddr = htonl(t);
2584 if (pkt_dev->cflows && f_seen(pkt_dev, flow)) {
2585 pkt_dev->cur_daddr = pkt_dev->flows[flow].cur_daddr;
2587 imn = ntohl(pkt_dev->daddr_min);
2588 imx = ntohl(pkt_dev->daddr_max);
2593 if (pkt_dev->flags & F_IPDST_RND) {
2596 t = get_random_u32_inclusive(imn, imx - 1);
2603 pkt_dev->cur_daddr = s;
2605 t = ntohl(pkt_dev->cur_daddr);
2610 pkt_dev->cur_daddr = htonl(t);
2613 if (pkt_dev->cflows) {
2614 pkt_dev->flows[flow].flags |= F_INIT;
2615 pkt_dev->flows[flow].cur_daddr =
2616 pkt_dev->cur_daddr;
2617 if (pkt_dev->flags & F_IPSEC)
2619 pkt_dev->nflows++;
2624 if (!ipv6_addr_any(&pkt_dev->min_in6_daddr)) {
2630 pkt_dev->cur_in6_daddr.s6_addr32[i] =
2632 pkt_dev->min_in6_daddr.s6_addr32[i]) &
2633 pkt_dev->max_in6_daddr.s6_addr32[i]);
2638 if (pkt_dev->min_pkt_size < pkt_dev->max_pkt_size) {
2641 if (pkt_dev->flags & F_TXSIZE_RND) {
2642 t = get_random_u32_inclusive(pkt_dev->min_pkt_size,
2643 pkt_dev->max_pkt_size - 1);
2645 t = pkt_dev->cur_pkt_size + 1;
2646 if (t > pkt_dev->max_pkt_size)
2647 t = pkt_dev->min_pkt_size;
2649 pkt_dev->cur_pkt_size = t;
2650 } else if (pkt_dev->n_imix_entries > 0) {
2653 __u8 entry_index = pkt_dev->imix_distribution[t];
2655 entry = &pkt_dev->imix_entries[entry_index];
2656 entry->count_so_far++;
2657 pkt_dev->cur_pkt_size = entry->size;
2662 pkt_dev->flows[flow].count++;
2673 for (i = 0; i < pkt_dev->n_imix_entries; i++)
2674 total_weight += pkt_dev->imix_entries[i].weight;
2677 for (i = 0; i < pkt_dev->n_imix_entries - 1; i++) {
2678 cumulative_prob += div64_u64(pkt_dev->imix_entries[i].weight *
2683 cumulative_probabilites[pkt_dev->n_imix_entries - 1] = 100;
2688 pkt_dev->imix_distribution[i] = j;
2700 struct xfrm_state *x = pkt_dev->flows[pkt_dev->curfl].x;
2702 struct net *net = dev_net(pkt_dev->odev);
2709 if ((x->props.mode != XFRM_MODE_TRANSPORT) && (pkt_dev->spi == 0))
2715 if ((x->props.mode == XFRM_MODE_TUNNEL) && (pkt_dev->spi != 0))
2716 skb->_skb_refdst = (unsigned long)&pkt_dev->xdst.u.dst | SKB_DST_NOREF;
2725 err = x->type->output(x, skb);
2730 spin_lock_bh(&x->lock);
2731 x->curlft.bytes += skb->len;
2732 x->curlft.packets++;
2733 spin_unlock_bh(&x->lock);
2740 if (pkt_dev->cflows) {
2744 for (i = 0; i < pkt_dev->cflows; i++) {
2745 struct xfrm_state *x = pkt_dev->flows[i].x;
2749 pkt_dev->flows[i].x = NULL;
2758 if (pkt_dev->flags & F_IPSEC) {
2759 struct xfrm_state *x = pkt_dev->flows[pkt_dev->curfl].x;
2767 nhead = x->props.header_len - skb_headroom(skb);
2786 memcpy(eth, pkt_dev->hh, 2 * ETH_ALEN);
2787 eth->h_proto = protocol;
2789 /* Update IPv4 header len as well as checksum value */
2791 iph->tot_len = htons(skb->len - ETH_HLEN);
2806 for (i = 0; i < pkt_dev->nr_labels; i++)
2807 *mpls++ = pkt_dev->labels[i] & ~MPLS_STACK_BOTTOM;
2809 mpls--;
2826 datalen -= sizeof(*pgh);
2828 if (pkt_dev->nfrags <= 0) {
2831 int frags = pkt_dev->nfrags;
2832 int i, len;
2838 len = datalen - frags * PAGE_SIZE;
2839 if (len > 0) {
2840 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,
2864 skb_frag_fill_page_desc(&skb_shinfo(skb)->frags[i],
2865 pkt_dev->page, 0, frag_len);
2867 datalen -= skb_frag_size(&skb_shinfo(skb)->frags[i]);
2868 skb->len += skb_frag_size(&skb_shinfo(skb)->frags[i]);
2869 skb->data_len += skb_frag_size(&skb_shinfo(skb)->frags[i]);
2871 skb_shinfo(skb)->nr_frags = i;
2878 pgh->pgh_magic = htonl(PKTGEN_MAGIC);
2879 pgh->seq_num = htonl(pkt_dev->seq_num);
2881 if (pkt_dev->flags & F_NO_TIMESTAMP) {
2882 pgh->tv_sec = 0;
2883 pgh->tv_usec = 0;
2886 * pgh->tv_sec wraps in y2106 when interpreted as unsigned
2889 * it, we could introduce a variant that puts 64-bit nanoseconds
2894 pgh->tv_sec = htonl(timestamp.tv_sec);
2895 pgh->tv_usec = htonl(timestamp.tv_nsec / NSEC_PER_USEC);
2906 size = pkt_dev->cur_pkt_size + 64 + extralen + pkt_dev->pkt_overhead;
2907 if (pkt_dev->flags & F_NODE) {
2908 int node = pkt_dev->node >= 0 ? pkt_dev->node : numa_node_id();
2913 skb->dev = dev;
2919 /* the caller pre-fetches from skb->data and reserves for the mac hdr */
2921 skb_reserve(skb, extralen - 16);
2937 __be16 *vlan_encapsulated_proto = NULL; /* packet type ID field (or len) for VLAN tag */
2939 __be16 *svlan_encapsulated_proto = NULL; /* packet type ID field (or len) for SVLAN tag */
2942 if (pkt_dev->nr_labels)
2945 if (pkt_dev->vlan_id != 0xffff)
2952 queue_map = pkt_dev->cur_queue_map;
2956 sprintf(pkt_dev->result, "No memory");
2960 prefetchw(skb->data);
2965 mpls = skb_put(skb, pkt_dev->nr_labels * sizeof(__u32));
2966 if (pkt_dev->nr_labels)
2969 if (pkt_dev->vlan_id != 0xffff) {
2970 if (pkt_dev->svlan_id != 0xffff) {
2972 *svlan_tci = build_tci(pkt_dev->svlan_id,
2973 pkt_dev->svlan_cfi,
2974 pkt_dev->svlan_p);
2980 *vlan_tci = build_tci(pkt_dev->vlan_id,
2981 pkt_dev->vlan_cfi,
2982 pkt_dev->vlan_p);
2988 skb_set_network_header(skb, skb->len);
2991 skb_set_transport_header(skb, skb->len);
2994 skb->priority = pkt_dev->skb_priority;
2996 memcpy(eth, pkt_dev->hh, 12);
3000 datalen = pkt_dev->cur_pkt_size - 14 - 20 - 8 -
3001 pkt_dev->pkt_overhead;
3005 udph->source = htons(pkt_dev->cur_udp_src);
3006 udph->dest = htons(pkt_dev->cur_udp_dst);
3007 udph->len = htons(datalen + 8); /* DATA + udphdr */
3008 udph->check = 0;
3010 iph->ihl = 5;
3011 iph->version = 4;
3012 iph->ttl = 32;
3013 iph->tos = pkt_dev->tos;
3014 iph->protocol = IPPROTO_UDP; /* UDP */
3015 iph->saddr = pkt_dev->cur_saddr;
3016 iph->daddr = pkt_dev->cur_daddr;
3017 iph->id = htons(pkt_dev->ip_id);
3018 pkt_dev->ip_id++;
3019 iph->frag_off = 0;
3021 iph->tot_len = htons(iplen);
3023 skb->protocol = protocol;
3024 skb->dev = odev;
3025 skb->pkt_type = PACKET_HOST;
3029 if (!(pkt_dev->flags & F_UDPCSUM)) {
3030 skb->ip_summed = CHECKSUM_NONE;
3031 } else if (odev->features & (NETIF_F_HW_CSUM | NETIF_F_IP_CSUM)) {
3032 skb->ip_summed = CHECKSUM_PARTIAL;
3033 skb->csum = 0;
3034 udp4_hwcsum(skb, iph->saddr, iph->daddr);
3038 /* add protocol-dependent pseudo-header */
3039 udph->check = csum_tcpudp_magic(iph->saddr, iph->daddr,
3042 if (udph->check == 0)
3043 udph->check = CSUM_MANGLED_0;
3065 __be16 *vlan_encapsulated_proto = NULL; /* packet type ID field (or len) for VLAN tag */
3067 __be16 *svlan_encapsulated_proto = NULL; /* packet type ID field (or len) for SVLAN tag */
3070 if (pkt_dev->nr_labels)
3073 if (pkt_dev->vlan_id != 0xffff)
3080 queue_map = pkt_dev->cur_queue_map;
3084 sprintf(pkt_dev->result, "No memory");
3088 prefetchw(skb->data);
3093 mpls = skb_put(skb, pkt_dev->nr_labels * sizeof(__u32));
3094 if (pkt_dev->nr_labels)
3097 if (pkt_dev->vlan_id != 0xffff) {
3098 if (pkt_dev->svlan_id != 0xffff) {
3100 *svlan_tci = build_tci(pkt_dev->svlan_id,
3101 pkt_dev->svlan_cfi,
3102 pkt_dev->svlan_p);
3108 *vlan_tci = build_tci(pkt_dev->vlan_id,
3109 pkt_dev->vlan_cfi,
3110 pkt_dev->vlan_p);
3116 skb_set_network_header(skb, skb->len);
3119 skb_set_transport_header(skb, skb->len);
3122 skb->priority = pkt_dev->skb_priority;
3124 memcpy(eth, pkt_dev->hh, 12);
3128 datalen = pkt_dev->cur_pkt_size - 14 -
3129 sizeof(struct ipv6hdr) - sizeof(struct udphdr) -
3130 pkt_dev->pkt_overhead;
3138 udph->source = htons(pkt_dev->cur_udp_src);
3139 udph->dest = htons(pkt_dev->cur_udp_dst);
3140 udph->len = htons(udplen);
3141 udph->check = 0;
3145 if (pkt_dev->traffic_class) {
3147 *(__be32 *)iph |= htonl(0x60000000 | (pkt_dev->traffic_class << 20));
3150 iph->hop_limit = 32;
3152 iph->payload_len = htons(udplen);
3153 iph->nexthdr = IPPROTO_UDP;
3155 iph->daddr = pkt_dev->cur_in6_daddr;
3156 iph->saddr = pkt_dev->cur_in6_saddr;
3158 skb->protocol = protocol;
3159 skb->dev = odev;
3160 skb->pkt_type = PACKET_HOST;
3164 if (!(pkt_dev->flags & F_UDPCSUM)) {
3165 skb->ip_summed = CHECKSUM_NONE;
3166 } else if (odev->features & (NETIF_F_HW_CSUM | NETIF_F_IPV6_CSUM)) {
3167 skb->ip_summed = CHECKSUM_PARTIAL;
3168 skb->csum_start = skb_transport_header(skb) - skb->head;
3169 skb->csum_offset = offsetof(struct udphdr, check);
3170 udph->check = ~csum_ipv6_magic(&iph->saddr, &iph->daddr, udplen, IPPROTO_UDP, 0);
3174 /* add protocol-dependent pseudo-header */
3175 udph->check = csum_ipv6_magic(&iph->saddr, &iph->daddr, udplen, IPPROTO_UDP, csum);
3177 if (udph->check == 0)
3178 udph->check = CSUM_MANGLED_0;
3187 if (pkt_dev->flags & F_IPV6)
3195 pkt_dev->seq_num = 1;
3196 pkt_dev->idle_acc = 0;
3197 pkt_dev->sofar = 0;
3198 pkt_dev->tx_bytes = 0;
3199 pkt_dev->errors = 0;
3212 list_for_each_entry_rcu(pkt_dev, &t->if_list, list) {
3219 if (pkt_dev->odev) {
3221 pkt_dev->skb = NULL;
3222 pkt_dev->started_at = pkt_dev->next_tx = ktime_get();
3226 strscpy(pkt_dev->result, "Starting");
3227 pkt_dev->running = 1; /* Cranke yeself! */
3230 strscpy(pkt_dev->result, "Error starting");
3234 t->control &= ~(T_STOP);
3243 list_for_each_entry(t, &pn->pktgen_threads, th_list)
3244 t->control |= (flags);
3261 list_for_each_entry_rcu(pkt_dev, &t->if_list, list)
3262 if (pkt_dev->running) {
3301 list_for_each_entry(t, &pn->pktgen_threads, th_list) {
3308 list_for_each_entry(t, &pn->pktgen_threads, th_list)
3309 t->control |= (T_STOP);
3322 /* Propagate thread->control */
3334 /* Propagate thread->control */
3343 char *p = pkt_dev->result;
3344 ktime_t elapsed = ktime_sub(pkt_dev->stopped_at,
3345 pkt_dev->started_at);
3346 ktime_t idle = ns_to_ktime(pkt_dev->idle_acc);
3352 (unsigned long long)pkt_dev->sofar,
3353 pkt_dev->cur_pkt_size, nr_frags);
3355 pps = div64_u64(pkt_dev->sofar * NSEC_PER_SEC,
3358 if (pkt_dev->n_imix_entries > 0) {
3363 for (i = 0; i < pkt_dev->n_imix_entries; i++) {
3364 entry = &pkt_dev->imix_entries[i];
3365 bps += entry->size * entry->count_so_far;
3369 bps = pps * 8 * pkt_dev->cur_pkt_size;
3378 (unsigned long long)pkt_dev->errors);
3381 /* Set stopped-at timer, remove from running list, do counters & statistics */
3384 int nr_frags = pkt_dev->skb ? skb_shinfo(pkt_dev->skb)->nr_frags : -1;
3386 if (!pkt_dev->running) {
3388 pkt_dev->odevname);
3389 return -EINVAL;
3392 pkt_dev->running = 0;
3393 kfree_skb(pkt_dev->skb);
3394 pkt_dev->skb = NULL;
3395 pkt_dev->stopped_at = ktime_get();
3407 list_for_each_entry_rcu(pkt_dev, &t->if_list, list) {
3408 if (!pkt_dev->running)
3412 else if (ktime_compare(pkt_dev->next_tx, best->next_tx) < 0)
3428 list_for_each_entry_rcu(pkt_dev, &t->if_list, list) {
3436 * one of our devices needs to be removed - find it
3446 list_for_each_safe(q, n, &t->if_list) {
3449 if (!cur->removal_mark)
3452 kfree_skb(cur->skb);
3453 cur->skb = NULL;
3470 list_for_each_safe(q, n, &t->if_list) {
3473 kfree_skb(cur->skb);
3474 cur->skb = NULL;
3483 remove_proc_entry(t->tsk->comm, t->net->proc_dir);
3491 pkt_dev->idle_acc += ktime_to_ns(ktime_sub(ktime_get(), idle_start));
3498 while (refcount_read(&(pkt_dev->skb->users)) != 1) {
3507 pkt_dev->idle_acc += ktime_to_ns(ktime_sub(ktime_get(), idle_start));
3512 bool skb_shared = !!(READ_ONCE(pkt_dev->flags) & F_SHARED);
3513 struct net_device *odev = pkt_dev->odev;
3526 burst = READ_ONCE(pkt_dev->burst);
3527 clone_skb = READ_ONCE(pkt_dev->clone_skb);
3536 /* This is max DELAY, this has special meaning of
3539 if (unlikely(pkt_dev->delay == ULLONG_MAX)) {
3540 pkt_dev->next_tx = ktime_add_ns(ktime_get(), ULONG_MAX);
3545 if (!pkt_dev->skb || (pkt_dev->last_ok &&
3546 ++pkt_dev->clone_count >= clone_skb)) {
3548 kfree_skb(pkt_dev->skb);
3550 pkt_dev->skb = fill_packet(odev, pkt_dev);
3551 if (pkt_dev->skb == NULL) {
3554 pkt_dev->clone_count--; /* back out increment, OOM */
3557 pkt_dev->last_pkt_size = pkt_dev->skb->len;
3558 pkt_dev->clone_count = 0; /* reset counter */
3561 if (pkt_dev->delay && pkt_dev->last_ok)
3562 spin(pkt_dev, pkt_dev->next_tx);
3564 if (pkt_dev->xmit_mode == M_NETIF_RECEIVE) {
3565 skb = pkt_dev->skb;
3566 skb->protocol = eth_type_trans(skb, skb->dev);
3568 refcount_add(burst, &skb->users);
3573 pkt_dev->errors++;
3574 pkt_dev->sofar++;
3575 pkt_dev->seq_num++;
3577 pkt_dev->skb = NULL;
3580 if (refcount_read(&skb->users) != burst) {
3584 WARN_ON(refcount_sub_and_test(burst - 1, &skb->users));
3594 } while (--burst > 0);
3596 } else if (pkt_dev->xmit_mode == M_QUEUE_XMIT) {
3599 refcount_inc(&pkt_dev->skb->users);
3601 ret = dev_queue_xmit(pkt_dev->skb);
3604 pkt_dev->skb = NULL;
3608 pkt_dev->sofar++;
3609 pkt_dev->seq_num++;
3610 pkt_dev->tx_bytes += pkt_dev->last_pkt_size;
3625 pkt_dev->errors++;
3627 pkt_dev->odevname, ret);
3633 txq = skb_get_tx_queue(odev, pkt_dev->skb);
3640 pkt_dev->last_ok = 0;
3644 refcount_add(burst, &pkt_dev->skb->users);
3647 ret = netdev_start_xmit(pkt_dev->skb, odev, txq, --burst > 0);
3650 pkt_dev->skb = NULL;
3654 pkt_dev->last_ok = 1;
3655 pkt_dev->sofar++;
3656 pkt_dev->seq_num++;
3657 pkt_dev->tx_bytes += pkt_dev->last_pkt_size;
3664 pkt_dev->errors++;
3668 pkt_dev->odevname, ret);
3669 pkt_dev->errors++;
3674 refcount_dec(&pkt_dev->skb->users);
3675 pkt_dev->last_ok = 0;
3678 WARN_ON(refcount_sub_and_test(burst, &pkt_dev->skb->users));
3685 /* If pkt_dev->count is zero, then run forever */
3686 if ((pkt_dev->count != 0) && (pkt_dev->sofar >= pkt_dev->count)) {
3687 if (pkt_dev->skb)
3703 int cpu = t->cpu;
3707 init_waitqueue_head(&t->queue);
3708 complete(&t->start_done);
3717 if (unlikely(!pkt_dev && t->control == 0)) {
3718 if (t->net->pktgen_exiting)
3720 wait_event_freezable_timeout(t->queue,
3721 t->control != 0, HZ / 10);
3734 if (t->control & T_STOP) {
3736 t->control &= ~(T_STOP);
3739 if (t->control & T_RUN) {
3741 t->control &= ~(T_RUN);
3744 if (t->control & T_REMDEVALL) {
3746 t->control &= ~(T_REMDEVALL);
3749 if (t->control & T_REMDEV) {
3751 t->control &= ~(T_REMDEV);
3757 pr_debug("%s stopping all device\n", t->tsk->comm);
3760 pr_debug("%s removing all device\n", t->tsk->comm);
3763 pr_debug("%s removing thread\n", t->tsk->comm);
3773 size_t len = strlen(ifname);
3776 list_for_each_entry_rcu(p, &t->if_list, list)
3777 if (strncmp(p->odevname, ifname, len) == 0) {
3778 if (p->odevname[len]) {
3779 if (exact || p->odevname[len] != '@')
3809 if (pkt_dev->pg_thread) {
3811 rv = -EBUSY;
3815 pkt_dev->running = 0;
3816 pkt_dev->pg_thread = t;
3817 list_add_rcu(&pkt_dev->list, &t->if_list);
3830 int node = cpu_to_node(t->cpu);
3834 pkt_dev = __pktgen_NN_threads(t->net, ifname, FIND);
3837 return -EBUSY;
3842 return -ENOMEM;
3844 strscpy(pkt_dev->odevname, ifname);
3845 pkt_dev->flows = vzalloc_node(array_size(MAX_CFLOWS,
3848 if (pkt_dev->flows == NULL) {
3850 return -ENOMEM;
3853 pkt_dev->removal_mark = 0;
3854 pkt_dev->nfrags = 0;
3855 pkt_dev->delay = pg_delay_d;
3856 pkt_dev->count = pg_count_d;
3857 pkt_dev->sofar = 0;
3858 pkt_dev->udp_src_min = 9; /* sink port */
3859 pkt_dev->udp_src_max = 9;
3860 pkt_dev->udp_dst_min = 9;
3861 pkt_dev->udp_dst_max = 9;
3862 pkt_dev->vlan_p = 0;
3863 pkt_dev->vlan_cfi = 0;
3864 pkt_dev->vlan_id = 0xffff;
3865 pkt_dev->svlan_p = 0;
3866 pkt_dev->svlan_cfi = 0;
3867 pkt_dev->svlan_id = 0xffff;
3868 pkt_dev->burst = 1;
3869 pkt_dev->node = NUMA_NO_NODE;
3870 pkt_dev->flags = F_SHARED; /* SKB shared by default */
3872 err = pktgen_setup_dev(t->net, pkt_dev, ifname);
3875 if (pkt_dev->odev->priv_flags & IFF_TX_SKB_SHARING)
3876 pkt_dev->clone_skb = pg_clone_skb_d;
3878 pkt_dev->entry = proc_create_data(ifname, 0600, t->net->proc_dir,
3880 if (!pkt_dev->entry) {
3883 err = -EINVAL;
3887 pkt_dev->ipsmode = XFRM_MODE_TRANSPORT;
3888 pkt_dev->ipsproto = IPPROTO_ESP;
3895 pkt_dev->dstops.family = AF_INET;
3896 pkt_dev->xdst.u.dst.dev = pkt_dev->odev;
3897 dst_init_metrics(&pkt_dev->xdst.u.dst, pktgen_dst_metrics, false);
3898 pkt_dev->xdst.child = &pkt_dev->xdst.u.dst;
3899 pkt_dev->xdst.u.dst.ops = &pkt_dev->dstops;
3904 netdev_put(pkt_dev->odev, &pkt_dev->dev_tracker);
3909 vfree(pkt_dev->flows);
3924 return -ENOMEM;
3927 mutex_init(&t->if_lock);
3928 t->cpu = cpu;
3930 INIT_LIST_HEAD(&t->if_list);
3932 list_add_tail(&t->th_list, &pn->pktgen_threads);
3933 init_completion(&t->start_done);
3937 pr_err("kthread_create_on_node() failed for cpu %d\n", t->cpu);
3938 list_del(&t->th_list);
3943 t->tsk = p;
3945 pe = proc_create_data(t->tsk->comm, 0600, pn->proc_dir,
3949 PG_PROC_DIR, t->tsk->comm);
3951 list_del(&t->th_list);
3953 return -EINVAL;
3956 t->net = pn;
3959 wait_for_completion(&t->start_done);
3974 list_for_each_safe(q, n, &t->if_list) {
3977 list_del_rcu(&p->list);
3987 if (pkt_dev->running) {
3992 /* Dis-associate from the interface */
3994 if (pkt_dev->odev) {
3995 netdev_put(pkt_dev->odev, &pkt_dev->dev_tracker);
3996 pkt_dev->odev = NULL;
4003 proc_remove(pkt_dev->entry);
4011 vfree(pkt_dev->flows);
4012 if (pkt_dev->page)
4013 put_page(pkt_dev->page);
4024 pn->net = net;
4025 INIT_LIST_HEAD(&pn->pktgen_threads);
4026 pn->pktgen_exiting = false;
4027 pn->proc_dir = proc_mkdir(PG_PROC_DIR, pn->net->proc_net);
4028 if (!pn->proc_dir) {
4030 return -ENODEV;
4032 pe = proc_create(PGCTRL, 0600, pn->proc_dir, &pktgen_proc_ops);
4035 ret = -EINVAL;
4050 if (list_empty(&pn->pktgen_threads)) {
4052 ret = -ENODEV;
4059 remove_proc_entry(PGCTRL, pn->proc_dir);
4061 remove_proc_entry(PG_PROC_DIR, pn->net->proc_net);
4073 pn->pktgen_exiting = true;
4076 list_splice_init(&pn->pktgen_threads, &list);
4081 list_del(&t->th_list);
4082 kthread_stop_put(t->tsk);
4086 remove_proc_entry(PGCTRL, pn->proc_dir);
4087 remove_proc_entry(PG_PROC_DIR, pn->net->proc_net);