Hi Hillf, [FYI, it's a private test report for your RFC patch.] [auto build test ERROR on linus/master] [cannot apply to v5.4-rc2 next-20191011] [if your patch is applied to the wrong git tree, please drop us a note to help improve the system. BTW, we also suggest to use '--base' option to specify the base tree in git format-patch, please see https://stackoverflow.com/a/37406982] url: https://github.com/0day-ci/linux/commits/Hillf-Danton/writeback-add-elast... config: sh-allmodconfig (attached as .config) compiler: sh4-linux-gcc (GCC) 7.4.0 reproduce: wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross # save the attached .config to linux build tree GCC_VERSION=7.4.0 make.cross ARCH=sh If you fix the issue, kindly add following tag Reported-by: kbuild test robot <lkp(a)intel.com&gt; All errors (new ones prefixed by >>): fs/fs-writeback.c: In function 'wbc_detach_inode': if (waitqueue_active(&wb->bdp_waitq)) ^~ In file included from include/linux/mmzone.h:10:0, from include/linux/gfp.h:6, from include/linux/slab.h:15, from fs/fs-writeback.c:20: fs/fs-writeback.c:638:19: error: 'struct bdi_writeback' has no member named 'bdp_waitq' wake_up_all(&wb->bdp_waitq); ^ include/linux/wait.h:210:36: note: in definition of macro 'wake_up_all' #define wake_up_all(x) __wake_up(x, TASK_NORMAL, 0, NULL) ^ vim +637 fs/fs-writeback.c 586 587 /** 588 * wbc_detach_inode - disassociate wbc from inode and perform foreign detection 589 * @wbc: writeback_control of the just finished writeback 590 * 591 * To be called after a writeback attempt of an inode finishes and undoes 592 * wbc_attach_and_unlock_inode(). Can be called under any context. 593 * 594 * As concurrent write sharing of an inode is expected to be very rare and 595 * memcg only tracks page ownership on first-use basis severely confining 596 * the usefulness of such sharing, cgroup writeback tracks ownership 597 * per-inode. While the support for concurrent write sharing of an inode 598 * is deemed unnecessary, an inode being written to by different cgroups at 599 * different points in time is a lot more common, and, more importantly, 600 * charging only by first-use can too readily lead to grossly incorrect 601 * behaviors (single foreign page can lead to gigabytes of writeback to be 602 * incorrectly attributed). 603 * 604 * To resolve this issue, cgroup writeback detects the majority dirtier of 605 * an inode and transfers the ownership to it. To avoid unnnecessary 606 * oscillation, the detection mechanism keeps track of history and gives 607 * out the switch verdict only if the foreign usage pattern is stable over 608 * a certain amount of time and/or writeback attempts. 609 * 610 * On each writeback attempt, @wbc tries to detect the majority writer 611 * using Boyer-Moore majority vote algorithm. In addition to the byte 612 * count from the majority voting, it also counts the bytes written for the 613 * current wb and the last round's winner wb (max of last round's current 614 * wb, the winner from two rounds ago, and the last round's majority 615 * candidate). Keeping track of the historical winner helps the algorithm 616 * to semi-reliably detect the most active writer even when it's not the 617 * absolute majority. 618 * 619 * Once the winner of the round is determined, whether the winner is 620 * foreign or not and how much IO time the round consumed is recorded in 621 * inode->i_wb_frn_history. If the amount of recorded foreign IO time is 622 * over a certain threshold, the switch verdict is given. 623 */ 624 void wbc_detach_inode(struct writeback_control *wbc) 625 { 626 struct bdi_writeback *wb = wbc->wb; 627 struct inode *inode = wbc->inode; 628 unsigned long avg_time, max_bytes, max_time; 629 u16 history; 630 int max_id; 631 632 if (!wb) 633 return; 634 635 if (IS_ENABLED(CONFIG_CGROUP_WRITEBACK) && 636 IS_ENABLED(CONFIG_CGWB_BDP_WITH_EBDI)) 638 wake_up_all(&wb->bdp_waitq); 639 640 history = inode->i_wb_frn_history; 641 avg_time = inode->i_wb_frn_avg_time; 642 643 /* pick the winner of this round */ 644 if (wbc->wb_bytes >= wbc->wb_lcand_bytes && 645 wbc->wb_bytes >= wbc->wb_tcand_bytes) { 646 max_id = wbc->wb_id; 647 max_bytes = wbc->wb_bytes; 648 } else if (wbc->wb_lcand_bytes >= wbc->wb_tcand_bytes) { 649 max_id = wbc->wb_lcand_id; 650 max_bytes = wbc->wb_lcand_bytes; 651 } else { 652 max_id = wbc->wb_tcand_id; 653 max_bytes = wbc->wb_tcand_bytes; 654 } 655 656 /* 657 * Calculate the amount of IO time the winner consumed and fold it 658 * into the running average kept per inode. If the consumed IO 659 * time is lower than avag / WB_FRN_TIME_CUT_DIV, ignore it for 660 * deciding whether to switch or not. This is to prevent one-off 661 * small dirtiers from skewing the verdict. 662 */ 663 max_time = DIV_ROUND_UP((max_bytes >> PAGE_SHIFT) << WB_FRN_TIME_SHIFT, 664 wb->avg_write_bandwidth); 665 if (avg_time) 666 avg_time += (max_time >> WB_FRN_TIME_AVG_SHIFT) - 667 (avg_time >> WB_FRN_TIME_AVG_SHIFT); 668 else 669 avg_time = max_time; /* immediate catch up on first run */ 670 671 if (max_time >= avg_time / WB_FRN_TIME_CUT_DIV) { 672 int slots; 673 674 /* 675 * The switch verdict is reached if foreign wb's consume 676 * more than a certain proportion of IO time in a 677 * WB_FRN_TIME_PERIOD. This is loosely tracked by 16 slot 678 * history mask where each bit represents one sixteenth of 679 * the period. Determine the number of slots to shift into 680 * history from @max_time. 681 */ 682 slots = min(DIV_ROUND_UP(max_time, WB_FRN_HIST_UNIT), 683 (unsigned long)WB_FRN_HIST_MAX_SLOTS); 684 history <<= slots; 685 if (wbc->wb_id != max_id) 686 history |= (1U << slots) - 1; 687 688 if (history) 689 trace_inode_foreign_history(inode, wbc, history); 690 691 /* 692 * Switch if the current wb isn't the consistent winner. 693 * If there are multiple closely competing dirtiers, the 694 * inode may switch across them repeatedly over time, which 695 * is okay. The main goal is avoiding keeping an inode on 696 * the wrong wb for an extended period of time. 697 */ 698 if (hweight32(history) > WB_FRN_HIST_THR_SLOTS) 699 inode_switch_wbs(inode, max_id); 700 } 701 702 /* 703 * Multiple instances of this function may race to update the 704 * following fields but we don't mind occassional inaccuracies. 705 */ 706 inode->i_wb_frn_winner = max_id; 707 inode->i_wb_frn_avg_time = min(avg_time, (unsigned long)U16_MAX); 708 inode->i_wb_frn_history = history; 709 710 wb_put(wbc->wb); 711 wbc->wb = NULL; 712 } 713 EXPORT_SYMBOL_GPL(wbc_detach_inode); 714 --- 0-DAY kernel test infrastructure Open Source Technology Center https://lists.01.org/pipermail/kbuild-all Intel Corporation