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 svc_xprt_class has xcl_ident])
 191         LB_LINUX_TRY_COMPILE([
 192                 #include <linux/sunrpc/xprt.h>
 193                 #include <linux/sunrpc/svc_xprt.h>
 194         ],[
 195                 struct svc_xprt_class svc_rdma_class = {
 196                         .xcl_ident = XPRT_TRANSPORT_RDMA,
 197                 };
 198                 return 0;
 199         ],[
 200                 AC_MSG_RESULT(yes)
 201                 AC_DEFINE(HAVE_XCL_IDENT, 1,
 202                           [xcl_ident defined])
 203         ],[
 204                 AC_MSG_RESULT(no)
 205         ])
 206
 207         AC_MSG_CHECKING([if struct ifla_vf_info has max_tx_rate])
 208         LB_LINUX_TRY_COMPILE([
 209                 #include <linux/if_link.h>
 210         ],[
 211                 struct ifla_vf_info *ivf;
 212
 213                 ivf->max_tx_rate = 0;
 214                 ivf->min_tx_rate = 0;
 215
 216                 return 0;
 217         ],[
 218                 AC_MSG_RESULT(yes)
 219                 AC_DEFINE(HAVE_TX_RATE_LIMIT, 1,
 220                           [max_tx_rate is defined])
 221         ],[
 222                 AC_MSG_RESULT(no)
 223         ])
 224
 225         AC_MSG_CHECKING([if struct ethtool_ops has get/set_rxfh])
 226         LB_LINUX_TRY_COMPILE([
 227                 #include <linux/ethtool.h>
 228         ],[
 229                 const struct ethtool_ops en_ethtool_ops = {
 230                         .get_rxfh_indir_size = NULL,
 231                         .get_rxfh = NULL,
 232                         .set_rxfh = NULL,
 233                 };
 234
 235                 return 0;
 236         ],[
 237                 AC_MSG_RESULT(yes)
 238                 AC_DEFINE(HAVE_GET_SET_RXFH, 1,
 239                           [get/set_rxfh is defined])
 240         ],[
 241                 AC_MSG_RESULT(no)
 242         ])
 243
 244
 245         AC_MSG_CHECKING([if struct ethtool_ops has get/set_tunable])
 246         LB_LINUX_TRY_COMPILE([
 247                 #include <linux/ethtool.h>
 248         ],[
 249                 const struct ethtool_ops en_ethtool_ops = {
 250                         .get_tunable = NULL,
 251                         .set_tunable = NULL,
 252                 };
 253
 254                 return 0;
 255         ],[
 256                 AC_MSG_RESULT(yes)
 257                 AC_DEFINE(HAVE_GET_SET_TUNABLE, 1,
 258                           [get/set_tunable is defined])
 259         ],[
 260                 AC_MSG_RESULT(no)
 261         ])
 262
 263         AC_MSG_CHECKING([if exist struct ethtool_ops_ext])
 264         LB_LINUX_TRY_COMPILE([
 265                 #include <linux/ethtool.h>
 266         ],[
 267                 const struct ethtool_ops_ext en_ethtool_ops_ext = {
 268                         .size = sizeof(struct ethtool_ops_ext),
 269                 };
 270
 271                 return 0;
 272         ],[
 273                 AC_MSG_RESULT(yes)
 274                 AC_DEFINE(HAVE_ETHTOOL_OPS_EXT, 1,
 275                           [struct ethtool_ops_ext is defined])
 276         ],[
 277                 AC_MSG_RESULT(no)
 278         ])
 279
 280         AC_MSG_CHECKING([if struct ethtool_ops_ext has get/set_rxfh])
 281         LB_LINUX_TRY_COMPILE([
 282                 #include <linux/ethtool.h>
 283         ],[
 284                 const struct ethtool_ops_ext en_ethtool_ops_ext = {
 285                         .get_rxfh_indir_size = NULL,
 286                         .get_rxfh = NULL,
 287                         .set_rxfh = NULL,
 288                 };
 289
 290                 return 0;
 291         ],[
 292                 AC_MSG_RESULT(yes)
 293                 AC_DEFINE(HAVE_GET_SET_RXFH_OPS_EXT, 1,
 294                           [get/set_rxfh is defined])
 295         ],[
 296                 AC_MSG_RESULT(no)
 297         ])
 298
 299         AC_MSG_CHECKING([if struct ethtool_ops_ext has get/set_rxfh_indir])
 300         LB_LINUX_TRY_COMPILE([
 301                 #include <linux/ethtool.h>
 302         ],[
 303                 const struct ethtool_ops_ext en_ethtool_ops_ext = {
 304                         .get_rxfh_indir = NULL,
 305                         .set_rxfh_indir = NULL,
 306                 };
 307
 308                 return 0;
 309         ],[
 310                 AC_MSG_RESULT(yes)
 311                 AC_DEFINE(HAVE_GET_SET_RXFH_INDIR, 1,
 312                           [get/set_rxfh_indir is defined])
 313         ],[
 314                 AC_MSG_RESULT(no)
 315         ])
 316
 317         AC_MSG_CHECKING([if struct ethtool_ops_ext has get/set_rxfh_indir])
 318         LB_LINUX_TRY_COMPILE([
 319                 #include <linux/ethtool.h>
 320         ],[
 321                 const struct ethtool_ops_ext en_ethtool_ops_ext = {
 322                         .get_rxfh_indir = NULL,
 323                         .set_rxfh_indir = NULL,
 324                 };
 325
 326                 return 0;
 327         ],[
 328                 AC_MSG_RESULT(yes)
 329                 AC_DEFINE(HAVE_GET_SET_RXFH_INDIR_EXT, 1,
 330                           [get/set_rxfh_indir is defined])
 331         ],[
 332                 AC_MSG_RESULT(no)
 333         ])
 334
 335         AC_MSG_CHECKING([if struct net_device has dev_port])
 336         LB_LINUX_TRY_COMPILE([
 337                 #include <linux/netdevice.h>
 338         ],[
 339                 struct net_device *dev = NULL;
 340
 341                 dev->dev_port = 0;
 342
 343                 return 0;
 344         ],[
 345                 AC_MSG_RESULT(yes)
 346                 AC_DEFINE(HAVE_NET_DEVICE_DEV_PORT, 1,
 347                           [dev_port is defined])
 348         ],[
 349                 AC_MSG_RESULT(no)
 350         ])
 351
 352         AC_MSG_CHECKING([if struct ptp_clock_info has n_pins])
 353         LB_LINUX_TRY_COMPILE([
 354                 #include <linux/ptp_clock_kernel.h>
 355         ],[
 356                 struct ptp_clock_info *info;
 357                 info->n_pins = 0;
 358
 359                 return 0;
 360         ],[
 361                 AC_MSG_RESULT(yes)
 362                 AC_DEFINE(HAVE_PTP_CLOCK_INFO_N_PINS, 1,
 363                           [n_pins is defined])
 364         ],[
 365                 AC_MSG_RESULT(no)
 366         ])
 367
 368         AC_MSG_CHECKING([if pci.h pci_enable_msi_exact])
 369         LB_LINUX_TRY_COMPILE([
 370                 #include <linux/pci.h>
 371         ],[
 372                 int x = pci_enable_msi_exact(NULL, 0);
 373
 374                 return 0;
 375         ],[
 376                 AC_MSG_RESULT(yes)
 377                 AC_DEFINE(HAVE_PCI_ENABLE_MSI_EXACT, 1,
 378                           [pci_enable_msi_exact is defined])
 379         ],[
 380                 AC_MSG_RESULT(no)
 381         ])
 382
 383         AC_MSG_CHECKING([if pci.h pci_enable_msix_range])
 384         LB_LINUX_TRY_COMPILE([
 385                 #include <linux/pci.h>
 386         ],[
 387                 int x = pci_enable_msix_range(NULL, 0, 0, 0);
 388
 389                 return 0;
 390         ],[
 391                 AC_MSG_RESULT(yes)
 392                 AC_DEFINE(HAVE_PCI_ENABLE_MSIX_RANGE, 1,
 393                           [pci_enable_msix_range is defined])
 394         ],[
 395                 AC_MSG_RESULT(no)
 396         ])
 397
 398         AC_MSG_CHECKING([if pci.h pci_msix_vec_count])
 399         LB_LINUX_TRY_COMPILE([
 400                 #include <linux/pci.h>
 401         ],[
 402                 int x = pci_msix_vec_count(NULL);
 403
 404                 return 0;
 405         ],[
 406                 AC_MSG_RESULT(yes)
 407                 AC_DEFINE(HAVE_PCI_MSIX_VEC_COUNT, 1,
 408                           [pci_msix_vec_count is defined])
 409         ],[
 410                 AC_MSG_RESULT(no)
 411         ])
 412
 413         AC_MSG_CHECKING([if pci_dev has msix_cap])
 414         LB_LINUX_TRY_COMPILE([
 415                 #include <linux/pci.h>
 416         ],[
 417                 struct pci_dev pdev;
 418                 pdev.msix_cap = 0;
 419
 420                 return 0;
 421         ],[
 422                 AC_MSG_RESULT(yes)
 423                 AC_DEFINE(HAVE_PCI_MSIX_CAP, 1,
 424                           [msix_cap is defined])
 425         ],[
 426                 AC_MSG_RESULT(no)
 427         ])
 428
 429         AC_MSG_CHECKING([if mm_struct has pinned_vm])
 430         LB_LINUX_TRY_COMPILE([
 431                 #include <linux/mm_types.h>
 432         ],[
 433                 struct mm_types mmt;
 434                 mmt.pinned_vm = 0;
 435
 436                 return 0;
 437         ],[
 438                 AC_MSG_RESULT(yes)
 439                 AC_DEFINE(HAVE_PINNED_VM, 1,
 440                           [pinned_vm is defined])
 441         ],[
 442                 AC_MSG_RESULT(no)
 443         ])
 444
 445         AC_MSG_CHECKING([if kernel has idr_alloc])
 446         LB_LINUX_TRY_COMPILE([
 447                 #include <linux/idr.h>
 448         ],[
 449                 int x;
 450                 x =  idr_alloc(NULL, NULL, 0, 0, 0);
 451
 452                 return 0;
 453         ],[
 454                 AC_MSG_RESULT(yes)
 455                 AC_DEFINE(HAVE_IDR_ALLOC, 1,
 456                           [idr_alloc is defined])
 457         ],[
 458                 AC_MSG_RESULT(no)
 459         ])
 460
 461         AC_MSG_CHECKING([if kernel has percpu variables])
 462         LB_LINUX_TRY_COMPILE([
 463                 #include <linux/percpu.h>
 464         ],[
 465                 static DEFINE_PER_CPU(unsigned int, x);
 466                 this_cpu_inc(x);
 467
 468                 return 0;
 469         ],[
 470                 AC_MSG_RESULT(yes)
 471                 AC_DEFINE(HAVE_PERCPU_VARS, 1,
 472                           [percpu variables are defined])
 473         ],[
 474                 AC_MSG_RESULT(no)
 475         ])
 476
 477         AC_MSG_CHECKING([if struct iscsi_transport has attr_is_visible])
 478         LB_LINUX_TRY_COMPILE([
 479                 #include <scsi/scsi_transport_iscsi.h>
 480         ],[
 481                 static struct iscsi_transport iscsi_iser_transport = {
 482                         .attr_is_visible = NULL,
 483                 };
 484
 485                 return 0;
 486         ],[
 487                 AC_MSG_RESULT(yes)
 488                 AC_DEFINE(HAVE_ISCSI_ATTR_IS_VISIBLE, 1,
 489                           [attr_is_visible is defined])
 490         ],[
 491                 AC_MSG_RESULT(no)
 492         ])
 493
 494         AC_MSG_CHECKING([if struct iscsi_transport has get_ep_param])
 495         LB_LINUX_TRY_COMPILE([
 496                 #include <scsi/scsi_transport_iscsi.h>
 497         ],[
 498                 static struct iscsi_transport iscsi_iser_transport = {
 499                         .get_ep_param = NULL,
 500                 };
 501
 502                 return 0;
 503         ],[
 504                 AC_MSG_RESULT(yes)
 505                 AC_DEFINE(HAVE_ISCSI_GET_EP_PARAM, 1,
 506                           [get_ep_param is defined])
 507         ],[
 508                 AC_MSG_RESULT(no)
 509         ])
 510
 511         AC_MSG_CHECKING([if struct iscsi_transport has check_protection])
 512         LB_LINUX_TRY_COMPILE([
 513                 #include <scsi/scsi_transport_iscsi.h>
 514         ],[
 515                 static struct iscsi_transport iscsi_iser_transport = {
 516                         .check_protection = NULL,
 517                 };
 518
 519                 return 0;
 520         ],[
 521                 AC_MSG_RESULT(yes)
 522                 AC_DEFINE(HAVE_ISCSI_CHECK_PROTECTION, 1,
 523                           [check_protection is defined])
 524         ],[
 525                 AC_MSG_RESULT(no)
 526         ])
 527
 528         AC_MSG_CHECKING([if iscsi_proto.h has struct iscsi_scsi_req])
 529         LB_LINUX_TRY_COMPILE([
 530                 #include <scsi/iscsi_proto.h>
 531         ],[
 532                 struct iscsi_scsi_req req = {
 533                         .opcode = 0,
 534                 };
 535
 536                 return 0;
 537         ],[
 538                 AC_MSG_RESULT(yes)
 539                 AC_DEFINE(HAVE_ISCSI_SCSI_REQ, 1,
 540                           [struct iscsi_scsi_req is defined])
 541         ],[
 542                 AC_MSG_RESULT(no)
 543         ])
 544
 545         AC_MSG_CHECKING([if struct request_queue has request_fn_active])
 546         LB_LINUX_TRY_COMPILE([
 547                 #include <linux/blkdev.h>
 548         ],[
 549                 struct request_queue rq = {
 550                         .request_fn_active = 0,
 551                 };
 552
 553                 return 0;
 554         ],[
 555                 AC_MSG_RESULT(yes)
 556                 AC_DEFINE(HAVE_REQUEST_QUEUE_REQUEST_FN_ACTIVE, 1,
 557                           [struct request_queue has request_fn_active])
 558         ],[
 559                 AC_MSG_RESULT(no)
 560         ])
 561
 562         AC_MSG_CHECKING([if netdevice.h has select_queue_fallback_t])
 563         LB_LINUX_TRY_COMPILE([
 564                 #include <linux/netdevice.h>
 565         ],[
 566                 select_queue_fallback_t fallback;
 567
 568                 fallback = NULL;
 569
 570                 return 0;
 571         ],[
 572                 AC_MSG_RESULT(yes)
 573                 AC_DEFINE(HAVE_SELECT_QUEUE_FALLBACK_T, 1,
 574                           [select_queue_fallback_t is defined])
 575         ],[
 576                 AC_MSG_RESULT(no)
 577         ])
 578
 579         AC_MSG_CHECKING([if netdevice.h has skb_set_hash])
 580         LB_LINUX_TRY_COMPILE([
 581                 #include <linux/netdevice.h>
 582         ],[
 583                 skb_set_hash(NULL, 0, PKT_HASH_TYPE_L3);
 584
 585                 return 0;
 586         ],[
 587                 AC_MSG_RESULT(yes)
 588                 AC_DEFINE(HAVE_SKB_SET_HASH, 1,
 589                           [skb_set_hash is defined])
 590         ],[
 591                 AC_MSG_RESULT(no)
 592         ])
 593
 594         AC_MSG_CHECKING([if netdevice.h has alloc_netdev with 4 params])
 595         LB_LINUX_TRY_COMPILE([
 596                 #include <linux/netdevice.h>
 597         ],[
 598                 struct net_device *dev;
 599
 600                 dev = alloc_netdev(0, NULL, 0, NULL);
 601
 602                 return 0;
 603         ],[
 604                 AC_MSG_RESULT(yes)
 605                 AC_DEFINE(HAVE_ALLOC_NETDEV_4P, 1,
 606                           [alloc_netdev has 4 parameters])
 607         ],[
 608                 AC_MSG_RESULT(no)
 609         ])
 610
 611         AC_MSG_CHECKING([if sockios.h has SIOCGHWTSTAMP])
 612         LB_LINUX_TRY_COMPILE([
 613                 #include <linux/sockios.h>
 614         ],[
 615                 int x = SIOCGHWTSTAMP;
 616
 617                 return 0;
 618         ],[
 619                 AC_MSG_RESULT(yes)
 620                 AC_DEFINE(HAVE_SIOCGHWTSTAMP, 1,
 621                           [SIOCGHWTSTAMP is defined])
 622         ],[
 623                 AC_MSG_RESULT(no)
 624         ])
 625
 626         AC_MSG_CHECKING([if ip.h inet_get_local_port_range has 3 parameters])
 627         LB_LINUX_TRY_COMPILE([
 628                 #include <net/ip.h>
 629         ],[
 630                 inet_get_local_port_range(NULL, NULL, NULL);
 631
 632                 return 0;
 633         ],[
 634                 AC_MSG_RESULT(yes)
 635                 AC_DEFINE(HAVE_INET_GET_LOCAL_PORT_RANGE_3_PARAMS, 1,
 636                           [inet_get_local_port_range has 3 parameters])
 637         ],[
 638                 AC_MSG_RESULT(no)
 639         ])
 640
 641         AC_MSG_CHECKING([if net.h has net_get_random_once])
 642         LB_LINUX_TRY_COMPILE([
 643                 #include <linux/net.h>
 644         ],[
 645                 net_get_random_once(NULL, 0);
 646
 647                 return 0;
 648         ],[
 649                 AC_MSG_RESULT(yes)
 650                 AC_DEFINE(HAVE_NET_GET_RANDOM_ONCE, 1,
 651                           [net_get_random_once is defined])
 652         ],[
 653                 AC_MSG_RESULT(no)
 654         ])
 655
 656         AC_MSG_CHECKING([if inet_sock.h has __inet_ehashfn])
 657         LB_LINUX_TRY_COMPILE([
 658                 #include <net/inet_sock.h>
 659         ],[
 660                 __inet_ehashfn(0, 0, 0, 0, 0);
 661
 662                 return 0;
 663         ],[
 664                 AC_MSG_RESULT(yes)
 665                 AC_DEFINE(HAVE_INET_EHASHFN, 1,
 666                           [__inet_ehashfn is defined])
 667         ],[
 668                 AC_MSG_RESULT(no)
 669         ])
 670
 671         AC_MSG_CHECKING([if err.h has PTR_ERR_OR_ZERO])
 672         LB_LINUX_TRY_COMPILE([
 673                 #include <linux/err.h>
 674         ],[
 675                 int x = PTR_ERR_OR_ZERO(NULL);
 676
 677                 return 0;
 678         ],[
 679                 AC_MSG_RESULT(yes)
 680                 AC_DEFINE(HAVE_PTR_ERR_OR_ZERO, 1,
 681                           [PTR_ERR_OR_ZERO is defined])
 682         ],[
 683                 AC_MSG_RESULT(no)
 684         ])
 685
 686         AC_MSG_CHECKING([if struct iscsi_session has discovery_sess])
 687         LB_LINUX_TRY_COMPILE([
 688                 #include <scsi/libiscsi.h>
 689         ],[
 690                 struct iscsi_session session;
 691                 session.discovery_sess = 0;
 692
 693                 return 0;
 694         ],[
 695                 AC_MSG_RESULT(yes)
 696                 AC_DEFINE(HAVE_ISCSI_DISCOVERY_SESS, 1,
 697                           [discovery_sess is defined])
 698         ],[
 699                 AC_MSG_RESULT(no)
 700         ])
 701
 702         AC_MSG_CHECKING([if enum iscsi_param has ISCSI_PARAM_DISCOVERY_SESS])
 703         LB_LINUX_TRY_COMPILE([
 704                 #include <scsi/iscsi_if.h>
 705         ],[
 706                 int x = ISCSI_PARAM_DISCOVERY_SESS;
 707
 708                 return 0;
 709         ],[
 710                 AC_MSG_RESULT(yes)
 711                 AC_DEFINE(HAVE_ISCSI_PARAM_DISCOVERY_SESS, 1,
 712                           [ISCSI_PARAM_DISCOVERY_SESS is defined])
 713         ],[
 714                 AC_MSG_RESULT(no)
 715         ])
 716
 717         AC_MSG_CHECKING([if pci.h has enum pcie_link_width])
 718         LB_LINUX_TRY_COMPILE([
 719                 #include <linux/pci.h>
 720                 #include <linux/pci_hotplug.h>
 721         ],[
 722                 enum pcie_link_width width = PCIE_LNK_WIDTH_UNKNOWN;
 723
 724                 return 0;
 725         ],[
 726                 AC_MSG_RESULT(yes)
 727                 AC_DEFINE(HAVE_PCIE_LINK_WIDTH, 1,
 728                           [pcie_link_width is defined])
 729         ],[
 730                 AC_MSG_RESULT(no)
 731         ])
 732
 733         AC_MSG_CHECKING([if pci.h has enum pci_bus_speed])
 734         LB_LINUX_TRY_COMPILE([
 735                 #include <linux/pci.h>
 736                 #include <linux/pci_hotplug.h>
 737         ],[
 738                 enum pci_bus_speed speed = PCI_SPEED_UNKNOWN;
 739
 740                 return 0;
 741         ],[
 742                 AC_MSG_RESULT(yes)
 743                 AC_DEFINE(HAVE_PCI_BUS_SPEED, 1,
 744                           [pci_bus_speed is defined])
 745         ],[
 746                 AC_MSG_RESULT(no)
 747         ])
 748
 749         AC_MSG_CHECKING([if netdevice.h has struct netdev_phys_port_id])
 750         LB_LINUX_TRY_COMPILE([
 751                 #include <linux/netdevice.h>
 752         ],[
 753                 struct netdev_phys_port_id *x = NULL;
 754
 755                 return 0;
 756         ],[
 757                 AC_MSG_RESULT(yes)
 758                 AC_DEFINE(HAVE_NETDEV_PHYS_PORT_ID, 1,
 759                           [netdev_phys_port_id is defined])
 760         ],[
 761                 AC_MSG_RESULT(no)
 762         ])
 763
 764         AC_MSG_CHECKING([if struct ifla_vf_info has linkstate])
 765         LB_LINUX_TRY_COMPILE([
 766                 #include <linux/if_link.h>
 767         ],[
 768                 struct ifla_vf_info *x;
 769                 x->linkstate = 0;
 770
 771                 return 0;
 772         ],[
 773                 AC_MSG_RESULT(yes)
 774                 AC_DEFINE(HAVE_LINKSTATE, 1,
 775                           [linkstate is defined])
 776         ],[
 777                 AC_MSG_RESULT(no)
 778         ])
 779
 780         AC_MSG_CHECKING([if busy_poll.h has skb_mark_napi_id])
 781         LB_LINUX_TRY_COMPILE([
 782                 #include <net/busy_poll.h>
 783         ],[
 784                 skb_mark_napi_id(NULL, NULL);
 785
 786                 return 0;
 787         ],[
 788                 AC_MSG_RESULT(yes)
 789                 AC_DEFINE(HAVE_SKB_MARK_NAPI_ID, 1,
 790                           [skb_mark_napi_id is defined])
 791         ],[
 792                 AC_MSG_RESULT(no)
 793         ])
 794
 795         AC_MSG_CHECKING([if netdevice.h has napi_hash_add])
 796         LB_LINUX_TRY_COMPILE([
 797                 #include <linux/netdevice.h>
 798         ],[
 799                 napi_hash_add(NULL);
 800
 801                 return 0;
 802         ],[
 803                 AC_MSG_RESULT(yes)
 804                 AC_DEFINE(HAVE_NAPI_HASH_ADD, 1,
 805                           [napi_hash_add is defined])
 806         ],[
 807                 AC_MSG_RESULT(no)
 808         ])
 809
 810         AC_MSG_CHECKING([if netdevice.h has netif_keep_dst])
 811         LB_LINUX_TRY_COMPILE([
 812                 #include <linux/netdevice.h>
 813         ],[
 814                 netif_keep_dst(NULL);
 815
 816                 return 0;
 817         ],[
 818                 AC_MSG_RESULT(yes)
 819                 AC_DEFINE(HAVE_NETIF_KEEP_DST, 1,
 820                           [netif_keep_dst is defined])
 821         ],[
 822                 AC_MSG_RESULT(no)
 823         ])
 824
 825         AC_MSG_CHECKING([if netdevice.h has dev_consume_skb_any])
 826         LB_LINUX_TRY_COMPILE([
 827                 #include <linux/netdevice.h>
 828         ],[
 829                 dev_consume_skb_any(NULL);
 830
 831                 return 0;
 832         ],[
 833                 AC_MSG_RESULT(yes)
 834                 AC_DEFINE(HAVE_DEV_CONSUME_SKB_ANY, 1,
 835                           [dev_consume_skb_any is defined])
 836         ],[
 837                 AC_MSG_RESULT(no)
 838         ])
 839
 840         AC_MSG_CHECKING([if netdevice.h has netdev_txq_bql_complete_prefetchw])
 841         LB_LINUX_TRY_COMPILE([
 842                 #include <linux/netdevice.h>
 843         ],[
 844                 netdev_txq_bql_complete_prefetchw(NULL);
 845                 netdev_txq_bql_enqueue_prefetchw(NULL);
 846
 847                 return 0;
 848         ],[
 849                 AC_MSG_RESULT(yes)
 850                 AC_DEFINE(HAVE_NETDEV_TXQ_BQL_PREFETCHW, 1,
 851                           [netdev_txq_bql_complete_prefetchw is defined])
 852         ],[
 853                 AC_MSG_RESULT(no)
 854         ])
 855
 856         AC_MSG_CHECKING([if struct sk_buff has xmit_more])
 857         LB_LINUX_TRY_COMPILE([
 858                 #include <linux/skbuff.h>
 859         ],[
 860                 struct sk_buff *skb;
 861                 skb->xmit_more = 0;
 862
 863                 return 0;
 864         ],[
 865                 AC_MSG_RESULT(yes)
 866                 AC_DEFINE(HAVE_SK_BUFF_XMIT_MORE, 1,
 867                           [xmit_more is defined])
 868         ],[
 869                 AC_MSG_RESULT(no)
 870         ])
 871
 872         AC_MSG_CHECKING([if struct sk_buff has encapsulation])
 873         LB_LINUX_TRY_COMPILE([
 874                 #include <linux/skbuff.h>
 875         ],[
 876                 struct sk_buff *skb;
 877                 skb->encapsulation = 0;
 878
 879                 return 0;
 880         ],[
 881                 AC_MSG_RESULT(yes)
 882                 AC_DEFINE(HAVE_SK_BUFF_ENCAPSULATION, 1,
 883                           [encapsulation is defined])
 884         ],[
 885                 AC_MSG_RESULT(no)
 886         ])
 887
 888         AC_MSG_CHECKING([if etherdevice.h has eth_get_headlen])
 889         LB_LINUX_TRY_COMPILE([
 890                 #include <linux/etherdevice.h>
 891         ],[
 892                 eth_get_headlen(NULL, 0);
 893
 894                 return 0;
 895         ],[
 896                 AC_MSG_RESULT(yes)
 897                 AC_DEFINE(HAVE_ETH_GET_HEADLEN, 1,
 898                           [eth_get_headlen is defined])
 899         ],[
 900                 AC_MSG_RESULT(no)
 901         ])
 902
 903         AC_MSG_CHECKING([if struct sk_buff has csum_level])
 904         LB_LINUX_TRY_COMPILE([
 905                 #include <linux/skbuff.h>
 906         ],[
 907                 struct sk_buff *skb;
 908                 skb->csum_level = 0;
 909
 910                 return 0;
 911         ],[
 912                 AC_MSG_RESULT(yes)
 913                 AC_DEFINE(HAVE_SK_BUFF_CSUM_LEVEL, 1,
 914                           [csum_level is defined])
 915         ],[
 916                 AC_MSG_RESULT(no)
 917         ])
 918
 919         AC_MSG_CHECKING([if struct skbuff.h has skb_inner_transport_header])
 920         LB_LINUX_TRY_COMPILE([
 921                 #include <linux/skbuff.h>
 922         ],[
 923                 skb_inner_transport_header(NULL);
 924
 925                 return 0;
 926         ],[
 927                 AC_MSG_RESULT(yes)
 928                 AC_DEFINE(HAVE_SKB_INNER_TRANSPORT_HEADER, 1,
 929                           [skb_inner_transport_header is defined])
 930         ],[
 931                 AC_MSG_RESULT(no)
 932         ])
 933
 934         AC_MSG_CHECKING([if struct skbuff.h has skb_inner_network_header])
 935         LB_LINUX_TRY_COMPILE([
 936                 #include <linux/skbuff.h>
 937         ],[
 938                 skb_inner_network_header(NULL);
 939
 940                 return 0;
 941         ],[
 942                 AC_MSG_RESULT(yes)
 943                 AC_DEFINE(HAVE_SKB_INNER_NETWORK_HEADER, 1,
 944                           [skb_inner_network_header is defined])
 945         ],[
 946                 AC_MSG_RESULT(no)
 947         ])
 948
 949         AC_MSG_CHECKING([if if_vlan.h has vlan_dev_get_egress_qos_mask])
 950         LB_LINUX_TRY_COMPILE([
 951                 #include <linux/if_vlan.h>
 952         ],[
 953                 vlan_dev_get_egress_qos_mask(NULL, 0);
 954
 955                 return 0;
 956         ],[
 957                 AC_MSG_RESULT(yes)
 958                 AC_DEFINE(HAVE_VLAN_DEV_GET_EGRESS_QOS_MASK, 1,
 959                           [vlan_dev_get_egress_qos_mask is defined])
 960         ],[
 961                 AC_MSG_RESULT(no)
 962         ])
 963
 964         AC_MSG_CHECKING([if netdevice.h has netdev_get_prio_tc_map])
 965         LB_LINUX_TRY_COMPILE([
 966                 #include <linux/netdevice.h>
 967         ],[
 968                 netdev_get_prio_tc_map(NULL, 0);
 969
 970                 return 0;
 971         ],[
 972                 AC_MSG_RESULT(yes)
 973                 AC_DEFINE(HAVE_NETDEV_GET_PRIO_TC_MAP, 1,
 974                           [netdev_get_prio_tc_map is defined])
 975         ],[
 976                 AC_MSG_RESULT(no)
 977         ])
 978
 979         AC_MSG_CHECKING([if if_vlan.h has __vlan_find_dev_deep_rcu])
 980         LB_LINUX_TRY_COMPILE([
 981                 #include <linux/if_vlan.h>
 982         ],[
 983                 __vlan_find_dev_deep_rcu(NULL, 0, 0);
 984
 985                 return 0;
 986         ],[
 987                 AC_MSG_RESULT(yes)
 988                 AC_DEFINE(HAVE___VLAN_FIND_DEV_DEEP_RCU, 1,
 989                           [__vlan_find_dev_deep_rcu is defined])
 990         ],[
 991                 AC_MSG_RESULT(no)
 992         ])
 993
 994         AC_MSG_CHECKING([if ndo_select_queue has accel_priv])
 995         LB_LINUX_TRY_COMPILE([
 996                 #include <linux/netdevice.h>
 997
 998                 static u16 select_queue(struct net_device *dev, struct sk_buff *skb,
 999                                         void *accel_priv)
1000                 {
1001                         return 0;
1002                 }
1003         ],[
1004                 struct net_device_opts ndops;
1005
1006                 ndops.ndo_select_queue = select_queue;
1007
1008                 return 0;
1009         ],[
1010                 AC_MSG_RESULT(yes)
1011                 AC_DEFINE(NDO_SELECT_QUEUE_HAS_ACCEL_PRIV, 1,
1012                           [ndo_select_queue has accel_priv])
1013         ],[
1014                 AC_MSG_RESULT(no)
1015         ])
1016
1017         AC_MSG_CHECKING([if include/net/bonding.h exists])
1018         LB_LINUX_TRY_COMPILE([
1019                 #include <net/bonding.h>
1020         ],[
1021                 return 0;
1022         ],[
1023                 AC_MSG_RESULT(yes)
1024                 AC_DEFINE(HAVE_BONDING_H, 1,
1025                           [include/net/bonding.h exists])
1026         ],[
1027                 AC_MSG_RESULT(no)
1028         ])
1029
1030         AC_MSG_CHECKING([if bonding.h bond_for_each_slave has 3 parameters])
1031         LB_LINUX_TRY_COMPILE([
1032                 #include <net/bonding.h>
1033         ],[
1034                 struct bonding *bond = NULL;
1035                 struct list_head *iter = NULL;
1036                 struct slave *slave = NULL;
1037
1038                 bond_for_each_slave(bond, slave, iter) ;
1039
1040                 return 0;
1041         ],[
1042                 AC_MSG_RESULT(yes)
1043                 AC_DEFINE(HAVE_BOND_FOR_EACH_SLAVE_3_PARAMS, 1,
1044                           [bond_for_each_slave has 3 parameters])
1045         ],[
1046                 AC_MSG_RESULT(no)
1047         ])
1048
1049
1050         AC_MSG_CHECKING([if u64_stats_sync.h has u64_stats_init])
1051         LB_LINUX_TRY_COMPILE([
1052                 #include <linux/u64_stats_sync.h>
1053         ],[
1054                 struct u64_stats_sync sync;
1055                 u64_stats_init(&sync);
1056
1057                 return 0;
1058         ],[
1059                 AC_MSG_RESULT(yes)
1060                 AC_DEFINE(HAVE_U64_STATS_SYNC, 1,
1061                           [u64_stats_sync is defined])
1062         ],[
1063                 AC_MSG_RESULT(no)
1064         ])
1065
1066         AC_MSG_CHECKING([if u64_stats_sync.h has u64_stats_fetch_begin_irq])
1067         LB_LINUX_TRY_COMPILE([
1068                 #include <linux/u64_stats_sync.h>
1069         ],[
1070                 struct u64_stats_sync sync;
1071                 u64_stats_fetch_begin_irq(&sync);
1072
1073                 return 0;
1074         ],[
1075                 AC_MSG_RESULT(yes)
1076                 AC_DEFINE(HAVE_U64_STATS_FETCH_BEGIN_IRQ, 1,
1077                           [u64_stats_fetch_begin_irq is defined])
1078         ],[
1079                 AC_MSG_RESULT(no)
1080         ])
1081         AC_MSG_CHECKING([if etherdevice.h has ether_addr_copy])
1082         LB_LINUX_TRY_COMPILE([
1083                 #include <linux/etherdevice.h>
1084         ],[
1085                 char dest[6], src[6];
1086                 ether_addr_copy(&dest, &src);
1087
1088                 return 0;
1089         ],[
1090                 AC_MSG_RESULT(yes)
1091                 AC_DEFINE(HAVE_ETHER_ADDR_COPY, 1,
1092                           [ether_addr_copy is defined])
1093         ],[
1094                 AC_MSG_RESULT(no)
1095         ])
1096
1097         AC_MSG_CHECKING([if struct net_device_ops has *ndo_set_vf_rate])
1098         LB_LINUX_TRY_COMPILE([
1099                 #include <linux/netdevice.h>
1100
1101                 int set_vf_rate(struct net_device *dev, int vf, int min_tx_rate,
1102                                                    int max_tx_rate)
1103                 {
1104                         return 0;
1105                 }
1106         ],[
1107                 struct net_device_ops netdev_ops;
1108
1109                 netdev_ops.ndo_set_vf_rate = set_vf_rate;
1110                 return 0;
1111         ],[
1112                 AC_MSG_RESULT(yes)
1113                 AC_DEFINE(HAVE_SET_VF_RATE, 1,
1114                           [ndo_set_vf_rate is defined])
1115         ],[
1116                 AC_MSG_RESULT(no)
1117         ])
1118
1119         AC_MSG_CHECKING([if netdev_extended has hw_features])
1120         LB_LINUX_TRY_COMPILE([
1121                 #include <linux/netdevice.h>
1122         ],[
1123                 struct net_device *dev = NULL;
1124
1125                 netdev_extended(dev)->hw_features = 0;
1126
1127                 return 0;
1128         ],[
1129                 AC_MSG_RESULT(yes)
1130                 AC_DEFINE(HAVE_NETDEV_EXTENDED_HW_FEATURES, 1,
1131                           [ is defined])
1132         ],[
1133                 AC_MSG_RESULT(no)
1134         ])
1135
1136         AC_MSG_CHECKING([if net_device_extended has _tx_ext])
1137         LB_LINUX_TRY_COMPILE([
1138                 #include <linux/netdevice.h>
1139         ],[
1140                 struct net_device *dev = NULL;
1141
1142                 netdev_extended(dev)->_tx_ext = NULL;
1143
1144                 return 0;
1145         ],[
1146                 AC_MSG_RESULT(yes)
1147                 AC_DEFINE(HAVE_NET_DEVICE_EXTENDED_TX_EXT, 1,
1148                           [ is defined])
1149         ],[
1150                 AC_MSG_RESULT(no)
1151         ])
1152
1153         AC_MSG_CHECKING([if net_device_extended has ndo_busy_poll])
1154         LB_LINUX_TRY_COMPILE([
1155                 #include <linux/netdevice.h>
1156
1157                 int busy_poll(struct napi_struct *napi)
1158                 {
1159                         return 0;
1160                 }
1161         ],[
1162                 struct net_device *dev = NULL;
1163
1164                 netdev_extended(dev)->ndo_busy_poll = busy_poll;
1165
1166                 return 0;
1167         ],[
1168                 AC_MSG_RESULT(yes)
1169                 AC_DEFINE(HAVE_NETDEV_EXTENDED_NDO_BUSY_POLL, 1,
1170                           [ is defined])
1171         ],[
1172                 AC_MSG_RESULT(no)
1173         ])
1174
1175         AC_MSG_CHECKING([if netdevice.h has set_netdev_hw_features])
1176         LB_LINUX_TRY_COMPILE([
1177                 #include <linux/netdevice.h>
1178         ],[
1179                 struct net_device *dev = NULL;
1180
1181                 set_netdev_hw_features(dev, 0);
1182
1183                 return 0;
1184         ],[
1185                 AC_MSG_RESULT(yes)
1186                 AC_DEFINE(HAVE_SET_NETDEV_HW_FEATURES, 1,
1187                           [ is defined])
1188         ],[
1189                 AC_MSG_RESULT(no)
1190         ])
1191
1192         AC_MSG_CHECKING([if netdevice.h has netif_set_xps_queue])
1193         LB_LINUX_TRY_COMPILE([
1194                 #include <linux/netdevice.h>
1195         ],[
1196                 struct net_device *dev = NULL;
1197
1198                 netif_set_xps_queue(dev, NULL, 0);
1199
1200                 return 0;
1201         ],[
1202                 AC_MSG_RESULT(yes)
1203                 AC_DEFINE(HAVE_NETIF_SET_XPS_QUEUE, 1,
1204                           [ is defined])
1205         ],[
1206                 AC_MSG_RESULT(no)
1207         ])
1208
1209
1210         AC_MSG_CHECKING([if struct net_device_ops has *ndo_set_features])
1211         LB_LINUX_TRY_COMPILE([
1212                 #include <linux/netdevice.h>
1213
1214                 int set_features(struct net_device *dev, netdev_features_t features)
1215                 {
1216                         return 0;
1217                 }
1218         ],[
1219                 struct net_device_ops netdev_ops;
1220
1221                 netdev_ops.ndo_set_features = set_features;
1222                 return 0;
1223         ],[
1224                 AC_MSG_RESULT(yes)
1225                 AC_DEFINE(HAVE_NDO_SET_FEATURES, 1,
1226                           [ndo_set_features is defined])
1227         ],[
1228                 AC_MSG_RESULT(no)
1229         ])
1230
1231         AC_MSG_CHECKING([if struct net_device_ops has *ndo_setup_tc])
1232         LB_LINUX_TRY_COMPILE([
1233                 #include <linux/netdevice.h>
1234         ],[
1235                 struct net_device_ops x = {
1236                         .ndo_setup_tc = NULL,
1237                 };
1238
1239                 return 0;
1240         ],[
1241                 AC_MSG_RESULT(yes)
1242                 AC_DEFINE(HAVE_NDO_SETUP_TC, 1,
1243                           [ndo_setup_tc is defined])
1244         ],[
1245                 AC_MSG_RESULT(no)
1246         ])
1247
1248         AC_MSG_CHECKING([if struct net_device_ops has *ndo_rx_flow_steer])
1249         LB_LINUX_TRY_COMPILE([
1250                 #include <linux/netdevice.h>
1251
1252                 int rx_flow_steer(struct net_device *dev,
1253                                                      const struct sk_buff *skb,
1254                                                      u16 rxq_index,
1255                                                      u32 flow_id)
1256                 {
1257                         return 0;
1258                 }
1259         ],[
1260                 struct net_device_ops netdev_ops;
1261
1262                 netdev_ops.ndo_rx_flow_steer = rx_flow_steer;
1263                 return 0;
1264         ],[
1265                 AC_MSG_RESULT(yes)
1266                 AC_DEFINE(HAVE_NDO_RX_FLOW_STEER, 1,
1267                           [ndo_rx_flow_steer is defined])
1268         ],[
1269                 AC_MSG_RESULT(no)
1270         ])
1271
1272         AC_MSG_CHECKING([if struct net_device has priv_flags])
1273         LB_LINUX_TRY_COMPILE([
1274                 #include <linux/netdevice.h>
1275         ],[
1276                 struct net_device *netdev;
1277                 netdev->priv_flags = 0;
1278
1279                 return 0;
1280         ],[
1281                 AC_MSG_RESULT(yes)
1282                 AC_DEFINE(HAVE_NET_DEVICE_PRIV_FLAGS, 1,
1283                           [priv_flags is defined])
1284         ],[
1285                 AC_MSG_RESULT(no)
1286         ])
1287
1288         AC_MSG_CHECKING([if struct net_device_ops has *ndo_get_stats64])
1289         LB_LINUX_TRY_COMPILE([
1290                 #include <linux/netdevice.h>
1291
1292                 struct rtnl_link_stats64* get_stats_64(struct net_device *dev,
1293                                                      struct rtnl_link_stats64 *storage)
1294                 {
1295                         struct rtnl_link_stats64 stats_64;
1296                         return &stats_64;
1297                 }
1298         ],[
1299                 struct net_device_ops netdev_ops;
1300
1301                 netdev_ops.ndo_get_stats64 = get_stats_64;
1302
1303                 return 0;
1304         ],[
1305                 AC_MSG_RESULT(yes)
1306                 AC_DEFINE(HAVE_NDO_GET_STATS64, 1,
1307                           [ndo_get_stats64 is defined])
1308         ],[
1309                 AC_MSG_RESULT(no)
1310         ])
1311         AC_MSG_CHECKING([if struct net_device_ops has ndo_bridge_set/getlink])
1312         LB_LINUX_TRY_COMPILE([
1313                 #include <linux/netdevice.h>
1314         ],[
1315                 struct net_device_ops netdev_ops =  {
1316                         .ndo_bridge_setlink = NULL,
1317                         .ndo_bridge_getlink = NULL,
1318                 };
1319
1320                 return 0;
1321         ],[
1322                 AC_MSG_RESULT(yes)
1323                 AC_DEFINE(HAVE_NDO_BRIDGE_SET_GET_LINK, 1,
1324                           [ndo_bridge_set/getlink is defined])
1325         ],[
1326                 AC_MSG_RESULT(no)
1327         ])
1328
1329         AC_MSG_CHECKING([if rtnetlink.h ndo_dflt_bridge_getlink has 7 params])
1330         LB_LINUX_TRY_COMPILE([
1331                 #include <linux/rtnetlink.h>
1332         ],[
1333                 ndo_dflt_bridge_getlink(NULL, 0, 0, NULL, 0, 0, 0);
1334
1335                 return 0;
1336         ],[
1337                 AC_MSG_RESULT(yes)
1338                 AC_DEFINE(HAVE_NDO_DFLT_BRIDGE_GETLINK_7_PARAMS, 1,
1339                         [ ndo_dflt_bridge_getlink with 7 params is defined])
1340         ],[
1341                 AC_MSG_RESULT(no)
1342         ])
1343
1344         AC_MSG_CHECKING([if struct net_device_ops ndo_vlan_rx_add_vid has 3 parameters ])
1345         LB_LINUX_TRY_COMPILE([
1346                 #include <linux/netdevice.h>
1347
1348         ],[
1349                 int vlan_rx_add_vid(struct net_device *dev,__be16 proto, u16 vid)
1350                 {
1351                         return 0;
1352                 }
1353                 struct net_device_ops netdev_ops;
1354
1355                 netdev_ops.ndo_vlan_rx_add_vid = vlan_rx_add_vid;
1356                 netdev_ops.ndo_vlan_rx_add_vid (NULL, 1, 1) ;
1357
1358                 return 0;
1359         ],[
1360                 AC_MSG_RESULT(yes)
1361                 AC_DEFINE(HAVE_NDO_RX_ADD_VID_HAS_3_PARAMS, 1,
1362                           [ndo_vlan_rx_add_vid has 3 parameters])
1363         ],[
1364                 AC_MSG_RESULT(no)
1365         ])
1366
1367         AC_MSG_CHECKING([if net_device_ops has ndo_get_phys_port_id])
1368         LB_LINUX_TRY_COMPILE([
1369                 #include <linux/netdevice.h>
1370
1371                 int get_phys_port_id(struct net_device *dev,
1372                                      struct netdev_phys_port_id *ppid)
1373                 {
1374                         return 0;
1375                 }
1376         ],[
1377                 struct net_device_ops netdev_ops;
1378
1379                 netdev_ops.ndo_get_phys_port_id = get_phys_port_id;
1380
1381                 return 0;
1382         ],[
1383                 AC_MSG_RESULT(yes)
1384                 AC_DEFINE(HAVE_NETDEV_NDO_GET_PHYS_PORT_ID, 1,
1385                           [ is defined])
1386         ],[
1387                 AC_MSG_RESULT(no)
1388         ])
1389
1390         AC_MSG_CHECKING([if struct net_device_ops_ext exist])
1391         LB_LINUX_TRY_COMPILE([
1392                 #include <linux/netdevice.h>
1393         ],[
1394                 struct net_device_ops_ext netdev_ops_ext = {
1395                         .size = sizeof(struct net_device_ops_ext),
1396                 };
1397
1398                 return 0;
1399         ],[
1400                 AC_MSG_RESULT(yes)
1401                 AC_DEFINE(HAVE_NET_DEVICE_OPS_EXT, 1,
1402                           [struct net_device_ops_ext is defined])
1403         ],[
1404                 AC_MSG_RESULT(no)
1405         ])
1406
1407         AC_MSG_CHECKING([if net_device_ops_ext has ndo_get_phys_port_id])
1408         LB_LINUX_TRY_COMPILE([
1409                 #include <linux/netdevice.h>
1410
1411                 int get_phys_port_id(struct net_device *dev,
1412                                      struct netdev_phys_port_id *ppid)
1413                 {
1414                         return 0;
1415                 }
1416         ],[
1417                 struct net_device_ops_ext netdev_ops_ext;
1418
1419                 netdev_ops_ext.ndo_get_phys_port_id = get_phys_port_id;
1420
1421                 return 0;
1422         ],[
1423                 AC_MSG_RESULT(yes)
1424                 AC_DEFINE(HAVE_NETDEV_EXT_NDO_GET_PHYS_PORT_ID, 1,
1425                           [ndo_get_phys_port_id is defined])
1426         ],[
1427                 AC_MSG_RESULT(no)
1428         ])
1429
1430         AC_MSG_CHECKING([if net_device_ops has ndo_set_vf_spoofchk])
1431         LB_LINUX_TRY_COMPILE([
1432                 #include <linux/netdevice.h>
1433
1434                 int set_vf_spoofchk(struct net_device *dev, int vf, bool setting)
1435                 {
1436                         return 0;
1437                 }
1438         ],[
1439                 struct net_device_ops netdev_ops;
1440
1441                 netdev_ops.ndo_set_vf_spoofchk = set_vf_spoofchk;
1442
1443                 return 0;
1444         ],[
1445                 AC_MSG_RESULT(yes)
1446                 AC_DEFINE(HAVE_NETDEV_OPS_NDO_SET_VF_SPOOFCHK, 1,
1447                           [ndo_set_vf_spoofchk is defined in net_device_ops])
1448         ],[
1449                 AC_MSG_RESULT(no)
1450         ])
1451
1452         AC_MSG_CHECKING([if net_device_ops_ext has ndo_set_vf_spoofchk])
1453         LB_LINUX_TRY_COMPILE([
1454                 #include <linux/netdevice.h>
1455
1456                 int set_vf_spoofchk(struct net_device *dev, int vf, bool setting)
1457                 {
1458                         return 0;
1459                 }
1460         ],[
1461                 struct net_device_ops_ext netdev_ops_ext;
1462
1463                 netdev_ops_ext.ndo_set_vf_spoofchk = set_vf_spoofchk;
1464
1465                 return 0;
1466         ],[
1467                 AC_MSG_RESULT(yes)
1468                 AC_DEFINE(HAVE_NETDEV_OPS_EXT_NDO_SET_VF_SPOOFCHK, 1,
1469                           [ndo_set_vf_spoofchk is defined in net_device_ops_ext])
1470         ],[
1471                 AC_MSG_RESULT(no)
1472         ])
1473
1474         AC_MSG_CHECKING([if net_device_ops has ndo_set_vf_link_state])
1475         LB_LINUX_TRY_COMPILE([
1476                 #include <linux/netdevice.h>
1477
1478                 int set_vf_link_state(struct net_device *dev, int vf, int link_state)
1479                 {
1480                         return 0;
1481                 }
1482         ],[
1483                 struct net_device_ops netdev_ops;
1484
1485                 netdev_ops.ndo_set_vf_link_state = set_vf_link_state;
1486
1487                 return 0;
1488         ],[
1489                 AC_MSG_RESULT(yes)
1490                 AC_DEFINE(HAVE_NETDEV_OPS_NDO_SET_VF_LINK_STATE, 1,
1491                           [ndo_set_vf_link_state is defined in net_device_ops])
1492         ],[
1493                 AC_MSG_RESULT(no)
1494         ])
1495
1496         AC_MSG_CHECKING([if net_device_ops_ext has ndo_set_vf_link_state])
1497         LB_LINUX_TRY_COMPILE([
1498                 #include <linux/netdevice.h>
1499
1500                 int set_vf_link_state(struct net_device *dev, int vf, int link_state)
1501                 {
1502                         return 0;
1503                 }
1504         ],[
1505                 struct net_device_ops_ext netdev_ops_ext;
1506
1507                 netdev_ops_ext.ndo_set_vf_link_state = set_vf_link_state;
1508
1509                 return 0;
1510         ],[
1511                 AC_MSG_RESULT(yes)
1512                 AC_DEFINE(HAVE_NETDEV_OPS_EXT_NDO_SET_VF_LINK_STATE, 1,
1513                           [ndo_set_vf_link_state is defined])
1514         ],[
1515                 AC_MSG_RESULT(no)
1516         ])
1517
1518
1519         AC_MSG_CHECKING([if netdevice.h netif_set_real_num_tx_queues returns int])
1520         LB_LINUX_TRY_COMPILE([
1521                 #include <linux/netdevice.h>
1522         ],[
1523                 struct net_device dev;
1524                 int ret;
1525                 ret = netif_set_real_num_tx_queues(&dev, 2);
1526                 return 0;
1527         ],[
1528                 AC_MSG_RESULT(yes)
1529                 AC_DEFINE(HAVE_RETURN_INT_FOR_SET_NUM_TX_QUEUES, 1,
1530                           [netif_set_real_num_tx_queues returns int])
1531         ],[
1532                 AC_MSG_RESULT(no)
1533         ])
1534
1535         AC_MSG_CHECKING([if struct netdevice.h has struct xps_map])
1536         LB_LINUX_TRY_COMPILE([
1537                 #include <linux/netdevice.h>
1538         ],[
1539                 struct xps_map map;
1540                 map.len = 0;
1541
1542                 return 0;
1543         ],[
1544                 AC_MSG_RESULT(yes)
1545                 AC_DEFINE(HAVE_XPS_MAP, 1,
1546                           [struct xps_map is defined])
1547         ],[
1548                 AC_MSG_RESULT(no)
1549         ])
1550
1551         AC_MSG_CHECKING([if struct ethtool_ops has set_phys_id])
1552         LB_LINUX_TRY_COMPILE([
1553                 #include <linux/ethtool.h>
1554         ],[
1555                 const struct ethtool_ops en_ethtool_ops = {
1556                         .set_phys_id= NULL,
1557                 };
1558
1559                 return 0;
1560         ],[
1561                 AC_MSG_RESULT(yes)
1562                 AC_DEFINE(HAVE_SET_PHYS_ID, 1,
1563                           [set_phys_id is defined])
1564         ],[
1565                 AC_MSG_RESULT(no)
1566         ])
1567
1568         AC_MSG_CHECKING([if struct ethtool_ops has get/set_channels])
1569         LB_LINUX_TRY_COMPILE([
1570                 #include <linux/ethtool.h>
1571         ],[
1572                 const struct ethtool_ops en_ethtool_ops = {
1573                         .get_channels = NULL,
1574                         .set_channels = NULL,
1575                 };
1576
1577                 return 0;
1578         ],[
1579                 AC_MSG_RESULT(yes)
1580                 AC_DEFINE(HAVE_GET_SET_CHANNELS, 1,
1581                           [get/set_channels is defined])
1582         ],[
1583                 AC_MSG_RESULT(no)
1584         ])
1585
1586         AC_MSG_CHECKING([if struct ethtool_ops_ext has get/set_channels])
1587         LB_LINUX_TRY_COMPILE([
1588                 #include <linux/ethtool.h>
1589         ],[
1590                 const struct ethtool_ops_ext en_ethtool_ops_ext = {
1591                         .get_channels = NULL,
1592                         .set_channels = NULL,
1593                 };
1594
1595                 return 0;
1596         ],[
1597                 AC_MSG_RESULT(yes)
1598                 AC_DEFINE(HAVE_GET_SET_CHANNELS_EXT, 1,
1599                           [get/set_channels is defined in ethtool_ops_ext])
1600         ],[
1601                 AC_MSG_RESULT(no)
1602         ])
1603
1604         AC_MSG_CHECKING([if struct ethtool_ops has get_ts_info])
1605         LB_LINUX_TRY_COMPILE([
1606                 #include <linux/ethtool.h>
1607         ],[
1608                 const struct ethtool_ops en_ethtool_ops = {
1609                         .get_ts_info = NULL,
1610                 };
1611
1612                 return 0;
1613         ],[
1614                 AC_MSG_RESULT(yes)
1615                 AC_DEFINE(HAVE_GET_TS_INFO, 1,
1616                           [get_ts_info is defined])
1617         ],[
1618                 AC_MSG_RESULT(no)
1619         ])
1620
1621         AC_MSG_CHECKING([if linux/timecounter.h exists])
1622         LB_LINUX_TRY_COMPILE([
1623                 #include <linux/timecounter.h>
1624         ],[
1625                 return 0;
1626         ],[
1627                 AC_MSG_RESULT(yes)
1628                 AC_DEFINE(HAVE_TIMECOUNTER_H, 1,
1629                           [linux/timecounter.h exists])
1630         ],[
1631                 AC_MSG_RESULT(no)
1632         ])
1633
1634         # timecounter_adjtime can be in timecounter.h or clocksource.h
1635         AC_MSG_CHECKING([if linux/timecounter.h has timecounter_adjtime])
1636         LB_LINUX_TRY_COMPILE([
1637                 #include <linux/timecounter.h>
1638         ],[
1639                 struct timecounter x;
1640                 s64 y = 0;
1641                 timecounter_adjtime(&x, y);
1642
1643                 return 0;
1644         ],[
1645                 AC_MSG_RESULT(yes)
1646                 AC_DEFINE(HAVE_TIMECOUNTER_ADJTIME, 1,
1647                           [timecounter_adjtime is defined])
1648         ],[
1649                 AC_MSG_RESULT(no)
1650         ])
1651
1652         AC_MSG_CHECKING([if linux/clocksource.h has timecounter_adjtime])
1653         LB_LINUX_TRY_COMPILE([
1654                 #include <linux/clocksource.h>
1655         ],[
1656                 struct timecounter x;
1657                 s64 y = 0;
1658                 timecounter_adjtime(&x, y);
1659
1660                 return 0;
1661         ],[
1662                 AC_MSG_RESULT(yes)
1663                 AC_DEFINE(HAVE_TIMECOUNTER_ADJTIME, 1,
1664                           [timecounter_adjtime is defined])
1665         ],[
1666                 AC_MSG_RESULT(no)
1667         ])
1668
1669         AC_MSG_CHECKING([if struct ethtool_ops has set_dump])
1670         LB_LINUX_TRY_COMPILE([
1671                 #include <linux/ethtool.h>
1672         ],[
1673                 const struct ethtool_ops en_ethtool_ops = {
1674                         .set_dump = NULL,
1675                 };
1676
1677                 return 0;
1678         ],[
1679                 AC_MSG_RESULT(yes)
1680                 AC_DEFINE(HAVE_ETHTOOL_OPS_SET_DUMP, 1,
1681                           [set_dump is defined])
1682         ],[
1683                 AC_MSG_RESULT(no)
1684         ])
1685
1686         AC_MSG_CHECKING([if struct ethtool_ops has get_module_info])
1687         LB_LINUX_TRY_COMPILE([
1688                 #include <linux/ethtool.h>
1689         ],[
1690                 const struct ethtool_ops en_ethtool_ops = {
1691                         .get_module_info = NULL,
1692                 };
1693
1694                 return 0;
1695         ],[
1696                 AC_MSG_RESULT(yes)
1697                 AC_DEFINE(HAVE_ETHTOOL_OPS_GET_MODULE_INFO, 1,
1698                           [get_module_info is defined])
1699         ],[
1700                 AC_MSG_RESULT(no)
1701         ])
1702
1703         AC_MSG_CHECKING([if struct ethtool_ops has get_module_eeprom])
1704         LB_LINUX_TRY_COMPILE([
1705                 #include <linux/ethtool.h>
1706         ],[
1707                 const struct ethtool_ops en_ethtool_ops = {
1708                         .get_module_eeprom = NULL,
1709                 };
1710
1711                 return 0;
1712         ],[
1713                 AC_MSG_RESULT(yes)
1714                 AC_DEFINE(HAVE_ETHTOOL_OPS_GET_MODULE_EEPROM, 1,
1715                           [get_module_eeprom is defined])
1716         ],[
1717                 AC_MSG_RESULT(no)
1718         ])
1719
1720         AC_MSG_CHECKING([if struct ethtool_ops_ext has get_ts_info])
1721         LB_LINUX_TRY_COMPILE([
1722                 #include <linux/ethtool.h>
1723         ],[
1724                 const struct ethtool_ops_ext en_ethtool_ops_ext = {
1725                         .get_ts_info = NULL,
1726                 };
1727
1728                 return 0;
1729         ],[
1730                 AC_MSG_RESULT(yes)
1731                 AC_DEFINE(HAVE_GET_TS_INFO_EXT, 1,
1732                           [get_ts_info is defined in ethtool_ops_ext])
1733         ],[
1734                 AC_MSG_RESULT(no)
1735         ])
1736
1737         AC_MSG_CHECKING([if struct ethtool_flow_ext has h_dest])
1738         LB_LINUX_TRY_COMPILE([
1739                 #include <linux/ethtool.h>
1740         ],[
1741                 unsigned char mac[ETH_ALEN];
1742                 struct ethtool_flow_ext h_ext;
1743
1744                 memcpy(&mac, h_ext.h_dest, ETH_ALEN);
1745
1746                 return 0;
1747         ],[
1748                 AC_MSG_RESULT(yes)
1749                 AC_DEFINE(HAVE_ETHTOOL_FLOW_EXT_H_DEST, 1,
1750                           [ethtool_flow_ext has h_dest])
1751         ],[
1752                 AC_MSG_RESULT(no)
1753         ])
1754
1755         AC_MSG_CHECKING([if netdevice.h has struct dev_addr_list])
1756         LB_LINUX_TRY_COMPILE([
1757                 #include <linux/netdevice.h>
1758         ],[
1759                 struct dev_addr_list addr;
1760                 return 0;
1761         ],[
1762                 AC_MSG_RESULT(yes)
1763                 AC_DEFINE(HAVE_NETDEV_DEV_ADDR, 1,
1764                           [dev_addr_list is defined])
1765         ],[
1766                 AC_MSG_RESULT(no)
1767         ])
1768
1769         AC_MSG_CHECKING([if pci.h has pci_vfs_assigned])
1770         LB_LINUX_TRY_COMPILE([
1771                 #include <linux/pci.h>
1772         ],[
1773                 struct pci_dev pdev;
1774                 pci_vfs_assigned(&pdev);
1775                 return 0;
1776         ],[
1777                 AC_MSG_RESULT(yes)
1778                 AC_DEFINE(HAVE_PCI_VF_ASSIGNED, 1,
1779                           [pci_vfs_assigned is defined])
1780         ],[
1781                 AC_MSG_RESULT(no)
1782         ])
1783
1784         AC_MSG_CHECKING([if vlan_insert_tag_set_proto is defined])
1785         LB_LINUX_TRY_COMPILE([
1786                 #include <linux/if_vlan.h>
1787         ],[
1788                 struct sk_buff *skb;
1789                 vlan_insert_tag_set_proto(skb, 0, 0);
1790                 return 0;
1791         ],[
1792                 AC_MSG_RESULT(yes)
1793                 AC_DEFINE(HAVE_VLAN_INSERT_TAG_SET_PROTO, 1,
1794                           [vlan_insert_tag_set_proto is defined])
1795         ],[
1796                 AC_MSG_RESULT(no)
1797                 AC_MSG_CHECKING([if __vlan_put_tag has 3 parameters])
1798                 LB_LINUX_TRY_COMPILE([
1799                         #include <linux/if_vlan.h>
1800                 ],[
1801                         struct sk_buff *skb;
1802                         __vlan_put_tag(skb, 0, 0);
1803                         return 0;
1804                 ],[
1805                         AC_MSG_RESULT(yes)
1806                         AC_DEFINE(HAVE_3_PARAMS_FOR_VLAN_PUT_TAG, 1,
1807                                   [__vlan_put_tag has 3 parameters])
1808                 ],[
1809                         AC_MSG_RESULT(no)
1810                 ])
1811         ])
1812
1813         AC_MSG_CHECKING([if __vlan_hwaccel_put_tag has 3 parameters])
1814         LB_LINUX_TRY_COMPILE([
1815                 #include <linux/if_vlan.h>
1816         ],[
1817                 struct sk_buff *skb;
1818                 __vlan_hwaccel_put_tag(skb, 0, 0);
1819
1820                 return 0;
1821         ],[
1822                 AC_MSG_RESULT(yes)
1823                 AC_DEFINE(HAVE_3_PARAMS_FOR_VLAN_HWACCEL_PUT_TAG, 1,
1824                           [__vlan_hwaccel_put_tag has 3 parameters])
1825         ],[
1826                 AC_MSG_RESULT(no)
1827         ])
1828
1829         AC_MSG_CHECKING([if struct inet6_ifaddr has if_next])
1830         LB_LINUX_TRY_COMPILE([
1831                 #include <net/if_inet6.h>
1832         ],[
1833                 struct inet6_ifaddr ifp ;
1834                 ifp.if_next = 0;
1835
1836                 return 0;
1837         ],[
1838                 AC_MSG_RESULT(yes)
1839                 AC_DEFINE(HAVE_INETADDR_IF_NEXT, 1,
1840                           [if_next is defined])
1841         ],[
1842                 AC_MSG_RESULT(no)
1843         ])
1844
1845         AC_MSG_CHECKING([if struct net_device has hw_features])
1846         LB_LINUX_TRY_COMPILE([
1847                 #include <linux/netdevice.h>
1848         ],[
1849                 struct net_device dev;
1850                 dev.hw_features = 0;
1851
1852                 return 0;
1853         ],[
1854                 AC_MSG_RESULT(yes)
1855                 AC_DEFINE(HAVE_NETDEV_HW_FEATURES, 1,
1856                           [hw_features is defined])
1857         ],[
1858                 AC_MSG_RESULT(no)
1859         ])
1860
1861         AC_MSG_CHECKING([if struct net_device has hw_enc_features])
1862         LB_LINUX_TRY_COMPILE([
1863                 #include <linux/netdevice.h>
1864         ],[
1865                 struct net_device dev;
1866                 dev.hw_enc_features = 0;
1867
1868                 return 0;
1869         ],[
1870                 AC_MSG_RESULT(yes)
1871                 AC_DEFINE(HAVE_NETDEV_HW_ENC_FEATURES, 1,
1872                           [hw_enc_features is defined])
1873         ],[
1874                 AC_MSG_RESULT(no)
1875         ])
1876
1877         AC_MSG_CHECKING([if struct net_device has rx_cpu_rmap])
1878         LB_LINUX_TRY_COMPILE([
1879                 #include <linux/netdevice.h>
1880         ],[
1881                 struct net_device dev;
1882                 dev.rx_cpu_rmap = NULL;
1883
1884                 return 0;
1885         ],[
1886                 AC_MSG_RESULT(yes)
1887                 AC_DEFINE(HAVE_NETDEV_RX_CPU_RMAP, 1,
1888                           [rx_cpu_rmap is defined])
1889         ],[
1890                 AC_MSG_RESULT(no)
1891         ])
1892
1893         AC_MSG_CHECKING([if if_vlan.h has vlan_hwaccel_receive_skb])
1894         LB_LINUX_TRY_COMPILE([
1895                 #include <linux/if_vlan.h>
1896         ],[
1897                 struct sk_buff *skb;
1898                 vlan_hwaccel_receive_skb(skb,0,0);
1899                 return 0;
1900         ],[
1901                 AC_MSG_RESULT(yes)
1902                 AC_DEFINE(HAVE_VLAN_HWACCEL_RECEIVE_SKB, 1,
1903                           [vlan_hwaccel_receive_skb is defined])
1904         ],[
1905                 AC_MSG_RESULT(no)
1906         ])
1907
1908         AC_MSG_CHECKING([if irqdesc.h has irq_desc_get_irq_data])
1909         LB_LINUX_TRY_COMPILE([
1910                 #include <linux/irq.h>
1911                 #include <linux/irqdesc.h>
1912         ],[
1913                 struct irq_desc desc;
1914                 struct irq_data *data = irq_desc_get_irq_data(&desc);
1915
1916                 return 0;
1917         ],[
1918                 AC_MSG_RESULT(yes)
1919                 AC_DEFINE(HAVE_IRQ_DESC_GET_IRQ_DATA, 1,
1920                           [irq_desc_get_irq_data is defined])
1921         ],[
1922                 AC_MSG_RESULT(no)
1923         ])
1924
1925
1926         AC_MSG_CHECKING([if pci_dev has pcie_mpss])
1927         LB_LINUX_TRY_COMPILE([
1928                 #include <linux/pci.h>
1929         ],[
1930                 struct pci_dev *pdev;
1931
1932                 pdev->pcie_mpss = 0;
1933                 return 0;
1934         ],[
1935                 AC_MSG_RESULT(yes)
1936                 AC_DEFINE(HAVE_PCI_DEV_PCIE_MPSS, 1,
1937                           [pcie_mpss is defined])
1938         ],[
1939                 AC_MSG_RESULT(no)
1940         ])
1941
1942         AC_MSG_CHECKING([if uapi/linux/if_ether.h exist])
1943         LB_LINUX_TRY_COMPILE([
1944                 #include <uapi/linux/if_ether.h>
1945         ],[
1946                 return 0;
1947         ],[
1948                 AC_MSG_RESULT(yes)
1949                 AC_DEFINE(HAVE_UAPI_LINUX_IF_ETHER_H, 1,
1950                           [uapi/linux/if_ether.h exist])
1951         ],[
1952                 AC_MSG_RESULT(no)
1953         ])
1954
1955         AC_MSG_CHECKING([if ifla_vf_info has spoofchk])
1956         LB_LINUX_TRY_COMPILE([
1957                 #include <linux/if_link.h>
1958         ],[
1959                 struct ifla_vf_info *ivf;
1960
1961                 ivf->spoofchk = 0;
1962                 return 0;
1963         ],[
1964                 AC_MSG_RESULT(yes)
1965                 AC_DEFINE(HAVE_VF_INFO_SPOOFCHK, 1,
1966                           [spoofchk is defined])
1967         ],[
1968                 AC_MSG_RESULT(no)
1969         ])
1970
1971         AC_MSG_CHECKING([if vxlan.h has vxlan_gso_check])
1972         LB_LINUX_TRY_COMPILE([
1973                 #include <net/vxlan.h>
1974         ],[
1975                 vxlan_gso_check(NULL);
1976
1977                 return 0;
1978         ],[
1979                 AC_MSG_RESULT(yes)
1980                 AC_DEFINE(HAVE_VXLAN_GSO_CHECK, 1,
1981                           [vxlan_gso_check is defined])
1982         ],[
1983                 AC_MSG_RESULT(no)
1984         ])
1985
1986         AC_MSG_CHECKING([if dst.h has dst_get_neighbour])
1987         LB_LINUX_TRY_COMPILE([
1988                 #include <net/dst.h>
1989         ],[
1990                 struct neighbour *neigh = dst_get_neighbour(NULL);
1991
1992                 return 0;
1993         ],[
1994                 AC_MSG_RESULT(yes)
1995                 AC_DEFINE(HAVE_DST_GET_NEIGHBOUR, 1,
1996                           [ is defined])
1997         ],[
1998                 AC_MSG_RESULT(no)
1999         ])
2000
2001         AC_MSG_CHECKING([if netlink_dump_start has 6 parameters])
2002         LB_LINUX_TRY_COMPILE([
2003                 #include <linux/netlink.h>
2004         ],[
2005                 int ret = netlink_dump_start(NULL, NULL, NULL, NULL, NULL, 0);
2006
2007                 return 0;
2008         ],[
2009                 AC_MSG_RESULT(yes)
2010                 AC_DEFINE(HAVE_NETLINK_DUMP_START_6P, 1,
2011                           [ is defined])
2012         ],[
2013                 AC_MSG_RESULT(no)
2014         ])
2015
2016         AC_MSG_CHECKING([if netlink_dump_start has 5 parameters])
2017         LB_LINUX_TRY_COMPILE([
2018                 #include <linux/netlink.h>
2019         ],[
2020                 int ret = netlink_dump_start(NULL, NULL, NULL, NULL, NULL);
2021
2022                 return 0;
2023         ],[
2024                 AC_MSG_RESULT(yes)
2025                 AC_DEFINE(HAVE_NETLINK_DUMP_START_5P, 1,
2026                           [ is defined])
2027         ],[
2028                 AC_MSG_RESULT(no)
2029         ])
2030
2031         AC_MSG_CHECKING([if struct dcbnl_rtnl_ops has ieee_getmaxrate/ieee_setmaxrate])
2032         LB_LINUX_TRY_COMPILE([
2033                 #include <net/dcbnl.h>
2034         ],[
2035                 const struct dcbnl_rtnl_ops en_dcbnl_ops = {
2036                         .ieee_getmaxrate = NULL,
2037                         .ieee_setmaxrate = NULL,
2038                 };
2039
2040                 return 0;
2041         ],[
2042                 AC_MSG_RESULT(yes)
2043                 AC_DEFINE(HAVE_IEEE_GET_SET_MAXRATE, 1,
2044                           [ieee_getmaxrate/ieee_setmaxrate is defined])
2045         ],[
2046                 AC_MSG_RESULT(no)
2047         ])
2048
2049         AC_LANG_PUSH(C)
2050         ac_c_werror_flag=yes
2051         save_EXTRA_KCFLAGS=$EXTRA_KCFLAGS
2052         EXTRA_KCFLAGS="$EXTRA_KCFLAGS -Werror"
2053
2054         AC_MSG_CHECKING([if bonding.h bond_for_each_slave has int for 3rd parameter])
2055         LB_LINUX_TRY_COMPILE([
2056                 #include <net/bonding.h>
2057         ],[
2058                 struct bonding *bond = NULL;
2059                 struct slave *slave = NULL;
2060                 int iter;
2061
2062                 bond_for_each_slave(bond, slave, iter) ;
2063
2064                 return 0;
2065         ],[
2066                 AC_MSG_RESULT(yes)
2067                 AC_DEFINE(HAVE_BOND_FOR_EACH_SLAVE_3RD_PARAM_IS_INT, 1,
2068                           [bond_for_each_slave has int for 3rd parameter])
2069         ],[
2070                 AC_MSG_RESULT(no)
2071         ])
2072         EXTRA_KCFLAGS="$save_EXTRA_KCFLAGS"
2073         ac_c_werror_flag=
2074         AC_LANG_POP
2075
2076         AC_MSG_CHECKING([if netdevice.h has netdev_master_upper_dev_get_rcu])
2077         LB_LINUX_TRY_COMPILE([
2078                 #include <linux/netdevice.h>
2079         ],[
2080                 netdev_master_upper_dev_get_rcu(NULL);
2081
2082                 return 0;
2083         ],[
2084                 AC_MSG_RESULT(yes)
2085                 AC_DEFINE(HAVE_NETDEV_MASTER_UPPER_DEV_GET_RCU, 1,
2086                           [netdev_master_upper_dev_get_rcu is defined])
2087         ],[
2088                 AC_MSG_RESULT(no)
2089         ])
2090
2091         AC_MSG_CHECKING([if __vlan_find_dev_deep has 3 parameters])
2092         LB_LINUX_TRY_COMPILE([
2093                 #include <linux/if_vlan.h>
2094         ],[
2095                 __vlan_find_dev_deep(NULL, 0, 0);
2096
2097                 return 0;
2098         ],[
2099                 AC_MSG_RESULT(yes)
2100                 AC_DEFINE(HAVE__VLAN_FIND_DEV_DEEP_3P, 1,
2101                           [__vlan_find_dev_deep has 3 paramters])
2102         ],[
2103                 AC_MSG_RESULT(no)
2104         ])
2105
2106         AC_MSG_CHECKING([if sk_buff.h has __skb_alloc_page])
2107         LB_LINUX_TRY_COMPILE([
2108                 #include <linux/skbuff.h>
2109         ],[
2110                 __skb_alloc_page(0, NULL);
2111
2112                 return 0;
2113         ],[
2114                 AC_MSG_RESULT(yes)
2115                 AC_DEFINE(HAVE__SKB_ALLOC_PAGE, 1,
2116                           [sk_buff has __skb_alloc_page])
2117         ],[
2118                 AC_MSG_RESULT(no)
2119         ])
2120
2121         AC_MSG_CHECKING([if __vlan_hwaccel_put_tag has 3 parameters])
2122         LB_LINUX_TRY_COMPILE([
2123                 #include <linux/if_vlan.h>
2124         ],[
2125                 __vlan_hwaccel_put_tag(NULL, 0, 0);
2126
2127                 return 0;
2128         ],[
2129                 AC_MSG_RESULT(yes)
2130                 AC_DEFINE(HAVE__VLAN_HWACCEL_PUT_TAG_3P, 1,
2131                           [__vlan_hwaccel_put_tag has 3 paramters])
2132         ],[
2133                 AC_MSG_RESULT(no)
2134         ])
2135
2136         AC_MSG_CHECKING([if linux/mm_types.h has struct page_frag])
2137         LB_LINUX_TRY_COMPILE([
2138                 #include <linux/mm_types.h>
2139         ],[
2140                 struct page_frag frag = {0};
2141
2142                 return 0;
2143         ],[
2144                 AC_MSG_RESULT(yes)
2145                 AC_DEFINE(HAVE_MM_TYPES_PAGE_FRAG, 1,
2146                           [linux/mm_types.h has struct page_frag])
2147         ],[
2148                 AC_MSG_RESULT(no)
2149         ])
2150
2151         AC_MSG_CHECKING([if if_vlan.h has __vlan_find_dev_deep])
2152         LB_LINUX_TRY_COMPILE([
2153                 #include <linux/if_vlan.h>
2154         ],[
2155                 __vlan_find_dev_deep(NULL, 0);
2156
2157                 return 0;
2158         ],[
2159                 AC_MSG_RESULT(yes)
2160                 AC_DEFINE(HAVE___VLAN_FIND_DEV_DEEP, 1,
2161                           [__vlan_find_dev_deep is defined])
2162         ],[
2163                 AC_MSG_RESULT(no)
2164         ])
2165
2166         AC_MSG_CHECKING([if idr .h has idr_Alloc])
2167         LB_LINUX_TRY_COMPILE([
2168                 #include <linux/idr.h>
2169         ],[
2170                 idr_alloc(NULL, NULL, 0, 0, 0);
2171                 return 0;
2172         ],[
2173                 AC_MSG_RESULT(yes)
2174                 AC_DEFINE(HAVE_IDR_NEW_INTERFACE, 1,
2175                           [idr_Alloc is defined]) ],[
2176                 AC_MSG_RESULT(no)
2177         ])
2178
2179         AC_MSG_CHECKING([if completion.h has reinit_completion])
2180         LB_LINUX_TRY_COMPILE([
2181                 #include <linux/completion.h>
2182         ],[
2183                 struct completion c;
2184
2185                 reinit_completion(&c);
2186                 return 0;
2187         ],[
2188                 AC_MSG_RESULT(yes)
2189                 AC_DEFINE(HAVE_REINIT_COMPLETION, 1,
2190                           [reinit_completion is defined])
2191         ],[
2192                 AC_MSG_RESULT(no)
2193         ])
2194
2195         AC_MSG_CHECKING([if dma-mapping.h has dma_set_mask_and_coherent])
2196         LB_LINUX_TRY_COMPILE([
2197                 #include <linux/dma-mapping.h>
2198         ],[
2199                 dma_set_mask_and_coherent(NULL, 0);
2200
2201                 return 0;
2202         ],[
2203                 AC_MSG_RESULT(yes)
2204                 AC_DEFINE(HAVE_DMA_SET_MASK_AND_COHERENT, 1,
2205                           [dma_set_mask_and_coherent is defined])
2206         ],[
2207                 AC_MSG_RESULT(no)
2208         ])
2209
2210         AC_MSG_CHECKING([if in.h has proto_ports_offset])
2211         LB_LINUX_TRY_COMPILE([
2212                 #include <linux/in.h>
2213         ],[
2214                 int x = proto_ports_offset(IPPROTO_TCP);
2215                 return 0;
2216         ],[
2217                 AC_MSG_RESULT(yes)
2218                 AC_DEFINE(HAVE_PROTO_PORTS_OFFSET, 1,
2219                           [proto_ports_offset is defined])
2220         ],[
2221                 AC_MSG_RESULT(no)
2222         ])
2223
2224         LB_CHECK_SYMBOL_EXPORT([elfcorehdr_addr],
2225                 [kernel/crash_dump.c],
2226                 [AC_DEFINE(HAVE_ELFCOREHDR_ADDR_EXPORTED, 1,
2227                         [elfcorehdr_addr is exported by the kernel])],
2228         [])
2229
2230         AC_MSG_CHECKING([if netif_set_real_num_rx_queues is defined])
2231         LB_LINUX_TRY_COMPILE([
2232                 #include <linux/netdevice.h>
2233         ],[
2234                 int rc = netif_set_real_num_rx_queues(NULL, 0);
2235
2236                 return rc;
2237         ],[
2238                 AC_MSG_RESULT(yes)
2239                 AC_DEFINE(HAVE_NETIF_SET_REAL_NUM_RX_QUEUES, 1,
2240                           [netif_set_real_num_rx_queues is defined])
2241         ],[
2242                 AC_MSG_RESULT(no)
2243         ])
2244
2245         AC_MSG_CHECKING([if if_vlan.h has is_vlan_dev])
2246         LB_LINUX_TRY_COMPILE([
2247                 #include <linux/netdevice.h>
2248                 #include <linux/if_vlan.h>
2249         ],[
2250                 struct net_device dev;
2251                 is_vlan_dev(&dev);
2252
2253                 return 0;
2254         ],[
2255                 AC_MSG_RESULT(yes)
2256                 AC_DEFINE(HAVE_IS_VLAN_DEV, 1,
2257                           [is_vlan_dev is defined])
2258         ],[
2259                 AC_MSG_RESULT(no)
2260         ])
2261
2262         AC_MSG_CHECKING([if linux/timecounter.h exists])
2263         LB_LINUX_TRY_COMPILE([
2264                 #include <linux/timecounter.h>
2265         ],[
2266                 return 0;
2267         ],[
2268                 AC_MSG_RESULT(yes)
2269                 AC_DEFINE(HAVE_TIMECOUNTER_H, 1,
2270                           [linux/timecounter.h exists])
2271         ],[
2272                 AC_MSG_RESULT(no)
2273         ])
2274
2275         # timecounter_adjtime can be in timecounter.h or clocksource.h
2276         AC_MSG_CHECKING([if linux/timecounter.h has timecounter_adjtime])
2277         LB_LINUX_TRY_COMPILE([
2278                 #include <linux/timecounter.h>
2279         ],[
2280                 struct timecounter x;
2281                 s64 y = 0;
2282                 timecounter_adjtime(&x, y);
2283
2284                 return 0;
2285         ],[
2286                 AC_MSG_RESULT(yes)
2287                 AC_DEFINE(HAVE_TIMECOUNTER_ADJTIME, 1,
2288                           [timecounter_adjtime is defined])
2289         ],[
2290                 AC_MSG_RESULT(no)
2291         ])
2292
2293         AC_MSG_CHECKING([if linux/clocksource.h has timecounter_adjtime])
2294         LB_LINUX_TRY_COMPILE([
2295                 #include <linux/clocksource.h>
2296         ],[
2297                 struct timecounter x;
2298                 s64 y = 0;
2299                 timecounter_adjtime(&x, y);
2300
2301                 return 0;
2302         ],[
2303                 AC_MSG_RESULT(yes)
2304                 AC_DEFINE(HAVE_TIMECOUNTER_ADJTIME, 1,
2305                           [timecounter_adjtime is defined])
2306         ],[
2307                 AC_MSG_RESULT(no)
2308         ])
2309
2310         AC_MSG_CHECKING([if cyclecounter_cyc2ns has 4 parameters])
2311         LB_LINUX_TRY_COMPILE([
2312                 #include <linux/timecounter.h>
2313         ],[
2314                 cyclecounter_cyc2ns(NULL, NULL, 0, NULL);
2315
2316                 return 0;
2317         ],[
2318                 AC_MSG_RESULT(yes)
2319                 AC_DEFINE(HAVE_CYCLECOUNTER_CYC2NS_4_PARAMS, 1,
2320                           [cyclecounter_cyc2ns has 4 parameters])
2321         ],[
2322                 AC_MSG_RESULT(no)
2323         ])
2324
2325         AC_MSG_CHECKING([if netdevice.h struct net_device_ops has ndo_features_check])
2326         LB_LINUX_TRY_COMPILE([
2327                 #include <linux/netdevice.h>
2328         ],[
2329                 static const struct net_device_ops mlx4_netdev_ops = {
2330                         .ndo_features_check     = NULL,
2331                 };
2332
2333                 return 0;
2334         ],[
2335                 AC_MSG_RESULT(yes)
2336                 AC_DEFINE(HAVE_NETDEV_FEATURES_T, 1,
2337                           [netdev_features_t is defined])
2338         ],[
2339                 AC_MSG_RESULT(no)
2340         ])
2341
2342         AC_MSG_CHECKING([if struct ethtool_ops get_rxnfc gets u32 *rule_locs])
2343         LB_LINUX_TRY_COMPILE([
2344                 #include <linux/ethtool.h>
2345                 static int mlx4_en_get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *c,
2346                                              u32 *rule_locs)
2347                 {
2348                         return 0;
2349                 }
2350         ],[
2351                 struct ethtool_ops x = {
2352                         .get_rxnfc = mlx4_en_get_rxnfc,
2353                 };
2354
2355                 return 0;
2356         ],[
2357                 AC_MSG_RESULT(yes)
2358                 AC_DEFINE(HAVE_ETHTOOL_OPS_GET_RXNFC_U32_RULE_LOCS, 1,
2359                           [ethtool_ops get_rxnfc gets u32 *rule_locs])
2360         ],[
2361                 AC_MSG_RESULT(no)
2362         ])
2363
2364         AC_MSG_CHECKING([if ethtool.h enum ethtool_stringset has ETH_SS_RSS_HASH_FUNCS])
2365         LB_LINUX_TRY_COMPILE([
2366                 #include <linux/ethtool.h>
2367         ],[
2368                 enum ethtool_stringset x = ETH_SS_RSS_HASH_FUNCS;
2369
2370                 return 0;
2371         ],[
2372                 AC_MSG_RESULT(yes)
2373                 AC_DEFINE(HAVE_ETH_SS_RSS_HASH_FUNCS, 1,
2374                           [ETH_SS_RSS_HASH_FUNCS is defined])
2375         ],[
2376                 AC_MSG_RESULT(no)
2377         ])
2378 ])
2379 #
2380 # COMPAT_CONFIG_HEADERS
2381 #
2382 # add -include config.h
2383 #
2384 AC_DEFUN([COMPAT_CONFIG_HEADERS],[
2385         AC_CONFIG_HEADERS([config.h])
2386         EXTRA_KCFLAGS="-include $PWD/config.h $EXTRA_KCFLAGS"
2387         AC_SUBST(EXTRA_KCFLAGS)
2388 ])
2389
2390 AC_DEFUN([OFA_PROG_LINUX],
2391 [
2392
2393 LB_LINUX_PATH
2394 LB_LINUX_SYMVERFILE
2395 LB_LINUX_CONFIG([MODULES],[],[
2396     AC_MSG_ERROR([module support is required to build mlnx kernel modules.])
2397 ])
2398 LB_LINUX_CONFIG([MODVERSIONS])
2399 LB_LINUX_CONFIG([KALLSYMS],[],[
2400     AC_MSG_ERROR([compat_mlnx requires that CONFIG_KALLSYMS is enabled in your kernel.])
2401 ])
2402
2403 LINUX_CONFIG_COMPAT
2404 COMPAT_CONFIG_HEADERS
2405
2406 ])