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