libcfs/autoconf/lustre-libcfs.m4

   1 #
   2 # LIBCFS_CONFIG_CDEBUG
   3 #
   4 # whether to enable various libcfs debugs (CDEBUG, ENTRY/EXIT, LASSERT, etc.)
   5 #
   6 AC_DEFUN([LIBCFS_CONFIG_CDEBUG], [
   7 AC_MSG_CHECKING([whether to enable CDEBUG, CWARN])
   8 AC_ARG_ENABLE([libcfs_cdebug],
   9         AS_HELP_STRING([--disable-libcfs-cdebug],
  10                 [disable libcfs CDEBUG, CWARN]),
  11         [], [enable_libcfs_cdebug="yes"])
  12 AC_MSG_RESULT([$enable_libcfs_cdebug])
  13 AS_IF([test "x$enable_libcfs_cdebug" = xyes],
  14         [AC_DEFINE(CDEBUG_ENABLED, 1, [enable libcfs CDEBUG, CWARN])])
  15
  16 AC_MSG_CHECKING([whether to enable ENTRY/EXIT])
  17 AC_ARG_ENABLE([libcfs_trace],
  18         AS_HELP_STRING([--disable-libcfs-trace],
  19                 [disable libcfs ENTRY/EXIT]),
  20         [], [enable_libcfs_trace="yes"])
  21 AC_MSG_RESULT([$enable_libcfs_trace])
  22 AS_IF([test "x$enable_libcfs_trace" = xyes],
  23         [AC_DEFINE(CDEBUG_ENTRY_EXIT, 1, [enable libcfs ENTRY/EXIT])])
  24
  25 AC_MSG_CHECKING([whether to enable LASSERT, LASSERTF])
  26 AC_ARG_ENABLE([libcfs_assert],
  27         AS_HELP_STRING([--disable-libcfs-assert],
  28                 [disable libcfs LASSERT, LASSERTF]),
  29         [], [enable_libcfs_assert="yes"])
  30 AC_MSG_RESULT([$enable_libcfs_assert])
  31 AS_IF([test x$enable_libcfs_assert = xyes],
  32         [AC_DEFINE(LIBCFS_DEBUG, 1, [enable libcfs LASSERT, LASSERTF])])
  33 ]) # LIBCFS_CONFIG_CDEBUG
  34
  35 #
  36 # LIBCFS_CONFIG_PANIC_DUMPLOG
  37 #
  38 # check if tunable panic_dumplog is wanted
  39 #
  40 AC_DEFUN([LIBCFS_CONFIG_PANIC_DUMPLOG], [
  41 AC_MSG_CHECKING([whether to use tunable 'panic_dumplog' support])
  42 AC_ARG_ENABLE([panic_dumplog],
  43         AS_HELP_STRING([--enable-panic_dumplog],
  44                 [enable panic_dumplog]),
  45         [], [enable_panic_dumplog="no"])
  46 AC_MSG_RESULT([$enable_panic_dumplog])
  47 AS_IF([test "x$enable_panic_dumplog" = xyes],
  48         [AC_DEFINE(LNET_DUMP_ON_PANIC, 1, [use dumplog on panic])])
  49 ]) # LIBCFS_CONFIG_PANIC_DUMPLOG
  50
  51 #
  52 # Kernel version 3.11 introduced ktime_get_ts64
  53 #
  54 AC_DEFUN([LIBCFS_SRC_KTIME_GET_TS64], [
  55         LB2_LINUX_TEST_SRC([ktime_get_ts64], [
  56                 #include <linux/hrtimer.h>
  57                 #include <linux/ktime.h>
  58         ],[
  59                 struct timespec64 *ts = NULL;
  60
  61                 ktime_get_ts64(ts);
  62         ])
  63 ])
  64 AC_DEFUN([LIBCFS_KTIME_GET_TS64], [
  65         AC_MSG_CHECKING([does function 'ktime_get_ts64' exist])
  66         LB2_LINUX_TEST_RESULT([ktime_get_ts64], [
  67                 AC_DEFINE(HAVE_KTIME_GET_TS64, 1,
  68                         ['ktime_get_ts64' is available])
  69         ])
  70 ]) # LIBCFS_KTIME_GET_TS64
  71
  72 #
  73 # Kernel version 3.12-rc4 commit c2d816443ef30 added prepare_to_wait_event()
  74 #
  75 AC_DEFUN([LIBCFS_SRC_PREPARE_TO_WAIT_EVENT],[
  76         LB2_LINUX_TEST_SRC([prepare_to_wait_event], [
  77                 #include <linux/wait.h>
  78         ],[
  79                 prepare_to_wait_event(NULL, NULL, 0);
  80         ])
  81 ])
  82 AC_DEFUN([LIBCFS_PREPARE_TO_WAIT_EVENT],[
  83         AC_MSG_CHECKING([does function 'prepare_to_wait_event' exist])
  84         LB2_LINUX_TEST_RESULT([prepare_to_wait_event], [
  85                 AC_DEFINE(HAVE_PREPARE_TO_WAIT_EVENT, 1,
  86                         ['prepare_to_wait_event' is available])
  87         ])
  88 ]) # LIBCFS_PREPARE_TO_WAIT_EVENT
  89
  90 #
  91 # Linux kernel 3.12 introduced struct kernel_param_ops
  92 # This has been backported to all lustre supported
  93 # clients except RHEL6. We have to handle the differences.
  94 #
  95 AC_DEFUN([LIBCFS_SRC_KERNEL_PARAM_OPS],[
  96         LB2_LINUX_TEST_SRC([kernel_param_ops], [
  97                 #include <linux/module.h>
  98         ],[
  99                 struct kernel_param_ops ops;
 100
 101                 ops.set = NULL;
 102         ])
 103 ])
 104 AC_DEFUN([LIBCFS_KERNEL_PARAM_OPS],[
 105         AC_MSG_CHECKING([does 'struct kernel_param_ops' exist])
 106         LB2_LINUX_TEST_RESULT([kernel_param_ops], [
 107                 AC_DEFINE(HAVE_KERNEL_PARAM_OPS, 1,
 108                         ['struct kernel_param_ops' is available])
 109         ])
 110 ]) # LIBCFS_KERNEL_PARAM_OPS
 111
 112 #
 113 # Kernel version 3.12 introduced ktime_add
 114 #
 115 AC_DEFUN([LIBCFS_SRC_KTIME_ADD],[
 116         LB2_LINUX_TEST_SRC([ktime_add], [
 117                 #include <linux/hrtimer.h>
 118                 #include <linux/ktime.h>
 119         ],[
 120                 ktime_t start = ktime_set(0, 0);
 121                 ktime_t end = start;
 122                 ktime_t total;
 123
 124                 total = ktime_add(start, end);
 125         ])
 126 ])
 127 AC_DEFUN([LIBCFS_KTIME_ADD],[
 128         AC_MSG_CHECKING([does function 'ktime_add' exist])
 129         LB2_LINUX_TEST_RESULT([ktime_add], [
 130                 AC_DEFINE(HAVE_KTIME_ADD, 1, [ktime_add is available])
 131         ])
 132 ]) # LIBCFS_KTIME_ADD
 133
 134 #
 135 # Kernel version 3.12 introduced ktime_after
 136 #
 137 AC_DEFUN([LIBCFS_SRC_KTIME_AFTER],[
 138         LB2_LINUX_TEST_SRC([ktime_after], [
 139                 #include <linux/hrtimer.h>
 140                 #include <linux/ktime.h>
 141         ],[
 142                 ktime_t start = ktime_set(0, 0);
 143                 ktime_t end = start;
 144
 145                 ktime_after(start, end);
 146         ])
 147 ])
 148 AC_DEFUN([LIBCFS_KTIME_AFTER],[
 149         AC_MSG_CHECKING([does function 'ktime_after' exist])
 150         LB2_LINUX_TEST_RESULT([ktime_after], [
 151                 AC_DEFINE(HAVE_KTIME_AFTER, 1, [ktime_after is available])
 152         ])
 153 ]) # LIBCFS_KTIME_AFTER
 154
 155 #
 156 # Kernel version 3.12 introduced ktime_before
 157 # See linux commit 67cb9366ff5f99868100198efba5ca88aaa6ad25
 158 #
 159 AC_DEFUN([LIBCFS_SRC_KTIME_BEFORE],[
 160         LB2_LINUX_TEST_SRC([ktime_before], [
 161                 #include <linux/hrtimer.h>
 162                 #include <linux/ktime.h>
 163         ],[
 164                 ktime_t start = ktime_set(0, 0);
 165                 ktime_t end = start;
 166
 167                 ktime_before(start, end);
 168         ])
 169 ])
 170 AC_DEFUN([LIBCFS_KTIME_BEFORE],[
 171         AC_MSG_CHECKING([does function 'ktime_before' exist])
 172         LB2_LINUX_TEST_RESULT([ktime_before], [
 173                 AC_DEFINE(HAVE_KTIME_BEFORE, 1, [ktime_before is available])
 174         ])
 175 ]) # LIBCFS_KTIME_BEFORE
 176
 177 #
 178 # Kernel version 3.12 introduced ktime_compare
 179 #
 180 AC_DEFUN([LIBCFS_SRC_KTIME_COMPARE],[
 181         LB2_LINUX_TEST_SRC([ktime_compare], [
 182                 #include <linux/hrtimer.h>
 183                 #include <linux/ktime.h>
 184         ],[
 185                 ktime_t start = ktime_set(0, 0);
 186                 ktime_t end = start;
 187
 188                 ktime_compare(start, end);
 189         ])
 190 ])
 191 AC_DEFUN([LIBCFS_KTIME_COMPARE],[
 192         AC_MSG_CHECKING([does function 'ktime_compare' exist])
 193         LB2_LINUX_TEST_RESULT([ktime_compare], [
 194                 AC_DEFINE(HAVE_KTIME_COMPARE, 1,
 195                         [ktime_compare is available])
 196         ])
 197 ]) # LIBCFS_KTIME_COMPARE
 198
 199 #
 200 # FC19 3.12 kernel struct shrinker change
 201 #
 202 AC_DEFUN([LIBCFS_SRC_SHRINKER_COUNT],[
 203         LB2_LINUX_TEST_SRC([shrinker_count_objects], [
 204                 #include <linux/mmzone.h>
 205                 #include <linux/shrinker.h>
 206         ],[
 207                 struct shrinker shrinker;
 208
 209                 shrinker.count_objects = NULL;
 210         ])
 211 ])
 212 AC_DEFUN([LIBCFS_SHRINKER_COUNT],[
 213         AC_MSG_CHECKING([shrinker has 'count_objects'])
 214         LB2_LINUX_TEST_RESULT([shrinker_count_objects], [
 215                 AC_DEFINE(HAVE_SHRINKER_COUNT, 1,
 216                         [shrinker has count_objects member])
 217         ])
 218 ]) # LIBCFS_SHRINKER_COUNT
 219
 220 #
 221 # Kernel version 3.13 commit aace05097a0fd467230e39acb148be0fdaa90068
 222 # add match_wildcard() function.
 223 #
 224 AC_DEFUN([LIBCFS_SRC_MATCH_WILDCARD],[
 225         LB2_LINUX_TEST_SRC([match_wildcard], [
 226                 #include <linux/parser.h>
 227         ],[
 228                 bool match;
 229
 230                 match = match_wildcard(NULL, NULL);
 231         ])
 232 ])
 233 AC_DEFUN([LIBCFS_MATCH_WILDCARD],[
 234         AC_MSG_CHECKING([does function 'match_wildcard' exist])
 235         LB2_LINUX_TEST_RESULT([match_wildcard], [
 236                 AC_DEFINE(HAVE_MATCH_WILDCARD, 1,
 237                         [match_wildcard() is available])
 238         ])
 239 ]) # LIBCFS_MATCH_WILDCARD
 240
 241 #
 242 # LIBCFS_HAVE_MAPPING_AS_EXITING_FLAG
 243 #
 244 # v3.14-7405-g91b0abe36a7b added AS_EXITING flag with
 245 # mapping_exiting() and mapping_set_exiting()
 246 #
 247 AC_DEFUN([LIBCFS_SRC_HAVE_MAPPING_AS_EXITING_FLAG], [
 248 m4_pattern_allow([AS_EXITING])
 249         LB2_LINUX_TEST_SRC([mapping_exiting_exists], [
 250                 #include <linux/pagemap.h>
 251         ],[
 252                 enum mapping_flags flag = AS_EXITING;
 253                 (void)flag;
 254         ],[-Werror])
 255 ])
 256 AC_DEFUN([LIBCFS_HAVE_MAPPING_AS_EXITING_FLAG], [
 257         AC_MSG_CHECKING([if enum mapping_flags has AS_EXITING flag])
 258         LB2_LINUX_TEST_RESULT([mapping_exiting_exists], [
 259                 AC_DEFINE(HAVE_MAPPING_AS_EXITING_FLAG, 1,
 260                         [enum mapping_flags has AS_EXITING flag])
 261         ])
 262 ]) # LIBCFS_HAVE_MAPPING_AS_EXITING_FLAG
 263
 264 #
 265 # LIBCFS_IOV_ITER_HAS_TYPE
 266 #
 267 # kernel 3.15-rc4 commit 71d8e532b1549a478e6a6a8a44f309d050294d00
 268 # start adding the tag to iov_iter
 269 #
 270 AC_DEFUN([LIBCFS_SRC_IOV_ITER_HAS_TYPE], [
 271         LB2_LINUX_TEST_SRC([iov_iter_has_type_member], [
 272                 #include <linux/uio.h>
 273         ],[
 274                 struct iov_iter iter = { .type = ITER_KVEC };
 275                 (void)iter;
 276         ],
 277         [-Werror])
 278 ])
 279 AC_DEFUN([LIBCFS_IOV_ITER_HAS_TYPE], [
 280         AC_MSG_CHECKING([if iov_iter has member type])
 281         LB2_LINUX_TEST_RESULT([iov_iter_has_type_member], [
 282                 AC_DEFINE(HAVE_IOV_ITER_HAS_TYPE_MEMBER, 1,
 283                         [if iov_iter has member type])
 284         ])
 285 ]) # LIBCFS_IOV_ITER_HAS_TYPE
 286
 287 #
 288 # LIBCFS_HAVE_NS_TO_TIMESPEC64
 289 #
 290 # Kernel version 3.16-rc3 commit a84d1169164b274f13b97a23ff235c000efe3b49
 291 # introduced struct __kernel_old_timeval
 292 #
 293 AC_DEFUN([LIBCFS_SRC_HAVE_NS_TO_TIMESPEC64],[
 294         LB2_LINUX_TEST_SRC([kernel_old_timeval], [
 295                 #include <linux/time.h>
 296         ],[
 297                 struct timespec64 kts;
 298
 299                 kts = ns_to_timespec64(0);
 300         ])
 301 ])
 302 AC_DEFUN([LIBCFS_HAVE_NS_TO_TIMESPEC64],[
 303         AC_MSG_CHECKING([does 'ns_to_timespec64()' exist])
 304         LB2_LINUX_TEST_RESULT([kernel_old_timeval], [
 305                 AC_DEFINE(HAVE_NS_TO_TIMESPEC64, 1,
 306                         [ns_to_timespec64() is available])
 307         ])
 308 ]) # LIBCFS_HAVE_NS_TO_TIMESPEC64
 309
 310 #
 311 # LIBCFS_HAVE_GLOB
 312 #
 313 # Kernel version 3.16 commit b01250856b25f4417c51aa33afc451fbf7da1484
 314 # added glob support to the Linux kernel
 315 #
 316 AC_DEFUN([LIBCFS_SRC_HAVE_GLOB],[
 317         LB2_LINUX_TEST_SRC([glob_match], [
 318                 #include <linux/glob.h>
 319         ],[
 320                 return glob_match(NULL, NULL);
 321         ],[-Werror])
 322 ])
 323 AC_DEFUN([LIBCFS_HAVE_GLOB],[
 324         AC_MSG_CHECKING([does 'glob_match()' exist])
 325         LB2_LINUX_TEST_RESULT([glob_match], [
 326                 AC_DEFINE(HAVE_GLOB, 1,
 327                         [glob_match() is available])
 328         ])
 329 ]) # LIBCFS_HAVE_GLOB
 330
 331 #
 332 # Kernel version 3.17 changed hlist_add_after to
 333 # hlist_add_behind
 334 #
 335 AC_DEFUN([LIBCFS_SRC_HLIST_ADD_AFTER],[
 336         LB2_LINUX_TEST_SRC([hlist_add_after], [
 337                 #include <linux/list.h>
 338         ],[
 339                 hlist_add_after(NULL, NULL);
 340         ])
 341 ])
 342 AC_DEFUN([LIBCFS_HLIST_ADD_AFTER],[
 343         AC_MSG_CHECKING([does function 'hlist_add_after' exist])
 344         LB2_LINUX_TEST_RESULT([hlist_add_after], [
 345                 AC_DEFINE(HAVE_HLIST_ADD_AFTER, 1,
 346                         [hlist_add_after is available])
 347         ])
 348 ]) # LIBCFS_HLIST_ADD_AFTER
 349
 350 #
 351 # Kernel version 3.17 introduced struct timespec64
 352 #
 353 AC_DEFUN([LIBCFS_SRC_TIMESPEC64],[
 354         LB2_LINUX_TEST_SRC([timespec64], [
 355                 #include <linux/time.h>
 356         ],[
 357                 struct timespec64 ts;
 358
 359                 ts.tv_sec = 0;
 360                 ts.tv_nsec = 0;
 361         ])
 362 ])
 363 AC_DEFUN([LIBCFS_TIMESPEC64],[
 364         AC_MSG_CHECKING([does 'struct timespec64' exist])
 365         LB2_LINUX_TEST_RESULT([timespec64], [
 366                 AC_DEFINE(HAVE_TIMESPEC64, 1,
 367                         ['struct timespec64' is available])
 368         ])
 369 ]) # LIBCFS_TIMESPEC64
 370
 371 #
 372 # Kernel version 3.17 introduced ktime_get_real_ts64
 373 #
 374 AC_DEFUN([LIBCFS_SRC_KTIME_GET_REAL_TS64],[
 375         LB2_LINUX_TEST_SRC([ktime_get_real_ts64], [
 376                 #include <linux/ktime.h>
 377         ],[
 378                 struct timespec64 *ts = NULL;
 379
 380                 ktime_get_real_ts64(ts);
 381         ])
 382 ])
 383 AC_DEFUN([LIBCFS_KTIME_GET_REAL_TS64],[
 384         AC_MSG_CHECKING([does function 'ktime_get_real_ts64' exist])
 385         LB2_LINUX_TEST_RESULT([ktime_get_real_ts64], [
 386                 AC_DEFINE(HAVE_KTIME_GET_REAL_TS64, 1,
 387                         ['ktime_get_real_ts64' is available])
 388         ])
 389 ]) # LIBCFS_KTIME_GET_REAL_TS64
 390
 391 #
 392 # Kernel version 3.17 introduced ktime_get_real_seconds
 393 #
 394 AC_DEFUN([LIBCFS_SRC_KTIME_GET_REAL_SECONDS],[
 395         LB2_LINUX_TEST_SRC([ktime_get_real_seconds], [
 396                 #include <linux/hrtimer.h>
 397                 #include <linux/ktime.h>
 398         ],[
 399                 time64_t now;
 400
 401                 now = ktime_get_real_seconds();
 402         ])
 403 ])
 404 AC_DEFUN([LIBCFS_KTIME_GET_REAL_SECONDS],[
 405         AC_MSG_CHECKING([does function 'ktime_get_real_ts64' exist])
 406         LB2_LINUX_TEST_RESULT([ktime_get_real_seconds], [
 407                 AC_DEFINE(HAVE_KTIME_GET_REAL_SECONDS, 1,
 408                         ['ktime_get_real_seconds' is available])
 409         ])
 410 ]) # LIBCFS_KTIME_GET_REAL_SECONDS
 411
 412 #
 413 # Kernel version 3.17 created ktime_get_ns wrapper
 414 #
 415 AC_DEFUN([LIBCFS_SRC_KTIME_GET_NS],[
 416         LB2_LINUX_TEST_SRC([ktime_get_ns], [
 417                 #include <linux/hrtimer.h>
 418                 #include <linux/ktime.h>
 419         ],[
 420                 u64 nanoseconds;
 421
 422                 nanoseconds = ktime_get_ns();
 423         ])
 424 ])
 425 AC_DEFUN([LIBCFS_KTIME_GET_NS],[
 426         AC_MSG_CHECKING([does function 'ktime_get_ns' exist])
 427         LB2_LINUX_TEST_RESULT([ktime_get_ns], [],[
 428                 AC_DEFINE(NEED_KTIME_GET_NS, 1,
 429                         ['ktime_get_ns' is not available])
 430         ])
 431 ]) # LIBCFS_KTIME_GET_NS
 432
 433 #
 434 # Kernel version 3.17 created ktime_get_real_ns wrapper
 435 #
 436 AC_DEFUN([LIBCFS_SRC_KTIME_GET_REAL_NS],[
 437         LB2_LINUX_TEST_SRC([ktime_get_real_ns], [
 438                 #include <linux/hrtimer.h>
 439                 #include <linux/ktime.h>
 440         ],[
 441                 u64 nanoseconds;
 442
 443                 nanoseconds = ktime_get_real_ns();
 444         ])
 445 ])
 446 AC_DEFUN([LIBCFS_KTIME_GET_REAL_NS],[
 447         AC_MSG_CHECKING([does function 'ktime_get_real_ns' exist])
 448         LB2_LINUX_TEST_RESULT([ktime_get_real_ns], [],[
 449                 AC_DEFINE(NEED_KTIME_GET_REAL_NS, 1,
 450                         ['ktime_get_real_ns' is not available])
 451         ])
 452 ]) # LIBCFS_KTIME_GET_REAL_NS
 453
 454 #
 455 # Kernel version 3.17 introduced ktime_to_timespec64
 456 #
 457 AC_DEFUN([LIBCFS_SRC_KTIME_TO_TIMESPEC64],[
 458         LB2_LINUX_TEST_SRC([ktime_to_timespec64], [
 459                 #include <linux/hrtimer.h>
 460                 #include <linux/ktime.h>
 461         ],[
 462                 ktime_t now = ktime_set(0, 0);
 463                 struct timespec64 ts;
 464
 465                 ts = ktime_to_timespec64(now);
 466         ])
 467 ])
 468 AC_DEFUN([LIBCFS_KTIME_TO_TIMESPEC64],[
 469         AC_MSG_CHECKING([does function 'ktime_to_timespec64' exist])
 470         LB2_LINUX_TEST_RESULT([ktime_to_timespec64], [
 471                 AC_DEFINE(HAVE_KTIME_TO_TIMESPEC64, 1,
 472                         ['ktime_to_timespec64' is available])
 473         ])
 474 ]) # LIBCFS_KTIME_TO_TIMESPEC64
 475
 476 #
 477 # Kernel version 3.17 introduced timespec64_sub
 478 #
 479 AC_DEFUN([LIBCFS_SRC_TIMESPEC64_SUB],[
 480         LB2_LINUX_TEST_SRC([timespec64_sub], [
 481                 #include <linux/time.h>
 482         ],[
 483                 struct timespec64 later = { }, earlier = { }, diff;
 484
 485                 diff = timespec64_sub(later, earlier);
 486         ])
 487 ])
 488 AC_DEFUN([LIBCFS_TIMESPEC64_SUB],[
 489         AC_MSG_CHECKING([does function 'timespec64_sub' exist])
 490         LB2_LINUX_TEST_RESULT([timespec64_sub], [
 491                 AC_DEFINE(HAVE_TIMESPEC64_SUB, 1,
 492                         ['timespec64_sub' is available])
 493         ])
 494 ]) # LIBCFS_TIMESPEC64_SUB
 495
 496 #
 497 # Kernel version 3.17 introduced timespec64_to_ktime
 498 #
 499 AC_DEFUN([LIBCFS_SRC_TIMESPEC64_TO_KTIME],[
 500         LB2_LINUX_TEST_SRC([timespec64_to_ktime], [
 501         #include <linux/ktime.h>
 502         ],[
 503                 struct timespec64 ts;
 504                 ktime_t now;
 505
 506                 now = timespec64_to_ktime(ts);
 507         ])
 508 ])
 509 AC_DEFUN([LIBCFS_TIMESPEC64_TO_KTIME],[
 510         AC_MSG_CHECKING([does function 'timespec64_to_ktime' exist])
 511         LB2_LINUX_TEST_RESULT([timespec64_to_ktime], [
 512                 AC_DEFINE(HAVE_TIMESPEC64_TO_KTIME, 1,
 513                         ['timespec64_to_ktime' is available])
 514         ])
 515 ]) # LIBCFS_TIMESPEC64_TO_KTIME
 516
 517 #
 518 # Kernel version 3.19 introduced ktime_get_seconds
 519 #
 520 AC_DEFUN([LIBCFS_SRC_KTIME_GET_SECONDS],[
 521         LB2_LINUX_TEST_SRC([ktime_get_seconds], [
 522                 #include <linux/ktime.h>
 523         ],[
 524                 time64_t now;
 525
 526                 now = ktime_get_seconds();
 527         ])
 528 ])
 529 AC_DEFUN([LIBCFS_KTIME_GET_SECONDS],[
 530         AC_MSG_CHECKING([does function 'ktime_get_seconds' exist])
 531         LB2_LINUX_TEST_RESULT([ktime_get_seconds], [
 532                 AC_DEFINE(HAVE_KTIME_GET_SECONDS, 1,
 533                         ['ktime_get_seconds' is available])
 534         ])
 535 ]) # LIBCFS_KTIME_GET_SECONDS
 536
 537 #
 538 # Kernel version 3.19 commit v3.18-rc2-26-g61ada528dea0
 539 # introduce wait_woken()
 540 #
 541 AC_DEFUN([LIBCFS_SRC_WAIT_WOKEN],[
 542         LB2_LINUX_TEST_SRC([wait_woken], [
 543                 #include <linux/wait.h>
 544         ],[
 545                 wait_woken(NULL, 0, 0);
 546         ])
 547 ])
 548 AC_DEFUN([LIBCFS_WAIT_WOKEN],[
 549         AC_MSG_CHECKING([does function 'wait_woken' exist])
 550         LB2_LINUX_TEST_RESULT([wait_woken], [
 551                 AC_DEFINE(HAVE_WAIT_WOKEN, 1,
 552                         ['wait_woken, is available'])
 553         ])
 554 ]) # LIBCFS_WAIT_WOKEN
 555
 556 #
 557 # Kernel version 4.0 commit 41fbf3b39d5eca01527338b4d0ee15ee1ae1023c
 558 # introduced the helper function ktime_ms_delta.
 559 #
 560 AC_DEFUN([LIBCFS_SRC_KTIME_MS_DELTA],[
 561         LB2_LINUX_TEST_SRC([ktime_ms_delta], [
 562                 #include <linux/ktime.h>
 563         ],[
 564                 ktime_t start = ktime_set(0, 0);
 565                 ktime_t end = start;
 566
 567                 ktime_ms_delta(start, end);
 568         ])
 569 ])
 570 AC_DEFUN([LIBCFS_KTIME_MS_DELTA],[
 571         AC_MSG_CHECKING([does function 'ktime_ms_delta' exist])
 572         LB2_LINUX_TEST_RESULT([ktime_ms_delta], [
 573                 AC_DEFINE(HAVE_KTIME_MS_DELTA, 1,
 574                         ['ktime_ms_delta' is available])
 575         ])
 576 ]) # LIBCFS_KTIME_MS_DELTA
 577
 578 #
 579 # Kernel version 4.1 commit b51d23e4e9fea6f264d39535c2a62d1f51e7ccc3
 580 # create per module locks which added kernel_param_[un]lock(). Older
 581 # kernels you have to use __kernel_param_[un]lock(). In that case its
 582 # a global lock for all modules but that is okay since its a rare event.
 583 #
 584 AC_DEFUN([LIBCFS_SRC_KERNEL_PARAM_LOCK],[
 585         LB2_LINUX_TEST_SRC([kernel_param_lock], [
 586                 #include <linux/moduleparam.h>
 587         ],[
 588                 kernel_param_lock(NULL);
 589                 kernel_param_unlock(NULL);
 590         ])
 591 ])
 592 AC_DEFUN([LIBCFS_KERNEL_PARAM_LOCK],[
 593         AC_MSG_CHECKING([does function 'kernel_param_[un]lock' exist])
 594         LB2_LINUX_TEST_RESULT([kernel_param_lock], [
 595                 AC_DEFINE(HAVE_KERNEL_PARAM_LOCK, 1,
 596                         ['kernel_param_[un]lock' is available])
 597         ])
 598 ]) # LIBCFS_KERNEL_PARAM_LOCK
 599
 600 #
 601 # Kernel version 4.2 changed topology_thread_cpumask
 602 # to topology_sibling_cpumask
 603 #
 604 AC_DEFUN([LIBCFS_SRC_HAVE_TOPOLOGY_SIBLING_CPUMASK],[
 605         LB2_LINUX_TEST_SRC([topology_sibling_cpumask], [
 606                 #include <linux/topology.h>
 607         ],[
 608                 const struct cpumask *mask;
 609
 610                 mask = topology_sibling_cpumask(0);
 611         ])
 612 ])
 613 AC_DEFUN([LIBCFS_HAVE_TOPOLOGY_SIBLING_CPUMASK],[
 614         AC_MSG_CHECKING([does function 'topology_sibling_cpumask' exist])
 615         LB2_LINUX_TEST_RESULT([topology_sibling_cpumask], [
 616                 AC_DEFINE(HAVE_TOPOLOGY_SIBLING_CPUMASK, 1,
 617                         [topology_sibling_cpumask is available])
 618         ])
 619 ]) # LIBCFS_HAVE_TOPOLOGY_SIBLING_CPUMASK
 620
 621 #
 622 # Kernel version 4.4 commit ef951599074ba4fad2d0efa0a977129b41e6d203
 623 # introduced kstrtobool and kstrtobool_from_user.
 624 #
 625 AC_DEFUN([LIBCFS_SRC_KSTRTOBOOL_FROM_USER], [
 626         LB2_LINUX_TEST_SRC([kstrtobool_from_user], [
 627                 #include <linux/kernel.h>
 628         ],[
 629                 bool result;
 630                 return kstrtobool_from_user(NULL, 0, &result);
 631         ])
 632 ])
 633 AC_DEFUN([LIBCFS_KSTRTOBOOL_FROM_USER], [
 634         AC_MSG_CHECKING([if Linux kernel has 'kstrtobool_from_user'])
 635         LB2_LINUX_TEST_RESULT([kstrtobool_from_user], [
 636                 AC_DEFINE(HAVE_KSTRTOBOOL_FROM_USER, 1,
 637                         [kernel has kstrtobool_from_user])
 638         ])
 639 ]) # LIBCFS_KSTRTOBOOL_FROM_USER
 640
 641 #
 642 # LIBCFS_NETLINK_CALLBACK_START
 643 #
 644 # Kernel version 4.4-rc3 commit fc9e50f5a5a4e1fa9ba2756f745a13e693cf6a06
 645 # added a start function callback for struct netlink_callback
 646 #
 647 AC_DEFUN([LIBCFS_SRC_NETLINK_CALLBACK_START], [
 648         LB2_LINUX_TEST_SRC([cb_start], [
 649                 #include <net/genetlink.h>
 650         ],[
 651                 struct genl_ops ops;
 652
 653                 ops.start = NULL;
 654         ],[])
 655 ])
 656 AC_DEFUN([LIBCFS_NETLINK_CALLBACK_START], [
 657         AC_MSG_CHECKING([if struct genl_ops has start callback])
 658         LB2_LINUX_TEST_RESULT([cb_start], [
 659                 AC_DEFINE(HAVE_NETLINK_CALLBACK_START, 1,
 660                         [struct genl_ops has 'start' callback])
 661         ])
 662 ]) # LIBCFS_NETLINK_CALLBACK_START
 663
 664 #
 665 # Kernel version 4.5-rc1 commit d12481bc58fba89427565f8592e88446ec084a24
 666 # added crypto hash helpers
 667 #
 668 AC_DEFUN([LIBCFS_SRC_CRYPTO_HASH_HELPERS], [
 669         LB2_LINUX_TEST_SRC([crypto_hash_helpers], [
 670                 #include <crypto/hash.h>
 671         ],[
 672                 crypto_ahash_alg_name(NULL);
 673                 crypto_ahash_driver_name(NULL);
 674         ])
 675 ])
 676 AC_DEFUN([LIBCFS_CRYPTO_HASH_HELPERS], [
 677         AC_MSG_CHECKING([does crypto hash helper functions exist])
 678         LB2_LINUX_TEST_RESULT([crypto_hash_helpers], [
 679                 AC_DEFINE(HAVE_CRYPTO_HASH_HELPERS, 1,
 680                         [crypto hash helper functions are available])
 681         ])
 682 ]) # LIBCFS_CRYPTO_HASH_HELPERS
 683
 684 #
 685 # Kernel version 4.5-rc1 commit 3502cad73c4bbf8f6365d539e814159275252c59
 686 # introduced rhashtable_replace_fast
 687 #
 688 AC_DEFUN([LIBCFS_SRC_RHASHTABLE_REPLACE], [
 689         LB2_LINUX_TEST_SRC([rhashtable_replace_fast], [
 690                 #include <linux/rhashtable.h>
 691         ],[
 692                 const struct rhashtable_params params = { 0 };
 693
 694                 rhashtable_replace_fast(NULL, NULL, NULL, params);
 695         ])
 696 ])
 697 AC_DEFUN([LIBCFS_RHASHTABLE_REPLACE], [
 698         AC_MSG_CHECKING([if 'rhashtable_replace_fast' exists])
 699         LB2_LINUX_TEST_RESULT([rhashtable_replace_fast], [
 700                 AC_DEFINE(HAVE_RHASHTABLE_REPLACE, 1,
 701                         [rhashtable_replace_fast() is available])
 702         ])
 703 ]) # LIBCFS_RHASHTABLE_REPLACE
 704
 705 #
 706 # Kernel version 4.5-rc3 commit 2fe829aca9d7bed5fd6b49c6a1452e5e486b6cc3dd
 707 # made kset_find_obj() exportable to modules
 708 #
 709 AC_DEFUN([LIBCFS_EXPORT_KSET_FIND_OBJ], [
 710 LB_CHECK_EXPORT([kset_find_obj], [lib/kobject.c],
 711         [AC_DEFINE(HAVE_KSET_FIND_OBJ, 1,
 712                 [kset_find_obj is exported by the kernel])])
 713 ]) # LIBCFS_EXPORT_KSET_FIND_OBJ
 714
 715 #
 716 # Kernel version 4.6+ commit ef703f49a6c5b909a85149bb6625c4ed0d697186
 717 # fixed the brokenness of hash_64(). The fix removed GOLDEN_RATIO_PRIME_64
 718 # since it was a poor prime value.
 719 #
 720 AC_DEFUN([LIBCFS_SRC_BROKEN_HASH_64], [
 721         LB2_LINUX_TEST_SRC([broken_hash_64], [
 722         #include <linux/hash.h>
 723         ],[
 724                 int tmp = GOLDEN_RATIO_PRIME_64;
 725         ])
 726 ])
 727 AC_DEFUN([LIBCFS_BROKEN_HASH_64], [
 728         AC_MSG_CHECKING([kernel has fixed hash_64()])
 729         LB2_LINUX_TEST_RESULT([broken_hash_64], [
 730                 AC_DEFINE(HAVE_BROKEN_HASH_64, 1, [kernel hash_64() is broken])
 731         ])
 732 ]) # LIBCFS_BROKEN_HASH_64
 733
 734 #
 735 # LIBCFS_STACKTRACE_OPS_ADDRESS_RETURN_INT
 736 #
 737 # linux 4.6 kernel changed stacktrace_ops address to return an int
 738 #
 739 AC_DEFUN([LIBCFS_SRC_STACKTRACE_OPS_ADDRESS_RETURN_INT], [
 740         LB2_LINUX_TEST_SRC([stacktrace_ops_address_return_int], [
 741                 #include <asm/stacktrace.h>
 742         ],[
 743                 int rc;
 744
 745                 rc = ((struct stacktrace_ops *)0)->address(NULL, 0, 0);
 746         ])
 747 ])
 748 AC_DEFUN([LIBCFS_STACKTRACE_OPS_ADDRESS_RETURN_INT], [
 749         AC_MSG_CHECKING([if 'struct stacktrace_ops' address function returns an int])
 750         LB2_LINUX_TEST_RESULT([stacktrace_ops_address_return_int], [
 751                 AC_DEFINE(STACKTRACE_OPS_ADDRESS_RETURN_INT, 1,
 752                         ['struct stacktrace_ops' address function returns an int])
 753         ])
 754 ]) # LIBCFS_STACKTRACE_OPS_ADDRESS_RETURN_INT
 755
 756 #
 757 # Kernel version 4.6 removed both struct task_struct and struct mm_struct
 758 # arguments to get_user_pages
 759 #
 760 AC_DEFUN([LIBCFS_SRC_GET_USER_PAGES_6ARG], [
 761         LB2_LINUX_TEST_SRC([get_user_pages_6arg], [
 762                 #include <linux/mm.h>
 763         ],[
 764                 int rc;
 765
 766                 rc = get_user_pages(0, 0, 0, 0, NULL, NULL);
 767         ])
 768 ])
 769 AC_DEFUN([LIBCFS_GET_USER_PAGES_6ARG], [
 770         AC_MSG_CHECKING([if 'get_user_pages()' takes 6 arguments])
 771         LB2_LINUX_TEST_RESULT([get_user_pages_6arg], [
 772                 AC_DEFINE(HAVE_GET_USER_PAGES_6ARG, 1,
 773                         [get_user_pages takes 6 arguments])
 774         ])
 775 ]) # LIBCFS_GET_USER_PAGES_6ARG
 776
 777 #
 778 # LIBCFS_STRINGHASH
 779 #
 780 # 4.6 kernel created stringhash.h which moved stuff out of dcache.h
 781 # commit f4bcbe792b8f434e32487cff9d9e30ab45a3ce02
 782 #
 783 AC_DEFUN([LIBCFS_STRINGHASH], [
 784 LB_CHECK_LINUX_HEADER([linux/stringhash.h], [
 785         AC_DEFINE(HAVE_STRINGHASH, 1,
 786                 [stringhash.h is present])])
 787 ]) # LIBCFS_STRINGHASH
 788
 789 #
 790 # LIBCFS_RHASHTABLE_INSERT_FAST
 791 #
 792 # 4.7+ kernel commit 5ca8cc5bf11faed257c762018aea9106d529232f
 793 # changed __rhashtable_insert_fast to support the new function
 794 # rhashtable_lookup_get_insert_key().
 795 #
 796 AC_DEFUN([LIBCFS_SRC_RHASHTABLE_INSERT_FAST], [
 797         LB2_LINUX_TEST_SRC([rhashtable_insert_fast], [
 798                 #include <linux/rhashtable.h>
 799         ],[
 800                 const struct rhashtable_params params = { 0 };
 801                 int rc;
 802
 803                 rc = __rhashtable_insert_fast(NULL, NULL, NULL, params);
 804         ],
 805         [-Werror])
 806 ])
 807 AC_DEFUN([LIBCFS_RHASHTABLE_INSERT_FAST], [
 808         AC_MSG_CHECKING([if internal '__rhashtable_insert_fast()' returns int])
 809         LB2_LINUX_TEST_RESULT([rhashtable_insert_fast], [
 810                 AC_DEFINE(HAVE_HASHTABLE_INSERT_FAST_RETURN_INT, 1,
 811                           ['__rhashtable_insert_fast()' returns int])
 812         ])
 813 ]) # LIBCFS_RHASHTABLE_INSERT_FAST
 814
 815 #
 816 # Kernel version 4.7-rc1 commit 8f6fd83c6c5ec66a4a70c728535ddcdfef4f3697
 817 # added 3rd arg to rhashtable_walk_init
 818 #
 819 AC_DEFUN([LIBCFS_SRC_RHASHTABLE_WALK_INIT_3ARG], [
 820         LB2_LINUX_TEST_SRC([rhashtable_walk_init], [
 821                 #include <linux/gfp.h>
 822                 #include <linux/rhashtable.h>
 823         ],[
 824                 rhashtable_walk_init(NULL, NULL, GFP_KERNEL);
 825         ])
 826 ])
 827 AC_DEFUN([LIBCFS_RHASHTABLE_WALK_INIT_3ARG], [
 828         AC_MSG_CHECKING([if 'rhashtable_walk_init' has 3 args])
 829         LB2_LINUX_TEST_RESULT([rhashtable_walk_init], [
 830                 AC_DEFINE(HAVE_3ARG_RHASHTABLE_WALK_INIT, 1,
 831                         [rhashtable_walk_init() has 3 args])
 832         ])
 833 ]) # LIBCFS_RHASHTABLE_WALK_INIT_3ARG
 834
 835 #
 836 # Kernel version 4.8-rc6 commit ca26893f05e86497a86732768ec53cd38c0819ca
 837 # introduced rhashtable_lookup
 838 #
 839 AC_DEFUN([LIBCFS_SRC_RHASHTABLE_LOOKUP], [
 840         LB2_LINUX_TEST_SRC([rhashtable_lookup], [
 841                 #include <linux/rhashtable.h>
 842         ],[
 843                 const struct rhashtable_params params = { 0 };
 844                 void *ret;
 845
 846                 ret = rhashtable_lookup(NULL, NULL, params);
 847         ])
 848 ])
 849 AC_DEFUN([LIBCFS_RHASHTABLE_LOOKUP], [
 850         AC_MSG_CHECKING([if 'rhashtable_lookup' exist])
 851         LB2_LINUX_TEST_RESULT([rhashtable_lookup], [
 852                 AC_DEFINE(HAVE_RHASHTABLE_LOOKUP, 1,
 853                         [rhashtable_lookup() is available])
 854         ])
 855 ]) # LIBCFS_RHASHTABLE_LOOKUP
 856
 857 #
 858 # LIBCFS_RHLTABLE
 859 # Kernel version 4.8-rc6 commit ca26893f05e86497a86732768ec53cd38c0819ca
 860 # created the rhlist interface to allow inserting duplicate objects
 861 # into the same table.
 862 #
 863 AC_DEFUN([LIBCFS_SRC_RHLTABLE], [
 864         LB2_LINUX_TEST_SRC([rhtable], [
 865                 #include <linux/rhashtable.h>
 866         ],[
 867                 struct rhltable *hlt = NULL;
 868
 869                 rhltable_destroy(hlt);
 870         ])
 871 ])
 872 AC_DEFUN([LIBCFS_RHLTABLE], [
 873         AC_MSG_CHECKING([does 'struct rhltable' exist])
 874         LB2_LINUX_TEST_RESULT([rhtable], [
 875                 AC_DEFINE(HAVE_RHLTABLE, 1, [struct rhltable exist])
 876         ])
 877 ]) # LIBCFS_RHLTABLE
 878
 879 #
 880 # LIBCFS_STACKTRACE_OPS
 881 #
 882 # Kernel version 4.8 commit c8fe4609827aedc9c4b45de80e7cdc8ccfa8541b
 883 # removed both struct stacktrace_ops and dump_trace() function
 884 #
 885 AC_DEFUN([LIBCFS_SRC_STACKTRACE_OPS], [
 886         LB2_LINUX_TEST_SRC([stacktrace_ops], [
 887                 struct task_struct;
 888                 struct pt_regs;
 889                 #include <asm/stacktrace.h>
 890         ],[
 891                 struct stacktrace_ops ops;
 892                 ops.stack = NULL;
 893         ])
 894 ])
 895 AC_DEFUN([LIBCFS_STACKTRACE_OPS], [
 896 AC_MSG_CHECKING([if 'struct stacktrace_ops' exists])
 897         LB2_LINUX_TEST_RESULT([stacktrace_ops], [
 898                 AC_DEFINE(HAVE_STACKTRACE_OPS, 1,
 899                         [struct stacktrace_ops exists])
 900         ])
 901 ]) # LIBCFS_STACKTRACE_OPS
 902
 903 #
 904 # LIBCFS_RHASHTABLE_WALK_ENTER
 905 #
 906 # Kernel version 4.9-rc1 commit 246779dd090bd1b74d2652b3a6ca7759f593b27a
 907 # introduced rhashtable_walk_enter
 908 #
 909 AC_DEFUN([LIBCFS_SRC_RHASHTABLE_WALK_ENTER], [
 910         LB2_LINUX_TEST_SRC([rhashtable_walk_enter], [
 911                 #include <linux/rhashtable.h>
 912         ],[
 913                 rhashtable_walk_enter(NULL, NULL);
 914         ])
 915 ])
 916 AC_DEFUN([LIBCFS_RHASHTABLE_WALK_ENTER], [
 917         AC_MSG_CHECKING([if 'rhashtable_walk_enter' exists])
 918         LB2_LINUX_TEST_RESULT([rhashtable_walk_enter], [
 919                 AC_DEFINE(HAVE_RHASHTABLE_WALK_ENTER, 1,
 920                         [rhashtable_walk_enter() is available])
 921         ])
 922 ]) # LIBCFS_RHASHTABLE_WALK_ENTER
 923
 924 #
 925 # Kernel version 4.9 commit 768ae309a96103ed02eb1e111e838c87854d8b51
 926 # mm: replace get_user_pages() write/force parameters with gup_flags
 927 #
 928 AC_DEFUN([LIBCFS_SRC_GET_USER_PAGES_GUP_FLAGS], [
 929         LB2_LINUX_TEST_SRC([get_user_pages_gup_flags], [
 930                 #include <linux/mm.h>
 931         ],[
 932                 int rc;
 933                 rc = get_user_pages(0, 0, FOLL_WRITE, NULL, NULL);
 934         ])
 935 ])
 936 AC_DEFUN([LIBCFS_GET_USER_PAGES_GUP_FLAGS], [
 937         AC_MSG_CHECKING([if 'get_user_pages()' takes gup_flags in arguments])
 938         LB2_LINUX_TEST_RESULT([get_user_pages_gup_flags], [
 939                 AC_DEFINE(HAVE_GET_USER_PAGES_GUP_FLAGS, 1,
 940                         [get_user_pages takes gup_flags in arguments])
 941                 ])
 942 ]) # LIBCFS_GET_USER_PAGES_GUP_FLAGS
 943
 944 #
 945 # Kernel version 4.10 commit 7b737965b33188bd3dbb44e938535c4006d97fbb
 946 # libcfs: Convert to hotplug state machine
 947 #
 948 AC_DEFUN([LIBCFS_SRC_HOTPLUG_STATE_MACHINE], [
 949         LB2_LINUX_TEST_SRC([cpu_hotplug_state_machine], [
 950                 #include <linux/cpuhotplug.h>
 951         ],[
 952                 cpuhp_remove_state(CPUHP_LUSTRE_CFS_DEAD);
 953         ])
 954 ])
 955 AC_DEFUN([LIBCFS_HOTPLUG_STATE_MACHINE], [
 956         AC_MSG_CHECKING([if libcfs supports CPU hotplug state machine])
 957         LB2_LINUX_TEST_RESULT([cpu_hotplug_state_machine], [
 958                 AC_DEFINE(HAVE_HOTPLUG_STATE_MACHINE, 1,
 959                         [hotplug state machine is supported])
 960         ])
 961 ]) # LIBCFS_HOTPLUG_STATE_MACHINE
 962
 963 #
 964 # Kernel version 4.10-rc3 commit f405df5de3170c00e5c54f8b7cf4766044a032ba
 965 # introduced refcount_t which is atomic_t plus over flow guards.
 966 #
 967 AC_DEFUN([LIBCFS_REFCOUNT_T], [
 968 tmp_flags="$EXTRA_KCFLAGS"
 969 EXTRA_KCFLAGS="-Werror"
 970 LB_CHECK_LINUX_HEADER([linux/refcount.h], [
 971         AC_DEFINE(HAVE_REFCOUNT_T, 1,
 972                 [refcount_t is supported])
 973 ])
 974 EXTRA_KCFLAGS="$tmp_flags"
 975 ]) # LIBCFS_REFCOUNT_T
 976
 977 #
 978 # Kernel version 4.12 commit 499118e966f1d2150bd66647c8932343c4e9a0b8
 979 # introduce memalloc_noreclaim_{save,restore}
 980 #
 981 AC_DEFUN([LIBCFS_SRC_MEMALLOC_NORECLAIM], [
 982         LB2_LINUX_TEST_SRC([memalloc_noreclaim], [
 983                 #include <linux/sched/mm.h>
 984         ],[
 985                 int flag = memalloc_noreclaim_save();
 986                 memalloc_noreclaim_restore(flag);
 987         ])
 988 ])
 989 AC_DEFUN([LIBCFS_MEMALLOC_NORECLAIM], [
 990         AC_MSG_CHECKING([if memalloc_noreclaim_{save,restore} exist])
 991         LB2_LINUX_TEST_RESULT([memalloc_noreclaim], [
 992                 AC_DEFINE(HAVE_MEMALLOC_RECLAIM, 1,
 993                         [memalloc_noreclaim_{save,restore}() is supported])
 994         ])
 995 ]) # LIBCFS_MEMALLOC_NORECLAIM
 996
 997 #
 998 # LIBCFS_SCHED_HEADERS
 999 #
