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