Added macros for ISER and SRP
[~tnikolova/compat/.git] / config / rdma.m4
1 dnl Checks for the in-box ib_core
2 AC_DEFUN([RDMA_CONFIG_COMPAT],
3 [
4         AC_MSG_CHECKING([if ib_verbs has ib_dma_map_single])
5         LB_LINUX_TRY_COMPILE([
6                 #include <linux/version.h>
7                 #include <linux/pci.h>
8                 #include <linux/gfp.h>
9                 #include <rdma/ib_verbs.h>
10         ],[
11                 ib_dma_map_single(NULL, NULL, 0, 0);
12                 return 0;
13         ],[
14                 AC_MSG_RESULT(yes)
15                 AC_DEFINE(HAVE_INBOX_IB_DMA_MAP, 1,
16                           [ib_dma_map_single defined])
17         ],[
18                 AC_MSG_RESULT(no)
19         ])
20
21         AC_MSG_CHECKING([if ib_create_cq wants comp_vector])
22         LB_LINUX_TRY_COMPILE([
23                 #include <linux/version.h>
24                 #include <linux/pci.h>
25                 #include <linux/gfp.h>
26                 #include <rdma/ib_verbs.h>
27         ],[
28                 ib_create_cq(NULL, NULL, NULL, NULL, 0, 0);
29                 return 0;
30         ],[
31                 AC_MSG_RESULT(yes)
32                 AC_DEFINE(HAVE_INBOX_IB_COMP_VECTOR, 1,
33                           [has completion vector])
34         ],[
35                 AC_MSG_RESULT(no)
36         ])
37
38         AC_MSG_CHECKING([if rdma_cm has RDMA_CM_EVENT_ADDR_CHANGE])
39         LB_LINUX_TRY_COMPILE([
40                 #include <linux/version.h>
41                 #include <linux/pci.h>
42                 #include <linux/gfp.h>
43                 #include <rdma/rdma_cm.h>
44         ],[
45                 return (RDMA_CM_EVENT_ADDR_CHANGE == 0);
46         ],[
47                 AC_MSG_RESULT(yes)
48                 AC_DEFINE(HAVE_INBOX_RDMA_CMEV_ADDRCHANGE, 1,
49                           [has completion vector])
50         ],[
51                 AC_MSG_RESULT(no)
52         ])
53
54         AC_MSG_CHECKING([if rdma_cm has RDMA_CM_EVENT_TIMEWAIT_EXIT])
55         LB_LINUX_TRY_COMPILE([
56                 #include <linux/version.h>
57                 #include <linux/pci.h>
58                 #include <linux/gfp.h>
59                 #include <rdma/rdma_cm.h>
60         ],[
61                 return (RDMA_CM_EVENT_TIMEWAIT_EXIT == 0);
62         ],[
63                 AC_MSG_RESULT(yes)
64                 AC_DEFINE(HAVE_INBOX_RDMA_CMEV_TIMEWAIT_EXIT, 1,
65                           [has completion vector])
66         ],[
67                 AC_MSG_RESULT(no)
68         ])
69
70         AC_MSG_CHECKING([if rdma_cm has rdma_set_reuseaddr])
71         LB_LINUX_TRY_COMPILE([
72                 #include <linux/version.h>
73                 #include <linux/pci.h>
74                 #include <linux/gfp.h>
75                 #include <rdma/rdma_cm.h>
76         ],[
77                 rdma_set_reuseaddr(NULL, 1);
78                 return 0;
79         ],[
80                 AC_MSG_RESULT(yes)
81                 AC_DEFINE(HAVE_INBOX_RDMA_SET_REUSEADDR, 1,
82                           [rdma_set_reuse defined])
83         ],[
84                 AC_MSG_RESULT(no)
85         ])
86
87         AC_MSG_CHECKING([if struct ib_wc has member named ts])
88         LB_LINUX_TRY_COMPILE([
89                 #include <linux/version.h>
90                 #include <rdma/ib_verbs.h>
91         ],[
92         struct ib_wc wc;
93         wc->ts.timestamp = 0;
94
95                 return 0;
96         ],[
97                 AC_MSG_RESULT(yes)
98                 AC_DEFINE(HAVE_INBOX_IB_WC_TS, 1,
99                           [ib_wc has member named ts])
100         ],[
101                 AC_MSG_RESULT(no)
102         ])
103
104         AC_MSG_CHECKING([if struct ib_ah_attr has member named dmac])
105         LB_LINUX_TRY_COMPILE([
106                 #include <linux/version.h>
107                 #include <rdma/ib_verbs.h>
108         ],[
109         struct ib_ah_attr *ah_attr;
110         memset(ah_attr->dmac, 0, 6);
111
112                 return 0;
113         ],[
114                 AC_MSG_RESULT(yes)
115                 AC_DEFINE(HAVE_INBOX_IB_AH_ATTR_DMAC, 1,
116                           [ah_attr has member named dmac])
117         ],[
118                 AC_MSG_RESULT(no)
119         ])
120
121         AC_MSG_CHECKING([if struct ib_ah_attr has member named vlan_id])
122         LB_LINUX_TRY_COMPILE([
123                 #include <linux/version.h>
124                 #include <rdma/ib_verbs.h>
125         ],[
126         struct ib_ah_attr *ah_attr;
127         ah_attr->vlan_id = 0;
128
129                 return 0;
130         ],[
131                 AC_MSG_RESULT(yes)
132                 AC_DEFINE(HAVE_INBOX_IB_AH_ATTR_VLAN_ID, 1,
133                           [ah_attr has member named vlan_id])
134         ],[
135                 AC_MSG_RESULT(no)
136         ])
137 ])
138
139 dnl Examine kernel functionality
140 AC_DEFUN([LINUX_CONFIG_COMPAT],
141 [
142         AC_MSG_CHECKING([if file_system_type has mount method])
143         LB_LINUX_TRY_COMPILE([
144                 #include <linux/fs.h>
145         ],[
146                 struct file_system_type fst;
147
148                 fst.mount = NULL;
149                 return 0;
150         ],[
151                 AC_MSG_RESULT(yes)
152                 AC_DEFINE(HAVE_MOUNT_METHOD, 1,
153                           [mount method defined])
154         ],[
155                 AC_MSG_RESULT(no)
156         ])
157
158         AC_MSG_CHECKING([if kernel has get_next_ino])
159         LB_LINUX_TRY_COMPILE([
160                 #include <linux/fs.h>
161         ],[
162                 unsigned int ino;
163
164                 ino = get_next_ino();
165                 return 0;
166         ],[
167                 AC_MSG_RESULT(yes)
168                 AC_DEFINE(HAVE_GET_NEXT_INO, 1,
169                           [get_next_ino defined])
170         ],[
171                 AC_MSG_RESULT(no)
172         ])
173
174         AC_MSG_CHECKING([if kernel has ktime_get_ns])
175         LB_LINUX_TRY_COMPILE([
176                 #include <linux/ktime.h>
177         ],[
178                 unsigned long long ns;
179
180                 ns = ktime_get_ns();
181                 return 0;
182         ],[
183                 AC_MSG_RESULT(yes)
184                 AC_DEFINE(HAVE_KTIME_GET_NS, 1,
185                           [ktime_get_ns defined])
186         ],[
187                 AC_MSG_RESULT(no)
188         ])
189
190         AC_MSG_CHECKING([if kernel has ktime_get_boot_ns])
191         LB_LINUX_TRY_COMPILE([
192                 #include <linux/ktime.h>
193         ],[
194                 unsigned long long ns;
195
196                 ns = ktime_get_boot_ns();
197                 return 0;
198         ],[
199                 AC_MSG_RESULT(yes)
200                 AC_DEFINE(HAVE_KTIME_GET_BOOT_NS, 1,
201                           [ktime_get_boot_ns defined])
202         ],[
203                 AC_MSG_RESULT(no)
204         ])
205
206         AC_MSG_CHECKING([if timekeeping.h has ktime_get_real_ns])
207         LB_LINUX_TRY_COMPILE([
208                 #include <linux/ktime.h>
209                 #include <linux/timekeeping.h>
210         ],[
211                 ktime_get_real_ns();
212
213                 return 0;
214         ],[
215                 AC_MSG_RESULT(yes)
216                 AC_DEFINE(HAVE_KTIME_GET_REAL_NS, 1,
217                           [ktime_get_real_ns is defined])
218         ],[
219                 AC_MSG_RESULT(no)
220         ])
221
222         AC_MSG_CHECKING([if svc_xprt_class has xcl_ident])
223         LB_LINUX_TRY_COMPILE([
224                 #include <linux/sunrpc/xprt.h>
225                 #include <linux/sunrpc/svc_xprt.h>
226         ],[
227                 struct svc_xprt_class svc_rdma_class = {
228                         .xcl_ident = XPRT_TRANSPORT_RDMA,
229                 };
230                 return 0;
231         ],[
232                 AC_MSG_RESULT(yes)
233                 AC_DEFINE(HAVE_XCL_IDENT, 1,
234                           [xcl_ident defined])
235         ],[
236                 AC_MSG_RESULT(no)
237         ])
238
239         AC_MSG_CHECKING([if struct ifla_vf_info has max_tx_rate])
240         LB_LINUX_TRY_COMPILE([
241                 #include <linux/if_link.h>
242         ],[
243                 struct ifla_vf_info *ivf;
244
245                 ivf->max_tx_rate = 0;
246                 ivf->min_tx_rate = 0;
247
248                 return 0;
249         ],[
250                 AC_MSG_RESULT(yes)
251                 AC_DEFINE(HAVE_TX_RATE_LIMIT, 1,
252                           [max_tx_rate is defined])
253         ],[
254                 AC_MSG_RESULT(no)
255         ])
256
257         AC_MSG_CHECKING([if struct ethtool_ops has get/set_rxfh])
258         LB_LINUX_TRY_COMPILE([
259                 #include <linux/ethtool.h>
260         ],[
261                 const struct ethtool_ops en_ethtool_ops = {
262                         .get_rxfh_key_size = NULL,
263                         .get_rxfh = NULL,
264                         .set_rxfh = NULL,
265                 };
266
267                 return 0;
268         ],[
269                 AC_MSG_RESULT(yes)
270                 AC_DEFINE(HAVE_GET_SET_RXFH, 1,
271                           [get/set_rxfh is defined])
272         ],[
273                 AC_MSG_RESULT(no)
274         ])
275
276         AC_MSG_CHECKING([if struct ethtool_ops has get_rxfh_indir_size])
277         LB_LINUX_TRY_COMPILE([
278                 #include <linux/ethtool.h>
279         ],[
280                 const struct ethtool_ops en_ethtool_ops = {
281                         .get_rxfh_indir_size = NULL,
282                 };
283
284                 return 0;
285         ],[
286                 AC_MSG_RESULT(yes)
287                 AC_DEFINE(HAVE_RXFH_INDIR_SIZE, 1,
288                         [get_rxfh_indir_size is defined])
289         ],[
290                 AC_MSG_RESULT(no)
291         ])
292
293         AC_MSG_CHECKING([if struct ethtool_ops_ext has get_rxfh_indir_size])
294         LB_LINUX_TRY_COMPILE([
295                 #include <linux/ethtool.h>
296         ],[
297                 const struct ethtool_ops_ext en_ethtool_ops_ext = {
298                         .get_rxfh_indir_size = NULL,
299                 };
300
301                 return 0;
302         ],[
303                 AC_MSG_RESULT(yes)
304                 AC_DEFINE(HAVE_RXFH_INDIR_SIZE_EXT, 1,
305                         [get_rxfh_indir_size is defined in ethtool_ops_ext])
306         ],[
307                 AC_MSG_RESULT(no)
308         ])
309
310         AC_MSG_CHECKING([if struct ethtool_ops has get/set_rxfh_indir])
311         LB_LINUX_TRY_COMPILE([
312                 #include <linux/ethtool.h>
313
314                 int mlx4_en_get_rxfh_indir(struct net_device *d, u32 *r)
315                 {
316                         return 0;
317                 }
318         ],[
319                 struct ethtool_ops en_ethtool_ops;
320                 en_ethtool_ops.get_rxfh_indir = mlx4_en_get_rxfh_indir;
321
322                 return 0;
323         ],[
324                 AC_MSG_RESULT(yes)
325                 AC_DEFINE(HAVE_GET_SET_RXFH_INDIR, 1,
326                         [get/set_rxfh_indir is defined])
327         ],[
328                 AC_MSG_RESULT(no)
329         ])
330
331         AC_MSG_CHECKING([if struct ethtool_ops has get/set_tunable])
332         LB_LINUX_TRY_COMPILE([
333                 #include <linux/ethtool.h>
334         ],[
335                 const struct ethtool_ops en_ethtool_ops = {
336                         .get_tunable = NULL,
337                         .set_tunable = NULL,
338                 };
339
340                 return 0;
341         ],[
342                 AC_MSG_RESULT(yes)
343                 AC_DEFINE(HAVE_GET_SET_TUNABLE, 1,
344                           [get/set_tunable is defined])
345         ],[
346                 AC_MSG_RESULT(no)
347         ])
348
349         AC_MSG_CHECKING([if exist struct ethtool_ops_ext])
350         LB_LINUX_TRY_COMPILE([
351                 #include <linux/ethtool.h>
352         ],[
353                 const struct ethtool_ops_ext en_ethtool_ops_ext = {
354                         .size = sizeof(struct ethtool_ops_ext),
355                 };
356
357                 return 0;
358         ],[
359                 AC_MSG_RESULT(yes)
360                 AC_DEFINE(HAVE_ETHTOOL_OPS_EXT, 1,
361                           [struct ethtool_ops_ext is defined])
362         ],[
363                 AC_MSG_RESULT(no)
364         ])
365
366         AC_MSG_CHECKING([if struct ethtool_ops_ext has get/set_rxfh_indir])
367         LB_LINUX_TRY_COMPILE([
368                 #include <linux/ethtool.h>
369         ],[
370                 const struct ethtool_ops_ext en_ethtool_ops_ext = {
371                         .get_rxfh_indir = NULL,
372                         .set_rxfh_indir = NULL,
373                 };
374
375                 return 0;
376         ],[
377                 AC_MSG_RESULT(yes)
378                 AC_DEFINE(HAVE_GET_SET_RXFH_INDIR_EXT, 1,
379                           [get/set_rxfh_indir is defined])
380         ],[
381                 AC_MSG_RESULT(no)
382         ])
383
384         AC_MSG_CHECKING([if struct net_device has dev_port])
385         LB_LINUX_TRY_COMPILE([
386                 #include <linux/netdevice.h>
387         ],[
388                 struct net_device *dev = NULL;
389
390                 dev->dev_port = 0;
391
392                 return 0;
393         ],[
394                 AC_MSG_RESULT(yes)
395                 AC_DEFINE(HAVE_NET_DEVICE_DEV_PORT, 1,
396                           [dev_port is defined])
397         ],[
398                 AC_MSG_RESULT(no)
399         ])
400
401         AC_MSG_CHECKING([if netdev_extended has dev_port])
402         LB_LINUX_TRY_COMPILE([
403                 #include <linux/netdevice.h>
404         ],[
405                 struct net_device *dev = NULL;
406
407                 netdev_extended(dev)->dev_port = 0;
408
409                 return 0;
410         ],[
411                 AC_MSG_RESULT(yes)
412                 AC_DEFINE(HAVE_NETDEV_EXTENDED_DEV_PORT, 1,
413                           [ is defined])
414         ],[
415                 AC_MSG_RESULT(no)
416         ])
417
418         AC_MSG_CHECKING([if struct ptp_clock_info has n_pins])
419         LB_LINUX_TRY_COMPILE([
420                 #include <linux/ptp_clock_kernel.h>
421         ],[
422                 struct ptp_clock_info *info;
423                 info->n_pins = 0;
424
425                 return 0;
426         ],[
427                 AC_MSG_RESULT(yes)
428                 AC_DEFINE(HAVE_PTP_CLOCK_INFO_N_PINS, 1,
429                           [n_pins is defined])
430         ],[
431                 AC_MSG_RESULT(no)
432         ])
433
434         AC_MSG_CHECKING([if pci.h pci_enable_msi_exact])
435         LB_LINUX_TRY_COMPILE([
436                 #include <linux/pci.h>
437         ],[
438                 int x = pci_enable_msi_exact(NULL, 0);
439
440                 return 0;
441         ],[
442                 AC_MSG_RESULT(yes)
443                 AC_DEFINE(HAVE_PCI_ENABLE_MSI_EXACT, 1,
444                           [pci_enable_msi_exact is defined])
445         ],[
446                 AC_MSG_RESULT(no)
447         ])
448
449         AC_MSG_CHECKING([if pci.h pci_enable_msix_range])
450         LB_LINUX_TRY_COMPILE([
451                 #include <linux/pci.h>
452         ],[
453                 int x = pci_enable_msix_range(NULL, 0, 0, 0);
454
455                 return 0;
456         ],[
457                 AC_MSG_RESULT(yes)
458                 AC_DEFINE(HAVE_PCI_ENABLE_MSIX_RANGE, 1,
459                           [pci_enable_msix_range is defined])
460         ],[
461                 AC_MSG_RESULT(no)
462         ])
463
464         AC_MSG_CHECKING([if pci.h pci_msix_vec_count])
465         LB_LINUX_TRY_COMPILE([
466                 #include <linux/pci.h>
467         ],[
468                 int x = pci_msix_vec_count(NULL);
469
470                 return 0;
471         ],[
472                 AC_MSG_RESULT(yes)
473                 AC_DEFINE(HAVE_PCI_MSIX_VEC_COUNT, 1,
474                           [pci_msix_vec_count is defined])
475         ],[
476                 AC_MSG_RESULT(no)
477         ])
478
479         AC_MSG_CHECKING([if pci_dev has msix_cap])
480         LB_LINUX_TRY_COMPILE([
481                 #include <linux/pci.h>
482         ],[
483                 struct pci_dev pdev;
484                 pdev.msix_cap = 0;
485
486                 return 0;
487         ],[
488                 AC_MSG_RESULT(yes)
489                 AC_DEFINE(HAVE_PCI_MSIX_CAP, 1,
490                           [msix_cap is defined])
491         ],[
492                 AC_MSG_RESULT(no)
493         ])
494
495         AC_MSG_CHECKING([if mm_struct has pinned_vm])
496         LB_LINUX_TRY_COMPILE([
497                 #include <linux/mm_types.h>
498         ],[
499                 struct mm_types mmt;
500                 mmt.pinned_vm = 0;
501
502                 return 0;
503         ],[
504                 AC_MSG_RESULT(yes)
505                 AC_DEFINE(HAVE_PINNED_VM, 1,
506                           [pinned_vm is defined])
507         ],[
508                 AC_MSG_RESULT(no)
509         ])
510
511         AC_MSG_CHECKING([if kernel has idr_alloc])
512         LB_LINUX_TRY_COMPILE([
513                 #include <linux/idr.h>
514         ],[
515                 int x;
516                 x =  idr_alloc(NULL, NULL, 0, 0, 0);
517
518                 return 0;
519         ],[
520                 AC_MSG_RESULT(yes)
521                 AC_DEFINE(HAVE_IDR_ALLOC, 1,
522                           [idr_alloc is defined])
523         ],[
524                 AC_MSG_RESULT(no)
525         ])
526
527         AC_MSG_CHECKING([if kernel has percpu variables])
528         LB_LINUX_TRY_COMPILE([
529                 #include <linux/percpu.h>
530         ],[
531                 static DEFINE_PER_CPU(unsigned int, x);
532                 this_cpu_inc(x);
533
534                 return 0;
535         ],[
536                 AC_MSG_RESULT(yes)
537                 AC_DEFINE(HAVE_PERCPU_VARS, 1,
538                           [percpu variables are defined])
539         ],[
540                 AC_MSG_RESULT(no)
541         ])
542
543         AC_MSG_CHECKING([if struct iscsi_transport has attr_is_visible])
544         LB_LINUX_TRY_COMPILE([
545                 #include <scsi/scsi_transport_iscsi.h>
546         ],[
547                 static struct iscsi_transport iscsi_iser_transport = {
548                         .attr_is_visible = NULL,
549                 };
550
551                 return 0;
552         ],[
553                 AC_MSG_RESULT(yes)
554                 AC_DEFINE(HAVE_ISCSI_ATTR_IS_VISIBLE, 1,
555                           [attr_is_visible is defined])
556         ],[
557                 AC_MSG_RESULT(no)
558         ])
559
560         AC_MSG_CHECKING([if struct iscsi_transport has get_ep_param])
561         LB_LINUX_TRY_COMPILE([
562                 #include <scsi/scsi_transport_iscsi.h>
563         ],[
564                 static struct iscsi_transport iscsi_iser_transport = {
565                         .get_ep_param = NULL,
566                 };
567
568                 return 0;
569         ],[
570                 AC_MSG_RESULT(yes)
571                 AC_DEFINE(HAVE_ISCSI_GET_EP_PARAM, 1,
572                           [get_ep_param is defined])
573         ],[
574                 AC_MSG_RESULT(no)
575         ])
576
577         AC_MSG_CHECKING([if struct iscsi_transport has check_protection])
578         LB_LINUX_TRY_COMPILE([
579                 #include <scsi/scsi_transport_iscsi.h>
580         ],[
581                 static struct iscsi_transport iscsi_iser_transport = {
582                         .check_protection = NULL,
583                 };
584
585                 return 0;
586         ],[
587                 AC_MSG_RESULT(yes)
588                 AC_DEFINE(HAVE_ISCSI_CHECK_PROTECTION, 1,
589                           [check_protection is defined])
590         ],[
591                 AC_MSG_RESULT(no)
592         ])
593
594         AC_MSG_CHECKING([if iscsi_proto.h has struct iscsi_scsi_req])
595         LB_LINUX_TRY_COMPILE([
596                 #include <scsi/iscsi_proto.h>
597         ],[
598                 struct iscsi_scsi_req req = {
599                         .opcode = 0,
600                 };
601
602                 return 0;
603         ],[
604                 AC_MSG_RESULT(yes)
605                 AC_DEFINE(HAVE_ISCSI_SCSI_REQ, 1,
606                           [struct iscsi_scsi_req is defined])
607         ],[
608                 AC_MSG_RESULT(no)
609         ])
610
611         AC_MSG_CHECKING([if struct request_queue has request_fn_active])
612         LB_LINUX_TRY_COMPILE([
613                 #include <linux/blkdev.h>
614         ],[
615                 struct request_queue rq = {
616                         .request_fn_active = 0,
617                 };
618
619                 return 0;
620         ],[
621                 AC_MSG_RESULT(yes)
622                 AC_DEFINE(HAVE_REQUEST_QUEUE_REQUEST_FN_ACTIVE, 1,
623                           [struct request_queue has request_fn_active])
624         ],[
625                 AC_MSG_RESULT(no)
626         ])
627
628         AC_MSG_CHECKING([if netdevice.h has select_queue_fallback_t])
629         LB_LINUX_TRY_COMPILE([
630                 #include <linux/netdevice.h>
631         ],[
632                 select_queue_fallback_t fallback;
633
634                 fallback = NULL;
635
636                 return 0;
637         ],[
638                 AC_MSG_RESULT(yes)
639                 AC_DEFINE(HAVE_SELECT_QUEUE_FALLBACK_T, 1,
640                           [select_queue_fallback_t is defined])
641         ],[
642                 AC_MSG_RESULT(no)
643         ])
644
645         AC_MSG_CHECKING([if netdevice.h has skb_set_hash])
646         LB_LINUX_TRY_COMPILE([
647                 #include <linux/netdevice.h>
648         ],[
649                 skb_set_hash(NULL, 0, PKT_HASH_TYPE_L3);
650
651                 return 0;
652         ],[
653                 AC_MSG_RESULT(yes)
654                 AC_DEFINE(HAVE_SKB_SET_HASH, 1,
655                           [skb_set_hash is defined])
656         ],[
657                 AC_MSG_RESULT(no)
658         ])
659
660         AC_MSG_CHECKING([if netdevice.h has alloc_netdev with 4 params])
661         LB_LINUX_TRY_COMPILE([
662                 #include <linux/netdevice.h>
663         ],[
664                 struct net_device *dev;
665
666                 dev = alloc_netdev(0, NULL, 0, NULL);
667
668                 return 0;
669         ],[
670                 AC_MSG_RESULT(yes)
671                 AC_DEFINE(HAVE_ALLOC_NETDEV_4P, 1,
672                           [alloc_netdev has 4 parameters])
673         ],[
674                 AC_MSG_RESULT(no)
675         ])
676
677         AC_MSG_CHECKING([if sockios.h has SIOCGHWTSTAMP])
678         LB_LINUX_TRY_COMPILE([
679                 #include <linux/sockios.h>
680         ],[
681                 int x = SIOCGHWTSTAMP;
682
683                 return 0;
684         ],[
685                 AC_MSG_RESULT(yes)
686                 AC_DEFINE(HAVE_SIOCGHWTSTAMP, 1,
687                           [SIOCGHWTSTAMP is defined])
688         ],[
689                 AC_MSG_RESULT(no)
690         ])
691
692         AC_MSG_CHECKING([if ip.h inet_get_local_port_range has 3 parameters])
693         LB_LINUX_TRY_COMPILE([
694                 #include <net/ip.h>
695         ],[
696                 inet_get_local_port_range(NULL, NULL, NULL);
697
698                 return 0;
699         ],[
700                 AC_MSG_RESULT(yes)
701                 AC_DEFINE(HAVE_INET_GET_LOCAL_PORT_RANGE_3_PARAMS, 1,
702                           [inet_get_local_port_range has 3 parameters])
703         ],[
704                 AC_MSG_RESULT(no)
705         ])
706
707         AC_MSG_CHECKING([if net.h has net_get_random_once])
708         LB_LINUX_TRY_COMPILE([
709                 #include <linux/net.h>
710         ],[
711                 net_get_random_once(NULL, 0);
712
713                 return 0;
714         ],[
715                 AC_MSG_RESULT(yes)
716                 AC_DEFINE(HAVE_NET_GET_RANDOM_ONCE, 1,
717                           [net_get_random_once is defined])
718         ],[
719                 AC_MSG_RESULT(no)
720         ])
721
722         AC_MSG_CHECKING([if inet_sock.h has __inet_ehashfn])
723         LB_LINUX_TRY_COMPILE([
724                 #include <net/inet_sock.h>
725         ],[
726                 __inet_ehashfn(0, 0, 0, 0, 0);
727
728                 return 0;
729         ],[
730                 AC_MSG_RESULT(yes)
731                 AC_DEFINE(HAVE_INET_EHASHFN, 1,
732                           [__inet_ehashfn is defined])
733         ],[
734                 AC_MSG_RESULT(no)
735         ])
736
737         AC_MSG_CHECKING([if err.h has PTR_ERR_OR_ZERO])
738         LB_LINUX_TRY_COMPILE([
739                 #include <linux/err.h>
740         ],[
741                 int x = PTR_ERR_OR_ZERO(NULL);
742
743                 return 0;
744         ],[
745                 AC_MSG_RESULT(yes)
746                 AC_DEFINE(HAVE_PTR_ERR_OR_ZERO, 1,
747                           [PTR_ERR_OR_ZERO is defined])
748         ],[
749                 AC_MSG_RESULT(no)
750         ])
751
752         AC_MSG_CHECKING([if struct iscsi_session has discovery_sess])
753         LB_LINUX_TRY_COMPILE([
754                 #include <scsi/libiscsi.h>
755         ],[
756                 struct iscsi_session session;
757                 session.discovery_sess = 0;
758
759                 return 0;
760         ],[
761                 AC_MSG_RESULT(yes)
762                 AC_DEFINE(HAVE_ISCSI_DISCOVERY_SESS, 1,
763                           [discovery_sess is defined])
764         ],[
765                 AC_MSG_RESULT(no)
766         ])
767
768         AC_MSG_CHECKING([if enum iscsi_param has ISCSI_PARAM_DISCOVERY_SESS])
769         LB_LINUX_TRY_COMPILE([
770                 #include <scsi/iscsi_if.h>
771         ],[
772                 int x = ISCSI_PARAM_DISCOVERY_SESS;
773
774                 return 0;
775         ],[
776                 AC_MSG_RESULT(yes)
777                 AC_DEFINE(HAVE_ISCSI_PARAM_DISCOVERY_SESS, 1,
778                           [ISCSI_PARAM_DISCOVERY_SESS is defined])
779         ],[
780                 AC_MSG_RESULT(no)
781         ])
782
783         AC_MSG_CHECKING([if pci.h has enum pcie_link_width])
784         LB_LINUX_TRY_COMPILE([
785                 #include <linux/pci.h>
786                 #include <linux/pci_hotplug.h>
787         ],[
788                 enum pcie_link_width width = PCIE_LNK_WIDTH_UNKNOWN;
789
790                 return 0;
791         ],[
792                 AC_MSG_RESULT(yes)
793                 AC_DEFINE(HAVE_PCIE_LINK_WIDTH, 1,
794                           [pcie_link_width is defined])
795         ],[
796                 AC_MSG_RESULT(no)
797         ])
798
799         AC_MSG_CHECKING([if pci.h has enum pci_bus_speed])
800         LB_LINUX_TRY_COMPILE([
801                 #include <linux/pci.h>
802                 #include <linux/pci_hotplug.h>
803         ],[
804                 enum pci_bus_speed speed = PCI_SPEED_UNKNOWN;
805
806                 return speed;
807         ],[
808                 AC_MSG_RESULT(yes)
809                 AC_DEFINE(HAVE_PCI_BUS_SPEED, 1,
810                           [pci_bus_speed is defined])
811         ],[
812                 AC_MSG_RESULT(no)
813         ])
814
815         AC_MSG_CHECKING([if netdevice.h has struct netdev_phys_port_id])
816         LB_LINUX_TRY_COMPILE([
817                 #include <linux/netdevice.h>
818         ],[
819                 struct netdev_phys_port_id *x = NULL;
820
821                 return 0;
822         ],[
823                 AC_MSG_RESULT(yes)
824                 AC_DEFINE(HAVE_NETDEV_PHYS_PORT_ID, 1,
825                           [netdev_phys_port_id is defined])
826         ],[
827                 AC_MSG_RESULT(no)
828         ])
829
830         AC_MSG_CHECKING([if struct ifla_vf_info has linkstate])
831         LB_LINUX_TRY_COMPILE([
832                 #include <linux/if_link.h>
833         ],[
834                 struct ifla_vf_info *x;
835                 x->linkstate = 0;
836
837                 return 0;
838         ],[
839                 AC_MSG_RESULT(yes)
840                 AC_DEFINE(HAVE_LINKSTATE, 1,
841                           [linkstate is defined])
842         ],[
843                 AC_MSG_RESULT(no)
844         ])
845
846         AC_MSG_CHECKING([if busy_poll.h has skb_mark_napi_id])
847         LB_LINUX_TRY_COMPILE([
848                 #include <net/busy_poll.h>
849         ],[
850                 skb_mark_napi_id(NULL, NULL);
851
852                 return 0;
853         ],[
854                 AC_MSG_RESULT(yes)
855                 AC_DEFINE(HAVE_SKB_MARK_NAPI_ID, 1,
856                           [skb_mark_napi_id is defined])
857         ],[
858                 AC_MSG_RESULT(no)
859         ])
860
861         AC_MSG_CHECKING([if netdevice.h has napi_hash_add])
862         LB_LINUX_TRY_COMPILE([
863                 #include <linux/netdevice.h>
864         ],[
865                 napi_hash_add(NULL);
866
867                 return 0;
868         ],[
869                 AC_MSG_RESULT(yes)
870                 AC_DEFINE(HAVE_NAPI_HASH_ADD, 1,
871                           [napi_hash_add is defined])
872         ],[
873                 AC_MSG_RESULT(no)
874         ])
875
876         AC_MSG_CHECKING([if netdevice.h has netif_keep_dst])
877         LB_LINUX_TRY_COMPILE([
878                 #include <linux/netdevice.h>
879         ],[
880                 netif_keep_dst(NULL);
881
882                 return 0;
883         ],[
884                 AC_MSG_RESULT(yes)
885                 AC_DEFINE(HAVE_NETIF_KEEP_DST, 1,
886                           [netif_keep_dst is defined])
887         ],[
888                 AC_MSG_RESULT(no)
889         ])
890
891         AC_MSG_CHECKING([if netdevice.h has dev_consume_skb_any])
892         LB_LINUX_TRY_COMPILE([
893                 #include <linux/netdevice.h>
894         ],[
895                 dev_consume_skb_any(NULL);
896
897                 return 0;
898         ],[
899                 AC_MSG_RESULT(yes)
900                 AC_DEFINE(HAVE_DEV_CONSUME_SKB_ANY, 1,
901                           [dev_consume_skb_any is defined])
902         ],[
903                 AC_MSG_RESULT(no)
904         ])
905
906         AC_MSG_CHECKING([if netdevice.h has netdev_txq_bql_complete_prefetchw])
907         LB_LINUX_TRY_COMPILE([
908                 #include <linux/netdevice.h>
909         ],[
910                 netdev_txq_bql_complete_prefetchw(NULL);
911                 netdev_txq_bql_enqueue_prefetchw(NULL);
912
913                 return 0;
914         ],[
915                 AC_MSG_RESULT(yes)
916                 AC_DEFINE(HAVE_NETDEV_TXQ_BQL_PREFETCHW, 1,
917                           [netdev_txq_bql_complete_prefetchw is defined])
918         ],[
919                 AC_MSG_RESULT(no)
920         ])
921
922         AC_MSG_CHECKING([if struct sk_buff has xmit_more])
923         LB_LINUX_TRY_COMPILE([
924                 #include <linux/skbuff.h>
925         ],[
926                 struct sk_buff *skb;
927                 skb->xmit_more = 0;
928
929                 return 0;
930         ],[
931                 AC_MSG_RESULT(yes)
932                 AC_DEFINE(HAVE_SK_BUFF_XMIT_MORE, 1,
933                           [xmit_more is defined])
934         ],[
935                 AC_MSG_RESULT(no)
936         ])
937
938         AC_MSG_CHECKING([if struct sk_buff has encapsulation])
939         LB_LINUX_TRY_COMPILE([
940                 #include <linux/skbuff.h>
941         ],[
942                 struct sk_buff *skb;
943                 skb->encapsulation = 0;
944
945                 return 0;
946         ],[
947                 AC_MSG_RESULT(yes)
948                 AC_DEFINE(HAVE_SK_BUFF_ENCAPSULATION, 1,
949                           [encapsulation is defined])
950         ],[
951                 AC_MSG_RESULT(no)
952         ])
953
954         AC_MSG_CHECKING([if etherdevice.h has eth_get_headlen])
955         LB_LINUX_TRY_COMPILE([
956                 #include <linux/etherdevice.h>
957         ],[
958                 eth_get_headlen(NULL, 0);
959
960                 return 0;
961         ],[
962                 AC_MSG_RESULT(yes)
963                 AC_DEFINE(HAVE_ETH_GET_HEADLEN, 1,
964                           [eth_get_headlen is defined])
965         ],[
966                 AC_MSG_RESULT(no)
967         ])
968
969         AC_MSG_CHECKING([if struct sk_buff has csum_level])
970         LB_LINUX_TRY_COMPILE([
971                 #include <linux/skbuff.h>
972         ],[
973                 struct sk_buff *skb;
974                 skb->csum_level = 0;
975
976                 return 0;
977         ],[
978                 AC_MSG_RESULT(yes)
979                 AC_DEFINE(HAVE_SK_BUFF_CSUM_LEVEL, 1,
980                           [csum_level is defined])
981         ],[
982                 AC_MSG_RESULT(no)
983         ])
984
985         AC_MSG_CHECKING([if struct skbuff.h has skb_inner_transport_header])
986         LB_LINUX_TRY_COMPILE([
987                 #include <linux/skbuff.h>
988         ],[
989                 skb_inner_transport_header(NULL);
990
991                 return 0;
992         ],[
993                 AC_MSG_RESULT(yes)
994                 AC_DEFINE(HAVE_SKB_INNER_TRANSPORT_HEADER, 1,
995                           [skb_inner_transport_header is defined])
996         ],[
997                 AC_MSG_RESULT(no)
998         ])
999
1000         AC_MSG_CHECKING([if struct skbuff.h has skb_inner_network_header])
1001         LB_LINUX_TRY_COMPILE([
1002                 #include <linux/skbuff.h>
1003         ],[
1004                 skb_inner_network_header(NULL);
1005
1006                 return 0;
1007         ],[
1008                 AC_MSG_RESULT(yes)
1009                 AC_DEFINE(HAVE_SKB_INNER_NETWORK_HEADER, 1,
1010                           [skb_inner_network_header is defined])
1011         ],[
1012                 AC_MSG_RESULT(no)
1013         ])
1014
1015         AC_MSG_CHECKING([if if_vlan.h has vlan_dev_get_egress_qos_mask])
1016         LB_LINUX_TRY_COMPILE([
1017                 #include <linux/if_vlan.h>
1018         ],[
1019                 vlan_dev_get_egress_qos_mask(NULL, 0);
1020
1021                 return 0;
1022         ],[
1023                 AC_MSG_RESULT(yes)
1024                 AC_DEFINE(HAVE_VLAN_DEV_GET_EGRESS_QOS_MASK, 1,
1025                           [vlan_dev_get_egress_qos_mask is defined])
1026         ],[
1027                 AC_MSG_RESULT(no)
1028         ])
1029
1030         AC_MSG_CHECKING([if netdevice.h has netdev_get_prio_tc_map])
1031         LB_LINUX_TRY_COMPILE([
1032                 #include <linux/netdevice.h>
1033         ],[
1034                 netdev_get_prio_tc_map(NULL, 0);
1035
1036                 return 0;
1037         ],[
1038                 AC_MSG_RESULT(yes)
1039                 AC_DEFINE(HAVE_NETDEV_GET_PRIO_TC_MAP, 1,
1040                           [netdev_get_prio_tc_map is defined])
1041         ],[
1042                 AC_MSG_RESULT(no)
1043         ])
1044
1045         AC_MSG_CHECKING([if if_vlan.h has __vlan_find_dev_deep_rcu])
1046         LB_LINUX_TRY_COMPILE([
1047                 #include <linux/if_vlan.h>
1048         ],[
1049                 __vlan_find_dev_deep_rcu(NULL, 0, 0);
1050
1051                 return 0;
1052         ],[
1053                 AC_MSG_RESULT(yes)
1054                 AC_DEFINE(HAVE___VLAN_FIND_DEV_DEEP_RCU, 1,
1055                           [__vlan_find_dev_deep_rcu is defined])
1056         ],[
1057                 AC_MSG_RESULT(no)
1058         ])
1059
1060         AC_MSG_CHECKING([if ndo_select_queue has accel_priv])
1061         LB_LINUX_TRY_COMPILE([
1062                 #include <linux/netdevice.h>
1063
1064                 static u16 select_queue(struct net_device *dev, struct sk_buff *skb,
1065                                         void *accel_priv)
1066                 {
1067                         return 0;
1068                 }
1069         ],[
1070                 struct net_device_opts ndops;
1071
1072                 ndops.ndo_select_queue = select_queue;
1073
1074                 return 0;
1075         ],[
1076                 AC_MSG_RESULT(yes)
1077                 AC_DEFINE(NDO_SELECT_QUEUE_HAS_ACCEL_PRIV, 1,
1078                           [ndo_select_queue has accel_priv])
1079         ],[
1080                 AC_MSG_RESULT(no)
1081         ])
1082
1083         AC_MSG_CHECKING([if include/net/bonding.h exists])
1084         LB_LINUX_TRY_COMPILE([
1085                 #include <net/bonding.h>
1086         ],[
1087                 return 0;
1088         ],[
1089                 AC_MSG_RESULT(yes)
1090                 AC_DEFINE(HAVE_BONDING_H, 1,
1091                           [include/net/bonding.h exists])
1092         ],[
1093                 AC_MSG_RESULT(no)
1094         ])
1095
1096         AC_MSG_CHECKING([if bonding.h bond_for_each_slave has 3 parameters])
1097         LB_LINUX_TRY_COMPILE([
1098                 #include <net/bonding.h>
1099         ],[
1100                 struct bonding *bond = NULL;
1101                 struct list_head *iter = NULL;
1102                 struct slave *slave = NULL;
1103
1104                 bond_for_each_slave(bond, slave, iter) ;
1105
1106                 return 0;
1107         ],[
1108                 AC_MSG_RESULT(yes)
1109                 AC_DEFINE(HAVE_BOND_FOR_EACH_SLAVE_3_PARAMS, 1,
1110                           [bond_for_each_slave has 3 parameters])
1111         ],[
1112                 AC_MSG_RESULT(no)
1113         ])
1114
1115
1116         AC_MSG_CHECKING([if u64_stats_sync.h has u64_stats_init])
1117         LB_LINUX_TRY_COMPILE([
1118                 #include <linux/u64_stats_sync.h>
1119         ],[
1120                 struct u64_stats_sync sync;
1121                 u64_stats_init(&sync);
1122
1123                 return 0;
1124         ],[
1125                 AC_MSG_RESULT(yes)
1126                 AC_DEFINE(HAVE_U64_STATS_SYNC, 1,
1127                           [u64_stats_sync is defined])
1128         ],[
1129                 AC_MSG_RESULT(no)
1130         ])
1131
1132         AC_MSG_CHECKING([if u64_stats_sync.h has u64_stats_fetch_begin_irq])
1133         LB_LINUX_TRY_COMPILE([
1134                 #include <linux/u64_stats_sync.h>
1135         ],[
1136                 struct u64_stats_sync sync;
1137                 u64_stats_fetch_begin_irq(&sync);
1138
1139                 return 0;
1140         ],[
1141                 AC_MSG_RESULT(yes)
1142                 AC_DEFINE(HAVE_U64_STATS_FETCH_BEGIN_IRQ, 1,
1143                           [u64_stats_fetch_begin_irq is defined])
1144         ],[
1145                 AC_MSG_RESULT(no)
1146         ])
1147         AC_MSG_CHECKING([if etherdevice.h has ether_addr_copy])
1148         LB_LINUX_TRY_COMPILE([
1149                 #include <linux/etherdevice.h>
1150         ],[
1151                 char dest[6], src[6];
1152                 ether_addr_copy(&dest, &src);
1153
1154                 return 0;
1155         ],[
1156                 AC_MSG_RESULT(yes)
1157                 AC_DEFINE(HAVE_ETHER_ADDR_COPY, 1,
1158                           [ether_addr_copy is defined])
1159         ],[
1160                 AC_MSG_RESULT(no)
1161         ])
1162
1163         AC_MSG_CHECKING([if struct net_device_ops has *ndo_set_vf_rate])
1164         LB_LINUX_TRY_COMPILE([
1165                 #include <linux/netdevice.h>
1166
1167                 int set_vf_rate(struct net_device *dev, int vf, int min_tx_rate,
1168                                                    int max_tx_rate)
1169                 {
1170                         return 0;
1171                 }
1172         ],[
1173                 struct net_device_ops netdev_ops;
1174
1175                 netdev_ops.ndo_set_vf_rate = set_vf_rate;
1176                 return 0;
1177         ],[
1178                 AC_MSG_RESULT(yes)
1179                 AC_DEFINE(HAVE_SET_VF_RATE, 1,
1180                           [ndo_set_vf_rate is defined])
1181         ],[
1182                 AC_MSG_RESULT(no)
1183         ])
1184
1185         AC_MSG_CHECKING([if netdev_extended has hw_features])
1186         LB_LINUX_TRY_COMPILE([
1187                 #include <linux/netdevice.h>
1188         ],[
1189                 struct net_device *dev = NULL;
1190
1191                 netdev_extended(dev)->hw_features = 0;
1192
1193                 return 0;
1194         ],[
1195                 AC_MSG_RESULT(yes)
1196                 AC_DEFINE(HAVE_NETDEV_EXTENDED_HW_FEATURES, 1,
1197                           [ is defined])
1198         ],[
1199                 AC_MSG_RESULT(no)
1200         ])
1201
1202         AC_MSG_CHECKING([if net_device_extended has _tx_ext])
1203         LB_LINUX_TRY_COMPILE([
1204                 #include <linux/netdevice.h>
1205         ],[
1206                 struct net_device *dev = NULL;
1207
1208                 netdev_extended(dev)->_tx_ext = NULL;
1209
1210                 return 0;
1211         ],[
1212                 AC_MSG_RESULT(yes)
1213                 AC_DEFINE(HAVE_NET_DEVICE_EXTENDED_TX_EXT, 1,
1214                           [ is defined])
1215         ],[
1216                 AC_MSG_RESULT(no)
1217         ])
1218
1219         AC_MSG_CHECKING([if net_device_extended has ndo_busy_poll])
1220         LB_LINUX_TRY_COMPILE([
1221                 #include <linux/netdevice.h>
1222
1223                 int busy_poll(struct napi_struct *napi)
1224                 {
1225                         return 0;
1226                 }
1227         ],[
1228                 struct net_device *dev = NULL;
1229
1230                 netdev_extended(dev)->ndo_busy_poll = busy_poll;
1231
1232                 return 0;
1233         ],[
1234                 AC_MSG_RESULT(yes)
1235                 AC_DEFINE(HAVE_NETDEV_EXTENDED_NDO_BUSY_POLL, 1,
1236                           [ is defined])
1237         ],[
1238                 AC_MSG_RESULT(no)
1239         ])
1240
1241         AC_MSG_CHECKING([if netdevice.h has set_netdev_hw_features])
1242         LB_LINUX_TRY_COMPILE([
1243                 #include <linux/netdevice.h>
1244         ],[
1245                 struct net_device *dev = NULL;
1246
1247                 set_netdev_hw_features(dev, 0);
1248
1249                 return 0;
1250         ],[
1251                 AC_MSG_RESULT(yes)
1252                 AC_DEFINE(HAVE_SET_NETDEV_HW_FEATURES, 1,
1253                           [ is defined])
1254         ],[
1255                 AC_MSG_RESULT(no)
1256         ])
1257
1258         AC_MSG_CHECKING([if netdevice.h has netif_set_xps_queue])
1259         LB_LINUX_TRY_COMPILE([
1260                 #include <linux/netdevice.h>
1261         ],[
1262                 struct net_device *dev = NULL;
1263
1264                 netif_set_xps_queue(dev, NULL, 0);
1265
1266                 return 0;
1267         ],[
1268                 AC_MSG_RESULT(yes)
1269                 AC_DEFINE(HAVE_NETIF_SET_XPS_QUEUE, 1,
1270                           [ is defined])
1271         ],[
1272                 AC_MSG_RESULT(no)
1273         ])
1274
1275
1276         AC_MSG_CHECKING([if struct net_device_ops has *ndo_set_features])
1277         LB_LINUX_TRY_COMPILE([
1278                 #include <linux/netdevice.h>
1279
1280                 int set_features(struct net_device *dev, netdev_features_t features)
1281                 {
1282                         return 0;
1283                 }
1284         ],[
1285                 struct net_device_ops netdev_ops;
1286
1287                 netdev_ops.ndo_set_features = set_features;
1288                 return 0;
1289         ],[
1290                 AC_MSG_RESULT(yes)
1291                 AC_DEFINE(HAVE_NDO_SET_FEATURES, 1,
1292                           [ndo_set_features is defined])
1293         ],[
1294                 AC_MSG_RESULT(no)
1295         ])
1296
1297         AC_MSG_CHECKING([if struct net_device_ops has *ndo_rx_flow_steer])
1298         LB_LINUX_TRY_COMPILE([
1299                 #include <linux/netdevice.h>
1300
1301                 int rx_flow_steer(struct net_device *dev,
1302                                                      const struct sk_buff *skb,
1303                                                      u16 rxq_index,
1304                                                      u32 flow_id)
1305                 {
1306                         return 0;
1307                 }
1308         ],[
1309                 struct net_device_ops netdev_ops;
1310
1311                 netdev_ops.ndo_rx_flow_steer = rx_flow_steer;
1312                 return 0;
1313         ],[
1314                 AC_MSG_RESULT(yes)
1315                 AC_DEFINE(HAVE_NDO_RX_FLOW_STEER, 1,
1316                           [ndo_rx_flow_steer is defined])
1317         ],[
1318                 AC_MSG_RESULT(no)
1319         ])
1320
1321         AC_MSG_CHECKING([if struct net_device has priv_flags])
1322         LB_LINUX_TRY_COMPILE([
1323                 #include <linux/netdevice.h>
1324         ],[
1325                 struct net_device *netdev;
1326                 netdev->priv_flags = 0;
1327
1328                 return 0;
1329         ],[
1330                 AC_MSG_RESULT(yes)
1331                 AC_DEFINE(HAVE_NET_DEVICE_PRIV_FLAGS, 1,
1332                           [priv_flags is defined])
1333         ],[
1334                 AC_MSG_RESULT(no)
1335         ])
1336
1337         AC_MSG_CHECKING([if struct net_device_ops has *ndo_get_stats64])
1338         LB_LINUX_TRY_COMPILE([
1339                 #include <linux/netdevice.h>
1340
1341                 struct rtnl_link_stats64* get_stats_64(struct net_device *dev,
1342                                                      struct rtnl_link_stats64 *storage)
1343                 {
1344                         struct rtnl_link_stats64 stats_64;
1345                         return &stats_64;
1346                 }
1347         ],[
1348                 struct net_device_ops netdev_ops;
1349
1350                 netdev_ops.ndo_get_stats64 = get_stats_64;
1351
1352                 return 0;
1353         ],[
1354                 AC_MSG_RESULT(yes)
1355                 AC_DEFINE(HAVE_NDO_GET_STATS64, 1,
1356                           [ndo_get_stats64 is defined])
1357         ],[
1358                 AC_MSG_RESULT(no)
1359         ])
1360         AC_MSG_CHECKING([if struct net_device_ops has ndo_bridge_set/getlink])
1361         LB_LINUX_TRY_COMPILE([
1362                 #include <linux/netdevice.h>
1363         ],[
1364                 struct net_device_ops netdev_ops =  {
1365                         .ndo_bridge_setlink = NULL,
1366                         .ndo_bridge_getlink = NULL,
1367                 };
1368
1369                 return 0;
1370         ],[
1371                 AC_MSG_RESULT(yes)
1372                 AC_DEFINE(HAVE_NDO_BRIDGE_SET_GET_LINK, 1,
1373                           [ndo_bridge_set/getlink is defined])
1374         ],[
1375                 AC_MSG_RESULT(no)
1376         ])
1377
1378         AC_MSG_CHECKING([if rtnetlink.h ndo_dflt_bridge_getlink has 7 params])
1379         LB_LINUX_TRY_COMPILE([
1380                 #include <linux/rtnetlink.h>
1381         ],[
1382                 ndo_dflt_bridge_getlink(NULL, 0, 0, NULL, 0, 0, 0);
1383
1384                 return 0;
1385         ],[
1386                 AC_MSG_RESULT(yes)
1387                 AC_DEFINE(HAVE_NDO_DFLT_BRIDGE_GETLINK_7_PARAMS, 1,
1388                         [ ndo_dflt_bridge_getlink with 7 params is defined])
1389         ],[
1390                 AC_MSG_RESULT(no)
1391         ])
1392
1393         AC_MSG_CHECKING([if struct net_device_ops ndo_vlan_rx_add_vid has 3 parameters ])
1394         LB_LINUX_TRY_COMPILE([
1395                 #include <linux/netdevice.h>
1396
1397         ],[
1398                 int vlan_rx_add_vid(struct net_device *dev,__be16 proto, u16 vid)
1399                 {
1400                         return 0;
1401                 }
1402                 struct net_device_ops netdev_ops;
1403
1404                 netdev_ops.ndo_vlan_rx_add_vid = vlan_rx_add_vid;
1405                 netdev_ops.ndo_vlan_rx_add_vid (NULL, 1, 1) ;
1406
1407                 return 0;
1408         ],[
1409                 AC_MSG_RESULT(yes)
1410                 AC_DEFINE(HAVE_NDO_RX_ADD_VID_HAS_3_PARAMS, 1,
1411                           [ndo_vlan_rx_add_vid has 3 parameters])
1412         ],[
1413                 AC_MSG_RESULT(no)
1414         ])
1415
1416         AC_MSG_CHECKING([if net_device_ops has ndo_get_phys_port_id])
1417         LB_LINUX_TRY_COMPILE([
1418                 #include <linux/netdevice.h>
1419
1420                 int get_phys_port_id(struct net_device *dev,
1421                                      struct netdev_phys_port_id *ppid)
1422                 {
1423                         return 0;
1424                 }
1425         ],[
1426                 struct net_device_ops netdev_ops;
1427
1428                 netdev_ops.ndo_get_phys_port_id = get_phys_port_id;
1429
1430                 return 0;
1431         ],[
1432                 AC_MSG_RESULT(yes)
1433                 AC_DEFINE(HAVE_NETDEV_NDO_GET_PHYS_PORT_ID, 1,
1434                           [ is defined])
1435         ],[
1436                 AC_MSG_RESULT(no)
1437         ])
1438
1439         AC_MSG_CHECKING([if struct net_device_ops_ext exist])
1440         LB_LINUX_TRY_COMPILE([
1441                 #include <linux/netdevice.h>
1442         ],[
1443                 struct net_device_ops_ext netdev_ops_ext = {
1444                         .size = sizeof(struct net_device_ops_ext),
1445                 };
1446
1447                 return 0;
1448         ],[
1449                 AC_MSG_RESULT(yes)
1450                 AC_DEFINE(HAVE_NET_DEVICE_OPS_EXT, 1,
1451                           [struct net_device_ops_ext is defined])
1452         ],[
1453                 AC_MSG_RESULT(no)
1454         ])
1455
1456         AC_MSG_CHECKING([if net_device_ops_ext has ndo_get_phys_port_id])
1457         LB_LINUX_TRY_COMPILE([
1458                 #include <linux/netdevice.h>
1459
1460                 int get_phys_port_id(struct net_device *dev,
1461                                      struct netdev_phys_port_id *ppid)
1462                 {
1463                         return 0;
1464                 }
1465         ],[
1466                 struct net_device_ops_ext netdev_ops_ext;
1467
1468                 netdev_ops_ext.ndo_get_phys_port_id = get_phys_port_id;
1469
1470                 return 0;
1471         ],[
1472                 AC_MSG_RESULT(yes)
1473                 AC_DEFINE(HAVE_NETDEV_EXT_NDO_GET_PHYS_PORT_ID, 1,
1474                           [ndo_get_phys_port_id is defined])
1475         ],[
1476                 AC_MSG_RESULT(no)
1477         ])
1478
1479         AC_MSG_CHECKING([if net_device_ops has ndo_set_vf_spoofchk])
1480         LB_LINUX_TRY_COMPILE([
1481                 #include <linux/netdevice.h>
1482
1483                 int set_vf_spoofchk(struct net_device *dev, int vf, bool setting)
1484                 {
1485                         return 0;
1486                 }
1487         ],[
1488                 struct net_device_ops netdev_ops;
1489
1490                 netdev_ops.ndo_set_vf_spoofchk = set_vf_spoofchk;
1491
1492                 return 0;
1493         ],[
1494                 AC_MSG_RESULT(yes)
1495                 AC_DEFINE(HAVE_NETDEV_OPS_NDO_SET_VF_SPOOFCHK, 1,
1496                           [ndo_set_vf_spoofchk is defined in net_device_ops])
1497         ],[
1498                 AC_MSG_RESULT(no)
1499         ])
1500
1501         AC_MSG_CHECKING([if net_device_ops_ext has ndo_set_vf_spoofchk])
1502         LB_LINUX_TRY_COMPILE([
1503                 #include <linux/netdevice.h>
1504
1505                 int set_vf_spoofchk(struct net_device *dev, int vf, bool setting)
1506                 {
1507                         return 0;
1508                 }
1509         ],[
1510                 struct net_device_ops_ext netdev_ops_ext;
1511
1512                 netdev_ops_ext.ndo_set_vf_spoofchk = set_vf_spoofchk;
1513
1514                 return 0;
1515         ],[
1516                 AC_MSG_RESULT(yes)
1517                 AC_DEFINE(HAVE_NETDEV_OPS_EXT_NDO_SET_VF_SPOOFCHK, 1,
1518                           [ndo_set_vf_spoofchk is defined in net_device_ops_ext])
1519         ],[
1520                 AC_MSG_RESULT(no)
1521         ])
1522
1523         AC_MSG_CHECKING([if net_device_ops has ndo_set_vf_link_state])
1524         LB_LINUX_TRY_COMPILE([
1525                 #include <linux/netdevice.h>
1526
1527                 int set_vf_link_state(struct net_device *dev, int vf, int link_state)
1528                 {
1529                         return 0;
1530                 }
1531         ],[
1532                 struct net_device_ops netdev_ops;
1533
1534                 netdev_ops.ndo_set_vf_link_state = set_vf_link_state;
1535
1536                 return 0;
1537         ],[
1538                 AC_MSG_RESULT(yes)
1539                 AC_DEFINE(HAVE_NETDEV_OPS_NDO_SET_VF_LINK_STATE, 1,
1540                           [ndo_set_vf_link_state is defined in net_device_ops])
1541         ],[
1542                 AC_MSG_RESULT(no)
1543         ])
1544
1545         AC_MSG_CHECKING([if net_device_ops_ext has ndo_set_vf_link_state])
1546         LB_LINUX_TRY_COMPILE([
1547                 #include <linux/netdevice.h>
1548
1549                 int set_vf_link_state(struct net_device *dev, int vf, int link_state)
1550                 {
1551                         return 0;
1552                 }
1553         ],[
1554                 struct net_device_ops_ext netdev_ops_ext;
1555
1556                 netdev_ops_ext.ndo_set_vf_link_state = set_vf_link_state;
1557
1558                 return 0;
1559         ],[
1560                 AC_MSG_RESULT(yes)
1561                 AC_DEFINE(HAVE_NETDEV_OPS_EXT_NDO_SET_VF_LINK_STATE, 1,
1562                           [ndo_set_vf_link_state is defined])
1563         ],[
1564                 AC_MSG_RESULT(no)
1565         ])
1566
1567
1568         AC_MSG_CHECKING([if netdevice.h netif_set_real_num_tx_queues returns int])
1569         LB_LINUX_TRY_COMPILE([
1570                 #include <linux/netdevice.h>
1571         ],[
1572                 struct net_device dev;
1573                 int ret;
1574                 ret = netif_set_real_num_tx_queues(&dev, 2);
1575                 return 0;
1576         ],[
1577                 AC_MSG_RESULT(yes)
1578                 AC_DEFINE(HAVE_RETURN_INT_FOR_SET_NUM_TX_QUEUES, 1,
1579                           [netif_set_real_num_tx_queues returns int])
1580         ],[
1581                 AC_MSG_RESULT(no)
1582         ])
1583
1584         AC_MSG_CHECKING([if struct netdevice.h has struct xps_map])
1585         LB_LINUX_TRY_COMPILE([
1586                 #include <linux/netdevice.h>
1587         ],[
1588                 struct xps_map map;
1589                 map.len = 0;
1590
1591                 return 0;
1592         ],[
1593                 AC_MSG_RESULT(yes)
1594                 AC_DEFINE(HAVE_XPS_MAP, 1,
1595                           [struct xps_map is defined])
1596         ],[
1597                 AC_MSG_RESULT(no)
1598         ])
1599
1600         AC_MSG_CHECKING([if struct ethtool_ops has set_phys_id])
1601         LB_LINUX_TRY_COMPILE([
1602                 #include <linux/ethtool.h>
1603         ],[
1604                 const struct ethtool_ops en_ethtool_ops = {
1605                         .set_phys_id= NULL,
1606                 };
1607
1608                 return 0;
1609         ],[
1610                 AC_MSG_RESULT(yes)
1611                 AC_DEFINE(HAVE_SET_PHYS_ID, 1,
1612                           [set_phys_id is defined])
1613         ],[
1614                 AC_MSG_RESULT(no)
1615         ])
1616
1617         AC_MSG_CHECKING([if struct ethtool_ops has get/set_channels])
1618         LB_LINUX_TRY_COMPILE([
1619                 #include <linux/ethtool.h>
1620         ],[
1621                 const struct ethtool_ops en_ethtool_ops = {
1622                         .get_channels = NULL,
1623                         .set_channels = NULL,
1624                 };
1625
1626                 return 0;
1627         ],[
1628                 AC_MSG_RESULT(yes)
1629                 AC_DEFINE(HAVE_GET_SET_CHANNELS, 1,
1630                           [get/set_channels is defined])
1631         ],[
1632                 AC_MSG_RESULT(no)
1633         ])
1634
1635         AC_MSG_CHECKING([if struct ethtool_ops_ext has get/set_channels])
1636         LB_LINUX_TRY_COMPILE([
1637                 #include <linux/ethtool.h>
1638         ],[
1639                 const struct ethtool_ops_ext en_ethtool_ops_ext = {
1640                         .get_channels = NULL,
1641                         .set_channels = NULL,
1642                 };
1643
1644                 return 0;
1645         ],[
1646                 AC_MSG_RESULT(yes)
1647                 AC_DEFINE(HAVE_GET_SET_CHANNELS_EXT, 1,
1648                           [get/set_channels is defined in ethtool_ops_ext])
1649         ],[
1650                 AC_MSG_RESULT(no)
1651         ])
1652
1653         AC_MSG_CHECKING([if struct ethtool_ops has get_ts_info])
1654         LB_LINUX_TRY_COMPILE([
1655                 #include <linux/ethtool.h>
1656         ],[
1657                 const struct ethtool_ops en_ethtool_ops = {
1658                         .get_ts_info = NULL,
1659                 };
1660
1661                 return 0;
1662         ],[
1663                 AC_MSG_RESULT(yes)
1664                 AC_DEFINE(HAVE_GET_TS_INFO, 1,
1665                           [get_ts_info is defined])
1666         ],[
1667                 AC_MSG_RESULT(no)
1668         ])
1669
1670         AC_MSG_CHECKING([if struct ethtool_ops has set_dump])
1671         LB_LINUX_TRY_COMPILE([
1672                 #include <linux/ethtool.h>
1673         ],[
1674                 const struct ethtool_ops en_ethtool_ops = {
1675                         .set_dump = NULL,
1676                 };
1677
1678                 return 0;
1679         ],[
1680                 AC_MSG_RESULT(yes)
1681                 AC_DEFINE(HAVE_ETHTOOL_OPS_SET_DUMP, 1,
1682                           [set_dump is defined])
1683         ],[
1684                 AC_MSG_RESULT(no)
1685         ])
1686
1687         AC_MSG_CHECKING([if struct ethtool_ops has get_module_info])
1688         LB_LINUX_TRY_COMPILE([
1689                 #include <linux/ethtool.h>
1690         ],[
1691                 const struct ethtool_ops en_ethtool_ops = {
1692                         .get_module_info = NULL,
1693                 };
1694
1695                 return 0;
1696         ],[
1697                 AC_MSG_RESULT(yes)
1698                 AC_DEFINE(HAVE_ETHTOOL_OPS_GET_MODULE_INFO, 1,
1699                           [get_module_info is defined])
1700         ],[
1701                 AC_MSG_RESULT(no)
1702         ])
1703
1704         AC_MSG_CHECKING([if struct ethtool_ops has get_module_eeprom])
1705         LB_LINUX_TRY_COMPILE([
1706                 #include <linux/ethtool.h>
1707         ],[
1708                 const struct ethtool_ops en_ethtool_ops = {
1709                         .get_module_eeprom = NULL,
1710                 };
1711
1712                 return 0;
1713         ],[
1714                 AC_MSG_RESULT(yes)
1715                 AC_DEFINE(HAVE_ETHTOOL_OPS_GET_MODULE_EEPROM, 1,
1716                           [get_module_eeprom is defined])
1717         ],[
1718                 AC_MSG_RESULT(no)
1719         ])
1720
1721         AC_MSG_CHECKING([if struct ethtool_ops_ext has get_ts_info])
1722         LB_LINUX_TRY_COMPILE([
1723                 #include <linux/ethtool.h>
1724         ],[
1725                 const struct ethtool_ops_ext en_ethtool_ops_ext = {
1726                         .get_ts_info = NULL,
1727                 };
1728
1729                 return 0;
1730         ],[
1731                 AC_MSG_RESULT(yes)
1732                 AC_DEFINE(HAVE_GET_TS_INFO_EXT, 1,
1733                           [get_ts_info is defined in ethtool_ops_ext])
1734         ],[
1735                 AC_MSG_RESULT(no)
1736         ])
1737
1738         AC_MSG_CHECKING([if struct ethtool_flow_ext has h_dest])
1739         LB_LINUX_TRY_COMPILE([
1740                 #include <linux/ethtool.h>
1741         ],[
1742                 unsigned char mac[ETH_ALEN];
1743                 struct ethtool_flow_ext h_ext;
1744
1745                 memcpy(&mac, h_ext.h_dest, ETH_ALEN);
1746
1747                 return 0;
1748         ],[
1749                 AC_MSG_RESULT(yes)
1750                 AC_DEFINE(HAVE_ETHTOOL_FLOW_EXT_H_DEST, 1,
1751                           [ethtool_flow_ext has h_dest])
1752         ],[
1753                 AC_MSG_RESULT(no)
1754         ])
1755
1756         AC_MSG_CHECKING([if netdevice.h has struct dev_addr_list])
1757         LB_LINUX_TRY_COMPILE([
1758                 #include <linux/netdevice.h>
1759         ],[
1760                 struct dev_addr_list addr;
1761                 return 0;
1762         ],[
1763                 AC_MSG_RESULT(yes)
1764                 AC_DEFINE(HAVE_NETDEV_DEV_ADDR, 1,
1765                           [dev_addr_list is defined])
1766         ],[
1767                 AC_MSG_RESULT(no)
1768         ])
1769
1770         AC_MSG_CHECKING([if pci.h has pci_vfs_assigned])
1771         LB_LINUX_TRY_COMPILE([
1772                 #include <linux/pci.h>
1773         ],[
1774                 struct pci_dev pdev;
1775                 pci_vfs_assigned(&pdev);
1776                 return 0;
1777         ],[
1778                 AC_MSG_RESULT(yes)
1779                 AC_DEFINE(HAVE_PCI_VF_ASSIGNED, 1,
1780                           [pci_vfs_assigned is defined])
1781         ],[
1782                 AC_MSG_RESULT(no)
1783         ])
1784
1785         AC_MSG_CHECKING([if vlan_insert_tag_set_proto is defined])
1786         LB_LINUX_TRY_COMPILE([
1787                 #include <linux/if_vlan.h>
1788         ],[
1789                 struct sk_buff *skb;
1790                 vlan_insert_tag_set_proto(skb, 0, 0);
1791                 return 0;
1792         ],[
1793                 AC_MSG_RESULT(yes)
1794                 AC_DEFINE(HAVE_VLAN_INSERT_TAG_SET_PROTO, 1,
1795                           [vlan_insert_tag_set_proto is defined])
1796         ],[
1797                 AC_MSG_RESULT(no)
1798                 AC_MSG_CHECKING([if __vlan_put_tag has 3 parameters])
1799                 LB_LINUX_TRY_COMPILE([
1800                         #include <linux/if_vlan.h>
1801                 ],[
1802                         struct sk_buff *skb;
1803                         __vlan_put_tag(skb, 0, 0);
1804                         return 0;
1805                 ],[
1806                         AC_MSG_RESULT(yes)
1807                         AC_DEFINE(HAVE_3_PARAMS_FOR_VLAN_PUT_TAG, 1,
1808                                   [__vlan_put_tag has 3 parameters])
1809                 ],[
1810                         AC_MSG_RESULT(no)
1811                 ])
1812         ])
1813
1814         AC_MSG_CHECKING([if __vlan_hwaccel_put_tag has 3 parameters])
1815         LB_LINUX_TRY_COMPILE([
1816                 #include <linux/if_vlan.h>
1817         ],[
1818                 struct sk_buff *skb;
1819                 __vlan_hwaccel_put_tag(skb, 0, 0);
1820
1821                 return 0;
1822         ],[
1823                 AC_MSG_RESULT(yes)
1824                 AC_DEFINE(HAVE_3_PARAMS_FOR_VLAN_HWACCEL_PUT_TAG, 1,
1825                           [__vlan_hwaccel_put_tag has 3 parameters])
1826         ],[
1827                 AC_MSG_RESULT(no)
1828         ])
1829
1830         AC_MSG_CHECKING([if struct inet6_ifaddr has if_next])
1831         LB_LINUX_TRY_COMPILE([
1832                 #include <net/if_inet6.h>
1833         ],[
1834                 struct inet6_ifaddr ifp ;
1835                 ifp.if_next = 0;
1836
1837                 return 0;
1838         ],[
1839                 AC_MSG_RESULT(yes)
1840                 AC_DEFINE(HAVE_INETADDR_IF_NEXT, 1,
1841                           [if_next is defined])
1842         ],[
1843                 AC_MSG_RESULT(no)
1844         ])
1845
1846         AC_MSG_CHECKING([if struct net_device has hw_features])
1847         LB_LINUX_TRY_COMPILE([
1848                 #include <linux/netdevice.h>
1849         ],[
1850                 struct net_device dev;
1851                 dev.hw_features = 0;
1852
1853                 return 0;
1854         ],[
1855                 AC_MSG_RESULT(yes)
1856                 AC_DEFINE(HAVE_NETDEV_HW_FEATURES, 1,
1857                           [hw_features is defined])
1858         ],[
1859                 AC_MSG_RESULT(no)
1860         ])
1861
1862         AC_MSG_CHECKING([if struct net_device has hw_enc_features])
1863         LB_LINUX_TRY_COMPILE([
1864                 #include <linux/netdevice.h>
1865         ],[
1866                 struct net_device dev;
1867                 dev.hw_enc_features = 0;
1868
1869                 return 0;
1870         ],[
1871                 AC_MSG_RESULT(yes)
1872                 AC_DEFINE(HAVE_NETDEV_HW_ENC_FEATURES, 1,
1873                           [hw_enc_features is defined])
1874         ],[
1875                 AC_MSG_RESULT(no)
1876         ])
1877
1878         AC_MSG_CHECKING([if struct net_device has rx_cpu_rmap])
1879         LB_LINUX_TRY_COMPILE([
1880                 #include <linux/netdevice.h>
1881         ],[
1882                 struct net_device dev;
1883                 dev.rx_cpu_rmap = NULL;
1884
1885                 return 0;
1886         ],[
1887                 AC_MSG_RESULT(yes)
1888                 AC_DEFINE(HAVE_NETDEV_RX_CPU_RMAP, 1,
1889                           [rx_cpu_rmap is defined])
1890         ],[
1891                 AC_MSG_RESULT(no)
1892         ])
1893
1894         AC_MSG_CHECKING([if if_vlan.h has vlan_hwaccel_receive_skb])
1895         LB_LINUX_TRY_COMPILE([
1896                 #include <linux/if_vlan.h>
1897         ],[
1898                 struct sk_buff *skb;
1899                 vlan_hwaccel_receive_skb(skb,0,0);
1900                 return 0;
1901         ],[
1902                 AC_MSG_RESULT(yes)
1903                 AC_DEFINE(HAVE_VLAN_HWACCEL_RECEIVE_SKB, 1,
1904                           [vlan_hwaccel_receive_skb is defined])
1905         ],[
1906                 AC_MSG_RESULT(no)
1907         ])
1908
1909         AC_MSG_CHECKING([if irqdesc.h has irq_desc_get_irq_data])
1910         LB_LINUX_TRY_COMPILE([
1911                 #include <linux/irq.h>
1912                 #include <linux/irqdesc.h>
1913         ],[
1914                 struct irq_desc desc;
1915                 struct irq_data *data = irq_desc_get_irq_data(&desc);
1916
1917                 return 0;
1918         ],[
1919                 AC_MSG_RESULT(yes)
1920                 AC_DEFINE(HAVE_IRQ_DESC_GET_IRQ_DATA, 1,
1921                           [irq_desc_get_irq_data is defined])
1922         ],[
1923                 AC_MSG_RESULT(no)
1924         ])
1925
1926
1927         AC_MSG_CHECKING([if pci_dev has pcie_mpss])
1928         LB_LINUX_TRY_COMPILE([
1929                 #include <linux/pci.h>
1930         ],[
1931                 struct pci_dev *pdev;
1932
1933                 pdev->pcie_mpss = 0;
1934                 return 0;
1935         ],[
1936                 AC_MSG_RESULT(yes)
1937                 AC_DEFINE(HAVE_PCI_DEV_PCIE_MPSS, 1,
1938                           [pcie_mpss is defined])
1939         ],[
1940                 AC_MSG_RESULT(no)
1941         ])
1942
1943         AC_MSG_CHECKING([if uapi/linux/if_ether.h exist])
1944         LB_LINUX_TRY_COMPILE([
1945                 #include <uapi/linux/if_ether.h>
1946         ],[
1947                 return 0;
1948         ],[
1949                 AC_MSG_RESULT(yes)
1950                 AC_DEFINE(HAVE_UAPI_LINUX_IF_ETHER_H, 1,
1951                           [uapi/linux/if_ether.h exist])
1952         ],[
1953                 AC_MSG_RESULT(no)
1954         ])
1955
1956         AC_MSG_CHECKING([if ifla_vf_info has spoofchk])
1957         LB_LINUX_TRY_COMPILE([
1958                 #include <linux/if_link.h>
1959         ],[
1960                 struct ifla_vf_info *ivf;
1961
1962                 ivf->spoofchk = 0;
1963                 return 0;
1964         ],[
1965                 AC_MSG_RESULT(yes)
1966                 AC_DEFINE(HAVE_VF_INFO_SPOOFCHK, 1,
1967                           [spoofchk is defined])
1968         ],[
1969                 AC_MSG_RESULT(no)
1970         ])
1971
1972         AC_MSG_CHECKING([if vxlan.h has vxlan_gso_check])
1973         LB_LINUX_TRY_COMPILE([
1974                 #include <net/vxlan.h>
1975         ],[
1976                 vxlan_gso_check(NULL);
1977
1978                 return 0;
1979         ],[
1980                 AC_MSG_RESULT(yes)
1981                 AC_DEFINE(HAVE_VXLAN_GSO_CHECK, 1,
1982                           [vxlan_gso_check is defined])
1983         ],[
1984                 AC_MSG_RESULT(no)
1985         ])
1986
1987         AC_MSG_CHECKING([if dst.h has dst_get_neighbour])
1988         LB_LINUX_TRY_COMPILE([
1989                 #include <net/dst.h>
1990         ],[
1991                 struct neighbour *neigh = dst_get_neighbour(NULL);
1992
1993                 return 0;
1994         ],[
1995                 AC_MSG_RESULT(yes)
1996                 AC_DEFINE(HAVE_DST_GET_NEIGHBOUR, 1,
1997                           [ is defined])
1998         ],[
1999                 AC_MSG_RESULT(no)
2000         ])
2001
2002         AC_MSG_CHECKING([if netlink_dump_start has 6 parameters])
2003         LB_LINUX_TRY_COMPILE([
2004                 #include <linux/netlink.h>
2005         ],[
2006                 int ret = netlink_dump_start(NULL, NULL, NULL, NULL, NULL, 0);
2007
2008                 return 0;
2009         ],[
2010                 AC_MSG_RESULT(yes)
2011                 AC_DEFINE(HAVE_NETLINK_DUMP_START_6P, 1,
2012                           [ is defined])
2013         ],[
2014                 AC_MSG_RESULT(no)
2015         ])
2016
2017         AC_MSG_CHECKING([if netlink_dump_start has 5 parameters])
2018         LB_LINUX_TRY_COMPILE([
2019                 #include <linux/netlink.h>
2020         ],[
2021                 int ret = netlink_dump_start(NULL, NULL, NULL, NULL, NULL);
2022
2023                 return 0;
2024         ],[
2025                 AC_MSG_RESULT(yes)
2026                 AC_DEFINE(HAVE_NETLINK_DUMP_START_5P, 1,
2027                           [ is defined])
2028         ],[
2029                 AC_MSG_RESULT(no)
2030         ])
2031
2032         AC_MSG_CHECKING([if struct dcbnl_rtnl_ops has ieee_getmaxrate/ieee_setmaxrate])
2033         LB_LINUX_TRY_COMPILE([
2034                 #include <net/dcbnl.h>
2035         ],[
2036                 const struct dcbnl_rtnl_ops en_dcbnl_ops = {
2037                         .ieee_getmaxrate = NULL,
2038                         .ieee_setmaxrate = NULL,
2039                 };
2040
2041                 return 0;
2042         ],[
2043                 AC_MSG_RESULT(yes)
2044                 AC_DEFINE(HAVE_IEEE_GET_SET_MAXRATE, 1,
2045                           [ieee_getmaxrate/ieee_setmaxrate is defined])
2046         ],[
2047                 AC_MSG_RESULT(no)
2048         ])
2049
2050         AC_LANG_PUSH(C)
2051         ac_c_werror_flag=yes
2052         save_EXTRA_KCFLAGS=$EXTRA_KCFLAGS
2053         EXTRA_KCFLAGS="$EXTRA_KCFLAGS -Werror"
2054
2055         AC_MSG_CHECKING([if bonding.h bond_for_each_slave has int for 3rd parameter])
2056         LB_LINUX_TRY_COMPILE([
2057                 #include <net/bonding.h>
2058         ],[
2059                 struct bonding *bond = NULL;
2060                 struct slave *slave = NULL;
2061                 int iter;
2062
2063                 bond_for_each_slave(bond, slave, iter) ;
2064
2065                 return 0;
2066         ],[
2067                 AC_MSG_RESULT(yes)
2068                 AC_DEFINE(HAVE_BOND_FOR_EACH_SLAVE_3RD_PARAM_IS_INT, 1,
2069                           [bond_for_each_slave has int for 3rd parameter])
2070         ],[
2071                 AC_MSG_RESULT(no)
2072         ])
2073         EXTRA_KCFLAGS="$save_EXTRA_KCFLAGS"
2074         ac_c_werror_flag=
2075         AC_LANG_POP
2076
2077         AC_MSG_CHECKING([if netdevice.h has netdev_master_upper_dev_get_rcu])
2078         LB_LINUX_TRY_COMPILE([
2079                 #include <linux/netdevice.h>
2080         ],[
2081                 netdev_master_upper_dev_get_rcu(NULL);
2082
2083                 return 0;
2084         ],[
2085                 AC_MSG_RESULT(yes)
2086                 AC_DEFINE(HAVE_NETDEV_MASTER_UPPER_DEV_GET_RCU, 1,
2087                           [netdev_master_upper_dev_get_rcu is defined])
2088         ],[
2089                 AC_MSG_RESULT(no)
2090         ])
2091
2092         AC_MSG_CHECKING([if __vlan_find_dev_deep has 3 parameters])
2093         LB_LINUX_TRY_COMPILE([
2094                 #include <linux/if_vlan.h>
2095         ],[
2096                 __vlan_find_dev_deep(NULL, 0, 0);
2097
2098                 return 0;
2099         ],[
2100                 AC_MSG_RESULT(yes)
2101                 AC_DEFINE(HAVE__VLAN_FIND_DEV_DEEP_3P, 1,
2102                           [__vlan_find_dev_deep has 3 paramters])
2103         ],[
2104                 AC_MSG_RESULT(no)
2105         ])
2106
2107         AC_MSG_CHECKING([if sk_buff.h has __skb_alloc_page])
2108         LB_LINUX_TRY_COMPILE([
2109                 #include <linux/skbuff.h>
2110         ],[
2111                 __skb_alloc_page(0, NULL);
2112
2113                 return 0;
2114         ],[
2115                 AC_MSG_RESULT(yes)
2116                 AC_DEFINE(HAVE__SKB_ALLOC_PAGE, 1,
2117                           [sk_buff has __skb_alloc_page])
2118         ],[
2119                 AC_MSG_RESULT(no)
2120         ])
2121
2122         AC_MSG_CHECKING([if __vlan_hwaccel_put_tag has 3 parameters])
2123         LB_LINUX_TRY_COMPILE([
2124                 #include <linux/if_vlan.h>
2125         ],[
2126                 __vlan_hwaccel_put_tag(NULL, 0, 0);
2127
2128                 return 0;
2129         ],[
2130                 AC_MSG_RESULT(yes)
2131                 AC_DEFINE(HAVE__VLAN_HWACCEL_PUT_TAG_3P, 1,
2132                           [__vlan_hwaccel_put_tag has 3 paramters])
2133         ],[
2134                 AC_MSG_RESULT(no)
2135         ])
2136
2137         AC_MSG_CHECKING([if linux/mm_types.h has struct page_frag])
2138         LB_LINUX_TRY_COMPILE([
2139                 #include <linux/mm_types.h>
2140         ],[
2141                 struct page_frag frag = {0};
2142
2143                 return 0;
2144         ],[
2145                 AC_MSG_RESULT(yes)
2146                 AC_DEFINE(HAVE_MM_TYPES_PAGE_FRAG, 1,
2147                           [linux/mm_types.h has struct page_frag])
2148         ],[
2149                 AC_MSG_RESULT(no)
2150         ])
2151
2152         AC_MSG_CHECKING([if if_vlan.h has __vlan_find_dev_deep])
2153         LB_LINUX_TRY_COMPILE([
2154                 #include <linux/if_vlan.h>
2155         ],[
2156                 __vlan_find_dev_deep(NULL, 0);
2157
2158                 return 0;
2159         ],[
2160                 AC_MSG_RESULT(yes)
2161                 AC_DEFINE(HAVE___VLAN_FIND_DEV_DEEP, 1,
2162                           [__vlan_find_dev_deep is defined])
2163         ],[
2164                 AC_MSG_RESULT(no)
2165         ])
2166
2167         AC_MSG_CHECKING([if idr .h has idr_Alloc])
2168         LB_LINUX_TRY_COMPILE([
2169                 #include <linux/idr.h>
2170         ],[
2171                 idr_alloc(NULL, NULL, 0, 0, 0);
2172                 return 0;
2173         ],[
2174                 AC_MSG_RESULT(yes)
2175                 AC_DEFINE(HAVE_IDR_NEW_INTERFACE, 1,
2176                           [idr_Alloc is defined]) ],[
2177                 AC_MSG_RESULT(no)
2178         ])
2179
2180         AC_MSG_CHECKING([if completion.h has reinit_completion])
2181         LB_LINUX_TRY_COMPILE([
2182                 #include <linux/completion.h>
2183         ],[
2184                 struct completion c;
2185
2186                 reinit_completion(&c);
2187                 return 0;
2188         ],[
2189                 AC_MSG_RESULT(yes)
2190                 AC_DEFINE(HAVE_REINIT_COMPLETION, 1,
2191                           [reinit_completion is defined])
2192         ],[
2193                 AC_MSG_RESULT(no)
2194         ])
2195
2196         AC_MSG_CHECKING([if dma-mapping.h has dma_set_mask_and_coherent])
2197         LB_LINUX_TRY_COMPILE([
2198                 #include <linux/dma-mapping.h>
2199         ],[
2200                 dma_set_mask_and_coherent(NULL, 0);
2201
2202                 return 0;
2203         ],[
2204                 AC_MSG_RESULT(yes)
2205                 AC_DEFINE(HAVE_DMA_SET_MASK_AND_COHERENT, 1,
2206                           [dma_set_mask_and_coherent is defined])
2207         ],[
2208                 AC_MSG_RESULT(no)
2209         ])
2210
2211         AC_MSG_CHECKING([if in.h has proto_ports_offset])
2212         LB_LINUX_TRY_COMPILE([
2213                 #include <linux/in.h>
2214         ],[
2215                 int x = proto_ports_offset(IPPROTO_TCP);
2216                 return 0;
2217         ],[
2218                 AC_MSG_RESULT(yes)
2219                 AC_DEFINE(HAVE_PROTO_PORTS_OFFSET, 1,
2220                           [proto_ports_offset is defined])
2221         ],[
2222                 AC_MSG_RESULT(no)
2223         ])
2224
2225         LB_CHECK_SYMBOL_EXPORT([elfcorehdr_addr],
2226                 [kernel/crash_dump.c],
2227                 [AC_DEFINE(HAVE_ELFCOREHDR_ADDR_EXPORTED, 1,
2228                         [elfcorehdr_addr is exported by the kernel])],
2229         [])
2230
2231         AC_MSG_CHECKING([if netif_set_real_num_rx_queues is defined])
2232         LB_LINUX_TRY_COMPILE([
2233                 #include <linux/netdevice.h>
2234         ],[
2235                 int rc = netif_set_real_num_rx_queues(NULL, 0);
2236
2237                 return rc;
2238         ],[
2239                 AC_MSG_RESULT(yes)
2240                 AC_DEFINE(HAVE_NETIF_SET_REAL_NUM_RX_QUEUES, 1,
2241                           [netif_set_real_num_rx_queues is defined])
2242         ],[
2243                 AC_MSG_RESULT(no)
2244         ])
2245
2246         AC_MSG_CHECKING([if if_vlan.h has is_vlan_dev])
2247         LB_LINUX_TRY_COMPILE([
2248                 #include <linux/netdevice.h>
2249                 #include <linux/if_vlan.h>
2250         ],[
2251                 struct net_device dev;
2252                 is_vlan_dev(&dev);
2253
2254                 return 0;
2255         ],[
2256                 AC_MSG_RESULT(yes)
2257                 AC_DEFINE(HAVE_IS_VLAN_DEV, 1,
2258                           [is_vlan_dev is defined])
2259         ],[
2260                 AC_MSG_RESULT(no)
2261         ])
2262
2263         AC_MSG_CHECKING([if linux/timecounter.h exists])
2264         LB_LINUX_TRY_COMPILE([
2265                 #include <linux/timecounter.h>
2266         ],[
2267                 return 0;
2268         ],[
2269                 AC_MSG_RESULT(yes)
2270                 AC_DEFINE(HAVE_TIMECOUNTER_H, 1,
2271                           [linux/timecounter.h exists])
2272         ],[
2273                 AC_MSG_RESULT(no)
2274         ])
2275
2276         # timecounter_adjtime can be in timecounter.h or clocksource.h
2277         AC_MSG_CHECKING([if linux/clocksource.h has timecounter_adjtime])
2278         LB_LINUX_TRY_COMPILE([
2279                 #include <linux/timecounter.h>
2280         ],[
2281                 struct timecounter x;
2282                 s64 y = 0;
2283                 timecounter_adjtime(&x, y);
2284
2285                 return 0;
2286         ],[
2287                 AC_MSG_RESULT(yes)
2288                 AC_DEFINE(HAVE_TIMECOUNTER_ADJTIME, 1,
2289                           [timecounter_adjtime is defined])
2290         ],[
2291                 AC_MSG_RESULT(no)
2292         ])
2293
2294         AC_MSG_CHECKING([if linux/clocksource.h has timecounter_adjtime])
2295         LB_LINUX_TRY_COMPILE([
2296                 #include <linux/clocksource.h>
2297         ],[
2298                 struct timecounter x;
2299                 s64 y = 0;
2300                 timecounter_adjtime(&x, y);
2301
2302                 return 0;
2303         ],[
2304                 AC_MSG_RESULT(yes)
2305                 AC_DEFINE(HAVE_TIMECOUNTER_ADJTIME, 1,
2306                           [timecounter_adjtime is defined])
2307         ],[
2308                 AC_MSG_RESULT(no)
2309         ])
2310
2311         AC_MSG_CHECKING([if cyclecounter_cyc2ns has 4 parameters])
2312         LB_LINUX_TRY_COMPILE([
2313                 #include <linux/timecounter.h>
2314         ],[
2315                 cyclecounter_cyc2ns(NULL, NULL, 0, NULL);
2316
2317                 return 0;
2318         ],[
2319                 AC_MSG_RESULT(yes)
2320                 AC_DEFINE(HAVE_CYCLECOUNTER_CYC2NS_4_PARAMS, 1,
2321                           [cyclecounter_cyc2ns has 4 parameters])
2322         ],[
2323                 AC_MSG_RESULT(no)
2324         ])
2325
2326         AC_MSG_CHECKING([if netdevice.h struct net_device_ops has ndo_features_check])
2327         LB_LINUX_TRY_COMPILE([
2328                 #include <linux/netdevice.h>
2329         ],[
2330                 static const struct net_device_ops mlx4_netdev_ops = {
2331                         .ndo_features_check     = NULL,
2332                 };
2333
2334                 return 0;
2335         ],[
2336                 AC_MSG_RESULT(yes)
2337                 AC_DEFINE(HAVE_NETDEV_FEATURES_T, 1,
2338                           [netdev_features_t is defined])
2339         ],[
2340                 AC_MSG_RESULT(no)
2341         ])
2342
2343         AC_MSG_CHECKING([if struct ethtool_ops get_rxnfc gets u32 *rule_locs])
2344         LB_LINUX_TRY_COMPILE([
2345                 #include <linux/ethtool.h>
2346                 static int mlx4_en_get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *c,
2347                                              u32 *rule_locs)
2348                 {
2349                         return 0;
2350                 }
2351         ],[
2352                 struct ethtool_ops x = {
2353                         .get_rxnfc = mlx4_en_get_rxnfc,
2354                 };
2355
2356                 return 0;
2357         ],[
2358                 AC_MSG_RESULT(yes)
2359                 AC_DEFINE(HAVE_ETHTOOL_OPS_GET_RXNFC_U32_RULE_LOCS, 1,
2360                           [ethtool_ops get_rxnfc gets u32 *rule_locs])
2361         ],[
2362                 AC_MSG_RESULT(no)
2363         ])
2364
2365         AC_MSG_CHECKING([if ethtool.h enum ethtool_stringset has ETH_SS_RSS_HASH_FUNCS])
2366         LB_LINUX_TRY_COMPILE([
2367                 #include <linux/ethtool.h>
2368         ],[
2369                 enum ethtool_stringset x = ETH_SS_RSS_HASH_FUNCS;
2370
2371                 return 0;
2372         ],[
2373                 AC_MSG_RESULT(yes)
2374                 AC_DEFINE(HAVE_ETH_SS_RSS_HASH_FUNCS, 1,
2375                           [ETH_SS_RSS_HASH_FUNCS is defined])
2376         ],[
2377                 AC_MSG_RESULT(no)
2378         ])
2379
2380         AC_MSG_CHECKING([if include/linux/irq_poll.h exists])
2381         LB_LINUX_TRY_COMPILE([
2382                 #include <linux/irq_poll.h>
2383         ],[
2384                 return 0;
2385         ],[
2386                 AC_MSG_RESULT(yes)
2387                 AC_DEFINE(HAVE_IRQ_POLL_H, 1,
2388                           [include/linux/irq_poll.h exists])
2389         ],[
2390                 AC_MSG_RESULT(no)
2391         ])
2392
2393         AC_MSG_CHECKING([if linux/dma-mapping.h has struct dma_attrs])
2394         LB_LINUX_TRY_COMPILE([
2395                 #include <linux/dma-mapping.h>
2396         ],[
2397                 struct dma_attrs *attrs;
2398                 int ret;
2399
2400                 ret = dma_get_attr(DMA_ATTR_WRITE_BARRIER, attrs);
2401
2402                 return ret;
2403         ],[
2404                 AC_MSG_RESULT(yes)
2405                 AC_DEFINE(HAVE_STRUCT_DMA_ATTRS, 1,
2406                           [struct dma_attrs is defined])
2407         ],[
2408                 AC_MSG_RESULT(no)
2409         ])
2410
2411         AC_MSG_CHECKING([if pci.h has pcie_get_minimum_link])
2412         LB_LINUX_TRY_COMPILE([
2413                 #include <linux/pci.h>
2414         ],[
2415                 int ret;
2416                 ret = pcie_get_minimum_link(NULL, NULL, NULL);
2417
2418                 return ret;
2419         ],[
2420                 AC_MSG_RESULT(yes)
2421                 AC_DEFINE(HAVE_PCIE_GET_MINIMUM_LINK, 1,
2422                           [pcie_get_minimum_link is defined])
2423         ],[
2424                 AC_MSG_RESULT(no)
2425         ])
2426
2427         AC_MSG_CHECKING([if netdevice.h has netdev_for_each_all_upper_dev_rcu])
2428         LB_LINUX_TRY_COMPILE([
2429                 #include <linux/netdevice.h>
2430         ],[
2431                 struct net_device *dev;
2432                 struct net_device *upper;
2433                 struct list_head *list;
2434
2435                 netdev_for_each_all_upper_dev_rcu(dev, upper, list);
2436                 return 0;
2437         ],[
2438                 AC_MSG_RESULT(yes)
2439                 AC_DEFINE(HAVE_NETDEV_FOR_EACH_ALL_UPPER_DEV_RCU, 1,
2440                           [netdev_master_upper_dev_get_rcu is defined])
2441         ],[
2442                 AC_MSG_RESULT(no)
2443         ])
2444
2445         AC_MSG_CHECKING([if netdevice.h has netdev_has_upper_dev])
2446         LB_LINUX_TRY_COMPILE([
2447                 #include <linux/netdevice.h>
2448         ],[
2449                 struct net_device *dev;
2450                 struct net_device *upper;
2451                 netdev_has_upper_dev(dev, upper);
2452
2453                 return 0;
2454         ],[
2455                 AC_MSG_RESULT(yes)
2456                 AC_DEFINE(HAVE_NETDEV_HAS_UPPER_DEV, 1,
2457                           [netdev_has_upper_dev is defined])
2458         ],[
2459                 AC_MSG_RESULT(no)
2460         ])
2461
2462         AC_MSG_CHECKING([if ethtool.h has __ethtool_get_link_ksettings])
2463         LB_LINUX_TRY_COMPILE([
2464                 #include <linux/ethtool.h>
2465         ],[
2466                  __ethtool_get_link_ksettings(NULL, NULL);
2467
2468                 return 0;
2469         ],[
2470                 AC_MSG_RESULT(yes)
2471                 AC_DEFINE(HAVE___ETHTOOL_GET_LINK_KSETTINGS, 1,
2472                           [__ethtool_get_link_ksettings is defined])
2473         ],[
2474                 AC_MSG_RESULT(no)
2475         ])
2476
2477         AC_MSG_CHECKING([if addrconf.h has addrconf_ifid_eui48])
2478         LB_LINUX_TRY_COMPILE([
2479                 #include <net/addrconf.h>
2480         ],[
2481                 int x = addrconf_ifid_eui48(NULL, NULL);
2482
2483                 return 0;
2484         ],[
2485                 AC_MSG_RESULT(yes)
2486                 AC_DEFINE(HAVE_ADDRCONF_IFID_EUI48, 1,
2487                           [addrconf_ifid_eui48 is defined])
2488         ],[
2489                 AC_MSG_RESULT(no)
2490         ])
2491
2492         AC_MSG_CHECKING([if mm.h get_user_pages has 6 params])
2493         LB_LINUX_TRY_COMPILE([
2494                 #include <linux/mm.h>
2495         ],[
2496                 get_user_pages(0, 0, 0, 0, NULL, NULL);
2497
2498                 return 0;
2499         ],[
2500                 AC_MSG_RESULT(yes)
2501                 AC_DEFINE(HAVE_GET_USER_PAGES_6_PARAMS, 1,
2502                           [get_user_pages has 6 params])
2503         ],[
2504                 AC_MSG_RESULT(no)
2505         ])
2506
2507         AC_MSG_CHECKING([if mm.h get_user_pages_remote])
2508         LB_LINUX_TRY_COMPILE([
2509                 #include <linux/mm.h>
2510         ],[
2511                 get_user_pages_remote(NULL, NULL, 0, 0, 0, 0, NULL, NULL);
2512
2513                 return 0;
2514         ],[
2515                 AC_MSG_RESULT(yes)
2516                 AC_DEFINE(HAVE_GET_USER_PAGES_REMOTE, 1,
2517                           [get_user_pages_remote exist])
2518         ],[
2519                 AC_MSG_RESULT(no)
2520         ])
2521
2522         AC_MSG_CHECKING([if ip_fib.h fib_lookup has 4 params])
2523         LB_LINUX_TRY_COMPILE([
2524                 #include <linux/bug.h>
2525                 #include <net/ip_fib.h>
2526         ],[
2527                 fib_lookup(NULL, NULL, NULL, 0);
2528
2529                 return 0;
2530         ],[
2531                 AC_MSG_RESULT(yes)
2532                 AC_DEFINE(HAVE_FIB_LOOKUP_4_PARAMS, 1,
2533                           [fib_lookup has 4 params])
2534         ],[
2535                 AC_MSG_RESULT(no)
2536         ])
2537
2538         AC_MSG_CHECKING([if include/net/devlink.h exists])
2539         LB_LINUX_TRY_COMPILE([
2540                 #include <net/devlink.h>
2541         ],[
2542                 return 0;
2543         ],[
2544                 AC_MSG_RESULT(yes)
2545                 AC_DEFINE(HAVE_NET_DEVLINK_H, 1,
2546                           [include/net/devlink.h exists])
2547         ],[
2548                 AC_MSG_RESULT(no)
2549         ])
2550
2551         AC_MSG_CHECKING([if io_mapping_map_wc has 3 params])
2552         LB_LINUX_TRY_COMPILE([
2553                 #include <linux/io-mapping.h>
2554         ],[
2555                 io_mapping_map_wc(NULL, 0, 0);
2556
2557                 return 0;
2558         ],[
2559                 AC_MSG_RESULT(yes)
2560                 AC_DEFINE(HAVE_IO_MAPPING_MAP_WC_3_PARAMS, 1,
2561                           [io_mapping_map_wc has 3 params])
2562         ],[
2563                 AC_MSG_RESULT(no)
2564         ])
2565
2566         AC_MSG_CHECKING([if include/net/dcbnl.h struct dcbnl_rtnl_ops has *ieee_getqcn])
2567         LB_LINUX_TRY_COMPILE([
2568                 #include <linux/netdevice.h>
2569                 #include <net/dcbnl.h>
2570         ],[
2571                 struct dcbnl_rtnl_ops x = {
2572                         .ieee_getqcn = NULL,
2573                 };
2574
2575                 return 0;
2576         ],[
2577                 AC_MSG_RESULT(yes)
2578                 AC_DEFINE(HAVE_IEEE_GETQCN, 1,
2579                           [ieee_getqcn is defined])
2580         ],[
2581                 AC_MSG_RESULT(no)
2582         ])
2583
2584         AC_MSG_CHECKING([if dcbnl.h has struct ieee_qcn])
2585         LB_LINUX_TRY_COMPILE([
2586                 #include <linux/netdevice.h>
2587                 #include <net/dcbnl.h>
2588         ],[
2589                 struct ieee_qcn x;
2590
2591                 return 0;
2592         ],[
2593                 AC_MSG_RESULT(yes)
2594                 AC_DEFINE(HAVE_STRUCT_IEEE_QCN, 1,
2595                           [ieee_qcn is defined])
2596         ],[
2597                 AC_MSG_RESULT(no)
2598         ])
2599
2600         AC_MSG_CHECKING([if netdevice.h has napi_consume_skb])
2601         LB_LINUX_TRY_COMPILE([
2602                 #include <linux/skbuff.h>
2603         ],[
2604                 napi_consume_skb(NULL, 0);
2605
2606                 return 0;
2607         ],[
2608                 AC_MSG_RESULT(yes)
2609                 AC_DEFINE(HAVE_NAPI_CONSUME_SKB, 1,
2610                           [napi_consume_skb is defined])
2611         ],[
2612                 AC_MSG_RESULT(no)
2613         ])
2614
2615         AC_MSG_CHECKING([if include/linux/bpf.h exists])
2616         LB_LINUX_TRY_COMPILE([
2617                 #include <linux/bpf.h>
2618         ],[
2619                 return 0;
2620         ],[
2621                 AC_MSG_RESULT(yes)
2622                 AC_DEFINE(HAVE_LINUX_BPF_H, 1,
2623                           [include/linux/bpf.h exists])
2624         ],[
2625                 AC_MSG_RESULT(no)
2626         ])
2627
2628         AC_MSG_CHECKING([if mm_types.h struct page has _count])
2629         LB_LINUX_TRY_COMPILE([
2630                 #include <linux/mm.h>
2631                 #include <linux/mm_types.h>
2632         ],[
2633                 struct page p;
2634                 p._count.counter = 0;
2635
2636                 return 0;
2637         ],[
2638                 AC_MSG_RESULT(yes)
2639                 AC_DEFINE(HAVE_MM_PAGE__COUNT, 1,
2640                           [struct page has _count])
2641         ],[
2642                 AC_MSG_RESULT(no)
2643         ])
2644
2645         AC_MSG_CHECKING([if include/linux/page_ref.h exists])
2646         LB_LINUX_TRY_COMPILE([
2647                 #include <linux/page_ref.h>
2648         ],[
2649                 return 0;
2650         ],[
2651                 AC_MSG_RESULT(yes)
2652                 AC_DEFINE(HAVE_LINUX_PAGE_REF_H, 1,
2653                           [include/linux/page_ref.h exists])
2654         ],[
2655                 AC_MSG_RESULT(no)
2656         ])
2657
2658         AC_MSG_CHECKING([if linux/ethtool.h has ETHTOOL_xLINKSETTINGS API])
2659         LB_LINUX_TRY_COMPILE([
2660                 #include <linux/ethtool.h>
2661         ],[
2662                 enum ethtool_link_mode_bit_indices x = ETHTOOL_LINK_MODE_TP_BIT;
2663
2664                 return 0;
2665         ],[
2666                 AC_MSG_RESULT(yes)
2667                 AC_DEFINE(HAVE_ETHTOOL_xLINKSETTINGS, 1,
2668                           [ETHTOOL_xLINKSETTINGS API is defined])
2669         ],[
2670                 AC_MSG_RESULT(no)
2671         ])
2672
2673         AC_MSG_CHECKING([if linux/printk.h exists])
2674         LB_LINUX_TRY_COMPILE([
2675                 #include <linux/printk.h>
2676         ],[
2677                 return 0;
2678         ],[
2679                 AC_MSG_RESULT(yes)
2680                 AC_DEFINE(HAVE_LINUX_PRINTK_H, 1,
2681                           [linux/printk.h is defined])
2682         ],[
2683                 AC_MSG_RESULT(no)
2684         ])
2685
2686         AC_MSG_CHECKING([if printk.h has struct va_format])
2687         LB_LINUX_TRY_COMPILE([
2688                 #include <linux/printk.h>
2689         ],[
2690                 struct va_format x;
2691
2692                 return 0;
2693         ],[
2694                 AC_MSG_RESULT(yes)
2695                 AC_DEFINE(HAVE_VA_FORMAT, 1,
2696                           [va_format is defined])
2697         ],[
2698                 AC_MSG_RESULT(no)
2699         ])
2700
2701         AC_MSG_CHECKING([if irq.h irq_data has member affinity])
2702         LB_LINUX_TRY_COMPILE([
2703                 #include <linux/irq.h>
2704                 #include <linux/cpumask.h>
2705         ],[
2706                 cpumask_var_t x;
2707                 struct irq_data y = {
2708                         .affinity = x,
2709                 };
2710
2711                 return 0;
2712         ],[
2713                 AC_MSG_RESULT(yes)
2714                 AC_DEFINE(HAVE_IRQ_DATA_AFFINITY, 1,
2715                           [irq_data member affinity is defined])
2716         ],[
2717                 AC_MSG_RESULT(no)
2718         ])
2719
2720         AC_MSG_CHECKING([if irq.h irq_data_get_affinity_mask])
2721         LB_LINUX_TRY_COMPILE([
2722                 #include <linux/irq.h>
2723         ],[
2724                 irq_data_get_affinity_mask(NULL);
2725
2726                 return 0;
2727         ],[
2728                 AC_MSG_RESULT(yes)
2729                 AC_DEFINE(HAVE_IRQ_DATA_GET_AFFINITY_MASK, 1,
2730                           [irq_data_get_affinity_mask exist])
2731         ],[
2732                 AC_MSG_RESULT(no)
2733         ])
2734
2735         AC_MSG_CHECKING([if netdevice.h has netif_tx_napi_add])
2736         LB_LINUX_TRY_COMPILE([
2737                 #include <linux/netdevice.h>
2738         ],[
2739                 netif_tx_napi_add(NULL, NULL, NULL, 0);
2740
2741                 return 0;
2742         ],[
2743                 AC_MSG_RESULT(yes)
2744                 AC_DEFINE(HAVE_NETIF_TX_NAPI_ADD, 1,
2745                           [netif_tx_napi_add is defined])
2746         ],[
2747                 AC_MSG_RESULT(no)
2748         ])
2749
2750         AC_MSG_CHECKING([if ndo_setup_tc takes 4 parameters])
2751         LB_LINUX_TRY_COMPILE([
2752                 #include <linux/netdevice.h>
2753
2754                 int mlx4_en_setup_tc(struct net_device *dev, u32 handle,
2755                                                          __be16 protocol, struct tc_to_netdev *tc)
2756                 {
2757                         return 0;
2758                 }
2759         ],[
2760                 struct net_device_ops x = {
2761                         .ndo_setup_tc = mlx4_en_setup_tc,
2762                 };
2763
2764                 return 0;
2765         ],[
2766                 AC_MSG_RESULT(yes)
2767                 AC_DEFINE(HAVE_NDO_SETUP_TC_4_PARAMS, 1,
2768                           [ndo_setup_tc takes 4 parameters])
2769         ],[
2770                 AC_MSG_RESULT(no)
2771         ])
2772
2773         AC_MSG_CHECKING([if etherdevice.h has alloc_etherdev_mqs, alloc_etherdev_mqs, num_tc])
2774         LB_LINUX_TRY_COMPILE([
2775                 #include <linux/etherdevice.h>
2776                 #include <linux/netdevice.h>
2777         ],[
2778                 struct net_device x = {
2779                         .num_tx_queues = 0,
2780                         .num_tc = 0,
2781                 };
2782                 alloc_etherdev_mqs(0, 0, 0);
2783
2784                 return 0;
2785         ],[
2786                 AC_MSG_RESULT(yes)
2787                 AC_DEFINE(HAVE_NEW_TX_RING_SCHEME, 1,
2788                           [alloc_etherdev_mqs, alloc_etherdev_mqs, num_tc is defined])
2789         ],[
2790                 AC_MSG_RESULT(no)
2791         ])
2792
2793         AC_MSG_CHECKING([if struct net_device_ops has *ndo_set_tx_maxrate])
2794         LB_LINUX_TRY_COMPILE([
2795                 #include <linux/netdevice.h>
2796         ],[
2797                 struct net_device_ops x = {
2798                         .ndo_set_tx_maxrate = NULL,
2799                 };
2800
2801                 return 0;
2802         ],[
2803                 AC_MSG_RESULT(yes)
2804                 AC_DEFINE(HAVE_NDO_SET_TX_MAXRATE, 1,
2805                           [ndo_set_tx_maxrate is defined])
2806         ],[
2807                 AC_MSG_RESULT(no)
2808         ])
2809
2810         AC_MSG_CHECKING([if struct net_device has gso_partial_features])
2811         LB_LINUX_TRY_COMPILE([
2812                 #include <linux/netdevice.h>
2813         ],[
2814                 struct net_device *dev = NULL;
2815
2816                 dev->gso_partial_features = 0;
2817
2818                 return 0;
2819         ],[
2820                 AC_MSG_RESULT(yes)
2821                 AC_DEFINE(HAVE_NET_DEVICE_GSO_PARTIAL_FEATURES, 1,
2822                           [gso_partial_features is defined])
2823         ],[
2824                 AC_MSG_RESULT(no)
2825         ])
2826
2827         AC_MSG_CHECKING([if vxlan have ndo_add_vxlan_port])
2828         LB_LINUX_TRY_COMPILE([
2829                 #include <linux/netdevice.h>
2830
2831                 #if IS_ENABLED(CONFIG_VXLAN)
2832                 void add_vxlan_port(struct net_device *dev, sa_family_t sa_family, __be16 port)
2833                 {
2834                         return 0;
2835                 }
2836                 #endif
2837         ],[
2838                 struct net_device_ops netdev_ops;
2839                 netdev_ops.ndo_add_vxlan_port = add_vxlan_port;
2840
2841                 return 0;
2842         ],[
2843                 AC_MSG_RESULT(yes)
2844                 AC_DEFINE(HAVE_VXLAN_DYNAMIC_PORT, 1,
2845                         [ndo_add_vxlan_port is defined])
2846         ],[
2847                 AC_MSG_RESULT(no)
2848         ])
2849
2850         AC_MSG_CHECKING([if vxlan has vxlan_get_rx_port])
2851         LB_LINUX_TRY_COMPILE([
2852                 #if IS_ENABLED(CONFIG_VXLAN)
2853                 #include <net/vxlan.h>
2854                 #endif
2855         ],[
2856                 vxlan_get_rx_port(NULL);
2857
2858                 return 0;
2859         ],[
2860                 AC_MSG_RESULT(yes)
2861                 AC_DEFINE(HAVE_VXLAN_ENABLED, 1,
2862                           [vxlan_get_rx_port is defined])
2863         ],[
2864                 AC_MSG_RESULT(no)
2865         ])
2866
2867         AC_MSG_CHECKING([if vxlan have ndo_udp_tunnel_add])
2868         LB_LINUX_TRY_COMPILE([
2869                 #include <linux/netdevice.h>
2870
2871                 #if IS_ENABLED(CONFIG_VXLAN)
2872                 void udp_tunnel_add(struct net_device *dev, sa_family_t sa_family, __be16 port)
2873                 {
2874                         return 0;
2875                 }
2876                 #endif
2877         ],[
2878                 struct net_device_ops netdev_ops;
2879                 netdev_ops.ndo_udp_tunnel_add = udp_tunnel_add;
2880
2881                 return 0;
2882         ],[
2883                 AC_MSG_RESULT(yes)
2884                 AC_DEFINE(HAVE_NDO_UDP_TUNNEL_ADD, 1,
2885                         [ndo_udp_tunnel_add is defined])
2886         ],[
2887                 AC_MSG_RESULT(no)
2888         ])
2889
2890         AC_MSG_CHECKING([if vxlan has udp_tunnel_get_rx_info])
2891         LB_LINUX_TRY_COMPILE([
2892                 #include <net/udp_tunnel.h>
2893         ],[
2894                 udp_tunnel_get_rx_info(NULL);
2895
2896                 return 0;
2897         ],[
2898                 AC_MSG_RESULT(yes)
2899                 AC_DEFINE(HAVE_UDP_TUNNEL_GET_RX_INFO, 1,
2900                           [udp_tunnel_get_rx_info is defined])
2901         ],[
2902                 AC_MSG_RESULT(no)
2903         ])
2904
2905         AC_MSG_CHECKING([if netdevice.h has struct netdev_bonding_info])
2906         LB_LINUX_TRY_COMPILE([
2907                 #include <linux/netdevice.h>
2908         ],[
2909                 struct netdev_bonding_info x;
2910                 x.master.num_slaves = 0;
2911
2912                 return 0;
2913         ],[
2914                 AC_MSG_RESULT(yes)
2915                 AC_DEFINE(HAVE_NETDEV_BONDING_INFO, 1,
2916                           [netdev_bonding_info is defined])
2917         ],[
2918                 AC_MSG_RESULT(no)
2919         ])
2920
2921         AC_MSG_CHECKING([if netdevice.h has struct netdev_phys_item_id])
2922         LB_LINUX_TRY_COMPILE([
2923                 #include <linux/netdevice.h>
2924         ],[
2925                 struct netdev_phys_item_id x;
2926                 x.id_len = 0;
2927
2928                 return 0;
2929         ],[
2930                 AC_MSG_RESULT(yes)
2931                 AC_DEFINE(HAVE_NETDEV_PHYS_ITEM_ID, 1,
2932                           [netdev_phys_item_id is defined])
2933         ],[
2934                 AC_MSG_RESULT(no)
2935         ])
2936
2937         AC_MSG_CHECKING([if struct net_device_ops has *ndo_set_vf_mac])
2938         LB_LINUX_TRY_COMPILE([
2939                 #include <linux/netdevice.h>
2940
2941                 int set_vf_mac(struct net_device *dev, int queue, u8 *mac)
2942                 {
2943                         return 0;
2944                 }
2945         ],[
2946                 struct net_device_ops netdev_ops;
2947                 netdev_ops.ndo_set_vf_mac = set_vf_mac;
2948
2949                 return 0;
2950         ],[
2951                 AC_MSG_RESULT(yes)
2952                 AC_DEFINE(HAVE_NDO_SET_VF_MAC, 1,
2953                           [ndo_set_vf_mac is defined])
2954         ],[
2955                 AC_MSG_RESULT(no)
2956         ])
2957
2958         AC_MSG_CHECKING([if getnumtcs returns int])
2959         LB_LINUX_TRY_COMPILE([
2960                 #include <linux/netdevice.h>
2961                 #include <net/dcbnl.h>
2962
2963                 static int mlx4_en_dcbnl_getnumtcs(struct net_device *netdev, int tcid, u8 *num)
2964
2965                 {
2966                         return 0;
2967                 }
2968
2969         ],[
2970                 struct dcbnl_rtnl_ops mlx4_en_dcbnl_ops = {
2971                         .getnumtcs      = mlx4_en_dcbnl_getnumtcs,
2972                 };
2973
2974                 return 0;
2975         ],[
2976                 AC_MSG_RESULT(yes)
2977                 AC_DEFINE(NDO_GETNUMTCS_RETURNS_INT, 1,
2978                           [if getnumtcs returns int])
2979         ],[
2980                 AC_MSG_RESULT(no)
2981         ])
2982
2983         AC_MSG_CHECKING([if getapp returns int])
2984         LB_LINUX_TRY_COMPILE([
2985                 #include <linux/netdevice.h>
2986                 #include <net/dcbnl.h>
2987
2988                 static int mlx4_en_dcbnl_getapp(struct net_device *netdev, u8 idtype,
2989                                                 u16 id)
2990                 {
2991                         return 0;
2992                 }
2993         ],[
2994                 struct dcbnl_rtnl_ops mlx4_en_dcbnl_ops = {
2995                         .getapp         = mlx4_en_dcbnl_getapp,
2996                 };
2997
2998                 return 0;
2999         ],[
3000                 AC_MSG_RESULT(yes)
3001                 AC_DEFINE(NDO_GETAPP_RETURNS_INT, 1,
3002                           [if getapp returns int])
3003         ],[
3004                 AC_MSG_RESULT(no)
3005         ])
3006
3007         AC_MSG_CHECKING([if setapp returns int])
3008         LB_LINUX_TRY_COMPILE([
3009                 #include <linux/netdevice.h>
3010                 #include <net/dcbnl.h>
3011
3012                 static int mlx4_en_dcbnl_setapp(struct net_device *netdev, u8 idtype,
3013                                                 u16 id, u8 up)
3014                 {
3015                         return 0;
3016                 }
3017
3018         ],[
3019                 struct dcbnl_rtnl_ops mlx4_en_dcbnl_ops = {
3020                         .setapp         = mlx4_en_dcbnl_setapp,
3021                 };
3022
3023                 return 0;
3024         ],[
3025                 AC_MSG_RESULT(yes)
3026                 AC_DEFINE(NDO_SETAPP_RETURNS_INT, 1,
3027                           [if setapp returns int])
3028         ],[
3029                 AC_MSG_RESULT(no)
3030         ])
3031
3032         AC_MSG_CHECKING([if linux/inetdevice.h inet_confirm_addr has 5 parameters])
3033         LB_LINUX_TRY_COMPILE([
3034                 #include <linux/inetdevice.h>
3035         ],[
3036                 inet_confirm_addr(NULL, NULL, 0, 0, 0);
3037
3038                 return 0;
3039         ],[
3040                 AC_MSG_RESULT(yes)
3041                 AC_DEFINE(HAVE_INET_CONFIRM_ADDR_5_PARAMS, 1,
3042                           [inet_confirm_addr has 5 parameters])
3043         ],[
3044                 AC_MSG_RESULT(no)
3045         ])
3046
3047         AC_MSG_CHECKING([if netdevice.h has netdev_rss_key_fill])
3048         LB_LINUX_TRY_COMPILE([
3049                 #include <linux/netdevice.h>
3050         ],[
3051                 netdev_rss_key_fill(NULL, 0);
3052
3053                 return 0;
3054         ],[
3055                 AC_MSG_RESULT(yes)
3056                 AC_DEFINE(HAVE_NETDEV_RSS_KEY_FILL, 1,
3057                           [netdev_rss_key_fill is defined])
3058         ],[
3059                 AC_MSG_RESULT(no)
3060         ])
3061
3062         AC_MSG_CHECKING([if struct net_device_ops has *ndo_get_vf_stats])
3063         LB_LINUX_TRY_COMPILE([
3064                 #include <linux/netdevice.h>
3065
3066                 int get_vf_stats(struct net_device *dev, int vf, struct ifla_vf_stats *vf_stats)
3067                 {
3068                         return 0;
3069                 }
3070         ],[
3071                 struct net_device_ops netdev_ops;
3072                 netdev_ops.ndo_get_vf_stats = get_vf_stats;
3073
3074                 return 0;
3075         ],[
3076                 AC_MSG_RESULT(yes)
3077                 AC_DEFINE(HAVE_NDO_GET_VF_STATS, 1,
3078                           [ndo_get_vf_stats is defined])
3079         ],[
3080                 AC_MSG_RESULT(no)
3081         ])
3082
3083         AC_MSG_CHECKING([if struct net_device_ops has ndo_set_vf_guid])
3084         LB_LINUX_TRY_COMPILE([
3085                 #include <linux/netdevice.h>
3086
3087                 int set_vf_guid(struct net_device *dev, int vf, u64 guid, int guid_type)
3088                 {
3089                         return 0;
3090                 }
3091         ],[
3092                 struct net_device_ops netdev_ops;
3093                 netdev_ops.ndo_set_vf_guid = set_vf_guid;
3094
3095                 return 0;
3096         ],[
3097                 AC_MSG_RESULT(yes)
3098                 AC_DEFINE(HAVE_NDO_SET_VF_GUID, 1,
3099                           [ndo_set_vf_guid is defined])
3100         ],[
3101                 AC_MSG_RESULT(no)
3102         ])
3103
3104         AC_MSG_CHECKING([if netdevice.h has netif_trans_update])
3105         LB_LINUX_TRY_COMPILE([
3106                 #include <linux/netdevice.h>
3107         ],[
3108                 netif_trans_update(NULL);
3109
3110                 return 0;
3111         ],[
3112                 AC_MSG_RESULT(yes)
3113                 AC_DEFINE(HAVE_NETIF_TRANS_UPDATE, 1,
3114                           [netif_trans_update is defined])
3115         ],[
3116                 AC_MSG_RESULT(no)
3117         ])
3118
3119         AC_MSG_CHECKING([if netdevice.h alloc_netdev_mqs has 6 params])
3120         LB_LINUX_TRY_COMPILE([
3121                 #include <linux/netdevice.h>
3122         ],[
3123                 alloc_netdev_mqs(0, NULL, NET_NAME_UNKNOWN, NULL, 0, 0);
3124
3125                 return 0;
3126         ],[
3127                 AC_MSG_RESULT(yes)
3128                 AC_DEFINE(HAVE_ALLOC_NETDEV_MQS_6_PARAMS, 1,
3129                           [alloc_netdev_mqs has 6 params])
3130         ],[
3131                 AC_MSG_RESULT(no)
3132         ])
3133
3134         AC_MSG_CHECKING([if filter.h has XDP])
3135         LB_LINUX_TRY_COMPILE([
3136                 #include <linux/filter.h>
3137         ],[
3138                 enum xdp_action action = XDP_ABORTED;
3139
3140                 return 0;
3141         ],[
3142                 AC_MSG_RESULT(yes)
3143                 AC_DEFINE(HAVE_FILTER_XDP, 1,
3144                           [filter.h has XDP])
3145         ],[
3146                 AC_MSG_RESULT(no)
3147         ])
3148
3149         AC_MSG_CHECKING([if firmware.h has request_firmware_direct])
3150         LB_LINUX_TRY_COMPILE([
3151                 #include <linux/firmware.h>
3152         ],[
3153                 (void)request_firmware_direct(NULL, NULL, NULL);
3154
3155                 return 0;
3156         ],[
3157                 AC_MSG_RESULT(yes)
3158                 AC_DEFINE(HAVE_REQUEST_FIRMWARE_DIRECT, 1,
3159                           [firmware.h has request_firmware_direct])
3160         ],[
3161                 AC_MSG_RESULT(no)
3162         ])
3163
3164         AC_MSG_CHECKING([if pci.h has pci_set_vpd_size])
3165         LB_LINUX_TRY_COMPILE([
3166                 #include <linux/pci.h>
3167         ],[
3168                 (void)pci_set_vpd_size(NULL, 0);
3169
3170                 return 0;
3171         ],[
3172                 AC_MSG_RESULT(yes)
3173                 AC_DEFINE(HAVE_PCI_SET_VPD_SIZE, 1,
3174                           [pci.h has pci_set_vpd_size])
3175         ],[
3176                 AC_MSG_RESULT(no)
3177         ])
3178
3179         AC_MSG_CHECKING([if ethtooL_drvinfo has erom_version])
3180         LB_LINUX_TRY_COMPILE([
3181                 #include <linux/ethtool.h>
3182         ],[
3183                 struct ethtool_drvinfo e;
3184
3185                 return (e.erom_version);
3186         ],[
3187                 AC_MSG_RESULT(yes)
3188                 AC_DEFINE(HAVE_ETHTOOL_DRVINFO_EROM_VERSION, 1,
3189                           [ethtool_drvinfo has erom_version])
3190         ],[
3191                 AC_MSG_RESULT(no)
3192         ])
3193
3194         AC_MSG_CHECKING([if string_helpers.h string_get_size has 5 params])
3195         LB_LINUX_TRY_COMPILE([
3196                 #include <linux/sched.h>
3197                 #include <linux/bug.h>
3198                 #include <linux/kernel.h>
3199                 #include <linux/math64.h>
3200                 #include <linux/export.h>
3201                 #include <linux/ctype.h>
3202                 #include <linux/errno.h>
3203                 #include <linux/string.h>
3204                 #include <linux/string_helpers.h>
3205         ],[
3206                 (void)string_get_size(0, 0, 0, NULL, 0);
3207
3208                 return 0;
3209         ],[
3210                 AC_MSG_RESULT(yes)
3211                 AC_DEFINE(HAVE_STRING_GET_SIZE_5_PARAMS, 1,
3212                           [string_get_size has 5 params])
3213         ],[
3214                 AC_MSG_RESULT(no)
3215         ])
3216
3217         AC_MSG_CHECKING([if debugfs.h debugfs_create_bool has bool pointer])
3218         LB_LINUX_TRY_COMPILE([
3219                 #include <linux/debugfs.h>
3220         ],[
3221                 (void)debugfs_create_bool(NULL, 0, NULL, (bool *)0);
3222
3223                 return 0;
3224         ],[
3225                 AC_MSG_RESULT(yes)
3226                 AC_DEFINE(HAVE_DEBUGFS_CREATE_BOOL_USES_BOOL_PTR, 1,
3227                           [debugfs_create_bool has bool pointer])
3228         ],[
3229                 AC_MSG_RESULT(no)
3230         ])
3231
3232         AC_MSG_CHECKING([if pat_enabled is a function on X86])
3233         LB_LINUX_TRY_COMPILE([
3234 #if defined(CONFIG_X86)
3235                 #include <asm/pat.h>
3236 #else
3237                 #error "Not X86"
3238 #endif
3239         ],[
3240 #if defined(CONFIG_X86)
3241                 if (pat_enabled())
3242                         return 0;
3243 #endif
3244
3245                 return 0;
3246         ],[
3247                 AC_MSG_RESULT(yes)
3248                 AC_DEFINE(HAVE_PAT_ENABLED_FUNCTION_X86, 1,
3249                           [pat_enabled is a function])
3250         ],[
3251                 AC_MSG_RESULT(no)
3252         ])
3253
3254         AC_MSG_CHECKING([if include/net/switchdev.h exists])
3255         LB_LINUX_TRY_COMPILE([
3256                 #include <net/switchdev.h>
3257         ],[
3258                 return 0;
3259         ],[
3260                 AC_MSG_RESULT(yes)
3261                 AC_DEFINE(HAVE_NET_SWITCHDEV_H, 1,
3262                           [include/net/switchdev.h exists])
3263         ],[
3264                 AC_MSG_RESULT(no)
3265         ])
3266
3267         AC_MSG_CHECKING([if net_device_ops has ndo_udp_tunnel_add])
3268         LB_LINUX_TRY_COMPILE([
3269                 #include <linux/netdevice.h>
3270
3271                 void add_udp_tunnel(struct net_device *dev, struct udp_tunnel_info *ti)
3272                 {
3273                         return 0;
3274                 }
3275         ],[
3276                 struct net_device_ops netdev_ops;
3277                 netdev_ops.ndo_udp_tunnel_add = add_udp_tunnel;
3278
3279                 return 0;
3280         ],[
3281                 AC_MSG_RESULT(yes)
3282                 AC_DEFINE(HAVE_NDO_UDP_TUNNEL_ADD, 1,
3283                         [ndo_udp_tunnel_add is defined])
3284         ],[
3285                 AC_MSG_RESULT(no)
3286         ])
3287
3288         AC_MSG_CHECKING([if linux/netdev_features.h has tc offload feature])
3289         LB_LINUX_TRY_COMPILE([
3290                 #include <linux/netdevice.h>
3291         ],[
3292                 netdev_features_t hw_features = NETIF_F_HW_TC;
3293
3294                 return 0;
3295         ],[
3296                 AC_MSG_RESULT(yes)
3297                 AC_DEFINE(HAVE_TC_OFFLOAD, 1,
3298                           [tc offload is supported])
3299         ],[
3300                 AC_MSG_RESULT(no)
3301         ])
3302
3303         AC_MSG_CHECKING([if struct skbuff.h has skb_flow_dissect_flow_keys])
3304         LB_LINUX_TRY_COMPILE([
3305                 #include <linux/skbuff.h>
3306         ],[
3307                 skb_flow_dissect_flow_keys(NULL, NULL, 0);
3308
3309                 return 0;
3310         ],[
3311                 AC_MSG_RESULT(yes)
3312                 AC_DEFINE(HAVE_SKB_FLOW_DISSECT_FLOW_KEYS, 1,
3313                           [skb_flow_dissect_flow_keys is defined])
3314         ],[
3315                 AC_MSG_RESULT(no)
3316         ])
3317
3318         AC_MSG_CHECKING([if workqueue.h has __cancel_delayed_work])
3319         LB_LINUX_TRY_COMPILE([
3320                 #include <linux/workqueue.h>
3321         ],[
3322                 __cancel_delayed_work(NULL);
3323
3324                 return 0;
3325         ],[
3326                 AC_MSG_RESULT(yes)
3327                 AC_DEFINE(HAVE___CANCEL_DELAYED_WORK, 1,
3328                           [__cancel_delayed_work is defined])
3329         ],[
3330                 AC_MSG_RESULT(no)
3331         ])
3332
3333         AC_MSG_CHECKING([if struct ethtool_ops has get/set_priv_flags])
3334         LB_LINUX_TRY_COMPILE([
3335                 #include <linux/ethtool.h>
3336         ],[
3337                 const struct ethtool_ops en_ethtool_ops = {
3338                         .get_priv_flags = NULL,
3339                         .set_priv_flags = NULL,
3340                 };
3341
3342                 return 0;
3343         ],[
3344                 AC_MSG_RESULT(yes)
3345                 AC_DEFINE(HAVE_GET_SET_PRIV_FLAGS, 1,
3346                           [get/set_priv_flags is defined])
3347         ],[
3348                 AC_MSG_RESULT(no)
3349         ])
3350
3351         AC_MSG_CHECKING([if netdevice.h has netdev_get_num_tc])
3352         LB_LINUX_TRY_COMPILE([
3353                 #include <linux/netdevice.h>
3354         ],[
3355                 netdev_get_num_tc(NULL);
3356
3357                 return 0;
3358         ],[
3359                 AC_MSG_RESULT(yes)
3360                 AC_DEFINE(HAVE_NETDEV_GET_NUM_TC, 1,
3361                           [netdev_get_num_tc is defined])
3362         ],[
3363                 AC_MSG_RESULT(no)
3364         ])
3365
3366         AC_MSG_CHECKING([if net_device_ops has ndo_set_vf_trust])
3367         LB_LINUX_TRY_COMPILE([
3368                 #include <linux/netdevice.h>
3369
3370                 int set_vf_trust(struct net_device *dev, int vf, bool setting)
3371                 {
3372                         return 0;
3373                 }
3374         ],[
3375                 struct net_device_ops netdev_ops;
3376
3377                 netdev_ops.ndo_set_vf_trust = set_vf_trust;
3378
3379                 return 0;
3380         ],[
3381                 AC_MSG_RESULT(yes)
3382                 AC_DEFINE(HAVE_NETDEV_OPS_NDO_SET_VF_TRUST, 1,
3383                           [ndo_set_vf_trust is defined in net_device_ops])
3384         ],[
3385                 AC_MSG_RESULT(no)
3386         ])
3387
3388         AC_MSG_CHECKING([if netdev_features.h has NETIF_F_HW_VLAN_STAG_RX])
3389         LB_LINUX_TRY_COMPILE([
3390                 #include <linux/netdev_features.h>
3391         ],[
3392                 netdev_features_t stag = NETIF_F_HW_VLAN_STAG_RX;
3393
3394                 return 0;
3395         ],[
3396                 AC_MSG_RESULT(yes)
3397                 AC_DEFINE(HAVE_NETIF_F_HW_VLAN_STAG_RX, 1,
3398                         [NETIF_F_HW_VLAN_STAG_RX is defined in netdev_features.h])
3399         ],[
3400                 AC_MSG_RESULT(no)
3401         ])
3402
3403         AC_MSG_CHECKING([if struct netdevice.h has NETIF_F_RXHASH])
3404         LB_LINUX_TRY_COMPILE([
3405                 #include <linux/netdevice.h>
3406         ],[