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