commit: 5a7ae131b7b69198d892277ab46031299237a9a6 Author: Mike Pagano <mpagano <AT> gentoo <DOT> org> AuthorDate: Thu Oct 9 19:54:07 2014 +0000 Commit: Mike Pagano <mpagano <AT> gentoo <DOT> org> CommitDate: Thu Oct 9 19:54:07 2014 +0000 URL: http://sources.gentoo.org/gitweb/?p=proj/linux-patches.git;a=commit;h=5a7ae131
Linux patch 3.16.5 --- 0000_README | 8 + 1004_linux-3.16.5.patch | 987 ++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 995 insertions(+) diff --git a/0000_README b/0000_README index 25ca364..ede03f9 100644 --- a/0000_README +++ b/0000_README @@ -54,6 +54,14 @@ Patch: 1002_linux-3.16.3.patch From: http://www.kernel.org Desc: Linux 3.16.3 +Patch: 1003_linux-3.16.4.patch +From: http://www.kernel.org +Desc: Linux 3.16.4 + +Patch: 1004_linux-3.16.5.patch +From: http://www.kernel.org +Desc: Linux 3.16.5 + 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/1004_linux-3.16.5.patch b/1004_linux-3.16.5.patch new file mode 100644 index 0000000..248afad --- /dev/null +++ b/1004_linux-3.16.5.patch @@ -0,0 +1,987 @@ +diff --git a/Makefile b/Makefile +index e75c75f0ec35..41efc3d9f2e0 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,6 +1,6 @@ + VERSION = 3 + PATCHLEVEL = 16 +-SUBLEVEL = 4 ++SUBLEVEL = 5 + EXTRAVERSION = + NAME = Museum of Fishiegoodies + +diff --git a/arch/ia64/pci/fixup.c b/arch/ia64/pci/fixup.c +index 1fe9aa5068ea..fc505d58f078 100644 +--- a/arch/ia64/pci/fixup.c ++++ b/arch/ia64/pci/fixup.c +@@ -6,6 +6,7 @@ + #include <linux/pci.h> + #include <linux/init.h> + #include <linux/vgaarb.h> ++#include <linux/screen_info.h> + + #include <asm/machvec.h> + +@@ -61,8 +62,7 @@ static void pci_fixup_video(struct pci_dev *pdev) + pci_read_config_word(pdev, PCI_COMMAND, &config); + if (config & (PCI_COMMAND_IO | PCI_COMMAND_MEMORY)) { + pdev->resource[PCI_ROM_RESOURCE].flags |= IORESOURCE_ROM_SHADOW; +- dev_printk(KERN_DEBUG, &pdev->dev, "Boot video device\n"); +- vga_set_default_device(pdev); ++ dev_printk(KERN_DEBUG, &pdev->dev, "Video device with shadowed ROM\n"); + } + } + } +diff --git a/arch/x86/include/asm/vga.h b/arch/x86/include/asm/vga.h +index 44282fbf7bf9..c4b9dc2f67c5 100644 +--- a/arch/x86/include/asm/vga.h ++++ b/arch/x86/include/asm/vga.h +@@ -17,10 +17,4 @@ + #define vga_readb(x) (*(x)) + #define vga_writeb(x, y) (*(y) = (x)) + +-#ifdef CONFIG_FB_EFI +-#define __ARCH_HAS_VGA_DEFAULT_DEVICE +-extern struct pci_dev *vga_default_device(void); +-extern void vga_set_default_device(struct pci_dev *pdev); +-#endif +- + #endif /* _ASM_X86_VGA_H */ +diff --git a/arch/x86/pci/fixup.c b/arch/x86/pci/fixup.c +index b5e60268d93f..9a2b7101ae8a 100644 +--- a/arch/x86/pci/fixup.c ++++ b/arch/x86/pci/fixup.c +@@ -350,8 +350,7 @@ static void pci_fixup_video(struct pci_dev *pdev) + pci_read_config_word(pdev, PCI_COMMAND, &config); + if (config & (PCI_COMMAND_IO | PCI_COMMAND_MEMORY)) { + pdev->resource[PCI_ROM_RESOURCE].flags |= IORESOURCE_ROM_SHADOW; +- dev_printk(KERN_DEBUG, &pdev->dev, "Boot video device\n"); +- vga_set_default_device(pdev); ++ dev_printk(KERN_DEBUG, &pdev->dev, "Video device with shadowed ROM\n"); + } + } + } +diff --git a/drivers/cpufreq/integrator-cpufreq.c b/drivers/cpufreq/integrator-cpufreq.c +index e5122f1bfe78..302eb5c55d01 100644 +--- a/drivers/cpufreq/integrator-cpufreq.c ++++ b/drivers/cpufreq/integrator-cpufreq.c +@@ -213,9 +213,9 @@ static int __init integrator_cpufreq_probe(struct platform_device *pdev) + return cpufreq_register_driver(&integrator_driver); + } + +-static void __exit integrator_cpufreq_remove(struct platform_device *pdev) ++static int __exit integrator_cpufreq_remove(struct platform_device *pdev) + { +- cpufreq_unregister_driver(&integrator_driver); ++ return cpufreq_unregister_driver(&integrator_driver); + } + + static const struct of_device_id integrator_cpufreq_match[] = { +diff --git a/drivers/cpufreq/pcc-cpufreq.c b/drivers/cpufreq/pcc-cpufreq.c +index 728a2d879499..4d2c8e861089 100644 +--- a/drivers/cpufreq/pcc-cpufreq.c ++++ b/drivers/cpufreq/pcc-cpufreq.c +@@ -204,7 +204,6 @@ static int pcc_cpufreq_target(struct cpufreq_policy *policy, + u32 input_buffer; + int cpu; + +- spin_lock(&pcc_lock); + cpu = policy->cpu; + pcc_cpu_data = per_cpu_ptr(pcc_cpu_info, cpu); + +@@ -216,6 +215,7 @@ static int pcc_cpufreq_target(struct cpufreq_policy *policy, + freqs.old = policy->cur; + freqs.new = target_freq; + cpufreq_freq_transition_begin(policy, &freqs); ++ spin_lock(&pcc_lock); + + input_buffer = 0x1 | (((target_freq * 100) + / (ioread32(&pcch_hdr->nominal) * 1000)) << 8); +diff --git a/drivers/gpu/drm/i915/i915_gem_gtt.c b/drivers/gpu/drm/i915/i915_gem_gtt.c +index 8b3cde703364..8faabb95cd65 100644 +--- a/drivers/gpu/drm/i915/i915_gem_gtt.c ++++ b/drivers/gpu/drm/i915/i915_gem_gtt.c +@@ -1297,6 +1297,16 @@ void i915_check_and_clear_faults(struct drm_device *dev) + POSTING_READ(RING_FAULT_REG(&dev_priv->ring[RCS])); + } + ++static void i915_ggtt_flush(struct drm_i915_private *dev_priv) ++{ ++ if (INTEL_INFO(dev_priv->dev)->gen < 6) { ++ intel_gtt_chipset_flush(); ++ } else { ++ I915_WRITE(GFX_FLSH_CNTL_GEN6, GFX_FLSH_CNTL_EN); ++ POSTING_READ(GFX_FLSH_CNTL_GEN6); ++ } ++} ++ + void i915_gem_suspend_gtt_mappings(struct drm_device *dev) + { + struct drm_i915_private *dev_priv = dev->dev_private; +@@ -1313,6 +1323,8 @@ void i915_gem_suspend_gtt_mappings(struct drm_device *dev) + dev_priv->gtt.base.start, + dev_priv->gtt.base.total, + true); ++ ++ i915_ggtt_flush(dev_priv); + } + + void i915_gem_restore_gtt_mappings(struct drm_device *dev) +@@ -1365,7 +1377,7 @@ void i915_gem_restore_gtt_mappings(struct drm_device *dev) + gen6_write_pdes(container_of(vm, struct i915_hw_ppgtt, base)); + } + +- i915_gem_chipset_flush(dev); ++ i915_ggtt_flush(dev_priv); + } + + int i915_gem_gtt_prepare_object(struct drm_i915_gem_object *obj) +diff --git a/drivers/gpu/drm/i915/intel_opregion.c b/drivers/gpu/drm/i915/intel_opregion.c +index 4f6b53998d79..b9135dc3fe5d 100644 +--- a/drivers/gpu/drm/i915/intel_opregion.c ++++ b/drivers/gpu/drm/i915/intel_opregion.c +@@ -395,6 +395,16 @@ int intel_opregion_notify_adapter(struct drm_device *dev, pci_power_t state) + return -EINVAL; + } + ++/* ++ * If the vendor backlight interface is not in use and ACPI backlight interface ++ * is broken, do not bother processing backlight change requests from firmware. ++ */ ++static bool should_ignore_backlight_request(void) ++{ ++ return acpi_video_backlight_support() && ++ !acpi_video_verify_backlight_support(); ++} ++ + static u32 asle_set_backlight(struct drm_device *dev, u32 bclp) + { + struct drm_i915_private *dev_priv = dev->dev_private; +@@ -403,11 +413,7 @@ static u32 asle_set_backlight(struct drm_device *dev, u32 bclp) + + DRM_DEBUG_DRIVER("bclp = 0x%08x\n", bclp); + +- /* +- * If the acpi_video interface is not supposed to be used, don't +- * bother processing backlight level change requests from firmware. +- */ +- if (!acpi_video_verify_backlight_support()) { ++ if (should_ignore_backlight_request()) { + DRM_DEBUG_KMS("opregion backlight request ignored\n"); + return 0; + } +diff --git a/drivers/gpu/vga/vgaarb.c b/drivers/gpu/vga/vgaarb.c +index af0259708358..366641d0483f 100644 +--- a/drivers/gpu/vga/vgaarb.c ++++ b/drivers/gpu/vga/vgaarb.c +@@ -41,6 +41,7 @@ + #include <linux/poll.h> + #include <linux/miscdevice.h> + #include <linux/slab.h> ++#include <linux/screen_info.h> + + #include <linux/uaccess.h> + +@@ -580,8 +581,11 @@ static bool vga_arbiter_add_pci_device(struct pci_dev *pdev) + */ + #ifndef __ARCH_HAS_VGA_DEFAULT_DEVICE + if (vga_default == NULL && +- ((vgadev->owns & VGA_RSRC_LEGACY_MASK) == VGA_RSRC_LEGACY_MASK)) ++ ((vgadev->owns & VGA_RSRC_LEGACY_MASK) == VGA_RSRC_LEGACY_MASK)) { ++ pr_info("vgaarb: setting as boot device: PCI:%s\n", ++ pci_name(pdev)); + vga_set_default_device(pdev); ++ } + #endif + + vga_arbiter_check_bridge_sharing(vgadev); +@@ -1316,6 +1320,38 @@ static int __init vga_arb_device_init(void) + pr_info("vgaarb: loaded\n"); + + list_for_each_entry(vgadev, &vga_list, list) { ++#if defined(CONFIG_X86) || defined(CONFIG_IA64) ++ /* Override I/O based detection done by vga_arbiter_add_pci_device() ++ * as it may take the wrong device (e.g. on Apple system under EFI). ++ * ++ * Select the device owning the boot framebuffer if there is one. ++ */ ++ resource_size_t start, end; ++ int i; ++ ++ /* Does firmware framebuffer belong to us? */ ++ for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) { ++ if (!(pci_resource_flags(vgadev->pdev, i) & IORESOURCE_MEM)) ++ continue; ++ ++ start = pci_resource_start(vgadev->pdev, i); ++ end = pci_resource_end(vgadev->pdev, i); ++ ++ if (!start || !end) ++ continue; ++ ++ if (screen_info.lfb_base < start || ++ (screen_info.lfb_base + screen_info.lfb_size) >= end) ++ continue; ++ if (!vga_default_device()) ++ pr_info("vgaarb: setting as boot device: PCI:%s\n", ++ pci_name(vgadev->pdev)); ++ else if (vgadev->pdev != vga_default_device()) ++ pr_info("vgaarb: overriding boot device: PCI:%s\n", ++ pci_name(vgadev->pdev)); ++ vga_set_default_device(vgadev->pdev); ++ } ++#endif + if (vgadev->bridge_has_one_vga) + pr_info("vgaarb: bridge control possible %s\n", pci_name(vgadev->pdev)); + else +diff --git a/drivers/i2c/busses/i2c-qup.c b/drivers/i2c/busses/i2c-qup.c +index 2a5efb5b487c..eb47c98131ec 100644 +--- a/drivers/i2c/busses/i2c-qup.c ++++ b/drivers/i2c/busses/i2c-qup.c +@@ -670,16 +670,20 @@ static int qup_i2c_probe(struct platform_device *pdev) + qup->adap.dev.of_node = pdev->dev.of_node; + strlcpy(qup->adap.name, "QUP I2C adapter", sizeof(qup->adap.name)); + +- ret = i2c_add_adapter(&qup->adap); +- if (ret) +- goto fail; +- + pm_runtime_set_autosuspend_delay(qup->dev, MSEC_PER_SEC); + pm_runtime_use_autosuspend(qup->dev); + pm_runtime_set_active(qup->dev); + pm_runtime_enable(qup->dev); ++ ++ ret = i2c_add_adapter(&qup->adap); ++ if (ret) ++ goto fail_runtime; ++ + return 0; + ++fail_runtime: ++ pm_runtime_disable(qup->dev); ++ pm_runtime_set_suspended(qup->dev); + fail: + qup_i2c_disable_clocks(qup); + return ret; +diff --git a/drivers/i2c/busses/i2c-rk3x.c b/drivers/i2c/busses/i2c-rk3x.c +index 93cfc837200b..b38b0529946a 100644 +--- a/drivers/i2c/busses/i2c-rk3x.c ++++ b/drivers/i2c/busses/i2c-rk3x.c +@@ -238,7 +238,7 @@ static void rk3x_i2c_fill_transmit_buf(struct rk3x_i2c *i2c) + for (i = 0; i < 8; ++i) { + val = 0; + for (j = 0; j < 4; ++j) { +- if (i2c->processed == i2c->msg->len) ++ if ((i2c->processed == i2c->msg->len) && (cnt != 0)) + break; + + if (i2c->processed == 0 && cnt == 0) +diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c +index 183588b11fc1..9f0fbecd1eb5 100644 +--- a/drivers/md/raid5.c ++++ b/drivers/md/raid5.c +@@ -64,6 +64,10 @@ + #define cpu_to_group(cpu) cpu_to_node(cpu) + #define ANY_GROUP NUMA_NO_NODE + ++static bool devices_handle_discard_safely = false; ++module_param(devices_handle_discard_safely, bool, 0644); ++MODULE_PARM_DESC(devices_handle_discard_safely, ++ "Set to Y if all devices in each array reliably return zeroes on reads from discarded regions"); + static struct workqueue_struct *raid5_wq; + /* + * Stripe cache +@@ -6208,7 +6212,7 @@ static int run(struct mddev *mddev) + mddev->queue->limits.discard_granularity = stripe; + /* + * unaligned part of discard request will be ignored, so can't +- * guarantee discard_zerors_data ++ * guarantee discard_zeroes_data + */ + mddev->queue->limits.discard_zeroes_data = 0; + +@@ -6233,6 +6237,18 @@ static int run(struct mddev *mddev) + !bdev_get_queue(rdev->bdev)-> + limits.discard_zeroes_data) + discard_supported = false; ++ /* Unfortunately, discard_zeroes_data is not currently ++ * a guarantee - just a hint. So we only allow DISCARD ++ * if the sysadmin has confirmed that only safe devices ++ * are in use by setting a module parameter. ++ */ ++ if (!devices_handle_discard_safely) { ++ if (discard_supported) { ++ pr_info("md/raid456: discard support disabled due to uncertainty.\n"); ++ pr_info("Set raid456.devices_handle_discard_safely=Y to override.\n"); ++ } ++ discard_supported = false; ++ } + } + + if (discard_supported && +diff --git a/drivers/media/v4l2-core/videobuf2-core.c b/drivers/media/v4l2-core/videobuf2-core.c +index dcdceae30ab0..a946523772d6 100644 +--- a/drivers/media/v4l2-core/videobuf2-core.c ++++ b/drivers/media/v4l2-core/videobuf2-core.c +@@ -967,6 +967,7 @@ static int __reqbufs(struct vb2_queue *q, struct v4l2_requestbuffers *req) + * to the userspace. + */ + req->count = allocated_buffers; ++ q->waiting_for_buffers = !V4L2_TYPE_IS_OUTPUT(q->type); + + return 0; + } +@@ -1014,6 +1015,7 @@ static int __create_bufs(struct vb2_queue *q, struct v4l2_create_buffers *create + memset(q->plane_sizes, 0, sizeof(q->plane_sizes)); + memset(q->alloc_ctx, 0, sizeof(q->alloc_ctx)); + q->memory = create->memory; ++ q->waiting_for_buffers = !V4L2_TYPE_IS_OUTPUT(q->type); + } + + num_buffers = min(create->count, VIDEO_MAX_FRAME - q->num_buffers); +@@ -1812,6 +1814,7 @@ static int vb2_internal_qbuf(struct vb2_queue *q, struct v4l2_buffer *b) + */ + list_add_tail(&vb->queued_entry, &q->queued_list); + q->queued_count++; ++ q->waiting_for_buffers = false; + vb->state = VB2_BUF_STATE_QUEUED; + if (V4L2_TYPE_IS_OUTPUT(q->type)) { + /* +@@ -2244,6 +2247,7 @@ static int vb2_internal_streamoff(struct vb2_queue *q, enum v4l2_buf_type type) + * their normal dequeued state. + */ + __vb2_queue_cancel(q); ++ q->waiting_for_buffers = !V4L2_TYPE_IS_OUTPUT(q->type); + + dprintk(3, "successful\n"); + return 0; +@@ -2562,9 +2566,16 @@ unsigned int vb2_poll(struct vb2_queue *q, struct file *file, poll_table *wait) + } + + /* +- * There is nothing to wait for if no buffers have already been queued. ++ * There is nothing to wait for if the queue isn't streaming. + */ +- if (list_empty(&q->queued_list)) ++ if (!vb2_is_streaming(q)) ++ return res | POLLERR; ++ /* ++ * For compatibility with vb1: if QBUF hasn't been called yet, then ++ * return POLLERR as well. This only affects capture queues, output ++ * queues will always initialize waiting_for_buffers to false. ++ */ ++ if (q->waiting_for_buffers) + return res | POLLERR; + + if (list_empty(&q->done_list)) +diff --git a/drivers/usb/storage/uas-detect.h b/drivers/usb/storage/uas-detect.h +index bb05b984d5f6..8a6f371ed6e7 100644 +--- a/drivers/usb/storage/uas-detect.h ++++ b/drivers/usb/storage/uas-detect.h +@@ -9,32 +9,15 @@ static int uas_is_interface(struct usb_host_interface *intf) + intf->desc.bInterfaceProtocol == USB_PR_UAS); + } + +-static int uas_isnt_supported(struct usb_device *udev) +-{ +- struct usb_hcd *hcd = bus_to_hcd(udev->bus); +- +- dev_warn(&udev->dev, "The driver for the USB controller %s does not " +- "support scatter-gather which is\n", +- hcd->driver->description); +- dev_warn(&udev->dev, "required by the UAS driver. Please try an" +- "alternative USB controller if you wish to use UAS.\n"); +- return -ENODEV; +-} +- + static int uas_find_uas_alt_setting(struct usb_interface *intf) + { + int i; +- struct usb_device *udev = interface_to_usbdev(intf); +- int sg_supported = udev->bus->sg_tablesize != 0; + + for (i = 0; i < intf->num_altsetting; i++) { + struct usb_host_interface *alt = &intf->altsetting[i]; + +- if (uas_is_interface(alt)) { +- if (!sg_supported) +- return uas_isnt_supported(udev); ++ if (uas_is_interface(alt)) + return alt->desc.bAlternateSetting; +- } + } + + return -ENODEV; +@@ -76,13 +59,6 @@ static int uas_use_uas_driver(struct usb_interface *intf, + unsigned long flags = id->driver_info; + int r, alt; + +- usb_stor_adjust_quirks(udev, &flags); +- +- if (flags & US_FL_IGNORE_UAS) +- return 0; +- +- if (udev->speed >= USB_SPEED_SUPER && !hcd->can_do_streams) +- return 0; + + alt = uas_find_uas_alt_setting(intf); + if (alt < 0) +@@ -92,5 +68,46 @@ static int uas_use_uas_driver(struct usb_interface *intf, + if (r < 0) + return 0; + ++ /* ++ * ASM1051 and older ASM1053 devices have the same usb-id, and UAS is ++ * broken on the ASM1051, use the number of streams to differentiate. ++ * New ASM1053-s also support 32 streams, but have a different prod-id. ++ */ ++ if (le16_to_cpu(udev->descriptor.idVendor) == 0x174c && ++ le16_to_cpu(udev->descriptor.idProduct) == 0x55aa) { ++ if (udev->speed < USB_SPEED_SUPER) { ++ /* No streams info, assume ASM1051 */ ++ flags |= US_FL_IGNORE_UAS; ++ } else if (usb_ss_max_streams(&eps[1]->ss_ep_comp) == 32) { ++ flags |= US_FL_IGNORE_UAS; ++ } ++ } ++ ++ usb_stor_adjust_quirks(udev, &flags); ++ ++ if (flags & US_FL_IGNORE_UAS) { ++ dev_warn(&udev->dev, ++ "UAS is blacklisted for this device, using usb-storage instead\n"); ++ return 0; ++ } ++ ++ if (udev->bus->sg_tablesize == 0) { ++ dev_warn(&udev->dev, ++ "The driver for the USB controller %s does not support scatter-gather which is\n", ++ hcd->driver->description); ++ dev_warn(&udev->dev, ++ "required by the UAS driver. Please try an other USB controller if you wish to use UAS.\n"); ++ return 0; ++ } ++ ++ if (udev->speed >= USB_SPEED_SUPER && !hcd->can_do_streams) { ++ dev_warn(&udev->dev, ++ "USB controller %s does not support streams, which are required by the UAS driver.\n", ++ hcd_to_bus(hcd)->bus_name); ++ dev_warn(&udev->dev, ++ "Please try an other USB controller if you wish to use UAS.\n"); ++ return 0; ++ } ++ + return 1; + } +diff --git a/drivers/video/fbdev/efifb.c b/drivers/video/fbdev/efifb.c +index ae9618ff6735..982f6abe6faf 100644 +--- a/drivers/video/fbdev/efifb.c ++++ b/drivers/video/fbdev/efifb.c +@@ -19,8 +19,6 @@ + + static bool request_mem_succeeded = false; + +-static struct pci_dev *default_vga; +- + static struct fb_var_screeninfo efifb_defined = { + .activate = FB_ACTIVATE_NOW, + .height = -1, +@@ -84,23 +82,10 @@ static struct fb_ops efifb_ops = { + .fb_imageblit = cfb_imageblit, + }; + +-struct pci_dev *vga_default_device(void) +-{ +- return default_vga; +-} +- +-EXPORT_SYMBOL_GPL(vga_default_device); +- +-void vga_set_default_device(struct pci_dev *pdev) +-{ +- default_vga = pdev; +-} +- + static int efifb_setup(char *options) + { + char *this_opt; + int i; +- struct pci_dev *dev = NULL; + + if (options && *options) { + while ((this_opt = strsep(&options, ",")) != NULL) { +@@ -126,30 +111,6 @@ static int efifb_setup(char *options) + } + } + +- for_each_pci_dev(dev) { +- int i; +- +- if ((dev->class >> 8) != PCI_CLASS_DISPLAY_VGA) +- continue; +- +- for (i=0; i < DEVICE_COUNT_RESOURCE; i++) { +- resource_size_t start, end; +- +- if (!(pci_resource_flags(dev, i) & IORESOURCE_MEM)) +- continue; +- +- start = pci_resource_start(dev, i); +- end = pci_resource_end(dev, i); +- +- if (!start || !end) +- continue; +- +- if (screen_info.lfb_base >= start && +- (screen_info.lfb_base + screen_info.lfb_size) < end) +- default_vga = dev; +- } +- } +- + return 0; + } + +diff --git a/fs/cifs/smb1ops.c b/fs/cifs/smb1ops.c +index 84ca0a4caaeb..e9ad8d37bb00 100644 +--- a/fs/cifs/smb1ops.c ++++ b/fs/cifs/smb1ops.c +@@ -586,7 +586,7 @@ cifs_query_path_info(const unsigned int xid, struct cifs_tcon *tcon, + tmprc = CIFS_open(xid, &oparms, &oplock, NULL); + if (tmprc == -EOPNOTSUPP) + *symlink = true; +- else ++ else if (tmprc == 0) + CIFSSMBClose(xid, tcon, fid.netfid); + } + +diff --git a/fs/cifs/smb2maperror.c b/fs/cifs/smb2maperror.c +index a689514e260f..a491814cb2c0 100644 +--- a/fs/cifs/smb2maperror.c ++++ b/fs/cifs/smb2maperror.c +@@ -256,6 +256,8 @@ static const struct status_to_posix_error smb2_error_map_table[] = { + {STATUS_DLL_MIGHT_BE_INCOMPATIBLE, -EIO, + "STATUS_DLL_MIGHT_BE_INCOMPATIBLE"}, + {STATUS_STOPPED_ON_SYMLINK, -EOPNOTSUPP, "STATUS_STOPPED_ON_SYMLINK"}, ++ {STATUS_IO_REPARSE_TAG_NOT_HANDLED, -EOPNOTSUPP, ++ "STATUS_REPARSE_NOT_HANDLED"}, + {STATUS_DEVICE_REQUIRES_CLEANING, -EIO, + "STATUS_DEVICE_REQUIRES_CLEANING"}, + {STATUS_DEVICE_DOOR_OPEN, -EIO, "STATUS_DEVICE_DOOR_OPEN"}, +diff --git a/fs/udf/inode.c b/fs/udf/inode.c +index 236cd48184c2..a932f7740b51 100644 +--- a/fs/udf/inode.c ++++ b/fs/udf/inode.c +@@ -1271,13 +1271,22 @@ update_time: + return 0; + } + ++/* ++ * Maximum length of linked list formed by ICB hierarchy. The chosen number is ++ * arbitrary - just that we hopefully don't limit any real use of rewritten ++ * inode on write-once media but avoid looping for too long on corrupted media. ++ */ ++#define UDF_MAX_ICB_NESTING 1024 ++ + static void __udf_read_inode(struct inode *inode) + { + struct buffer_head *bh = NULL; + struct fileEntry *fe; + uint16_t ident; + struct udf_inode_info *iinfo = UDF_I(inode); ++ unsigned int indirections = 0; + ++reread: + /* + * Set defaults, but the inode is still incomplete! + * Note: get_new_inode() sets the following on a new inode: +@@ -1314,28 +1323,26 @@ static void __udf_read_inode(struct inode *inode) + ibh = udf_read_ptagged(inode->i_sb, &iinfo->i_location, 1, + &ident); + if (ident == TAG_IDENT_IE && ibh) { +- struct buffer_head *nbh = NULL; + struct kernel_lb_addr loc; + struct indirectEntry *ie; + + ie = (struct indirectEntry *)ibh->b_data; + loc = lelb_to_cpu(ie->indirectICB.extLocation); + +- if (ie->indirectICB.extLength && +- (nbh = udf_read_ptagged(inode->i_sb, &loc, 0, +- &ident))) { +- if (ident == TAG_IDENT_FE || +- ident == TAG_IDENT_EFE) { +- memcpy(&iinfo->i_location, +- &loc, +- sizeof(struct kernel_lb_addr)); +- brelse(bh); +- brelse(ibh); +- brelse(nbh); +- __udf_read_inode(inode); ++ if (ie->indirectICB.extLength) { ++ brelse(bh); ++ brelse(ibh); ++ memcpy(&iinfo->i_location, &loc, ++ sizeof(struct kernel_lb_addr)); ++ if (++indirections > UDF_MAX_ICB_NESTING) { ++ udf_err(inode->i_sb, ++ "too many ICBs in ICB hierarchy" ++ " (max %d supported)\n", ++ UDF_MAX_ICB_NESTING); ++ make_bad_inode(inode); + return; + } +- brelse(nbh); ++ goto reread; + } + } + brelse(ibh); +diff --git a/include/linux/jiffies.h b/include/linux/jiffies.h +index 1f44466c1e9d..c367cbdf73ab 100644 +--- a/include/linux/jiffies.h ++++ b/include/linux/jiffies.h +@@ -258,23 +258,11 @@ extern unsigned long preset_lpj; + #define SEC_JIFFIE_SC (32 - SHIFT_HZ) + #endif + #define NSEC_JIFFIE_SC (SEC_JIFFIE_SC + 29) +-#define USEC_JIFFIE_SC (SEC_JIFFIE_SC + 19) + #define SEC_CONVERSION ((unsigned long)((((u64)NSEC_PER_SEC << SEC_JIFFIE_SC) +\ + TICK_NSEC -1) / (u64)TICK_NSEC)) + + #define NSEC_CONVERSION ((unsigned long)((((u64)1 << NSEC_JIFFIE_SC) +\ + TICK_NSEC -1) / (u64)TICK_NSEC)) +-#define USEC_CONVERSION \ +- ((unsigned long)((((u64)NSEC_PER_USEC << USEC_JIFFIE_SC) +\ +- TICK_NSEC -1) / (u64)TICK_NSEC)) +-/* +- * USEC_ROUND is used in the timeval to jiffie conversion. See there +- * for more details. It is the scaled resolution rounding value. Note +- * that it is a 64-bit value. Since, when it is applied, we are already +- * in jiffies (albit scaled), it is nothing but the bits we will shift +- * off. +- */ +-#define USEC_ROUND (u64)(((u64)1 << USEC_JIFFIE_SC) - 1) + /* + * The maximum jiffie value is (MAX_INT >> 1). Here we translate that + * into seconds. The 64-bit case will overflow if we are not careful, +diff --git a/include/media/videobuf2-core.h b/include/media/videobuf2-core.h +index 8fab6fa0dbfb..d6f010c17f4a 100644 +--- a/include/media/videobuf2-core.h ++++ b/include/media/videobuf2-core.h +@@ -375,6 +375,9 @@ struct v4l2_fh; + * @streaming: current streaming state + * @start_streaming_called: start_streaming() was called successfully and we + * started streaming. ++ * @waiting_for_buffers: used in poll() to check if vb2 is still waiting for ++ * buffers. Only set for capture queues if qbuf has not yet been ++ * called since poll() needs to return POLLERR in that situation. + * @fileio: file io emulator internal data, used only if emulator is active + * @threadio: thread io internal data, used only if thread is active + */ +@@ -411,6 +414,7 @@ struct vb2_queue { + + unsigned int streaming:1; + unsigned int start_streaming_called:1; ++ unsigned int waiting_for_buffers:1; + + struct vb2_fileio_data *fileio; + struct vb2_threadio_data *threadio; +diff --git a/init/Kconfig b/init/Kconfig +index 9d76b99af1b9..35685a46e4da 100644 +--- a/init/Kconfig ++++ b/init/Kconfig +@@ -1432,6 +1432,7 @@ config FUTEX + + config HAVE_FUTEX_CMPXCHG + bool ++ depends on FUTEX + help + Architectures should select this if futex_atomic_cmpxchg_inatomic() + is implemented and always working. This removes a couple of runtime +diff --git a/kernel/events/core.c b/kernel/events/core.c +index f626c9f1f3c0..2065959042ea 100644 +--- a/kernel/events/core.c ++++ b/kernel/events/core.c +@@ -7921,8 +7921,10 @@ int perf_event_init_task(struct task_struct *child) + + for_each_task_context_nr(ctxn) { + ret = perf_event_init_context(child, ctxn); +- if (ret) ++ if (ret) { ++ perf_event_free_task(child); + return ret; ++ } + } + + return 0; +diff --git a/kernel/fork.c b/kernel/fork.c +index 6a13c46cd87d..b41958b0cb67 100644 +--- a/kernel/fork.c ++++ b/kernel/fork.c +@@ -1326,7 +1326,7 @@ static struct task_struct *copy_process(unsigned long clone_flags, + goto bad_fork_cleanup_policy; + retval = audit_alloc(p); + if (retval) +- goto bad_fork_cleanup_policy; ++ goto bad_fork_cleanup_perf; + /* copy all the process information */ + retval = copy_semundo(clone_flags, p); + if (retval) +@@ -1525,8 +1525,9 @@ bad_fork_cleanup_semundo: + exit_sem(p); + bad_fork_cleanup_audit: + audit_free(p); +-bad_fork_cleanup_policy: ++bad_fork_cleanup_perf: + perf_event_free_task(p); ++bad_fork_cleanup_policy: + #ifdef CONFIG_NUMA + mpol_put(p->mempolicy); + bad_fork_cleanup_threadgroup_lock: +diff --git a/kernel/time.c b/kernel/time.c +index 7c7964c33ae7..3c49ab45f822 100644 +--- a/kernel/time.c ++++ b/kernel/time.c +@@ -496,17 +496,20 @@ EXPORT_SYMBOL(usecs_to_jiffies); + * that a remainder subtract here would not do the right thing as the + * resolution values don't fall on second boundries. I.e. the line: + * nsec -= nsec % TICK_NSEC; is NOT a correct resolution rounding. ++ * Note that due to the small error in the multiplier here, this ++ * rounding is incorrect for sufficiently large values of tv_nsec, but ++ * well formed timespecs should have tv_nsec < NSEC_PER_SEC, so we're ++ * OK. + * + * Rather, we just shift the bits off the right. + * + * The >> (NSEC_JIFFIE_SC - SEC_JIFFIE_SC) converts the scaled nsec + * value to a scaled second value. + */ +-unsigned long +-timespec_to_jiffies(const struct timespec *value) ++static unsigned long ++__timespec_to_jiffies(unsigned long sec, long nsec) + { +- unsigned long sec = value->tv_sec; +- long nsec = value->tv_nsec + TICK_NSEC - 1; ++ nsec = nsec + TICK_NSEC - 1; + + if (sec >= MAX_SEC_IN_JIFFIES){ + sec = MAX_SEC_IN_JIFFIES; +@@ -517,6 +520,13 @@ timespec_to_jiffies(const struct timespec *value) + (NSEC_JIFFIE_SC - SEC_JIFFIE_SC))) >> SEC_JIFFIE_SC; + + } ++ ++unsigned long ++timespec_to_jiffies(const struct timespec *value) ++{ ++ return __timespec_to_jiffies(value->tv_sec, value->tv_nsec); ++} ++ + EXPORT_SYMBOL(timespec_to_jiffies); + + void +@@ -533,31 +543,27 @@ jiffies_to_timespec(const unsigned long jiffies, struct timespec *value) + } + EXPORT_SYMBOL(jiffies_to_timespec); + +-/* Same for "timeval" ++/* ++ * We could use a similar algorithm to timespec_to_jiffies (with a ++ * different multiplier for usec instead of nsec). But this has a ++ * problem with rounding: we can't exactly add TICK_NSEC - 1 to the ++ * usec value, since it's not necessarily integral. + * +- * Well, almost. The problem here is that the real system resolution is +- * in nanoseconds and the value being converted is in micro seconds. +- * Also for some machines (those that use HZ = 1024, in-particular), +- * there is a LARGE error in the tick size in microseconds. +- +- * The solution we use is to do the rounding AFTER we convert the +- * microsecond part. Thus the USEC_ROUND, the bits to be shifted off. +- * Instruction wise, this should cost only an additional add with carry +- * instruction above the way it was done above. ++ * We could instead round in the intermediate scaled representation ++ * (i.e. in units of 1/2^(large scale) jiffies) but that's also ++ * perilous: the scaling introduces a small positive error, which ++ * combined with a division-rounding-upward (i.e. adding 2^(scale) - 1 ++ * units to the intermediate before shifting) leads to accidental ++ * overflow and overestimates. ++ * ++ * At the cost of one additional multiplication by a constant, just ++ * use the timespec implementation. + */ + unsigned long + timeval_to_jiffies(const struct timeval *value) + { +- unsigned long sec = value->tv_sec; +- long usec = value->tv_usec; +- +- if (sec >= MAX_SEC_IN_JIFFIES){ +- sec = MAX_SEC_IN_JIFFIES; +- usec = 0; +- } +- return (((u64)sec * SEC_CONVERSION) + +- (((u64)usec * USEC_CONVERSION + USEC_ROUND) >> +- (USEC_JIFFIE_SC - SEC_JIFFIE_SC))) >> SEC_JIFFIE_SC; ++ return __timespec_to_jiffies(value->tv_sec, ++ value->tv_usec * NSEC_PER_USEC); + } + EXPORT_SYMBOL(timeval_to_jiffies); + +diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c +index 2ff0580d3dcd..51862982e1e9 100644 +--- a/kernel/trace/ring_buffer.c ++++ b/kernel/trace/ring_buffer.c +@@ -3375,7 +3375,7 @@ static void rb_iter_reset(struct ring_buffer_iter *iter) + iter->head = cpu_buffer->reader_page->read; + + iter->cache_reader_page = iter->head_page; +- iter->cache_read = iter->head; ++ iter->cache_read = cpu_buffer->read; + + if (iter->head) + iter->read_stamp = cpu_buffer->read_stamp; +diff --git a/mm/huge_memory.c b/mm/huge_memory.c +index 33514d88fef9..c9ef81e08e4a 100644 +--- a/mm/huge_memory.c ++++ b/mm/huge_memory.c +@@ -1775,21 +1775,24 @@ static int __split_huge_page_map(struct page *page, + if (pmd) { + pgtable = pgtable_trans_huge_withdraw(mm, pmd); + pmd_populate(mm, &_pmd, pgtable); ++ if (pmd_write(*pmd)) ++ BUG_ON(page_mapcount(page) != 1); + + haddr = address; + for (i = 0; i < HPAGE_PMD_NR; i++, haddr += PAGE_SIZE) { + pte_t *pte, entry; + BUG_ON(PageCompound(page+i)); ++ /* ++ * Note that pmd_numa is not transferred deliberately ++ * to avoid any possibility that pte_numa leaks to ++ * a PROT_NONE VMA by accident. ++ */ + entry = mk_pte(page + i, vma->vm_page_prot); + entry = maybe_mkwrite(pte_mkdirty(entry), vma); + if (!pmd_write(*pmd)) + entry = pte_wrprotect(entry); +- else +- BUG_ON(page_mapcount(page) != 1); + if (!pmd_young(*pmd)) + entry = pte_mkold(entry); +- if (pmd_numa(*pmd)) +- entry = pte_mknuma(entry); + pte = pte_offset_map(&_pmd, haddr); + BUG_ON(!pte_none(*pte)); + set_pte_at(mm, haddr, pte, entry); +diff --git a/mm/memcontrol.c b/mm/memcontrol.c +index 1f14a430c656..15fe66d83987 100644 +--- a/mm/memcontrol.c ++++ b/mm/memcontrol.c +@@ -292,6 +292,9 @@ struct mem_cgroup { + /* vmpressure notifications */ + struct vmpressure vmpressure; + ++ /* css_online() has been completed */ ++ int initialized; ++ + /* + * the counter to account for mem+swap usage. + */ +@@ -1106,10 +1109,21 @@ skip_node: + * skipping css reference should be safe. + */ + if (next_css) { +- if ((next_css == &root->css) || +- ((next_css->flags & CSS_ONLINE) && +- css_tryget_online(next_css))) +- return mem_cgroup_from_css(next_css); ++ struct mem_cgroup *memcg = mem_cgroup_from_css(next_css); ++ ++ if (next_css == &root->css) ++ return memcg; ++ ++ if (css_tryget_online(next_css)) { ++ /* ++ * Make sure the memcg is initialized: ++ * mem_cgroup_css_online() orders the the ++ * initialization against setting the flag. ++ */ ++ if (smp_load_acquire(&memcg->initialized)) ++ return memcg; ++ css_put(next_css); ++ } + + prev_css = next_css; + goto skip_node; +@@ -6277,6 +6291,7 @@ mem_cgroup_css_online(struct cgroup_subsys_state *css) + { + struct mem_cgroup *memcg = mem_cgroup_from_css(css); + struct mem_cgroup *parent = mem_cgroup_from_css(css->parent); ++ int ret; + + if (css->id > MEM_CGROUP_ID_MAX) + return -ENOSPC; +@@ -6313,7 +6328,18 @@ mem_cgroup_css_online(struct cgroup_subsys_state *css) + } + mutex_unlock(&memcg_create_mutex); + +- return memcg_init_kmem(memcg, &memory_cgrp_subsys); ++ ret = memcg_init_kmem(memcg, &memory_cgrp_subsys); ++ if (ret) ++ return ret; ++ ++ /* ++ * Make sure the memcg is initialized: mem_cgroup_iter() ++ * orders reading memcg->initialized against its callers ++ * reading the memcg members. ++ */ ++ smp_store_release(&memcg->initialized, 1); ++ ++ return 0; + } + + /* +diff --git a/mm/migrate.c b/mm/migrate.c +index be6dbf995c0c..0bba97914af0 100644 +--- a/mm/migrate.c ++++ b/mm/migrate.c +@@ -146,8 +146,11 @@ static int remove_migration_pte(struct page *new, struct vm_area_struct *vma, + pte = pte_mkold(mk_pte(new, vma->vm_page_prot)); + if (pte_swp_soft_dirty(*ptep)) + pte = pte_mksoft_dirty(pte); ++ ++ /* Recheck VMA as permissions can change since migration started */ + if (is_write_migration_entry(entry)) +- pte = pte_mkwrite(pte); ++ pte = maybe_mkwrite(pte, vma); ++ + #ifdef CONFIG_HUGETLB_PAGE + if (PageHuge(new)) { + pte = pte_mkhuge(pte); +diff --git a/sound/soc/codecs/ssm2602.c b/sound/soc/codecs/ssm2602.c +index 97b0454eb346..eb1bb7414b8b 100644 +--- a/sound/soc/codecs/ssm2602.c ++++ b/sound/soc/codecs/ssm2602.c +@@ -647,7 +647,7 @@ int ssm2602_probe(struct device *dev, enum ssm2602_type type, + return -ENOMEM; + + dev_set_drvdata(dev, ssm2602); +- ssm2602->type = SSM2602; ++ ssm2602->type = type; + ssm2602->regmap = regmap; + + return snd_soc_register_codec(dev, &soc_codec_dev_ssm2602, +diff --git a/sound/soc/soc-core.c b/sound/soc/soc-core.c +index b87d7d882e6d..49acc989e452 100644 +--- a/sound/soc/soc-core.c ++++ b/sound/soc/soc-core.c +@@ -3181,7 +3181,7 @@ int snd_soc_bytes_put(struct snd_kcontrol *kcontrol, + unsigned int val, mask; + void *data; + +- if (!component->regmap) ++ if (!component->regmap || !params->num_regs) + return -EINVAL; + + len = params->num_regs * component->val_bytes;
