X-Git-Url: https://git.pld-linux.org/?a=blobdiff_plain;f=kernel-small_fixes.patch;h=b97c7aafdb86c3ebfb2d414fc39ae3dc41fbbff6;hb=679d237fdefebb21903f94f8dfb1dc357f852489;hp=a5fbdf6aa5812fa569ba393b7583607bf182ae82;hpb=53badc7f4955f109c2815063203b36e44c7918e2;p=packages%2Fkernel.git diff --git a/kernel-small_fixes.patch b/kernel-small_fixes.patch index a5fbdf6a..b97c7aaf 100644 --- a/kernel-small_fixes.patch +++ b/kernel-small_fixes.patch @@ -1,117 +1,40 @@ ---- linux-2.6.33/scripts/mod/modpost.c~ 2010-02-24 19:52:17.000000000 +0100 -+++ linux-2.6.33/scripts/mod/modpost.c 2010-03-07 14:26:47.242168558 +0100 -@@ -15,7 +15,8 @@ - #include - #include - #include "modpost.h" --#include "../../include/generated/autoconf.h" -+// PLD architectures don't use CONFIG_SYMBOL_PREFIX -+//#include "../../include/generated/autoconf.h" - #include "../../include/linux/license.h" - - /* Some toolchains use a `_' prefix for all user symbols. */ - ---- linux-3.0/scripts/kconfig/lxdialog/check-lxdialog.sh~ 2011-07-22 04:17:23.000000000 +0200 -+++ linux-3.0/scripts/kconfig/lxdialog/check-lxdialog.sh 2011-08-25 21:26:04.799150642 +0200 -@@ -9,6 +9,12 @@ - $cc -print-file-name=lib${lib}.${ext} | grep -q / - if [ $? -eq 0 ]; then - echo "-l${lib}" -+ for libt in tinfow tinfo ; do -+ $cc -print-file-name=lib${libt}.${ext} | grep -q / -+ if [ $? -eq 0 ]; then -+ echo "-l${libt}" -+ fi -+ done - exit - fi - done - -From: Eric Sandeen -Subject: [PATCH] xfs: don't wrap ID in xfs_dq_get_next_id -Message-ID: -Date: Fri, 16 Dec 2016 18:05:20 -0600 - -The GETNEXTQOTA ioctl takes whatever ID is sent in, -and looks for the next active quota for an user -equal or higher to that ID. +From: Shaohua Li -But if we are at the maximum ID and then ask for the "next" -one, we may wrap back to zero. In this case, userspace -may loop forever, because it will start querying again -at zero. +Basically this is a copy of commit 001e4a8775f6(ext4: implement cgroup +writeback support). Tested with a fio test, verified writeback is +throttled against cgroup io.max write bandwidth, also verified moving +the fio test to another cgroup and the writeback is throttled against +new cgroup setting. -We'll fix this in userspace as well, but for the kernel, -return -ENOENT if we ask for the next quota ID -past UINT_MAX so the caller knows to stop. - -Signed-off-by: Eric Sandeen +Cc: Tejun Heo +Signed-off-by: Shaohua Li --- - -diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c -index 7a30b8f..dbeddd9 100644 ---- a/fs/xfs/xfs_dquot.c -+++ b/fs/xfs/xfs_dquot.c -@@ -710,6 +710,10 @@ - /* Simple advance */ - next_id = *id + 1; + fs/xfs/xfs_aops.c | 2 ++ + fs/xfs/xfs_super.c | 1 + + 2 files changed, 3 insertions(+) + +--- linux-4.19/fs/xfs/xfs_aops.c.org 2018-11-21 10:31:12.348955352 +0100 ++++ linux-4.19/fs/xfs/xfs_aops.c 2018-11-21 10:34:35.241764742 +0100 +@@ -613,8 +613,10 @@ xfs_add_to_ioend( + list_add(&wpc->ioend->io_list, iolist); + wpc->ioend = xfs_alloc_ioend(inode, wpc->io_type, offset, + bdev, sector); ++ wbc_init_bio(wbc, wpc->ioend->io_bio); + } -+ /* If we'd wrap past the max ID, stop */ -+ if (next_id < *id) -+ return -ENOENT; -+ - /* If new ID is within the current chunk, advancing it sufficed */ - if (next_id % mp->m_quotainfo->qi_dqperchunk) { - *id = next_id; - -From: Brian Foster -Subject: [PATCH] xfs: prevent quotacheck from overloading inode lru - -Quotacheck runs at mount time in situations where quota accounting must -be recalculated. In doing so, it uses bulkstat to visit every inode in -the filesystem. Historically, every inode processed during quotacheck -was released and immediately tagged for reclaim because quotacheck runs -before the superblock is marked active by the VFS. In other words, -the final iput() lead to an immediate ->destroy_inode() call, which -allowed the XFS background reclaim worker to start reclaiming inodes. - -Commit 17c12bcd3 ("xfs: when replaying bmap operations, don't let -unlinked inodes get reaped") marks the XFS superblock active sooner as -part of the mount process to support caching inodes processed during log -recovery. This occurs before quotacheck and thus means all inodes -processed by quotacheck are inserted to the LRU on release. The -s_umount lock is held until the mount has completed and thus prevents -the shrinkers from operating on the sb. This means that quotacheck can -excessively populate the inode LRU and lead to OOM conditions on systems -without sufficient RAM. - -Update the quotacheck bulkstat handler to set XFS_IGET_DONTCACHE on -inodes processed by quotacheck. This causes ->drop_inode() to return 1 -and in turn causes iput_final() to evict the inode. This preserves the -original quotacheck behavior and prevents it from overloading the LRU -and running out of memory. - -CC: stable@vger.kernel.org # v4.9 -Reported-by: Martin Svec -Signed-off-by: Brian Foster ---- - fs/xfs/xfs_qm.c | 3 ++- - 1 file changed, 2 insertions(+), 1 deletion(-) - -diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c -index 45e50ea..b669b12 100644 ---- a/fs/xfs/xfs_qm.c -+++ b/fs/xfs/xfs_qm.c -@@ -1177,7 +1177,8 @@ xfs_qm_dqusage_adjust( - * the case in all other instances. It's OK that we do this because - * quotacheck is done only at mount time. - */ -- error = xfs_iget(mp, NULL, ino, 0, XFS_ILOCK_EXCL, &ip); -+ error = xfs_iget(mp, NULL, ino, XFS_IGET_DONTCACHE, XFS_ILOCK_EXCL, -+ &ip); - if (error) { - *res = BULKSTAT_RV_NOTHING; - return error; --- -2.7.4 - ++ wbc_account_io(wbc, page, len); + if (!__bio_try_merge_page(wpc->ioend->io_bio, page, len, poff)) { + if (iop) + atomic_inc(&iop->write_count); +diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c +index 584cf2d..aea3bc2 100644 +--- a/fs/xfs/xfs_super.c ++++ b/fs/xfs/xfs_super.c +@@ -1634,6 +1634,7 @@ xfs_fs_fill_super( + sb->s_max_links = XFS_MAXLINK; + sb->s_time_gran = 1; + set_posix_acl_flag(sb); ++ sb->s_iflags |= SB_I_CGROUPWB; + + /* version 5 superblocks support inode version counters. */ + if (XFS_SB_VERSION_NUM(&mp->m_sb) == XFS_SB_VERSION_5)