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 kernel has ktime_get_ns])
 143         LB_LINUX_TRY_COMPILE([
 144                 #include <linux/ktime.h>
 145         ],[
 146                 unsigned long long ns;
 147
 148                 ns = ktime_get_ns();
 149                 return 0;
 150         ],[
 151                 AC_MSG_RESULT(yes)
 152                 AC_DEFINE(HAVE_KTIME_GET_NS, 1,
 153                           [ktime_get_ns defined])
 154         ],[
 155                 AC_MSG_RESULT(no)
 156         ])
 157
 158         AC_MSG_CHECKING([if svc_xprt_class has xcl_ident])
 159         LB_LINUX_TRY_COMPILE([
 160                 #include <linux/sunrpc/xprt.h>
 161                 #include <linux/sunrpc/svc_xprt.h>
 162         ],[
 163                 struct svc_xprt_class svc_rdma_class = {
 164                         .xcl_ident = XPRT_TRANSPORT_RDMA,
 165                 };
 166                 return 0;
 167         ],[
 168                 AC_MSG_RESULT(yes)
 169                 AC_DEFINE(HAVE_XCL_IDENT, 1,
 170                           [xcl_ident defined])
 171         ],[
 172                 AC_MSG_RESULT(no)
 173         ])
 174
 175         AC_MSG_CHECKING([if struct ifla_vf_info has max_tx_rate])
 176         LB_LINUX_TRY_COMPILE([
 177                 #include <linux/if_link.h>
 178         ],[
 179                 struct ifla_vf_info *ivf;
 180
 181                 ivf->max_tx_rate = 0;
 182                 ivf->min_tx_rate = 0;
 183
 184                 return 0;
 185         ],[
 186                 AC_MSG_RESULT(yes)
 187                 AC_DEFINE(HAVE_TX_RATE_LIMIT, 1,
 188                           [max_tx_rate is defined])
 189         ],[
 190                 AC_MSG_RESULT(no)
 191         ])
 192
 193         AC_MSG_CHECKING([if struct ethtool_ops has get/set_rxfh])
 194         LB_LINUX_TRY_COMPILE([
 195                 #include <linux/ethtool.h>
 196         ],[
 197                 const struct ethtool_ops en_ethtool_ops = {
 198                         .get_rxfh_indir_size = NULL,
 199                         .get_rxfh = NULL,
 200                         .set_rxfh = NULL,
 201                 };
 202
 203                 return 0;
 204         ],[
 205                 AC_MSG_RESULT(yes)
 206                 AC_DEFINE(HAVE_GET_SET_RXFH, 1,
 207                           [get/set_rxfh is defined])
 208         ],[
 209                 AC_MSG_RESULT(no)
 210         ])
 211
 212
 213         AC_MSG_CHECKING([if struct ethtool_ops has get/set_tunable])
 214         LB_LINUX_TRY_COMPILE([
 215                 #include <linux/ethtool.h>
 216         ],[
 217                 const struct ethtool_ops en_ethtool_ops = {
 218                         .get_tunable = NULL,
 219                         .set_tunable = NULL,
 220                 };
 221
 222                 return 0;
 223         ],[
 224                 AC_MSG_RESULT(yes)
 225                 AC_DEFINE(HAVE_GET_SET_TUNABLE, 1,
 226                           [get/set_tunable is defined])
 227         ],[
 228                 AC_MSG_RESULT(no)
 229         ])
 230
 231         AC_MSG_CHECKING([if exist struct ethtool_ops_ext])
 232         LB_LINUX_TRY_COMPILE([
 233                 #include <linux/ethtool.h>
 234         ],[
 235                 const struct ethtool_ops_ext en_ethtool_ops_ext = {
 236                         .size = sizeof(struct ethtool_ops_ext),
 237                 };
 238
 239                 return 0;
 240         ],[
 241                 AC_MSG_RESULT(yes)
 242                 AC_DEFINE(HAVE_ETHTOOL_OPS_EXT, 1,
 243                           [struct ethtool_ops_ext is defined])
 244         ],[
 245                 AC_MSG_RESULT(no)
 246         ])
 247
 248         AC_MSG_CHECKING([if struct ethtool_ops_ext has get/set_rxfh])
 249         LB_LINUX_TRY_COMPILE([
 250                 #include <linux/ethtool.h>
 251         ],[
 252                 const struct ethtool_ops_ext en_ethtool_ops_ext = {
 253                         .get_rxfh_indir_size = NULL,
 254                         .get_rxfh = NULL,
 255                         .set_rxfh = NULL,
 256                 };
 257
 258                 return 0;
 259         ],[
 260                 AC_MSG_RESULT(yes)
 261                 AC_DEFINE(HAVE_GET_SET_RXFH_OPS_EXT, 1,
 262                           [get/set_rxfh is defined])
 263         ],[
 264                 AC_MSG_RESULT(no)
 265         ])
 266
 267         AC_MSG_CHECKING([if struct ethtool_ops_ext has get/set_rxfh_indir])
 268         LB_LINUX_TRY_COMPILE([
 269                 #include <linux/ethtool.h>
 270         ],[
 271                 const struct ethtool_ops_ext en_ethtool_ops_ext = {
 272                         .get_rxfh_indir_size = NULL,
 273                         .get_rxfh_indir = NULL,
 274                         .set_rxfh_indir = NULL,
 275                 };
 276
 277                 return 0;
 278         ],[
 279                 AC_MSG_RESULT(yes)
 280                 AC_DEFINE(HAVE_GET_SET_RXFH_INDIR, 1,
 281                           [get/set_rxfh_indir is defined])
 282         ],[
 283                 AC_MSG_RESULT(no)
 284         ])
 285
 286         AC_MSG_CHECKING([if struct net_device has dev_port])
 287         LB_LINUX_TRY_COMPILE([
 288                 #include <linux/netdevice.h>
 289         ],[
 290                 struct net_device *dev = NULL;
 291
 292                 dev->dev_port = 0;
 293
 294                 return 0;
 295         ],[
 296                 AC_MSG_RESULT(yes)
 297                 AC_DEFINE(HAVE_NET_DEVICE_DEV_PORT, 1,
 298                           [dev_port is defined])
 299         ],[
 300                 AC_MSG_RESULT(no)
 301         ])
 302
 303         AC_MSG_CHECKING([if struct ptp_clock_info has n_pins])
 304         LB_LINUX_TRY_COMPILE([
 305                 #include <linux/ptp_clock_kernel.h>
 306         ],[
 307                 struct ptp_clock_info *info;
 308                 info->n_pins = 0;
 309
 310                 return 0;
 311         ],[
 312                 AC_MSG_RESULT(yes)
 313                 AC_DEFINE(HAVE_PTP_CLOCK_INFO_N_PINS, 1,
 314                           [n_pins is defined])
 315         ],[
 316                 AC_MSG_RESULT(no)
 317         ])
 318
 319         AC_MSG_CHECKING([if pci.h pci_enable_msi_exact])
 320         LB_LINUX_TRY_COMPILE([
 321                 #include <linux/pci.h>
 322         ],[
 323                 int x = pci_enable_msi_exact(NULL, 0);
 324
 325                 return 0;
 326         ],[
 327                 AC_MSG_RESULT(yes)
 328                 AC_DEFINE(HAVE_PCI_ENABLE_MSI_EXACT, 1,
 329                           [pci_enable_msi_exact is defined])
 330         ],[
 331                 AC_MSG_RESULT(no)
 332         ])
 333
 334         AC_MSG_CHECKING([if pci.h pci_enable_msix_range])
 335         LB_LINUX_TRY_COMPILE([
 336                 #include <linux/pci.h>
 337         ],[
 338                 int x = pci_enable_msix_range(NULL, 0, 0, 0);
 339
 340                 return 0;
 341         ],[
 342                 AC_MSG_RESULT(yes)
 343                 AC_DEFINE(HAVE_PCI_ENABLE_MSIX_RANGE, 1,
 344                           [pci_enable_msix_range is defined])
 345         ],[
 346                 AC_MSG_RESULT(no)
 347         ])
 348
 349         AC_MSG_CHECKING([if struct iscsi_transport has attr_is_visible])
 350         LB_LINUX_TRY_COMPILE([
 351                 #include <scsi/scsi_transport_iscsi.h>
 352         ],[
 353                 static struct iscsi_transport iscsi_iser_transport = {
 354                         .attr_is_visible = NULL,
 355                 };
 356
 357                 return 0;
 358         ],[
 359                 AC_MSG_RESULT(yes)
 360                 AC_DEFINE(HAVE_ISCSI_ATTR_IS_VISIBLE, 1,
 361                           [attr_is_visible is defined])
 362         ],[
 363                 AC_MSG_RESULT(no)
 364         ])
 365
 366         AC_MSG_CHECKING([if struct iscsi_transport has get_ep_param])
 367         LB_LINUX_TRY_COMPILE([
 368                 #include <scsi/scsi_transport_iscsi.h>
 369         ],[
 370                 static struct iscsi_transport iscsi_iser_transport = {
 371                         .get_ep_param = NULL,
 372                 };
 373
 374                 return 0;
 375         ],[
 376                 AC_MSG_RESULT(yes)
 377                 AC_DEFINE(HAVE_ISCSI_GET_EP_PARAM, 1,
 378                           [get_ep_param is defined])
 379         ],[
 380                 AC_MSG_RESULT(no)
 381         ])
 382
 383         AC_MSG_CHECKING([if struct iscsi_transport has check_protection])
 384         LB_LINUX_TRY_COMPILE([
 385                 #include <scsi/scsi_transport_iscsi.h>
 386         ],[
 387                 static struct iscsi_transport iscsi_iser_transport = {
 388                         .check_protection = NULL,
 389                 };
 390
 391                 return 0;
 392         ],[
 393                 AC_MSG_RESULT(yes)
 394                 AC_DEFINE(HAVE_ISCSI_CHECK_PROTECTION, 1,
 395                           [check_protection is defined])
 396         ],[
 397                 AC_MSG_RESULT(no)
 398         ])
 399
 400         AC_MSG_CHECKING([if iscsi_proto.h has struct iscsi_scsi_req])
 401         LB_LINUX_TRY_COMPILE([
 402                 #include <scsi/iscsi_proto.h>
 403         ],[
 404                 struct iscsi_scsi_req *req = NULL;
 405
 406                 return 0;
 407         ],[
 408                 AC_MSG_RESULT(yes)
 409                 AC_DEFINE(HAVE_ISCSI_SCSI_REQ, 1,
 410                           [struct iscsi_scsi_req is defined])
 411         ],[
 412                 AC_MSG_RESULT(no)
 413         ])
 414
 415         AC_MSG_CHECKING([if netdevice.h has select_queue_fallback_t])
 416         LB_LINUX_TRY_COMPILE([
 417                 #include <linux/netdevice.h>
 418         ],[
 419                 select_queue_fallback_t fallback;
 420
 421                 fallback = NULL;
 422
 423                 return 0;
 424         ],[
 425                 AC_MSG_RESULT(yes)
 426                 AC_DEFINE(HAVE_SELECT_QUEUE_FALLBACK_T, 1,
 427                           [select_queue_fallback_t is defined])
 428         ],[
 429                 AC_MSG_RESULT(no)
 430         ])
 431
 432         AC_MSG_CHECKING([if skbuff.h has skb_set_hash])
 433         LB_LINUX_TRY_COMPILE([
 434                 #include <linux/netdevice.h>
 435         ],[
 436                 skb_set_hash(NULL, 0, PKT_HASH_TYPE_L3);
 437
 438                 return 0;
 439         ],[
 440                 AC_MSG_RESULT(yes)
 441                 AC_DEFINE(HAVE_SKB_SET_HASH, 1,
 442                           [skb_set_hash is defined])
 443         ],[
 444                 AC_MSG_RESULT(no)
 445         ])
 446
 447         AC_MSG_CHECKING([if sockios.h has SIOCGHWTSTAMP])
 448         LB_LINUX_TRY_COMPILE([
 449                 #include <linux/sockios.h>
 450         ],[
 451                 int x = SIOCGHWTSTAMP;
 452
 453                 return 0;
 454         ],[
 455                 AC_MSG_RESULT(yes)
 456                 AC_DEFINE(HAVE_SIOCGHWTSTAMP, 1,
 457                           [SIOCGHWTSTAMP is defined])
 458         ],[
 459                 AC_MSG_RESULT(no)
 460         ])
 461
 462         AC_MSG_CHECKING([if ip.h inet_get_local_port_range has 3 parameters])
 463         LB_LINUX_TRY_COMPILE([
 464                 #include <net/ip.h>
 465         ],[
 466                 inet_get_local_port_range(NULL, NULL, NULL);
 467
 468                 return 0;
 469         ],[
 470                 AC_MSG_RESULT(yes)
 471                 AC_DEFINE(HAVE_INET_GET_LOCAL_PORT_RANGE_3_PARAMS, 1,
 472                           [inet_get_local_port_range has 3 parameters])
 473         ],[
 474                 AC_MSG_RESULT(no)
 475         ])
 476
 477         AC_MSG_CHECKING([if net.h has net_get_random_once])
 478         LB_LINUX_TRY_COMPILE([
 479                 #include <linux/net.h>
 480         ],[
 481                 net_get_random_once(NULL, 0);
 482
 483                 return 0;
 484         ],[
 485                 AC_MSG_RESULT(yes)
 486                 AC_DEFINE(HAVE_NET_GET_RANDOM_ONCE, 1,
 487                           [net_get_random_once is defined])
 488         ],[
 489                 AC_MSG_RESULT(no)
 490         ])
 491
 492         AC_MSG_CHECKING([if inet_sock.h has __inet_ehashfn])
 493         LB_LINUX_TRY_COMPILE([
 494                 #include <net/inet_sock.h>
 495         ],[
 496                 __inet_ehashfn(0, 0, 0, 0, 0);
 497
 498                 return 0;
 499         ],[
 500                 AC_MSG_RESULT(yes)
 501                 AC_DEFINE(HAVE_INET_EHASHFN, 1,
 502                           [__inet_ehashfn is defined])
 503         ],[
 504                 AC_MSG_RESULT(no)
 505         ])
 506
 507         AC_MSG_CHECKING([if err.h has PTR_ERR_OR_ZERO])
 508         LB_LINUX_TRY_COMPILE([
 509                 #include <linux/err.h>
 510         ],[
 511                 int x = PTR_ERR_OR_ZERO(NULL);
 512
 513                 return 0;
 514         ],[
 515                 AC_MSG_RESULT(yes)
 516                 AC_DEFINE(HAVE_PTR_ERR_OR_ZERO, 1,
 517                           [PTR_ERR_OR_ZERO is defined])
 518         ],[
 519                 AC_MSG_RESULT(no)
 520         ])
 521
 522         AC_MSG_CHECKING([if struct iscsi_session has discovery_sess])
 523         LB_LINUX_TRY_COMPILE([
 524                 #include <scsi/libiscsi.h>
 525         ],[
 526                 struct iscsi_session session;
 527                 session.discovery_sess = 0;
 528
 529                 return 0;
 530         ],[
 531                 AC_MSG_RESULT(yes)
 532                 AC_DEFINE(HAVE_ISCSI_DISCOVERY_SESS, 1,
 533                           [discovery_sess is defined])
 534         ],[
 535                 AC_MSG_RESULT(no)
 536         ])
 537
 538         AC_MSG_CHECKING([if enum iscsi_param has ISCSI_PARAM_DISCOVERY_SESS])
 539         LB_LINUX_TRY_COMPILE([
 540                 #include <scsi/iscsi_if.h>
 541         ],[
 542                 int x = ISCSI_PARAM_DISCOVERY_SESS;
 543
 544                 return 0;
 545         ],[
 546                 AC_MSG_RESULT(yes)
 547                 AC_DEFINE(HAVE_ISCSI_PARAM_DISCOVERY_SESS, 1,
 548                           [ISCSI_PARAM_DISCOVERY_SESS is defined])
 549         ],[
 550                 AC_MSG_RESULT(no)
 551         ])
 552
 553         AC_MSG_CHECKING([if pci.h has enum pcie_link_width])
 554         LB_LINUX_TRY_COMPILE([
 555                 #include <linux/pci.h>
 556         ],[
 557                 enum pcie_link_width width = PCIE_LNK_WIDTH_UNKNOWN;
 558
 559                 return 0;
 560         ],[
 561                 AC_MSG_RESULT(yes)
 562                 AC_DEFINE(HAVE_PCIE_LINK_WIDTH, 1,
 563                           [pcie_link_width is defined])
 564         ],[
 565                 AC_MSG_RESULT(no)
 566         ])
 567
 568         AC_MSG_CHECKING([if pci.h has enum pci_bus_speed])
 569         LB_LINUX_TRY_COMPILE([
 570                 #include <linux/pci.h>
 571         ],[
 572                 enum pci_bus_speed speed = PCI_SPEED_UNKNOWN;
 573
 574                 return 0;
 575         ],[
 576                 AC_MSG_RESULT(yes)
 577                 AC_DEFINE(HAVE_PCI_BUS_SPEED, 1,
 578                           [pci_bus_speed is defined])
 579         ],[
 580                 AC_MSG_RESULT(no)
 581         ])
 582
 583         AC_MSG_CHECKING([if netdevice.h has struct netdev_phys_port_id])
 584         LB_LINUX_TRY_COMPILE([
 585                 #include <linux/netdevice.h>
 586         ],[
 587                 struct netdev_phys_port_id *x = NULL;
 588
 589                 return 0;
 590         ],[
 591                 AC_MSG_RESULT(yes)
 592                 AC_DEFINE(HAVE_NETDEV_PHYS_PORT_ID, 1,
 593                           [netdev_phys_port_id is defined])
 594         ],[
 595                 AC_MSG_RESULT(no)
 596         ])
 597
 598         AC_MSG_CHECKING([if struct ifla_vf_info has linkstate])
 599         LB_LINUX_TRY_COMPILE([
 600                 #include <linux/if_link.h>
 601         ],[
 602                 struct struct ifla_vf_info x;
 603                 x->linkstate = 0;
 604
 605                 return 0;
 606         ],[
 607                 AC_MSG_RESULT(yes)
 608                 AC_DEFINE(HAVE_LINKSTATE, 1,
 609                           [linkstate is defined])
 610         ],[
 611                 AC_MSG_RESULT(no)
 612         ])
 613
 614         AC_MSG_CHECKING([if busy_poll.h has skb_mark_napi_id])
 615         LB_LINUX_TRY_COMPILE([
 616                 #include <net/busy_poll.h>
 617         ],[
 618                 skb_mark_napi_id(NULL, NULL);
 619
 620                 return 0;
 621         ],[
 622                 AC_MSG_RESULT(yes)
 623                 AC_DEFINE(HAVE_SKB_MARK_NAPI_ID, 1,
 624                           [skb_mark_napi_id is defined])
 625         ],[
 626                 AC_MSG_RESULT(no)
 627         ])
 628
 629         AC_MSG_CHECKING([if netdevice.h has napi_hash_add])
 630         LB_LINUX_TRY_COMPILE([
 631                 #include <linux/netdevice.h>
 632         ],[
 633                 napi_hash_add(NULL);
 634
 635                 return 0;
 636         ],[
 637                 AC_MSG_RESULT(yes)
 638                 AC_DEFINE(HAVE_NAPI_HASH_ADD, 1,
 639                           [napi_hash_add is defined])
 640         ],[
 641                 AC_MSG_RESULT(no)
 642         ])
 643
 644         AC_MSG_CHECKING([if netdevice.h has netif_keep_dst])
 645         LB_LINUX_TRY_COMPILE([
 646                 #include <linux/netdevice.h>
 647         ],[
 648                 netif_keep_dst(NULL);
 649
 650                 return 0;
 651         ],[
 652                 AC_MSG_RESULT(yes)
 653                 AC_DEFINE(HAVE_NETIF_KEEP_DST, 1,
 654                           [netif_keep_dst is defined])
 655         ],[
 656                 AC_MSG_RESULT(no)
 657         ])
 658
 659         AC_MSG_CHECKING([if mm.h has kvfree])
 660         LB_LINUX_TRY_COMPILE([
 661                 #include <linux/mm.h>
 662         ],[
 663                 kvfree(NULL);
 664
 665                 return 0;
 666         ],[
 667                 AC_MSG_RESULT(yes)
 668                 AC_DEFINE(HAVE_KVFREE, 1,
 669                           [kvfree is defined])
 670         ],[
 671                 AC_MSG_RESULT(no)
 672         ])
 673
 674         AC_MSG_CHECKING([if netdevice.h has dev_consume_skb_any])
 675         LB_LINUX_TRY_COMPILE([
 676                 #include <linux/netdevice.h>
 677         ],[
 678                 dev_consume_skb_any(NULL);
 679
 680                 return 0;
 681         ],[
 682                 AC_MSG_RESULT(yes)
 683                 AC_DEFINE(HAVE_DEV_CONSUME_SKB_ANY, 1,
 684                           [dev_consume_skb_any is defined])
 685         ],[
 686                 AC_MSG_RESULT(no)
 687         ])
 688
 689         AC_MSG_CHECKING([if netdevice.h has netdev_txq_bql_complete_prefetchw])
 690         LB_LINUX_TRY_COMPILE([
 691                 #include <linux/netdevice.h>
 692         ],[
 693                 netdev_txq_bql_complete_prefetchw(NULL);
 694                 netdev_txq_bql_enqueue_prefetchw(NULL);
 695
 696                 return 0;
 697         ],[
 698                 AC_MSG_RESULT(yes)
 699                 AC_DEFINE(HAVE_NETDEV_TXQ_BQL_PREFETCHW, 1,
 700                           [netdev_txq_bql_complete_prefetchw is defined])
 701         ],[
 702                 AC_MSG_RESULT(no)
 703         ])
 704
 705         AC_MSG_CHECKING([if struct sk_buff has xmit_more])
 706         LB_LINUX_TRY_COMPILE([
 707                 #include <linux/skbuff.h>
 708         ],[
 709                 struct sk_buff *skb;
 710                 skb->xmit_more = 0;
 711
 712                 return 0;
 713         ],[
 714                 AC_MSG_RESULT(yes)
 715                 AC_DEFINE(HAVE_SK_BUFF_XMIT_MORE, 1,
 716                           [xmit_more is defined])
 717         ],[
 718                 AC_MSG_RESULT(no)
 719         ])
 720
 721         AC_MSG_CHECKING([if struct sk_buff has encapsulation])
 722         LB_LINUX_TRY_COMPILE([
 723                 #include <linux/skbuff.h>
 724         ],[
 725                 struct sk_buff *skb;
 726                 skb->encapsulation = 0;
 727
 728                 return 0;
 729         ],[
 730                 AC_MSG_RESULT(yes)
 731                 AC_DEFINE(HAVE_SK_BUFF_ENCAPSULATION, 1,
 732                           [encapsulation is defined])
 733         ],[
 734                 AC_MSG_RESULT(no)
 735         ])
 736
 737         AC_MSG_CHECKING([if etherdevice.h has eth_get_headlen])
 738         LB_LINUX_TRY_COMPILE([
 739                 #include <linux/etherdevice.h>
 740         ],[
 741                 eth_get_headlen(NULL, 0);
 742
 743                 return 0;
 744         ],[
 745                 AC_MSG_RESULT(yes)
 746                 AC_DEFINE(HAVE_ETH_GET_HEADLEN, 1,
 747                           [eth_get_headlen is defined])
 748         ],[
 749                 AC_MSG_RESULT(no)
 750         ])
 751
 752         AC_MSG_CHECKING([if struct sk_buff has csum_level])
 753         LB_LINUX_TRY_COMPILE([
 754                 #include <linux/skbuff.h>
 755         ],[
 756                 struct sk_buff *skb;
 757                 skb->csum_level = 0;
 758
 759                 return 0;
 760         ],[
 761                 AC_MSG_RESULT(yes)
 762                 AC_DEFINE(HAVE_SK_BUFF_CSUM_LEVEL, 1,
 763                           [csum_level is defined])
 764         ],[
 765                 AC_MSG_RESULT(no)
 766         ])
 767
 768         AC_MSG_CHECKING([if struct skbuff.h has skb_inner_transport_header])
 769         LB_LINUX_TRY_COMPILE([
 770                 #include <linux/skbuff.h>
 771         ],[
 772                 skb_inner_transport_header(NULL);
 773
 774                 return 0;
 775         ],[
 776                 AC_MSG_RESULT(yes)
 777                 AC_DEFINE(HAVE_SKB_INNER_TRANSPORT_HEADER, 1,
 778                           [skb_inner_transport_header is defined])
 779         ],[
 780                 AC_MSG_RESULT(no)
 781         ])
 782
 783         AC_MSG_CHECKING([if struct skbuff.h has skb_inner_network_header])
 784         LB_LINUX_TRY_COMPILE([
 785                 #include <linux/skbuff.h>
 786         ],[
 787                 skb_inner_network_header(NULL);
 788
 789                 return 0;
 790         ],[
 791                 AC_MSG_RESULT(yes)
 792                 AC_DEFINE(HAVE_SKB_INNER_NETWORK_HEADER, 1,
 793                           [skb_inner_network_header is defined])
 794         ],[
 795                 AC_MSG_RESULT(no)
 796         ])
 797
 798         AC_MSG_CHECKING([if if_vlan.h has vlan_dev_get_egress_qos_mask])
 799         LB_LINUX_TRY_COMPILE([
 800                 #include <linux/if_vlan.h>
 801         ],[
 802                 vlan_dev_get_egress_qos_mask(NULL, 0);
 803
 804                 return 0;
 805         ],[
 806                 AC_MSG_RESULT(yes)
 807                 AC_DEFINE(HAVE_VLAN_DEV_GET_EGRESS_QOS_MASK, 1,
 808                           [vlan_dev_get_egress_qos_mask is defined])
 809         ],[
 810                 AC_MSG_RESULT(no)
 811         ])
 812
 813         AC_MSG_CHECKING([if netdevice.h has netdev_get_prio_tc_map])
 814         LB_LINUX_TRY_COMPILE([
 815                 #include <linux/netdevice.h>
 816         ],[
 817                 netdev_get_prio_tc_map(NULL, 0);
 818
 819                 return 0;
 820         ],[
 821                 AC_MSG_RESULT(yes)
 822                 AC_DEFINE(HAVE_NETDEV_GET_PRIO_TC_MAP, 1,
 823                           [netdev_get_prio_tc_map is defined])
 824         ],[
 825                 AC_MSG_RESULT(no)
 826         ])
 827
 828         AC_MSG_CHECKING([if if_vlan.h has __vlan_find_dev_deep_rcu])
 829         LB_LINUX_TRY_COMPILE([
 830                 #include <linux/if_vlan.h>
 831         ],[
 832                 __vlan_find_dev_deep_rcu(NULL, 0, 0);
 833
 834                 return 0;
 835         ],[
 836                 AC_MSG_RESULT(yes)
 837                 AC_DEFINE(HAVE___VLAN_FIND_DEV_DEEP_RCU, 1,
 838                           [__vlan_find_dev_deep_rcu is defined])
 839         ],[
 840                 AC_MSG_RESULT(no)
 841         ])
 842
 843         AC_MSG_CHECKING([if ndo_select_queue has accel_priv])
 844         LB_LINUX_TRY_COMPILE([
 845                 #include <linux/netdevice.h>
 846
 847                 static u16 select_queue(struct net_device *dev, struct sk_buff *skb,
 848                                         void *accel_priv)
 849                 {
 850                         return 0;
 851                 }
 852         ],[
 853                 struct net_device_opts ndops;
 854
 855                 ndops.ndo_select_queue = select_queue;
 856
 857                 return 0;
 858         ],[
 859                 AC_MSG_RESULT(yes)
 860                 AC_DEFINE(NDO_SELECT_QUEUE_HAS_ACCEL_PRIV, 1,
 861                           [ndo_select_queue has accel_priv])
 862         ],[
 863                 AC_MSG_RESULT(no)
 864         ])
 865
 866         AC_MSG_CHECKING([if drivers/net/bonding/bonding.h exists])
 867         LB_LINUX_TRY_COMPILE([
 868                 #include "../drivers/net/bonding/bonding.h"
 869         ],[
 870                 return 0;
 871         ],[
 872                 AC_MSG_RESULT(yes)
 873                 AC_DEFINE(HAVE_BONDING_H, 1,
 874                           [drivers/net/bonding/bonding.h exists])
 875         ],[
 876                 AC_MSG_RESULT(no)
 877         ])
 878
 879         AC_MSG_CHECKING([if bonding.h bond_for_each_slave has 3 parameters])
 880         LB_LINUX_TRY_COMPILE([
 881                 #include "../drivers/net/bonding/bonding.h"
 882         ],[
 883                 struct bonding *bond = NULL;
 884                 struct list_head *iter = NULL;
 885                 struct slave *slave = NULL;
 886
 887                 bond_for_each_slave(bond, slave, iter) ;
 888
 889                 return 0;
 890         ],[
 891                 AC_MSG_RESULT(yes)
 892                 AC_DEFINE(HAVE_BOND_FOR_EACH_SLAVE_3_PARAMS, 1,
 893                           [bond_for_each_slave has 3 parameters])
 894         ],[
 895                 AC_MSG_RESULT(no)
 896         ])
 897
 898
 899         AC_MSG_CHECKING([if u64_stats_sync.h has u64_stats_init])
 900         LB_LINUX_TRY_COMPILE([
 901                 #include <linux/u64_stats_sync.h>
 902         ],[
 903                 struct u64_stats_sync sync;
 904                 u64_stats_init(&sync);
 905
 906                 return 0;
 907         ],[
 908                 AC_MSG_RESULT(yes)
 909                 AC_DEFINE(HAVE_U64_STATS_SYNC, 1,
 910                           [u64_stats_sync is defined])
 911         ],[
 912                 AC_MSG_RESULT(no)
 913         ])
 914
 915         AC_MSG_CHECKING([if u64_stats_sync.h has u64_stats_fetch_begin_irq])
 916         LB_LINUX_TRY_COMPILE([
 917                 #include <linux/u64_stats_sync.h>
 918         ],[
 919                 struct u64_stats_sync sync;
 920                 u64_stats_fetch_begin_irq(&sync);
 921
 922                 return 0;
 923         ],[
 924                 AC_MSG_RESULT(yes)
 925                 AC_DEFINE(HAVE_U64_STATS_FETCH_BEGIN_IRQ, 1,
 926                           [u64_stats_fetch_begin_irq is defined])
 927         ],[
 928                 AC_MSG_RESULT(no)
 929         ])
 930         AC_MSG_CHECKING([if etherdevice.h has ether_addr_copy])
 931         LB_LINUX_TRY_COMPILE([
 932                 #include <linux/etherdevice.h>
 933         ],[
 934                 char dest[6], src[6];
 935                 ether_addr_copy(&dest, &src);
 936
 937                 return 0;
 938         ],[
 939                 AC_MSG_RESULT(yes)
 940                 AC_DEFINE(HAVE_ETHER_ADDR_COPY, 1,
 941                           [ether_addr_copy is defined])
 942         ],[
 943                 AC_MSG_RESULT(no)
 944         ])
 945
 946         AC_MSG_CHECKING([if struct net_device_ops has *ndo_set_vf_rate])
 947         LB_LINUX_TRY_COMPILE([
 948                 #include <linux/netdevice.h>
 949
 950                 int set_vf_rate(struct net_device *dev, int vf, int min_tx_rate,
 951                                                    int max_tx_rate)
 952                 {
 953                         return 0;
 954                 }
 955         ],[
 956                 struct net_device_ops netdev_ops;
 957
 958                 netdev_ops.ndo_set_vf_rate = set_vf_rate;
 959                 return 0;
 960         ],[
 961                 AC_MSG_RESULT(yes)
 962                 AC_DEFINE(HAVE_SET_VF_RATE, 1,
 963                           [ndo_set_vf_rate is defined])
 964         ],[
 965                 AC_MSG_RESULT(no)
 966         ])
 967
 968         AC_MSG_CHECKING([if netdev_extended has hw_features])
 969         LB_LINUX_TRY_COMPILE([
 970                 #include <linux/netdevice.h>
 971         ],[
 972                 struct net_device *dev = NULL;
 973
 974                 netdev_extended(dev)->hw_features = 0;
 975
 976                 return 0;
 977         ],[
 978                 AC_MSG_RESULT(yes)
 979                 AC_DEFINE(HAVE_NETDEV_EXTENDED_HW_FEATURES, 1,
 980                           [ is defined])
 981         ],[
 982                 AC_MSG_RESULT(no)
 983         ])
 984
 985         AC_MSG_CHECKING([if net_device_extended has _tx_ext])
 986         LB_LINUX_TRY_COMPILE([
 987                 #include <linux/netdevice.h>
 988         ],[
 989                 struct net_device *dev = NULL;
 990
 991                 netdev_extended(dev)->_tx_ext = NULL;
 992
 993                 return 0;
 994         ],[
 995                 AC_MSG_RESULT(yes)
 996                 AC_DEFINE(HAVE_NET_DEVICE_EXTENDED_TX_EXT, 1,
 997                           [ is defined])
 998         ],[
 999                 AC_MSG_RESULT(no)
1000         ])
1001
1002         AC_MSG_CHECKING([if net_device_extended has ndo_busy_poll])
1003         LB_LINUX_TRY_COMPILE([
1004                 #include <linux/netdevice.h>
1005
1006                 int busy_poll(struct napi_struct *napi)
1007                 {
1008                         return 0;
1009                 }
1010         ],[
1011                 struct net_device *dev = NULL;
1012
1013                 netdev_extended(dev)->ndo_busy_poll = busy_poll;
1014
1015                 return 0;
1016         ],[
1017                 AC_MSG_RESULT(yes)
1018                 AC_DEFINE(HAVE_NETDEV_EXTENDED_NDO_BUSY_POLL, 1,
1019                           [ is defined])
1020         ],[
1021                 AC_MSG_RESULT(no)
1022         ])
1023
1024         AC_MSG_CHECKING([if netdevice.h has set_netdev_hw_features])
1025         LB_LINUX_TRY_COMPILE([
1026                 #include <linux/netdevice.h>
1027         ],[
1028                 struct net_device *dev = NULL;
1029
1030                 set_netdev_hw_features(dev, 0);
1031
1032                 return 0;
1033         ],[
1034                 AC_MSG_RESULT(yes)
1035                 AC_DEFINE(HAVE_SET_NETDEV_HW_FEATURES, 1,
1036                           [ is defined])
1037         ],[
1038                 AC_MSG_RESULT(no)
1039         ])
1040
1041         AC_MSG_CHECKING([if netdevice.h has netif_set_xps_queue])
1042         LB_LINUX_TRY_COMPILE([
1043                 #include <linux/netdevice.h>
1044         ],[
1045                 struct net_device *dev = NULL;
1046
1047                 netif_set_xps_queue(dev, NULL, 0);
1048
1049                 return 0;
1050         ],[
1051                 AC_MSG_RESULT(yes)
1052                 AC_DEFINE(HAVE_NETIF_SET_XPS_QUEUE, 1,
1053                           [ is defined])
1054         ],[
1055                 AC_MSG_RESULT(no)
1056         ])
1057
1058
1059         AC_MSG_CHECKING([if struct net_device_ops has *ndo_set_features])
1060         LB_LINUX_TRY_COMPILE([
1061                 #include <linux/netdevice.h>
1062
1063                 int set_features(struct net_device *dev, netdev_features_t features)
1064                 {
1065                         return 0;
1066                 }
1067         ],[
1068                 struct net_device_ops netdev_ops;
1069
1070                 netdev_ops.ndo_set_features = set_features;
1071                 return 0;
1072         ],[
1073                 AC_MSG_RESULT(yes)
1074                 AC_DEFINE(HAVE_NDO_SET_FEATURES, 1,
1075                           [ndo_set_features is defined])
1076         ],[
1077                 AC_MSG_RESULT(no)
1078         ])
1079
1080         AC_MSG_CHECKING([if struct net_device_ops has *ndo_setup_tc])
1081         LB_LINUX_TRY_COMPILE([
1082                 #include <linux/netdevice.h>
1083
1084                 int setup_tc(struct net_device *dev, , u8 tc)
1085                 {
1086                         return 0;
1087                 }
1088         ],[
1089                 struct net_device_ops netdev_ops;
1090
1091                 netdev_ops.ndo_setup_tc = setup_tc;
1092                 return 0;
1093         ],[
1094                 AC_MSG_RESULT(yes)
1095                 AC_DEFINE(HAVE_NDO_SETUP_TC, 1,
1096                           [ndo_setup_tc is defined])
1097         ],[
1098                 AC_MSG_RESULT(no)
1099         ])
1100
1101         AC_MSG_CHECKING([if struct net_device_ops has *ndo_rx_flow_steer])
1102         LB_LINUX_TRY_COMPILE([
1103                 #include <linux/netdevice.h>
1104
1105                 int rx_flow_steer(struct net_device *dev,
1106                                                      const struct sk_buff *skb,
1107                                                      u16 rxq_index,
1108                                                      u32 flow_id)
1109                 {
1110                         return 0;
1111                 }
1112         ],[
1113                 struct net_device_ops netdev_ops;
1114
1115                 netdev_ops.ndo_rx_flow_steer = rx_flow_steer;
1116                 return 0;
1117         ],[
1118                 AC_MSG_RESULT(yes)
1119                 AC_DEFINE(HAVE_NDO_RX_FLOW_STEER, 1,
1120                           [ndo_rx_flow_steer is defined])
1121         ],[
1122                 AC_MSG_RESULT(no)
1123         ])
1124
1125         AC_MSG_CHECKING([if struct net_device has priv_flags])
1126         LB_LINUX_TRY_COMPILE([
1127                 #include <linux/netdevice.h>
1128         ],[
1129                 struct net_device *netdev;
1130                 netdev->priv_flags = 0;
1131
1132                 return 0;
1133         ],[
1134                 AC_MSG_RESULT(yes)
1135                 AC_DEFINE(HAVE_NET_DEVICE_PRIV_FLAGS, 1,
1136                           [priv_flags is defined])
1137         ],[
1138                 AC_MSG_RESULT(no)
1139         ])
1140
1141         AC_MSG_CHECKING([if struct net_device_ops has *ndo_get_stats64])
1142         LB_LINUX_TRY_COMPILE([
1143                 #include <linux/netdevice.h>
1144
1145                 struct rtnl_link_stats64* get_stats_64(struct net_device *dev,
1146                                                      struct rtnl_link_stats64 *storage)
1147                 {
1148                         struct rtnl_link_stats64 stats_64;
1149                         return &stats_64;
1150                 }
1151         ],[
1152                 struct net_device_ops netdev_ops;
1153
1154                 netdev_ops.ndo_get_stats64 = get_stats_64;
1155
1156                 return 0;
1157         ],[
1158                 AC_MSG_RESULT(yes)
1159                 AC_DEFINE(HAVE_NDO_GET_STATS64, 1,
1160                           [ndo_get_stats64 is defined])
1161         ],[
1162                 AC_MSG_RESULT(no)
1163         ])
1164         AC_MSG_CHECKING([if struct net_device_ops has ndo_bridge_set/getlink])
1165         LB_LINUX_TRY_COMPILE([
1166                 #include <linux/netdevice.h>
1167         ],[
1168                 struct net_device_ops netdev_ops =  {
1169                         .ndo_bridge_setlink = NULL,
1170                         .ndo_bridge_getlink = NULL,
1171                 };
1172
1173                 return 0;
1174         ],[
1175                 AC_MSG_RESULT(yes)
1176                 AC_DEFINE(HAVE_NDO_BRIDGE_SET_GET_LINK, 1,
1177                           [ndo_bridge_set/getlink is defined])
1178         ],[
1179                 AC_MSG_RESULT(no)
1180         ])
1181
1182         AC_MSG_CHECKING([if struct net_device_ops ndo_vlan_rx_add_vid has 3 parameters ])
1183         LB_LINUX_TRY_COMPILE([
1184                 #include <linux/netdevice.h>
1185
1186                 int vlan_rx_add_vid(struct net_device *dev,__be16 proto, u16 vid)
1187                 {
1188                         return 0;
1189                 }
1190         ],[
1191                 struct net_device_ops netdev_ops;
1192
1193                 netdev_ops.ndo_vlan_rx_add_vid = vlan_rx_add_vid;
1194
1195                 return 0;
1196         ],[
1197                 AC_MSG_RESULT(yes)
1198                 AC_DEFINE(HAVE_NDO_RX_ADD_VID_HAS_3_PARAMS, 1,
1199                           [ndo_vlan_rx_add_vid has 3 parameters])
1200         ],[
1201                 AC_MSG_RESULT(no)
1202         ])
1203
1204         AC_MSG_CHECKING([if net_device_ops has ndo_get_phys_port_id])
1205         LB_LINUX_TRY_COMPILE([
1206                 #include <linux/netdevice.h>
1207
1208                 int get_phys_port_id(struct net_device *dev,
1209                                      struct netdev_phys_port_id *ppid)
1210                 {
1211                         return 0;
1212                 }
1213         ],[
1214                 struct net_device_ops netdev_ops;
1215
1216                 netdev_ops.ndo_get_phys_port_id = get_phys_port_id;
1217
1218                 return 0;
1219         ],[
1220                 AC_MSG_RESULT(yes)
1221                 AC_DEFINE(HAVE_NETDEV_NDO_GET_PHYS_PORT_ID, 1,
1222                           [ is defined])
1223         ],[
1224                 AC_MSG_RESULT(no)
1225         ])
1226
1227         AC_MSG_CHECKING([if struct net_device_ops_ext exist])
1228         LB_LINUX_TRY_COMPILE([
1229                 #include <linux/netdevice.h>
1230         ],[
1231                 struct net_device_ops_ext netdev_ops_ext;
1232                 struct net_device_ops_ext netdev_ops__ext = {
1233                         .size                   = sizeof(struct net_device_ops_ext),
1234                 };
1235
1236                 return 0;
1237         ],[
1238                 AC_MSG_RESULT(yes)
1239                 AC_DEFINE(HAVE_NET_DEVICE_OPS_EXT, 1,
1240                           [struct net_device_ops_ext is defined])
1241         ],[
1242                 AC_MSG_RESULT(no)
1243         ])
1244
1245         AC_MSG_CHECKING([if net_device_ops_ext has ndo_get_phys_port_id])
1246         LB_LINUX_TRY_COMPILE([
1247                 #include <linux/netdevice.h>
1248
1249                 int get_phys_port_id(struct net_device *dev,
1250                                      struct netdev_phys_port_id *ppid)
1251                 {
1252                         return 0;
1253                 }
1254         ],[
1255                 struct net_device_ops_ext netdev_ops_ext;
1256
1257                 netdev_ops_ext.ndo_get_phys_port_id = get_phys_port_id;
1258
1259                 return 0;
1260         ],[
1261                 AC_MSG_RESULT(yes)
1262                 AC_DEFINE(HAVE_NETDEV_EXT_NDO_GET_PHYS_PORT_ID, 1,
1263                           [ndo_get_phys_port_id is defined])
1264         ],[
1265                 AC_MSG_RESULT(no)
1266         ])
1267
1268         AC_MSG_CHECKING([if net_device_ops has ndo_set_vf_spoofchk])
1269         LB_LINUX_TRY_COMPILE([
1270                 #include <linux/netdevice.h>
1271
1272                 int set_vf_spoofchk(struct net_device *dev, int vf, bool setting)
1273                 {
1274                         return 0;
1275                 }
1276         ],[
1277                 struct net_device_ops netdev_ops;
1278
1279                 netdev_ops.ndo_set_vf_spoofchk = set_vf_spoofchk;
1280
1281                 return 0;
1282         ],[
1283                 AC_MSG_RESULT(yes)
1284                 AC_DEFINE(HAVE_NETDEV_OPS_NDO_SET_VF_SPOOFCHK, 1,
1285                           [ndo_set_vf_spoofchk is defined in net_device_ops])
1286         ],[
1287                 AC_MSG_RESULT(no)
1288         ])
1289
1290         AC_MSG_CHECKING([if net_device_ops_ext has ndo_set_vf_spoofchk])
1291         LB_LINUX_TRY_COMPILE([
1292                 #include <linux/netdevice.h>
1293
1294                 int set_vf_spoofchk(struct net_device *dev, int vf, bool setting)
1295                 {
1296                         return 0;
1297                 }
1298         ],[
1299                 struct net_device_ops_ext netdev_ops_ext;
1300
1301                 netdev_ops_ext.ndo_set_vf_spoofchk = set_vf_spoofchk;
1302
1303                 return 0;
1304         ],[
1305                 AC_MSG_RESULT(yes)
1306                 AC_DEFINE(HAVE_NETDEV_OPS_EXT_NDO_SET_VF_SPOOFCHK, 1,
1307                           [ndo_set_vf_spoofchk is defined in net_device_ops_ext])
1308         ],[
1309                 AC_MSG_RESULT(no)
1310         ])
1311
1312         AC_MSG_CHECKING([if net_device_ops has ndo_set_vf_link_state])
1313         LB_LINUX_TRY_COMPILE([
1314                 #include <linux/netdevice.h>
1315
1316                 int set_vf_link_state(struct net_device *dev, int vf, int link_state)
1317                 {
1318                         return 0;
1319                 }
1320         ],[
1321                 struct net_device_ops netdev_ops;
1322
1323                 netdev_ops.ndo_set_vf_link_state = set_vf_link_state;
1324
1325                 return 0;
1326         ],[
1327                 AC_MSG_RESULT(yes)
1328                 AC_DEFINE(HAVE_NETDEV_OPS_NDO_SET_VF_LINK_STATE, 1,
1329                           [ndo_set_vf_link_state is defined in net_device_ops])
1330         ],[
1331                 AC_MSG_RESULT(no)
1332         ])
1333
1334         AC_MSG_CHECKING([if net_device_ops_ext has ndo_set_vf_link_state])
1335         LB_LINUX_TRY_COMPILE([
1336                 #include <linux/netdevice.h>
1337
1338                 int set_vf_link_state(struct net_device *dev, int vf, int link_state)
1339                 {
1340                         return 0;
1341                 }
1342         ],[
1343                 struct net_device_ops_ext netdev_ops_ext;
1344
1345                 netdev_ops_ext.ndo_set_vf_link_state = set_vf_link_state;
1346
1347                 return 0;
1348         ],[
1349                 AC_MSG_RESULT(yes)
1350                 AC_DEFINE(HAVE_NETDEV_OPS_EXT_NDO_SET_VF_LINK_STATE, 1,
1351                           [ndo_set_vf_link_state is defined])
1352         ],[
1353                 AC_MSG_RESULT(no)
1354         ])
1355
1356
1357         AC_MSG_CHECKING([if netdevice.h netif_set_real_num_tx_queues returns int])
1358         LB_LINUX_TRY_COMPILE([
1359                 #include <linux/netdevice.h>
1360         ],[
1361                 struct net_device dev;
1362                 int ret;
1363                 ret = netif_set_real_num_tx_queues(&dev, 2);
1364                 return 0;
1365         ],[
1366                 AC_MSG_RESULT(yes)
1367                 AC_DEFINE(HAVE_RETURN_INT_FOR_SET_NUM_TX_QUEUES, 1,
1368                           [netif_set_real_num_tx_queues returns int])
1369         ],[
1370                 AC_MSG_RESULT(no)
1371         ])
1372
1373         AC_MSG_CHECKING([if struct netdevice.h has struct xps_map])
1374         LB_LINUX_TRY_COMPILE([
1375                 #include <linux/netdevice.h>
1376         ],[
1377                 struct xps_map map;
1378                 map.len = 0;
1379
1380                 return 0;
1381         ],[
1382                 AC_MSG_RESULT(yes)
1383                 AC_DEFINE(HAVE_XPS_MAP, 1,
1384                           [struct xps_map is defined])
1385         ],[
1386                 AC_MSG_RESULT(no)
1387         ])
1388
1389         AC_MSG_CHECKING([if struct ethtool_ops has set_phys_id])
1390         LB_LINUX_TRY_COMPILE([
1391                 #include <linux/ethtool.h>
1392         ],[
1393                 const struct ethtool_ops en_ethtool_ops = {
1394                         .set_phys_id= NULL,
1395                 };
1396
1397                 return 0;
1398         ],[
1399                 AC_MSG_RESULT(yes)
1400                 AC_DEFINE(HAVE_SET_PHYS_ID, 1,
1401                           [set_phys_id is defined])
1402         ],[
1403                 AC_MSG_RESULT(no)
1404         ])
1405
1406         AC_MSG_CHECKING([if struct ethtool_ops has get/set_channels])
1407         LB_LINUX_TRY_COMPILE([
1408                 #include <linux/ethtool.h>
1409         ],[
1410                 const struct ethtool_ops en_ethtool_ops = {
1411                         .get_channels = NULL,
1412                         .set_channels = NULL,
1413                 };
1414
1415                 return 0;
1416         ],[
1417                 AC_MSG_RESULT(yes)
1418                 AC_DEFINE(HAVE_GET_SET_CHANNELS, 1,
1419                           [get/set_channels is defined])
1420         ],[
1421                 AC_MSG_RESULT(no)
1422         ])
1423
1424         AC_MSG_CHECKING([if struct ethtool_ops_ext has get/set_channels])
1425         LB_LINUX_TRY_COMPILE([
1426                 #include <linux/ethtool.h>
1427         ],[
1428                 const struct ethtool_ops_ext en_ethtool_ops_ext = {
1429                         .get_channels = NULL,
1430                         .set_channels = NULL,
1431                 };
1432
1433                 return 0;
1434         ],[
1435                 AC_MSG_RESULT(yes)
1436                 AC_DEFINE(HAVE_GET_SET_CHANNELS_EXT, 1,
1437                           [get/set_channels is defined in ethtool_ops_ext])
1438         ],[
1439                 AC_MSG_RESULT(no)
1440         ])
1441
1442         AC_MSG_CHECKING([if struct ethtool_ops has get_ts_info])
1443         LB_LINUX_TRY_COMPILE([
1444                 #include <linux/ethtool.h>
1445         ],[
1446                 const struct ethtool_ops en_ethtool_ops = {
1447                         .get_ts_info = NULL,
1448                 };
1449
1450                 return 0;
1451         ],[
1452                 AC_MSG_RESULT(yes)
1453                 AC_DEFINE(HAVE_GET_TS_INFO, 1,
1454                           [get_ts_info is defined])
1455         ],[
1456                 AC_MSG_RESULT(no)
1457         ])
1458
1459         AC_MSG_CHECKING([if struct ethtool_ops_ext has get_ts_info])
1460         LB_LINUX_TRY_COMPILE([
1461                 #include <linux/ethtool.h>
1462         ],[
1463                 const struct ethtool_ops_ext en_ethtool_ops_ext = {
1464                         .get_ts_info = NULL,
1465                 };
1466
1467                 return 0;
1468         ],[
1469                 AC_MSG_RESULT(yes)
1470                 AC_DEFINE(HAVE_GET_TS_INFO_EXT, 1,
1471                           [get_ts_info is defined in ethtool_ops_ext])
1472         ],[
1473                 AC_MSG_RESULT(no)
1474         ])
1475
1476         AC_MSG_CHECKING([if struct ethtool_flow_ext has h_dest])
1477         LB_LINUX_TRY_COMPILE([
1478                 #include <linux/ethtool.h>
1479         ],[
1480                 unsigned char mac[ETH_ALEN];
1481                 struct ethtool_flow_ext h_ext;
1482
1483                 memcpy(&mac, h_ext.h_dest, ETH_ALEN);
1484
1485                 return 0;
1486         ],[
1487                 AC_MSG_RESULT(yes)
1488                 AC_DEFINE(HAVE_ETHTOOL_FLOW_EXT_H_DEST, 1,
1489                           [ethtool_flow_ext has h_dest])
1490         ],[
1491                 AC_MSG_RESULT(no)
1492         ])
1493
1494         AC_MSG_CHECKING([if netdevice.h has struct netdev_hw_addr])
1495         LB_LINUX_TRY_COMPILE([
1496                 #include <linux/netdevice.h>
1497         ],[
1498                 struct netdev_hw_addr addr;
1499                 return 0;
1500         ],[
1501                 AC_MSG_RESULT(yes)
1502                 AC_DEFINE(HAVE_NETDEV_HW_ADDR, 1,
1503                           [netdev_hw_addr is defined])
1504         ],[
1505                 AC_MSG_RESULT(no)
1506         ])
1507
1508         AC_MSG_CHECKING([if pci.h has pci_vfs_assigned])
1509         LB_LINUX_TRY_COMPILE([
1510                 #include <linux/pci.h>
1511         ],[
1512                 struct pci_dev pdev;
1513                 pci_vfs_assigned(&pdev);
1514                 return 0;
1515         ],[
1516                 AC_MSG_RESULT(yes)
1517                 AC_DEFINE(HAVE_PCI_VF_ASSIGNED, 1,
1518                           [pci_vfs_assigned is defined])
1519         ],[
1520                 AC_MSG_RESULT(no)
1521         ])
1522         AC_MSG_CHECKING([if __vlan_put_tag has 3 parameters])
1523         LB_LINUX_TRY_COMPILE([
1524                 #include <linux/if_vlan.h>
1525         ],[
1526                 struct sk_buff *skb;
1527                 __vlan_put_tag(skb, 0, 0);
1528
1529                 return 0;
1530         ],[
1531                 AC_MSG_RESULT(yes)
1532                 AC_DEFINE(HAVE_3_PARAMS_FOR_VLAN_PUT_TAG, 1,
1533                           [__vlan_put_tag has 3 parameters])
1534         ],[
1535                 AC_MSG_RESULT(no)
1536         ])
1537
1538         AC_MSG_CHECKING([if __vlan_hwaccel_put_tag has 3 parameters])
1539         LB_LINUX_TRY_COMPILE([
1540                 #include <linux/if_vlan.h>
1541         ],[
1542                 struct sk_buff *skb;
1543                 __vlan_hwaccel_put_tag(skb, 0, 0);
1544
1545                 return 0;
1546         ],[
1547                 AC_MSG_RESULT(yes)
1548                 AC_DEFINE(HAVE_3_PARAMS_FOR_VLAN_HWACCEL_PUT_TAG, 1,
1549                           [__vlan_hwaccel_put_tag has 3 parameters])
1550         ],[
1551                 AC_MSG_RESULT(no)
1552         ])
1553
1554         AC_MSG_CHECKING([if struct net_device has hw_features])
1555         LB_LINUX_TRY_COMPILE([
1556                 #include <linux/netdevice.h>
1557         ],[
1558                 struct net_device dev;
1559                 dev.hw_features = 0;
1560
1561                 return 0;
1562         ],[
1563                 AC_MSG_RESULT(yes)
1564                 AC_DEFINE(HAVE_NETDEV_HW_FEATURES, 1,
1565                           [hw_features is defined])
1566         ],[
1567                 AC_MSG_RESULT(no)
1568         ])
1569
1570         AC_MSG_CHECKING([if struct net_device has hw_enc_features])
1571         LB_LINUX_TRY_COMPILE([
1572                 #include <linux/netdevice.h>
1573         ],[
1574                 struct net_device dev;
1575                 dev.hw_enc_features = 0;
1576
1577                 return 0;
1578         ],[
1579                 AC_MSG_RESULT(yes)
1580                 AC_DEFINE(HAVE_NETDEV_HW_ENC_FEATURES, 1,
1581                           [hw_enc_features is defined])
1582         ],[
1583                 AC_MSG_RESULT(no)
1584         ])
1585
1586         AC_MSG_CHECKING([if struct net_device has rx_cpu_rmap])
1587         LB_LINUX_TRY_COMPILE([
1588                 #include <linux/netdevice.h>
1589         ],[
1590                 struct net_device dev;
1591                 dev.rx_cpu_rmap = NULL;
1592
1593                 return 0;
1594         ],[
1595                 AC_MSG_RESULT(yes)
1596                 AC_DEFINE(HAVE_NETDEV_RX_CPU_RMAP, 1,
1597                           [rx_cpu_rmap is defined])
1598         ],[
1599                 AC_MSG_RESULT(no)
1600         ])
1601
1602         AC_MSG_CHECKING([if if_vlan.h has vlan_hwaccel_receive_skb])
1603         LB_LINUX_TRY_COMPILE([
1604                 #include <linux/if_vlan.h>
1605         ],[
1606                 struct sk_buff *skb;
1607                 vlan_hwaccel_receive_skb(skb,0,0);
1608                 return 0;
1609         ],[
1610                 AC_MSG_RESULT(yes)
1611                 AC_DEFINE(HAVE_VLAN_HWACCEL_RECEIVE_SKB, 1,
1612                           [vlan_hwaccel_receive_skb is defined])
1613         ],[
1614                 AC_MSG_RESULT(no)
1615         ])
1616
1617         AC_MSG_CHECKING([if irqdesc.h has irq_desc_get_irq_data])
1618         LB_LINUX_TRY_COMPILE([
1619                 #include <linux/irqdesc.h>
1620         ],[
1621                 struct irq_data *data = irq_desc_get_irq_data(NULL);
1622                 return 0;
1623         ],[
1624                 AC_MSG_RESULT(yes)
1625                 AC_DEFINE(HAVE_IRQ_DESC_GET_IRQ_DATA, 1,
1626                           [irq_desc_get_irq_data is defined])
1627         ],[
1628                 AC_MSG_RESULT(no)
1629         ])
1630
1631
1632         AC_MSG_CHECKING([if pci_dev has pcie_mpss])
1633         LB_LINUX_TRY_COMPILE([
1634                 #include <linux/pci.h>
1635         ],[
1636                 struct pci_dev pdev;
1637
1638                 pdev->pcie_mpss = 0;
1639                 return 0;
1640         ],[
1641                 AC_MSG_RESULT(yes)
1642                 AC_DEFINE(HAVE_PCI_DEV_PCIE_MPSS, 1,
1643                           [pcie_mpss is defined])
1644         ],[
1645                 AC_MSG_RESULT(no)
1646         ])
1647
1648         AC_MSG_CHECKING([if uapi/linux/if_ether.h exist])
1649         LB_LINUX_TRY_COMPILE([
1650                 #include <uapi/linux/if_ether.h>
1651         ],[
1652                 return 0;
1653         ],[
1654                 AC_MSG_RESULT(yes)
1655                 AC_DEFINE(HAVE_UAPI_LINUX_IF_ETHER_H, 1,
1656                           [uapi/linux/if_ether.h exist])
1657         ],[
1658                 AC_MSG_RESULT(no)
1659         ])
1660
1661         AC_MSG_CHECKING([if ifla_vf_info has spoofchk])
1662         LB_LINUX_TRY_COMPILE([
1663                 #include <linux/if_link.h>
1664         ],[
1665                 struct ifla_vf_info *ivf;
1666
1667                 ivf->spoofchk = 0;
1668                 return 0;
1669         ],[
1670                 AC_MSG_RESULT(yes)
1671                 AC_DEFINE(HAVE_VF_INFO_SPOOFCHK, 1,
1672                           [spoofchk is defined])
1673         ],[
1674                 AC_MSG_RESULT(no)
1675         ])
1676
1677         AC_MSG_CHECKING([if dst.h has dst_get_neighbour])
1678         LB_LINUX_TRY_COMPILE([
1679                 #include <net/dst.h>
1680         ],[
1681                 struct neighbour *neigh = dst_get_neighbour(NULL);
1682
1683                 return 0;
1684         ],[
1685                 AC_MSG_RESULT(yes)
1686                 AC_DEFINE(HAVE_DST_GET_NEIGHBOUR, 1,
1687                           [ is defined])
1688         ],[
1689                 AC_MSG_RESULT(no)
1690         ])
1691
1692         AC_MSG_CHECKING([if netlink_dump_start has 6 parameters])
1693         LB_LINUX_TRY_COMPILE([
1694                 #include <linux/netlink.h>
1695         ],[
1696                 int ret = netlink_dump_start(NULL, NULL, NULL, NULL, NULL, 0);
1697
1698                 return 0;
1699         ],[
1700                 AC_MSG_RESULT(yes)
1701                 AC_DEFINE(HAVE_NETLINK_DUMP_START_6P, 1,
1702                           [ is defined])
1703         ],[
1704                 AC_MSG_RESULT(no)
1705         ])
1706
1707         AC_MSG_CHECKING([if netlink_dump_start has 5 parameters])
1708         LB_LINUX_TRY_COMPILE([
1709                 #include <linux/netlink.h>
1710         ],[
1711                 int ret = netlink_dump_start(NULL, NULL, NULL, NULL, NULL);
1712
1713                 return 0;
1714         ],[
1715                 AC_MSG_RESULT(yes)
1716                 AC_DEFINE(HAVE_NETLINK_DUMP_START_5P, 1,
1717                           [ is defined])
1718         ],[
1719                 AC_MSG_RESULT(no)
1720         ])
1721
1722         AC_MSG_CHECKING([if struct dcbnl_rtnl_ops has ieee_getmaxrate/ieee_setmaxrate])
1723         LB_LINUX_TRY_COMPILE([
1724                 #include <net/dcbnl.h>
1725         ],[
1726                 const struct dcbnl_rtnl_ops en_dcbnl_ops = {
1727                         .ieee_getmaxrate = NULL,
1728                         .ieee_setmaxrate = NULL,
1729                 };
1730
1731                 return 0;
1732         ],[
1733                 AC_MSG_RESULT(yes)
1734                 AC_DEFINE(HAVE_IEEE_GET_SET_MAXRATE, 1,
1735                           [ieee_getmaxrate/ieee_setmaxrate is defined])
1736         ],[
1737                 AC_MSG_RESULT(no)
1738         ])
1739 ])
1740 #
1741 # COMPAT_CONFIG_HEADERS
1742 #
1743 # add -include config.h
1744 #
1745 AC_DEFUN([COMPAT_CONFIG_HEADERS],[
1746         AC_CONFIG_HEADERS([config.h])
1747         EXTRA_KCFLAGS="-include $PWD/config.h $EXTRA_KCFLAGS"
1748         AC_SUBST(EXTRA_KCFLAGS)
1749 ])
1750
1751 AC_DEFUN([OFA_PROG_LINUX],
1752 [
1753
1754 LB_LINUX_PATH
1755 LB_LINUX_SYMVERFILE
1756 LB_LINUX_CONFIG([MODULES],[],[
1757     AC_MSG_ERROR([module support is required to build mlnx kernel modules.])
1758 ])
1759 LB_LINUX_CONFIG([MODVERSIONS])
1760 LB_LINUX_CONFIG([KALLSYMS],[],[
1761     AC_MSG_ERROR([compat_mlnx requires that CONFIG_KALLSYMS is enabled in your kernel.])
1762 ])
1763
1764 LINUX_CONFIG_COMPAT
1765 COMPAT_CONFIG_HEADERS
1766
1767 ])