commit: e15331f8e11c18c10e0e46ad38741a0b33aebef6 Author: Mike Pagano <mpagano <AT> gentoo <DOT> org> AuthorDate: Sat Jan 9 12:56:04 2021 +0000 Commit: Mike Pagano <mpagano <AT> gentoo <DOT> org> CommitDate: Sat Jan 9 12:56:04 2021 +0000 URL: https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=e15331f8
Linux patch 4.14.214 Signed-off-by: Mike Pagano <mpagano <AT> gentoo.org> 0000_README | 4 + 1213_linux-4.14.214.patch | 1567 +++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 1571 insertions(+) diff --git a/0000_README b/0000_README index ff5e177..f54adb5 100644 --- a/0000_README +++ b/0000_README @@ -895,6 +895,10 @@ Patch: 1212_linux-4.14.213.patch From: https://www.kernel.org Desc: Linux 4.14.213 +Patch: 1213_linux-4.14.214.patch +From: https://www.kernel.org +Desc: Linux 4.14.214 + Patch: 1500_XATTR_USER_PREFIX.patch From: https://bugs.gentoo.org/show_bug.cgi?id=470644 Desc: Support for namespace user.pax.* on tmpfs. diff --git a/1213_linux-4.14.214.patch b/1213_linux-4.14.214.patch new file mode 100644 index 0000000..46dae79 --- /dev/null +++ b/1213_linux-4.14.214.patch @@ -0,0 +1,1567 @@ +diff --git a/Makefile b/Makefile +index d059e257b976a..d36b8f4228a47 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,7 +1,7 @@ + # SPDX-License-Identifier: GPL-2.0 + VERSION = 4 + PATCHLEVEL = 14 +-SUBLEVEL = 213 ++SUBLEVEL = 214 + EXTRAVERSION = + NAME = Petit Gorille + +diff --git a/arch/powerpc/include/asm/bitops.h b/arch/powerpc/include/asm/bitops.h +index b750ffef83c7d..0ec93d940d12c 100644 +--- a/arch/powerpc/include/asm/bitops.h ++++ b/arch/powerpc/include/asm/bitops.h +@@ -220,15 +220,34 @@ static __inline__ void __clear_bit_unlock(int nr, volatile unsigned long *addr) + */ + static __inline__ int fls(unsigned int x) + { +- return 32 - __builtin_clz(x); ++ int lz; ++ ++ if (__builtin_constant_p(x)) ++ return x ? 32 - __builtin_clz(x) : 0; ++ asm("cntlzw %0,%1" : "=r" (lz) : "r" (x)); ++ return 32 - lz; + } + + #include <asm-generic/bitops/builtin-__fls.h> + ++/* ++ * 64-bit can do this using one cntlzd (count leading zeroes doubleword) ++ * instruction; for 32-bit we use the generic version, which does two ++ * 32-bit fls calls. ++ */ ++#ifdef CONFIG_PPC64 + static __inline__ int fls64(__u64 x) + { +- return 64 - __builtin_clzll(x); ++ int lz; ++ ++ if (__builtin_constant_p(x)) ++ return x ? 64 - __builtin_clzll(x) : 0; ++ asm("cntlzd %0,%1" : "=r" (lz) : "r" (x)); ++ return 64 - lz; + } ++#else ++#include <asm-generic/bitops/fls64.h> ++#endif + + #ifdef CONFIG_PPC64 + unsigned int __arch_hweight8(unsigned int w); +diff --git a/arch/powerpc/sysdev/mpic_msgr.c b/arch/powerpc/sysdev/mpic_msgr.c +index 280e964e1aa88..497e86cfb12e0 100644 +--- a/arch/powerpc/sysdev/mpic_msgr.c ++++ b/arch/powerpc/sysdev/mpic_msgr.c +@@ -196,7 +196,7 @@ static int mpic_msgr_probe(struct platform_device *dev) + + /* IO map the message register block. */ + of_address_to_resource(np, 0, &rsrc); +- msgr_block_addr = ioremap(rsrc.start, resource_size(&rsrc)); ++ msgr_block_addr = devm_ioremap(&dev->dev, rsrc.start, resource_size(&rsrc)); + if (!msgr_block_addr) { + dev_err(&dev->dev, "Failed to iomap MPIC message registers"); + return -EFAULT; +diff --git a/arch/x86/entry/entry_64.S b/arch/x86/entry/entry_64.S +index f24974bddfc96..ac389ffb1822b 100644 +--- a/arch/x86/entry/entry_64.S ++++ b/arch/x86/entry/entry_64.S +@@ -55,7 +55,7 @@ END(native_usergs_sysret64) + + .macro TRACE_IRQS_IRETQ + #ifdef CONFIG_TRACE_IRQFLAGS +- bt $9, EFLAGS(%rsp) /* interrupts off? */ ++ btl $9, EFLAGS(%rsp) /* interrupts off? */ + jnc 1f + TRACE_IRQS_ON + 1: +diff --git a/drivers/iio/imu/bmi160/bmi160_core.c b/drivers/iio/imu/bmi160/bmi160_core.c +index 01fcd715485c5..c56512297fb9e 100644 +--- a/drivers/iio/imu/bmi160/bmi160_core.c ++++ b/drivers/iio/imu/bmi160/bmi160_core.c +@@ -110,6 +110,13 @@ enum bmi160_sensor_type { + + struct bmi160_data { + struct regmap *regmap; ++ /* ++ * Ensure natural alignment for timestamp if present. ++ * Max length needed: 2 * 3 channels + 4 bytes padding + 8 byte ts. ++ * If fewer channels are enabled, less space may be needed, as ++ * long as the timestamp is still aligned to 8 bytes. ++ */ ++ __le16 buf[12] __aligned(8); + }; + + const struct regmap_config bmi160_regmap_config = { +@@ -385,8 +392,6 @@ static irqreturn_t bmi160_trigger_handler(int irq, void *p) + struct iio_poll_func *pf = p; + struct iio_dev *indio_dev = pf->indio_dev; + struct bmi160_data *data = iio_priv(indio_dev); +- __le16 buf[12]; +- /* 2 sens x 3 axis x __le16 + 2 x __le16 pad + 4 x __le16 tstamp */ + int i, ret, j = 0, base = BMI160_REG_DATA_MAGN_XOUT_L; + __le16 sample; + +@@ -396,10 +401,10 @@ static irqreturn_t bmi160_trigger_handler(int irq, void *p) + &sample, sizeof(sample)); + if (ret < 0) + goto done; +- buf[j++] = sample; ++ data->buf[j++] = sample; + } + +- iio_push_to_buffers_with_timestamp(indio_dev, buf, ++ iio_push_to_buffers_with_timestamp(indio_dev, data->buf, + iio_get_time_ns(indio_dev)); + done: + iio_trigger_notify_done(indio_dev->trig); +diff --git a/drivers/iio/magnetometer/mag3110.c b/drivers/iio/magnetometer/mag3110.c +index dad8d57f7402b..974e141c0dc04 100644 +--- a/drivers/iio/magnetometer/mag3110.c ++++ b/drivers/iio/magnetometer/mag3110.c +@@ -52,6 +52,12 @@ struct mag3110_data { + struct i2c_client *client; + struct mutex lock; + u8 ctrl_reg1; ++ /* Ensure natural alignment of timestamp */ ++ struct { ++ __be16 channels[3]; ++ u8 temperature; ++ s64 ts __aligned(8); ++ } scan; + }; + + static int mag3110_request(struct mag3110_data *data) +@@ -262,10 +268,9 @@ static irqreturn_t mag3110_trigger_handler(int irq, void *p) + struct iio_poll_func *pf = p; + struct iio_dev *indio_dev = pf->indio_dev; + struct mag3110_data *data = iio_priv(indio_dev); +- u8 buffer[16]; /* 3 16-bit channels + 1 byte temp + padding + ts */ + int ret; + +- ret = mag3110_read(data, (__be16 *) buffer); ++ ret = mag3110_read(data, data->scan.channels); + if (ret < 0) + goto done; + +@@ -274,10 +279,10 @@ static irqreturn_t mag3110_trigger_handler(int irq, void *p) + MAG3110_DIE_TEMP); + if (ret < 0) + goto done; +- buffer[6] = ret; ++ data->scan.temperature = ret; + } + +- iio_push_to_buffers_with_timestamp(indio_dev, buffer, ++ iio_push_to_buffers_with_timestamp(indio_dev, &data->scan, + iio_get_time_ns(indio_dev)); + + done: +diff --git a/drivers/md/dm-verity-target.c b/drivers/md/dm-verity-target.c +index e705799976c2c..2dae30713eb3d 100644 +--- a/drivers/md/dm-verity-target.c ++++ b/drivers/md/dm-verity-target.c +@@ -551,6 +551,15 @@ static int verity_verify_io(struct dm_verity_io *io) + return 0; + } + ++/* ++ * Skip verity work in response to I/O error when system is shutting down. ++ */ ++static inline bool verity_is_system_shutting_down(void) ++{ ++ return system_state == SYSTEM_HALT || system_state == SYSTEM_POWER_OFF ++ || system_state == SYSTEM_RESTART; ++} ++ + /* + * End one "io" structure with a given error. + */ +@@ -578,7 +587,8 @@ static void verity_end_io(struct bio *bio) + { + struct dm_verity_io *io = bio->bi_private; + +- if (bio->bi_status && !verity_fec_is_enabled(io->v)) { ++ if (bio->bi_status && ++ (!verity_fec_is_enabled(io->v) || verity_is_system_shutting_down())) { + verity_finish_io(io, bio->bi_status); + return; + } +diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c +index d08d77b9674ff..419ecdd914f4c 100644 +--- a/drivers/md/raid10.c ++++ b/drivers/md/raid10.c +@@ -1120,7 +1120,7 @@ static void raid10_read_request(struct mddev *mddev, struct bio *bio, + struct md_rdev *err_rdev = NULL; + gfp_t gfp = GFP_NOIO; + +- if (r10_bio->devs[slot].rdev) { ++ if (slot >= 0 && r10_bio->devs[slot].rdev) { + /* + * This is an error retry, but we cannot + * safely dereference the rdev in the r10_bio, +@@ -1513,6 +1513,7 @@ static void __make_request(struct mddev *mddev, struct bio *bio, int sectors) + r10_bio->mddev = mddev; + r10_bio->sector = bio->bi_iter.bi_sector; + r10_bio->state = 0; ++ r10_bio->read_slot = -1; + memset(r10_bio->devs, 0, sizeof(r10_bio->devs[0]) * conf->copies); + + if (bio_data_dir(bio) == READ) +diff --git a/drivers/media/usb/dvb-usb/gp8psk.c b/drivers/media/usb/dvb-usb/gp8psk.c +index 37f062225ed21..aac677f6aaa4f 100644 +--- a/drivers/media/usb/dvb-usb/gp8psk.c ++++ b/drivers/media/usb/dvb-usb/gp8psk.c +@@ -185,7 +185,7 @@ out_rel_fw: + + static int gp8psk_power_ctrl(struct dvb_usb_device *d, int onoff) + { +- u8 status, buf; ++ u8 status = 0, buf; + int gp_product_id = le16_to_cpu(d->udev->descriptor.idProduct); + + if (onoff) { +diff --git a/drivers/misc/vmw_vmci/vmci_context.c b/drivers/misc/vmw_vmci/vmci_context.c +index bc089e634a751..26e20b091160a 100644 +--- a/drivers/misc/vmw_vmci/vmci_context.c ++++ b/drivers/misc/vmw_vmci/vmci_context.c +@@ -751,7 +751,7 @@ static int vmci_ctx_get_chkpt_doorbells(struct vmci_ctx *context, + return VMCI_ERROR_MORE_DATA; + } + +- dbells = kmalloc(data_size, GFP_ATOMIC); ++ dbells = kzalloc(data_size, GFP_ATOMIC); + if (!dbells) + return VMCI_ERROR_NO_MEM; + +diff --git a/drivers/net/wireless/marvell/mwifiex/join.c b/drivers/net/wireless/marvell/mwifiex/join.c +index d87aeff70cefb..c2cb1e711c06e 100644 +--- a/drivers/net/wireless/marvell/mwifiex/join.c ++++ b/drivers/net/wireless/marvell/mwifiex/join.c +@@ -877,6 +877,8 @@ mwifiex_cmd_802_11_ad_hoc_start(struct mwifiex_private *priv, + + memset(adhoc_start->ssid, 0, IEEE80211_MAX_SSID_LEN); + ++ if (req_ssid->ssid_len > IEEE80211_MAX_SSID_LEN) ++ req_ssid->ssid_len = IEEE80211_MAX_SSID_LEN; + memcpy(adhoc_start->ssid, req_ssid->ssid, req_ssid->ssid_len); + + mwifiex_dbg(adapter, INFO, "info: ADHOC_S_CMD: SSID = %s\n", +diff --git a/drivers/rtc/rtc-sun6i.c b/drivers/rtc/rtc-sun6i.c +index 8eb2b6dd36fea..1d0d9c8d0085d 100644 +--- a/drivers/rtc/rtc-sun6i.c ++++ b/drivers/rtc/rtc-sun6i.c +@@ -230,7 +230,7 @@ static void __init sun6i_rtc_clk_init(struct device_node *node) + 300000000); + if (IS_ERR(rtc->int_osc)) { + pr_crit("Couldn't register the internal oscillator\n"); +- return; ++ goto err; + } + + parents[0] = clk_hw_get_name(rtc->int_osc); +@@ -246,7 +246,7 @@ static void __init sun6i_rtc_clk_init(struct device_node *node) + rtc->losc = clk_register(NULL, &rtc->hw); + if (IS_ERR(rtc->losc)) { + pr_crit("Couldn't register the LOSC clock\n"); +- return; ++ goto err_register; + } + + of_property_read_string_index(node, "clock-output-names", 1, +@@ -257,7 +257,7 @@ static void __init sun6i_rtc_clk_init(struct device_node *node) + &rtc->lock); + if (IS_ERR(rtc->ext_losc)) { + pr_crit("Couldn't register the LOSC external gate\n"); +- return; ++ goto err_register; + } + + clk_data->num = 2; +@@ -266,6 +266,8 @@ static void __init sun6i_rtc_clk_init(struct device_node *node) + of_clk_add_hw_provider(node, of_clk_hw_onecell_get, clk_data); + return; + ++err_register: ++ clk_hw_unregister_fixed_rate(rtc->int_osc); + err: + kfree(clk_data); + } +diff --git a/drivers/s390/block/dasd_alias.c b/drivers/s390/block/dasd_alias.c +index 487b16ace0060..0f70cae1c01e3 100644 +--- a/drivers/s390/block/dasd_alias.c ++++ b/drivers/s390/block/dasd_alias.c +@@ -462,11 +462,19 @@ static int read_unit_address_configuration(struct dasd_device *device, + spin_unlock_irqrestore(&lcu->lock, flags); + + rc = dasd_sleep_on(cqr); +- if (rc && !suborder_not_supported(cqr)) { ++ if (!rc) ++ goto out; ++ ++ if (suborder_not_supported(cqr)) { ++ /* suborder not supported or device unusable for IO */ ++ rc = -EOPNOTSUPP; ++ } else { ++ /* IO failed but should be retried */ + spin_lock_irqsave(&lcu->lock, flags); + lcu->flags |= NEED_UAC_UPDATE; + spin_unlock_irqrestore(&lcu->lock, flags); + } ++out: + dasd_kfree_request(cqr, cqr->memdev); + return rc; + } +diff --git a/drivers/usb/serial/digi_acceleport.c b/drivers/usb/serial/digi_acceleport.c +index 2ce39af32cfa6..e494ffdc06bc9 100644 +--- a/drivers/usb/serial/digi_acceleport.c ++++ b/drivers/usb/serial/digi_acceleport.c +@@ -23,7 +23,6 @@ + #include <linux/tty_flip.h> + #include <linux/module.h> + #include <linux/spinlock.h> +-#include <linux/workqueue.h> + #include <linux/uaccess.h> + #include <linux/usb.h> + #include <linux/wait.h> +@@ -202,14 +201,12 @@ struct digi_port { + int dp_throttle_restart; + wait_queue_head_t dp_flush_wait; + wait_queue_head_t dp_close_wait; /* wait queue for close */ +- struct work_struct dp_wakeup_work; + struct usb_serial_port *dp_port; + }; + + + /* Local Function Declarations */ + +-static void digi_wakeup_write_lock(struct work_struct *work); + static int digi_write_oob_command(struct usb_serial_port *port, + unsigned char *buf, int count, int interruptible); + static int digi_write_inb_command(struct usb_serial_port *port, +@@ -360,26 +357,6 @@ __releases(lock) + return timeout; + } + +- +-/* +- * Digi Wakeup Write +- * +- * Wake up port, line discipline, and tty processes sleeping +- * on writes. +- */ +- +-static void digi_wakeup_write_lock(struct work_struct *work) +-{ +- struct digi_port *priv = +- container_of(work, struct digi_port, dp_wakeup_work); +- struct usb_serial_port *port = priv->dp_port; +- unsigned long flags; +- +- spin_lock_irqsave(&priv->dp_port_lock, flags); +- tty_port_tty_wakeup(&port->port); +- spin_unlock_irqrestore(&priv->dp_port_lock, flags); +-} +- + /* + * Digi Write OOB Command + * +@@ -990,6 +967,7 @@ static void digi_write_bulk_callback(struct urb *urb) + struct digi_serial *serial_priv; + int ret = 0; + int status = urb->status; ++ bool wakeup; + + /* port and serial sanity check */ + if (port == NULL || (priv = usb_get_serial_port_data(port)) == NULL) { +@@ -1016,6 +994,7 @@ static void digi_write_bulk_callback(struct urb *urb) + } + + /* try to send any buffered data on this port */ ++ wakeup = true; + spin_lock(&priv->dp_port_lock); + priv->dp_write_urb_in_use = 0; + if (priv->dp_out_buf_len > 0) { +@@ -1031,19 +1010,18 @@ static void digi_write_bulk_callback(struct urb *urb) + if (ret == 0) { + priv->dp_write_urb_in_use = 1; + priv->dp_out_buf_len = 0; ++ wakeup = false; + } + } +- /* wake up processes sleeping on writes immediately */ +- tty_port_tty_wakeup(&port->port); +- /* also queue up a wakeup at scheduler time, in case we */ +- /* lost the race in write_chan(). */ +- schedule_work(&priv->dp_wakeup_work); +- + spin_unlock(&priv->dp_port_lock); ++ + if (ret && ret != -EPERM) + dev_err_console(port, + "%s: usb_submit_urb failed, ret=%d, port=%d\n", + __func__, ret, priv->dp_port_num); ++ ++ if (wakeup) ++ tty_port_tty_wakeup(&port->port); + } + + static int digi_write_room(struct tty_struct *tty) +@@ -1243,7 +1221,6 @@ static int digi_port_init(struct usb_serial_port *port, unsigned port_num) + init_waitqueue_head(&priv->dp_transmit_idle_wait); + init_waitqueue_head(&priv->dp_flush_wait); + init_waitqueue_head(&priv->dp_close_wait); +- INIT_WORK(&priv->dp_wakeup_work, digi_wakeup_write_lock); + priv->dp_port = port; + + init_waitqueue_head(&port->write_wait); +@@ -1510,13 +1487,14 @@ static int digi_read_oob_callback(struct urb *urb) + rts = C_CRTSCTS(tty); + + if (tty && opcode == DIGI_CMD_READ_INPUT_SIGNALS) { ++ bool wakeup = false; ++ + spin_lock(&priv->dp_port_lock); + /* convert from digi flags to termiox flags */ + if (val & DIGI_READ_INPUT_SIGNALS_CTS) { + priv->dp_modem_signals |= TIOCM_CTS; +- /* port must be open to use tty struct */ + if (rts) +- tty_port_tty_wakeup(&port->port); ++ wakeup = true; + } else { + priv->dp_modem_signals &= ~TIOCM_CTS; + /* port must be open to use tty struct */ +@@ -1535,6 +1513,9 @@ static int digi_read_oob_callback(struct urb *urb) + priv->dp_modem_signals &= ~TIOCM_CD; + + spin_unlock(&priv->dp_port_lock); ++ ++ if (wakeup) ++ tty_port_tty_wakeup(&port->port); + } else if (opcode == DIGI_CMD_TRANSMIT_IDLE) { + spin_lock(&priv->dp_port_lock); + priv->dp_transmit_idle = 1; +diff --git a/drivers/vfio/pci/vfio_pci.c b/drivers/vfio/pci/vfio_pci.c +index 6fceefcab81db..dedc7edea5178 100644 +--- a/drivers/vfio/pci/vfio_pci.c ++++ b/drivers/vfio/pci/vfio_pci.c +@@ -118,8 +118,6 @@ static void vfio_pci_probe_mmaps(struct vfio_pci_device *vdev) + int bar; + struct vfio_pci_dummy_resource *dummy_res; + +- INIT_LIST_HEAD(&vdev->dummy_resources_list); +- + for (bar = PCI_STD_RESOURCES; bar <= PCI_STD_RESOURCE_END; bar++) { + res = vdev->pdev->resource + bar; + +@@ -1524,6 +1522,7 @@ static int vfio_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id) + vdev->irq_type = VFIO_PCI_NUM_IRQS; + mutex_init(&vdev->igate); + spin_lock_init(&vdev->irqlock); ++ INIT_LIST_HEAD(&vdev->dummy_resources_list); + mutex_init(&vdev->vma_lock); + INIT_LIST_HEAD(&vdev->vma_list); + init_rwsem(&vdev->memory_lock); +diff --git a/fs/quota/quota_tree.c b/fs/quota/quota_tree.c +index bb3f59bcfcf5b..656f9ff63edda 100644 +--- a/fs/quota/quota_tree.c ++++ b/fs/quota/quota_tree.c +@@ -61,7 +61,7 @@ static ssize_t read_blk(struct qtree_mem_dqinfo *info, uint blk, char *buf) + + memset(buf, 0, info->dqi_usable_bs); + return sb->s_op->quota_read(sb, info->dqi_type, buf, +- info->dqi_usable_bs, blk << info->dqi_blocksize_bits); ++ info->dqi_usable_bs, (loff_t)blk << info->dqi_blocksize_bits); + } + + static ssize_t write_blk(struct qtree_mem_dqinfo *info, uint blk, char *buf) +@@ -70,7 +70,7 @@ static ssize_t write_blk(struct qtree_mem_dqinfo *info, uint blk, char *buf) + ssize_t ret; + + ret = sb->s_op->quota_write(sb, info->dqi_type, buf, +- info->dqi_usable_bs, blk << info->dqi_blocksize_bits); ++ info->dqi_usable_bs, (loff_t)blk << info->dqi_blocksize_bits); + if (ret != info->dqi_usable_bs) { + quota_error(sb, "dquota write failed"); + if (ret >= 0) +@@ -283,7 +283,7 @@ static uint find_free_dqentry(struct qtree_mem_dqinfo *info, + blk); + goto out_buf; + } +- dquot->dq_off = (blk << info->dqi_blocksize_bits) + ++ dquot->dq_off = ((loff_t)blk << info->dqi_blocksize_bits) + + sizeof(struct qt_disk_dqdbheader) + + i * info->dqi_entry_size; + kfree(buf); +@@ -558,7 +558,7 @@ static loff_t find_block_dqentry(struct qtree_mem_dqinfo *info, + ret = -EIO; + goto out_buf; + } else { +- ret = (blk << info->dqi_blocksize_bits) + sizeof(struct ++ ret = ((loff_t)blk << info->dqi_blocksize_bits) + sizeof(struct + qt_disk_dqdbheader) + i * info->dqi_entry_size; + } + out_buf: +diff --git a/fs/reiserfs/stree.c b/fs/reiserfs/stree.c +index 2946713cb00d6..5229038852ca1 100644 +--- a/fs/reiserfs/stree.c ++++ b/fs/reiserfs/stree.c +@@ -454,6 +454,12 @@ static int is_leaf(char *buf, int blocksize, struct buffer_head *bh) + "(second one): %h", ih); + return 0; + } ++ if (is_direntry_le_ih(ih) && (ih_item_len(ih) < (ih_entry_count(ih) * IH_SIZE))) { ++ reiserfs_warning(NULL, "reiserfs-5093", ++ "item entry count seems wrong %h", ++ ih); ++ return 0; ++ } + prev_location = ih_location(ih); + } + +diff --git a/include/linux/kdev_t.h b/include/linux/kdev_t.h +index 85b5151911cfd..4856706fbfeb4 100644 +--- a/include/linux/kdev_t.h ++++ b/include/linux/kdev_t.h +@@ -21,61 +21,61 @@ + }) + + /* acceptable for old filesystems */ +-static inline bool old_valid_dev(dev_t dev) ++static __always_inline bool old_valid_dev(dev_t dev) + { + return MAJOR(dev) < 256 && MINOR(dev) < 256; + } + +-static inline u16 old_encode_dev(dev_t dev) ++static __always_inline u16 old_encode_dev(dev_t dev) + { + return (MAJOR(dev) << 8) | MINOR(dev); + } + +-static inline dev_t old_decode_dev(u16 val) ++static __always_inline dev_t old_decode_dev(u16 val) + { + return MKDEV((val >> 8) & 255, val & 255); + } + +-static inline u32 new_encode_dev(dev_t dev) ++static __always_inline u32 new_encode_dev(dev_t dev) + { + unsigned major = MAJOR(dev); + unsigned minor = MINOR(dev); + return (minor & 0xff) | (major << 8) | ((minor & ~0xff) << 12); + } + +-static inline dev_t new_decode_dev(u32 dev) ++static __always_inline dev_t new_decode_dev(u32 dev) + { + unsigned major = (dev & 0xfff00) >> 8; + unsigned minor = (dev & 0xff) | ((dev >> 12) & 0xfff00); + return MKDEV(major, minor); + } + +-static inline u64 huge_encode_dev(dev_t dev) ++static __always_inline u64 huge_encode_dev(dev_t dev) + { + return new_encode_dev(dev); + } + +-static inline dev_t huge_decode_dev(u64 dev) ++static __always_inline dev_t huge_decode_dev(u64 dev) + { + return new_decode_dev(dev); + } + +-static inline int sysv_valid_dev(dev_t dev) ++static __always_inline int sysv_valid_dev(dev_t dev) + { + return MAJOR(dev) < (1<<14) && MINOR(dev) < (1<<18); + } + +-static inline u32 sysv_encode_dev(dev_t dev) ++static __always_inline u32 sysv_encode_dev(dev_t dev) + { + return MINOR(dev) | (MAJOR(dev) << 18); + } + +-static inline unsigned sysv_major(u32 dev) ++static __always_inline unsigned sysv_major(u32 dev) + { + return (dev >> 18) & 0x3fff; + } + +-static inline unsigned sysv_minor(u32 dev) ++static __always_inline unsigned sysv_minor(u32 dev) + { + return dev & 0x3ffff; + } +diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h +index 69966c461d1c1..8820468635810 100644 +--- a/include/linux/memcontrol.h ++++ b/include/linux/memcontrol.h +@@ -108,7 +108,10 @@ struct lruvec_stat { + */ + struct mem_cgroup_per_node { + struct lruvec lruvec; +- struct lruvec_stat __percpu *lruvec_stat; ++ ++ struct lruvec_stat __percpu *lruvec_stat_cpu; ++ atomic_long_t lruvec_stat[NR_VM_NODE_STAT_ITEMS]; ++ + unsigned long lru_zone_size[MAX_NR_ZONES][NR_LRU_LISTS]; + + struct mem_cgroup_reclaim_iter iter[DEF_PRIORITY + 1]; +@@ -227,10 +230,10 @@ struct mem_cgroup { + spinlock_t move_lock; + struct task_struct *move_lock_task; + unsigned long move_lock_flags; +- /* +- * percpu counter. +- */ +- struct mem_cgroup_stat_cpu __percpu *stat; ++ ++ struct mem_cgroup_stat_cpu __percpu *stat_cpu; ++ atomic_long_t stat[MEMCG_NR_STAT]; ++ atomic_long_t events[MEMCG_NR_EVENTS]; + + unsigned long socket_pressure; + +@@ -265,6 +268,12 @@ struct mem_cgroup { + /* WARNING: nodeinfo must be the last member here */ + }; + ++/* ++ * size of first charge trial. "32" comes from vmscan.c's magic value. ++ * TODO: maybe necessary to use big numbers in big irons. ++ */ ++#define MEMCG_CHARGE_BATCH 32U ++ + extern struct mem_cgroup *root_mem_cgroup; + + static inline bool mem_cgroup_disabled(void) +@@ -272,13 +281,6 @@ static inline bool mem_cgroup_disabled(void) + return !cgroup_subsys_enabled(memory_cgrp_subsys); + } + +-static inline void mem_cgroup_event(struct mem_cgroup *memcg, +- enum memcg_event_item event) +-{ +- this_cpu_inc(memcg->stat->events[event]); +- cgroup_file_notify(&memcg->events_file); +-} +- + bool mem_cgroup_low(struct mem_cgroup *root, struct mem_cgroup *memcg); + + int mem_cgroup_try_charge(struct page *page, struct mm_struct *mm, +@@ -492,32 +494,38 @@ void unlock_page_memcg(struct page *page); + static inline unsigned long memcg_page_state(struct mem_cgroup *memcg, + int idx) + { +- long val = 0; +- int cpu; +- +- for_each_possible_cpu(cpu) +- val += per_cpu(memcg->stat->count[idx], cpu); +- +- if (val < 0) +- val = 0; +- +- return val; ++ long x = atomic_long_read(&memcg->stat[idx]); ++#ifdef CONFIG_SMP ++ if (x < 0) ++ x = 0; ++#endif ++ return x; + } + + /* idx can be of type enum memcg_stat_item or node_stat_item */ + static inline void __mod_memcg_state(struct mem_cgroup *memcg, + int idx, int val) + { +- if (!mem_cgroup_disabled()) +- __this_cpu_add(memcg->stat->count[idx], val); ++ long x; ++ ++ if (mem_cgroup_disabled()) ++ return; ++ ++ x = val + __this_cpu_read(memcg->stat_cpu->count[idx]); ++ if (unlikely(abs(x) > MEMCG_CHARGE_BATCH)) { ++ atomic_long_add(x, &memcg->stat[idx]); ++ x = 0; ++ } ++ __this_cpu_write(memcg->stat_cpu->count[idx], x); + } + + /* idx can be of type enum memcg_stat_item or node_stat_item */ + static inline void mod_memcg_state(struct mem_cgroup *memcg, + int idx, int val) + { +- if (!mem_cgroup_disabled()) +- this_cpu_add(memcg->stat->count[idx], val); ++ preempt_disable(); ++ __mod_memcg_state(memcg, idx, val); ++ preempt_enable(); + } + + /** +@@ -555,87 +563,108 @@ static inline unsigned long lruvec_page_state(struct lruvec *lruvec, + enum node_stat_item idx) + { + struct mem_cgroup_per_node *pn; +- long val = 0; +- int cpu; ++ long x; + + if (mem_cgroup_disabled()) + return node_page_state(lruvec_pgdat(lruvec), idx); + + pn = container_of(lruvec, struct mem_cgroup_per_node, lruvec); +- for_each_possible_cpu(cpu) +- val += per_cpu(pn->lruvec_stat->count[idx], cpu); +- +- if (val < 0) +- val = 0; +- +- return val; ++ x = atomic_long_read(&pn->lruvec_stat[idx]); ++#ifdef CONFIG_SMP ++ if (x < 0) ++ x = 0; ++#endif ++ return x; + } + + static inline void __mod_lruvec_state(struct lruvec *lruvec, + enum node_stat_item idx, int val) + { + struct mem_cgroup_per_node *pn; ++ long x; + ++ /* Update node */ + __mod_node_page_state(lruvec_pgdat(lruvec), idx, val); ++ + if (mem_cgroup_disabled()) + return; ++ + pn = container_of(lruvec, struct mem_cgroup_per_node, lruvec); ++ ++ /* Update memcg */ + __mod_memcg_state(pn->memcg, idx, val); +- __this_cpu_add(pn->lruvec_stat->count[idx], val); ++ ++ /* Update lruvec */ ++ x = val + __this_cpu_read(pn->lruvec_stat_cpu->count[idx]); ++ if (unlikely(abs(x) > MEMCG_CHARGE_BATCH)) { ++ atomic_long_add(x, &pn->lruvec_stat[idx]); ++ x = 0; ++ } ++ __this_cpu_write(pn->lruvec_stat_cpu->count[idx], x); + } + + static inline void mod_lruvec_state(struct lruvec *lruvec, + enum node_stat_item idx, int val) + { +- struct mem_cgroup_per_node *pn; +- +- mod_node_page_state(lruvec_pgdat(lruvec), idx, val); +- if (mem_cgroup_disabled()) +- return; +- pn = container_of(lruvec, struct mem_cgroup_per_node, lruvec); +- mod_memcg_state(pn->memcg, idx, val); +- this_cpu_add(pn->lruvec_stat->count[idx], val); ++ preempt_disable(); ++ __mod_lruvec_state(lruvec, idx, val); ++ preempt_enable(); + } + + static inline void __mod_lruvec_page_state(struct page *page, + enum node_stat_item idx, int val) + { +- struct mem_cgroup_per_node *pn; ++ pg_data_t *pgdat = page_pgdat(page); ++ struct lruvec *lruvec; + +- __mod_node_page_state(page_pgdat(page), idx, val); +- if (mem_cgroup_disabled() || !page->mem_cgroup) ++ /* Untracked pages have no memcg, no lruvec. Update only the node */ ++ if (!page->mem_cgroup) { ++ __mod_node_page_state(pgdat, idx, val); + return; +- __mod_memcg_state(page->mem_cgroup, idx, val); +- pn = page->mem_cgroup->nodeinfo[page_to_nid(page)]; +- __this_cpu_add(pn->lruvec_stat->count[idx], val); ++ } ++ ++ lruvec = mem_cgroup_lruvec(pgdat, page->mem_cgroup); ++ __mod_lruvec_state(lruvec, idx, val); + } + + static inline void mod_lruvec_page_state(struct page *page, + enum node_stat_item idx, int val) + { +- struct mem_cgroup_per_node *pn; +- +- mod_node_page_state(page_pgdat(page), idx, val); +- if (mem_cgroup_disabled() || !page->mem_cgroup) +- return; +- mod_memcg_state(page->mem_cgroup, idx, val); +- pn = page->mem_cgroup->nodeinfo[page_to_nid(page)]; +- this_cpu_add(pn->lruvec_stat->count[idx], val); ++ preempt_disable(); ++ __mod_lruvec_page_state(page, idx, val); ++ preempt_enable(); + } + + unsigned long mem_cgroup_soft_limit_reclaim(pg_data_t *pgdat, int order, + gfp_t gfp_mask, + unsigned long *total_scanned); + ++/* idx can be of type enum memcg_event_item or vm_event_item */ ++static inline void __count_memcg_events(struct mem_cgroup *memcg, ++ int idx, unsigned long count) ++{ ++ unsigned long x; ++ ++ if (mem_cgroup_disabled()) ++ return; ++ ++ x = count + __this_cpu_read(memcg->stat_cpu->events[idx]); ++ if (unlikely(x > MEMCG_CHARGE_BATCH)) { ++ atomic_long_add(x, &memcg->events[idx]); ++ x = 0; ++ } ++ __this_cpu_write(memcg->stat_cpu->events[idx], x); ++} ++ + static inline void count_memcg_events(struct mem_cgroup *memcg, +- enum vm_event_item idx, +- unsigned long count) ++ int idx, unsigned long count) + { +- if (!mem_cgroup_disabled()) +- this_cpu_add(memcg->stat->events[idx], count); ++ preempt_disable(); ++ __count_memcg_events(memcg, idx, count); ++ preempt_enable(); + } + +-/* idx can be of type enum memcg_stat_item or node_stat_item */ ++/* idx can be of type enum memcg_event_item or vm_event_item */ + static inline void count_memcg_page_event(struct page *page, + int idx) + { +@@ -654,12 +683,20 @@ static inline void count_memcg_event_mm(struct mm_struct *mm, + rcu_read_lock(); + memcg = mem_cgroup_from_task(rcu_dereference(mm->owner)); + if (likely(memcg)) { +- this_cpu_inc(memcg->stat->events[idx]); ++ count_memcg_events(memcg, idx, 1); + if (idx == OOM_KILL) + cgroup_file_notify(&memcg->events_file); + } + rcu_read_unlock(); + } ++ ++static inline void mem_cgroup_event(struct mem_cgroup *memcg, ++ enum memcg_event_item event) ++{ ++ count_memcg_events(memcg, event, 1); ++ cgroup_file_notify(&memcg->events_file); ++} ++ + #ifdef CONFIG_TRANSPARENT_HUGEPAGE + void mem_cgroup_split_huge_fixup(struct page *head); + #endif +diff --git a/include/linux/of.h b/include/linux/of.h +index 3c108f9be5e7c..af10856159226 100644 +--- a/include/linux/of.h ++++ b/include/linux/of.h +@@ -1163,6 +1163,7 @@ static inline int of_get_available_child_count(const struct device_node *np) + #define _OF_DECLARE(table, name, compat, fn, fn_type) \ + static const struct of_device_id __of_table_##name \ + __used __section(__##table##_of_table) \ ++ __aligned(__alignof__(struct of_device_id)) \ + = { .compatible = compat, \ + .data = (fn == (fn_type)NULL) ? fn : fn } + #else +diff --git a/include/uapi/linux/const.h b/include/uapi/linux/const.h +index 92537757590aa..dab9f34383e5b 100644 +--- a/include/uapi/linux/const.h ++++ b/include/uapi/linux/const.h +@@ -25,4 +25,9 @@ + #define _BITUL(x) (_AC(1,UL) << (x)) + #define _BITULL(x) (_AC(1,ULL) << (x)) + ++#define __ALIGN_KERNEL(x, a) __ALIGN_KERNEL_MASK(x, (typeof(x))(a) - 1) ++#define __ALIGN_KERNEL_MASK(x, mask) (((x) + (mask)) & ~(mask)) ++ ++#define __KERNEL_DIV_ROUND_UP(n, d) (((n) + (d) - 1) / (d)) ++ + #endif /* !(_LINUX_CONST_H) */ +diff --git a/include/uapi/linux/ethtool.h b/include/uapi/linux/ethtool.h +index 9eae13eefc49e..1e3f1a43bf1d9 100644 +--- a/include/uapi/linux/ethtool.h ++++ b/include/uapi/linux/ethtool.h +@@ -14,7 +14,7 @@ + #ifndef _UAPI_LINUX_ETHTOOL_H + #define _UAPI_LINUX_ETHTOOL_H + +-#include <linux/kernel.h> ++#include <linux/const.h> + #include <linux/types.h> + #include <linux/if_ether.h> + +diff --git a/include/uapi/linux/kernel.h b/include/uapi/linux/kernel.h +index 0ff8f7477847c..fadf2db71fe8a 100644 +--- a/include/uapi/linux/kernel.h ++++ b/include/uapi/linux/kernel.h +@@ -3,13 +3,6 @@ + #define _UAPI_LINUX_KERNEL_H + + #include <linux/sysinfo.h> +- +-/* +- * 'kernel.h' contains some often-used function prototypes etc +- */ +-#define __ALIGN_KERNEL(x, a) __ALIGN_KERNEL_MASK(x, (typeof(x))(a) - 1) +-#define __ALIGN_KERNEL_MASK(x, mask) (((x) + (mask)) & ~(mask)) +- +-#define __KERNEL_DIV_ROUND_UP(n, d) (((n) + (d) - 1) / (d)) ++#include <linux/const.h> + + #endif /* _UAPI_LINUX_KERNEL_H */ +diff --git a/include/uapi/linux/lightnvm.h b/include/uapi/linux/lightnvm.h +index 42d1a434af296..0d44ebba00932 100644 +--- a/include/uapi/linux/lightnvm.h ++++ b/include/uapi/linux/lightnvm.h +@@ -21,7 +21,7 @@ + #define _UAPI_LINUX_LIGHTNVM_H + + #ifdef __KERNEL__ +-#include <linux/kernel.h> ++#include <linux/const.h> + #include <linux/ioctl.h> + #else /* __KERNEL__ */ + #include <stdio.h> +diff --git a/include/uapi/linux/mroute6.h b/include/uapi/linux/mroute6.h +index 9999cc006390d..1617eb9949a5d 100644 +--- a/include/uapi/linux/mroute6.h ++++ b/include/uapi/linux/mroute6.h +@@ -2,7 +2,7 @@ + #ifndef _UAPI__LINUX_MROUTE6_H + #define _UAPI__LINUX_MROUTE6_H + +-#include <linux/kernel.h> ++#include <linux/const.h> + #include <linux/types.h> + #include <linux/sockios.h> + #include <linux/in6.h> /* For struct sockaddr_in6. */ +diff --git a/include/uapi/linux/netfilter/x_tables.h b/include/uapi/linux/netfilter/x_tables.h +index a8283f7dbc519..b8c6bb233ac1c 100644 +--- a/include/uapi/linux/netfilter/x_tables.h ++++ b/include/uapi/linux/netfilter/x_tables.h +@@ -1,7 +1,7 @@ + /* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ + #ifndef _UAPI_X_TABLES_H + #define _UAPI_X_TABLES_H +-#include <linux/kernel.h> ++#include <linux/const.h> + #include <linux/types.h> + + #define XT_FUNCTION_MAXNAMELEN 30 +diff --git a/include/uapi/linux/netlink.h b/include/uapi/linux/netlink.h +index 776bc92e91180..3481cde43a841 100644 +--- a/include/uapi/linux/netlink.h ++++ b/include/uapi/linux/netlink.h +@@ -2,7 +2,7 @@ + #ifndef _UAPI__LINUX_NETLINK_H + #define _UAPI__LINUX_NETLINK_H + +-#include <linux/kernel.h> ++#include <linux/const.h> + #include <linux/socket.h> /* for __kernel_sa_family_t */ + #include <linux/types.h> + +diff --git a/include/uapi/linux/sysctl.h b/include/uapi/linux/sysctl.h +index 0f272818a4d27..5fc0b7fd08470 100644 +--- a/include/uapi/linux/sysctl.h ++++ b/include/uapi/linux/sysctl.h +@@ -23,7 +23,7 @@ + #ifndef _UAPI_LINUX_SYSCTL_H + #define _UAPI_LINUX_SYSCTL_H + +-#include <linux/kernel.h> ++#include <linux/const.h> + #include <linux/types.h> + #include <linux/compiler.h> + +diff --git a/kernel/module.c b/kernel/module.c +index 2806c9b6577c1..0b2654592d3a7 100644 +--- a/kernel/module.c ++++ b/kernel/module.c +@@ -1789,7 +1789,6 @@ static int mod_sysfs_init(struct module *mod) + if (err) + mod_kobject_put(mod); + +- /* delay uevent until full sysfs population */ + out: + return err; + } +@@ -1826,7 +1825,6 @@ static int mod_sysfs_setup(struct module *mod, + add_sect_attrs(mod, info); + add_notes_attrs(mod, info); + +- kobject_uevent(&mod->mkobj.kobj, KOBJ_ADD); + return 0; + + out_unreg_modinfo_attrs: +@@ -3481,6 +3479,9 @@ static noinline int do_init_module(struct module *mod) + blocking_notifier_call_chain(&module_notify_list, + MODULE_STATE_LIVE, mod); + ++ /* Delay uevent until module has finished its init routine */ ++ kobject_uevent(&mod->mkobj.kobj, KOBJ_ADD); ++ + /* + * We need to finish all async code before the module init sequence + * is done. This has potential to deadlock. For example, a newly +@@ -3801,6 +3802,7 @@ static int load_module(struct load_info *info, const char __user *uargs, + MODULE_STATE_GOING, mod); + klp_module_going(mod); + bug_cleanup: ++ mod->state = MODULE_STATE_GOING; + /* module_bug_cleanup needs module_mutex protection */ + mutex_lock(&module_mutex); + module_bug_cleanup(mod); +diff --git a/mm/memcontrol.c b/mm/memcontrol.c +index 70707d44a6903..4e763cdccb335 100644 +--- a/mm/memcontrol.c ++++ b/mm/memcontrol.c +@@ -542,39 +542,10 @@ mem_cgroup_largest_soft_limit_node(struct mem_cgroup_tree_per_node *mctz) + return mz; + } + +-/* +- * Return page count for single (non recursive) @memcg. +- * +- * Implementation Note: reading percpu statistics for memcg. +- * +- * Both of vmstat[] and percpu_counter has threshold and do periodic +- * synchronization to implement "quick" read. There are trade-off between +- * reading cost and precision of value. Then, we may have a chance to implement +- * a periodic synchronization of counter in memcg's counter. +- * +- * But this _read() function is used for user interface now. The user accounts +- * memory usage by memory cgroup and he _always_ requires exact value because +- * he accounts memory. Even if we provide quick-and-fuzzy read, we always +- * have to visit all online cpus and make sum. So, for now, unnecessary +- * synchronization is not implemented. (just implemented for cpu hotplug) +- * +- * If there are kernel internal actions which can make use of some not-exact +- * value, and reading all cpu value can be performance bottleneck in some +- * common workload, threshold and synchronization as vmstat[] should be +- * implemented. +- * +- * The parameter idx can be of type enum memcg_event_item or vm_event_item. +- */ +- + static unsigned long memcg_sum_events(struct mem_cgroup *memcg, + int event) + { +- unsigned long val = 0; +- int cpu; +- +- for_each_possible_cpu(cpu) +- val += per_cpu(memcg->stat->events[event], cpu); +- return val; ++ return atomic_long_read(&memcg->events[event]); + } + + static void mem_cgroup_charge_statistics(struct mem_cgroup *memcg, +@@ -586,27 +557,27 @@ static void mem_cgroup_charge_statistics(struct mem_cgroup *memcg, + * counted as CACHE even if it's on ANON LRU. + */ + if (PageAnon(page)) +- __this_cpu_add(memcg->stat->count[MEMCG_RSS], nr_pages); ++ __mod_memcg_state(memcg, MEMCG_RSS, nr_pages); + else { +- __this_cpu_add(memcg->stat->count[MEMCG_CACHE], nr_pages); ++ __mod_memcg_state(memcg, MEMCG_CACHE, nr_pages); + if (PageSwapBacked(page)) +- __this_cpu_add(memcg->stat->count[NR_SHMEM], nr_pages); ++ __mod_memcg_state(memcg, NR_SHMEM, nr_pages); + } + + if (compound) { + VM_BUG_ON_PAGE(!PageTransHuge(page), page); +- __this_cpu_add(memcg->stat->count[MEMCG_RSS_HUGE], nr_pages); ++ __mod_memcg_state(memcg, MEMCG_RSS_HUGE, nr_pages); + } + + /* pagein of a big page is an event. So, ignore page size */ + if (nr_pages > 0) +- __this_cpu_inc(memcg->stat->events[PGPGIN]); ++ __count_memcg_events(memcg, PGPGIN, 1); + else { +- __this_cpu_inc(memcg->stat->events[PGPGOUT]); ++ __count_memcg_events(memcg, PGPGOUT, 1); + nr_pages = -nr_pages; /* for event */ + } + +- __this_cpu_add(memcg->stat->nr_page_events, nr_pages); ++ __this_cpu_add(memcg->stat_cpu->nr_page_events, nr_pages); + } + + unsigned long mem_cgroup_node_nr_lru_pages(struct mem_cgroup *memcg, +@@ -642,8 +613,8 @@ static bool mem_cgroup_event_ratelimit(struct mem_cgroup *memcg, + { + unsigned long val, next; + +- val = __this_cpu_read(memcg->stat->nr_page_events); +- next = __this_cpu_read(memcg->stat->targets[target]); ++ val = __this_cpu_read(memcg->stat_cpu->nr_page_events); ++ next = __this_cpu_read(memcg->stat_cpu->targets[target]); + /* from time_after() in jiffies.h */ + if ((long)(next - val) < 0) { + switch (target) { +@@ -659,7 +630,7 @@ static bool mem_cgroup_event_ratelimit(struct mem_cgroup *memcg, + default: + break; + } +- __this_cpu_write(memcg->stat->targets[target], next); ++ __this_cpu_write(memcg->stat_cpu->targets[target], next); + return true; + } + return false; +@@ -1726,11 +1697,6 @@ void unlock_page_memcg(struct page *page) + } + EXPORT_SYMBOL(unlock_page_memcg); + +-/* +- * size of first charge trial. "32" comes from vmscan.c's magic value. +- * TODO: maybe necessary to use big numbers in big irons. +- */ +-#define CHARGE_BATCH 32U + struct memcg_stock_pcp { + struct mem_cgroup *cached; /* this never be root cgroup */ + unsigned int nr_pages; +@@ -1758,7 +1724,7 @@ static bool consume_stock(struct mem_cgroup *memcg, unsigned int nr_pages) + unsigned long flags; + bool ret = false; + +- if (nr_pages > CHARGE_BATCH) ++ if (nr_pages > MEMCG_CHARGE_BATCH) + return ret; + + local_irq_save(flags); +@@ -1827,7 +1793,7 @@ static void refill_stock(struct mem_cgroup *memcg, unsigned int nr_pages) + } + stock->nr_pages += nr_pages; + +- if (stock->nr_pages > CHARGE_BATCH) ++ if (stock->nr_pages > MEMCG_CHARGE_BATCH) + drain_stock(stock); + + local_irq_restore(flags); +@@ -1877,9 +1843,44 @@ static void drain_all_stock(struct mem_cgroup *root_memcg) + static int memcg_hotplug_cpu_dead(unsigned int cpu) + { + struct memcg_stock_pcp *stock; ++ struct mem_cgroup *memcg; + + stock = &per_cpu(memcg_stock, cpu); + drain_stock(stock); ++ ++ for_each_mem_cgroup(memcg) { ++ int i; ++ ++ for (i = 0; i < MEMCG_NR_STAT; i++) { ++ int nid; ++ long x; ++ ++ x = this_cpu_xchg(memcg->stat_cpu->count[i], 0); ++ if (x) ++ atomic_long_add(x, &memcg->stat[i]); ++ ++ if (i >= NR_VM_NODE_STAT_ITEMS) ++ continue; ++ ++ for_each_node(nid) { ++ struct mem_cgroup_per_node *pn; ++ ++ pn = mem_cgroup_nodeinfo(memcg, nid); ++ x = this_cpu_xchg(pn->lruvec_stat_cpu->count[i], 0); ++ if (x) ++ atomic_long_add(x, &pn->lruvec_stat[i]); ++ } ++ } ++ ++ for (i = 0; i < MEMCG_NR_EVENTS; i++) { ++ long x; ++ ++ x = this_cpu_xchg(memcg->stat_cpu->events[i], 0); ++ if (x) ++ atomic_long_add(x, &memcg->events[i]); ++ } ++ } ++ + return 0; + } + +@@ -1900,7 +1901,7 @@ static void high_work_func(struct work_struct *work) + struct mem_cgroup *memcg; + + memcg = container_of(work, struct mem_cgroup, high_work); +- reclaim_high(memcg, CHARGE_BATCH, GFP_KERNEL); ++ reclaim_high(memcg, MEMCG_CHARGE_BATCH, GFP_KERNEL); + } + + /* +@@ -1924,7 +1925,7 @@ void mem_cgroup_handle_over_high(void) + static int try_charge(struct mem_cgroup *memcg, gfp_t gfp_mask, + unsigned int nr_pages) + { +- unsigned int batch = max(CHARGE_BATCH, nr_pages); ++ unsigned int batch = max(MEMCG_CHARGE_BATCH, nr_pages); + int nr_retries = MEM_CGROUP_RECLAIM_RETRIES; + struct mem_cgroup *mem_over_limit; + struct page_counter *counter; +@@ -2444,18 +2445,11 @@ void mem_cgroup_split_huge_fixup(struct page *head) + for (i = 1; i < HPAGE_PMD_NR; i++) + head[i].mem_cgroup = head->mem_cgroup; + +- __this_cpu_sub(head->mem_cgroup->stat->count[MEMCG_RSS_HUGE], +- HPAGE_PMD_NR); ++ __mod_memcg_state(head->mem_cgroup, MEMCG_RSS_HUGE, -HPAGE_PMD_NR); + } + #endif /* CONFIG_TRANSPARENT_HUGEPAGE */ + + #ifdef CONFIG_MEMCG_SWAP +-static void mem_cgroup_swap_statistics(struct mem_cgroup *memcg, +- int nr_entries) +-{ +- this_cpu_add(memcg->stat->count[MEMCG_SWAP], nr_entries); +-} +- + /** + * mem_cgroup_move_swap_account - move swap charge and swap_cgroup's record. + * @entry: swap entry to be moved +@@ -2479,8 +2473,8 @@ static int mem_cgroup_move_swap_account(swp_entry_t entry, + new_id = mem_cgroup_id(to); + + if (swap_cgroup_cmpxchg(entry, old_id, new_id) == old_id) { +- mem_cgroup_swap_statistics(from, -1); +- mem_cgroup_swap_statistics(to, 1); ++ mod_memcg_state(from, MEMCG_SWAP, -1); ++ mod_memcg_state(to, MEMCG_SWAP, 1); + return 0; + } + return -EINVAL; +@@ -4210,8 +4204,8 @@ static int alloc_mem_cgroup_per_node_info(struct mem_cgroup *memcg, int node) + if (!pn) + return 1; + +- pn->lruvec_stat = alloc_percpu(struct lruvec_stat); +- if (!pn->lruvec_stat) { ++ pn->lruvec_stat_cpu = alloc_percpu(struct lruvec_stat); ++ if (!pn->lruvec_stat_cpu) { + kfree(pn); + return 1; + } +@@ -4232,7 +4226,7 @@ static void free_mem_cgroup_per_node_info(struct mem_cgroup *memcg, int node) + if (!pn) + return; + +- free_percpu(pn->lruvec_stat); ++ free_percpu(pn->lruvec_stat_cpu); + kfree(pn); + } + +@@ -4242,7 +4236,7 @@ static void __mem_cgroup_free(struct mem_cgroup *memcg) + + for_each_node(node) + free_mem_cgroup_per_node_info(memcg, node); +- free_percpu(memcg->stat); ++ free_percpu(memcg->stat_cpu); + kfree(memcg); + } + +@@ -4271,8 +4265,8 @@ static struct mem_cgroup *mem_cgroup_alloc(void) + if (memcg->id.id < 0) + goto fail; + +- memcg->stat = alloc_percpu(struct mem_cgroup_stat_cpu); +- if (!memcg->stat) ++ memcg->stat_cpu = alloc_percpu(struct mem_cgroup_stat_cpu); ++ if (!memcg->stat_cpu) + goto fail; + + for_each_node(node) +@@ -4632,8 +4626,8 @@ static int mem_cgroup_move_account(struct page *page, + spin_lock_irqsave(&from->move_lock, flags); + + if (!anon && page_mapped(page)) { +- __this_cpu_sub(from->stat->count[NR_FILE_MAPPED], nr_pages); +- __this_cpu_add(to->stat->count[NR_FILE_MAPPED], nr_pages); ++ __mod_memcg_state(from, NR_FILE_MAPPED, -nr_pages); ++ __mod_memcg_state(to, NR_FILE_MAPPED, nr_pages); + } + + /* +@@ -4645,16 +4639,14 @@ static int mem_cgroup_move_account(struct page *page, + struct address_space *mapping = page_mapping(page); + + if (mapping_cap_account_dirty(mapping)) { +- __this_cpu_sub(from->stat->count[NR_FILE_DIRTY], +- nr_pages); +- __this_cpu_add(to->stat->count[NR_FILE_DIRTY], +- nr_pages); ++ __mod_memcg_state(from, NR_FILE_DIRTY, -nr_pages); ++ __mod_memcg_state(to, NR_FILE_DIRTY, nr_pages); + } + } + + if (PageWriteback(page)) { +- __this_cpu_sub(from->stat->count[NR_WRITEBACK], nr_pages); +- __this_cpu_add(to->stat->count[NR_WRITEBACK], nr_pages); ++ __mod_memcg_state(from, NR_WRITEBACK, -nr_pages); ++ __mod_memcg_state(to, NR_WRITEBACK, nr_pages); + } + + /* +@@ -5690,12 +5682,12 @@ static void uncharge_batch(const struct uncharge_gather *ug) + } + + local_irq_save(flags); +- __this_cpu_sub(ug->memcg->stat->count[MEMCG_RSS], ug->nr_anon); +- __this_cpu_sub(ug->memcg->stat->count[MEMCG_CACHE], ug->nr_file); +- __this_cpu_sub(ug->memcg->stat->count[MEMCG_RSS_HUGE], ug->nr_huge); +- __this_cpu_sub(ug->memcg->stat->count[NR_SHMEM], ug->nr_shmem); +- __this_cpu_add(ug->memcg->stat->events[PGPGOUT], ug->pgpgout); +- __this_cpu_add(ug->memcg->stat->nr_page_events, nr_pages); ++ __mod_memcg_state(ug->memcg, MEMCG_RSS, -ug->nr_anon); ++ __mod_memcg_state(ug->memcg, MEMCG_CACHE, -ug->nr_file); ++ __mod_memcg_state(ug->memcg, MEMCG_RSS_HUGE, -ug->nr_huge); ++ __mod_memcg_state(ug->memcg, NR_SHMEM, -ug->nr_shmem); ++ __count_memcg_events(ug->memcg, PGPGOUT, ug->pgpgout); ++ __this_cpu_add(ug->memcg->stat_cpu->nr_page_events, nr_pages); + memcg_check_events(ug->memcg, ug->dummy_page); + local_irq_restore(flags); + +@@ -5926,7 +5918,7 @@ bool mem_cgroup_charge_skmem(struct mem_cgroup *memcg, unsigned int nr_pages) + if (in_softirq()) + gfp_mask = GFP_NOWAIT; + +- this_cpu_add(memcg->stat->count[MEMCG_SOCK], nr_pages); ++ mod_memcg_state(memcg, MEMCG_SOCK, nr_pages); + + if (try_charge(memcg, gfp_mask, nr_pages) == 0) + return true; +@@ -5947,7 +5939,7 @@ void mem_cgroup_uncharge_skmem(struct mem_cgroup *memcg, unsigned int nr_pages) + return; + } + +- this_cpu_sub(memcg->stat->count[MEMCG_SOCK], nr_pages); ++ mod_memcg_state(memcg, MEMCG_SOCK, -nr_pages); + + refill_stock(memcg, nr_pages); + } +@@ -6071,7 +6063,7 @@ void mem_cgroup_swapout(struct page *page, swp_entry_t entry) + oldid = swap_cgroup_record(entry, mem_cgroup_id(swap_memcg), + nr_entries); + VM_BUG_ON_PAGE(oldid, page); +- mem_cgroup_swap_statistics(swap_memcg, nr_entries); ++ mod_memcg_state(swap_memcg, MEMCG_SWAP, nr_entries); + + page->mem_cgroup = NULL; + +@@ -6137,7 +6129,7 @@ int mem_cgroup_try_charge_swap(struct page *page, swp_entry_t entry) + mem_cgroup_id_get_many(memcg, nr_pages - 1); + oldid = swap_cgroup_record(entry, mem_cgroup_id(memcg), nr_pages); + VM_BUG_ON_PAGE(oldid, page); +- mem_cgroup_swap_statistics(memcg, nr_pages); ++ mod_memcg_state(memcg, MEMCG_SWAP, nr_pages); + + return 0; + } +@@ -6165,7 +6157,7 @@ void mem_cgroup_uncharge_swap(swp_entry_t entry, unsigned int nr_pages) + else + page_counter_uncharge(&memcg->memsw, nr_pages); + } +- mem_cgroup_swap_statistics(memcg, -nr_pages); ++ mod_memcg_state(memcg, MEMCG_SWAP, -nr_pages); + mem_cgroup_id_put_many(memcg, nr_pages); + } + rcu_read_unlock(); +diff --git a/sound/core/pcm_native.c b/sound/core/pcm_native.c +index 071e09c3d8557..c78db361cbbaa 100644 +--- a/sound/core/pcm_native.c ++++ b/sound/core/pcm_native.c +@@ -721,8 +721,13 @@ static int snd_pcm_hw_params(struct snd_pcm_substream *substream, + runtime->boundary *= 2; + + /* clear the buffer for avoiding possible kernel info leaks */ +- if (runtime->dma_area && !substream->ops->copy_user) +- memset(runtime->dma_area, 0, runtime->dma_bytes); ++ if (runtime->dma_area && !substream->ops->copy_user) { ++ size_t size = runtime->dma_bytes; ++ ++ if (runtime->info & SNDRV_PCM_INFO_MMAP) ++ size = PAGE_ALIGN(size); ++ memset(runtime->dma_area, 0, size); ++ } + + snd_pcm_timer_resolution_change(substream); + snd_pcm_set_state(substream, SNDRV_PCM_STATE_SETUP); +diff --git a/sound/core/seq/seq_queue.h b/sound/core/seq/seq_queue.h +index 719093489a2c4..7909cf6040e3d 100644 +--- a/sound/core/seq/seq_queue.h ++++ b/sound/core/seq/seq_queue.h +@@ -40,10 +40,10 @@ struct snd_seq_queue { + + struct snd_seq_timer *timer; /* time keeper for this queue */ + int owner; /* client that 'owns' the timer */ +- unsigned int locked:1, /* timer is only accesibble by owner if set */ +- klocked:1, /* kernel lock (after START) */ +- check_again:1, +- check_blocked:1; ++ bool locked; /* timer is only accesibble by owner if set */ ++ bool klocked; /* kernel lock (after START) */ ++ bool check_again; /* concurrent access happened during check */ ++ bool check_blocked; /* queue being checked */ + + unsigned int flags; /* status flags */ + unsigned int info_flags; /* info for sync */ +diff --git a/sound/pci/hda/patch_ca0132.c b/sound/pci/hda/patch_ca0132.c +index 92f5f452bee2b..369f812d70722 100644 +--- a/sound/pci/hda/patch_ca0132.c ++++ b/sound/pci/hda/patch_ca0132.c +@@ -4443,11 +4443,10 @@ static void hp_callback(struct hda_codec *codec, struct hda_jack_callback *cb) + /* Delay enabling the HP amp, to let the mic-detection + * state machine run. + */ +- cancel_delayed_work(&spec->unsol_hp_work); +- schedule_delayed_work(&spec->unsol_hp_work, msecs_to_jiffies(500)); + tbl = snd_hda_jack_tbl_get(codec, cb->nid); + if (tbl) + tbl->block_report = 1; ++ schedule_delayed_work(&spec->unsol_hp_work, msecs_to_jiffies(500)); + } + + static void amic_callback(struct hda_codec *codec, struct hda_jack_callback *cb) +@@ -4625,12 +4624,25 @@ static void ca0132_free(struct hda_codec *codec) + kfree(codec->spec); + } + ++#ifdef CONFIG_PM ++static int ca0132_suspend(struct hda_codec *codec) ++{ ++ struct ca0132_spec *spec = codec->spec; ++ ++ cancel_delayed_work_sync(&spec->unsol_hp_work); ++ return 0; ++} ++#endif ++ + static const struct hda_codec_ops ca0132_patch_ops = { + .build_controls = ca0132_build_controls, + .build_pcms = ca0132_build_pcms, + .init = ca0132_init, + .free = ca0132_free, + .unsol_event = snd_hda_jack_unsol_event, ++#ifdef CONFIG_PM ++ .suspend = ca0132_suspend, ++#endif + }; + + static void ca0132_config(struct hda_codec *codec) +diff --git a/sound/usb/pcm.c b/sound/usb/pcm.c +index 6caf94581a0e8..ecdbdb26164ea 100644 +--- a/sound/usb/pcm.c ++++ b/sound/usb/pcm.c +@@ -324,6 +324,7 @@ static int set_sync_ep_implicit_fb_quirk(struct snd_usb_substream *subs, + struct usb_host_interface *alts; + struct usb_interface *iface; + unsigned int ep; ++ unsigned int ifnum; + + /* Implicit feedback sync EPs consumers are always playback EPs */ + if (subs->direction != SNDRV_PCM_STREAM_PLAYBACK) +@@ -334,44 +335,23 @@ static int set_sync_ep_implicit_fb_quirk(struct snd_usb_substream *subs, + case USB_ID(0x0763, 0x2031): /* M-Audio Fast Track C600 */ + case USB_ID(0x22f0, 0x0006): /* Allen&Heath Qu-16 */ + ep = 0x81; +- iface = usb_ifnum_to_if(dev, 3); +- +- if (!iface || iface->num_altsetting == 0) +- return -EINVAL; +- +- alts = &iface->altsetting[1]; +- goto add_sync_ep; +- break; ++ ifnum = 3; ++ goto add_sync_ep_from_ifnum; + case USB_ID(0x0763, 0x2080): /* M-Audio FastTrack Ultra */ + case USB_ID(0x0763, 0x2081): + ep = 0x81; +- iface = usb_ifnum_to_if(dev, 2); +- +- if (!iface || iface->num_altsetting == 0) +- return -EINVAL; +- +- alts = &iface->altsetting[1]; +- goto add_sync_ep; +- case USB_ID(0x2466, 0x8003): ++ ifnum = 2; ++ goto add_sync_ep_from_ifnum; ++ case USB_ID(0x2466, 0x8003): /* Fractal Audio Axe-Fx II */ + ep = 0x86; +- iface = usb_ifnum_to_if(dev, 2); +- +- if (!iface || iface->num_altsetting == 0) +- return -EINVAL; +- +- alts = &iface->altsetting[1]; +- goto add_sync_ep; +- case USB_ID(0x1397, 0x0002): ++ ifnum = 2; ++ goto add_sync_ep_from_ifnum; ++ case USB_ID(0x1397, 0x0002): /* Behringer UFX1204 */ + ep = 0x81; +- iface = usb_ifnum_to_if(dev, 1); +- +- if (!iface || iface->num_altsetting == 0) +- return -EINVAL; +- +- alts = &iface->altsetting[1]; +- goto add_sync_ep; +- ++ ifnum = 1; ++ goto add_sync_ep_from_ifnum; + } ++ + if (attr == USB_ENDPOINT_SYNC_ASYNC && + altsd->bInterfaceClass == USB_CLASS_VENDOR_SPEC && + altsd->bInterfaceProtocol == 2 && +@@ -386,6 +366,14 @@ static int set_sync_ep_implicit_fb_quirk(struct snd_usb_substream *subs, + /* No quirk */ + return 0; + ++add_sync_ep_from_ifnum: ++ iface = usb_ifnum_to_if(dev, ifnum); ++ ++ if (!iface || iface->num_altsetting < 2) ++ return -EINVAL; ++ ++ alts = &iface->altsetting[1]; ++ + add_sync_ep: + subs->sync_endpoint = snd_usb_add_endpoint(subs->stream->chip, + alts, ep, !subs->direction,
