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