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