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