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