5:22 p.m.
tree: https://git.kernel.org/pub/scm/linux/kernel/git/djwong/xfs-linux.git
scrub-rtsummary
head: 6a3195f0b8086aa941c656f91b7a0498e15aad0d
commit: 6fdc49bc994d255e80d09aece3521849005b956a [23/25] xfs: create a big array data
structure
config: x86_64-kexec (attached as .config)
compiler: gcc-9 (Debian 9.3.0-13) 9.3.0
reproduce (this is a W=1 build):
git checkout 6fdc49bc994d255e80d09aece3521849005b956a
# save the attached .config to linux build tree
make W=1 ARCH=x86_64
If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot <lkp(a)intel.com>
All errors (new ones prefixed by >>):
fs/xfs/scrub/array.c: In function 'xfbma_sort':
> fs/xfs/scrub/array.c:627:2: error: implicit declaration of
function 'trace_xfbma_sort_stats' [-Werror=implicit-function-declaration]
627 | trace_xfbma_sort_stats(array->nr, max_stack_depth, max_stack_used,
| ^~~~~~~~~~~~~~~~~~~~~~
cc1: some warnings being treated as errors
vim +/trace_xfbma_sort_stats +627 fs/xfs/scrub/array.c
468
469 /*
470 * For array subsets smaller than 4 elements, it's slightly faster to use
471 * insertion sort than quicksort's stack machine.
472 */
473 #define ISORT_THRESHOLD (4)
474 int
475 xfbma_sort(
476 struct xfbma *array,
477 xfbma_cmp_fn cmp_fn)
478 {
479 int64_t *stack;
480 int64_t *beg;
481 int64_t *end;
482 void *pivot = xfbma_temp(array, 0);
483 void *temp = xfbma_temp(array, 1);
484 int64_t lo, mid, hi;
485 const int max_stack_depth = ilog2(array->nr) + 1;
486 int stack_depth = 0;
487 int max_stack_used = 0;
488 int error = 0;
489
490 if (array->nr == 0)
491 return 0;
492 if (array->nr >= QSORT_MAX_RECS)
493 return -E2BIG;
494 if (array->nr <= ISORT_THRESHOLD)
495 return xfbma_isort(array, cmp_fn, 0, array->nr - 1);
496
497 /* Allocate our pointer stacks for sorting. */
498 stack = kmem_alloc(sizeof(int64_t) * 2 * max_stack_depth,
499 KM_NOFS | KM_MAYFAIL);
500 if (!stack)
501 return -ENOMEM;
502 beg = stack;
503 end = &stack[max_stack_depth];
504
505 beg[0] = 0;
506 end[0] = array->nr;
507 while (stack_depth >= 0) {
508 lo = beg[stack_depth];
509 hi = end[stack_depth] - 1;
510
511 /* Nothing left in this partition to sort; pop stack. */
512 if (lo >= hi) {
513 stack_depth--;
514 continue;
515 }
516
517 /* Small enough for insertion sort? */
518 if (hi - lo <= ISORT_THRESHOLD) {
519 error = xfbma_isort(array, cmp_fn, lo, hi);
520 if (error)
521 goto out_free;
522 stack_depth--;
523 continue;
524 }
525
526 /* Pick a pivot, move it to a[lo] and stash it. */
527 mid = lo + ((hi - lo) / 2);
528 error = xfbma_qsort_pivot(array, cmp_fn, lo, mid, hi);
529 if (error)
530 goto out_free;
531
532 error = xfbma_get(array, lo, pivot);
533 if (error)
534 goto out_free;
535
536 /*
537 * Rearrange a[lo..hi] such that everything smaller than the
538 * pivot is on the left side of the range and everything larger
539 * than the pivot is on the right side of the range.
540 */
541 while (lo < hi) {
542 /*
543 * Decrement hi until it finds an a[hi] less than the
544 * pivot value.
545 */
546 error = xfbma_get(array, hi, temp);
547 if (error)
548 goto out_free;
549 while (cmp_fn(temp, pivot) >= 0 && lo < hi) {
550 hi--;
551 error = xfbma_get(array, hi, temp);
552 if (error)
553 goto out_free;
554 }
555
556 /* Copy that item (a[hi]) to a[lo]. */
557 if (lo < hi) {
558 error = xfbma_set(array, lo++, temp);
559 if (error)
560 goto out_free;
561 }
562
563 /*
564 * Increment lo until it finds an a[lo] greater than
565 * the pivot value.
566 */
567 error = xfbma_get(array, lo, temp);
568 if (error)
569 goto out_free;
570 while (cmp_fn(temp, pivot) <= 0 && lo < hi) {
571 lo++;
572 error = xfbma_get(array, lo, temp);
573 if (error)
574 goto out_free;
575 }
576
577 /* Copy that item (a[lo]) to a[hi]. */
578 if (lo < hi) {
579 error = xfbma_set(array, hi--, temp);
580 if (error)
581 goto out_free;
582 }
583 }
584
585 /*
586 * Put our pivot value in the correct place at a[lo]. All
587 * values between a[beg[i]] and a[lo - 1] should be less than
588 * the pivot; and all values between a[lo + 1] and a[end[i]-1]
589 * should be greater than the pivot.
590 */
591 error = xfbma_set(array, lo, pivot);
592 if (error)
593 goto out_free;
594
595 /*
596 * Set up the pointers for the next iteration. We push onto
597 * the stack all of the unsorted values between a[lo + 1] and
598 * a[end[i]], and we tweak the current stack frame to point to
599 * the unsorted values between a[beg[i]] and a[lo] so that
600 * those values will be sorted when we pop the stack.
601 */
602 beg[stack_depth + 1] = lo + 1;
603 end[stack_depth + 1] = end[stack_depth];
604 end[stack_depth++] = lo;
605
606 /* Check our stack usage. */
607 max_stack_used = max(max_stack_used, stack_depth);
608 if (stack_depth >= max_stack_depth) {
609 ASSERT(0);
610 error = -EFSCORRUPTED;
611 goto out_free;
612 }
613
614 /*
615 * Always start with the smaller of the two partitions to keep
616 * the amount of recursion in check.
617 */
618 if (end[stack_depth] - beg[stack_depth] >
619 end[stack_depth - 1] - beg[stack_depth - 1]) {
620 swap(beg[stack_depth], beg[stack_depth - 1]);
621 swap(end[stack_depth], end[stack_depth - 1]);
622 }
623 }
624
625 out_free:
626 kfree(stack);
627 trace_xfbma_sort_stats(array->nr, max_stack_depth,
max_stack_used,
628 error);
629 return error;
630 }
631
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org