1000 # 4.11 has broken up sched.h into more headers.
1001 #
1002 AC_DEFUN([LIBCFS_SCHED_HEADERS], [
1003 LB_CHECK_LINUX_HEADER([linux/sched/signal.h], [
1004         AC_DEFINE(HAVE_SCHED_HEADERS, 1,
1005                 [linux/sched header directory exist])])
1006 ]) # LIBCFS_SCHED_HEADERS
1007
1008 #
1009 # Kernel version 4.11-rc1 commit 2c935bc57221cc2edc787c72ea0e2d30cdcd3d5e
1010 # introduce kref_read
1011 #
1012 AC_DEFUN([LIBCFS_SRC_KREF_READ], [
1013         LB2_LINUX_TEST_SRC([kref_read], [
1014                 #include <linux/kref.h>
1015         ],[
1016                 kref_read(NULL);
1017         ])
1018 ])
1019 AC_DEFUN([LIBCFS_KREF_READ], [
1020         AC_MSG_CHECKING([if 'kref_read' exists])
1021         LB2_LINUX_TEST_RESULT([kref_read], [
1022                 AC_DEFINE(HAVE_KREF_READ, 1, [kref_read() is available])
1023         ])
1024 ]) # LIBCFS_KREF_READ
1025
1026 #
1027 # Kernel version 4.11-rc1 commit da20420f83ea0fbcf3d03afda08d971ea1d8a356
1028 # introduced rht_bucket_var
1029 #
1030 AC_DEFUN([LIBCFS_SRC_RHT_BUCKET_VAR], [
1031         LB2_LINUX_TEST_SRC([rht_bucket_var], [
1032                 #include <linux/rhashtable.h>
1033         ],[
1034                 rht_bucket_var(NULL, 0);
1035         ])
1036 ])
1037 AC_DEFUN([LIBCFS_RHT_BUCKET_VAR], [
1038         AC_MSG_CHECKING([if 'rht_bucket_var' exists])
1039         LB2_LINUX_TEST_RESULT([rht_bucket_var], [
1040                 AC_DEFINE(HAVE_RHT_BUCKET_VAR, 1,
1041                         [rht_bucket_var() is available])
1042         ])
1043 ]) # LIBCFS_RHT_BUCKET_VAR
1044
1045 #
1046 # Kernel version 4.11-rc5 commit fceb6435e85298f747fee938415057af837f5a8a
1047 # began the enhanchement of Netlink with extended ACK struct for advanced
1048 # error handling. By commit 7ab606d1609dd6dfeae9c8ad0a8a4e051d831e46 we
1049 # had full support for this new feature.
1050 #
1051 AC_DEFUN([LIBCFS_SRC_NL_EXT_ACK], [
1052         LB2_LINUX_TEST_SRC([netlink_ext_ack], [
1053                 #include <net/genetlink.h>
1054         ],[
1055                 struct genl_info info;
1056
1057                 info.extack = NULL;
1058         ])
1059 ])
1060 AC_DEFUN([LIBCFS_NL_EXT_ACK], [
1061         AC_MSG_CHECKING([if Netlink supports netlink_ext_ack])
1062         LB2_LINUX_TEST_RESULT([netlink_ext_ack], [
1063                 AC_DEFINE(HAVE_NL_PARSE_WITH_EXT_ACK, 1,
1064                         [netlink_ext_ack is an argument to nla_parse type function])
1065         ])
1066 ]) # LIBCFS_NL_EXT_ACK
1067
1068 #
1069 # Kernel version 4.11 commit f9fe1c12d126f9887441fa5bb165046f30ddd4b5
1070 # introduced rhashtable_lookup_get_insert_fast
1071 #
1072 AC_DEFUN([LIBCFS_SRC_RHASHTABLE_LOOKUP_GET_INSERT_FAST], [
1073         LB2_LINUX_TEST_SRC([rhashtable_lookup_get_insert_fast], [
1074                 #include <linux/rhashtable.h>
1075         ],[
1076                 const struct rhashtable_params params = { 0 };
1077                 void *ret;
1078
1079                 ret = rhashtable_lookup_get_insert_fast(NULL, NULL, params);
1080         ])
1081 ])
1082 AC_DEFUN([LIBCFS_RHASHTABLE_LOOKUP_GET_INSERT_FAST], [
1083         AC_MSG_CHECKING([if 'rhashtable_lookup_get_insert_fast' exist])
1084         LB2_LINUX_TEST_RESULT([rhashtable_lookup_get_insert_fast], [
1085                 AC_DEFINE(HAVE_RHASHTABLE_LOOKUP_GET_INSERT_FAST, 1,
1086                         [rhashtable_lookup_get_insert_fast() is available])
1087         ])
1088 ]) # LIBCFS_RHASHTABLE_LOOKUP_GET_INSERT_FAST
1089
1090 #
1091 # Kernel version 4.12-rc2 8f553c498e1772cccb39a114da4a498d22992758
1092 # provide proper CPU hotplug locking
1093 #
1094 AC_DEFUN([LIBCFS_SRC_CPUS_READ_LOCK], [
1095         LB2_LINUX_TEST_SRC([cpu_read_lock], [
1096                 #include <linux/cpu.h>
1097         ],[
1098                 cpus_read_lock();
1099                 cpus_read_unlock();
1100         ])
1101 ])
1102 AC_DEFUN([LIBCFS_CPUS_READ_LOCK], [
1103         AC_MSG_CHECKING([if 'cpus_read_[un]lock' exist])
1104         LB2_LINUX_TEST_RESULT([cpu_read_lock], [
1105                 AC_DEFINE(HAVE_CPUS_READ_LOCK, 1, ['cpus_read_lock' exist])
1106         ])
1107 ]) # LIBCFS_CPUS_READ_LOCK
1108
1109 #
1110 # Kernel version 4.12-rc3 f9727a17db9bab71ddae91f74f11a8a2f9a0ece6
1111 # renamed uuid_be to uuid_t
1112 #
1113 AC_DEFUN([LIBCFS_SRC_UUID_T], [
1114         LB2_LINUX_TEST_SRC([uuid_t], [
1115                 #include <linux/uuid.h>
1116         ],[
1117                 uuid_t uuid;
1118
1119                 memset(uuid.b, 0, 16);
1120         ])
1121 ])
1122 AC_DEFUN([LIBCFS_UUID_T], [
1123         AC_MSG_CHECKING([if 'uuid_t' exist])
1124         LB2_LINUX_TEST_RESULT([uuid_t], [
1125                 AC_DEFINE(HAVE_UUID_T, 1, ['uuid_t' exist])
1126         ])
1127 ]) # LIBCFS_UUID_T
1128
1129 #
1130 # Kernel version 4.12-rc3 commit fd851a3cdc196bfc1d229b5f22369069af532bf8
1131 # introduce processor.h
1132 #
1133 AC_DEFUN([LIBCFS_HAVE_PROCESSOR_HEADER], [
1134 tmp_flags="$EXTRA_KCFLAGS"
1135 EXTRA_KCFLAGS="-Werror"
1136 LB_CHECK_LINUX_HEADER([linux/processor.h], [
1137         AC_DEFINE(HAVE_PROCESSOR_H, 1,
1138                 [processor.h is present])
1139 ])
1140 EXTRA_KCFLAGS="$tmp_flags"
1141 ]) # LIBCFS_HAVE_PROCESSOR_HEADER
1142
1143 #
1144 # Kernel verison 4.12-rc6 commit 5dd43ce2f69d42a71dcacdb13d17d8c0ac1fe8f7
1145 # created wait_bit.h
1146 #
1147 AC_DEFUN([LIBCFS_HAVE_WAIT_BIT_HEADER], [
1148 LB_CHECK_LINUX_HEADER([linux/wait_bit.h], [
1149         AC_DEFINE(HAVE_WAIT_BIT_HEADER_H, 1,
1150                 [wait_bit.h is present])])
1151 ]) # LIBCFS_HAVE_WAIT_BIT_HEADER
1152
1153 #
1154 # Kernel version 4.12-rc6 commmit 2055da97389a605c8a00d163d40903afbe413921
1155 # changed:
1156 #       struct wait_queue_head::task_list       => ::head
1157 #       struct wait_queue_entry::task_list      => ::entry
1158 #
1159 AC_DEFUN([LIBCFS_SRC_WAIT_QUEUE_TASK_LIST_RENAME], [
1160         LB2_LINUX_TEST_SRC([wait_queue_task_list], [
1161                 #include <linux/wait.h>
1162         ],[
1163                 wait_queue_head_t e;
1164
1165                 INIT_LIST_HEAD(&e.head);
1166         ])
1167 ])
1168 AC_DEFUN([LIBCFS_WAIT_QUEUE_TASK_LIST_RENAME], [
1169         AC_MSG_CHECKING([if linux wait_queue_head list_head is named head])
1170         LB2_LINUX_TEST_RESULT([wait_queue_task_list], [
1171                 AC_DEFINE(HAVE_WAIT_QUEUE_ENTRY_LIST, 1,
1172                         [linux wait_queue_head_t list_head is name head])
1173         ])
1174 ]) # LIBCFS_WAIT_QUEUE_TASK_LIST_RENAME
1175
1176 #
1177 # LIBCFS_WAIT_BIT_QUEUE_ENTRY_EXISTS
1178 #
1179 # Kernel version v4.12-rc6-23-g76c85ddc4695
1180 # sched/wait: Standardize wait_bit_queue naming
1181 #
1182 # renamed struct wait_bit_queue  => wait_bit_queue_entry
1183 #
1184 AC_DEFUN([LIBCFS_SRC_WAIT_BIT_QUEUE_ENTRY_EXISTS], [
1185         LB2_LINUX_TEST_SRC([struct_wait_bit_queue_entry_exists], [
1186                 #include <linux/wait.h>
1187                 #if HAVE_WAIT_BIT_HEADER_H
1188                         #include <linux/wait_bit.h>
1189                 #endif
1190         ],[
1191                 struct wait_bit_queue_entry entry;
1192                 memset(&entry, 0, sizeof(entry));
1193         ])
1194 ])
1195 AC_DEFUN([LIBCFS_WAIT_BIT_QUEUE_ENTRY_EXISTS], [
1196         AC_MSG_CHECKING([if struct wait_bit_queue_entry exists])
1197         LB2_LINUX_TEST_RESULT([struct_wait_bit_queue_entry_exists], [
1198                 AC_DEFINE(HAVE_WAIT_BIT_QUEUE_ENTRY, 1,
1199                         [if struct wait_bit_queue_entry exists])
1200         ])
1201 ]) # LIBCFS_WAIT_BIT_QUEUE_ENTRY_EXISTS
1202
1203 #
1204 # LIBCFS_NLA_STRDUP
1205 #
1206 # Kernel version 4.13-rc1 commit 2cf0c8b3e6942ecafe6ebb1a6d0328a81641bf39
1207 # created nla_strdup(). This is needed since push strings can be
1208 # any size.
1209 #
1210 AC_DEFUN([LIBCFS_SRC_NLA_STRDUP], [
1211         LB2_LINUX_TEST_SRC([nla_strdup], [
1212                 #include <net/netlink.h>
1213         ],[
1214                 char *tmp = nla_strdup(NULL, GFP_KERNEL);
1215                 (void)tmp;
1216         ],[])
1217 ])
1218 AC_DEFUN([LIBCFS_NLA_STRDUP], [
1219         AC_MSG_CHECKING([if 'nla_strdup()' exists])
1220         LB2_LINUX_TEST_RESULT([nla_strdup], [
1221                 AC_DEFINE(HAVE_NLA_STRDUP, 1,
1222                         ['nla_strdup' is available])
1223         ])
1224 ]) # LIBCFS_NLA_STRDUP
1225
1226 #
1227 # LIBCFS_WAIT_QUEUE_ENTRY
1228 #
1229 # Kernel version 4.13 ac6424b981bce1c4bc55675c6ce11bfe1bbfa64f
1230 # Rename wait_queue_t => wait_queue_entry_t
1231 #
1232 AC_DEFUN([LIBCFS_SRC_WAIT_QUEUE_ENTRY], [
1233         LB2_LINUX_TEST_SRC([wait_queue_entry], [
1234                 #include <linux/wait.h>
1235         ],[
1236                 wait_queue_entry_t e;
1237
1238                 e.flags = 0;
1239         ])
1240 ])
1241 AC_DEFUN([LIBCFS_WAIT_QUEUE_ENTRY], [
1242         AC_MSG_CHECKING([if 'wait_queue_entry_t' exists])
1243         LB2_LINUX_TEST_RESULT([wait_queue_entry], [
1244                 AC_DEFINE(HAVE_WAIT_QUEUE_ENTRY, 1,
1245                         ['wait_queue_entry_t' is available])
1246         ])
1247 ]) # LIBCFS_WAIT_QUEUE_ENTRY
1248
1249 #
1250 # LIBCFS_NEW_KERNEL_WRITE
1251 #
1252 # Kernel version 4.14 e13ec939e96b13e664bb6cee361cc976a0ee621a
1253 # changed kernel_write prototype to make is plug compatible
1254 # with the unexported vfs_write()
1255 #
1256 AC_DEFUN([LIBCFS_SRC_NEW_KERNEL_WRITE], [
1257         LB2_LINUX_TEST_SRC([kernel_write_match], [
1258                 #include <linux/fs.h>
1259         ],[
1260                 const void *buf = NULL;
1261                 loff_t pos = 0;
1262                 return kernel_write(NULL, buf, 0, &pos);
1263         ],[-Werror])
1264 ])
1265 AC_DEFUN([LIBCFS_NEW_KERNEL_WRITE], [
1266         AC_MSG_CHECKING([if 'kernel_write' matches other read/write helpers])
1267         LB2_LINUX_TEST_RESULT([kernel_write_match], [
1268                 AC_DEFINE(HAVE_NEW_KERNEL_WRITE, 1,
1269                         ['kernel_write' aligns with read/write helpers])
1270         ])
1271 ]) # LIBCFS_NEW_KERNEL_WRITE
1272
1273 #
1274 # LIBCFS_MM_TOTALRAM_PAGES_FUNC
1275 #
1276 # kernel 5.0 commit ca79b0c211af63fa3276f0e3fd7dd9ada2439839
1277 # mm: convert totalram_pages and totalhigh_pages variables to atomic
1278 #
1279 AC_DEFUN([LIBCFS_SRC_MM_TOTALRAM_PAGES_FUNC], [
1280         LB2_LINUX_TEST_SRC([totalram_pages], [
1281                 #include <linux/mm.h>
1282         ],[
1283                 totalram_pages_inc();
1284         ],[-Werror])
1285 ])
1286 AC_DEFUN([LIBCFS_MM_TOTALRAM_PAGES_FUNC], [
1287         AC_MSG_CHECKING([if totalram_pages is a function])
1288         LB2_LINUX_TEST_RESULT([totalram_pages], [
1289                 AC_DEFINE(HAVE_TOTALRAM_PAGES_AS_FUNC, 1,
1290                         [if totalram_pages is a function])
1291         ])
1292 ]) # LIBCFS_MM_TOTALRAM_PAGES_FUNC
1293
1294 #
1295 # LIBCFS_NEW_KERNEL_READ
1296 #
1297 # 4.14 commit bdd1d2d3d251c65b74ac4493e08db18971c09240 changed
1298 # the signature of kernel_read to match other read/write helpers
1299 # and place offset last.
1300 #
1301 AC_DEFUN([LIBCFS_SRC_NEW_KERNEL_READ], [
1302         LB2_LINUX_TEST_SRC([kernel_read], [
1303                 #include <linux/fs.h>
1304         ],[
1305                 loff_t pos = 0;
1306                 kernel_read(NULL, NULL, 0, &pos);
1307         ],[-Werror])
1308 ])
1309 AC_DEFUN([LIBCFS_NEW_KERNEL_READ], [
1310         AC_MSG_CHECKING([if 'kernel_read()' has loff_t *pos as last parameter])
1311         LB2_LINUX_TEST_RESULT([kernel_read], [
1312                 AC_DEFINE(HAVE_KERNEL_READ_LAST_POSP, 1,
1313                         [kernel_read() signature ends with loff_t *pos])
1314         ])
1315 ]) # LIBCFS_NEW_KERNEL_READ
1316
1317 #
1318 # LIBCFS_DEFINE_TIMER
1319 #
1320 # Kernel version 4.14 commit 1d27e3e2252ba9d949ca82fbdb73cde102cb2067
1321 # remove expires and data arguments from DEFINE_TIMER. Also the callback
1322 # when from using unsigned long argument to using struct timer_list pointer.
1323 #
1324 AC_DEFUN([LIBCFS_SRC_DEFINE_TIMER], [
1325         LB2_LINUX_TEST_SRC([define_timer], [
1326                 #include <linux/timer.h>
1327         ],[
1328                 static DEFINE_TIMER(my_timer, NULL);
1329         ])
1330 ])
1331 AC_DEFUN([LIBCFS_DEFINE_TIMER], [
1332         AC_MSG_CHECKING([if DEFINE_TIMER takes only 2 arguments])
1333         LB2_LINUX_TEST_RESULT([define_timer], [
1334                 AC_DEFINE(HAVE_NEW_DEFINE_TIMER, 1,
1335                         [DEFINE_TIMER uses only 2 arguements])
1336         ])
1337 ]) # LIBCFS_DEFINE_TIMER
1338
1339 #
1340 # LIBCFS_EXPORT_SAVE_STACK_TRACE_TSK
1341 #
1342 # Kernel 2.6.27 commit 8594698ebddeef5443b7da8258ae33b3eaca61d5
1343 # exported save_stack_trace_tsk for x86.
1344 # Kernel 2.6.27 commit 01f4b8b8b8db09b88be7df7e51192e4e678b69d3
1345 # exported save_stack_trace_tsk for powerpc
1346 # Kernel 4.13 commit e27c7fa015d61c8be6a2c32b2144aad2ae6ec975
1347 # exported save_stack_trace_tsk for arm64
1348 # Kernel 4.14 commit 9a3dc3186fc3795e076a4122da9e0258651a9631
1349 # exported save_stack_trace_tsk for arm
1350 #
1351 AC_DEFUN([LIBCFS_EXPORT_SAVE_STACK_TRACE_TSK], [
1352 LB_CHECK_EXPORT([save_stack_trace_tsk], [arch/$SUBARCH/kernel/stacktrace.c],
1353         [AC_DEFINE(HAVE_SAVE_STACK_TRACE_TSK, 1,
1354                 [save_stack_trace_tsk is exported])])
1355 ]) # LIBCFS_EXPORT_SAVE_STACK_TRACE_TSK
1356
1357 #
1358 # LIBCFS_LOCKDEP_IS_HELD
1359 #
1360 # Kernel v4.15-rc8-106-g08f36ff64234
1361 # lockdep: Make lockdep checking constant
1362 #
1363 AC_DEFUN([LIBCFS_SRC_LOCKDEP_IS_HELD], [
1364         LB2_LINUX_TEST_SRC([lockdep_is_held], [
1365                 #include <linux/lockdep.h>
1366         ],[
1367         #ifdef CONFIG_LOCKDEP
1368                 const struct spinlock *lock = NULL;
1369
1370                 lockdep_is_held(lock);
1371         #endif
1372         ],[-Werror])
1373 ])
1374 AC_DEFUN([LIBCFS_LOCKDEP_IS_HELD], [
1375         AC_MSG_CHECKING([if 'lockdep_is_held()' uses const argument])
1376         LB2_LINUX_TEST_RESULT([lockdep_is_held], [],[
1377                 AC_DEFINE(NEED_LOCKDEP_IS_HELD_DISCARD_CONST, 1,
1378                         [lockdep_is_held() argument is const])
1379         ])
1380 ]) # LIBCFS_LOCKDEP_IS_HELD
1381
1382 #
1383 # LIBCFS_TIMER_SETUP
1384 #
1385 # Kernel version 4.15 commit e99e88a9d2b067465adaa9c111ada99a041bef9a
1386 # setup_timer() was replaced by timer_setup(), where the callback
1387 # argument is the structure already holding the struct timer_list.
1388 #
1389 AC_DEFUN([LIBCFS_SRC_TIMER_SETUP], [
1390         LB2_LINUX_TEST_SRC([timer_setup], [
1391                 #include <linux/timer.h>
1392         ],[
1393                 timer_setup(NULL, NULL, 0);
1394         ])
1395 ])
1396 AC_DEFUN([LIBCFS_TIMER_SETUP], [
1397         AC_MSG_CHECKING([if setup_timer has been replaced with timer_setup])
1398         LB2_LINUX_TEST_RESULT([timer_setup], [
1399                 AC_DEFINE(HAVE_TIMER_SETUP, 1,
1400                         [timer_setup has replaced setup_timer])
1401         ])
1402 ]) # LIBCFS_TIMER_SETUP
1403
1404 #
1405 # LIBCFS_WAIT_VAR_EVENT
1406 #
1407 # Kernel version 4.16-rc4 commit 6b2bb7265f0b62605e8caee3613449ed0db270b9
1408 # added wait_var_event()
1409 #
1410 AC_DEFUN([LIBCFS_SRC_WAIT_VAR_EVENT], [
1411         if test "x$lb_cv_header_linux_wait_bit_h" = xyes; then
1412                 WAIT_BIT_H="-DHAVE_WAIT_BIT_HEADER_H=1"
1413         else
1414                 WAIT_BIT_H=""
1415         fi
1416         LB2_LINUX_TEST_SRC([wait_var_event], [
1417                 #ifdef HAVE_WAIT_BIT_HEADER_H
1418                 #include <linux/wait_bit.h>
1419                 #endif
1420                 #include <linux/wait.h>
1421         ],[
1422                 wake_up_var(NULL);
1423         ],[${WAIT_BIT_H}])
1424 ])
1425 AC_DEFUN([LIBCFS_WAIT_VAR_EVENT], [
1426         AC_MSG_CHECKING([if 'wait_var_event' exist])
1427         LB2_LINUX_TEST_RESULT([wait_var_event], [
1428                 AC_DEFINE(HAVE_WAIT_VAR_EVENT, 1,
1429                         ['wait_var_event' is available])
1430         ])
1431 ]) # LIBCFS_WAIT_VAR_EVENT
1432
1433 #
1434 # LIBCFS_BITMAP_ALLOC
1435 #
1436 # Kernel version 4.17 commit c42b65e363ce97a828f81b59033c3558f8fa7f70
1437 # added bitmap memory allocation handling.
1438 #
1439 AC_DEFUN([LIBCFS_SRC_BITMAP_ALLOC], [
1440         LB2_LINUX_TEST_SRC([bitmap_alloc], [
1441                 #include <linux/bitmap.h>
1442         ],[
1443                 unsigned long *map = bitmap_alloc(1, GFP_KERNEL);
1444                 (void)map;
1445         ])
1446 ])
1447 AC_DEFUN([LIBCFS_BITMAP_ALLOC], [
1448         AC_MSG_CHECKING([if Linux bitmap memory management exist])
1449         LB2_LINUX_TEST_RESULT([bitmap_alloc], [
1450                 AC_DEFINE(HAVE_BITMAP_ALLOC, 1,
1451                         [Linux bitmap can be allocated])
1452         ])
1453 ]) # LIBCFS_BITMAP_ALLOC
1454
1455 #
1456 # LIBCFS_CLEAR_AND_WAKE_UP_BIT
1457 #
1458 # Kernel version 4.17-rc2 commit 8236b0ae31c837d2b3a2565c5f8d77f637e824cc
1459 # added clear_and_wake_up_bit()
1460 #
1461 AC_DEFUN([LIBCFS_SRC_CLEAR_AND_WAKE_UP_BIT], [
1462         if test "x$lb_cv_header_linux_wait_bit_h" = xyes; then
1463                 WAIT_BIT_H="-DHAVE_WAIT_BIT_HEADER_H=1"
1464         else
1465                 WAIT_BIT_H=""
1466         fi
1467         LB2_LINUX_TEST_SRC([clear_and_wake_up_bit], [
1468                 #ifdef HAVE_WAIT_BIT_HEADER_H
1469                 #include <linux/wait_bit.h>
1470                 #endif
1471                 #include <linux/wait.h>
1472         ],[
1473                 clear_and_wake_up_bit(0, NULL);
1474         ],[${WAIT_BIT_H}])
1475 ])
1476 AC_DEFUN([LIBCFS_CLEAR_AND_WAKE_UP_BIT], [
1477         AC_MSG_CHECKING([if 'clear_and_wake_up_bit' exist])
1478         LB2_LINUX_TEST_RESULT([clear_and_wake_up_bit], [
1479                 AC_DEFINE(HAVE_CLEAR_AND_WAKE_UP_BIT, 1,
1480                         ['clear_and_wake_up_bit' is available])
1481         ])
1482 ]) # LIBCFS_CLEAR_AND_WAKE_UP_BIT
1483
1484 #
1485 # LIBCFS_TCP_SOCK_SET_NODELAY
1486 #
1487 # kernel 4.18.0-293.el8
1488 # tcp_sock_set_nodelay() was added
1489 AC_DEFUN([LIBCFS_SRC_TCP_SOCK_SET_NODELAY], [
1490         LB2_LINUX_TEST_SRC([tcp_sock_set_nodelay_exists], [
1491                 #include <linux/tcp.h>
1492         ],[
1493                 tcp_sock_set_nodelay(NULL);
1494         ],[-Werror])
1495 ])
1496 AC_DEFUN([LIBCFS_TCP_SOCK_SET_NODELAY], [
1497         AC_MSG_CHECKING([if 'tcp_sock_set_nodelay()' exists])
1498         LB2_LINUX_TEST_RESULT([tcp_sock_set_nodelay_exists], [
1499                 AC_DEFINE(HAVE_TCP_SOCK_SET_NODELAY, 1,
1500                         ['tcp_sock_set_nodelay()' exists])
1501         ])
1502 ]) # LIBCFS_TCP_SOCK_SET_NODELAY
1503
1504 #
1505 # LIBCFS_TCP_SOCK_SET_KEEPIDLE
1506 #
1507 # kernel 4.18.0-293.el8
1508 # tcp_sock_set_keepidle() was added
1509 #
1510 AC_DEFUN([LIBCFS_SRC_TCP_SOCK_SET_KEEPIDLE], [
1511         LB2_LINUX_TEST_SRC([tcp_sock_set_keepidle_exists], [
1512                 #include <linux/tcp.h>
1513         ],[
1514                 tcp_sock_set_keepidle(NULL, 0);
1515         ],[-Werror])
1516 ])
1517 AC_DEFUN([LIBCFS_TCP_SOCK_SET_KEEPIDLE], [
1518         AC_MSG_CHECKING([if 'tcp_sock_set_keepidle()' exists])
1519         LB2_LINUX_TEST_RESULT([tcp_sock_set_keepidle_exists], [
1520                 AC_DEFINE(HAVE_TCP_SOCK_SET_KEEPIDLE, 1,
1521                         ['tcp_sock_set_keepidle()' exists])
1522         ])
1523 ]) # LIBCFS_TCP_SOCK_SET_KEEPIDLE
1524
1525 #
1526 # LIBCFS_TCP_SOCK_SET_QUICKACK
1527 # kernel v5.7-rc6-2504-gddd061b8daed
1528 #   tcp: add tcp_sock_set_quickack
1529 #
1530 AC_DEFUN([LIBCFS_SRC_TCP_SOCK_SET_QUICKACK], [
1531         LB2_LINUX_TEST_SRC([tcp_sock_set_quickack_exists], [
1532                 #include <linux/tcp.h>
1533         ],[
1534                 tcp_sock_set_quickack(NULL, 0);
1535         ],[-Werror])
1536 ])
1537 AC_DEFUN([LIBCFS_TCP_SOCK_SET_QUICKACK], [
1538         AC_MSG_CHECKING([if 'tcp_sock_set_quickack()' exists])
1539         LB2_LINUX_TEST_RESULT([tcp_sock_set_quickack_exists], [
1540                 AC_DEFINE(HAVE_TCP_SOCK_SET_QUICKACK, 1,
1541                         ['tcp_sock_set_quickack()' exists])
1542         ])
1543 ]) # LIBCFS_TCP_SOCK_SET_QUICKACK
1544
1545 #
1546 # LIBCFS_TCP_SOCK_SET_KEEPINTVL
1547 # v5.7-rc6-2508-gd41ecaac903c
1548 # tcp: add tcp_sock_set_keepintvl
1549 #
1550 AC_DEFUN([LIBCFS_SRC_TCP_SOCK_SET_KEEPINTVL], [
1551         LB2_LINUX_TEST_SRC([tcp_sock_set_keepintvl_exists], [
1552                 #include <linux/tcp.h>
1553         ],[
1554                 tcp_sock_set_keepintvl(NULL, 0);
1555         ],[-Werror])
1556 ])
1557 AC_DEFUN([LIBCFS_TCP_SOCK_SET_KEEPINTVL], [
1558         AC_MSG_CHECKING([if 'tcp_sock_set_keepintvl()' exists])
1559         LB2_LINUX_TEST_RESULT([tcp_sock_set_keepintvl_exists], [
1560                 AC_DEFINE(HAVE_TCP_SOCK_SET_KEEPINTVL, 1,
1561                         ['tcp_sock_set_keepintvl()' exists])
1562         ])
1563 ]) # LIBCFS_TCP_SOCK_SET_KEEPINTVL
1564
1565 #
1566 # LIBCFS_TCP_SOCK_SET_KEEPCNT
1567 # v5.7-rc6-2509-g480aeb9639d6
1568 # tcp: add tcp_sock_set_keepcnt
1569 #
1570 AC_DEFUN([LIBCFS_SRC_TCP_SOCK_SET_KEEPCNT], [
1571         LB2_LINUX_TEST_SRC([tcp_sock_set_keepcnt_exists], [
1572                 #include <linux/tcp.h>
1573         ],[
1574                 tcp_sock_set_keepcnt(NULL, 0);
1575         ],[-Werror])
1576 ])
1577 AC_DEFUN([LIBCFS_TCP_SOCK_SET_KEEPCNT], [
1578         AC_MSG_CHECKING([if 'tcp_sock_set_keepcnt()' exists])
1579         LB2_LINUX_TEST_RESULT([tcp_sock_set_keepcnt_exists], [
1580                 AC_DEFINE(HAVE_TCP_SOCK_SET_KEEPCNT, 1,
1581                         ['tcp_sock_set_keepcnt()' exists])
1582         ])
1583 ]) # LIBCFS_TCP_SOCK_SET_KEEPCNT
1584
1585 #
1586 # LIBCFS_XARRAY_SUPPORT
1587 #
1588 # 4.19-rc5 kernel commit 3159f943aafdbacb2f94c38fdaadabf2bbde2a14
1589 # replaced the radix tree implementation with Xarrays. This change
1590 # introduced functionaly needed for general Xarray support
1591 #
1592 AC_DEFUN([LIBCFS_SRC_XARRAY_SUPPORT], [
1593         LB2_LINUX_TEST_SRC([xarray_support], [
1594                 #include <linux/xarray.h>
1595         ],[
1596                 xa_is_value(NULL);
1597         ],[-Werror])
1598 ])
1599 AC_DEFUN([LIBCFS_XARRAY_SUPPORT], [
1600         AC_MSG_CHECKING([if page cache uses Xarray])
1601         LB2_LINUX_TEST_RESULT([xarray_support], [
1602                 AC_DEFINE(HAVE_XARRAY_SUPPORT, 1,
1603                         [kernel Xarray implementation lacks 'xa_is_value'])
1604         ])
1605 ]) # LIBCFS_XARRAY_SUPPORT
1606
1607 #
1608 # LIBCFS_NL_DUMP_EXT_ACK
1609 #
1610 # Kernel version 4.19-rc6 commit 4a19edb60d0203cd5bf95a8b46ea8f63fd41194c
1611 # added extended ACK handling to Netlink dump handlers
1612 #
1613 AC_DEFUN([LIBCFS_SRC_NL_DUMP_EXT_ACK], [
1614         LB2_LINUX_TEST_SRC([netlink_dump_ext_ack], [
1615                 #include <net/netlink.h>
1616         ],[
1617                 struct netlink_callback *cb = NULL;
1618                 cb->extack = NULL;
1619         ],[])
1620 ])
1621 AC_DEFUN([LIBCFS_NL_DUMP_EXT_ACK], [
1622         AC_MSG_CHECKING([if Netlink dump handlers support ext_ack])
1623         LB2_LINUX_TEST_RESULT([netlink_dump_ext_ack], [
1624                 AC_DEFINE(HAVE_NL_DUMP_WITH_EXT_ACK, 1,
1625                         [netlink_ext_ack is handled for Netlink dump handlers])
1626         ])
1627 ]) # LIBCFS_NL_DUMP_EXT_ACK
1628
1629 #
1630 # LIBCFS_HAVE_IOV_ITER_TYPE
1631 #
1632 # kernel 4.20 commit 00e23707442a75b404392cef1405ab4fd498de6b
1633 # iov_iter: Use accessor functions to access an iterator's type and direction.
1634 #
1635 AC_DEFUN([LIBCFS_SRC_HAVE_IOV_ITER_TYPE], [
1636         LB2_LINUX_TEST_SRC([macro_iov_iter_type_exists], [
1637                 #include <linux/uio.h>
1638         ],[
1639                 struct iov_iter iter = { };
1640                 enum iter_type type = iov_iter_type(&iter);
1641                 (void)type;
1642         ],[-Werror])
1643 ])
1644 AC_DEFUN([LIBCFS_HAVE_IOV_ITER_TYPE], [
1645         AC_MSG_CHECKING([if iov_iter_type exists])
1646         LB2_LINUX_TEST_RESULT([macro_iov_iter_type_exists], [
1647                 AC_DEFINE(HAVE_IOV_ITER_TYPE, 1,
1648                         [if iov_iter_type exists])
1649         ])
1650 ]) # LIBCFS_HAVE_IOV_ITER_TYPE
1651
1652 #
1653 # LIBCFS_GENRADIX
1654 #
1655 # Kernel 5.0 commit ba20ba2e3743bac786dff777954c11930256075e
1656 # implemented generic radix trees to handle very large memory
1657 # allocation that can be used instead of vmalloc which has
1658 # a performance penalty.
1659 #
1660 AC_DEFUN([LIBCFS_GENRADIX], [
1661 LB_CHECK_EXPORT([__genradix_ptr], [lib/generic-radix-tree.c],
1662         [AC_DEFINE(HAVE_GENRADIX_SUPPORT, 1,
1663                 [generic-radix-tree is present])])
1664 ]) # LIBCFS_GENRADIX
1665
1666 #
1667 # LIBCFS_GET_REQUEST_KEY_AUTH
1668 #
1669 # kernel 5.0 commit 822ad64d7e46a8e2c8b8a796738d7b657cbb146d
1670 # keys: Fix dependency loop between construction record and auth key
1671 #
1672 # Added <keys/request_key_auth-type.h> and get_request_key_auth()
1673 # which was propagated to stable
1674 #
1675 AC_DEFUN([LIBCFS_SRC_GET_REQUEST_KEY_AUTH], [
1676         LB2_LINUX_TEST_SRC([get_request_key_auth_exported], [
1677                 #include <linux/key.h>
1678                 #include <linux/keyctl.h>
1679                 #include <keys/request_key_auth-type.h>
1680         ],[
1681                 struct key *ring;
1682                 const struct key *key = NULL;
1683                 struct request_key_auth *rka = get_request_key_auth(key);
1684
1685                 ring = key_get(rka->dest_keyring);
1686         ],[-Werror])
1687 ])
1688 AC_DEFUN([LIBCFS_GET_REQUEST_KEY_AUTH], [
1689         AC_MSG_CHECKING([if get_request_key_auth() is available])
1690         LB2_LINUX_TEST_RESULT([get_request_key_auth_exported], [
1691                 AC_DEFINE(HAVE_GET_REQUEST_KEY_AUTH, 1,
1692                         [get_request_key_auth() is available])
1693         ])
1694 ]) # LIBCFS_GET_REQUEST_KEY_AUTH
1695
1696 #
1697 # LIBCFS_KOBJ_TYPE_DEFAULT_GROUPS
1698 #
1699 # Linux commit v5.1-rc3-29-gaa30f47cf666
1700 #    kobject: Add support for default attribute groups to kobj_type
1701 # Linux commit v5.18-rc1-2-gcdb4f26a63c3
1702 #    kobject: kobj_type: remove default_attrs
1703 #
1704 AC_DEFUN([LIBCFS_SRC_KOBJ_TYPE_DEFAULT_GROUPS],[
1705         LB2_LINUX_TEST_SRC([kobj_type_default_groups], [
1706                 #include <linux/kobject.h>
1707         ],[
1708                 struct kobj_type *kobj_type = NULL;
1709                 void *has = kobj_type->default_groups;
1710                 (void) has;
1711         ])
1712 ])
1713 AC_DEFUN([LIBCFS_KOBJ_TYPE_DEFAULT_GROUPS],[
1714         AC_MSG_CHECKING([does struct kobj_type have 'default_groups' member])
1715         LB2_LINUX_TEST_RESULT([kobj_type_default_groups], [
1716                 AC_DEFINE(HAVE_KOBJ_TYPE_DEFAULT_GROUPS, 1,
1717                         [struct kobj_type has 'default_groups' member])
1718         ])
1719 ]) # LIBCFS_KOBJ_TYPE_DEFAULT_GROUPS
1720
1721 #
1722 # LIBCFS_LOOKUP_USER_KEY
1723 #
1724 # kernel 5.3 commit 3cf5d076fb4d48979f382bc9452765bf8b79e740
1725 # signal: Remove task parameter from force_sig
1726 #
1727 AC_DEFUN([LIBCFS_SRC_LOOKUP_USER_KEY], [
1728         LB2_LINUX_TEST_SRC([lookup_user_key_exported], [
1729                 #include <linux/key.h>
1730                 #include <linux/keyctl.h>
1731         ],[
1732                 lookup_user_key(KEY_SPEC_USER_KEYRING, 0, 0);
1733         ],[-Werror])
1734 ])
1735 AC_DEFUN([LIBCFS_LOOKUP_USER_KEY], [
1736         AC_MSG_CHECKING([if lookup_user_key() is available])
1737         LB2_LINUX_TEST_RESULT([lookup_user_key_exported], [
1738                 AC_DEFINE(HAVE_LOOKUP_USER_KEY, 1,
1739                         [lookup_user_key() is available])
1740         ])
1741 ]) # LIBCFS_LOOKUP_USER_KEY
1742
1743 #
1744 # LIBCFS_FORCE_SIG_WITH_TASK
1745 #
1746 # kernel 5.3 commit 3cf5d076fb4d48979f382bc9452765bf8b79e740
1747 # signal: Remove task parameter from force_sig
1748 #
1749 AC_DEFUN([LIBCFS_SRC_FORCE_SIG_WITH_TASK], [
1750         LB2_LINUX_TEST_SRC([force_sig_with_task], [
1751                 #include <linux/sched/signal.h>
1752         ],[
1753                 force_sig(SIGINT, NULL);
1754         ],[-Werror])
1755 ])
1756 AC_DEFUN([LIBCFS_FORCE_SIG_WITH_TASK], [
1757         AC_MSG_CHECKING([if force_sig has task parameter])
1758         LB2_LINUX_TEST_RESULT([force_sig_with_task], [
1759                 AC_DEFINE(HAVE_FORCE_SIG_WITH_TASK, 1,
1760                         [force_sig() has task parameter])
1761         ])
1762 ]) # LIBCFS_FORCE_SIG_WITH_TASK
1763
1764 #
1765 # LIBCFS_CACHE_DETAIL_WRITERS
1766 #
1767 # kernel v5.3-rc2-1-g64a38e840ce5
1768 # SUNRPC: Track writers of the 'channel' file to improve cache_listeners_exist
1769 #
1770 AC_DEFUN([LIBCFS_SRC_CACHE_DETAIL_WRITERS], [
1771         LB2_LINUX_TEST_SRC([cache_detail_writers_atomic], [
1772                 #include <linux/sunrpc/cache.h>
1773
1774                 static struct cache_detail rsi_cache;
1775         ],[
1776                 atomic_set(&rsi_cache.writers, 0);
1777         ],[-Werror])
1778 ])
1779 AC_DEFUN([LIBCFS_CACHE_DETAIL_WRITERS], [
1780         AC_MSG_CHECKING([if struct cache_detail has writers])
1781         LB2_LINUX_TEST_RESULT([cache_detail_writers_atomic], [
1782                 AC_DEFINE(HAVE_CACHE_DETAIL_WRITERS, 1,
1783                         [struct cache_detail has writers])
1784         ])
1785 ]) # LIBCFS_CACHE_DETAIL_WRITERS
1786
1787 #
1788 # LIBCFS_GENL_DUMPIT_INFO
1789 #
1790 # kernel v5.4-rc1 commit bf813b0afeae2f012f0e527a526c1b78ca21ad82
1791 # expanded struct genl_dumpit_info to include struct genl_family.
1792 #
1793 AC_DEFUN([LIBCFS_SRC_GENL_DUMPIT_INFO], [
1794         LB2_LINUX_TEST_SRC([genl_dumpit_info], [
1795                 #include <net/genetlink.h>
1796         ],[
1797                 static struct genl_dumpit_info info;
1798
1799                 info.family = NULL;
1800         ],[-Werror])
1801 ])
1802 AC_DEFUN([LIBCFS_GENL_DUMPIT_INFO], [
1803         AC_MSG_CHECKING([if struct genl_dumpit_info has family field])
1804         LB2_LINUX_TEST_RESULT([genl_dumpit_info], [
1805                 AC_DEFINE(HAVE_GENL_DUMPIT_INFO, 1,
1806                         [struct genl_dumpit_info has family field])
1807         ])
1808 ]) # LIBCFS_GENL_DUMPIT_INFO
1809
1810 #
1811 # LIBCFS_KALLSYMS_LOOKUP
1812 #
1813 # kernel v5.6-11591-g0bd476e6c671
1814 # kallsyms: unexport kallsyms_lookup_name() and kallsyms_on_each_symbol()
1815 AC_DEFUN([LIBCFS_KALLSYMS_LOOKUP], [
1816 LB_CHECK_EXPORT([kallsyms_lookup_name], [kernel/kallsyms.c],
1817         [AC_DEFINE(HAVE_KALLSYMS_LOOKUP_NAME, 1,
1818                 [kallsyms_lookup_name is exported by kernel])])
1819 ]) # LIBCFS_KALLSYMS_LOOKUP
1820
1821 #
1822 # v5.5-8862-gd56c0d45f0e2
1823 # proc: decouple proc from VFS with "struct proc_ops"
1824 #
1825 AC_DEFUN([LIBCFS_SRC_HAVE_PROC_OPS], [
1826         LB2_LINUX_TEST_SRC([proc_ops], [
1827                 #include <linux/proc_fs.h>
1828
1829                 static struct proc_ops *my_proc;
1830         ],[
1831                 my_proc->proc_lseek = NULL;
1832         ],[-Werror])
1833 ]) # LIBCFS_SRC_HAVE_PROC_OPS
1834 AC_DEFUN([LIBCFS_HAVE_PROC_OPS], [
1835         AC_MSG_CHECKING([if struct proc_ops exists])
1836         LB2_LINUX_TEST_RESULT([proc_ops], [
1837                 AC_DEFINE(HAVE_PROC_OPS, 1,
1838                         [struct proc_ops exists])
1839         ])
1840 ]) # LIBCFS_HAVE_PROC_OPS
1841
1842 #
1843 # LIBCFS_IP6_SET_PREF
1844 #
1845 # kernel v5.8-rc1~165^2~71^2~3 commit 18d5ad62327576cbb1e5b9938a59d63ac0c15832
1846 # ipv6: add ip6_sock_set_addr_preferences
1847 #
1848 AC_DEFUN([LIBCFS_SRC_IP6_SET_PREF], [
1849         LB2_LINUX_TEST_SRC([ip6_set_pref_test], [
1850                 #include <net/ipv6.h>
1851         ],[
1852                 ip6_sock_set_addr_preferences(NULL, 0);
1853         ],[-Werror])
1854 ])
1855 AC_DEFUN([LIBCFS_IP6_SET_PREF], [
1856         AC_MSG_CHECKING([if ip6_sock_set_addr_preferences() exists])
1857         LB2_LINUX_TEST_RESULT([ip6_set_pref_test], [
1858                 AC_DEFINE(HAVE_IP6_SET_PREF, 1,
1859                         [if ip6_sock_set_addr_preferences exists])
1860         ])
1861 ]) # LIBCFS_IP6_SET_PREF
1862
1863 #
1864 # LIBCFS_VMALLOC_2ARGS
1865 #
1866 # kernel v5.8-rc1~201^2~19
1867 # mm: remove the pgprot argument to __vmalloc
1868 AC_DEFUN([LIBCFS_SRC_VMALLOC_2ARGS], [
1869         LB2_LINUX_TEST_SRC([vmalloc_2args], [
1870                 #include <linux/vmalloc.h>
1871         ],[
1872                 __vmalloc(0, 0);
1873         ],[])
1874 ])
1875 AC_DEFUN([LIBCFS_VMALLOC_2ARGS], [
1876         AC_MSG_CHECKING([if __vmalloc has 2 args])
1877         LB2_LINUX_TEST_RESULT([vmalloc_2args], [
1878                 AC_DEFINE(HAVE_VMALLOC_2ARGS, 1,
1879                         [__vmalloc only takes 2 args.])
1880         ])
1881 ]) # LIBCFS_VMALLOC_2ARGS
1882
1883 #
1884 # LIBCFS_HAVE_NR_UNSTABLE_NFS
1885 #
1886 # kernel v5.8-rc1~201^2~75
1887 # mm/writeback: discard NR_UNSTABLE_NFS, use NR_WRITEBACK instead
1888 #
1889 AC_DEFUN([LIBCFS_SRC_HAVE_NR_UNSTABLE_NFS], [
1890         LB2_LINUX_TEST_SRC([nr_unstable_nfs_exists], [
1891                 #include <linux/mm.h>
1892
1893                 int i;
1894         ],[
1895                 i = NR_UNSTABLE_NFS;
1896         ],[-Werror])
1897 ])
1898 AC_DEFUN([LIBCFS_HAVE_NR_UNSTABLE_NFS], [
1899         AC_MSG_CHECKING([if NR_UNSTABLE_NFS still in use])
1900         LB2_LINUX_TEST_RESULT([nr_unstable_nfs_exists], [
1901                 AC_DEFINE(HAVE_NR_UNSTABLE_NFS, 1,
1902                         [NR_UNSTABLE_NFS is still in use.])
1903         ])
1904 ]) # LIBCFS_HAVE_NR_UNSTABLE_NFS
1905
1906 #
1907 # LIBCFS_HAVE_MMAP_LOCK
1908 #
1909 # kernel v5.8-rc1~83^2~24
1910 # mmap locking API: rename mmap_sem to mmap_lock
1911 #
1912 AC_DEFUN([LIBCFS_SRC_HAVE_MMAP_LOCK], [
1913         LB2_LINUX_TEST_SRC([mmap_write_lock], [
1914                 #include <linux/mm.h>
1915         ],[
1916                 mmap_write_lock(NULL);
1917         ],[])
1918 ])
1919 AC_DEFUN([LIBCFS_HAVE_MMAP_LOCK], [
1920         AC_MSG_CHECKING([if mmap_lock API is available])
1921         LB2_LINUX_TEST_RESULT([mmap_write_lock], [
1922                 AC_DEFINE(HAVE_MMAP_LOCK, 1,
1923                         [mmap_lock API is available.])
1924         ])
1925 ]) # LIBCFS_HAVE_MMAP_LOCK
1926
1927 #
1928 # LIBCFS_KERNEL_SETSOCKOPT
1929 #
1930 # kernel v5.8-rc1~165^2~59^2
1931 # net: remove kernel_setsockopt
1932 AC_DEFUN([LIBCFS_SRC_KERNEL_SETSOCKOPT], [
1933         LB2_LINUX_TEST_SRC([kernel_setsockopt_exists], [
1934                 #include <linux/net.h>
1935         ],[
1936                 kernel_setsockopt(NULL, 0, 0, NULL, 0);
1937         ],[-Werror])
1938 ])
1939 AC_DEFUN([LIBCFS_KERNEL_SETSOCKOPT], [
1940         AC_MSG_CHECKING([if kernel_setsockopt still in use])
1941         LB2_LINUX_TEST_RESULT([kernel_setsockopt_exists], [
1942         AC_DEFINE(HAVE_KERNEL_SETSOCKOPT, 1,
1943                 [kernel_setsockopt still in use])
1944         ])
1945 ]) # LIBCFS_KERNEL_SETSOCKOPT
1946
1947 #
1948 # LIBCFS_SEC_RELEASE_SECCTX
1949 #
1950 # kernel linux-hwe-5.8 (5.8.0-22.23~20.04.1)
1951 # LSM: Use lsmcontext in security_release_secctx
1952 AC_DEFUN([LIBCFS_SRC_SEC_RELEASE_SECCTX], [
1953         LB2_LINUX_TEST_SRC([security_release_secctx_1arg], [
1954                 #include <linux/security.h>
1955         ],[
1956                 security_release_secctx(NULL);
1957         ],[])
1958 ])
1959 AC_DEFUN([LIBCFS_SEC_RELEASE_SECCTX], [
1960         AC_MSG_CHECKING([if security_release_secctx has 1 arg])
1961         LB2_LINUX_TEST_RESULT([security_release_secctx_1arg], [
1962                 AC_DEFINE(HAVE_SEC_RELEASE_SECCTX_1ARG, 1,
1963                         [security_release_secctx has 1 arg.])
1964         ])
1965 ]) # LIBCFS_SEC_RELEASE_SECCTX
1966
1967 #
1968 # LIBCFS_HAVE_KFREE_SENSITIVE
1969 #
1970 # kernel v5.10-rc1~3
1971 # mm: remove kzfree() compatibility definition
1972 #
1973 AC_DEFUN([LIBCFS_SRC_HAVE_KFREE_SENSITIVE], [
1974         LB2_LINUX_TEST_SRC([kfree_sensitive_exists], [
1975                 #include <linux/slab.h>
1976         ],[
1977                 kfree_sensitive(NULL);
1978         ], [-Werror])
1979 ])
1980 AC_DEFUN([LIBCFS_HAVE_KFREE_SENSITIVE], [
1981         AC_MSG_CHECKING([if kfree_sensitive() is available])
1982         LB2_LINUX_TEST_RESULT([kfree_sensitive_exists], [
1983                 AC_DEFINE(HAVE_KFREE_SENSITIVE, 1,
1984                         [kfree_sensitive() is available.])
1985         ])
1986 ]) # LIBCFS_HAVE_KFREE_SENSITIVE
1987
1988 #
1989 # LIBCFS_HAVE_CRYPTO_SHA2_HEADER
1990 #
1991 # Kernel v5.10-rc1-114-ga24d22b225ce
1992 # crypto: sha - split sha.h into sha1.h and sha2.h
1993 #
1994 AC_DEFUN([LIBCFS_HAVE_CRYPTO_SHA2_HEADER], [
1995 LB_CHECK_LINUX_HEADER([crypto/sha2.h], [
1996         AC_DEFINE(HAVE_CRYPTO_SHA2_HEADER, 1,
1997                 [crypto/sha2.h is present])])
1998 ]) # LIBCFS_HAVE_CRYPTO_SHA2_HEADER
1999
2000 #
2001 # LIBCFS_HAVE_LIST_CMP_FUNC_T
2002 #
2003 # kernel 5.10.70 commit 4f0f586bf0c898233d8f316f471a21db2abd522d
2004 # treewide: Change list_sort to use const pointers
2005 AC_DEFUN([LIBCFS_SRC_HAVE_LIST_CMP_FUNC_T], [
2006         LB2_LINUX_TEST_SRC([list_cmp_func_t_exists], [
2007                 #include <linux/list_sort.h>
2008         ],[
2009                 list_cmp_func_t cmp;
2010                 (void)cmp;
2011         ], [-Werror])
2012 ])
2013 AC_DEFUN([LIBCFS_HAVE_LIST_CMP_FUNC_T], [
2014         AC_MSG_CHECKING([if list_cmp_func_t type is defined])
2015         LB2_LINUX_TEST_RESULT([list_cmp_func_t_exists], [
2016                 AC_DEFINE(HAVE_LIST_CMP_FUNC_T, 1,
2017                         [list_cmp_func_t type is defined])
2018         ])
2019 ]) # LIBCFS_HAVE_LIST_CMP_FUNC_T
2020
2021 #
2022 # LIBCFS_NLA_STRLCPY
2023 #
2024 # Kernel version 5.10-rc3 commit 872f690341948b502c93318f806d821c56772c42
2025 # replaced nla_strlcpy() with nla_strscpy().
2026 #
2027 AC_DEFUN([LIBCFS_SRC_NLA_STRLCPY], [
2028         LB2_LINUX_TEST_SRC([nla_strlcpy], [
2029                 #include <net/netlink.h>
2030         ],[
2031                 if (nla_strlcpy(NULL, NULL, 0) == 0)
2032                         return -EINVAL;
2033         ])
2034 ])
2035 AC_DEFUN([LIBCFS_NLA_STRLCPY], [
2036         AC_MSG_CHECKING([if 'nla_strlcpy()' still exists])
2037         LB2_LINUX_TEST_RESULT([nla_strlcpy], [
2038                 AC_DEFINE(HAVE_NLA_STRLCPY, 1,
2039                         ['nla_strlcpy' is available])
2040         ])
2041 ]) # LIBCFS_NLA_STRLCPY
2042
2043 #
2044 # LIBCFS_LINUX_FORTIFY_STRING_HEADER
2045 #
2046 # Linux v5.11-11104-ga28a6e860c6c
2047 #  string.h: move fortified functions definitions in a dedicated header.
2048 #
2049 AC_DEFUN([LIBCFS_SRC_LINUX_FORTIFY_STRING_HEADER],[
2050         LB2_LINUX_TEST_SRC([linux_fortify_string_header], [
2051                 #include <linux/fortify-string.h>
2052         ],[
2053         ],[])
2054 ])
2055 AC_DEFUN([LIBCFS_LINUX_FORTIFY_STRING_HEADER],[
2056         AC_MSG_CHECKING([Is linux/fortify-string.h header available])
2057         LB2_LINUX_TEST_RESULT([linux_fortify_string_header], [
2058                 AC_DEFINE(HAVE_LINUX_FORTIFY_STRING_HEADER, 1,
2059                         [linux/fortify-string.h header available])
2060         ])
2061 ]) # LIBCFS_LINUX_FORTIFY_STRING_HEADER
2062
2063 #
2064 # LIBCFS_HAVE_CIPHER_HEADER
2065 #
2066 # Kernel 5.12 commit 0eb76ba29d16df2951d37c54ca279c4e5630b071
2067 # crypto: remove cipher routines from public crypto API
2068 #
2069 AC_DEFUN([LIBCFS_HAVE_CIPHER_HEADER], [
2070 tmp_flags="$EXTRA_KCFLAGS"
2071 EXTRA_KCFLAGS="-Werror"
2072 LB_CHECK_LINUX_HEADER([crypto/internal/cipher.h], [
2073         AC_DEFINE(HAVE_CIPHER_H, 1,
2074                 [crypto/internal/cipher.h is present])
2075 ])
2076 EXTRA_KCFLAGS="$tmp_flags"
2077 ]) # LIBCFS_HAVE_CIPHER_HEADER
2078
2079 #
2080 # LIBCFS_HAVE_TASK_RUNNING
2081 #
2082 # Kernel 5.13-rc6 commit b03fbd4ff24c5f075e58eb19261d5f8b3e40d
2083 # introduced task_is_running() macro.
2084 #
2085 AC_DEFUN([LIBCFS_SRC_HAVE_TASK_IS_RUNNING], [
2086         LB2_LINUX_TEST_SRC([task_is_running], [
2087                 #include <linux/sched.h>
2088         ],[
2089                 if (task_is_running(current))
2090                         schedule();
2091         ], [-Werror])
2092 ])
2093 AC_DEFUN([LIBCFS_HAVE_TASK_IS_RUNNING], [
2094         AC_MSG_CHECKING([if task_is_running() is defined])
2095         LB2_LINUX_TEST_RESULT([task_is_running], [
2096                 AC_DEFINE(HAVE_TASK_IS_RUNNING, 1,
2097                         [task_is_running() is defined])
2098         ])
2099 ]) # LIBCFS_HAVE_TASK_IS_RUNNING
2100
2101 #
2102 # LIBCFS_IOV_ITER_HAS_ITER_TYPE
2103 #
2104 # kernel 5.13 commit 8cd54c1c848031a87820e58d772166ffdf8c08c0 change
2105 # ->type to ->iter_type
2106 #
2107 AC_DEFUN([LIBCFS_SRC_IOV_ITER_HAS_ITER_TYPE], [
2108         LB2_LINUX_TEST_SRC([iov_iter_has_iter_type_member], [
2109                 #include <linux/uio.h>
2110         ],[
2111                 struct iov_iter iter = { .iter_type = ITER_KVEC };
2112                 (void)iter;
2113         ],
2114         [-Werror])
2115 ])
2116 AC_DEFUN([LIBCFS_IOV_ITER_HAS_ITER_TYPE], [
2117         AC_MSG_CHECKING([if iov_iter has member type])
2118         LB2_LINUX_TEST_RESULT([iov_iter_has_iter_type_member], [
2119                 AC_DEFINE(HAVE_IOV_ITER_HAS_ITER_TYPE_MEMBER, 1,
2120                         [if iov_iter has member iter_type])
2121         ])
2122 ]) # LIBCFS_IOV_ITER_HAS_ITER_TYPE
2123
2124 #
2125 # LIBCFS_LINUX_STDARG_HEADER
2126 #
2127 # Kernel 5.14-rc5 commit c0891ac15f0428ffa81b2e818d416bdf3cb74ab6
2128 # isystem: ship and use stdarg.h
2129 #
2130 AC_DEFUN([LIBCFS_LINUX_STDARG_HEADER], [
2131 tmp_flags="$EXTRA_KCFLAGS"
2132 EXTRA_KCFLAGS="-Werror"
2133 LB_CHECK_LINUX_HEADER([linux/stdarg.h], [
2134         AC_DEFINE(HAVE_LINUX_STDARG_HEADER, 1, [linux/stdarg.h is present])
2135 ])
2136 EXTRA_KCFLAGS="$tmp_flags"
2137 ]) # LIBCFS_LINUX_STDARG_HEADER
2138
2139 #
2140 # LIBCFS_HAVE_PANIC_NOTIFIER_HEADER
2141 #
2142 # Kernel 5.14 commit f39650de687e35766572ac89dbcd16a5911e2f0a
2143 # kernel.h: split out panic and oops helpers
2144 #
2145 AC_DEFUN([LIBCFS_HAVE_PANIC_NOTIFIER_HEADER], [
2146 tmp_flags="$EXTRA_KCFLAGS"
2147 EXTRA_KCFLAGS="-Werror"
2148 LB_CHECK_LINUX_HEADER([linux/panic_notifier.h], [
2149         AC_DEFINE(HAVE_PANIC_NOTIFIER_H, 1,
2150                 [linux/panic_notifier.h is present])
2151 ])
2152 EXTRA_KCFLAGS="$tmp_flags"
2153 ]) # LIBCFS_HAVE_PANIC_NOTIFIER_HEADER
2154
2155 #
2156 # LIBCFS_PARAM_SET_UINT_MINMAX
2157 #
2158 # Kernel 5.15-rc1 commit 2a14c9ae15a38148484a128b84bff7e9ffd90d68
2159 # moved param_set_uint_minmax to common code
2160 #
2161 AC_DEFUN([LIBCFS_SRC_PARAM_SET_UINT_MINMAX],[
2162         LB2_LINUX_TEST_SRC([param_set_uint_minmax], [
2163                 #include <linux/moduleparam.h>
2164         ],[
2165                 param_set_uint_minmax(NULL, NULL, 0, 0);
2166         ], [])
2167 ])
2168 AC_DEFUN([LIBCFS_PARAM_SET_UINT_MINMAX],[
2169         AC_MSG_CHECKING([does function 'param_set_uint_minmax' exist])
2170         LB2_LINUX_TEST_RESULT([param_set_uint_minmax], [
2171                 AC_DEFINE(HAVE_PARAM_SET_UINT_MINMAX, 1,
2172                         ['param_set_uint_minmax' is available])
2173         ])
2174 ]) # LIBCFS_PARAM_SET_UINT_MINMAX
2175
2176 #
2177 # LIBCFS_LINUX_BLK_INTEGRITY_HEADER
2178 #
2179 # Kernel 5.15-rc6 commit fe45e630a1035aea94c29016f2598bbde149bbe3
2180 # block: move integrity handling out of <linux/blkdev.h>
2181 #
2182 AC_DEFUN([LIBCFS_LINUX_BLK_INTEGRITY_HEADER], [
2183 tmp_flags="$EXTRA_KCFLAGS"
2184 EXTRA_KCFLAGS="-Werror"
2185 LB_CHECK_LINUX_HEADER([linux/blk-integrity.h], [
2186         AC_DEFINE(HAVE_LINUX_BLK_INTEGRITY_HEADER, 1,
2187                 [linux/blk-integrity.h is present])
2188 ])
2189 EXTRA_KCFLAGS="$tmp_flags"
2190 ]) # LIBCFS_LINUX_BLK_INTEGRITY_HEADER
2191
2192 #
2193 # LIBCFS_PDE_DATA_EXISTS
2194 #
2195 # Linux commit v5.16-11573-g6dfbbae14a7b
2196 #    introduce pde_data()
2197 # Linux commit v5.16-11574-g359745d78351
2198 #    remove PDE_DATA()
2199 #
2200 AC_DEFUN([LIBCFS_SRC_PDE_DATA_EXISTS],[
2201         LB2_LINUX_TEST_SRC([pde_data], [
2202                 #include <linux/proc_fs.h>
2203         ],[
2204                 struct inode *inode = NULL;
2205                 void *data =pde_data(inode);
2206                 (void)data;
2207         ],[])
2208 ])
2209 AC_DEFUN([LIBCFS_PDE_DATA_EXISTS],[
2210         AC_MSG_CHECKING([does function 'pde_data' exist])
2211         LB2_LINUX_TEST_RESULT([pde_data], [
2212                 AC_DEFINE(HAVE_pde_data, 1, [function pde_data() available])
2213         ],[
2214                 AC_DEFINE(pde_data(inode), PDE_DATA(inode),
2215                           [function pde_data() unavailable])
2216         ])
2217 ]) # LIBCFS_PDE_DATA_EXISTS
2218
2219 #
2220 # LIBCFS_BIO_ALLOC_WITH_BDEV
2221 #
2222 # Linux commit v5.17-rc2-21-g07888c665b40
2223 #   block: pass a block_device and opf to bio_alloc
2224 #
2225 AC_DEFUN([LIBCFS_SRC_BIO_ALLOC_WITH_BDEV],[
2226         LB2_LINUX_TEST_SRC([bio_alloc_with_bdev], [
2227                 #include <linux/bio.h>
2228         ],[
2229                 struct block_device *bdev = NULL;
2230                 unsigned short nr_vecs = 1;
2231                 gfp_t gfp = GFP_KERNEL;
2232                 struct bio *bio = bio_alloc(bdev, nr_vecs, REQ_OP_WRITE, gfp);
2233                 (void) bio;
2234         ],[])
2235 ])
2236 AC_DEFUN([LIBCFS_BIO_ALLOC_WITH_BDEV],[
2237         AC_MSG_CHECKING([does bio_alloc() takes a struct block_device])
2238         LB2_LINUX_TEST_RESULT([bio_alloc_with_bdev], [
2239                 AC_DEFINE(HAVE_BIO_ALLOC_WITH_BDEV, 1,
2240                         [bio_alloc() takes a struct block_device])
2241         ])
2242 ]) # LIBCFS_BIO_ALLOC_WITH_BDEV
2243
2244 dnl #
2245 dnl # Generate and compile all of the kernel API test cases to determine
2246 dnl # which interfaces are available.  By invoking the kernel build system
2247 dnl # only once the compilation can be done in parallel significantly
2248 dnl # speeding up the process.
2249 dnl #
2250 AC_DEFUN([LIBCFS_PROG_LINUX_SRC], [
2251         # 3.11
2252         LIBCFS_SRC_KTIME_GET_TS64
2253         # 3.12
2254         LIBCFS_SRC_PREPARE_TO_WAIT_EVENT
2255         LIBCFS_SRC_KERNEL_PARAM_OPS
2256         LIBCFS_SRC_KTIME_ADD
2257         LIBCFS_SRC_KTIME_AFTER
2258         LIBCFS_SRC_KTIME_BEFORE
2259         LIBCFS_SRC_KTIME_COMPARE
2260         LIBCFS_SRC_SHRINKER_COUNT
2261         # 3.13
2262         LIBCFS_SRC_MATCH_WILDCARD
2263         # 3.14
2264         LIBCFS_SRC_HAVE_MAPPING_AS_EXITING_FLAG
2265         # 3.15
2266         LIBCFS_SRC_IOV_ITER_HAS_TYPE
2267         # 3.16
2268         LIBCFS_SRC_HAVE_GLOB
2269         # 3.17
2270         LIBCFS_SRC_HLIST_ADD_AFTER
2271         LIBCFS_SRC_TIMESPEC64
2272         LIBCFS_SRC_KTIME_GET_NS
2273         LIBCFS_SRC_KTIME_GET_REAL_TS64
2274         LIBCFS_SRC_KTIME_GET_REAL_SECONDS
2275         LIBCFS_SRC_KTIME_GET_REAL_NS
2276         LIBCFS_SRC_KTIME_TO_TIMESPEC64
2277         LIBCFS_SRC_TIMESPEC64_SUB
2278         LIBCFS_SRC_TIMESPEC64_TO_KTIME
2279         # 3.19
2280         LIBCFS_SRC_KTIME_GET_SECONDS
2281         LIBCFS_SRC_WAIT_WOKEN
2282         # 4.0
2283         LIBCFS_SRC_KTIME_MS_DELTA
2284         # 4.2
2285         LIBCFS_SRC_KERNEL_PARAM_LOCK
2286         # 4.2
2287         LIBCFS_SRC_HAVE_TOPOLOGY_SIBLING_CPUMASK
2288         # 4.4
2289         LIBCFS_SRC_KSTRTOBOOL_FROM_USER
2290         LIBCFS_SRC_NETLINK_CALLBACK_START
2291         # 4.5
2292         LIBCFS_SRC_CRYPTO_HASH_HELPERS
2293         LIBCFS_SRC_RHASHTABLE_REPLACE
2294         # 4.6
2295         LIBCFS_SRC_BROKEN_HASH_64
2296         LIBCFS_SRC_STACKTRACE_OPS_ADDRESS_RETURN_INT
2297         LIBCFS_SRC_GET_USER_PAGES_6ARG
2298         # 4.7
2299         LIBCFS_SRC_RHASHTABLE_INSERT_FAST
2300         LIBCFS_SRC_RHASHTABLE_WALK_INIT_3ARG
2301         # 4.8
2302         LIBCFS_SRC_RHASHTABLE_LOOKUP
2303         LIBCFS_SRC_RHLTABLE
2304         LIBCFS_SRC_STACKTRACE_OPS
2305         # 4.9
2306         LIBCFS_SRC_GET_USER_PAGES_GUP_FLAGS
2307         LIBCFS_SRC_RHASHTABLE_WALK_ENTER
2308         # 4.10
2309         LIBCFS_SRC_HOTPLUG_STATE_MACHINE
2310         # 4.11
2311         LIBCFS_SRC_NL_EXT_ACK
2312         LIBCFS_SRC_RHASHTABLE_LOOKUP_GET_INSERT_FAST
2313         LIBCFS_SRC_KREF_READ
2314         LIBCFS_SRC_RHT_BUCKET_VAR
2315         # 4.12
2316         LIBCFS_SRC_CPUS_READ_LOCK
2317         LIBCFS_SRC_UUID_T
2318         LIBCFS_SRC_WAIT_QUEUE_TASK_LIST_RENAME
2319         LIBCFS_SRC_WAIT_BIT_QUEUE_ENTRY_EXISTS
2320         LIBCFS_SRC_MEMALLOC_NORECLAIM
2321         # 4.13
2322         LIBCFS_SRC_NLA_STRDUP
2323         LIBCFS_SRC_WAIT_QUEUE_ENTRY
2324         # 4.14
2325         LIBCFS_SRC_DEFINE_TIMER
2326         LIBCFS_SRC_NEW_KERNEL_WRITE
2327         LIBCFS_SRC_NEW_KERNEL_READ
2328         # 4.15
2329         LIBCFS_SRC_LOCKDEP_IS_HELD
2330         LIBCFS_SRC_TIMER_SETUP
2331         # 4.16
2332         LIBCFS_SRC_HAVE_NS_TO_TIMESPEC64
2333         LIBCFS_SRC_WAIT_VAR_EVENT
2334         # 4.17
2335         LIBCFS_SRC_BITMAP_ALLOC
2336         LIBCFS_SRC_CLEAR_AND_WAKE_UP_BIT
2337         # 4.18
2338         LIBCFS_SRC_TCP_SOCK_SET_NODELAY
2339         LIBCFS_SRC_TCP_SOCK_SET_KEEPIDLE
2340         # 4.19
2341         LIBCFS_SRC_XARRAY_SUPPORT
2342         LIBCFS_SRC_NL_DUMP_EXT_ACK
2343         # 4.20
2344         LIBCFS_SRC_HAVE_IOV_ITER_TYPE
2345         # 5.0
2346         LIBCFS_SRC_MM_TOTALRAM_PAGES_FUNC
2347         LIBCFS_SRC_GET_REQUEST_KEY_AUTH
2348         # 5.2
2349         LIBCFS_SRC_KOBJ_TYPE_DEFAULT_GROUPS
2350         # 5.3
2351         LIBCFS_SRC_LOOKUP_USER_KEY
2352         LIBCFS_SRC_FORCE_SIG_WITH_TASK
2353         LIBCFS_SRC_CACHE_DETAIL_WRITERS
2354         # 5.4
2355         LIBCFS_SRC_GENL_DUMPIT_INFO
2356         # 5.6
2357         LIBCFS_SRC_HAVE_PROC_OPS
2358         # 5.7
2359         LIBCFS_SRC_TCP_SOCK_SET_QUICKACK
2360         LIBCFS_SRC_TCP_SOCK_SET_KEEPINTVL
2361         LIBCFS_SRC_TCP_SOCK_SET_KEEPCNT
2362         # 5.8
2363         LIBCFS_SRC_HAVE_NR_UNSTABLE_NFS
2364         LIBCFS_SRC_HAVE_MMAP_LOCK
2365         LIBCFS_SRC_KERNEL_SETSOCKOPT
2366         LIBCFS_SRC_IP6_SET_PREF
2367         LIBCFS_SRC_VMALLOC_2ARGS
2368         # 5.10
2369         LIBCFS_SRC_SEC_RELEASE_SECCTX
2370         LIBCFS_SRC_HAVE_KFREE_SENSITIVE
2371         LIBCFS_SRC_HAVE_LIST_CMP_FUNC_T
2372         LIBCFS_SRC_NLA_STRLCPY
2373         # 5.12
2374         LIBCFS_SRC_LINUX_FORTIFY_STRING_HEADER
2375         # 5.13
2376         LIBCFS_SRC_HAVE_TASK_IS_RUNNING
2377         LIBCFS_SRC_IOV_ITER_HAS_ITER_TYPE
2378         # 5.15
2379         LIBCFS_SRC_PARAM_SET_UINT_MINMAX
2380         # 5.17
2381         LIBCFS_SRC_PDE_DATA_EXISTS
2382         LIBCFS_SRC_BIO_ALLOC_WITH_BDEV
2383
2384         LB2_LINUX_TEST_COMPILE_ALL([libcfs],
2385                 [for available kernel interfaces to libcfs])
2386 ])
2387
2388 dnl #
2389 dnl # Check results of kernel interface tests.
2390 dnl #
2391 AC_DEFUN([LIBCFS_PROG_LINUX_RESULTS], [
2392         # 3.11
2393         LIBCFS_KTIME_GET_TS64
2394         # 3.12
2395         LIBCFS_PREPARE_TO_WAIT_EVENT
2396         LIBCFS_KERNEL_PARAM_OPS
2397         LIBCFS_KTIME_ADD
2398         LIBCFS_KTIME_AFTER
2399         LIBCFS_KTIME_BEFORE
2400         LIBCFS_KTIME_COMPARE
2401         LIBCFS_SHRINKER_COUNT
2402         # 3.13
2403         LIBCFS_MATCH_WILDCARD
2404         # 3.14
2405         LIBCFS_HAVE_MAPPING_AS_EXITING_FLAG
2406         # 3.15
2407         LIBCFS_IOV_ITER_HAS_TYPE
2408         # 3.16
2409         LIBCFS_HAVE_GLOB
2410         # 3.17
2411         LIBCFS_HLIST_ADD_AFTER
2412         LIBCFS_TIMESPEC64
2413         LIBCFS_KTIME_GET_NS
2414         LIBCFS_KTIME_GET_REAL_TS64
2415         LIBCFS_KTIME_GET_REAL_SECONDS
2416         LIBCFS_KTIME_GET_REAL_NS
2417         LIBCFS_KTIME_TO_TIMESPEC64
2418         LIBCFS_TIMESPEC64_SUB
2419         LIBCFS_TIMESPEC64_TO_KTIME
2420         # 3.19
2421         LIBCFS_KTIME_GET_SECONDS
2422         LIBCFS_WAIT_WOKEN
2423         # 4.0
2424         LIBCFS_KTIME_MS_DELTA
2425         # 4.1
2426         LIBCFS_KERNEL_PARAM_LOCK
2427         # 4.2
2428         LIBCFS_HAVE_TOPOLOGY_SIBLING_CPUMASK
2429         # 4.4
2430         LIBCFS_KSTRTOBOOL_FROM_USER
2431         LIBCFS_NETLINK_CALLBACK_START
2432         # 4.5
2433         LIBCFS_CRYPTO_HASH_HELPERS
2434         LIBCFS_RHASHTABLE_REPLACE
2435         # 4.6
2436         LIBCFS_BROKEN_HASH_64
2437         LIBCFS_STACKTRACE_OPS_ADDRESS_RETURN_INT
2438         LIBCFS_GET_USER_PAGES_6ARG
2439         # 4.7
2440         LIBCFS_RHASHTABLE_INSERT_FAST
2441         LIBCFS_RHASHTABLE_WALK_INIT_3ARG
2442         # 4.8
2443         LIBCFS_RHASHTABLE_LOOKUP
2444         LIBCFS_RHLTABLE
2445         LIBCFS_STACKTRACE_OPS
2446         # 4.9
2447         LIBCFS_GET_USER_PAGES_GUP_FLAGS
2448         LIBCFS_RHASHTABLE_WALK_ENTER
2449         # 4.10
2450         LIBCFS_HOTPLUG_STATE_MACHINE
2451         # 4.11
2452         LIBCFS_NL_EXT_ACK
2453         LIBCFS_RHASHTABLE_LOOKUP_GET_INSERT_FAST
2454         LIBCFS_KREF_READ
2455         LIBCFS_RHT_BUCKET_VAR
2456         # 4.12
2457         LIBCFS_CPUS_READ_LOCK
2458         LIBCFS_UUID_T
2459         LIBCFS_WAIT_QUEUE_TASK_LIST_RENAME
2460         LIBCFS_WAIT_BIT_QUEUE_ENTRY_EXISTS
2461         LIBCFS_MEMALLOC_NORECLAIM
2462         # 4.13
2463         LIBCFS_NLA_STRDUP
2464         LIBCFS_WAIT_QUEUE_ENTRY
2465         # 4.14
2466         LIBCFS_DEFINE_TIMER
2467         LIBCFS_NEW_KERNEL_WRITE
2468         LIBCFS_NEW_KERNEL_READ
2469         # 4.15
2470         LIBCFS_LOCKDEP_IS_HELD
2471         LIBCFS_TIMER_SETUP
2472         # 4.16
2473         LIBCFS_HAVE_NS_TO_TIMESPEC64
2474         LIBCFS_WAIT_VAR_EVENT
2475         # 4.17
2476         LIBCFS_BITMAP_ALLOC
2477         LIBCFS_CLEAR_AND_WAKE_UP_BIT
2478         # 4.18
2479         LIBCFS_TCP_SOCK_SET_NODELAY
2480         LIBCFS_TCP_SOCK_SET_KEEPIDLE
2481         # 4.19
2482         LIBCFS_XARRAY_SUPPORT
2483         LIBCFS_NL_DUMP_EXT_ACK
2484         # 4.20
2485         LIBCFS_HAVE_IOV_ITER_TYPE
2486         # 5.0
2487         LIBCFS_MM_TOTALRAM_PAGES_FUNC
2488         LIBCFS_GET_REQUEST_KEY_AUTH
2489         # 5.2
2490         LIBCFS_KOBJ_TYPE_DEFAULT_GROUPS
2491         # 5.3
2492         LIBCFS_LOOKUP_USER_KEY
2493         LIBCFS_FORCE_SIG_WITH_TASK
2494         LIBCFS_CACHE_DETAIL_WRITERS
2495         # 5.4
2496         LIBCFS_GENL_DUMPIT_INFO
2497         # 5.6
2498         LIBCFS_HAVE_PROC_OPS
2499         # 5.7
2500         LIBCFS_TCP_SOCK_SET_QUICKACK
2501         LIBCFS_TCP_SOCK_SET_KEEPINTVL
2502         LIBCFS_TCP_SOCK_SET_KEEPCNT
2503         # 5.8
2504         LIBCFS_HAVE_NR_UNSTABLE_NFS
2505         LIBCFS_HAVE_MMAP_LOCK
2506         LIBCFS_KERNEL_SETSOCKOPT
2507         LIBCFS_IP6_SET_PREF
2508         LIBCFS_VMALLOC_2ARGS
2509         # 5.10
2510         LIBCFS_SEC_RELEASE_SECCTX
2511         LIBCFS_HAVE_KFREE_SENSITIVE
2512         LIBCFS_HAVE_LIST_CMP_FUNC_T
2513         LIBCFS_NLA_STRLCPY
2514         # 5.12
2515         LIBCFS_LINUX_FORTIFY_STRING_HEADER
2516         # 5.13
2517         LIBCFS_HAVE_TASK_IS_RUNNING
2518         LIBCFS_IOV_ITER_HAS_ITER_TYPE
2519         # 5.15
2520         LIBCFS_PARAM_SET_UINT_MINMAX
2521         # 5.17
2522         LIBCFS_PDE_DATA_EXISTS
2523         LIBCFS_BIO_ALLOC_WITH_BDEV
2524 ])
2525
2526 #
2527 # LIBCFS_PROG_LINUX
2528 #
2529 # LibCFS linux kernel checks
2530 #
2531 AC_DEFUN([LIBCFS_PROG_LINUX], [
2532 AC_MSG_NOTICE([LibCFS kernel checks
2533 ==============================================================================])
2534 LIBCFS_CONFIG_PANIC_DUMPLOG
2535
2536 # 4.6 - Header Check
2537 LIBCFS_STRINGHASH
2538 # 4.6 - Export Check
2539 LIBCFS_EXPORT_KSET_FIND_OBJ
2540 # 4.10 - Header Check
2541 LIBCFS_REFCOUNT_T
2542 # 4.11 - Header Check
2543 LIBCFS_SCHED_HEADERS
2544 # 4.13 - Header Checks
2545 LIBCFS_HAVE_PROCESSOR_HEADER
2546 LIBCFS_HAVE_WAIT_BIT_HEADER
2547 # 4.13 - Export Check
2548 LIBCFS_EXPORT_SAVE_STACK_TRACE_TSK
2549 # 5.0 - Header Check
2550 LIBCFS_GENRADIX
2551 # 5.7 - Export Check and Header Check
2552 LIBCFS_KALLSYMS_LOOKUP
2553 LIBCFS_HAVE_CRYPTO_SHA2_HEADER
2554 # 5.12 - Header Check
2555 LIBCFS_HAVE_CIPHER_HEADER
2556 # 5.14 - Header Checks
2557 LIBCFS_LINUX_STDARG_HEADER
2558 LIBCFS_HAVE_PANIC_NOTIFIER_HEADER
2559 # 5.15 - Header Check
2560 LIBCFS_LINUX_BLK_INTEGRITY_HEADER
2561 ]) # LIBCFS_PROG_LINUX
2562
2563 #
2564 # LIBCFS_PATH_DEFAULTS
2565 #
2566 # default paths for installed files
2567 #
2568 AC_DEFUN([LIBCFS_PATH_DEFAULTS], [
2569 ]) # LIBCFS_PATH_DEFAULTS
2570
2571 #
2572 # LIBCFS_CONFIGURE
2573 #
2574 # other configure checks
2575 #
2576 AC_DEFUN([LIBCFS_CONFIGURE], [
2577 AC_MSG_NOTICE([LibCFS core checks
2578 ==============================================================================])
2579
2580 # libcfs/libcfs/util/nidstrings.c
2581 AC_CHECK_HEADERS([netdb.h asm/types.h endian.h])
2582 AC_CHECK_FUNCS([gethostbyname])
2583
2584 # --------  Check for required packages  --------------
2585
2586 AC_MSG_NOTICE([LibCFS required packages checks
2587 ==============================================================================])
2588
2589 AC_MSG_CHECKING([whether to enable readline support])
2590 AC_ARG_ENABLE(readline,
2591         AS_HELP_STRING([--disable-readline],
2592                 [disable readline support]),
2593         [], [enable_readline="yes"])
2594 AC_MSG_RESULT([$enable_readline])
2595
2596 LIBREADLINE=""
2597 AS_IF([test "x$enable_readline" = xyes], [
2598         AC_CHECK_LIB([readline], [readline], [
2599                 LIBREADLINE="-lreadline"
2600                 AC_DEFINE(HAVE_LIBREADLINE, 1,
2601                         [readline library is available])
2602         ])
2603 ])
2604 AC_SUBST(LIBREADLINE)
2605
2606 AC_MSG_CHECKING([whether to use libpthread for libcfs library])
2607 AC_ARG_ENABLE([libpthread],
2608         AS_HELP_STRING([--disable-libpthread],
2609                 [disable libpthread]),
2610         [], [enable_libpthread="yes"])
2611 AC_MSG_RESULT([$enable_libpthread])
2612
2613 PTHREAD_LIBS=""
2614 AS_IF([test "x$enable_libpthread" = xyes], [
2615         AC_CHECK_LIB([pthread], [pthread_create], [
2616                 PTHREAD_LIBS="-lpthread"
2617                 AC_DEFINE([HAVE_LIBPTHREAD], 1,
2618                         [use libpthread for libcfs library])
2619         ])
2620 ], [
2621         AC_MSG_WARN([Using libpthread for libcfs library is disabled explicitly])
2622 ])
2623 AC_SUBST(PTHREAD_LIBS)
2624 ]) # LIBCFS_CONFIGURE
2625
2626 #
2627 # LIBCFS_CONFIG_FILES
2628 #
2629 # files that should be generated with AC_OUTPUT
2630 #
2631 AC_DEFUN([LIBCFS_CONFIG_FILES], [
2632 AC_CONFIG_FILES([
2633 libcfs/Makefile
2634 libcfs/autoMakefile
2635 libcfs/autoconf/Makefile
2636 libcfs/include/Makefile
2637 libcfs/include/libcfs/Makefile
2638 libcfs/include/uapi/Makefile
2639 libcfs/include/libcfs/linux/Makefile
2640 libcfs/include/libcfs/util/Makefile
2641 libcfs/include/libcfs/crypto/Makefile
2642 libcfs/include/uapi/linux/Makefile
2643 libcfs/libcfs/Makefile
2644 libcfs/libcfs/autoMakefile
2645 libcfs/libcfs/linux/Makefile
2646 libcfs/libcfs/util/Makefile
2647 libcfs/libcfs/crypto/Makefile
2648 ])
2649 ]) # LIBCFS_CONFIG_FILES