config/rdma.m4

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