compat: Added support for ib_core from kernel 4.8 on RHEL7.2
[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_setup_tc])
1281         LB_LINUX_TRY_COMPILE([
1282                 #include <linux/netdevice.h>
1283         ],[
1284                 struct net_device_ops x = {
1285                         .ndo_setup_tc = NULL,
1286                 };
1287
1288                 return 0;
1289         ],[
1290                 AC_MSG_RESULT(yes)
1291                 AC_DEFINE(HAVE_NDO_SETUP_TC, 1,
1292                           [ndo_setup_tc is defined])
1293         ],[
1294                 AC_MSG_RESULT(no)
1295         ])
1296
1297         AC_MSG_CHECKING([if struct net_device_ops has *ndo_rx_flow_steer])
1298         LB_LINUX_TRY_COMPILE([
1299                 #include <linux/netdevice.h>
1300
1301                 int rx_flow_steer(struct net_device *dev,
1302                                                      const struct sk_buff *skb,
1303                                                      u16 rxq_index,
1304                                                      u32 flow_id)
1305                 {
1306                         return 0;
1307                 }
1308         ],[
1309                 struct net_device_ops netdev_ops;
1310
1311                 netdev_ops.ndo_rx_flow_steer = rx_flow_steer;
1312                 return 0;
1313         ],[
1314                 AC_MSG_RESULT(yes)
1315                 AC_DEFINE(HAVE_NDO_RX_FLOW_STEER, 1,
1316                           [ndo_rx_flow_steer is defined])
1317         ],[
1318                 AC_MSG_RESULT(no)
1319         ])
1320
1321         AC_MSG_CHECKING([if struct net_device has priv_flags])
1322         LB_LINUX_TRY_COMPILE([
1323                 #include <linux/netdevice.h>
1324         ],[
1325                 struct net_device *netdev;
1326                 netdev->priv_flags = 0;
1327
1328                 return 0;
1329         ],[
1330                 AC_MSG_RESULT(yes)
1331                 AC_DEFINE(HAVE_NET_DEVICE_PRIV_FLAGS, 1,
1332                           [priv_flags is defined])
1333         ],[
1334                 AC_MSG_RESULT(no)
1335         ])
1336
1337         AC_MSG_CHECKING([if struct net_device_ops has *ndo_get_stats64])
1338         LB_LINUX_TRY_COMPILE([
1339                 #include <linux/netdevice.h>
1340
1341                 struct rtnl_link_stats64* get_stats_64(struct net_device *dev,
1342                                                      struct rtnl_link_stats64 *storage)
1343                 {
1344                         struct rtnl_link_stats64 stats_64;
1345                         return &stats_64;
1346                 }
1347         ],[
1348                 struct net_device_ops netdev_ops;
1349
1350                 netdev_ops.ndo_get_stats64 = get_stats_64;
1351
1352                 return 0;
1353         ],[
1354                 AC_MSG_RESULT(yes)
1355                 AC_DEFINE(HAVE_NDO_GET_STATS64, 1,
1356                           [ndo_get_stats64 is defined])
1357         ],[
1358                 AC_MSG_RESULT(no)
1359         ])
1360         AC_MSG_CHECKING([if struct net_device_ops has ndo_bridge_set/getlink])
1361         LB_LINUX_TRY_COMPILE([
1362                 #include <linux/netdevice.h>
1363         ],[
1364                 struct net_device_ops netdev_ops =  {
1365                         .ndo_bridge_setlink = NULL,
1366                         .ndo_bridge_getlink = NULL,
1367                 };
1368
1369                 return 0;
1370         ],[
1371                 AC_MSG_RESULT(yes)
1372                 AC_DEFINE(HAVE_NDO_BRIDGE_SET_GET_LINK, 1,
1373                           [ndo_bridge_set/getlink is defined])
1374         ],[
1375                 AC_MSG_RESULT(no)
1376         ])
1377
1378         AC_MSG_CHECKING([if rtnetlink.h ndo_dflt_bridge_getlink has 7 params])
1379         LB_LINUX_TRY_COMPILE([
1380                 #include <linux/rtnetlink.h>
1381         ],[
1382                 ndo_dflt_bridge_getlink(NULL, 0, 0, NULL, 0, 0, 0);
1383
1384                 return 0;
1385         ],[
1386                 AC_MSG_RESULT(yes)
1387                 AC_DEFINE(HAVE_NDO_DFLT_BRIDGE_GETLINK_7_PARAMS, 1,
1388                         [ ndo_dflt_bridge_getlink with 7 params is defined])
1389         ],[
1390                 AC_MSG_RESULT(no)
1391         ])
1392
1393         AC_MSG_CHECKING([if struct net_device_ops ndo_vlan_rx_add_vid has 3 parameters ])
1394         LB_LINUX_TRY_COMPILE([
1395                 #include <linux/netdevice.h>
1396
1397         ],[
1398                 int vlan_rx_add_vid(struct net_device *dev,__be16 proto, u16 vid)
1399                 {
1400                         return 0;
1401                 }
1402                 struct net_device_ops netdev_ops;
1403
1404                 netdev_ops.ndo_vlan_rx_add_vid = vlan_rx_add_vid;
1405                 netdev_ops.ndo_vlan_rx_add_vid (NULL, 1, 1) ;
1406
1407                 return 0;
1408         ],[
1409                 AC_MSG_RESULT(yes)
1410                 AC_DEFINE(HAVE_NDO_RX_ADD_VID_HAS_3_PARAMS, 1,
1411                           [ndo_vlan_rx_add_vid has 3 parameters])
1412         ],[
1413                 AC_MSG_RESULT(no)
1414         ])
1415
1416         AC_MSG_CHECKING([if net_device_ops has ndo_get_phys_port_id])
1417         LB_LINUX_TRY_COMPILE([
1418                 #include <linux/netdevice.h>
1419
1420                 int get_phys_port_id(struct net_device *dev,
1421                                      struct netdev_phys_port_id *ppid)
1422                 {
1423                         return 0;
1424                 }
1425         ],[
1426                 struct net_device_ops netdev_ops;
1427
1428                 netdev_ops.ndo_get_phys_port_id = get_phys_port_id;
1429
1430                 return 0;
1431         ],[
1432                 AC_MSG_RESULT(yes)
1433                 AC_DEFINE(HAVE_NETDEV_NDO_GET_PHYS_PORT_ID, 1,
1434                           [ is defined])
1435         ],[
1436                 AC_MSG_RESULT(no)
1437         ])
1438
1439         AC_MSG_CHECKING([if struct net_device_ops_ext exist])
1440         LB_LINUX_TRY_COMPILE([
1441                 #include <linux/netdevice.h>
1442         ],[
1443                 struct net_device_ops_ext netdev_ops_ext = {
1444                         .size = sizeof(struct net_device_ops_ext),
1445                 };
1446
1447                 return 0;
1448         ],[
1449                 AC_MSG_RESULT(yes)
1450                 AC_DEFINE(HAVE_NET_DEVICE_OPS_EXT, 1,
1451                           [struct net_device_ops_ext is defined])
1452         ],[
1453                 AC_MSG_RESULT(no)
1454         ])
1455
1456         AC_MSG_CHECKING([if net_device_ops_ext has ndo_get_phys_port_id])
1457         LB_LINUX_TRY_COMPILE([
1458                 #include <linux/netdevice.h>
1459
1460                 int get_phys_port_id(struct net_device *dev,
1461                                      struct netdev_phys_port_id *ppid)
1462                 {
1463                         return 0;
1464                 }
1465         ],[
1466                 struct net_device_ops_ext netdev_ops_ext;
1467
1468                 netdev_ops_ext.ndo_get_phys_port_id = get_phys_port_id;
1469
1470                 return 0;
1471         ],[
1472                 AC_MSG_RESULT(yes)
1473                 AC_DEFINE(HAVE_NETDEV_EXT_NDO_GET_PHYS_PORT_ID, 1,
1474                           [ndo_get_phys_port_id is defined])
1475         ],[
1476                 AC_MSG_RESULT(no)
1477         ])
1478
1479         AC_MSG_CHECKING([if net_device_ops has ndo_set_vf_spoofchk])
1480         LB_LINUX_TRY_COMPILE([
1481                 #include <linux/netdevice.h>
1482
1483                 int set_vf_spoofchk(struct net_device *dev, int vf, bool setting)
1484                 {
1485                         return 0;
1486                 }
1487         ],[
1488                 struct net_device_ops netdev_ops;
1489
1490                 netdev_ops.ndo_set_vf_spoofchk = set_vf_spoofchk;
1491
1492                 return 0;
1493         ],[
1494                 AC_MSG_RESULT(yes)
1495                 AC_DEFINE(HAVE_NETDEV_OPS_NDO_SET_VF_SPOOFCHK, 1,
1496                           [ndo_set_vf_spoofchk is defined in net_device_ops])
1497         ],[
1498                 AC_MSG_RESULT(no)
1499         ])
1500
1501         AC_MSG_CHECKING([if net_device_ops_ext has ndo_set_vf_spoofchk])
1502         LB_LINUX_TRY_COMPILE([
1503                 #include <linux/netdevice.h>
1504
1505                 int set_vf_spoofchk(struct net_device *dev, int vf, bool setting)
1506                 {
1507                         return 0;
1508                 }
1509         ],[
1510                 struct net_device_ops_ext netdev_ops_ext;
1511
1512                 netdev_ops_ext.ndo_set_vf_spoofchk = set_vf_spoofchk;
1513
1514                 return 0;
1515         ],[
1516                 AC_MSG_RESULT(yes)
1517                 AC_DEFINE(HAVE_NETDEV_OPS_EXT_NDO_SET_VF_SPOOFCHK, 1,
1518                           [ndo_set_vf_spoofchk is defined in net_device_ops_ext])
1519         ],[
1520                 AC_MSG_RESULT(no)
1521         ])
1522
1523         AC_MSG_CHECKING([if net_device_ops has ndo_set_vf_link_state])
1524         LB_LINUX_TRY_COMPILE([
1525                 #include <linux/netdevice.h>
1526
1527                 int set_vf_link_state(struct net_device *dev, int vf, int link_state)
1528                 {
1529                         return 0;
1530                 }
1531         ],[
1532                 struct net_device_ops netdev_ops;
1533
1534                 netdev_ops.ndo_set_vf_link_state = set_vf_link_state;
1535
1536                 return 0;
1537         ],[
1538                 AC_MSG_RESULT(yes)
1539                 AC_DEFINE(HAVE_NETDEV_OPS_NDO_SET_VF_LINK_STATE, 1,
1540                           [ndo_set_vf_link_state is defined in net_device_ops])
1541         ],[
1542                 AC_MSG_RESULT(no)
1543         ])
1544
1545         AC_MSG_CHECKING([if net_device_ops_ext has ndo_set_vf_link_state])
1546         LB_LINUX_TRY_COMPILE([
1547                 #include <linux/netdevice.h>
1548
1549                 int set_vf_link_state(struct net_device *dev, int vf, int link_state)
1550                 {
1551                         return 0;
1552                 }
1553         ],[
1554                 struct net_device_ops_ext netdev_ops_ext;
1555
1556                 netdev_ops_ext.ndo_set_vf_link_state = set_vf_link_state;
1557
1558                 return 0;
1559         ],[
1560                 AC_MSG_RESULT(yes)
1561                 AC_DEFINE(HAVE_NETDEV_OPS_EXT_NDO_SET_VF_LINK_STATE, 1,
1562                           [ndo_set_vf_link_state is defined])
1563         ],[
1564                 AC_MSG_RESULT(no)
1565         ])
1566
1567
1568         AC_MSG_CHECKING([if netdevice.h netif_set_real_num_tx_queues returns int])
1569         LB_LINUX_TRY_COMPILE([
1570                 #include <linux/netdevice.h>
1571         ],[
1572                 struct net_device dev;
1573                 int ret;
1574                 ret = netif_set_real_num_tx_queues(&dev, 2);
1575                 return 0;
1576         ],[
1577                 AC_MSG_RESULT(yes)
1578                 AC_DEFINE(HAVE_RETURN_INT_FOR_SET_NUM_TX_QUEUES, 1,
1579                           [netif_set_real_num_tx_queues returns int])
1580         ],[
1581                 AC_MSG_RESULT(no)
1582         ])
1583
1584         AC_MSG_CHECKING([if struct netdevice.h has struct xps_map])
1585         LB_LINUX_TRY_COMPILE([
1586                 #include <linux/netdevice.h>
1587         ],[
1588                 struct xps_map map;
1589                 map.len = 0;
1590
1591                 return 0;
1592         ],[
1593                 AC_MSG_RESULT(yes)
1594                 AC_DEFINE(HAVE_XPS_MAP, 1,
1595                           [struct xps_map is defined])
1596         ],[
1597                 AC_MSG_RESULT(no)
1598         ])
1599
1600         AC_MSG_CHECKING([if struct ethtool_ops has set_phys_id])
1601         LB_LINUX_TRY_COMPILE([
1602                 #include <linux/ethtool.h>
1603         ],[
1604                 const struct ethtool_ops en_ethtool_ops = {
1605                         .set_phys_id= NULL,
1606                 };
1607
1608                 return 0;
1609         ],[
1610                 AC_MSG_RESULT(yes)
1611                 AC_DEFINE(HAVE_SET_PHYS_ID, 1,
1612                           [set_phys_id is defined])
1613         ],[
1614                 AC_MSG_RESULT(no)
1615         ])
1616
1617         AC_MSG_CHECKING([if struct ethtool_ops has get/set_channels])
1618         LB_LINUX_TRY_COMPILE([
1619                 #include <linux/ethtool.h>
1620         ],[
1621                 const struct ethtool_ops en_ethtool_ops = {
1622                         .get_channels = NULL,
1623                         .set_channels = NULL,
1624                 };
1625
1626                 return 0;
1627         ],[
1628                 AC_MSG_RESULT(yes)
1629                 AC_DEFINE(HAVE_GET_SET_CHANNELS, 1,
1630                           [get/set_channels is defined])
1631         ],[
1632                 AC_MSG_RESULT(no)
1633         ])
1634
1635         AC_MSG_CHECKING([if struct ethtool_ops_ext has get/set_channels])
1636         LB_LINUX_TRY_COMPILE([
1637                 #include <linux/ethtool.h>
1638         ],[
1639                 const struct ethtool_ops_ext en_ethtool_ops_ext = {
1640                         .get_channels = NULL,
1641                         .set_channels = NULL,
1642                 };
1643
1644                 return 0;
1645         ],[
1646                 AC_MSG_RESULT(yes)
1647                 AC_DEFINE(HAVE_GET_SET_CHANNELS_EXT, 1,
1648                           [get/set_channels is defined in ethtool_ops_ext])
1649         ],[
1650                 AC_MSG_RESULT(no)
1651         ])
1652
1653         AC_MSG_CHECKING([if struct ethtool_ops has get_ts_info])
1654         LB_LINUX_TRY_COMPILE([
1655                 #include <linux/ethtool.h>
1656         ],[
1657                 const struct ethtool_ops en_ethtool_ops = {
1658                         .get_ts_info = NULL,
1659                 };
1660
1661                 return 0;
1662         ],[
1663                 AC_MSG_RESULT(yes)
1664                 AC_DEFINE(HAVE_GET_TS_INFO, 1,
1665                           [get_ts_info is defined])
1666         ],[
1667                 AC_MSG_RESULT(no)
1668         ])
1669
1670         AC_MSG_CHECKING([if struct ethtool_ops has set_dump])
1671         LB_LINUX_TRY_COMPILE([
1672                 #include <linux/ethtool.h>
1673         ],[
1674                 const struct ethtool_ops en_ethtool_ops = {
1675                         .set_dump = NULL,
1676                 };
1677
1678                 return 0;
1679         ],[
1680                 AC_MSG_RESULT(yes)
1681                 AC_DEFINE(HAVE_ETHTOOL_OPS_SET_DUMP, 1,
1682                           [set_dump is defined])
1683         ],[
1684                 AC_MSG_RESULT(no)
1685         ])
1686
1687         AC_MSG_CHECKING([if struct ethtool_ops has get_module_info])
1688         LB_LINUX_TRY_COMPILE([
1689                 #include <linux/ethtool.h>
1690         ],[
1691                 const struct ethtool_ops en_ethtool_ops = {
1692                         .get_module_info = NULL,
1693                 };
1694
1695                 return 0;
1696         ],[
1697                 AC_MSG_RESULT(yes)
1698                 AC_DEFINE(HAVE_ETHTOOL_OPS_GET_MODULE_INFO, 1,
1699                           [get_module_info is defined])
1700         ],[
1701                 AC_MSG_RESULT(no)
1702         ])
1703
1704         AC_MSG_CHECKING([if struct ethtool_ops has get_module_eeprom])
1705         LB_LINUX_TRY_COMPILE([
1706                 #include <linux/ethtool.h>
1707         ],[
1708                 const struct ethtool_ops en_ethtool_ops = {
1709                         .get_module_eeprom = NULL,
1710                 };
1711
1712                 return 0;
1713         ],[
1714                 AC_MSG_RESULT(yes)
1715                 AC_DEFINE(HAVE_ETHTOOL_OPS_GET_MODULE_EEPROM, 1,
1716                           [get_module_eeprom is defined])
1717         ],[
1718                 AC_MSG_RESULT(no)
1719         ])
1720
1721         AC_MSG_CHECKING([if struct ethtool_ops_ext has get_ts_info])
1722         LB_LINUX_TRY_COMPILE([
1723                 #include <linux/ethtool.h>
1724         ],[
1725                 const struct ethtool_ops_ext en_ethtool_ops_ext = {
1726                         .get_ts_info = NULL,
1727                 };
1728
1729                 return 0;
1730         ],[
1731                 AC_MSG_RESULT(yes)
1732                 AC_DEFINE(HAVE_GET_TS_INFO_EXT, 1,
1733                           [get_ts_info is defined in ethtool_ops_ext])
1734         ],[
1735                 AC_MSG_RESULT(no)
1736         ])
1737
1738         AC_MSG_CHECKING([if struct ethtool_flow_ext has h_dest])
1739         LB_LINUX_TRY_COMPILE([
1740                 #include <linux/ethtool.h>
1741         ],[
1742                 unsigned char mac[ETH_ALEN];
1743                 struct ethtool_flow_ext h_ext;
1744
1745                 memcpy(&mac, h_ext.h_dest, ETH_ALEN);
1746
1747                 return 0;
1748         ],[
1749                 AC_MSG_RESULT(yes)
1750                 AC_DEFINE(HAVE_ETHTOOL_FLOW_EXT_H_DEST, 1,
1751                           [ethtool_flow_ext has h_dest])
1752         ],[
1753                 AC_MSG_RESULT(no)
1754         ])
1755
1756         AC_MSG_CHECKING([if netdevice.h has struct dev_addr_list])
1757         LB_LINUX_TRY_COMPILE([
1758                 #include <linux/netdevice.h>
1759         ],[
1760                 struct dev_addr_list addr;
1761                 return 0;
1762         ],[
1763                 AC_MSG_RESULT(yes)
1764                 AC_DEFINE(HAVE_NETDEV_DEV_ADDR, 1,
1765                           [dev_addr_list is defined])
1766         ],[
1767                 AC_MSG_RESULT(no)
1768         ])
1769
1770         AC_MSG_CHECKING([if pci.h has pci_vfs_assigned])
1771         LB_LINUX_TRY_COMPILE([
1772                 #include <linux/pci.h>
1773         ],[
1774                 struct pci_dev pdev;
1775                 pci_vfs_assigned(&pdev);
1776                 return 0;
1777         ],[
1778                 AC_MSG_RESULT(yes)
1779                 AC_DEFINE(HAVE_PCI_VF_ASSIGNED, 1,
1780                           [pci_vfs_assigned is defined])
1781         ],[
1782                 AC_MSG_RESULT(no)
1783         ])
1784
1785         AC_MSG_CHECKING([if vlan_insert_tag_set_proto is defined])
1786         LB_LINUX_TRY_COMPILE([
1787                 #include <linux/if_vlan.h>
1788         ],[
1789                 struct sk_buff *skb;
1790                 vlan_insert_tag_set_proto(skb, 0, 0);
1791                 return 0;
1792         ],[
1793                 AC_MSG_RESULT(yes)
1794                 AC_DEFINE(HAVE_VLAN_INSERT_TAG_SET_PROTO, 1,
1795                           [vlan_insert_tag_set_proto is defined])
1796         ],[
1797                 AC_MSG_RESULT(no)
1798                 AC_MSG_CHECKING([if __vlan_put_tag has 3 parameters])
1799                 LB_LINUX_TRY_COMPILE([
1800                         #include <linux/if_vlan.h>
1801                 ],[
1802                         struct sk_buff *skb;
1803                         __vlan_put_tag(skb, 0, 0);
1804                         return 0;
1805                 ],[
1806                         AC_MSG_RESULT(yes)
1807                         AC_DEFINE(HAVE_3_PARAMS_FOR_VLAN_PUT_TAG, 1,
1808                                   [__vlan_put_tag has 3 parameters])
1809                 ],[
1810                         AC_MSG_RESULT(no)
1811                 ])
1812         ])
1813
1814         AC_MSG_CHECKING([if __vlan_hwaccel_put_tag has 3 parameters])
1815         LB_LINUX_TRY_COMPILE([
1816                 #include <linux/if_vlan.h>
1817         ],[
1818                 struct sk_buff *skb;
1819                 __vlan_hwaccel_put_tag(skb, 0, 0);
1820
1821                 return 0;
1822         ],[
1823                 AC_MSG_RESULT(yes)
1824                 AC_DEFINE(HAVE_3_PARAMS_FOR_VLAN_HWACCEL_PUT_TAG, 1,
1825                           [__vlan_hwaccel_put_tag has 3 parameters])
1826         ],[
1827                 AC_MSG_RESULT(no)
1828         ])
1829
1830         AC_MSG_CHECKING([if struct inet6_ifaddr has if_next])
1831         LB_LINUX_TRY_COMPILE([
1832                 #include <net/if_inet6.h>
1833         ],[
1834                 struct inet6_ifaddr ifp ;
1835                 ifp.if_next = 0;
1836
1837                 return 0;
1838         ],[
1839                 AC_MSG_RESULT(yes)
1840                 AC_DEFINE(HAVE_INETADDR_IF_NEXT, 1,
1841                           [if_next is defined])
1842         ],[
1843                 AC_MSG_RESULT(no)
1844         ])
1845
1846         AC_MSG_CHECKING([if struct net_device has hw_features])
1847         LB_LINUX_TRY_COMPILE([
1848                 #include <linux/netdevice.h>
1849         ],[
1850                 struct net_device dev;
1851                 dev.hw_features = 0;
1852
1853                 return 0;
1854         ],[
1855                 AC_MSG_RESULT(yes)
1856                 AC_DEFINE(HAVE_NETDEV_HW_FEATURES, 1,
1857                           [hw_features is defined])
1858         ],[
1859                 AC_MSG_RESULT(no)
1860         ])
1861
1862         AC_MSG_CHECKING([if struct net_device has hw_enc_features])
1863         LB_LINUX_TRY_COMPILE([
1864                 #include <linux/netdevice.h>
1865         ],[
1866                 struct net_device dev;
1867                 dev.hw_enc_features = 0;
1868
1869                 return 0;
1870         ],[
1871                 AC_MSG_RESULT(yes)
1872                 AC_DEFINE(HAVE_NETDEV_HW_ENC_FEATURES, 1,
1873                           [hw_enc_features is defined])
1874         ],[
1875                 AC_MSG_RESULT(no)
1876         ])
1877
1878         AC_MSG_CHECKING([if struct net_device has rx_cpu_rmap])
1879         LB_LINUX_TRY_COMPILE([
1880                 #include <linux/netdevice.h>
1881         ],[
1882                 struct net_device dev;
1883                 dev.rx_cpu_rmap = NULL;
1884
1885                 return 0;
1886         ],[
1887                 AC_MSG_RESULT(yes)
1888                 AC_DEFINE(HAVE_NETDEV_RX_CPU_RMAP, 1,
1889                           [rx_cpu_rmap is defined])
1890         ],[
1891                 AC_MSG_RESULT(no)
1892         ])
1893
1894         AC_MSG_CHECKING([if if_vlan.h has vlan_hwaccel_receive_skb])
1895         LB_LINUX_TRY_COMPILE([
1896                 #include <linux/if_vlan.h>
1897         ],[
1898                 struct sk_buff *skb;
1899                 vlan_hwaccel_receive_skb(skb,0,0);
1900                 return 0;
1901         ],[
1902                 AC_MSG_RESULT(yes)
1903                 AC_DEFINE(HAVE_VLAN_HWACCEL_RECEIVE_SKB, 1,
1904                           [vlan_hwaccel_receive_skb is defined])
1905         ],[
1906                 AC_MSG_RESULT(no)
1907         ])
1908
1909         AC_MSG_CHECKING([if irqdesc.h has irq_desc_get_irq_data])
1910         LB_LINUX_TRY_COMPILE([
1911                 #include <linux/irq.h>
1912                 #include <linux/irqdesc.h>
1913         ],[
1914                 struct irq_desc desc;
1915                 struct irq_data *data = irq_desc_get_irq_data(&desc);
1916
1917                 return 0;
1918         ],[
1919                 AC_MSG_RESULT(yes)
1920                 AC_DEFINE(HAVE_IRQ_DESC_GET_IRQ_DATA, 1,
1921                           [irq_desc_get_irq_data is defined])
1922         ],[
1923                 AC_MSG_RESULT(no)
1924         ])
1925
1926
1927         AC_MSG_CHECKING([if pci_dev has pcie_mpss])
1928         LB_LINUX_TRY_COMPILE([
1929                 #include <linux/pci.h>
1930         ],[
1931                 struct pci_dev *pdev;
1932
1933                 pdev->pcie_mpss = 0;
1934                 return 0;
1935         ],[
1936                 AC_MSG_RESULT(yes)
1937                 AC_DEFINE(HAVE_PCI_DEV_PCIE_MPSS, 1,
1938                           [pcie_mpss is defined])
1939         ],[
1940                 AC_MSG_RESULT(no)
1941         ])
1942
1943         AC_MSG_CHECKING([if uapi/linux/if_ether.h exist])
1944         LB_LINUX_TRY_COMPILE([
1945                 #include <uapi/linux/if_ether.h>
1946         ],[
1947                 return 0;
1948         ],[
1949                 AC_MSG_RESULT(yes)
1950                 AC_DEFINE(HAVE_UAPI_LINUX_IF_ETHER_H, 1,
1951                           [uapi/linux/if_ether.h exist])
1952         ],[
1953                 AC_MSG_RESULT(no)
1954         ])
1955
1956         AC_MSG_CHECKING([if ifla_vf_info has spoofchk])
1957         LB_LINUX_TRY_COMPILE([
1958                 #include <linux/if_link.h>
1959         ],[
1960                 struct ifla_vf_info *ivf;
1961
1962                 ivf->spoofchk = 0;
1963                 return 0;
1964         ],[
1965                 AC_MSG_RESULT(yes)
1966                 AC_DEFINE(HAVE_VF_INFO_SPOOFCHK, 1,
1967                           [spoofchk is defined])
1968         ],[
1969                 AC_MSG_RESULT(no)
1970         ])
1971
1972         AC_MSG_CHECKING([if vxlan.h has vxlan_gso_check])
1973         LB_LINUX_TRY_COMPILE([
1974                 #include <net/vxlan.h>
1975         ],[
1976                 vxlan_gso_check(NULL);
1977
1978                 return 0;
1979         ],[
1980                 AC_MSG_RESULT(yes)
1981                 AC_DEFINE(HAVE_VXLAN_GSO_CHECK, 1,
1982                           [vxlan_gso_check is defined])
1983         ],[
1984                 AC_MSG_RESULT(no)
1985         ])
1986
1987         AC_MSG_CHECKING([if dst.h has dst_get_neighbour])
1988         LB_LINUX_TRY_COMPILE([
1989                 #include <net/dst.h>
1990         ],[
1991                 struct neighbour *neigh = dst_get_neighbour(NULL);
1992
1993                 return 0;
1994         ],[
1995                 AC_MSG_RESULT(yes)
1996                 AC_DEFINE(HAVE_DST_GET_NEIGHBOUR, 1,
1997                           [ is defined])
1998         ],[
1999                 AC_MSG_RESULT(no)
2000         ])
2001
2002         AC_MSG_CHECKING([if netlink_dump_start has 6 parameters])
2003         LB_LINUX_TRY_COMPILE([
2004                 #include <linux/netlink.h>
2005         ],[
2006                 int ret = netlink_dump_start(NULL, NULL, NULL, NULL, NULL, 0);
2007
2008                 return 0;
2009         ],[
2010                 AC_MSG_RESULT(yes)
2011                 AC_DEFINE(HAVE_NETLINK_DUMP_START_6P, 1,
2012                           [ is defined])
2013         ],[
2014                 AC_MSG_RESULT(no)
2015         ])
2016
2017         AC_MSG_CHECKING([if netlink_dump_start has 5 parameters])
2018         LB_LINUX_TRY_COMPILE([
2019                 #include <linux/netlink.h>
2020         ],[
2021                 int ret = netlink_dump_start(NULL, NULL, NULL, NULL, NULL);
2022
2023                 return 0;
2024         ],[
2025                 AC_MSG_RESULT(yes)
2026                 AC_DEFINE(HAVE_NETLINK_DUMP_START_5P, 1,
2027                           [ is defined])
2028         ],[
2029                 AC_MSG_RESULT(no)
2030         ])
2031
2032         AC_MSG_CHECKING([if struct dcbnl_rtnl_ops has ieee_getmaxrate/ieee_setmaxrate])
2033         LB_LINUX_TRY_COMPILE([
2034                 #include <net/dcbnl.h>
2035         ],[
2036                 const struct dcbnl_rtnl_ops en_dcbnl_ops = {
2037                         .ieee_getmaxrate = NULL,
2038                         .ieee_setmaxrate = NULL,
2039                 };
2040
2041                 return 0;
2042         ],[
2043                 AC_MSG_RESULT(yes)
2044                 AC_DEFINE(HAVE_IEEE_GET_SET_MAXRATE, 1,
2045                           [ieee_getmaxrate/ieee_setmaxrate is defined])
2046         ],[
2047                 AC_MSG_RESULT(no)
2048         ])
2049
2050         AC_LANG_PUSH(C)
2051         ac_c_werror_flag=yes
2052         save_EXTRA_KCFLAGS=$EXTRA_KCFLAGS
2053         EXTRA_KCFLAGS="$EXTRA_KCFLAGS -Werror"
2054
2055         AC_MSG_CHECKING([if bonding.h bond_for_each_slave has int for 3rd parameter])
2056         LB_LINUX_TRY_COMPILE([
2057                 #include <net/bonding.h>
2058         ],[
2059                 struct bonding *bond = NULL;
2060                 struct slave *slave = NULL;
2061                 int iter;
2062
2063                 bond_for_each_slave(bond, slave, iter) ;
2064
2065                 return 0;
2066         ],[
2067                 AC_MSG_RESULT(yes)
2068                 AC_DEFINE(HAVE_BOND_FOR_EACH_SLAVE_3RD_PARAM_IS_INT, 1,
2069                           [bond_for_each_slave has int for 3rd parameter])
2070         ],[
2071                 AC_MSG_RESULT(no)
2072         ])
2073         EXTRA_KCFLAGS="$save_EXTRA_KCFLAGS"
2074         ac_c_werror_flag=
2075         AC_LANG_POP
2076
2077         AC_MSG_CHECKING([if netdevice.h has netdev_master_upper_dev_get_rcu])
2078         LB_LINUX_TRY_COMPILE([
2079                 #include <linux/netdevice.h>
2080         ],[
2081                 netdev_master_upper_dev_get_rcu(NULL);
2082
2083                 return 0;
2084         ],[
2085                 AC_MSG_RESULT(yes)
2086                 AC_DEFINE(HAVE_NETDEV_MASTER_UPPER_DEV_GET_RCU, 1,
2087                           [netdev_master_upper_dev_get_rcu is defined])
2088         ],[
2089                 AC_MSG_RESULT(no)
2090         ])
2091
2092         AC_MSG_CHECKING([if __vlan_find_dev_deep has 3 parameters])
2093         LB_LINUX_TRY_COMPILE([
2094                 #include <linux/if_vlan.h>
2095         ],[
2096                 __vlan_find_dev_deep(NULL, 0, 0);
2097
2098                 return 0;
2099         ],[
2100                 AC_MSG_RESULT(yes)
2101                 AC_DEFINE(HAVE__VLAN_FIND_DEV_DEEP_3P, 1,
2102                           [__vlan_find_dev_deep has 3 paramters])
2103         ],[
2104                 AC_MSG_RESULT(no)
2105         ])
2106
2107         AC_MSG_CHECKING([if sk_buff.h has __skb_alloc_page])
2108         LB_LINUX_TRY_COMPILE([
2109                 #include <linux/skbuff.h>
2110         ],[
2111                 __skb_alloc_page(0, NULL);
2112
2113                 return 0;
2114         ],[
2115                 AC_MSG_RESULT(yes)
2116                 AC_DEFINE(HAVE__SKB_ALLOC_PAGE, 1,
2117                           [sk_buff has __skb_alloc_page])
2118         ],[
2119                 AC_MSG_RESULT(no)
2120         ])
2121
2122         AC_MSG_CHECKING([if __vlan_hwaccel_put_tag has 3 parameters])
2123         LB_LINUX_TRY_COMPILE([
2124                 #include <linux/if_vlan.h>
2125         ],[
2126                 __vlan_hwaccel_put_tag(NULL, 0, 0);
2127
2128                 return 0;
2129         ],[
2130                 AC_MSG_RESULT(yes)
2131                 AC_DEFINE(HAVE__VLAN_HWACCEL_PUT_TAG_3P, 1,
2132                           [__vlan_hwaccel_put_tag has 3 paramters])
2133         ],[
2134                 AC_MSG_RESULT(no)
2135         ])
2136
2137         AC_MSG_CHECKING([if linux/mm_types.h has struct page_frag])
2138         LB_LINUX_TRY_COMPILE([
2139                 #include <linux/mm_types.h>
2140         ],[
2141                 struct page_frag frag = {0};
2142
2143                 return 0;
2144         ],[
2145                 AC_MSG_RESULT(yes)
2146                 AC_DEFINE(HAVE_MM_TYPES_PAGE_FRAG, 1,
2147                           [linux/mm_types.h has struct page_frag])
2148         ],[
2149                 AC_MSG_RESULT(no)
2150         ])
2151
2152         AC_MSG_CHECKING([if if_vlan.h has __vlan_find_dev_deep])
2153         LB_LINUX_TRY_COMPILE([
2154                 #include <linux/if_vlan.h>
2155         ],[
2156                 __vlan_find_dev_deep(NULL, 0);
2157
2158                 return 0;
2159         ],[
2160                 AC_MSG_RESULT(yes)
2161                 AC_DEFINE(HAVE___VLAN_FIND_DEV_DEEP, 1,
2162                           [__vlan_find_dev_deep is defined])
2163         ],[
2164                 AC_MSG_RESULT(no)
2165         ])
2166
2167         AC_MSG_CHECKING([if idr .h has idr_Alloc])
2168         LB_LINUX_TRY_COMPILE([
2169                 #include <linux/idr.h>
2170         ],[
2171                 idr_alloc(NULL, NULL, 0, 0, 0);
2172                 return 0;
2173         ],[
2174                 AC_MSG_RESULT(yes)
2175                 AC_DEFINE(HAVE_IDR_NEW_INTERFACE, 1,
2176                           [idr_Alloc is defined]) ],[
2177                 AC_MSG_RESULT(no)
2178         ])
2179
2180         AC_MSG_CHECKING([if completion.h has reinit_completion])
2181         LB_LINUX_TRY_COMPILE([
2182                 #include <linux/completion.h>
2183         ],[
2184                 struct completion c;
2185
2186                 reinit_completion(&c);
2187                 return 0;
2188         ],[
2189                 AC_MSG_RESULT(yes)
2190                 AC_DEFINE(HAVE_REINIT_COMPLETION, 1,
2191                           [reinit_completion is defined])
2192         ],[
2193                 AC_MSG_RESULT(no)
2194         ])
2195
2196         AC_MSG_CHECKING([if dma-mapping.h has dma_set_mask_and_coherent])
2197         LB_LINUX_TRY_COMPILE([
2198                 #include <linux/dma-mapping.h>
2199         ],[
2200                 dma_set_mask_and_coherent(NULL, 0);
2201
2202                 return 0;
2203         ],[
2204                 AC_MSG_RESULT(yes)
2205                 AC_DEFINE(HAVE_DMA_SET_MASK_AND_COHERENT, 1,
2206                           [dma_set_mask_and_coherent is defined])
2207         ],[
2208                 AC_MSG_RESULT(no)
2209         ])
2210
2211         AC_MSG_CHECKING([if in.h has proto_ports_offset])
2212         LB_LINUX_TRY_COMPILE([
2213                 #include <linux/in.h>
2214         ],[
2215                 int x = proto_ports_offset(IPPROTO_TCP);
2216                 return 0;
2217         ],[
2218                 AC_MSG_RESULT(yes)
2219                 AC_DEFINE(HAVE_PROTO_PORTS_OFFSET, 1,
2220                           [proto_ports_offset is defined])
2221         ],[
2222                 AC_MSG_RESULT(no)
2223         ])
2224
2225         LB_CHECK_SYMBOL_EXPORT([elfcorehdr_addr],
2226                 [kernel/crash_dump.c],
2227                 [AC_DEFINE(HAVE_ELFCOREHDR_ADDR_EXPORTED, 1,
2228                         [elfcorehdr_addr is exported by the kernel])],
2229         [])
2230
2231         AC_MSG_CHECKING([if netif_set_real_num_rx_queues is defined])
2232         LB_LINUX_TRY_COMPILE([
2233                 #include <linux/netdevice.h>
2234         ],[
2235                 int rc = netif_set_real_num_rx_queues(NULL, 0);
2236
2237                 return rc;
2238         ],[
2239                 AC_MSG_RESULT(yes)
2240                 AC_DEFINE(HAVE_NETIF_SET_REAL_NUM_RX_QUEUES, 1,
2241                           [netif_set_real_num_rx_queues is defined])
2242         ],[
2243                 AC_MSG_RESULT(no)
2244         ])
2245
2246         AC_MSG_CHECKING([if if_vlan.h has is_vlan_dev])
2247         LB_LINUX_TRY_COMPILE([
2248                 #include <linux/netdevice.h>
2249                 #include <linux/if_vlan.h>
2250         ],[
2251                 struct net_device dev;
2252                 is_vlan_dev(&dev);
2253
2254                 return 0;
2255         ],[
2256                 AC_MSG_RESULT(yes)
2257                 AC_DEFINE(HAVE_IS_VLAN_DEV, 1,
2258                           [is_vlan_dev is defined])
2259         ],[
2260                 AC_MSG_RESULT(no)
2261         ])
2262
2263         AC_MSG_CHECKING([if linux/timecounter.h exists])
2264         LB_LINUX_TRY_COMPILE([
2265                 #include <linux/timecounter.h>
2266         ],[
2267                 return 0;
2268         ],[
2269                 AC_MSG_RESULT(yes)
2270                 AC_DEFINE(HAVE_TIMECOUNTER_H, 1,
2271                           [linux/timecounter.h exists])
2272         ],[
2273                 AC_MSG_RESULT(no)
2274         ])
2275
2276         # timecounter_adjtime can be in timecounter.h or clocksource.h
2277         AC_MSG_CHECKING([if linux/clocksource.h has timecounter_adjtime])
2278         LB_LINUX_TRY_COMPILE([
2279                 #include <linux/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/ip_fib.h>
2508         ],[
2509                 fib_lookup(NULL, NULL, NULL, 0);
2510
2511                 return 0;
2512         ],[
2513                 AC_MSG_RESULT(yes)
2514                 AC_DEFINE(HAVE_FIB_LOOKUP_4_PARAMS, 1,
2515                           [fib_lookup has 4 params])
2516         ],[
2517                 AC_MSG_RESULT(no)
2518         ])
2519
2520         AC_MSG_CHECKING([if include/net/devlink.h exists])
2521         LB_LINUX_TRY_COMPILE([
2522                 #include <net/devlink.h>
2523         ],[
2524                 return 0;
2525         ],[
2526                 AC_MSG_RESULT(yes)
2527                 AC_DEFINE(HAVE_NET_DEVLINK_H, 1,
2528                           [include/net/devlink.h exists])
2529         ],[
2530                 AC_MSG_RESULT(no)
2531         ])
2532
2533         AC_MSG_CHECKING([if io_mapping_map_wc has 3 params])
2534         LB_LINUX_TRY_COMPILE([
2535                 #include <linux/io-mapping.h>
2536         ],[
2537                 io_mapping_map_wc(NULL, 0, 0);
2538
2539                 return 0;
2540         ],[
2541                 AC_MSG_RESULT(yes)
2542                 AC_DEFINE(HAVE_IO_MAPPING_MAP_WC_3_PARAMS, 1,
2543                           [io_mapping_map_wc has 3 params])
2544         ],[
2545                 AC_MSG_RESULT(no)
2546         ])
2547
2548         AC_MSG_CHECKING([if include/net/dcbnl.h struct dcbnl_rtnl_ops has *ieee_getqcn])
2549         LB_LINUX_TRY_COMPILE([
2550                 #include <linux/netdevice.h>
2551                 #include <net/dcbnl.h>
2552         ],[
2553                 struct dcbnl_rtnl_ops x = {
2554                         .ieee_getqcn = NULL,
2555                 };
2556
2557                 return 0;
2558         ],[
2559                 AC_MSG_RESULT(yes)
2560                 AC_DEFINE(HAVE_IEEE_GETQCN, 1,
2561                           [ieee_getqcn is defined])
2562         ],[
2563                 AC_MSG_RESULT(no)
2564         ])
2565
2566         AC_MSG_CHECKING([if dcbnl.h has struct ieee_qcn])
2567         LB_LINUX_TRY_COMPILE([
2568                 #include <linux/netdevice.h>
2569                 #include <net/dcbnl.h>
2570         ],[
2571                 struct ieee_qcn x;
2572
2573                 return 0;
2574         ],[
2575                 AC_MSG_RESULT(yes)
2576                 AC_DEFINE(HAVE_STRUCT_IEEE_QCN, 1,
2577                           [ieee_qcn is defined])
2578         ],[
2579                 AC_MSG_RESULT(no)
2580         ])
2581
2582         AC_MSG_CHECKING([if netdevice.h has napi_consume_skb])
2583         LB_LINUX_TRY_COMPILE([
2584                 #include <linux/skbuff.h>
2585         ],[
2586                 napi_consume_skb(NULL, 0);
2587
2588                 return 0;
2589         ],[
2590                 AC_MSG_RESULT(yes)
2591                 AC_DEFINE(HAVE_NAPI_CONSUME_SKB, 1,
2592                           [napi_consume_skb is defined])
2593         ],[
2594                 AC_MSG_RESULT(no)
2595         ])
2596
2597         AC_MSG_CHECKING([if include/linux/bpf.h exists])
2598         LB_LINUX_TRY_COMPILE([
2599                 #include <linux/bpf.h>
2600         ],[
2601                 return 0;
2602         ],[
2603                 AC_MSG_RESULT(yes)
2604                 AC_DEFINE(HAVE_LINUX_BPF_H, 1,
2605                           [include/linux/bpf.h exists])
2606         ],[
2607                 AC_MSG_RESULT(no)
2608         ])
2609
2610         AC_MSG_CHECKING([if mm_types.h struct page has _count])
2611         LB_LINUX_TRY_COMPILE([
2612                 #include <linux/mm.h>
2613                 #include <linux/mm_types.h>
2614         ],[
2615                 struct page p;
2616                 p._count.counter = 0;
2617
2618                 return 0;
2619         ],[
2620                 AC_MSG_RESULT(yes)
2621                 AC_DEFINE(HAVE_MM_PAGE__COUNT, 1,
2622                           [struct page has _count])
2623         ],[
2624                 AC_MSG_RESULT(no)
2625         ])
2626
2627         AC_MSG_CHECKING([if include/linux/page_ref.h exists])
2628         LB_LINUX_TRY_COMPILE([
2629                 #include <linux/page_ref.h>
2630         ],[
2631                 return 0;
2632         ],[
2633                 AC_MSG_RESULT(yes)
2634                 AC_DEFINE(HAVE_LINUX_PAGE_REF_H, 1,
2635                           [include/linux/page_ref.h exists])
2636         ],[
2637                 AC_MSG_RESULT(no)
2638         ])
2639
2640         AC_MSG_CHECKING([if linux/ethtool.h has ETHTOOL_xLINKSETTINGS API])
2641         LB_LINUX_TRY_COMPILE([
2642                 #include <linux/ethtool.h>
2643         ],[
2644                 enum ethtool_link_mode_bit_indices x = ETHTOOL_LINK_MODE_TP_BIT;
2645
2646                 return 0;
2647         ],[
2648                 AC_MSG_RESULT(yes)
2649                 AC_DEFINE(HAVE_ETHTOOL_xLINKSETTINGS, 1,
2650                           [ETHTOOL_xLINKSETTINGS API is defined])
2651         ],[
2652                 AC_MSG_RESULT(no)
2653         ])
2654
2655         AC_MSG_CHECKING([if linux/printk.h exists])
2656         LB_LINUX_TRY_COMPILE([
2657                 #include <linux/printk.h>
2658         ],[
2659                 return 0;
2660         ],[
2661                 AC_MSG_RESULT(yes)
2662                 AC_DEFINE(HAVE_LINUX_PRINTK_H, 1,
2663                           [linux/printk.h is defined])
2664         ],[
2665                 AC_MSG_RESULT(no)
2666         ])
2667
2668         AC_MSG_CHECKING([if printk.h has struct va_format])
2669         LB_LINUX_TRY_COMPILE([
2670                 #include <linux/printk.h>
2671         ],[
2672                 struct va_format x;
2673
2674                 return 0;
2675         ],[
2676                 AC_MSG_RESULT(yes)
2677                 AC_DEFINE(HAVE_VA_FORMAT, 1,
2678                           [va_format is defined])
2679         ],[
2680                 AC_MSG_RESULT(no)
2681         ])
2682
2683         AC_MSG_CHECKING([if irq.h irq_data has member affinity])
2684         LB_LINUX_TRY_COMPILE([
2685                 #include <linux/irq.h>
2686                 #include <linux/cpumask.h>
2687         ],[
2688                 cpumask_var_t x;
2689                 struct irq_data y = {
2690                         .affinity = x,
2691                 };
2692
2693                 return 0;
2694         ],[
2695                 AC_MSG_RESULT(yes)
2696                 AC_DEFINE(HAVE_IRQ_DATA_AFFINITY, 1,
2697                           [irq_data member affinity is defined])
2698         ],[
2699                 AC_MSG_RESULT(no)
2700         ])
2701
2702         AC_MSG_CHECKING([if irq.h irq_data_get_affinity_mask])
2703         LB_LINUX_TRY_COMPILE([
2704                 #include <linux/irq.h>
2705         ],[
2706                 irq_data_get_affinity_mask(NULL);
2707
2708                 return 0;
2709         ],[
2710                 AC_MSG_RESULT(yes)
2711                 AC_DEFINE(HAVE_IRQ_DATA_GET_AFFINITY_MASK, 1,
2712                           [irq_data_get_affinity_mask exist])
2713         ],[
2714                 AC_MSG_RESULT(no)
2715         ])
2716
2717 ])
2718 #
2719 # COMPAT_CONFIG_HEADERS
2720 #
2721 # add -include config.h
2722 #
2723 AC_DEFUN([COMPAT_CONFIG_HEADERS],[
2724         AC_CONFIG_HEADERS([config.h])
2725         EXTRA_KCFLAGS="-include $PWD/config.h $EXTRA_KCFLAGS"
2726         AC_SUBST(EXTRA_KCFLAGS)
2727 ])
2728
2729 AC_DEFUN([OFA_PROG_LINUX],
2730 [
2731
2732 LB_LINUX_PATH
2733 LB_LINUX_SYMVERFILE
2734 LB_LINUX_CONFIG([MODULES],[],[
2735     AC_MSG_ERROR([module support is required to build mlnx kernel modules.])
2736 ])
2737 LB_LINUX_CONFIG([MODVERSIONS])
2738 LB_LINUX_CONFIG([KALLSYMS],[],[
2739     AC_MSG_ERROR([compat_mlnx requires that CONFIG_KALLSYMS is enabled in your kernel.])
2740 ])
2741
2742 LINUX_CONFIG_COMPAT
2743 COMPAT_CONFIG_HEADERS
2744
2745 ])