From: Greg Kroah-Hartman Date: Wed, 2 Jul 2014 23:54:35 +0000 (-0700) Subject: 3.14-stable patches X-Git-Tag: v3.4.97~20 X-Git-Url: http://git.ipfire.org/gitweb.cgi?a=commitdiff_plain;h=ac5ee2e1690ca67ef56626c55b4cb45ed92a38cc;p=thirdparty%2Fkernel%2Fstable-queue.git 3.14-stable patches added patches: reiserfs-call-truncate_setsize-under-tailpack-mutex.patch xfs-block-allocation-work-needs-to-be-kswapd-aware.patch xfs-xfs_readsb-needs-to-check-for-magic-numbers.patch --- diff --git a/queue-3.14/reiserfs-call-truncate_setsize-under-tailpack-mutex.patch b/queue-3.14/reiserfs-call-truncate_setsize-under-tailpack-mutex.patch new file mode 100644 index 00000000000..aa151e54301 --- /dev/null +++ b/queue-3.14/reiserfs-call-truncate_setsize-under-tailpack-mutex.patch @@ -0,0 +1,48 @@ +From 22e7478ddbcb670e33fab72d0bbe7c394c3a2c84 Mon Sep 17 00:00:00 2001 +From: Jeff Mahoney +Date: Wed, 21 May 2014 13:28:07 -0400 +Subject: reiserfs: call truncate_setsize under tailpack mutex + +From: Jeff Mahoney + +commit 22e7478ddbcb670e33fab72d0bbe7c394c3a2c84 upstream. + +Prior to commit 0e4f6a791b1e (Fix reiserfs_file_release()), reiserfs +truncates serialized on i_mutex. They mostly still do, with the exception +of reiserfs_file_release. That blocks out other writers via the tailpack +mutex and the inode openers counter adjusted in reiserfs_file_open. + +However, NFS will call reiserfs_setattr without having called ->open, so +we end up with a race when nfs is calling ->setattr while another +process is releasing the file. Ultimately, it triggers the +BUG_ON(inode->i_size != new_file_size) check in maybe_indirect_to_direct. + +The solution is to pull the lock into reiserfs_setattr to encompass the +truncate_setsize call as well. + +Signed-off-by: Jeff Mahoney +Signed-off-by: Jan Kara +Signed-off-by: Greg Kroah-Hartman + +--- + fs/reiserfs/inode.c | 8 +++++++- + 1 file changed, 7 insertions(+), 1 deletion(-) + +--- a/fs/reiserfs/inode.c ++++ b/fs/reiserfs/inode.c +@@ -3220,8 +3220,14 @@ int reiserfs_setattr(struct dentry *dent + attr->ia_size != i_size_read(inode)) { + error = inode_newsize_ok(inode, attr->ia_size); + if (!error) { ++ /* ++ * Could race against reiserfs_file_release ++ * if called from NFS, so take tailpack mutex. ++ */ ++ mutex_lock(&REISERFS_I(inode)->tailpack); + truncate_setsize(inode, attr->ia_size); +- reiserfs_vfs_truncate_file(inode); ++ reiserfs_truncate_file(inode, 1); ++ mutex_unlock(&REISERFS_I(inode)->tailpack); + } + } + diff --git a/queue-3.14/series b/queue-3.14/series index 86775749f8b..59955067462 100644 --- a/queue-3.14/series +++ b/queue-3.14/series @@ -44,3 +44,6 @@ powerpc-fix-typo-config_ppc_cpu.patch powerpc-don-t-setup-cpus-with-bad-status.patch powerpc-add-at_hwcap2-to-indicate-v.crypto-category-support.patch powerpc-don-t-skip-epapr-spin-table-cpus.patch +xfs-block-allocation-work-needs-to-be-kswapd-aware.patch +xfs-xfs_readsb-needs-to-check-for-magic-numbers.patch +reiserfs-call-truncate_setsize-under-tailpack-mutex.patch diff --git a/queue-3.14/xfs-block-allocation-work-needs-to-be-kswapd-aware.patch b/queue-3.14/xfs-block-allocation-work-needs-to-be-kswapd-aware.patch new file mode 100644 index 00000000000..25bda5f8edb --- /dev/null +++ b/queue-3.14/xfs-block-allocation-work-needs-to-be-kswapd-aware.patch @@ -0,0 +1,101 @@ +From 1f6d64829db78a7e1d63e15c9f48f0a5d2b5a679 Mon Sep 17 00:00:00 2001 +From: Dave Chinner +Date: Fri, 6 Jun 2014 15:59:59 +1000 +Subject: xfs: block allocation work needs to be kswapd aware + +From: Dave Chinner + +commit 1f6d64829db78a7e1d63e15c9f48f0a5d2b5a679 upstream. + +Upon memory pressure, kswapd calls xfs_vm_writepage() from +shrink_page_list(). This can result in delayed allocation occurring +and that gets deferred to the the allocation workqueue. + +The allocation then runs outside kswapd context, which means if it +needs memory (and it does to demand page metadata from disk) it can +block in shrink_inactive_list() waiting for IO congestion. These +blocking waits are normally avoiding in kswapd context, so under +memory pressure writeback from kswapd can be arbitrarily delayed by +memory reclaim. + +To avoid this, pass the kswapd context to the allocation being done +by the workqueue, so that memory reclaim understands correctly that +the work is being done for kswapd and therefore it is not blocked +and does not delay memory reclaim. + +To avoid issues with int->char conversion of flag fields (as noticed +in v1 of this patch) convert the flag fields in the struct +xfs_bmalloca to bool types. pahole indicates these variables are +still single byte variables, so no extra space is consumed by this +change. + +Reported-by: Tetsuo Handa +Signed-off-by: Dave Chinner +Reviewed-by: Christoph Hellwig +Signed-off-by: Dave Chinner +Signed-off-by: Greg Kroah-Hartman + +--- + fs/xfs/xfs_bmap_util.c | 16 +++++++++++++--- + fs/xfs/xfs_bmap_util.h | 13 +++++++------ + 2 files changed, 20 insertions(+), 9 deletions(-) + +--- a/fs/xfs/xfs_bmap_util.c ++++ b/fs/xfs/xfs_bmap_util.c +@@ -258,14 +258,23 @@ xfs_bmapi_allocate_worker( + struct xfs_bmalloca *args = container_of(work, + struct xfs_bmalloca, work); + unsigned long pflags; ++ unsigned long new_pflags = PF_FSTRANS; + +- /* we are in a transaction context here */ +- current_set_flags_nested(&pflags, PF_FSTRANS); ++ /* ++ * we are in a transaction context here, but may also be doing work ++ * in kswapd context, and hence we may need to inherit that state ++ * temporarily to ensure that we don't block waiting for memory reclaim ++ * in any way. ++ */ ++ if (args->kswapd) ++ new_pflags |= PF_MEMALLOC | PF_SWAPWRITE | PF_KSWAPD; ++ ++ current_set_flags_nested(&pflags, new_pflags); + + args->result = __xfs_bmapi_allocate(args); + complete(args->done); + +- current_restore_flags_nested(&pflags, PF_FSTRANS); ++ current_restore_flags_nested(&pflags, new_pflags); + } + + /* +@@ -284,6 +293,7 @@ xfs_bmapi_allocate( + + + args->done = &done; ++ args->kswapd = current_is_kswapd(); + INIT_WORK_ONSTACK(&args->work, xfs_bmapi_allocate_worker); + queue_work(xfs_alloc_wq, &args->work); + wait_for_completion(&done); +--- a/fs/xfs/xfs_bmap_util.h ++++ b/fs/xfs/xfs_bmap_util.h +@@ -50,12 +50,13 @@ struct xfs_bmalloca { + xfs_extlen_t total; /* total blocks needed for xaction */ + xfs_extlen_t minlen; /* minimum allocation size (blocks) */ + xfs_extlen_t minleft; /* amount must be left after alloc */ +- char eof; /* set if allocating past last extent */ +- char wasdel; /* replacing a delayed allocation */ +- char userdata;/* set if is user data */ +- char aeof; /* allocated space at eof */ +- char conv; /* overwriting unwritten extents */ +- char stack_switch; ++ bool eof; /* set if allocating past last extent */ ++ bool wasdel; /* replacing a delayed allocation */ ++ bool userdata;/* set if is user data */ ++ bool aeof; /* allocated space at eof */ ++ bool conv; /* overwriting unwritten extents */ ++ bool stack_switch; ++ bool kswapd; /* allocation in kswapd context */ + int flags; + struct completion *done; + struct work_struct work; diff --git a/queue-3.14/xfs-xfs_readsb-needs-to-check-for-magic-numbers.patch b/queue-3.14/xfs-xfs_readsb-needs-to-check-for-magic-numbers.patch new file mode 100644 index 00000000000..5625357c4a4 --- /dev/null +++ b/queue-3.14/xfs-xfs_readsb-needs-to-check-for-magic-numbers.patch @@ -0,0 +1,70 @@ +From 556b8883cfac3d3203557e161ea8005f8b5479b2 Mon Sep 17 00:00:00 2001 +From: Dave Chinner +Date: Fri, 6 Jun 2014 16:00:43 +1000 +Subject: xfs: xfs_readsb needs to check for magic numbers + +From: Dave Chinner + +commit 556b8883cfac3d3203557e161ea8005f8b5479b2 upstream. + +Commit daba542 ("xfs: skip verification on initial "guess" +superblock read") dropped the use of a verifier for the initial +superblock read so we can probe the sector size of the filesystem +stored in the superblock. It, however, now fails to validate that +what was read initially is actually an XFS superblock and hence will +fail the sector size check and return ENOSYS. + +This causes probe-based mounts to fail because it expects XFS to +return EINVAL when it doesn't recognise the superblock format. + +Reported-by: Plamen Petrov +Tested-by: Plamen Petrov +Signed-off-by: Dave Chinner +Reviewed-by: Christoph Hellwig +Signed-off-by: Dave Chinner +Signed-off-by: Greg Kroah-Hartman + +--- + fs/xfs/xfs_mount.c | 23 +++++++++++++++++------ + 1 file changed, 17 insertions(+), 6 deletions(-) + +--- a/fs/xfs/xfs_mount.c ++++ b/fs/xfs/xfs_mount.c +@@ -320,8 +320,19 @@ reread: + /* + * Initialize the mount structure from the superblock. + */ +- xfs_sb_from_disk(&mp->m_sb, XFS_BUF_TO_SBP(bp)); +- xfs_sb_quota_from_disk(&mp->m_sb); ++ xfs_sb_from_disk(sbp, XFS_BUF_TO_SBP(bp)); ++ xfs_sb_quota_from_disk(sbp); ++ ++ /* ++ * If we haven't validated the superblock, do so now before we try ++ * to check the sector size and reread the superblock appropriately. ++ */ ++ if (sbp->sb_magicnum != XFS_SB_MAGIC) { ++ if (loud) ++ xfs_warn(mp, "Invalid superblock magic number"); ++ error = EINVAL; ++ goto release_buf; ++ } + + /* + * We must be able to do sector-sized and sector-aligned IO. +@@ -334,11 +345,11 @@ reread: + goto release_buf; + } + +- /* +- * Re-read the superblock so the buffer is correctly sized, +- * and properly verified. +- */ + if (buf_ops == NULL) { ++ /* ++ * Re-read the superblock so the buffer is correctly sized, ++ * and properly verified. ++ */ + xfs_buf_relse(bp); + sector_size = sbp->sb_sectsize; + buf_ops = loud ? &xfs_sb_buf_ops : &xfs_sb_quiet_buf_ops;