rdma.m4: remove dulpications
[~tnikolova/compat/.git] / config / rdma.m4
1 dnl Checks for the in-box ib_core
2 AC_DEFUN([RDMA_CONFIG_COMPAT],
3 [
4         AC_MSG_CHECKING([if ib_verbs has ib_dma_map_single])
5         LB_LINUX_TRY_COMPILE([
6                 #include <linux/version.h>
7                 #include <linux/pci.h>
8                 #include <linux/gfp.h>
9                 #include <rdma/ib_verbs.h>
10         ],[
11                 ib_dma_map_single(NULL, NULL, 0, 0);
12                 return 0;
13         ],[
14                 AC_MSG_RESULT(yes)
15                 AC_DEFINE(HAVE_INBOX_IB_DMA_MAP, 1,
16                           [ib_dma_map_single defined])
17         ],[
18                 AC_MSG_RESULT(no)
19         ])
20
21         AC_MSG_CHECKING([if ib_create_cq wants comp_vector])
22         LB_LINUX_TRY_COMPILE([
23                 #include <linux/version.h>
24                 #include <linux/pci.h>
25                 #include <linux/gfp.h>
26                 #include <rdma/ib_verbs.h>
27         ],[
28                 ib_create_cq(NULL, NULL, NULL, NULL, 0, 0);
29                 return 0;
30         ],[
31                 AC_MSG_RESULT(yes)
32                 AC_DEFINE(HAVE_INBOX_IB_COMP_VECTOR, 1,
33                           [has completion vector])
34         ],[
35                 AC_MSG_RESULT(no)
36         ])
37
38         AC_MSG_CHECKING([if rdma_cm has RDMA_CM_EVENT_ADDR_CHANGE])
39         LB_LINUX_TRY_COMPILE([
40                 #include <linux/version.h>
41                 #include <linux/pci.h>
42                 #include <linux/gfp.h>
43                 #include <rdma/rdma_cm.h>
44         ],[
45                 return (RDMA_CM_EVENT_ADDR_CHANGE == 0);
46         ],[
47                 AC_MSG_RESULT(yes)
48                 AC_DEFINE(HAVE_INBOX_RDMA_CMEV_ADDRCHANGE, 1,
49                           [has completion vector])
50         ],[
51                 AC_MSG_RESULT(no)
52         ])
53
54         AC_MSG_CHECKING([if rdma_cm has RDMA_CM_EVENT_TIMEWAIT_EXIT])
55         LB_LINUX_TRY_COMPILE([
56                 #include <linux/version.h>
57                 #include <linux/pci.h>
58                 #include <linux/gfp.h>
59                 #include <rdma/rdma_cm.h>
60         ],[
61                 return (RDMA_CM_EVENT_TIMEWAIT_EXIT == 0);
62         ],[
63                 AC_MSG_RESULT(yes)
64                 AC_DEFINE(HAVE_INBOX_RDMA_CMEV_TIMEWAIT_EXIT, 1,
65                           [has completion vector])
66         ],[
67                 AC_MSG_RESULT(no)
68         ])
69
70         AC_MSG_CHECKING([if rdma_cm has rdma_set_reuseaddr])
71         LB_LINUX_TRY_COMPILE([
72                 #include <linux/version.h>
73                 #include <linux/pci.h>
74                 #include <linux/gfp.h>
75                 #include <rdma/rdma_cm.h>
76         ],[
77                 rdma_set_reuseaddr(NULL, 1);
78                 return 0;
79         ],[
80                 AC_MSG_RESULT(yes)
81                 AC_DEFINE(HAVE_INBOX_RDMA_SET_REUSEADDR, 1,
82                           [rdma_set_reuse defined])
83         ],[
84                 AC_MSG_RESULT(no)
85         ])
86
87         AC_MSG_CHECKING([if struct ib_wc has member named ts])
88         LB_LINUX_TRY_COMPILE([
89                 #include <linux/version.h>
90                 #include <rdma/ib_verbs.h>
91         ],[
92         struct ib_wc wc;
93         wc->ts.timestamp = 0;
94
95                 return 0;
96         ],[
97                 AC_MSG_RESULT(yes)
98                 AC_DEFINE(HAVE_INBOX_IB_WC_TS, 1,
99                           [ib_wc has member named ts])
100         ],[
101                 AC_MSG_RESULT(no)
102         ])
103
104         AC_MSG_CHECKING([if struct ib_ah_attr has member named dmac])
105         LB_LINUX_TRY_COMPILE([
106                 #include <linux/version.h>
107                 #include <rdma/ib_verbs.h>
108         ],[
109         struct ib_ah_attr *ah_attr;
110         memset(ah_attr->dmac, 0, 6);
111
112                 return 0;
113         ],[
114                 AC_MSG_RESULT(yes)
115                 AC_DEFINE(HAVE_INBOX_IB_AH_ATTR_DMAC, 1,
116                           [ah_attr has member named dmac])
117         ],[
118                 AC_MSG_RESULT(no)
119         ])
120
121         AC_MSG_CHECKING([if struct ib_ah_attr has member named vlan_id])
122         LB_LINUX_TRY_COMPILE([
123                 #include <linux/version.h>
124                 #include <rdma/ib_verbs.h>
125         ],[
126         struct ib_ah_attr *ah_attr;
127         ah_attr->vlan_id = 0;
128
129                 return 0;
130         ],[
131                 AC_MSG_RESULT(yes)
132                 AC_DEFINE(HAVE_INBOX_IB_AH_ATTR_VLAN_ID, 1,
133                           [ah_attr has member named vlan_id])
134         ],[
135                 AC_MSG_RESULT(no)
136         ])
137 ])
138
139 dnl Examine kernel functionality
140 AC_DEFUN([LINUX_CONFIG_COMPAT],
141 [
142         AC_MSG_CHECKING([if file_system_type has mount method])
143         LB_LINUX_TRY_COMPILE([
144                 #include <linux/fs.h>
145         ],[
146                 struct file_system_type fst;
147
148                 fst.mount = NULL;
149                 return 0;
150         ],[
151                 AC_MSG_RESULT(yes)
152                 AC_DEFINE(HAVE_MOUNT_METHOD, 1,
153                           [mount method defined])
154         ],[
155                 AC_MSG_RESULT(no)
156         ])
157
158         AC_MSG_CHECKING([if kernel has get_next_ino])
159         LB_LINUX_TRY_COMPILE([
160                 #include <linux/fs.h>
161         ],[
162                 unsigned int ino;
163
164                 ino = get_next_ino();
165                 return 0;
166         ],[
167                 AC_MSG_RESULT(yes)
168                 AC_DEFINE(HAVE_GET_NEXT_INO, 1,
169                           [get_next_ino defined])
170         ],[
171                 AC_MSG_RESULT(no)
172         ])
173
174         AC_MSG_CHECKING([if kernel has ktime_get_ns])
175         LB_LINUX_TRY_COMPILE([
176                 #include <linux/ktime.h>
177         ],[
178                 unsigned long long ns;
179
180                 ns = ktime_get_ns();
181                 return 0;
182         ],[
183                 AC_MSG_RESULT(yes)
184                 AC_DEFINE(HAVE_KTIME_GET_NS, 1,
185                           [ktime_get_ns defined])
186         ],[
187                 AC_MSG_RESULT(no)
188         ])
189
190         AC_MSG_CHECKING([if svc_xprt_class has xcl_ident])
191         LB_LINUX_TRY_COMPILE([
192                 #include <linux/sunrpc/xprt.h>
193                 #include <linux/sunrpc/svc_xprt.h>
194         ],[
195                 struct svc_xprt_class svc_rdma_class = {
196                         .xcl_ident = XPRT_TRANSPORT_RDMA,
197                 };
198                 return 0;
199         ],[
200                 AC_MSG_RESULT(yes)
201                 AC_DEFINE(HAVE_XCL_IDENT, 1,
202                           [xcl_ident defined])
203         ],[
204                 AC_MSG_RESULT(no)
205         ])
206
207         AC_MSG_CHECKING([if struct ifla_vf_info has max_tx_rate])
208         LB_LINUX_TRY_COMPILE([
209                 #include <linux/if_link.h>
210         ],[
211                 struct ifla_vf_info *ivf;
212
213                 ivf->max_tx_rate = 0;
214                 ivf->min_tx_rate = 0;
215
216                 return 0;
217         ],[
218                 AC_MSG_RESULT(yes)
219                 AC_DEFINE(HAVE_TX_RATE_LIMIT, 1,
220                           [max_tx_rate is defined])
221         ],[
222                 AC_MSG_RESULT(no)
223         ])
224
225         AC_MSG_CHECKING([if struct ethtool_ops has get/set_rxfh])
226         LB_LINUX_TRY_COMPILE([
227                 #include <linux/ethtool.h>
228         ],[
229                 const struct ethtool_ops en_ethtool_ops = {
230                         .get_rxfh_key_size = NULL,
231                         .get_rxfh = NULL,
232                         .set_rxfh = NULL,
233                 };
234
235                 return 0;
236         ],[
237                 AC_MSG_RESULT(yes)
238                 AC_DEFINE(HAVE_GET_SET_RXFH, 1,
239                           [get/set_rxfh is defined])
240         ],[
241                 AC_MSG_RESULT(no)
242         ])
243
244         AC_MSG_CHECKING([if struct ethtool_ops has get_rxfh_indir_size])
245         LB_LINUX_TRY_COMPILE([
246                 #include <linux/ethtool.h>
247         ],[
248                 const struct ethtool_ops en_ethtool_ops = {
249                         .get_rxfh_indir_size = NULL,
250                 };
251
252                 return 0;
253         ],[
254                 AC_MSG_RESULT(yes)
255                 AC_DEFINE(HAVE_RXFH_INDIR_SIZE, 1,
256                         [get_rxfh_indir_size is defined])
257         ],[
258                 AC_MSG_RESULT(no)
259         ])
260
261         AC_MSG_CHECKING([if struct ethtool_ops_ext has get_rxfh_indir_size])
262         LB_LINUX_TRY_COMPILE([
263                 #include <linux/ethtool.h>
264         ],[
265                 const struct ethtool_ops_ext en_ethtool_ops_ext = {
266                         .get_rxfh_indir_size = NULL,
267                 };
268
269                 return 0;
270         ],[
271                 AC_MSG_RESULT(yes)
272                 AC_DEFINE(HAVE_RXFH_INDIR_SIZE_EXT, 1,
273                         [get_rxfh_indir_size is defined in ethtool_ops_ext])
274         ],[
275                 AC_MSG_RESULT(no)
276         ])
277
278         AC_MSG_CHECKING([if struct ethtool_ops has get/set_rxfh_indir])
279         LB_LINUX_TRY_COMPILE([
280                 #include <linux/ethtool.h>
281
282                 int mlx4_en_get_rxfh_indir(struct net_device *d, u32 *r)
283                 {
284                         return 0;
285                 }
286         ],[
287                 struct ethtool_ops en_ethtool_ops;
288                 en_ethtool_ops.get_rxfh_indir = mlx4_en_get_rxfh_indir;
289
290                 return 0;
291         ],[
292                 AC_MSG_RESULT(yes)
293                 AC_DEFINE(HAVE_GET_SET_RXFH_INDIR, 1,
294                         [get/set_rxfh_indir is defined])
295         ],[
296                 AC_MSG_RESULT(no)
297         ])
298
299         AC_MSG_CHECKING([if struct ethtool_ops has get/set_tunable])
300         LB_LINUX_TRY_COMPILE([
301                 #include <linux/ethtool.h>
302         ],[
303                 const struct ethtool_ops en_ethtool_ops = {
304                         .get_tunable = NULL,
305                         .set_tunable = NULL,
306                 };
307
308                 return 0;
309         ],[
310                 AC_MSG_RESULT(yes)
311                 AC_DEFINE(HAVE_GET_SET_TUNABLE, 1,
312                           [get/set_tunable is defined])
313         ],[
314                 AC_MSG_RESULT(no)
315         ])
316
317         AC_MSG_CHECKING([if exist struct ethtool_ops_ext])
318         LB_LINUX_TRY_COMPILE([
319                 #include <linux/ethtool.h>
320         ],[
321                 const struct ethtool_ops_ext en_ethtool_ops_ext = {
322                         .size = sizeof(struct ethtool_ops_ext),
323                 };
324
325                 return 0;
326         ],[
327                 AC_MSG_RESULT(yes)
328                 AC_DEFINE(HAVE_ETHTOOL_OPS_EXT, 1,
329                           [struct ethtool_ops_ext is defined])
330         ],[
331                 AC_MSG_RESULT(no)
332         ])
333
334         AC_MSG_CHECKING([if struct ethtool_ops_ext has get/set_rxfh_indir])
335         LB_LINUX_TRY_COMPILE([
336                 #include <linux/ethtool.h>
337         ],[
338                 const struct ethtool_ops_ext en_ethtool_ops_ext = {
339                         .get_rxfh_indir = NULL,
340                         .set_rxfh_indir = NULL,
341                 };
342
343                 return 0;
344         ],[
345                 AC_MSG_RESULT(yes)
346                 AC_DEFINE(HAVE_GET_SET_RXFH_INDIR_EXT, 1,
347                           [get/set_rxfh_indir is defined])
348         ],[
349                 AC_MSG_RESULT(no)
350         ])
351
352         AC_MSG_CHECKING([if struct net_device has dev_port])
353         LB_LINUX_TRY_COMPILE([
354                 #include <linux/netdevice.h>
355         ],[
356                 struct net_device *dev = NULL;
357
358                 dev->dev_port = 0;
359
360                 return 0;
361         ],[
362                 AC_MSG_RESULT(yes)
363                 AC_DEFINE(HAVE_NET_DEVICE_DEV_PORT, 1,
364                           [dev_port is defined])
365         ],[
366                 AC_MSG_RESULT(no)
367         ])
368
369         AC_MSG_CHECKING([if struct ptp_clock_info has n_pins])
370         LB_LINUX_TRY_COMPILE([
371                 #include <linux/ptp_clock_kernel.h>
372         ],[
373                 struct ptp_clock_info *info;
374                 info->n_pins = 0;
375
376                 return 0;
377         ],[
378                 AC_MSG_RESULT(yes)
379                 AC_DEFINE(HAVE_PTP_CLOCK_INFO_N_PINS, 1,
380                           [n_pins is defined])
381         ],[
382                 AC_MSG_RESULT(no)
383         ])
384
385         AC_MSG_CHECKING([if pci.h pci_enable_msi_exact])
386         LB_LINUX_TRY_COMPILE([
387                 #include <linux/pci.h>
388         ],[
389                 int x = pci_enable_msi_exact(NULL, 0);
390
391                 return 0;
392         ],[
393                 AC_MSG_RESULT(yes)
394                 AC_DEFINE(HAVE_PCI_ENABLE_MSI_EXACT, 1,
395                           [pci_enable_msi_exact is defined])
396         ],[
397                 AC_MSG_RESULT(no)
398         ])
399
400         AC_MSG_CHECKING([if pci.h pci_enable_msix_range])
401         LB_LINUX_TRY_COMPILE([
402                 #include <linux/pci.h>
403         ],[
404                 int x = pci_enable_msix_range(NULL, 0, 0, 0);
405
406                 return 0;
407         ],[
408                 AC_MSG_RESULT(yes)
409                 AC_DEFINE(HAVE_PCI_ENABLE_MSIX_RANGE, 1,
410                           [pci_enable_msix_range is defined])
411         ],[
412                 AC_MSG_RESULT(no)
413         ])
414
415         AC_MSG_CHECKING([if pci.h pci_msix_vec_count])
416         LB_LINUX_TRY_COMPILE([
417                 #include <linux/pci.h>
418         ],[
419                 int x = pci_msix_vec_count(NULL);
420
421                 return 0;
422         ],[
423                 AC_MSG_RESULT(yes)
424                 AC_DEFINE(HAVE_PCI_MSIX_VEC_COUNT, 1,
425                           [pci_msix_vec_count is defined])
426         ],[
427                 AC_MSG_RESULT(no)
428         ])
429
430         AC_MSG_CHECKING([if pci_dev has msix_cap])
431         LB_LINUX_TRY_COMPILE([
432                 #include <linux/pci.h>
433         ],[
434                 struct pci_dev pdev;
435                 pdev.msix_cap = 0;
436
437                 return 0;
438         ],[
439                 AC_MSG_RESULT(yes)
440                 AC_DEFINE(HAVE_PCI_MSIX_CAP, 1,
441                           [msix_cap is defined])
442         ],[
443                 AC_MSG_RESULT(no)
444         ])
445
446         AC_MSG_CHECKING([if mm_struct has pinned_vm])
447         LB_LINUX_TRY_COMPILE([
448                 #include <linux/mm_types.h>
449         ],[
450                 struct mm_types mmt;
451                 mmt.pinned_vm = 0;
452
453                 return 0;
454         ],[
455                 AC_MSG_RESULT(yes)
456                 AC_DEFINE(HAVE_PINNED_VM, 1,
457                           [pinned_vm is defined])
458         ],[
459                 AC_MSG_RESULT(no)
460         ])
461
462         AC_MSG_CHECKING([if kernel has idr_alloc])
463         LB_LINUX_TRY_COMPILE([
464                 #include <linux/idr.h>
465         ],[
466                 int x;
467                 x =  idr_alloc(NULL, NULL, 0, 0, 0);
468
469                 return 0;
470         ],[
471                 AC_MSG_RESULT(yes)
472                 AC_DEFINE(HAVE_IDR_ALLOC, 1,
473                           [idr_alloc is defined])
474         ],[
475                 AC_MSG_RESULT(no)
476         ])
477
478         AC_MSG_CHECKING([if kernel has percpu variables])
479         LB_LINUX_TRY_COMPILE([
480                 #include <linux/percpu.h>
481         ],[
482                 static DEFINE_PER_CPU(unsigned int, x);
483                 this_cpu_inc(x);
484
485                 return 0;
486         ],[
487                 AC_MSG_RESULT(yes)
488                 AC_DEFINE(HAVE_PERCPU_VARS, 1,
489                           [percpu variables are defined])
490         ],[
491                 AC_MSG_RESULT(no)
492         ])
493
494         AC_MSG_CHECKING([if struct iscsi_transport has attr_is_visible])
495         LB_LINUX_TRY_COMPILE([
496                 #include <scsi/scsi_transport_iscsi.h>
497         ],[
498                 static struct iscsi_transport iscsi_iser_transport = {
499                         .attr_is_visible = NULL,
500                 };
501
502                 return 0;
503         ],[
504                 AC_MSG_RESULT(yes)
505                 AC_DEFINE(HAVE_ISCSI_ATTR_IS_VISIBLE, 1,
506                           [attr_is_visible is defined])
507         ],[
508                 AC_MSG_RESULT(no)
509         ])
510
511         AC_MSG_CHECKING([if struct iscsi_transport has get_ep_param])
512         LB_LINUX_TRY_COMPILE([
513                 #include <scsi/scsi_transport_iscsi.h>
514         ],[
515                 static struct iscsi_transport iscsi_iser_transport = {
516                         .get_ep_param = NULL,
517                 };
518
519                 return 0;
520         ],[
521                 AC_MSG_RESULT(yes)
522                 AC_DEFINE(HAVE_ISCSI_GET_EP_PARAM, 1,
523                           [get_ep_param is defined])
524         ],[
525                 AC_MSG_RESULT(no)
526         ])
527
528         AC_MSG_CHECKING([if struct iscsi_transport has check_protection])
529         LB_LINUX_TRY_COMPILE([
530                 #include <scsi/scsi_transport_iscsi.h>
531         ],[
532                 static struct iscsi_transport iscsi_iser_transport = {
533                         .check_protection = NULL,
534                 };
535
536                 return 0;
537         ],[
538                 AC_MSG_RESULT(yes)
539                 AC_DEFINE(HAVE_ISCSI_CHECK_PROTECTION, 1,
540                           [check_protection is defined])
541         ],[
542                 AC_MSG_RESULT(no)
543         ])
544
545         AC_MSG_CHECKING([if iscsi_proto.h has struct iscsi_scsi_req])
546         LB_LINUX_TRY_COMPILE([
547                 #include <scsi/iscsi_proto.h>
548         ],[
549                 struct iscsi_scsi_req req = {
550                         .opcode = 0,
551                 };
552
553                 return 0;
554         ],[
555                 AC_MSG_RESULT(yes)
556                 AC_DEFINE(HAVE_ISCSI_SCSI_REQ, 1,
557                           [struct iscsi_scsi_req is defined])
558         ],[
559                 AC_MSG_RESULT(no)
560         ])
561
562         AC_MSG_CHECKING([if struct request_queue has request_fn_active])
563         LB_LINUX_TRY_COMPILE([
564                 #include <linux/blkdev.h>
565         ],[
566                 struct request_queue rq = {
567                         .request_fn_active = 0,
568                 };
569
570                 return 0;
571         ],[
572                 AC_MSG_RESULT(yes)
573                 AC_DEFINE(HAVE_REQUEST_QUEUE_REQUEST_FN_ACTIVE, 1,
574                           [struct request_queue has request_fn_active])
575         ],[
576                 AC_MSG_RESULT(no)
577         ])
578
579         AC_MSG_CHECKING([if netdevice.h has select_queue_fallback_t])
580         LB_LINUX_TRY_COMPILE([
581                 #include <linux/netdevice.h>
582         ],[
583                 select_queue_fallback_t fallback;
584
585                 fallback = NULL;
586
587                 return 0;
588         ],[
589                 AC_MSG_RESULT(yes)
590                 AC_DEFINE(HAVE_SELECT_QUEUE_FALLBACK_T, 1,
591                           [select_queue_fallback_t is defined])
592         ],[
593                 AC_MSG_RESULT(no)
594         ])
595
596         AC_MSG_CHECKING([if netdevice.h has skb_set_hash])
597         LB_LINUX_TRY_COMPILE([
598                 #include <linux/netdevice.h>
599         ],[
600                 skb_set_hash(NULL, 0, PKT_HASH_TYPE_L3);
601
602                 return 0;
603         ],[
604                 AC_MSG_RESULT(yes)
605                 AC_DEFINE(HAVE_SKB_SET_HASH, 1,
606                           [skb_set_hash is defined])
607         ],[
608                 AC_MSG_RESULT(no)
609         ])
610
611         AC_MSG_CHECKING([if netdevice.h has alloc_netdev with 4 params])
612         LB_LINUX_TRY_COMPILE([
613                 #include <linux/netdevice.h>
614         ],[
615                 struct net_device *dev;
616
617                 dev = alloc_netdev(0, NULL, 0, NULL);
618
619                 return 0;
620         ],[
621                 AC_MSG_RESULT(yes)
622                 AC_DEFINE(HAVE_ALLOC_NETDEV_4P, 1,
623                           [alloc_netdev has 4 parameters])
624         ],[
625                 AC_MSG_RESULT(no)
626         ])
627
628         AC_MSG_CHECKING([if sockios.h has SIOCGHWTSTAMP])
629         LB_LINUX_TRY_COMPILE([
630                 #include <linux/sockios.h>
631         ],[
632                 int x = SIOCGHWTSTAMP;
633
634                 return 0;
635         ],[
636                 AC_MSG_RESULT(yes)
637                 AC_DEFINE(HAVE_SIOCGHWTSTAMP, 1,
638                           [SIOCGHWTSTAMP is defined])
639         ],[
640                 AC_MSG_RESULT(no)
641         ])
642
643         AC_MSG_CHECKING([if ip.h inet_get_local_port_range has 3 parameters])
644         LB_LINUX_TRY_COMPILE([
645                 #include <net/ip.h>
646         ],[
647                 inet_get_local_port_range(NULL, NULL, NULL);
648
649                 return 0;
650         ],[
651                 AC_MSG_RESULT(yes)
652                 AC_DEFINE(HAVE_INET_GET_LOCAL_PORT_RANGE_3_PARAMS, 1,
653                           [inet_get_local_port_range has 3 parameters])
654         ],[
655                 AC_MSG_RESULT(no)
656         ])
657
658         AC_MSG_CHECKING([if net.h has net_get_random_once])
659         LB_LINUX_TRY_COMPILE([
660                 #include <linux/net.h>
661         ],[
662                 net_get_random_once(NULL, 0);
663
664                 return 0;
665         ],[
666                 AC_MSG_RESULT(yes)
667                 AC_DEFINE(HAVE_NET_GET_RANDOM_ONCE, 1,
668                           [net_get_random_once is defined])
669         ],[
670                 AC_MSG_RESULT(no)
671         ])
672
673         AC_MSG_CHECKING([if inet_sock.h has __inet_ehashfn])
674         LB_LINUX_TRY_COMPILE([
675                 #include <net/inet_sock.h>
676         ],[
677                 __inet_ehashfn(0, 0, 0, 0, 0);
678
679                 return 0;
680         ],[
681                 AC_MSG_RESULT(yes)
682                 AC_DEFINE(HAVE_INET_EHASHFN, 1,
683                           [__inet_ehashfn is defined])
684         ],[
685                 AC_MSG_RESULT(no)
686         ])
687
688         AC_MSG_CHECKING([if err.h has PTR_ERR_OR_ZERO])
689         LB_LINUX_TRY_COMPILE([
690                 #include <linux/err.h>
691         ],[
692                 int x = PTR_ERR_OR_ZERO(NULL);
693
694                 return 0;
695         ],[
696                 AC_MSG_RESULT(yes)
697                 AC_DEFINE(HAVE_PTR_ERR_OR_ZERO, 1,
698                           [PTR_ERR_OR_ZERO is defined])
699         ],[
700                 AC_MSG_RESULT(no)
701         ])
702
703         AC_MSG_CHECKING([if struct iscsi_session has discovery_sess])
704         LB_LINUX_TRY_COMPILE([
705                 #include <scsi/libiscsi.h>
706         ],[
707                 struct iscsi_session session;
708                 session.discovery_sess = 0;
709
710                 return 0;
711         ],[
712                 AC_MSG_RESULT(yes)
713                 AC_DEFINE(HAVE_ISCSI_DISCOVERY_SESS, 1,
714                           [discovery_sess is defined])
715         ],[
716                 AC_MSG_RESULT(no)
717         ])
718
719         AC_MSG_CHECKING([if enum iscsi_param has ISCSI_PARAM_DISCOVERY_SESS])
720         LB_LINUX_TRY_COMPILE([
721                 #include <scsi/iscsi_if.h>
722         ],[
723                 int x = ISCSI_PARAM_DISCOVERY_SESS;
724
725                 return 0;
726         ],[
727                 AC_MSG_RESULT(yes)
728                 AC_DEFINE(HAVE_ISCSI_PARAM_DISCOVERY_SESS, 1,
729                           [ISCSI_PARAM_DISCOVERY_SESS is defined])
730         ],[
731                 AC_MSG_RESULT(no)
732         ])
733
734         AC_MSG_CHECKING([if pci.h has enum pcie_link_width])
735         LB_LINUX_TRY_COMPILE([
736                 #include <linux/pci.h>
737                 #include <linux/pci_hotplug.h>
738         ],[
739                 enum pcie_link_width width = PCIE_LNK_WIDTH_UNKNOWN;
740
741                 return 0;
742         ],[
743                 AC_MSG_RESULT(yes)
744                 AC_DEFINE(HAVE_PCIE_LINK_WIDTH, 1,
745                           [pcie_link_width is defined])
746         ],[
747                 AC_MSG_RESULT(no)
748         ])
749
750         AC_MSG_CHECKING([if pci.h has enum pci_bus_speed])
751         LB_LINUX_TRY_COMPILE([
752                 #include <linux/pci.h>
753                 #include <linux/pci_hotplug.h>
754         ],[
755                 enum pci_bus_speed speed = PCI_SPEED_UNKNOWN;
756
757                 return 0;
758         ],[
759                 AC_MSG_RESULT(yes)
760                 AC_DEFINE(HAVE_PCI_BUS_SPEED, 1,
761                           [pci_bus_speed is defined])
762         ],[
763                 AC_MSG_RESULT(no)
764         ])
765
766         AC_MSG_CHECKING([if netdevice.h has struct netdev_phys_port_id])
767         LB_LINUX_TRY_COMPILE([
768                 #include <linux/netdevice.h>
769         ],[
770                 struct netdev_phys_port_id *x = NULL;
771
772                 return 0;
773         ],[
774                 AC_MSG_RESULT(yes)
775                 AC_DEFINE(HAVE_NETDEV_PHYS_PORT_ID, 1,
776                           [netdev_phys_port_id is defined])
777         ],[
778                 AC_MSG_RESULT(no)
779         ])
780
781         AC_MSG_CHECKING([if struct ifla_vf_info has linkstate])
782         LB_LINUX_TRY_COMPILE([
783                 #include <linux/if_link.h>
784         ],[
785                 struct ifla_vf_info *x;
786                 x->linkstate = 0;
787
788                 return 0;
789         ],[
790                 AC_MSG_RESULT(yes)
791                 AC_DEFINE(HAVE_LINKSTATE, 1,
792                           [linkstate is defined])
793         ],[
794                 AC_MSG_RESULT(no)
795         ])
796
797         AC_MSG_CHECKING([if busy_poll.h has skb_mark_napi_id])
798         LB_LINUX_TRY_COMPILE([
799                 #include <net/busy_poll.h>
800         ],[
801                 skb_mark_napi_id(NULL, NULL);
802
803                 return 0;
804         ],[
805                 AC_MSG_RESULT(yes)
806                 AC_DEFINE(HAVE_SKB_MARK_NAPI_ID, 1,
807                           [skb_mark_napi_id is defined])
808         ],[
809                 AC_MSG_RESULT(no)
810         ])
811
812         AC_MSG_CHECKING([if netdevice.h has napi_hash_add])
813         LB_LINUX_TRY_COMPILE([
814                 #include <linux/netdevice.h>
815         ],[
816                 napi_hash_add(NULL);
817
818                 return 0;
819         ],[
820                 AC_MSG_RESULT(yes)
821                 AC_DEFINE(HAVE_NAPI_HASH_ADD, 1,
822                           [napi_hash_add is defined])
823         ],[
824                 AC_MSG_RESULT(no)
825         ])
826
827         AC_MSG_CHECKING([if netdevice.h has netif_keep_dst])
828         LB_LINUX_TRY_COMPILE([
829                 #include <linux/netdevice.h>
830         ],[
831                 netif_keep_dst(NULL);
832
833                 return 0;
834         ],[
835                 AC_MSG_RESULT(yes)
836                 AC_DEFINE(HAVE_NETIF_KEEP_DST, 1,
837                           [netif_keep_dst is defined])
838         ],[
839                 AC_MSG_RESULT(no)
840         ])
841
842         AC_MSG_CHECKING([if netdevice.h has dev_consume_skb_any])
843         LB_LINUX_TRY_COMPILE([
844                 #include <linux/netdevice.h>
845         ],[
846                 dev_consume_skb_any(NULL);
847
848                 return 0;
849         ],[
850                 AC_MSG_RESULT(yes)
851                 AC_DEFINE(HAVE_DEV_CONSUME_SKB_ANY, 1,
852                           [dev_consume_skb_any is defined])
853         ],[
854                 AC_MSG_RESULT(no)
855         ])
856
857         AC_MSG_CHECKING([if netdevice.h has netdev_txq_bql_complete_prefetchw])
858         LB_LINUX_TRY_COMPILE([
859                 #include <linux/netdevice.h>
860         ],[
861                 netdev_txq_bql_complete_prefetchw(NULL);
862                 netdev_txq_bql_enqueue_prefetchw(NULL);
863
864                 return 0;
865         ],[
866                 AC_MSG_RESULT(yes)
867                 AC_DEFINE(HAVE_NETDEV_TXQ_BQL_PREFETCHW, 1,
868                           [netdev_txq_bql_complete_prefetchw is defined])
869         ],[
870                 AC_MSG_RESULT(no)
871         ])
872
873         AC_MSG_CHECKING([if struct sk_buff has xmit_more])
874         LB_LINUX_TRY_COMPILE([
875                 #include <linux/skbuff.h>
876         ],[
877                 struct sk_buff *skb;
878                 skb->xmit_more = 0;
879
880                 return 0;
881         ],[
882                 AC_MSG_RESULT(yes)
883                 AC_DEFINE(HAVE_SK_BUFF_XMIT_MORE, 1,
884                           [xmit_more is defined])
885         ],[
886                 AC_MSG_RESULT(no)
887         ])
888
889         AC_MSG_CHECKING([if struct sk_buff has encapsulation])
890         LB_LINUX_TRY_COMPILE([
891                 #include <linux/skbuff.h>
892         ],[
893                 struct sk_buff *skb;
894                 skb->encapsulation = 0;
895
896                 return 0;
897         ],[
898                 AC_MSG_RESULT(yes)
899                 AC_DEFINE(HAVE_SK_BUFF_ENCAPSULATION, 1,
900                           [encapsulation is defined])
901         ],[
902                 AC_MSG_RESULT(no)
903         ])
904
905         AC_MSG_CHECKING([if etherdevice.h has eth_get_headlen])
906         LB_LINUX_TRY_COMPILE([
907                 #include <linux/etherdevice.h>
908         ],[
909                 eth_get_headlen(NULL, 0);
910
911                 return 0;
912         ],[
913                 AC_MSG_RESULT(yes)
914                 AC_DEFINE(HAVE_ETH_GET_HEADLEN, 1,
915                           [eth_get_headlen is defined])
916         ],[
917                 AC_MSG_RESULT(no)
918         ])
919
920         AC_MSG_CHECKING([if struct sk_buff has csum_level])
921         LB_LINUX_TRY_COMPILE([
922                 #include <linux/skbuff.h>
923         ],[
924                 struct sk_buff *skb;
925                 skb->csum_level = 0;
926
927                 return 0;
928         ],[
929                 AC_MSG_RESULT(yes)
930                 AC_DEFINE(HAVE_SK_BUFF_CSUM_LEVEL, 1,
931                           [csum_level is defined])
932         ],[
933                 AC_MSG_RESULT(no)
934         ])
935
936         AC_MSG_CHECKING([if struct skbuff.h has skb_inner_transport_header])
937         LB_LINUX_TRY_COMPILE([
938                 #include <linux/skbuff.h>
939         ],[
940                 skb_inner_transport_header(NULL);
941
942                 return 0;
943         ],[
944                 AC_MSG_RESULT(yes)
945                 AC_DEFINE(HAVE_SKB_INNER_TRANSPORT_HEADER, 1,
946                           [skb_inner_transport_header is defined])
947         ],[
948                 AC_MSG_RESULT(no)
949         ])
950
951         AC_MSG_CHECKING([if struct skbuff.h has skb_inner_network_header])
952         LB_LINUX_TRY_COMPILE([
953                 #include <linux/skbuff.h>
954         ],[
955                 skb_inner_network_header(NULL);
956
957                 return 0;
958         ],[
959                 AC_MSG_RESULT(yes)
960                 AC_DEFINE(HAVE_SKB_INNER_NETWORK_HEADER, 1,
961                           [skb_inner_network_header is defined])
962         ],[
963                 AC_MSG_RESULT(no)
964         ])
965
966         AC_MSG_CHECKING([if if_vlan.h has vlan_dev_get_egress_qos_mask])
967         LB_LINUX_TRY_COMPILE([
968                 #include <linux/if_vlan.h>
969         ],[
970                 vlan_dev_get_egress_qos_mask(NULL, 0);
971
972                 return 0;
973         ],[
974                 AC_MSG_RESULT(yes)
975                 AC_DEFINE(HAVE_VLAN_DEV_GET_EGRESS_QOS_MASK, 1,
976                           [vlan_dev_get_egress_qos_mask is defined])
977         ],[
978                 AC_MSG_RESULT(no)
979         ])
980
981         AC_MSG_CHECKING([if netdevice.h has netdev_get_prio_tc_map])
982         LB_LINUX_TRY_COMPILE([
983                 #include <linux/netdevice.h>
984         ],[
985                 netdev_get_prio_tc_map(NULL, 0);
986
987                 return 0;
988         ],[
989                 AC_MSG_RESULT(yes)
990                 AC_DEFINE(HAVE_NETDEV_GET_PRIO_TC_MAP, 1,
991                           [netdev_get_prio_tc_map is defined])
992         ],[
993                 AC_MSG_RESULT(no)
994         ])
995
996         AC_MSG_CHECKING([if if_vlan.h has __vlan_find_dev_deep_rcu])
997         LB_LINUX_TRY_COMPILE([
998                 #include <linux/if_vlan.h>
999         ],[
1000                 __vlan_find_dev_deep_rcu(NULL, 0, 0);
1001
1002                 return 0;
1003         ],[
1004                 AC_MSG_RESULT(yes)
1005                 AC_DEFINE(HAVE___VLAN_FIND_DEV_DEEP_RCU, 1,
1006                           [__vlan_find_dev_deep_rcu is defined])
1007         ],[
1008                 AC_MSG_RESULT(no)
1009         ])
1010
1011         AC_MSG_CHECKING([if ndo_select_queue has accel_priv])
1012         LB_LINUX_TRY_COMPILE([
1013                 #include <linux/netdevice.h>
1014
1015                 static u16 select_queue(struct net_device *dev, struct sk_buff *skb,
1016                                         void *accel_priv)
1017                 {
1018                         return 0;
1019                 }
1020         ],[
1021                 struct net_device_opts ndops;
1022
1023                 ndops.ndo_select_queue = select_queue;
1024
1025                 return 0;
1026         ],[
1027                 AC_MSG_RESULT(yes)
1028                 AC_DEFINE(NDO_SELECT_QUEUE_HAS_ACCEL_PRIV, 1,
1029                           [ndo_select_queue has accel_priv])
1030         ],[
1031                 AC_MSG_RESULT(no)
1032         ])
1033
1034         AC_MSG_CHECKING([if include/net/bonding.h exists])
1035         LB_LINUX_TRY_COMPILE([
1036                 #include <net/bonding.h>
1037         ],[
1038                 return 0;
1039         ],[
1040                 AC_MSG_RESULT(yes)
1041                 AC_DEFINE(HAVE_BONDING_H, 1,
1042                           [include/net/bonding.h exists])
1043         ],[
1044                 AC_MSG_RESULT(no)
1045         ])
1046
1047         AC_MSG_CHECKING([if bonding.h bond_for_each_slave has 3 parameters])
1048         LB_LINUX_TRY_COMPILE([
1049                 #include <net/bonding.h>
1050         ],[
1051                 struct bonding *bond = NULL;
1052                 struct list_head *iter = NULL;
1053                 struct slave *slave = NULL;
1054
1055                 bond_for_each_slave(bond, slave, iter) ;
1056
1057                 return 0;
1058         ],[
1059                 AC_MSG_RESULT(yes)
1060                 AC_DEFINE(HAVE_BOND_FOR_EACH_SLAVE_3_PARAMS, 1,
1061                           [bond_for_each_slave has 3 parameters])
1062         ],[
1063                 AC_MSG_RESULT(no)
1064         ])
1065
1066
1067         AC_MSG_CHECKING([if u64_stats_sync.h has u64_stats_init])
1068         LB_LINUX_TRY_COMPILE([
1069                 #include <linux/u64_stats_sync.h>
1070         ],[
1071                 struct u64_stats_sync sync;
1072                 u64_stats_init(&sync);
1073
1074                 return 0;
1075         ],[
1076                 AC_MSG_RESULT(yes)
1077                 AC_DEFINE(HAVE_U64_STATS_SYNC, 1,
1078                           [u64_stats_sync is defined])
1079         ],[
1080                 AC_MSG_RESULT(no)
1081         ])
1082
1083         AC_MSG_CHECKING([if u64_stats_sync.h has u64_stats_fetch_begin_irq])
1084         LB_LINUX_TRY_COMPILE([
1085                 #include <linux/u64_stats_sync.h>
1086         ],[
1087                 struct u64_stats_sync sync;
1088                 u64_stats_fetch_begin_irq(&sync);
1089
1090                 return 0;
1091         ],[
1092                 AC_MSG_RESULT(yes)
1093                 AC_DEFINE(HAVE_U64_STATS_FETCH_BEGIN_IRQ, 1,
1094                           [u64_stats_fetch_begin_irq is defined])
1095         ],[
1096                 AC_MSG_RESULT(no)
1097         ])
1098         AC_MSG_CHECKING([if etherdevice.h has ether_addr_copy])
1099         LB_LINUX_TRY_COMPILE([
1100                 #include <linux/etherdevice.h>
1101         ],[
1102                 char dest[6], src[6];
1103                 ether_addr_copy(&dest, &src);
1104
1105                 return 0;
1106         ],[
1107                 AC_MSG_RESULT(yes)
1108                 AC_DEFINE(HAVE_ETHER_ADDR_COPY, 1,
1109                           [ether_addr_copy is defined])
1110         ],[
1111                 AC_MSG_RESULT(no)
1112         ])
1113
1114         AC_MSG_CHECKING([if struct net_device_ops has *ndo_set_vf_rate])
1115         LB_LINUX_TRY_COMPILE([
1116                 #include <linux/netdevice.h>
1117
1118                 int set_vf_rate(struct net_device *dev, int vf, int min_tx_rate,
1119                                                    int max_tx_rate)
1120                 {
1121                         return 0;
1122                 }
1123         ],[
1124                 struct net_device_ops netdev_ops;
1125
1126                 netdev_ops.ndo_set_vf_rate = set_vf_rate;
1127                 return 0;
1128         ],[
1129                 AC_MSG_RESULT(yes)
1130                 AC_DEFINE(HAVE_SET_VF_RATE, 1,
1131                           [ndo_set_vf_rate is defined])
1132         ],[
1133                 AC_MSG_RESULT(no)
1134         ])
1135
1136         AC_MSG_CHECKING([if netdev_extended has hw_features])
1137         LB_LINUX_TRY_COMPILE([
1138                 #include <linux/netdevice.h>
1139         ],[
1140                 struct net_device *dev = NULL;
1141
1142                 netdev_extended(dev)->hw_features = 0;
1143
1144                 return 0;
1145         ],[
1146                 AC_MSG_RESULT(yes)
1147                 AC_DEFINE(HAVE_NETDEV_EXTENDED_HW_FEATURES, 1,
1148                           [ is defined])
1149         ],[
1150                 AC_MSG_RESULT(no)
1151         ])
1152
1153         AC_MSG_CHECKING([if net_device_extended has _tx_ext])
1154         LB_LINUX_TRY_COMPILE([
1155                 #include <linux/netdevice.h>
1156         ],[
1157                 struct net_device *dev = NULL;
1158
1159                 netdev_extended(dev)->_tx_ext = NULL;
1160
1161                 return 0;
1162         ],[
1163                 AC_MSG_RESULT(yes)
1164                 AC_DEFINE(HAVE_NET_DEVICE_EXTENDED_TX_EXT, 1,
1165                           [ is defined])
1166         ],[
1167                 AC_MSG_RESULT(no)
1168         ])
1169
1170         AC_MSG_CHECKING([if net_device_extended has ndo_busy_poll])
1171         LB_LINUX_TRY_COMPILE([
1172                 #include <linux/netdevice.h>
1173
1174                 int busy_poll(struct napi_struct *napi)
1175                 {
1176                         return 0;
1177                 }
1178         ],[
1179                 struct net_device *dev = NULL;
1180
1181                 netdev_extended(dev)->ndo_busy_poll = busy_poll;
1182
1183                 return 0;
1184         ],[
1185                 AC_MSG_RESULT(yes)
1186                 AC_DEFINE(HAVE_NETDEV_EXTENDED_NDO_BUSY_POLL, 1,
1187                           [ is defined])
1188         ],[
1189                 AC_MSG_RESULT(no)
1190         ])
1191
1192         AC_MSG_CHECKING([if netdevice.h has set_netdev_hw_features])
1193         LB_LINUX_TRY_COMPILE([
1194                 #include <linux/netdevice.h>
1195         ],[
1196                 struct net_device *dev = NULL;
1197
1198                 set_netdev_hw_features(dev, 0);
1199
1200                 return 0;
1201         ],[
1202                 AC_MSG_RESULT(yes)
1203                 AC_DEFINE(HAVE_SET_NETDEV_HW_FEATURES, 1,
1204                           [ is defined])
1205         ],[
1206                 AC_MSG_RESULT(no)
1207         ])
1208
1209         AC_MSG_CHECKING([if netdevice.h has netif_set_xps_queue])
1210         LB_LINUX_TRY_COMPILE([
1211                 #include <linux/netdevice.h>
1212         ],[
1213                 struct net_device *dev = NULL;
1214
1215                 netif_set_xps_queue(dev, NULL, 0);
1216
1217                 return 0;
1218         ],[
1219                 AC_MSG_RESULT(yes)
1220                 AC_DEFINE(HAVE_NETIF_SET_XPS_QUEUE, 1,
1221                           [ is defined])
1222         ],[
1223                 AC_MSG_RESULT(no)
1224         ])
1225
1226
1227         AC_MSG_CHECKING([if struct net_device_ops has *ndo_set_features])
1228         LB_LINUX_TRY_COMPILE([
1229                 #include <linux/netdevice.h>
1230
1231                 int set_features(struct net_device *dev, netdev_features_t features)
1232                 {
1233                         return 0;
1234                 }
1235         ],[
1236                 struct net_device_ops netdev_ops;
1237
1238                 netdev_ops.ndo_set_features = set_features;
1239                 return 0;
1240         ],[
1241                 AC_MSG_RESULT(yes)
1242                 AC_DEFINE(HAVE_NDO_SET_FEATURES, 1,
1243                           [ndo_set_features is defined])
1244         ],[
1245                 AC_MSG_RESULT(no)
1246         ])
1247
1248         AC_MSG_CHECKING([if struct net_device_ops has *ndo_setup_tc])
1249         LB_LINUX_TRY_COMPILE([
1250                 #include <linux/netdevice.h>
1251         ],[
1252                 struct net_device_ops x = {
1253                         .ndo_setup_tc = NULL,
1254                 };
1255
1256                 return 0;
1257         ],[
1258                 AC_MSG_RESULT(yes)
1259                 AC_DEFINE(HAVE_NDO_SETUP_TC, 1,
1260                           [ndo_setup_tc is defined])
1261         ],[
1262                 AC_MSG_RESULT(no)
1263         ])
1264
1265         AC_MSG_CHECKING([if struct net_device_ops has *ndo_rx_flow_steer])
1266         LB_LINUX_TRY_COMPILE([
1267                 #include <linux/netdevice.h>
1268
1269                 int rx_flow_steer(struct net_device *dev,
1270                                                      const struct sk_buff *skb,
1271                                                      u16 rxq_index,
1272                                                      u32 flow_id)
1273                 {
1274                         return 0;
1275                 }
1276         ],[
1277                 struct net_device_ops netdev_ops;
1278
1279                 netdev_ops.ndo_rx_flow_steer = rx_flow_steer;
1280                 return 0;
1281         ],[
1282                 AC_MSG_RESULT(yes)
1283                 AC_DEFINE(HAVE_NDO_RX_FLOW_STEER, 1,
1284                           [ndo_rx_flow_steer is defined])
1285         ],[
1286                 AC_MSG_RESULT(no)
1287         ])
1288
1289         AC_MSG_CHECKING([if struct net_device has priv_flags])
1290         LB_LINUX_TRY_COMPILE([
1291                 #include <linux/netdevice.h>
1292         ],[
1293                 struct net_device *netdev;
1294                 netdev->priv_flags = 0;
1295
1296                 return 0;
1297         ],[
1298                 AC_MSG_RESULT(yes)
1299                 AC_DEFINE(HAVE_NET_DEVICE_PRIV_FLAGS, 1,
1300                           [priv_flags is defined])
1301         ],[
1302                 AC_MSG_RESULT(no)
1303         ])
1304
1305         AC_MSG_CHECKING([if struct net_device_ops has *ndo_get_stats64])
1306         LB_LINUX_TRY_COMPILE([
1307                 #include <linux/netdevice.h>
1308
1309                 struct rtnl_link_stats64* get_stats_64(struct net_device *dev,
1310                                                      struct rtnl_link_stats64 *storage)
1311                 {
1312                         struct rtnl_link_stats64 stats_64;
1313                         return &stats_64;
1314                 }
1315         ],[
1316                 struct net_device_ops netdev_ops;
1317
1318                 netdev_ops.ndo_get_stats64 = get_stats_64;
1319
1320                 return 0;
1321         ],[
1322                 AC_MSG_RESULT(yes)
1323                 AC_DEFINE(HAVE_NDO_GET_STATS64, 1,
1324                           [ndo_get_stats64 is defined])
1325         ],[
1326                 AC_MSG_RESULT(no)
1327         ])
1328         AC_MSG_CHECKING([if struct net_device_ops has ndo_bridge_set/getlink])
1329         LB_LINUX_TRY_COMPILE([
1330                 #include <linux/netdevice.h>
1331         ],[
1332                 struct net_device_ops netdev_ops =  {
1333                         .ndo_bridge_setlink = NULL,
1334                         .ndo_bridge_getlink = NULL,
1335                 };
1336
1337                 return 0;
1338         ],[
1339                 AC_MSG_RESULT(yes)
1340                 AC_DEFINE(HAVE_NDO_BRIDGE_SET_GET_LINK, 1,
1341                           [ndo_bridge_set/getlink is defined])
1342         ],[
1343                 AC_MSG_RESULT(no)
1344         ])
1345
1346         AC_MSG_CHECKING([if rtnetlink.h ndo_dflt_bridge_getlink has 7 params])
1347         LB_LINUX_TRY_COMPILE([
1348                 #include <linux/rtnetlink.h>
1349         ],[
1350                 ndo_dflt_bridge_getlink(NULL, 0, 0, NULL, 0, 0, 0);
1351
1352                 return 0;
1353         ],[
1354                 AC_MSG_RESULT(yes)
1355                 AC_DEFINE(HAVE_NDO_DFLT_BRIDGE_GETLINK_7_PARAMS, 1,
1356                         [ ndo_dflt_bridge_getlink with 7 params is defined])
1357         ],[
1358                 AC_MSG_RESULT(no)
1359         ])
1360
1361         AC_MSG_CHECKING([if struct net_device_ops ndo_vlan_rx_add_vid has 3 parameters ])
1362         LB_LINUX_TRY_COMPILE([
1363                 #include <linux/netdevice.h>
1364
1365         ],[
1366                 int vlan_rx_add_vid(struct net_device *dev,__be16 proto, u16 vid)
1367                 {
1368                         return 0;
1369                 }
1370                 struct net_device_ops netdev_ops;
1371
1372                 netdev_ops.ndo_vlan_rx_add_vid = vlan_rx_add_vid;
1373                 netdev_ops.ndo_vlan_rx_add_vid (NULL, 1, 1) ;
1374
1375                 return 0;
1376         ],[
1377                 AC_MSG_RESULT(yes)
1378                 AC_DEFINE(HAVE_NDO_RX_ADD_VID_HAS_3_PARAMS, 1,
1379                           [ndo_vlan_rx_add_vid has 3 parameters])
1380         ],[
1381                 AC_MSG_RESULT(no)
1382         ])
1383
1384         AC_MSG_CHECKING([if net_device_ops has ndo_get_phys_port_id])
1385         LB_LINUX_TRY_COMPILE([
1386                 #include <linux/netdevice.h>
1387
1388                 int get_phys_port_id(struct net_device *dev,
1389                                      struct netdev_phys_port_id *ppid)
1390                 {
1391                         return 0;
1392                 }
1393         ],[
1394                 struct net_device_ops netdev_ops;
1395
1396                 netdev_ops.ndo_get_phys_port_id = get_phys_port_id;
1397
1398                 return 0;
1399         ],[
1400                 AC_MSG_RESULT(yes)
1401                 AC_DEFINE(HAVE_NETDEV_NDO_GET_PHYS_PORT_ID, 1,
1402                           [ is defined])
1403         ],[
1404                 AC_MSG_RESULT(no)
1405         ])
1406
1407         AC_MSG_CHECKING([if struct net_device_ops_ext exist])
1408         LB_LINUX_TRY_COMPILE([
1409                 #include <linux/netdevice.h>
1410         ],[
1411                 struct net_device_ops_ext netdev_ops_ext = {
1412                         .size = sizeof(struct net_device_ops_ext),
1413                 };
1414
1415                 return 0;
1416         ],[
1417                 AC_MSG_RESULT(yes)
1418                 AC_DEFINE(HAVE_NET_DEVICE_OPS_EXT, 1,
1419                           [struct net_device_ops_ext is defined])
1420         ],[
1421                 AC_MSG_RESULT(no)
1422         ])
1423
1424         AC_MSG_CHECKING([if net_device_ops_ext has ndo_get_phys_port_id])
1425         LB_LINUX_TRY_COMPILE([
1426                 #include <linux/netdevice.h>
1427
1428                 int get_phys_port_id(struct net_device *dev,
1429                                      struct netdev_phys_port_id *ppid)
1430                 {
1431                         return 0;
1432                 }
1433         ],[
1434                 struct net_device_ops_ext netdev_ops_ext;
1435
1436                 netdev_ops_ext.ndo_get_phys_port_id = get_phys_port_id;
1437
1438                 return 0;
1439         ],[
1440                 AC_MSG_RESULT(yes)
1441                 AC_DEFINE(HAVE_NETDEV_EXT_NDO_GET_PHYS_PORT_ID, 1,
1442                           [ndo_get_phys_port_id is defined])
1443         ],[
1444                 AC_MSG_RESULT(no)
1445         ])
1446
1447         AC_MSG_CHECKING([if net_device_ops has ndo_set_vf_spoofchk])
1448         LB_LINUX_TRY_COMPILE([
1449                 #include <linux/netdevice.h>
1450
1451                 int set_vf_spoofchk(struct net_device *dev, int vf, bool setting)
1452                 {
1453                         return 0;
1454                 }
1455         ],[
1456                 struct net_device_ops netdev_ops;
1457
1458                 netdev_ops.ndo_set_vf_spoofchk = set_vf_spoofchk;
1459
1460                 return 0;
1461         ],[
1462                 AC_MSG_RESULT(yes)
1463                 AC_DEFINE(HAVE_NETDEV_OPS_NDO_SET_VF_SPOOFCHK, 1,
1464                           [ndo_set_vf_spoofchk is defined in net_device_ops])
1465         ],[
1466                 AC_MSG_RESULT(no)
1467         ])
1468
1469         AC_MSG_CHECKING([if net_device_ops_ext has ndo_set_vf_spoofchk])
1470         LB_LINUX_TRY_COMPILE([
1471                 #include <linux/netdevice.h>
1472
1473                 int set_vf_spoofchk(struct net_device *dev, int vf, bool setting)
1474                 {
1475                         return 0;
1476                 }
1477         ],[
1478                 struct net_device_ops_ext netdev_ops_ext;
1479
1480                 netdev_ops_ext.ndo_set_vf_spoofchk = set_vf_spoofchk;
1481
1482                 return 0;
1483         ],[
1484                 AC_MSG_RESULT(yes)
1485                 AC_DEFINE(HAVE_NETDEV_OPS_EXT_NDO_SET_VF_SPOOFCHK, 1,
1486                           [ndo_set_vf_spoofchk is defined in net_device_ops_ext])
1487         ],[
1488                 AC_MSG_RESULT(no)
1489         ])
1490
1491         AC_MSG_CHECKING([if net_device_ops has ndo_set_vf_link_state])
1492         LB_LINUX_TRY_COMPILE([
1493                 #include <linux/netdevice.h>
1494
1495                 int set_vf_link_state(struct net_device *dev, int vf, int link_state)
1496                 {
1497                         return 0;
1498                 }
1499         ],[
1500                 struct net_device_ops netdev_ops;
1501
1502                 netdev_ops.ndo_set_vf_link_state = set_vf_link_state;
1503
1504                 return 0;
1505         ],[
1506                 AC_MSG_RESULT(yes)
1507                 AC_DEFINE(HAVE_NETDEV_OPS_NDO_SET_VF_LINK_STATE, 1,
1508                           [ndo_set_vf_link_state is defined in net_device_ops])
1509         ],[
1510                 AC_MSG_RESULT(no)
1511         ])
1512
1513         AC_MSG_CHECKING([if net_device_ops_ext has ndo_set_vf_link_state])
1514         LB_LINUX_TRY_COMPILE([
1515                 #include <linux/netdevice.h>
1516
1517                 int set_vf_link_state(struct net_device *dev, int vf, int link_state)
1518                 {
1519                         return 0;
1520                 }
1521         ],[
1522                 struct net_device_ops_ext netdev_ops_ext;
1523
1524                 netdev_ops_ext.ndo_set_vf_link_state = set_vf_link_state;
1525
1526                 return 0;
1527         ],[
1528                 AC_MSG_RESULT(yes)
1529                 AC_DEFINE(HAVE_NETDEV_OPS_EXT_NDO_SET_VF_LINK_STATE, 1,
1530                           [ndo_set_vf_link_state is defined])
1531         ],[
1532                 AC_MSG_RESULT(no)
1533         ])
1534
1535
1536         AC_MSG_CHECKING([if netdevice.h netif_set_real_num_tx_queues returns int])
1537         LB_LINUX_TRY_COMPILE([
1538                 #include <linux/netdevice.h>
1539         ],[
1540                 struct net_device dev;
1541                 int ret;
1542                 ret = netif_set_real_num_tx_queues(&dev, 2);
1543                 return 0;
1544         ],[
1545                 AC_MSG_RESULT(yes)
1546                 AC_DEFINE(HAVE_RETURN_INT_FOR_SET_NUM_TX_QUEUES, 1,
1547                           [netif_set_real_num_tx_queues returns int])
1548         ],[
1549                 AC_MSG_RESULT(no)
1550         ])
1551
1552         AC_MSG_CHECKING([if struct netdevice.h has struct xps_map])
1553         LB_LINUX_TRY_COMPILE([
1554                 #include <linux/netdevice.h>
1555         ],[
1556                 struct xps_map map;
1557                 map.len = 0;
1558
1559                 return 0;
1560         ],[
1561                 AC_MSG_RESULT(yes)
1562                 AC_DEFINE(HAVE_XPS_MAP, 1,
1563                           [struct xps_map is defined])
1564         ],[
1565                 AC_MSG_RESULT(no)
1566         ])
1567
1568         AC_MSG_CHECKING([if struct ethtool_ops has set_phys_id])
1569         LB_LINUX_TRY_COMPILE([
1570                 #include <linux/ethtool.h>
1571         ],[
1572                 const struct ethtool_ops en_ethtool_ops = {
1573                         .set_phys_id= NULL,
1574                 };
1575
1576                 return 0;
1577         ],[
1578                 AC_MSG_RESULT(yes)
1579                 AC_DEFINE(HAVE_SET_PHYS_ID, 1,
1580                           [set_phys_id is defined])
1581         ],[
1582                 AC_MSG_RESULT(no)
1583         ])
1584
1585         AC_MSG_CHECKING([if struct ethtool_ops has get/set_channels])
1586         LB_LINUX_TRY_COMPILE([
1587                 #include <linux/ethtool.h>
1588         ],[
1589                 const struct ethtool_ops en_ethtool_ops = {
1590                         .get_channels = NULL,
1591                         .set_channels = NULL,
1592                 };
1593
1594                 return 0;
1595         ],[
1596                 AC_MSG_RESULT(yes)
1597                 AC_DEFINE(HAVE_GET_SET_CHANNELS, 1,
1598                           [get/set_channels is defined])
1599         ],[
1600                 AC_MSG_RESULT(no)
1601         ])
1602
1603         AC_MSG_CHECKING([if struct ethtool_ops_ext has get/set_channels])
1604         LB_LINUX_TRY_COMPILE([
1605                 #include <linux/ethtool.h>
1606         ],[
1607                 const struct ethtool_ops_ext en_ethtool_ops_ext = {
1608                         .get_channels = NULL,
1609                         .set_channels = NULL,
1610                 };
1611
1612                 return 0;
1613         ],[
1614                 AC_MSG_RESULT(yes)
1615                 AC_DEFINE(HAVE_GET_SET_CHANNELS_EXT, 1,
1616                           [get/set_channels is defined in ethtool_ops_ext])
1617         ],[
1618                 AC_MSG_RESULT(no)
1619         ])
1620
1621         AC_MSG_CHECKING([if struct ethtool_ops has get_ts_info])
1622         LB_LINUX_TRY_COMPILE([
1623                 #include <linux/ethtool.h>
1624         ],[
1625                 const struct ethtool_ops en_ethtool_ops = {
1626                         .get_ts_info = NULL,
1627                 };
1628
1629                 return 0;
1630         ],[
1631                 AC_MSG_RESULT(yes)
1632                 AC_DEFINE(HAVE_GET_TS_INFO, 1,
1633                           [get_ts_info is defined])
1634         ],[
1635                 AC_MSG_RESULT(no)
1636         ])
1637
1638         AC_MSG_CHECKING([if struct ethtool_ops has set_dump])
1639         LB_LINUX_TRY_COMPILE([
1640                 #include <linux/ethtool.h>
1641         ],[
1642                 const struct ethtool_ops en_ethtool_ops = {
1643                         .set_dump = NULL,
1644                 };
1645
1646                 return 0;
1647         ],[
1648                 AC_MSG_RESULT(yes)
1649                 AC_DEFINE(HAVE_ETHTOOL_OPS_SET_DUMP, 1,
1650                           [set_dump is defined])
1651         ],[
1652                 AC_MSG_RESULT(no)
1653         ])
1654
1655         AC_MSG_CHECKING([if struct ethtool_ops has get_module_info])
1656         LB_LINUX_TRY_COMPILE([
1657                 #include <linux/ethtool.h>
1658         ],[
1659                 const struct ethtool_ops en_ethtool_ops = {
1660                         .get_module_info = NULL,
1661                 };
1662
1663                 return 0;
1664         ],[
1665                 AC_MSG_RESULT(yes)
1666                 AC_DEFINE(HAVE_ETHTOOL_OPS_GET_MODULE_INFO, 1,
1667                           [get_module_info is defined])
1668         ],[
1669                 AC_MSG_RESULT(no)
1670         ])
1671
1672         AC_MSG_CHECKING([if struct ethtool_ops has get_module_eeprom])
1673         LB_LINUX_TRY_COMPILE([
1674                 #include <linux/ethtool.h>
1675         ],[
1676                 const struct ethtool_ops en_ethtool_ops = {
1677                         .get_module_eeprom = NULL,
1678                 };
1679
1680                 return 0;
1681         ],[
1682                 AC_MSG_RESULT(yes)
1683                 AC_DEFINE(HAVE_ETHTOOL_OPS_GET_MODULE_EEPROM, 1,
1684                           [get_module_eeprom is defined])
1685         ],[
1686                 AC_MSG_RESULT(no)
1687         ])
1688
1689         AC_MSG_CHECKING([if struct ethtool_ops_ext has get_ts_info])
1690         LB_LINUX_TRY_COMPILE([
1691                 #include <linux/ethtool.h>
1692         ],[
1693                 const struct ethtool_ops_ext en_ethtool_ops_ext = {
1694                         .get_ts_info = NULL,
1695                 };
1696
1697                 return 0;
1698         ],[
1699                 AC_MSG_RESULT(yes)
1700                 AC_DEFINE(HAVE_GET_TS_INFO_EXT, 1,
1701                           [get_ts_info is defined in ethtool_ops_ext])
1702         ],[
1703                 AC_MSG_RESULT(no)
1704         ])
1705
1706         AC_MSG_CHECKING([if struct ethtool_flow_ext has h_dest])
1707         LB_LINUX_TRY_COMPILE([
1708                 #include <linux/ethtool.h>
1709         ],[
1710                 unsigned char mac[ETH_ALEN];
1711                 struct ethtool_flow_ext h_ext;
1712
1713                 memcpy(&mac, h_ext.h_dest, ETH_ALEN);
1714
1715                 return 0;
1716         ],[
1717                 AC_MSG_RESULT(yes)
1718                 AC_DEFINE(HAVE_ETHTOOL_FLOW_EXT_H_DEST, 1,
1719                           [ethtool_flow_ext has h_dest])
1720         ],[
1721                 AC_MSG_RESULT(no)
1722         ])
1723
1724         AC_MSG_CHECKING([if netdevice.h has struct dev_addr_list])
1725         LB_LINUX_TRY_COMPILE([
1726                 #include <linux/netdevice.h>
1727         ],[
1728                 struct dev_addr_list addr;
1729                 return 0;
1730         ],[
1731                 AC_MSG_RESULT(yes)
1732                 AC_DEFINE(HAVE_NETDEV_DEV_ADDR, 1,
1733                           [dev_addr_list is defined])
1734         ],[
1735                 AC_MSG_RESULT(no)
1736         ])
1737
1738         AC_MSG_CHECKING([if pci.h has pci_vfs_assigned])
1739         LB_LINUX_TRY_COMPILE([
1740                 #include <linux/pci.h>
1741         ],[
1742                 struct pci_dev pdev;
1743                 pci_vfs_assigned(&pdev);
1744                 return 0;
1745         ],[
1746                 AC_MSG_RESULT(yes)
1747                 AC_DEFINE(HAVE_PCI_VF_ASSIGNED, 1,
1748                           [pci_vfs_assigned is defined])
1749         ],[
1750                 AC_MSG_RESULT(no)
1751         ])
1752
1753         AC_MSG_CHECKING([if vlan_insert_tag_set_proto is defined])
1754         LB_LINUX_TRY_COMPILE([
1755                 #include <linux/if_vlan.h>
1756         ],[
1757                 struct sk_buff *skb;
1758                 vlan_insert_tag_set_proto(skb, 0, 0);
1759                 return 0;
1760         ],[
1761                 AC_MSG_RESULT(yes)
1762                 AC_DEFINE(HAVE_VLAN_INSERT_TAG_SET_PROTO, 1,
1763                           [vlan_insert_tag_set_proto is defined])
1764         ],[
1765                 AC_MSG_RESULT(no)
1766                 AC_MSG_CHECKING([if __vlan_put_tag has 3 parameters])
1767                 LB_LINUX_TRY_COMPILE([
1768                         #include <linux/if_vlan.h>
1769                 ],[
1770                         struct sk_buff *skb;
1771                         __vlan_put_tag(skb, 0, 0);
1772                         return 0;
1773                 ],[
1774                         AC_MSG_RESULT(yes)
1775                         AC_DEFINE(HAVE_3_PARAMS_FOR_VLAN_PUT_TAG, 1,
1776                                   [__vlan_put_tag has 3 parameters])
1777                 ],[
1778                         AC_MSG_RESULT(no)
1779                 ])
1780         ])
1781
1782         AC_MSG_CHECKING([if __vlan_hwaccel_put_tag has 3 parameters])
1783         LB_LINUX_TRY_COMPILE([
1784                 #include <linux/if_vlan.h>
1785         ],[
1786                 struct sk_buff *skb;
1787                 __vlan_hwaccel_put_tag(skb, 0, 0);
1788
1789                 return 0;
1790         ],[
1791                 AC_MSG_RESULT(yes)
1792                 AC_DEFINE(HAVE_3_PARAMS_FOR_VLAN_HWACCEL_PUT_TAG, 1,
1793                           [__vlan_hwaccel_put_tag has 3 parameters])
1794         ],[
1795                 AC_MSG_RESULT(no)
1796         ])
1797
1798         AC_MSG_CHECKING([if struct inet6_ifaddr has if_next])
1799         LB_LINUX_TRY_COMPILE([
1800                 #include <net/if_inet6.h>
1801         ],[
1802                 struct inet6_ifaddr ifp ;
1803                 ifp.if_next = 0;
1804
1805                 return 0;
1806         ],[
1807                 AC_MSG_RESULT(yes)
1808                 AC_DEFINE(HAVE_INETADDR_IF_NEXT, 1,
1809                           [if_next is defined])
1810         ],[
1811                 AC_MSG_RESULT(no)
1812         ])
1813
1814         AC_MSG_CHECKING([if struct net_device has hw_features])
1815         LB_LINUX_TRY_COMPILE([
1816                 #include <linux/netdevice.h>
1817         ],[
1818                 struct net_device dev;
1819                 dev.hw_features = 0;
1820
1821                 return 0;
1822         ],[
1823                 AC_MSG_RESULT(yes)
1824                 AC_DEFINE(HAVE_NETDEV_HW_FEATURES, 1,
1825                           [hw_features is defined])
1826         ],[
1827                 AC_MSG_RESULT(no)
1828         ])
1829
1830         AC_MSG_CHECKING([if struct net_device has hw_enc_features])
1831         LB_LINUX_TRY_COMPILE([
1832                 #include <linux/netdevice.h>
1833         ],[
1834                 struct net_device dev;
1835                 dev.hw_enc_features = 0;
1836
1837                 return 0;
1838         ],[
1839                 AC_MSG_RESULT(yes)
1840                 AC_DEFINE(HAVE_NETDEV_HW_ENC_FEATURES, 1,
1841                           [hw_enc_features is defined])
1842         ],[
1843                 AC_MSG_RESULT(no)
1844         ])
1845
1846         AC_MSG_CHECKING([if struct net_device has rx_cpu_rmap])
1847         LB_LINUX_TRY_COMPILE([
1848                 #include <linux/netdevice.h>
1849         ],[
1850                 struct net_device dev;
1851                 dev.rx_cpu_rmap = NULL;
1852
1853                 return 0;
1854         ],[
1855                 AC_MSG_RESULT(yes)
1856                 AC_DEFINE(HAVE_NETDEV_RX_CPU_RMAP, 1,
1857                           [rx_cpu_rmap is defined])
1858         ],[
1859                 AC_MSG_RESULT(no)
1860         ])
1861
1862         AC_MSG_CHECKING([if if_vlan.h has vlan_hwaccel_receive_skb])
1863         LB_LINUX_TRY_COMPILE([
1864                 #include <linux/if_vlan.h>
1865         ],[
1866                 struct sk_buff *skb;
1867                 vlan_hwaccel_receive_skb(skb,0,0);
1868                 return 0;
1869         ],[
1870                 AC_MSG_RESULT(yes)
1871                 AC_DEFINE(HAVE_VLAN_HWACCEL_RECEIVE_SKB, 1,
1872                           [vlan_hwaccel_receive_skb is defined])
1873         ],[
1874                 AC_MSG_RESULT(no)
1875         ])
1876
1877         AC_MSG_CHECKING([if irqdesc.h has irq_desc_get_irq_data])
1878         LB_LINUX_TRY_COMPILE([
1879                 #include <linux/irq.h>
1880                 #include <linux/irqdesc.h>
1881         ],[
1882                 struct irq_desc desc;
1883                 struct irq_data *data = irq_desc_get_irq_data(&desc);
1884
1885                 return 0;
1886         ],[
1887                 AC_MSG_RESULT(yes)
1888                 AC_DEFINE(HAVE_IRQ_DESC_GET_IRQ_DATA, 1,
1889                           [irq_desc_get_irq_data is defined])
1890         ],[
1891                 AC_MSG_RESULT(no)
1892         ])
1893
1894
1895         AC_MSG_CHECKING([if pci_dev has pcie_mpss])
1896         LB_LINUX_TRY_COMPILE([
1897                 #include <linux/pci.h>
1898         ],[
1899                 struct pci_dev *pdev;
1900
1901                 pdev->pcie_mpss = 0;
1902                 return 0;
1903         ],[
1904                 AC_MSG_RESULT(yes)
1905                 AC_DEFINE(HAVE_PCI_DEV_PCIE_MPSS, 1,
1906                           [pcie_mpss is defined])
1907         ],[
1908                 AC_MSG_RESULT(no)
1909         ])
1910
1911         AC_MSG_CHECKING([if uapi/linux/if_ether.h exist])
1912         LB_LINUX_TRY_COMPILE([
1913                 #include <uapi/linux/if_ether.h>
1914         ],[
1915                 return 0;
1916         ],[
1917                 AC_MSG_RESULT(yes)
1918                 AC_DEFINE(HAVE_UAPI_LINUX_IF_ETHER_H, 1,
1919                           [uapi/linux/if_ether.h exist])
1920         ],[
1921                 AC_MSG_RESULT(no)
1922         ])
1923
1924         AC_MSG_CHECKING([if ifla_vf_info has spoofchk])
1925         LB_LINUX_TRY_COMPILE([
1926                 #include <linux/if_link.h>
1927         ],[
1928                 struct ifla_vf_info *ivf;
1929
1930                 ivf->spoofchk = 0;
1931                 return 0;
1932         ],[
1933                 AC_MSG_RESULT(yes)
1934                 AC_DEFINE(HAVE_VF_INFO_SPOOFCHK, 1,
1935                           [spoofchk is defined])
1936         ],[
1937                 AC_MSG_RESULT(no)
1938         ])
1939
1940         AC_MSG_CHECKING([if vxlan.h has vxlan_gso_check])
1941         LB_LINUX_TRY_COMPILE([
1942                 #include <net/vxlan.h>
1943         ],[
1944                 vxlan_gso_check(NULL);
1945
1946                 return 0;
1947         ],[
1948                 AC_MSG_RESULT(yes)
1949                 AC_DEFINE(HAVE_VXLAN_GSO_CHECK, 1,
1950                           [vxlan_gso_check is defined])
1951         ],[
1952                 AC_MSG_RESULT(no)
1953         ])
1954
1955         AC_MSG_CHECKING([if dst.h has dst_get_neighbour])
1956         LB_LINUX_TRY_COMPILE([
1957                 #include <net/dst.h>
1958         ],[
1959                 struct neighbour *neigh = dst_get_neighbour(NULL);
1960
1961                 return 0;
1962         ],[
1963                 AC_MSG_RESULT(yes)
1964                 AC_DEFINE(HAVE_DST_GET_NEIGHBOUR, 1,
1965                           [ is defined])
1966         ],[
1967                 AC_MSG_RESULT(no)
1968         ])
1969
1970         AC_MSG_CHECKING([if netlink_dump_start has 6 parameters])
1971         LB_LINUX_TRY_COMPILE([
1972                 #include <linux/netlink.h>
1973         ],[
1974                 int ret = netlink_dump_start(NULL, NULL, NULL, NULL, NULL, 0);
1975
1976                 return 0;
1977         ],[
1978                 AC_MSG_RESULT(yes)
1979                 AC_DEFINE(HAVE_NETLINK_DUMP_START_6P, 1,
1980                           [ is defined])
1981         ],[
1982                 AC_MSG_RESULT(no)
1983         ])
1984
1985         AC_MSG_CHECKING([if netlink_dump_start has 5 parameters])
1986         LB_LINUX_TRY_COMPILE([
1987                 #include <linux/netlink.h>
1988         ],[
1989                 int ret = netlink_dump_start(NULL, NULL, NULL, NULL, NULL);
1990
1991                 return 0;
1992         ],[
1993                 AC_MSG_RESULT(yes)
1994                 AC_DEFINE(HAVE_NETLINK_DUMP_START_5P, 1,
1995                           [ is defined])
1996         ],[
1997                 AC_MSG_RESULT(no)
1998         ])
1999
2000         AC_MSG_CHECKING([if struct dcbnl_rtnl_ops has ieee_getmaxrate/ieee_setmaxrate])
2001         LB_LINUX_TRY_COMPILE([
2002                 #include <net/dcbnl.h>
2003         ],[
2004                 const struct dcbnl_rtnl_ops en_dcbnl_ops = {
2005                         .ieee_getmaxrate = NULL,
2006                         .ieee_setmaxrate = NULL,
2007                 };
2008
2009                 return 0;
2010         ],[
2011                 AC_MSG_RESULT(yes)
2012                 AC_DEFINE(HAVE_IEEE_GET_SET_MAXRATE, 1,
2013                           [ieee_getmaxrate/ieee_setmaxrate is defined])
2014         ],[
2015                 AC_MSG_RESULT(no)
2016         ])
2017
2018         AC_LANG_PUSH(C)
2019         ac_c_werror_flag=yes
2020         save_EXTRA_KCFLAGS=$EXTRA_KCFLAGS
2021         EXTRA_KCFLAGS="$EXTRA_KCFLAGS -Werror"
2022
2023         AC_MSG_CHECKING([if bonding.h bond_for_each_slave has int for 3rd parameter])
2024         LB_LINUX_TRY_COMPILE([
2025                 #include <net/bonding.h>
2026         ],[
2027                 struct bonding *bond = NULL;
2028                 struct slave *slave = NULL;
2029                 int iter;
2030
2031                 bond_for_each_slave(bond, slave, iter) ;
2032
2033                 return 0;
2034         ],[
2035                 AC_MSG_RESULT(yes)
2036                 AC_DEFINE(HAVE_BOND_FOR_EACH_SLAVE_3RD_PARAM_IS_INT, 1,
2037                           [bond_for_each_slave has int for 3rd parameter])
2038         ],[
2039                 AC_MSG_RESULT(no)
2040         ])
2041         EXTRA_KCFLAGS="$save_EXTRA_KCFLAGS"
2042         ac_c_werror_flag=
2043         AC_LANG_POP
2044
2045         AC_MSG_CHECKING([if netdevice.h has netdev_master_upper_dev_get_rcu])
2046         LB_LINUX_TRY_COMPILE([
2047                 #include <linux/netdevice.h>
2048         ],[
2049                 netdev_master_upper_dev_get_rcu(NULL);
2050
2051                 return 0;
2052         ],[
2053                 AC_MSG_RESULT(yes)
2054                 AC_DEFINE(HAVE_NETDEV_MASTER_UPPER_DEV_GET_RCU, 1,
2055                           [netdev_master_upper_dev_get_rcu is defined])
2056         ],[
2057                 AC_MSG_RESULT(no)
2058         ])
2059
2060         AC_MSG_CHECKING([if __vlan_find_dev_deep has 3 parameters])
2061         LB_LINUX_TRY_COMPILE([
2062                 #include <linux/if_vlan.h>
2063         ],[
2064                 __vlan_find_dev_deep(NULL, 0, 0);
2065
2066                 return 0;
2067         ],[
2068                 AC_MSG_RESULT(yes)
2069                 AC_DEFINE(HAVE__VLAN_FIND_DEV_DEEP_3P, 1,
2070                           [__vlan_find_dev_deep has 3 paramters])
2071         ],[
2072                 AC_MSG_RESULT(no)
2073         ])
2074
2075         AC_MSG_CHECKING([if sk_buff.h has __skb_alloc_page])
2076         LB_LINUX_TRY_COMPILE([
2077                 #include <linux/skbuff.h>
2078         ],[
2079                 __skb_alloc_page(0, NULL);
2080
2081                 return 0;
2082         ],[
2083                 AC_MSG_RESULT(yes)
2084                 AC_DEFINE(HAVE__SKB_ALLOC_PAGE, 1,
2085                           [sk_buff has __skb_alloc_page])
2086         ],[
2087                 AC_MSG_RESULT(no)
2088         ])
2089
2090         AC_MSG_CHECKING([if __vlan_hwaccel_put_tag has 3 parameters])
2091         LB_LINUX_TRY_COMPILE([
2092                 #include <linux/if_vlan.h>
2093         ],[
2094                 __vlan_hwaccel_put_tag(NULL, 0, 0);
2095
2096                 return 0;
2097         ],[
2098                 AC_MSG_RESULT(yes)
2099                 AC_DEFINE(HAVE__VLAN_HWACCEL_PUT_TAG_3P, 1,
2100                           [__vlan_hwaccel_put_tag has 3 paramters])
2101         ],[
2102                 AC_MSG_RESULT(no)
2103         ])
2104
2105         AC_MSG_CHECKING([if linux/mm_types.h has struct page_frag])
2106         LB_LINUX_TRY_COMPILE([
2107                 #include <linux/mm_types.h>
2108         ],[
2109                 struct page_frag frag = {0};
2110
2111                 return 0;
2112         ],[
2113                 AC_MSG_RESULT(yes)
2114                 AC_DEFINE(HAVE_MM_TYPES_PAGE_FRAG, 1,
2115                           [linux/mm_types.h has struct page_frag])
2116         ],[
2117                 AC_MSG_RESULT(no)
2118         ])
2119
2120         AC_MSG_CHECKING([if if_vlan.h has __vlan_find_dev_deep])
2121         LB_LINUX_TRY_COMPILE([
2122                 #include <linux/if_vlan.h>
2123         ],[
2124                 __vlan_find_dev_deep(NULL, 0);
2125
2126                 return 0;
2127         ],[
2128                 AC_MSG_RESULT(yes)
2129                 AC_DEFINE(HAVE___VLAN_FIND_DEV_DEEP, 1,
2130                           [__vlan_find_dev_deep is defined])
2131         ],[
2132                 AC_MSG_RESULT(no)
2133         ])
2134
2135         AC_MSG_CHECKING([if idr .h has idr_Alloc])
2136         LB_LINUX_TRY_COMPILE([
2137                 #include <linux/idr.h>
2138         ],[
2139                 idr_alloc(NULL, NULL, 0, 0, 0);
2140                 return 0;
2141         ],[
2142                 AC_MSG_RESULT(yes)
2143                 AC_DEFINE(HAVE_IDR_NEW_INTERFACE, 1,
2144                           [idr_Alloc is defined]) ],[
2145                 AC_MSG_RESULT(no)
2146         ])
2147
2148         AC_MSG_CHECKING([if completion.h has reinit_completion])
2149         LB_LINUX_TRY_COMPILE([
2150                 #include <linux/completion.h>
2151         ],[
2152                 struct completion c;
2153
2154                 reinit_completion(&c);
2155                 return 0;
2156         ],[
2157                 AC_MSG_RESULT(yes)
2158                 AC_DEFINE(HAVE_REINIT_COMPLETION, 1,
2159                           [reinit_completion is defined])
2160         ],[
2161                 AC_MSG_RESULT(no)
2162         ])
2163
2164         AC_MSG_CHECKING([if dma-mapping.h has dma_set_mask_and_coherent])
2165         LB_LINUX_TRY_COMPILE([
2166                 #include <linux/dma-mapping.h>
2167         ],[
2168                 dma_set_mask_and_coherent(NULL, 0);
2169
2170                 return 0;
2171         ],[
2172                 AC_MSG_RESULT(yes)
2173                 AC_DEFINE(HAVE_DMA_SET_MASK_AND_COHERENT, 1,
2174                           [dma_set_mask_and_coherent is defined])
2175         ],[
2176                 AC_MSG_RESULT(no)
2177         ])
2178
2179         AC_MSG_CHECKING([if in.h has proto_ports_offset])
2180         LB_LINUX_TRY_COMPILE([
2181                 #include <linux/in.h>
2182         ],[
2183                 int x = proto_ports_offset(IPPROTO_TCP);
2184                 return 0;
2185         ],[
2186                 AC_MSG_RESULT(yes)
2187                 AC_DEFINE(HAVE_PROTO_PORTS_OFFSET, 1,
2188                           [proto_ports_offset is defined])
2189         ],[
2190                 AC_MSG_RESULT(no)
2191         ])
2192
2193         LB_CHECK_SYMBOL_EXPORT([elfcorehdr_addr],
2194                 [kernel/crash_dump.c],
2195                 [AC_DEFINE(HAVE_ELFCOREHDR_ADDR_EXPORTED, 1,
2196                         [elfcorehdr_addr is exported by the kernel])],
2197         [])
2198
2199         AC_MSG_CHECKING([if netif_set_real_num_rx_queues is defined])
2200         LB_LINUX_TRY_COMPILE([
2201                 #include <linux/netdevice.h>
2202         ],[
2203                 int rc = netif_set_real_num_rx_queues(NULL, 0);
2204
2205                 return rc;
2206         ],[
2207                 AC_MSG_RESULT(yes)
2208                 AC_DEFINE(HAVE_NETIF_SET_REAL_NUM_RX_QUEUES, 1,
2209                           [netif_set_real_num_rx_queues is defined])
2210         ],[
2211                 AC_MSG_RESULT(no)
2212         ])
2213
2214         AC_MSG_CHECKING([if if_vlan.h has is_vlan_dev])
2215         LB_LINUX_TRY_COMPILE([
2216                 #include <linux/netdevice.h>
2217                 #include <linux/if_vlan.h>
2218         ],[
2219                 struct net_device dev;
2220                 is_vlan_dev(&dev);
2221
2222                 return 0;
2223         ],[
2224                 AC_MSG_RESULT(yes)
2225                 AC_DEFINE(HAVE_IS_VLAN_DEV, 1,
2226                           [is_vlan_dev is defined])
2227         ],[
2228                 AC_MSG_RESULT(no)
2229         ])
2230
2231         AC_MSG_CHECKING([if linux/timecounter.h exists])
2232         LB_LINUX_TRY_COMPILE([
2233                 #include <linux/timecounter.h>
2234         ],[
2235                 return 0;
2236         ],[
2237                 AC_MSG_RESULT(yes)
2238                 AC_DEFINE(HAVE_TIMECOUNTER_H, 1,
2239                           [linux/timecounter.h exists])
2240         ],[
2241                 AC_MSG_RESULT(no)
2242         ])
2243
2244         # timecounter_adjtime can be in timecounter.h or clocksource.h
2245         AC_MSG_CHECKING([if linux/clocksource.h has timecounter_adjtime])
2246         LB_LINUX_TRY_COMPILE([
2247                 #include <linux/clocksource.h>
2248         ],[
2249                 struct timecounter x;
2250                 s64 y = 0;
2251                 timecounter_adjtime(&x, y);
2252
2253                 return 0;
2254         ],[
2255                 AC_MSG_RESULT(yes)
2256                 AC_DEFINE(HAVE_TIMECOUNTER_ADJTIME, 1,
2257                           [timecounter_adjtime is defined])
2258         ],[
2259                 AC_MSG_RESULT(no)
2260         ])
2261
2262         AC_MSG_CHECKING([if cyclecounter_cyc2ns has 4 parameters])
2263         LB_LINUX_TRY_COMPILE([
2264                 #include <linux/timecounter.h>
2265         ],[
2266                 cyclecounter_cyc2ns(NULL, NULL, 0, NULL);
2267
2268                 return 0;
2269         ],[
2270                 AC_MSG_RESULT(yes)
2271                 AC_DEFINE(HAVE_CYCLECOUNTER_CYC2NS_4_PARAMS, 1,
2272                           [cyclecounter_cyc2ns has 4 parameters])
2273         ],[
2274                 AC_MSG_RESULT(no)
2275         ])
2276
2277         AC_MSG_CHECKING([if netdevice.h struct net_device_ops has ndo_features_check])
2278         LB_LINUX_TRY_COMPILE([
2279                 #include <linux/netdevice.h>
2280         ],[
2281                 static const struct net_device_ops mlx4_netdev_ops = {
2282                         .ndo_features_check     = NULL,
2283                 };
2284
2285                 return 0;
2286         ],[
2287                 AC_MSG_RESULT(yes)
2288                 AC_DEFINE(HAVE_NETDEV_FEATURES_T, 1,
2289                           [netdev_features_t is defined])
2290         ],[
2291                 AC_MSG_RESULT(no)
2292         ])
2293
2294         AC_MSG_CHECKING([if struct ethtool_ops get_rxnfc gets u32 *rule_locs])
2295         LB_LINUX_TRY_COMPILE([
2296                 #include <linux/ethtool.h>
2297                 static int mlx4_en_get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *c,
2298                                              u32 *rule_locs)
2299                 {
2300                         return 0;
2301                 }
2302         ],[
2303                 struct ethtool_ops x = {
2304                         .get_rxnfc = mlx4_en_get_rxnfc,
2305                 };
2306
2307                 return 0;
2308         ],[
2309                 AC_MSG_RESULT(yes)
2310                 AC_DEFINE(HAVE_ETHTOOL_OPS_GET_RXNFC_U32_RULE_LOCS, 1,
2311                           [ethtool_ops get_rxnfc gets u32 *rule_locs])
2312         ],[
2313                 AC_MSG_RESULT(no)
2314         ])
2315
2316         AC_MSG_CHECKING([if ethtool.h enum ethtool_stringset has ETH_SS_RSS_HASH_FUNCS])
2317         LB_LINUX_TRY_COMPILE([
2318                 #include <linux/ethtool.h>
2319         ],[
2320                 enum ethtool_stringset x = ETH_SS_RSS_HASH_FUNCS;
2321
2322                 return 0;
2323         ],[
2324                 AC_MSG_RESULT(yes)
2325                 AC_DEFINE(HAVE_ETH_SS_RSS_HASH_FUNCS, 1,
2326                           [ETH_SS_RSS_HASH_FUNCS is defined])
2327         ],[
2328                 AC_MSG_RESULT(no)
2329         ])
2330 ])
2331 #
2332 # COMPAT_CONFIG_HEADERS
2333 #
2334 # add -include config.h
2335 #
2336 AC_DEFUN([COMPAT_CONFIG_HEADERS],[
2337         AC_CONFIG_HEADERS([config.h])
2338         EXTRA_KCFLAGS="-include $PWD/config.h $EXTRA_KCFLAGS"
2339         AC_SUBST(EXTRA_KCFLAGS)
2340 ])
2341
2342 AC_DEFUN([OFA_PROG_LINUX],
2343 [
2344
2345 LB_LINUX_PATH
2346 LB_LINUX_SYMVERFILE
2347 LB_LINUX_CONFIG([MODULES],[],[
2348     AC_MSG_ERROR([module support is required to build mlnx kernel modules.])
2349 ])
2350 LB_LINUX_CONFIG([MODVERSIONS])
2351 LB_LINUX_CONFIG([KALLSYMS],[],[
2352     AC_MSG_ERROR([compat_mlnx requires that CONFIG_KALLSYMS is enabled in your kernel.])
2353 ])
2354
2355 LINUX_CONFIG_COMPAT
2356 COMPAT_CONFIG_HEADERS
2357
2358 ])