X-Git-Url: http://git.pld-linux.org/?a=blobdiff_plain;f=kernel-small_fixes.patch;h=1fbd7c139408c56eeeec5bf7b1f8c086a8440c98;hb=234da52fc4c0749529be74422c132f4a5f391a1a;hp=f8c1e758aa6d1ebafcdd63eb42237b5eebf59763;hpb=99992ee38162d313ea413f836b516d62ccdf5f96;p=packages%2Fkernel.git diff --git a/kernel-small_fixes.patch b/kernel-small_fixes.patch index f8c1e758..1fbd7c13 100644 --- a/kernel-small_fixes.patch +++ b/kernel-small_fixes.patch @@ -26,163 +26,80 @@ exit fi done - -From 30927520dbae297182990bb21d08762bcc35ce1d Mon Sep 17 00:00:00 2001 -From: Eric Dumazet -Date: Wed, 9 Sep 2015 21:55:07 -0700 -Subject: [PATCH] tcp_cubic: better follow cubic curve after idle period - -Jana Iyengar found an interesting issue on CUBIC : - -The epoch is only updated/reset initially and when experiencing losses. -The delta "t" of now - epoch_start can be arbitrary large after app idle -as well as the bic_target. Consequentially the slope (inverse of -ca->cnt) would be really large, and eventually ca->cnt would be -lower-bounded in the end to 2 to have delayed-ACK slow-start behavior. - -This particularly shows up when slow_start_after_idle is disabled -as a dangerous cwnd inflation (1.5 x RTT) after few seconds of idle -time. - -Jana initial fix was to reset epoch_start if app limited, -but Neal pointed out it would ask the CUBIC algorithm to recalculate the -curve so that we again start growing steeply upward from where cwnd is -now (as CUBIC does just after a loss). Ideally we'd want the cwnd growth -curve to be the same shape, just shifted later in time by the amount of -the idle period. - -Reported-by: Jana Iyengar -Signed-off-by: Eric Dumazet -Signed-off-by: Yuchung Cheng -Signed-off-by: Neal Cardwell -Cc: Stephen Hemminger -Cc: Sangtae Ha -Cc: Lawrence Brakmo -Signed-off-by: David S. Miller +From 5d12f71723762a39435d054d02bbf5fb87c5cd14 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Arkadiusz=20Mi=C5=9Bkiewicz?= +Date: Mon, 6 Feb 2017 14:45:15 +0100 +Subject: [PATCH] mac80211: Print text for disassociation reason +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +When disassociation happens only numeric reason is printed +in ieee80211_rx_mgmt_disassoc(). Add text variant, too. + +Signed-off-by: Arkadiusz Miśkiewicz --- - net/ipv4/tcp_cubic.c | 16 ++++++++++++++++ - 1 file changed, 16 insertions(+) - -diff --git a/net/ipv4/tcp_cubic.c b/net/ipv4/tcp_cubic.c -index 28011fb1..c6ded6b 100644 ---- a/net/ipv4/tcp_cubic.c -+++ b/net/ipv4/tcp_cubic.c -@@ -151,6 +151,21 @@ static void bictcp_init(struct sock *sk) - tcp_sk(sk)->snd_ssthresh = initial_ssthresh; - } + net/mac80211/mlme.c | 5 +++-- + 1 file changed, 3 insertions(+), 2 deletions(-) + +diff --git a/net/mac80211/mlme.c b/net/mac80211/mlme.c +index 098ce9b179ee..fcf8d0aa66ec 100644 +--- a/net/mac80211/mlme.c ++++ b/net/mac80211/mlme.c +@@ -2801,8 +2801,9 @@ static void ieee80211_rx_mgmt_disassoc(struct ieee80211_sub_if_data *sdata, -+static void bictcp_cwnd_event(struct sock *sk, enum tcp_ca_event event) -+{ -+ if (event == CA_EVENT_TX_START) { -+ s32 delta = tcp_time_stamp - tcp_sk(sk)->lsndtime; -+ struct bictcp *ca = inet_csk_ca(sk); -+ -+ /* We were application limited (idle) for a while. -+ * Shift epoch_start to keep cwnd growth to cubic curve. -+ */ -+ if (ca->epoch_start && delta > 0) -+ ca->epoch_start += delta; -+ return; -+ } -+} -+ - /* calculate the cubic root of x using a table lookup followed by one - * Newton-Raphson iteration. - * Avg err ~= 0.195% -@@ -450,6 +465,7 @@ static struct tcp_congestion_ops cubictcp __read_mostly = { - .cong_avoid = bictcp_cong_avoid, - .set_state = bictcp_state, - .undo_cwnd = bictcp_undo_cwnd, -+ .cwnd_event = bictcp_cwnd_event, - .pkts_acked = bictcp_acked, - .owner = THIS_MODULE, - .name = "cubic", -From 7a29ac474a47eb8cf212b45917683ae89d6fa13b Mon Sep 17 00:00:00 2001 -From: Chris Mason -Date: Tue, 10 Nov 2015 10:10:34 +1100 -Subject: xfs: give all workqueues rescuer threads - -We're consistently hitting deadlocks here with XFS on recent kernels. -After some digging through the crash files, it looks like everyone in -the system is waiting for XFS to reclaim memory. - -Something like this: - -PID: 2733434 TASK: ffff8808cd242800 CPU: 19 COMMAND: "java" - #0 [ffff880019c53588] __schedule at ffffffff818c4df2 - #1 [ffff880019c535d8] schedule at ffffffff818c5517 - #2 [ffff880019c535f8] _xfs_log_force_lsn at ffffffff81316348 - #3 [ffff880019c53688] xfs_log_force_lsn at ffffffff813164fb - #4 [ffff880019c536b8] xfs_iunpin_wait at ffffffff8130835e - #5 [ffff880019c53728] xfs_reclaim_inode at ffffffff812fd453 - #6 [ffff880019c53778] xfs_reclaim_inodes_ag at ffffffff812fd8c7 - #7 [ffff880019c53928] xfs_reclaim_inodes_nr at ffffffff812fe433 - #8 [ffff880019c53958] xfs_fs_free_cached_objects at ffffffff8130d3b9 - #9 [ffff880019c53968] super_cache_scan at ffffffff811a6f73 -#10 [ffff880019c539c8] shrink_slab at ffffffff811460e6 -#11 [ffff880019c53aa8] shrink_zone at ffffffff8114a53f -#12 [ffff880019c53b48] do_try_to_free_pages at ffffffff8114a8ba -#13 [ffff880019c53be8] try_to_free_pages at ffffffff8114ad5a -#14 [ffff880019c53c78] __alloc_pages_nodemask at ffffffff8113e1b8 -#15 [ffff880019c53d88] alloc_kmem_pages_node at ffffffff8113e671 -#16 [ffff880019c53dd8] copy_process at ffffffff8104f781 -#17 [ffff880019c53ec8] do_fork at ffffffff8105129c -#18 [ffff880019c53f38] sys_clone at ffffffff810515b6 -#19 [ffff880019c53f48] stub_clone at ffffffff818c8e4d - -xfs_log_force_lsn is waiting for logs to get cleaned, which is waiting -for IO, which is waiting for workers to complete the IO which is waiting -for worker threads that don't exist yet: - -PID: 2752451 TASK: ffff880bd6bdda00 CPU: 37 COMMAND: "kworker/37:1" - #0 [ffff8808d20abbb0] __schedule at ffffffff818c4df2 - #1 [ffff8808d20abc00] schedule at ffffffff818c5517 - #2 [ffff8808d20abc20] schedule_timeout at ffffffff818c7c6c - #3 [ffff8808d20abcc0] wait_for_completion_killable at ffffffff818c6495 - #4 [ffff8808d20abd30] kthread_create_on_node at ffffffff8106ec82 - #5 [ffff8808d20abdf0] create_worker at ffffffff8106752f - #6 [ffff8808d20abe40] worker_thread at ffffffff810699be - #7 [ffff8808d20abec0] kthread at ffffffff8106ef59 - #8 [ffff8808d20abf50] ret_from_fork at ffffffff818c8ac8 + reason_code = le16_to_cpu(mgmt->u.disassoc.reason_code); + +- sdata_info(sdata, "disassociated from %pM (Reason: %u)\n", +- mgmt->sa, reason_code); ++ sdata_info(sdata, "disassociated from %pM (Reason: %u=%s)\n", ++ mgmt->sa, reason_code, ++ ieee80211_get_reason_code_string(reason_code)); + + ieee80211_set_disassoc(sdata, 0, 0, false, NULL); + +-- +2.11.0 -I think we should be using WQ_MEM_RECLAIM to make sure this thread -pool makes progress when we're not able to allocate new workers. +From: Shaohua Li -[dchinner: make all workqueues WQ_MEM_RECLAIM] +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. -Signed-off-by: Chris Mason -Reviewed-by: Dave Chinner -Signed-off-by: Dave Chinner +Cc: Tejun Heo +Signed-off-by: Shaohua Li --- - fs/xfs/xfs_super.c | 7 ++++--- - 1 file changed, 4 insertions(+), 3 deletions(-) - + fs/xfs/xfs_aops.c | 2 ++ + fs/xfs/xfs_super.c | 1 + + 2 files changed, 3 insertions(+) + +diff --git a/fs/xfs/xfs_aops.c b/fs/xfs/xfs_aops.c +index f18e593..6535054 100644 +--- a/fs/xfs/xfs_aops.c ++++ b/fs/xfs/xfs_aops.c +@@ -630,8 +630,10 @@ xfs_add_to_ioend( + if (wpc->ioend) + list_add(&wpc->ioend->io_list, iolist); + wpc->ioend = xfs_alloc_ioend(inode, wpc->io_type, offset, bh); ++ wbc_init_bio(wbc, wpc->ioend->io_bio); + } + ++ wbc_account_io(wbc, bh->b_page, bh->b_size); + /* + * If the buffer doesn't fit into the bio we need to allocate a new + * one. This shouldn't happen more than once for a given buffer. diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c -index 29531ec..65fbfb7 100644 +index 584cf2d..aea3bc2 100644 --- a/fs/xfs/xfs_super.c +++ b/fs/xfs/xfs_super.c -@@ -838,17 +838,18 @@ xfs_init_mount_workqueues( - goto out_destroy_unwritten; +@@ -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; - mp->m_reclaim_workqueue = alloc_workqueue("xfs-reclaim/%s", -- WQ_FREEZABLE, 0, mp->m_fsname); -+ WQ_MEM_RECLAIM|WQ_FREEZABLE, 0, mp->m_fsname); - if (!mp->m_reclaim_workqueue) - goto out_destroy_cil; - - mp->m_log_workqueue = alloc_workqueue("xfs-log/%s", -- WQ_FREEZABLE|WQ_HIGHPRI, 0, mp->m_fsname); -+ WQ_MEM_RECLAIM|WQ_FREEZABLE|WQ_HIGHPRI, 0, -+ mp->m_fsname); - if (!mp->m_log_workqueue) - goto out_destroy_reclaim; - - mp->m_eofblocks_workqueue = alloc_workqueue("xfs-eofblocks/%s", -- WQ_FREEZABLE, 0, mp->m_fsname); -+ WQ_MEM_RECLAIM|WQ_FREEZABLE, 0, mp->m_fsname); - if (!mp->m_eofblocks_workqueue) - goto out_destroy_log; - --- -cgit v0.11.2 - + /* version 5 superblocks support inode version counters. */ + if (XFS_SB_VERSION_NUM(&mp->m_sb) == XFS_SB_VERSION_5)