X-Git-Url: http://git.pld-linux.org/?p=packages%2Fkernel.git;a=blobdiff_plain;f=kernel-small_fixes.patch;h=227c0eb394c4b737f65ec3328308a3321019bf59;hp=0a0eebcda3aa051b675a3cdbb17cc270825e523b;hb=9b3fcbe069e2b3f442cb26a46e780a41df1aa844;hpb=0cde89eaf21831647fce0235792d7da946355397 diff --git a/kernel-small_fixes.patch b/kernel-small_fixes.patch index 0a0eebcd..227c0eb3 100644 --- a/kernel-small_fixes.patch +++ b/kernel-small_fixes.patch @@ -1,357 +1,172 @@ ---- 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-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. ---- 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 +Signed-off-by: Christoph Hellwig +--- + fs/xfs/xfs_aops.c | 35 +++++++++++++++++------------------ + 1 file changed, 17 insertions(+), 18 deletions(-) -diff --git a/drivers/net/ethernet/realtek/r8169.c b/drivers/net/ethernet/realtek/r8169.c -index 7a0c800..ec5ebbb 100644 ---- a/drivers/net/ethernet/realtek/r8169.c -+++ b/drivers/net/ethernet/realtek/r8169.c -@@ -6927,6 +6927,14 @@ rtl_init_one(struct pci_dev *pdev, const - for (i = 0; i < ETH_ALEN; i++) - dev->dev_addr[i] = RTL_R8(MAC0 + i); - -+ if (!is_valid_ether_addr(dev->dev_addr)) { -+ /* Report it and use a random ethernet address instead */ -+ netdev_err(dev, "Invalid MAC address: %pM\n", dev->dev_addr); -+ random_ether_addr(dev->dev_addr); -+ netdev_info(dev, "Using random MAC address: %pM\n", -+ dev->dev_addr); -+ } -+ - SET_ETHTOOL_OPS(dev, &rtl8169_ethtool_ops); - dev->watchdog_timeo = RTL8169_TX_TIMEOUT; +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; + } -[PATCH] SCSI: Don't attempt to send extended INQUIRY command if skip_vpd_pages is set - -If a device has the skip_vpd_pages flag set we should simply fail the -scsi_get_vpd_page() call. - -Signed-off-by: Martin K. Petersen -Acked-by: Alan Stern -Tested-by: Stuart Foster -Cc: stable@vger.kernel.org - -diff --git a/drivers/scsi/scsi.c b/drivers/scsi/scsi.c -index 3b1ea34..eaa808e 100644 ---- a/drivers/scsi/scsi.c -+++ b/drivers/scsi/scsi.c -@@ -1031,6 +1031,9 @@ +- 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) { - int i, result; - -+ if (sdev->skip_vpd_pages) -+ goto fail; + 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 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; + - /* Ask for all the pages supported by this device */ - result = scsi_vpd_inquiry(sdev, buf, 0, buf_len); - if (result) -commit 4d0ed18277cc6f07513ee0b04475f19cd69e75ef -Author: Peter Hurley -Date: Tue Dec 10 17:12:02 2013 -0500 - - n_tty: Fix buffer overruns with larger-than-4k pastes - - readline() inadvertently triggers an error recovery path when - pastes larger than 4k overrun the line discipline buffer. The - error recovery path discards input when the line discipline buffer - is full and operating in canonical mode and no newline has been - received. Because readline() changes the termios to non-canonical - mode to read the line char-by-char, the line discipline buffer - can become full, and then when readline() restores termios back - to canonical mode for the caller, the now-full line discipline - buffer triggers the error recovery. - - When changing termios from non-canon to canon mode and the read - buffer contains data, simulate an EOF push _without_ the - DISABLED_CHAR in the read buffer. - - Importantly for the readline() problem, the termios can be - changed back to non-canonical mode without changes to the read - buffer occurring; ie., as if the previous termios change had not - happened (as long as no intervening read took place). - - Preserve existing userspace behavior which allows '\0's already - received in non-canon mode to be read as '\0's in canon mode - (rather than trigger add'l EOF pushes or an actual EOF). - - Patch based on original proposal and discussion here - https://bugzilla.kernel.org/show_bug.cgi?id=55991 - by Stas Sergeev - - Reported-by: Margarita Manterola - Cc: Maximiliano Curia - Cc: Pavel Machek - Cc: Arkadiusz Miskiewicz - Acked-by: Stas Sergeev - Signed-off-by: Peter Hurley - Signed-off-by: Greg Kroah-Hartman - -diff --git a/drivers/tty/n_tty.c b/drivers/tty/n_tty.c -index fdc2ecd..961e6a9 100644 ---- a/drivers/tty/n_tty.c -+++ b/drivers/tty/n_tty.c -@@ -104,6 +104,7 @@ struct n_tty_data { - - /* must hold exclusive termios_rwsem to reset these */ - unsigned char lnext:1, erasing:1, raw:1, real_raw:1, icanon:1; -+ unsigned char push:1; - - /* shared by producer and consumer */ - char read_buf[N_TTY_BUF_SIZE]; -@@ -341,6 +342,7 @@ static void reset_buffer_flags(struct n_tty_data *ldata) - - ldata->erasing = 0; - bitmap_zero(ldata->read_flags, N_TTY_BUF_SIZE); -+ ldata->push = 0; ++ bio_chain(prev, new); ++ bio_get(prev); /* for xfs_destroy_ioend */ ++ submit_bio(prev); ++ return new; } - static void n_tty_packet_mode_flush(struct tty_struct *tty) -@@ -1745,7 +1747,16 @@ static void n_tty_set_termios(struct tty_struct *tty, struct ktermios *old) - - if (!old || (old->c_lflag ^ tty->termios.c_lflag) & ICANON) { - bitmap_zero(ldata->read_flags, N_TTY_BUF_SIZE); -- ldata->line_start = ldata->canon_head = ldata->read_tail; -+ ldata->line_start = ldata->read_tail; -+ if (!L_ICANON(tty) || !read_cnt(ldata)) { -+ ldata->canon_head = ldata->read_tail; -+ ldata->push = 0; -+ } else { -+ set_bit((ldata->read_head - 1) & (N_TTY_BUF_SIZE - 1), -+ ldata->read_flags); -+ ldata->canon_head = ldata->read_head; -+ ldata->push = 1; -+ } - ldata->erasing = 0; - ldata->lnext = 0; + /* +@@ -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); } -@@ -1951,6 +1962,12 @@ static int copy_from_read_buf(struct tty_struct *tty, - * it copies one line of input up to and including the line-delimiting - * character into the user-space buffer. - * -+ * NB: When termios is changed from non-canonical to canonical mode and -+ * the read buffer contains data, n_tty_set_termios() simulates an EOF -+ * push (as if C-d were input) _without_ the DISABLED_CHAR in the buffer. -+ * This causes data already processed as input to be immediately available -+ * as input although a newline has not been received. -+ * - * Called under the atomic_read_lock mutex - * - * n_tty_read()/consumer path: -@@ -1997,7 +2014,7 @@ static int canon_copy_from_read_buf(struct tty_struct *tty, - n += found; - c = n; -- if (found && read_buf(ldata, eol) == __DISABLED_CHAR) { -+ if (found && !ldata->push && read_buf(ldata, eol) == __DISABLED_CHAR) { - n--; - eof_push = !n && ldata->read_tail != ldata->line_start; - } -@@ -2024,7 +2041,10 @@ static int canon_copy_from_read_buf(struct tty_struct *tty, - ldata->read_tail += c; + merged = __bio_try_merge_page(wpc->ioend->io_bio, page, len, poff, +@@ -783,7 +783,7 @@ xfs_add_to_ioend( - if (found) { -- ldata->line_start = ldata->read_tail; -+ if (!ldata->push) -+ ldata->line_start = ldata->read_tail; -+ else -+ ldata->push = 0; - tty_audit_push(tty); + 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); } - return eof_push ? -EAGAIN : 0; -From 27095111cbafd3212c7e9a4a8cef1099b7520ca8 Mon Sep 17 00:00:00 2001 -From: Kieran Clancy -Date: Fri, 28 Feb 2014 14:12:28 +0000 -Subject: ACPI / EC: Clear stale EC events on Samsung systems - -A number of Samsung notebooks (530Uxx/535Uxx/540Uxx/550Pxx/900Xxx/etc) -continue to log events during sleep (lid open/close, AC plug/unplug, -battery level change), which accumulate in the EC until a buffer fills. -After the buffer is full (tests suggest it holds 8 events), GPEs stop -being triggered for new events. This state persists on wake or even on -power cycle, and prevents new events from being registered until the EC -is manually polled. - -This is the root cause of a number of bugs, including AC not being -detected properly, lid close not triggering suspend, and low ambient -light not triggering the keyboard backlight. The bug also seemed to be -responsible for performance issues on at least one user's machine. - -Juan Manuel Cabo found the cause of bug and the workaround of polling -the EC manually on wake. + +-- +2.20.1 -The loop which clears the stale events is based on an earlier patch by -Lan Tianyu (see referenced attachment). -This patch: - - Adds a function acpi_ec_clear() which polls the EC for stale _Q - events at most ACPI_EC_CLEAR_MAX (currently 100) times. A warning is - logged if this limit is reached. - - Adds a flag EC_FLAGS_CLEAR_ON_RESUME which is set to 1 if the DMI - system vendor is Samsung. This check could be replaced by several - more specific DMI vendor/product pairs, but it's likely that the bug - affects more Samsung products than just the five series mentioned - above. Further, it should not be harmful to run acpi_ec_clear() on - systems without the bug; it will return immediately after finding no - data waiting. - - Runs acpi_ec_clear() on initialisation (boot), from acpi_ec_add() - - Runs acpi_ec_clear() on wake, from acpi_ec_unblock_transactions() +Link every newly allocated writeback bio to cgroup pointed to by the +writeback control structure, and charge every byte written back to it. -References: https://bugzilla.kernel.org/show_bug.cgi?id=44161 -References: https://bugzilla.kernel.org/show_bug.cgi?id=45461 -References: https://bugzilla.kernel.org/show_bug.cgi?id=57271 -References: https://bugzilla.kernel.org/attachment.cgi?id=126801 -Suggested-by: Juan Manuel Cabo -Signed-off-by: Kieran Clancy -Reviewed-by: Lan Tianyu -Reviewed-by: Dennis Jansen -Tested-by: Kieran Clancy -Tested-by: Juan Manuel Cabo -Tested-by: Dennis Jansen -Tested-by: Maurizio D'Addona -Tested-by: San Zamoyski -Signed-off-by: Rafael J. Wysocki +Tested-by: Stefan Priebe - Profihost AG +Signed-off-by: Christoph Hellwig --- -diff --git a/drivers/acpi/ec.c b/drivers/acpi/ec.c -index 959d41a..d7d32c2 100644 ---- a/drivers/acpi/ec.c -+++ b/drivers/acpi/ec.c -@@ -67,6 +67,8 @@ enum ec_command { - #define ACPI_EC_DELAY 500 /* Wait 500ms max. during EC ops */ - #define ACPI_EC_UDELAY_GLK 1000 /* Wait 1ms max. to get global lock */ - #define ACPI_EC_MSI_UDELAY 550 /* Wait 550us for MSI EC */ -+#define ACPI_EC_CLEAR_MAX 100 /* Maximum number of events to query -+ * when trying to clear the EC */ - - enum { - EC_FLAGS_QUERY_PENDING, /* Query is pending */ -@@ -116,6 +118,7 @@ EXPORT_SYMBOL(first_ec); - static int EC_FLAGS_MSI; /* Out-of-spec MSI controller */ - static int EC_FLAGS_VALIDATE_ECDT; /* ASUStec ECDTs need to be validated */ - static int EC_FLAGS_SKIP_DSDT_SCAN; /* Not all BIOS survive early DSDT scan */ -+static int EC_FLAGS_CLEAR_ON_RESUME; /* Needs acpi_ec_clear() on boot/resume */ - - /* -------------------------------------------------------------------------- - Transaction Management -@@ -440,6 +443,29 @@ acpi_handle ec_get_handle(void) - - EXPORT_SYMBOL(ec_get_handle); - -+static int acpi_ec_query_unlocked(struct acpi_ec *ec, u8 *data); -+ -+/* -+ * Clears stale _Q events that might have accumulated in the EC. -+ * Run with locked ec mutex. -+ */ -+static void acpi_ec_clear(struct acpi_ec *ec) -+{ -+ int i, status; -+ u8 value = 0; -+ -+ for (i = 0; i < ACPI_EC_CLEAR_MAX; i++) { -+ status = acpi_ec_query_unlocked(ec, &value); -+ if (status || !value) -+ break; -+ } -+ -+ if (unlikely(i == ACPI_EC_CLEAR_MAX)) -+ pr_warn("Warning: Maximum of %d stale EC events cleared\n", i); -+ else -+ pr_info("%d stale EC events cleared\n", i); -+} -+ - void acpi_ec_block_transactions(void) - { - struct acpi_ec *ec = first_ec; -@@ -463,6 +489,10 @@ void acpi_ec_unblock_transactions(void) - mutex_lock(&ec->mutex); - /* Allow transactions to be carried out again */ - clear_bit(EC_FLAGS_BLOCKED, &ec->flags); -+ -+ if (EC_FLAGS_CLEAR_ON_RESUME) -+ acpi_ec_clear(ec); -+ - mutex_unlock(&ec->mutex); - } - -@@ -821,6 +851,13 @@ static int acpi_ec_add(struct acpi_device *device) - - /* EC is fully operational, allow queries */ - clear_bit(EC_FLAGS_QUERY_PENDING, &ec->flags); -+ -+ /* Clear stale _Q events if hardware might require that */ -+ if (EC_FLAGS_CLEAR_ON_RESUME) { -+ mutex_lock(&ec->mutex); -+ acpi_ec_clear(ec); -+ mutex_unlock(&ec->mutex); -+ } - return ret; - } + 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( + } -@@ -922,6 +959,30 @@ static int ec_enlarge_storm_threshold(const struct dmi_system_id *id) - return 0; + wpc->ioend->io_size += len; ++ wbc_account_io(wbc, page, len); } -+/* -+ * On some hardware it is necessary to clear events accumulated by the EC during -+ * sleep. These ECs stop reporting GPEs until they are manually polled, if too -+ * many events are accumulated. (e.g. Samsung Series 5/9 notebooks) -+ * -+ * https://bugzilla.kernel.org/show_bug.cgi?id=44161 -+ * -+ * Ideally, the EC should also be instructed NOT to accumulate events during -+ * sleep (which Windows seems to do somehow), but the interface to control this -+ * behaviour is not known at this time. -+ * -+ * Models known to be affected are Samsung 530Uxx/535Uxx/540Uxx/550Pxx/900Xxx, -+ * however it is very likely that other Samsung models are affected. -+ * -+ * On systems which don't accumulate _Q events during sleep, this extra check -+ * should be harmless. -+ */ -+static int ec_clear_on_resume(const struct dmi_system_id *id) -+{ -+ pr_debug("Detected system needing EC poll on resume.\n"); -+ EC_FLAGS_CLEAR_ON_RESUME = 1; -+ return 0; -+} + 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; + - static struct dmi_system_id ec_dmi_table[] __initdata = { - { - ec_skip_dsdt_scan, "Compal JFL92", { -@@ -965,6 +1026,9 @@ static struct dmi_system_id ec_dmi_table[] __initdata = { - ec_validate_ecdt, "ASUS hardware", { - DMI_MATCH(DMI_SYS_VENDOR, "ASUSTek Computer Inc."), - DMI_MATCH(DMI_PRODUCT_NAME, "L4R"),}, NULL}, -+ { -+ ec_clear_on_resume, "Samsung hardware", { -+ DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD.")}, NULL}, - {}, - }; + set_posix_acl_flag(sb); --- -cgit v0.9.2 + /* version 5 superblocks support inode version counters. */ +-- +2.20.1 +