---- 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 <stdio.h>
- #include <ctype.h>
- #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: Dave Chinner <dchinner@redhat.com>
-
-When we do inode readahead in log recovery, we do can do the
-readahead before we've replayed the icreate transaction that stamps
-the buffer with inode cores. The inode readahead verifier catches
-this and marks the buffer as !done to indicate that it doesn't yet
-contain valid inodes.
-
-In adding buffer error notification (i.e. setting b_error = -EIO at
-the same time as as we clear the done flag) to such a readahead
-verifier failure, we can then get subsequent inode recovery failing
-with this error:
-
-XFS (dm-0): metadata I/O error: block 0xa00060 ("xlog_recover_do..(read#2)") error 5 numblks 32
-
-This occurs when readahead completion races with icreate item replay
-such as:
-
- inode readahead
- find buffer
- lock buffer
- submit RA io
- ....
- icreate recovery
- xfs_trans_get_buffer
- find buffer
- lock buffer
- <blocks on RA completion>
- .....
- <ra completion>
- fails verifier
- clear XBF_DONE
- set bp->b_error = -EIO
- release and unlock buffer
- <icreate gains lock>
- icreate initialises buffer
- marks buffer as done
- adds buffer to delayed write queue
- releases buffer
-
-At this point, we have an initialised inode buffer that is up to
-date but has an -EIO state registered against it. When we finally
-get to recovering an inode in that buffer:
-
- inode item recovery
- xfs_trans_read_buffer
- find buffer
- lock buffer
- sees XBF_DONE is set, returns buffer
- sees bp->b_error is set
- fail log recovery!
-
-Essentially, we need xfs_trans_get_buf_map() to clear the error status of
-the buffer when doing a lookup. This function returns uninitialised
-buffers, so the buffer returned can not be in an error state and
-none of the code that uses this function expects b_error to be set
-on return. Indeed, there is an ASSERT(!bp->b_error); in the
-transaction case in xfs_trans_get_buf_map() that would have caught
-this if log recovery used transactions....
-
-This patch firstly changes the inode readahead failure to set -EIO
-on the buffer, and secondly changes xfs_buf_get_map() to never
-return a buffer with an error state set so this first change doesn't
-cause unexpected log recovery failures.
-
-Signed-off-by: Dave Chinner <dchinner@redhat.com>
+--- linux-5.1/net/sunrpc/Kconfig~ 2019-05-06 02:42:58.000000000 +0200
++++ linux-5.1/net/sunrpc/Kconfig 2019-05-10 12:54:36.566903892 +0200
+@@ -34,7 +34,7 @@ config RPCSEC_GSS_KRB5
+
+ If unsure, say Y.
+
+-config CONFIG_SUNRPC_DISABLE_INSECURE_ENCTYPES
++config SUNRPC_DISABLE_INSECURE_ENCTYPES
+ bool "Secure RPC: Disable insecure Kerberos encryption types"
+ depends on RPCSEC_GSS_KRB5
+ default n
+Move setting up operation and write hint to xfs_alloc_ioend, and
+then just copy over all needed information from the previous bio
+in xfs_chain_bio and stop passing various parameters to it.
+
+Signed-off-by: Christoph Hellwig <hch@lst.de>
---
- fs/xfs/libxfs/xfs_inode_buf.c | 12 +++++++-----
- fs/xfs/xfs_buf.c | 7 +++++++
- 2 files changed, 14 insertions(+), 5 deletions(-)
-
-diff --git a/fs/xfs/libxfs/xfs_inode_buf.c b/fs/xfs/libxfs/xfs_inode_buf.c
-index 1b8d98a..ff17c48 100644
---- a/fs/xfs/libxfs/xfs_inode_buf.c
-+++ b/fs/xfs/libxfs/xfs_inode_buf.c
-@@ -62,11 +62,12 @@ xfs_inobp_check(
- * has not had the inode cores stamped into it. Hence for readahead, the buffer
- * may be potentially invalid.
- *
-- * If the readahead buffer is invalid, we don't want to mark it with an error,
-- * but we do want to clear the DONE status of the buffer so that a followup read
-- * will re-read it from disk. This will ensure that we don't get an unnecessary
-- * warnings during log recovery and we don't get unnecssary panics on debug
-- * kernels.
-+ * If the readahead buffer is invalid, we need to mark it with an error and
-+ * clear the DONE status of the buffer so that a followup read will re-read it
-+ * from disk. We don't report the error otherwise to avoid warnings during log
-+ * recovery and we don't get unnecssary panics on debug kernels. We use EIO here
-+ * because all we want to do is say readahead failed; there is no-one to report
-+ * the error to, so this will distinguish it from a non-ra verifier failure.
- */
- static void
- xfs_inode_buf_verify(
-@@ -93,6 +94,7 @@ xfs_inode_buf_verify(
- XFS_RANDOM_ITOBP_INOTOBP))) {
- if (readahead) {
- bp->b_flags &= ~XBF_DONE;
-+ xfs_buf_ioerror(bp, -EIO);
- return;
- }
-
-diff --git a/fs/xfs/xfs_buf.c b/fs/xfs/xfs_buf.c
-index 45a8ea7..ae86b16 100644
---- a/fs/xfs/xfs_buf.c
-+++ b/fs/xfs/xfs_buf.c
-@@ -604,6 +604,13 @@ found:
- }
+ fs/xfs/xfs_aops.c | 35 +++++++++++++++++------------------
+ 1 file changed, 17 insertions(+), 18 deletions(-)
+
+diff --git a/fs/xfs/xfs_aops.c b/fs/xfs/xfs_aops.c
+index a6f0f4761a37..9cceb90e77c5 100644
+--- a/fs/xfs/xfs_aops.c
++++ b/fs/xfs/xfs_aops.c
+@@ -665,7 +665,6 @@ xfs_submit_ioend(
+
+ ioend->io_bio->bi_private = ioend;
+ ioend->io_bio->bi_end_io = xfs_end_bio;
+- ioend->io_bio->bi_opf = REQ_OP_WRITE | wbc_to_write_flags(wbc);
+
+ /*
+ * If we are failing the IO now, just mark the ioend with an
+@@ -679,7 +678,6 @@ xfs_submit_ioend(
+ return status;
}
-+ /*
-+ * Clear b_error if this is a lookup from a caller that doesn't expect
-+ * valid data to be found in the buffer.
-+ */
-+ if (!(flags & XBF_READ))
-+ xfs_buf_ioerror(bp, 0);
-+
- XFS_STATS_INC(target->bt_mount, xb_get);
- trace_xfs_buf_get(bp, flags, _RET_IP_);
- return bp;
---
-2.5.0
-
-_______________________________________________
-xfs mailing list
-xfs@oss.sgi.com
-http://oss.sgi.com/mailman/listinfo/xfs
-From: Dave Chinner <dchinner@redhat.com>
-
-When we do dquot readahead in log recovery, we do not use a verifier
-as the underlying buffer may not have dquots in it. e.g. the
-allocation operation hasn't yet been replayed. Hence we do not want
-to fail recovery because we detect an operation to be replayed has
-not been run yet. This problem was addressed for inodes in commit
-d891400 ("xfs: inode buffers may not be valid during recovery
-readahead") but the problem was not recognised to exist for dquots
-and their buffers as the dquot readahead did not have a verifier.
-
-The result of not using a verifier is that when the buffer is then
-next read to replay a dquot modification, the dquot buffer verifier
-will only be attached to the buffer if *readahead is not complete*.
-Hence we can read the buffer, replay the dquot changes and then add
-it to the delwri submission list without it having a verifier
-attached to it. This then generates warnings in xfs_buf_ioapply(),
-which catches and warns about this case.
-
-Fix this and make it handle the same readahead verifier error cases
-as for inode buffers by adding a new readahead verifier that has a
-write operation as well as a read operation that marks the buffer as
-not done if any corruption is detected. Also make sure we don't run
-readahead if the dquot buffer has been marked as cancelled by
-recovery.
-
-This will result in readahead either succeeding and the buffer
-having a valid write verifier, or readahead failing and the buffer
-state requiring the subsequent read to resubmit the IO with the new
-verifier. In either case, this will result in the buffer always
-ending up with a valid write verifier on it.
-
-Note: we also need to fix the inode buffer readahead error handling
-to mark the buffer with EIO. Brian noticed the code I copied from
-there wrong during review, so fix it at the same time. Add comments
-linking the two functions that handle readahead verifier errors
-together so we don't forget this behavioural link in future.
-
-cc: <stable@vger.kernel.org> # 3.12 - current
-Signed-off-by: Dave Chinner <dchinner@redhat.com>
-Reviewed-by: Brian Foster <bfoster@redhat.com>
-Signed-off-by: Dave Chinner <david@fromorbit.com>
----
- fs/xfs/libxfs/xfs_dquot_buf.c | 36 ++++++++++++++++++++++++++++++------
- fs/xfs/libxfs/xfs_inode_buf.c | 2 ++
- fs/xfs/libxfs/xfs_quota_defs.h | 2 +-
- fs/xfs/libxfs/xfs_shared.h | 1 +
- fs/xfs/xfs_log_recover.c | 9 +++++++--
- 5 files changed, 41 insertions(+), 9 deletions(-)
-
-diff --git a/fs/xfs/libxfs/xfs_dquot_buf.c b/fs/xfs/libxfs/xfs_dquot_buf.c
-index 11cefb2..3cc3cf7 100644
---- a/fs/xfs/libxfs/xfs_dquot_buf.c
-+++ b/fs/xfs/libxfs/xfs_dquot_buf.c
-@@ -54,7 +54,7 @@ xfs_dqcheck(
- xfs_dqid_t id,
- uint type, /* used only when IO_dorepair is true */
- uint flags,
-- char *str)
-+ const char *str)
+- ioend->io_bio->bi_write_hint = ioend->io_inode->i_write_hint;
+ submit_bio(ioend->io_bio);
+ return 0;
+ }
+@@ -691,7 +689,8 @@ xfs_alloc_ioend(
+ xfs_exntst_t state,
+ xfs_off_t offset,
+ struct block_device *bdev,
+- sector_t sector)
++ sector_t sector,
++ struct writeback_control *wbc)
{
- xfs_dqblk_t *d = (xfs_dqblk_t *)ddq;
- int errs = 0;
-@@ -207,7 +207,8 @@ xfs_dquot_buf_verify_crc(
- STATIC bool
- xfs_dquot_buf_verify(
- struct xfs_mount *mp,
-- struct xfs_buf *bp)
-+ struct xfs_buf *bp,
-+ int warn)
+ struct xfs_ioend *ioend;
+ struct bio *bio;
+@@ -699,6 +698,8 @@ xfs_alloc_ioend(
+ bio = bio_alloc_bioset(GFP_NOFS, BIO_MAX_PAGES, &xfs_ioend_bioset);
+ bio_set_dev(bio, bdev);
+ bio->bi_iter.bi_sector = sector;
++ bio->bi_opf = REQ_OP_WRITE | wbc_to_write_flags(wbc);
++ bio->bi_write_hint = inode->i_write_hint;
+
+ ioend = container_of(bio, struct xfs_ioend, io_inline_bio);
+ INIT_LIST_HEAD(&ioend->io_list);
+@@ -719,24 +720,22 @@ xfs_alloc_ioend(
+ * so that the bi_private linkage is set up in the right direction for the
+ * traversal in xfs_destroy_ioend().
+ */
+-static void
++static struct bio *
+ xfs_chain_bio(
+- struct xfs_ioend *ioend,
+- struct writeback_control *wbc,
+- struct block_device *bdev,
+- sector_t sector)
++ struct bio *prev)
{
- struct xfs_dqblk *d = (struct xfs_dqblk *)bp->b_addr;
- xfs_dqid_t id = 0;
-@@ -240,8 +241,7 @@ xfs_dquot_buf_verify(
- if (i == 0)
- id = be32_to_cpu(ddq->d_id);
-
-- error = xfs_dqcheck(mp, ddq, id + i, 0, XFS_QMOPT_DOWARN,
-- "xfs_dquot_buf_verify");
-+ error = xfs_dqcheck(mp, ddq, id + i, 0, warn, __func__);
- if (error)
- return false;
- }
-@@ -256,7 +256,7 @@ xfs_dquot_buf_read_verify(
-
- if (!xfs_dquot_buf_verify_crc(mp, bp))
- xfs_buf_ioerror(bp, -EFSBADCRC);
-- else if (!xfs_dquot_buf_verify(mp, bp))
-+ else if (!xfs_dquot_buf_verify(mp, bp, XFS_QMOPT_DOWARN))
- xfs_buf_ioerror(bp, -EFSCORRUPTED);
-
- if (bp->b_error)
-@@ -264,6 +264,25 @@ xfs_dquot_buf_read_verify(
+ struct bio *new;
+
+ new = bio_alloc(GFP_NOFS, BIO_MAX_PAGES);
+- bio_set_dev(new, bdev);
+- new->bi_iter.bi_sector = sector;
+- bio_chain(ioend->io_bio, new);
+- bio_get(ioend->io_bio); /* for xfs_destroy_ioend */
+- ioend->io_bio->bi_opf = REQ_OP_WRITE | wbc_to_write_flags(wbc);
+- ioend->io_bio->bi_write_hint = ioend->io_inode->i_write_hint;
+- submit_bio(ioend->io_bio);
+- ioend->io_bio = new;
++ bio_copy_dev(new, prev);
++ new->bi_iter.bi_sector = bio_end_sector(prev);
++ new->bi_opf = prev->bi_opf;
++ new->bi_write_hint = prev->bi_write_hint;
++
++ bio_chain(prev, new);
++ bio_get(prev); /* for xfs_destroy_ioend */
++ submit_bio(prev);
++ return new;
}
/*
-+ * readahead errors are silent and simply leave the buffer as !done so a real
-+ * read will then be run with the xfs_dquot_buf_ops verifier. See
-+ * xfs_inode_buf_verify() for why we use EIO and ~XBF_DONE here rather than
-+ * reporting the failure.
-+ */
-+static void
-+xfs_dquot_buf_readahead_verify(
-+ struct xfs_buf *bp)
-+{
-+ struct xfs_mount *mp = bp->b_target->bt_mount;
-+
-+ if (!xfs_dquot_buf_verify_crc(mp, bp) ||
-+ !xfs_dquot_buf_verify(mp, bp, 0)) {
-+ xfs_buf_ioerror(bp, -EIO);
-+ bp->b_flags &= ~XBF_DONE;
-+ }
-+}
-+
-+/*
- * we don't calculate the CRC here as that is done when the dquot is flushed to
- * the buffer after the update is done. This ensures that the dquot in the
- * buffer always has an up-to-date CRC value.
-@@ -274,7 +293,7 @@ xfs_dquot_buf_write_verify(
- {
- struct xfs_mount *mp = bp->b_target->bt_mount;
-
-- if (!xfs_dquot_buf_verify(mp, bp)) {
-+ if (!xfs_dquot_buf_verify(mp, bp, XFS_QMOPT_DOWARN)) {
- xfs_buf_ioerror(bp, -EFSCORRUPTED);
- xfs_verifier_error(bp);
- return;
-@@ -287,3 +306,8 @@ const struct xfs_buf_ops xfs_dquot_buf_ops = {
- .verify_write = xfs_dquot_buf_write_verify,
- };
-
-+const struct xfs_buf_ops xfs_dquot_buf_ra_ops = {
-+
-+ .verify_read = xfs_dquot_buf_readahead_verify,
-+ .verify_write = xfs_dquot_buf_write_verify,
-+};
-diff --git a/fs/xfs/libxfs/xfs_inode_buf.c b/fs/xfs/libxfs/xfs_inode_buf.c
-index ff17c48..1aabfda 100644
---- a/fs/xfs/libxfs/xfs_inode_buf.c
-+++ b/fs/xfs/libxfs/xfs_inode_buf.c
-@@ -68,6 +68,8 @@ xfs_inobp_check(
- * recovery and we don't get unnecssary panics on debug kernels. We use EIO here
- * because all we want to do is say readahead failed; there is no-one to report
- * the error to, so this will distinguish it from a non-ra verifier failure.
-+ * Changes to this readahead error behavour also need to be reflected in
-+ * xfs_dquot_buf_readahead_verify().
- */
- static void
- xfs_inode_buf_verify(
-diff --git a/fs/xfs/libxfs/xfs_quota_defs.h b/fs/xfs/libxfs/xfs_quota_defs.h
-index 1b0a083..f51078f 100644
---- a/fs/xfs/libxfs/xfs_quota_defs.h
-+++ b/fs/xfs/libxfs/xfs_quota_defs.h
-@@ -153,7 +153,7 @@ typedef __uint16_t xfs_qwarncnt_t;
- #define XFS_QMOPT_RESBLK_MASK (XFS_QMOPT_RES_REGBLKS | XFS_QMOPT_RES_RTBLKS)
-
- extern int xfs_dqcheck(struct xfs_mount *mp, xfs_disk_dquot_t *ddq,
-- xfs_dqid_t id, uint type, uint flags, char *str);
-+ xfs_dqid_t id, uint type, uint flags, const char *str);
- extern int xfs_calc_dquots_per_chunk(unsigned int nbblks);
-
- #endif /* __XFS_QUOTA_H__ */
-diff --git a/fs/xfs/libxfs/xfs_shared.h b/fs/xfs/libxfs/xfs_shared.h
-index 5be5297..15c3ceb 100644
---- a/fs/xfs/libxfs/xfs_shared.h
-+++ b/fs/xfs/libxfs/xfs_shared.h
-@@ -49,6 +49,7 @@ extern const struct xfs_buf_ops xfs_inobt_buf_ops;
- extern const struct xfs_buf_ops xfs_inode_buf_ops;
- extern const struct xfs_buf_ops xfs_inode_buf_ra_ops;
- extern const struct xfs_buf_ops xfs_dquot_buf_ops;
-+extern const struct xfs_buf_ops xfs_dquot_buf_ra_ops;
- extern const struct xfs_buf_ops xfs_sb_buf_ops;
- extern const struct xfs_buf_ops xfs_sb_quiet_buf_ops;
- extern const struct xfs_buf_ops xfs_symlink_buf_ops;
-diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
-index c5ecaac..5991cdc 100644
---- a/fs/xfs/xfs_log_recover.c
-+++ b/fs/xfs/xfs_log_recover.c
-@@ -3204,6 +3204,7 @@ xlog_recover_dquot_ra_pass2(
- struct xfs_disk_dquot *recddq;
- struct xfs_dq_logformat *dq_f;
- uint type;
-+ int len;
-
+@@ -772,7 +772,7 @@ xfs_add_to_ioend(
+ if (wpc->ioend)
+ list_add(&wpc->ioend->io_list, iolist);
+ wpc->ioend = xfs_alloc_ioend(inode, wpc->fork,
+- wpc->imap.br_state, offset, bdev, sector);
++ wpc->imap.br_state, offset, bdev, sector, wbc);
+ }
- if (mp->m_qflags == 0)
-@@ -3224,8 +3225,12 @@ xlog_recover_dquot_ra_pass2(
- ASSERT(dq_f);
- ASSERT(dq_f->qlf_len == 1);
+ merged = __bio_try_merge_page(wpc->ioend->io_bio, page, len, poff,
+@@ -783,7 +783,7 @@ xfs_add_to_ioend(
-- xfs_buf_readahead(mp->m_ddev_targp, dq_f->qlf_blkno,
-- XFS_FSB_TO_BB(mp, dq_f->qlf_len), NULL);
-+ len = XFS_FSB_TO_BB(mp, dq_f->qlf_len);
-+ if (xlog_peek_buffer_cancelled(log, dq_f->qlf_blkno, len, 0))
-+ return;
-+
-+ xfs_buf_readahead(mp->m_ddev_targp, dq_f->qlf_blkno, len,
-+ &xfs_dquot_buf_ra_ops);
- }
+ if (!merged) {
+ if (bio_full(wpc->ioend->io_bio))
+- xfs_chain_bio(wpc->ioend, wbc, bdev, sector);
++ wpc->ioend->io_bio = xfs_chain_bio(wpc->ioend->io_bio);
+ bio_add_page(wpc->ioend->io_bio, page, len, poff);
+ }
- STATIC void
--
-2.5.0
-
-_______________________________________________
-xfs mailing list
-xfs@oss.sgi.com
-http://oss.sgi.com/mailman/listinfo/xfs
-From david at fromorbit.com Tue Jan 12 23:12:48 2016
-From: david at fromorbit.com (Dave Chinner)
-Date: Wed, 13 Jan 2016 16:12:48 +1100
-Subject: [PATCH] Revert "xfs: clear PF_NOFREEZE for xfsaild kthread"
-Message-ID: <1452661968-11482-1-git-send-email-david@fromorbit.com>
-Content-Length: 916
-Lines: 30
+2.20.1
-This reverts commit 24ba16bb3d499c49974669cd8429c3e4138ab102 as it
-prevents machines from suspending. This regression occurs when the
-xfsaild is idle on entry to suspend, and so there s no activity to
-wake it from it's idle sleep and hence see that it is supposed to
-freeze. Hence the freezer times out waiting for it and suspend is
-cancelled.
-There is no obvious fix for this short of freezing the filesystem
-properly, so revert this change for now.
+Link every newly allocated writeback bio to cgroup pointed to by the
+writeback control structure, and charge every byte written back to it.
-Signed-off-by: Dave Chinner <david at fromorbit.com>
+Tested-by: Stefan Priebe - Profihost AG <s.priebe@profihost.ag>
+Signed-off-by: Christoph Hellwig <hch@lst.de>
---
- fs/xfs/xfs_trans_ail.c | 1 -
- 1 file changed, 1 deletion(-)
-
-diff --git a/fs/xfs/xfs_trans_ail.c b/fs/xfs/xfs_trans_ail.c
-index aa67339..4f18fd9 100644
---- a/fs/xfs/xfs_trans_ail.c
-+++ b/fs/xfs/xfs_trans_ail.c
-@@ -497,7 +497,6 @@ xfsaild(
- long tout = 0; /* milliseconds */
+ fs/xfs/xfs_aops.c | 4 +++-
+ fs/xfs/xfs_super.c | 2 ++
+ 2 files changed, 5 insertions(+), 1 deletion(-)
+
+diff --git a/fs/xfs/xfs_aops.c b/fs/xfs/xfs_aops.c
+index 9cceb90e77c5..73c291aeae17 100644
+--- a/fs/xfs/xfs_aops.c
++++ b/fs/xfs/xfs_aops.c
+@@ -700,6 +700,7 @@ xfs_alloc_ioend(
+ bio->bi_iter.bi_sector = sector;
+ bio->bi_opf = REQ_OP_WRITE | wbc_to_write_flags(wbc);
+ bio->bi_write_hint = inode->i_write_hint;
++ wbc_init_bio(wbc, bio);
+
+ ioend = container_of(bio, struct xfs_ioend, io_inline_bio);
+ INIT_LIST_HEAD(&ioend->io_list);
+@@ -727,7 +728,7 @@ xfs_chain_bio(
+ struct bio *new;
+
+ new = bio_alloc(GFP_NOFS, BIO_MAX_PAGES);
+- bio_copy_dev(new, prev);
++ bio_copy_dev(new, prev);/* also copies over blkcg information */
+ new->bi_iter.bi_sector = bio_end_sector(prev);
+ new->bi_opf = prev->bi_opf;
+ new->bi_write_hint = prev->bi_write_hint;
+@@ -782,6 +783,7 @@ xfs_add_to_ioend(
+ }
- current->flags |= PF_MEMALLOC;
-- set_freezable();
+ wpc->ioend->io_size += len;
++ wbc_account_io(wbc, page, len);
+ }
+
+ STATIC void
+diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c
+index 594c119824cc..ee0df8f611ff 100644
+--- a/fs/xfs/xfs_super.c
++++ b/fs/xfs/xfs_super.c
+@@ -1685,6 +1685,8 @@ xfs_fs_fill_super(
+ sb->s_maxbytes = xfs_max_file_offset(sb->s_blocksize_bits);
+ sb->s_max_links = XFS_MAXLINK;
+ sb->s_time_gran = 1;
++ sb->s_iflags |= SB_I_CGROUPWB;
++
+ set_posix_acl_flag(sb);
- while (!kthread_should_stop()) {
- if (tout && tout <= 20)
+ /* version 5 superblocks support inode version counters. */
--
-2.5.0
-From: Tetsuo Handa <penguin-kernel@i-love.sakura.ne.jp>
-Subject: mm, vmstat: fix wrong WQ sleep when memory reclaim doesn't make any progress
+2.20.1
-Jan Stancek has reported that system occasionally hanging after "oom01"
-testcase from LTP triggers OOM. Guessing from a result that there is a
-kworker thread doing memory allocation and the values between "Node 0
-Normal free:" and "Node 0 Normal:" differs when hanging, vmstat is not
-up-to-date for some reason.
-
-According to commit 373ccbe59270 ("mm, vmstat: allow WQ concurrency to
-discover memory reclaim doesn't make any progress"), it meant to force the
-kworker thread to take a short sleep, but it by error used
-schedule_timeout(1). We missed that schedule_timeout() in state
-TASK_RUNNING doesn't do anything.
-
-Fix it by using schedule_timeout_uninterruptible(1) which forces the
-kworker thread to take a short sleep in order to make sure that vmstat is
-up-to-date.
-
-Fixes: 373ccbe59270 ("mm, vmstat: allow WQ concurrency to discover memory reclaim doesn't make any progress")
-Signed-off-by: Tetsuo Handa <penguin-kernel@I-love.SAKURA.ne.jp>
-Reported-by: Jan Stancek <jstancek@redhat.com>
-Acked-by: Michal Hocko <mhocko@suse.com>
-Cc: Tejun Heo <tj@kernel.org>
-Cc: Cristopher Lameter <clameter@sgi.com>
-Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
-Cc: Arkadiusz Miskiewicz <arekm@maven.pl>
-Cc: <stable@vger.kernel.org>
-Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
----
-
- mm/backing-dev.c | 2 +-
- 1 file changed, 1 insertion(+), 1 deletion(-)
-
-diff -puN mm/backing-dev.c~mm-vmstat-fix-wrong-wq-sleep-when-memory-reclaim-doesnt-make-any-progress mm/backing-dev.c
---- a/mm/backing-dev.c~mm-vmstat-fix-wrong-wq-sleep-when-memory-reclaim-doesnt-make-any-progress
-+++ a/mm/backing-dev.c
-@@ -989,7 +989,7 @@ long wait_iff_congested(struct zone *zon
- * here rather than calling cond_resched().
- */
- if (current->flags & PF_WQ_WORKER)
-- schedule_timeout(1);
-+ schedule_timeout_uninterruptible(1);
- else
- cond_resched();
-
-_
projects / packages / kernel.git / blobdiff