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