5.1.20-stable review
Subsystems (8)
Greg Kroah-Hartman
maintainerPATCH 310/371 fs/proc/proc_sysctl.c: fix the default values of i_uid/i_gid on /proc/sys inodes.
In reply to Greg Kroah-HartmanFrom: Radoslaw Burny <[email protected]>
commit 5ec27ec735ba0477d48c80561cc5e856f0c5dfaf upstream.
Normally, the inode's i_uid/i_gid are translated relative to s_user_ns, but this is not a correct behavior for proc. Since sysctl permission check in test_perm is done against GLOBAL_ROOT_[UG]ID, it makes more sense to use these values in u_[ug]id of proc inodes. In other words:
although uid/gid in the inode is not read during test_perm, the inode logically belongs to the root of the namespace. I have confirmed this with Eric Biederman at LPC and in this thread:
https://lore.kernel.org/lkml/[email protected]
Consequences
============
Since the i_[ug]id values of proc nodes are not used for permissions checks, this change usually makes no functional difference. However, it causes an issue in a setup where:
* a namespace container is created without root user in container - hence the i_[ug]id of proc nodes are set to INVALID_[UG]ID
* container creator tries to configure it by writing /proc/sys files, e.g. writing /proc/sys/kernel/shmmax to configure shared memory limit
Kernel does not allow to open an inode for writing if its i_[ug]id are invalid, making it impossible to write shmmax and thus - configure the container.
Using a container with no root mapping is apparently rare, but we do use this configuration at Google. Also, we use a generic tool to configure the container limits, and the inability to write any of them causes a failure.
History
=======
The invalid uids/gids in inodes first appeared due to 81754357770e (fs:
Update i_[ug]id_(read|write) to translate relative to s_user_ns). However, AFAIK, this did not immediately cause any issues. The inability to write to these "invalid" inodes was only caused by a later commit 0bd23d09b874 (vfs: Don't modify inodes with a uid or gid unknown to the vfs).
Tested: Used a repro program that creates a user namespace without any mapping and stat'ed /proc/$PID/root/proc/sys/kernel/shmmax from outside. Before the change, it shows the overflow uid, with the change it's 0. The overflow uid indicates that the uid in the inode is not correct and thus it is not possible to open the file for writing.
--- fs/proc/proc_sysctl.c | 4 ++++ 1 file changed, 4 insertions(+)
fs/proc/proc_sysctl.c +4 -0
@@ -498,6 +498,10 @@ static struct inode *proc_sys_make_inodeif (root->set_ownership) root->set_ownership (head, table, &inode->i_uid, &inode->i_gid); +else { + inode->i_uid =GLOBAL_ROOT_UID ; + inode->i_gid =GLOBAL_ROOT_GID ; + }return inode; }
Greg Kroah-Hartman
maintainerPATCH 311/371 i3c: fix i2c and i3c scl rate by bus mode
In reply to Greg Kroah-HartmanFrom: Vitor Soares <[email protected]>
commit ecc8fb54bd443bf69996d9d5ddb8d90a50f14936 upstream.
Currently the I3C framework limits SCL frequency to FM speed when dealing with a mixed slow bus, even if all I2C devices are FM+ capable.
The core was also not accounting for I3C speed limitations when operating in mixed slow mode and was erroneously using FM+ speed as the max I2C speed when operating in mixed fast mode.
--- drivers/i3c/master.c | 51 ++++++++++++++++++++++++++++++++++++++------------- 1 file changed, 38 insertions(+), 13 deletions(-)
drivers/i3c/master.c +38 -13
@@ -91,6 +91,12 @@ void i3c_bus_normaluse_unlock(struct i3cup_read (&bus->lock); } +static struct i3c_master_controller * +i3c_bus_to_i3c_master (struct i3c_bus *i3cbus) +{ + return container_of(i3cbus, struct i3c_master_controller, bus); +} +static struct i3c_master_controller *dev_to_i3cmaster (struct device *dev) { return container_of(dev, struct i3c_master_controller, dev);
@@ -565,20 +571,38 @@ static const struct device_type i3c_mast .groups = i3c_masterdev_groups, }; -int i3c_bus_set_mode (struct i3c_bus *i3cbus,enum i3c_bus_mode mode) +int i3c_bus_set_mode (struct i3c_bus *i3cbus,enum i3c_bus_mode mode, +unsigned long max_i2c_scl_rate) { - i3cbus->mode = mode; +struct i3c_master_controller *master =i3c_bus_to_i3c_master (i3cbus); -if (!i3cbus->scl_rate.i3c) - i3cbus->scl_rate.i3c =I3C_BUS_TYP_I3C_SCL_RATE ; + i3cbus->mode = mode; -if (!i3cbus->scl_rate.i2c) { -if (i3cbus->mode ==I3C_BUS_MODE_MIXED_SLOW ) - i3cbus->scl_rate.i2c =I3C_BUS_I2C_FM_SCL_RATE ; -else - i3cbus->scl_rate.i2c =I3C_BUS_I2C_FM_PLUS_SCL_RATE ; +switch (i3cbus->mode) { +case I3C_BUS_MODE_PURE : +if (!i3cbus->scl_rate.i3c) + i3cbus->scl_rate.i3c =I3C_BUS_TYP_I3C_SCL_RATE ; +break ; +case I3C_BUS_MODE_MIXED_FAST : +if (!i3cbus->scl_rate.i3c) + i3cbus->scl_rate.i3c =I3C_BUS_TYP_I3C_SCL_RATE ; +if (!i3cbus->scl_rate.i2c) + i3cbus->scl_rate.i2c = max_i2c_scl_rate; +break ; +case I3C_BUS_MODE_MIXED_SLOW : +if (!i3cbus->scl_rate.i2c) + i3cbus->scl_rate.i2c = max_i2c_scl_rate; +if (!i3cbus->scl_rate.i3c || + i3cbus->scl_rate.i3c > i3cbus->scl_rate.i2c) + i3cbus->scl_rate.i3c = i3cbus->scl_rate.i2c; +break ; +default : +return -EINVAL ; } +dev_dbg (&master->dev,"i2c-scl = %ld Hz i3c-scl = %ld Hz\n" , + i3cbus->scl_rate.i2c, i3cbus->scl_rate.i3c); +/* * I3C/I2C frequency may have been overridden, check that user-provided * values are not exceeding max possible frequency.
@@ -1966,9 +1990,6 @@ of_i3c_master_add_i2c_boardinfo(struct i/* LVR is encoded in reg[2]. */ boardinfo->lvr = reg[2 ]; -if (boardinfo->lvr &I3C_LVR_I2C_FM_MODE ) - master->bus.scl_rate.i2c =I3C_BUS_I2C_FM_SCL_RATE ; -list_add_tail (&boardinfo->node, &master->boardinfo.i2c);of_node_get (node);
@@ -2417,6 +2438,7 @@ int i3c_master_register(struct i3c_masteconst struct i3c_master_controller_ops *ops, bool secondary) { + unsigned long i2c_scl_rate = I3C_BUS_I2C_FM_PLUS_SCL_RATE;struct i3c_bus *i3cbus =i3c_master_get_bus (master);enum i3c_bus_mode mode =I3C_BUS_MODE_PURE ;struct i2c_dev_boardinfo *i2cbi;
@@ -2466,9 +2488,12 @@ int i3c_master_register(struct i3c_maste ret = -EINVAL ; goto err_put_dev; } + +if (i2cbi->lvr &I3C_LVR_I2C_FM_MODE ) + i2c_scl_rate =I3C_BUS_I2C_FM_SCL_RATE ; } - ret =i3c_bus_set_mode (i3cbus, mode); + ret =i3c_bus_set_mode (i3cbus, mode, i2c_scl_rate);if (ret) goto err_put_dev;
Greg Kroah-Hartman
maintainerPATCH 312/371 kconfig: fix missing choice values in auto.conf
In reply to Greg Kroah-HartmanFrom: Masahiro Yamada <[email protected]>
commit 8e2442a5f86e1f77b86401fce274a7f622740bc4 upstream.
Since commit 00c864f8903d ("kconfig: allow all config targets to write auto.conf if missing"), Kconfig creates include/config/auto.conf in the defconfig stage when it is missing.
Joonas Kylmälä reported incorrect auto.conf generation under some circumstances.
To reproduce it, apply the following diff:
| --- a/arch/arm/configs/imx_v6_v7_defconfig | +++ b/arch/arm/configs/imx_v6_v7_defconfig | @@ -345,14 +345,7 @@ CONFIG_USB_CONFIGFS_F_MIDI=y | CONFIG_USB_CONFIGFS_F_HID=y | CONFIG_USB_CONFIGFS_F_UVC=y | CONFIG_USB_CONFIGFS_F_PRINTER=y | -CONFIG_USB_ZERO=m | -CONFIG_USB_AUDIO=m | -CONFIG_USB_ETH=m | -CONFIG_USB_G_NCM=m | -CONFIG_USB_GADGETFS=m | -CONFIG_USB_FUNCTIONFS=m | -CONFIG_USB_MASS_STORAGE=m | -CONFIG_USB_G_SERIAL=m | +CONFIG_USB_FUNCTIONFS=y | CONFIG_MMC=y | CONFIG_MMC_SDHCI=y | CONFIG_MMC_SDHCI_PLTFM=y
And then, run:
$ make ARCH=arm mrproper imx_v6_v7_defconfig
You will see CONFIG_USB_FUNCTIONFS=y is correctly contained in the .config, but not in the auto.conf.
Please note drivers/usb/gadget/legacy/Kconfig is included from a choice block in drivers/usb/gadget/Kconfig. So USB_FUNCTIONFS is a choice value.
This is probably a similar situation described in commit beaaddb62540 ("kconfig: tests: test defconfig when two choices interact").
When sym_calc_choice() is called, the choice symbol forgets the SYMBOL_DEF_USER unless all of its choice values are explicitly set by the user.
The choice symbol is given just one chance to recall it because set_all_choice_values() is called if SYMBOL_NEED_SET_CHOICE_VALUES is set.
When sym_calc_choice() is called again, the choice symbol forgets it forever, since SYMBOL_NEED_SET_CHOICE_VALUES is a one-time aid. Hence, we cannot call sym_clear_all_valid() again and again.
It is crazy to repeat set and unset of internal flags. However, we cannot simply get rid of "sym->flags &= flags | ~SYMBOL_DEF_USER;" Doing so would re-introduce the problem solved by commit 5d09598d488f ("kconfig: fix new choices being skipped upon config update").
To work around the issue, conf_write_autoconf() stopped calling sym_clear_all_valid().
conf_write() must be changed accordingly. Currently, it clears SYMBOL_WRITE after the symbol is written into the .config file. This is needed to prevent it from writing the same symbol multiple times in case the symbol is declared in two or more locations. I added the new flag SYMBOL_WRITTEN, to track the symbols that have been written.
Anyway, this is a cheesy workaround in order to suppress the issue as far as defconfig is concerned.
Handling of choices is totally broken. sym_clear_all_valid() is called every time a user touches a symbol from the GUI interface. To reproduce it, just add a new symbol drivers/usb/gadget/legacy/Kconfig, then touch around unrelated symbols from menuconfig. USB_FUNCTIONFS will disappear from the .config file.
I added the Fixes tag since it is more fatal than before. But, this has been broken since long long time before, and still it is. We should take a closer look to fix this correctly somehow.
--- scripts/kconfig/confdata.c | 7 +++---- scripts/kconfig/expr.h | 1 + 2 files changed, 4 insertions(+), 4 deletions(-)
scripts/kconfig/confdata.c +3 -4
@@ -871,11 +871,12 @@ int conf_write(const char *name)"#\n" "# %s\n" "#\n", str); - }else if (!(sym->flags &SYMBOL_CHOICE )) { + }else if (!(sym->flags &SYMBOL_CHOICE ) && + !(sym->flags &SYMBOL_WRITTEN )) {sym_calc_value (sym);if (!(sym->flags &SYMBOL_WRITE )) goto next; - sym->flags &= ~SYMBOL_WRITE ; + sym->flags |=SYMBOL_WRITTEN ;conf_write_symbol (out, sym, &kconfig_printer_cb,NULL ); }
@@ -1026,8 +1027,6 @@ int conf_write_autoconf(int overwrite)if (!overwrite &&is_present (autoconf_name))return 0 ; -sym_clear_all_valid (); -conf_write_dep ("include/config/auto.conf.cmd" );if (conf_touch_deps ())
scripts/kconfig/expr.h +1 -0
@@ -141,6 +141,7 @@ struct symbol {#define SYMBOL_OPTIONAL 0x0100/* choice is optional - values can be 'n' */ #define SYMBOL_WRITE 0x0200/* write symbol to file (KCONFIG_CONFIG) */ #define SYMBOL_CHANGED 0x0400/* ? */ +#define SYMBOL_WRITTEN 0x0800/* track info to avoid double-write to .config */ #define SYMBOL_NO_WRITE 0x1000/* Symbol for internal use only; it will not be written */ #define SYMBOL_CHECKED 0x2000/* used during dependency checking */ #define SYMBOL_WARNED 0x8000/* warning has been issued */
Greg Kroah-Hartman
maintainerPATCH 313/371 ARM: dts: gemini: Set DIR-685 SPI CS as active low
In reply to Greg Kroah-HartmanFrom: Linus Walleij <[email protected]>
commit f90b8fda3a9d72a9422ea80ae95843697f94ea4a upstream.
The SPI to the display on the DIR-685 is active low, we were just saved by the SPI library enforcing active low on everything before, so set it as active low to avoid ambiguity.
--- arch/arm/boot/dts/gemini-dlink-dir-685.dts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
arch/arm/boot/dts/gemini-dlink-dir-685.dts +1 -1
@@ -64,7 +64,7 @@ gpio-sck = <&gpio1 5 GPIO_ACTIVE_HIGH>; gpio-miso = <&gpio1 8 GPIO_ACTIVE_HIGH>; gpio-mosi = <&gpio1 7 GPIO_ACTIVE_HIGH>; - cs-gpios = <&gpio0 20 GPIO_ACTIVE_HIGH>; + cs-gpios = <&gpio0 20 GPIO_ACTIVE_LOW>; num-chipselects = <1>; panel: display@0 {
Greg Kroah-Hartman
maintainerPATCH 314/371 drm/nouveau/i2c: Enable i2c pads & busses during preinit
In reply to Greg Kroah-HartmanFrom: Lyude Paul <[email protected]>
commit 7cb95eeea6706c790571042a06782e378b2561ea upstream.
It turns out that while disabling i2c bus access from software when the GPU is suspended was a step in the right direction with:
commit 342406e4fbba ("drm/nouveau/i2c: Disable i2c bus access after ->fini()")
We also ended up accidentally breaking the vbios init scripts on some older Tesla GPUs, as apparently said scripts can actually use the i2c bus. Since these scripts are executed before initializing any subdevices, we end up failing to acquire access to the i2c bus which has left a number of cards with their fan controllers uninitialized. Luckily this doesn't break hardware - it just means the fan gets stuck at 100%.
This also means that we've always been using our i2c busses before initializing them during the init scripts for older GPUs, we just didn't notice it until we started preventing them from being used until init. It's pretty impressive this never caused us any issues before!
So, fix this by initializing our i2c pad and busses during subdev pre-init. We skip initializing aux busses during pre-init, as those are guaranteed to only ever be used by nouveau for DP aux transactions.
--- drivers/gpu/drm/nouveau/nvkm/subdev/i2c/base.c | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+)
drivers/gpu/drm/nouveau/nvkm/subdev/i2c/base.c +20 -0
@@ -185,6 +185,25 @@ nvkm_i2c_fini(struct nvkm_subdev *subdev }static int +nvkm_i2c_preinit (struct nvkm_subdev *subdev) +{ +struct nvkm_i2c *i2c =nvkm_i2c (subdev); +struct nvkm_i2c_bus *bus; +struct nvkm_i2c_pad *pad; + +/* +* We init our i2c busses as early as possible, since they may be +* needed by the vbios init scripts on some cards +*/ +list_for_each_entry (pad, &i2c->pad, head) +nvkm_i2c_pad_init (pad); +list_for_each_entry (bus, &i2c->bus, head) +nvkm_i2c_bus_init (bus); + +return 0 ; +} + +static int nvkm_i2c_init (struct nvkm_subdev *subdev) {struct nvkm_i2c *i2c =nvkm_i2c (subdev);
@@ -238,6 +257,7 @@ nvkm_i2c_dtor(struct nvkm_subdev *subdevstatic const struct nvkm_subdev_func nvkm_i2c = { .dtor = nvkm_i2c_dtor, + .preinit = nvkm_i2c_preinit, .init = nvkm_i2c_init, .fini = nvkm_i2c_fini, .intr = nvkm_i2c_intr,
Greg Kroah-Hartman
maintainerPATCH 315/371 padata: use smp_mb in padata_reorder to avoid orphaned padata jobs
In reply to Greg Kroah-HartmanFrom: Daniel Jordan <[email protected]>
commit cf144f81a99d1a3928f90b0936accfd3f45c9a0a upstream.
Testing padata with the tcrypt module on a 5.2 kernel...
# modprobe tcrypt alg="pcrypt(rfc4106(gcm(aes)))" type=3
# modprobe tcrypt mode=211 sec=1...produces this splat:
INFO: task modprobe:10075 blocked for more than 120 seconds.
Not tainted 5.2.0-base+ #16
modprobe D 0 10075 10064 0x80004080
Call Trace:
? __schedule+0x4dd/0x610
? ring_buffer_unlock_commit+0x23/0x100
schedule+0x6c/0x90
schedule_timeout+0x3b/0x320
? trace_buffer_unlock_commit_regs+0x4f/0x1f0
wait_for_common+0x160/0x1a0
? wake_up_q+0x80/0x80
{ crypto_wait_req } # entries in braces added by hand
{ do_one_aead_op }
{ test_aead_jiffies }
test_aead_speed.constprop.17+0x681/0xf30 [tcrypt]
do_test+0x4053/0x6a2b [tcrypt]
? 0xffffffffa00f4000
tcrypt_mod_init+0x50/0x1000 [tcrypt]
...The second modprobe command never finishes because in padata_reorder, CPU0's load of reorder_objects is executed before the unlocking store in spin_unlock_bh(pd->lock), causing CPU0 to miss CPU1's increment:
CPU0 CPU1
padata_reorder padata_do_serial
LOAD reorder_objects // 0
INC reorder_objects // 1 padata_reorder
TRYLOCK pd->lock // failed
UNLOCK pd->lock
CPU0 deletes the timer before returning from padata_reorder and since no other job is submitted to padata, modprobe waits indefinitely.
Add a pair of full barriers to guarantee proper ordering:
CPU0 CPU1
padata_reorder padata_do_serial
UNLOCK pd->lock
smp_mb()
LOAD reorder_objects
INC reorder_objects
smp_mb__after_atomic()
padata_reorder
TRYLOCK pd->locksmp_mb__after_atomic is needed so the read part of the trylock operation
comes after the INC, as Andrea points out. Thanks also to Andrea for
help with writing a litmus test.
--- kernel/padata.c | 12 ++++++++++++ 1 file changed, 12 insertions(+)
kernel/padata.c +12 -0
@@ -267,7 +267,12 @@ static void padata_reorder(struct parall* The next object that needs serialization might have arrived to * the reorder queues in the meantime, we will be called again * from the timer function if no one else cares for it. +* +* Ensure reorder_objects is read after pd->lock is dropped so we see +* an increment from another task in padata_do_serial. Pairs with +* smp_mb__after_atomic in padata_do_serial. */ +smp_mb ();if (atomic_read (&pd->reorder_objects) && !(pinst->flags &PADATA_RESET ))mod_timer (&pd->timer, jiffies +HZ );
@@ -387,6 +392,13 @@ void padata_do_serial(struct padata_privlist_add_tail (&padata->list, &pqueue->reorder.list);spin_unlock (&pqueue->reorder.lock); +/* +* Ensure the atomic_inc of reorder_objects above is ordered correctly +* with the trylock of pd->lock in padata_reorder. Pairs with smp_mb +* in padata_reorder. +*/ +smp_mb__after_atomic (); +put_cpu ();/* If we're running on the wrong CPU, call padata_reorder() via a
Greg Kroah-Hartman
maintainerPATCH 316/371 dm zoned: fix zone state management race
In reply to Greg Kroah-HartmanFrom: Damien Le Moal <[email protected]>
commit 3b8cafdd5436f9298b3bf6eb831df5eef5ee82b6 upstream.
dm-zoned uses the zone flag DMZ_ACTIVE to indicate that a zone of the backend device is being actively read or written and so cannot be reclaimed. This flag is set as long as the zone atomic reference counter is not 0. When this atomic is decremented and reaches 0 (e.g. on BIO completion), the active flag is cleared and set again whenever the zone is reused and BIO issued with the atomic counter incremented. These 2 operations (atomic inc/dec and flag set/clear) are however not always executed atomically under the target metadata mutex lock and this causes the warning:
WARN_ON(!test_bit(DMZ_ACTIVE, &zone->flags));
in dmz_deactivate_zone() to be displayed. This problem is regularly triggered with xfstests generic/209, generic/300, generic/451 and xfs/077 with XFS being used as the file system on the dm-zoned target device. Similarly, xfstests ext4/303, ext4/304, generic/209 and generic/300 trigger the warning with ext4 use.
This problem can be easily fixed by simply removing the DMZ_ACTIVE flag and managing the "ACTIVE" state by directly looking at the reference counter value. To do so, the functions dmz_activate_zone() and dmz_deactivate_zone() are changed to inline functions respectively calling atomic_inc() and atomic_dec(), while the dmz_is_active() macro is changed to an inline function calling atomic_read().
--- drivers/md/dm-zoned-metadata.c | 24 ------------------------ drivers/md/dm-zoned.h | 28 ++++++++++++++++++++++++---- 2 files changed, 24 insertions(+), 28 deletions(-)
drivers/md/dm-zoned-metadata.c +0 -24
@@ -1594,30 +1594,6 @@ struct dm_zone *dmz_get_zone_for_reclaim }/* -* Activate a zone (increment its reference count). -*/ -void dmz_activate_zone (struct dm_zone *zone) -{ -set_bit (DMZ_ACTIVE , &zone->flags); -atomic_inc (&zone->refcount); -} - -/* -* Deactivate a zone. This decrement the zone reference counter -* and clears the active state of the zone once the count reaches 0, -* indicating that all BIOs to the zone have completed. Returns -* true if the zone was deactivated. -*/ -void dmz_deactivate_zone (struct dm_zone *zone) -{ -if (atomic_dec_and_test (&zone->refcount)) { -WARN_ON (!test_bit (DMZ_ACTIVE , &zone->flags)); -clear_bit_unlock (DMZ_ACTIVE , &zone->flags); -smp_mb__after_atomic (); - } -} - -/* * Get the zone mapping a chunk, if the chunk is mapped already. * If no mapping exist and the operation is WRITE, a zone is * allocated and used to map the chunk.
drivers/md/dm-zoned.h +24 -4
@@ -115,7 +115,6 @@ enum {DMZ_BUF ,/* Zone internal state */ -DMZ_ACTIVE ,DMZ_RECLAIM , DMZ_SEQ_WRITE_ERR, };
@@ -128,7 +127,6 @@ enum {#define dmz_is_empty (z) ((z)->wp_block == 0)#define dmz_is_offline (z) test_bit(DMZ_OFFLINE, &(z)->flags)#define dmz_is_readonly (z) test_bit(DMZ_READ_ONLY, &(z)->flags) -#define dmz_is_active (z) test_bit(DMZ_ACTIVE, &(z)->flags)#define dmz_in_reclaim (z) test_bit(DMZ_RECLAIM, &(z)->flags)#define dmz_seq_write_err (z) test_bit(DMZ_SEQ_WRITE_ERR, &(z)->flags)
@@ -188,8 +186,30 @@ void dmz_unmap_zone(struct dmz_metadataunsigned int dmz_nr_rnd_zones (struct dmz_metadata *zmd);unsigned int dmz_nr_unmap_rnd_zones (struct dmz_metadata *zmd); -void dmz_activate_zone (struct dm_zone *zone); -void dmz_deactivate_zone (struct dm_zone *zone); +/* +* Activate a zone (increment its reference count). +*/ +static inline void dmz_activate_zone (struct dm_zone *zone) +{ +atomic_inc (&zone->refcount); +} + +/* +* Deactivate a zone. This decrement the zone reference counter +* indicating that all BIOs to the zone have completed when the count is 0. +*/ +static inline void dmz_deactivate_zone (struct dm_zone *zone) +{ +atomic_dec (&zone->refcount); +} + +/* +* Test if a zone is active, that is, has a refcount > 0. +*/ +static inline bool dmz_is_active (struct dm_zone *zone) +{ +return atomic_read (&zone->refcount); +}int dmz_lock_zone_reclaim (struct dm_zone *zone);void dmz_unlock_zone_reclaim (struct dm_zone *zone);
Greg Kroah-Hartman
maintainerPATCH 317/371 xen/events: fix binding user event channels to cpus
In reply to Greg Kroah-HartmanFrom: Juergen Gross <[email protected]>
commit bce5963bcb4f9934faa52be323994511d59fd13c upstream.
When binding an interdomain event channel to a vcpu via IOCTL_EVTCHN_BIND_INTERDOMAIN not only the event channel needs to be bound, but the affinity of the associated IRQi must be changed, too. Otherwise the IRQ and the event channel won't be moved to another vcpu in case the original vcpu they were bound to is going offline.
--- drivers/xen/events/events_base.c | 12 ++++++++++-- drivers/xen/evtchn.c | 2 +- include/xen/events.h | 3 ++- 3 files changed, 13 insertions(+), 4 deletions(-)
drivers/xen/events/events_base.c +10 -2
@@ -1293,7 +1293,7 @@ void rebind_evtchn_irq(int evtchn, int i }/* Rebind an evtchn so that it gets delivered to a specific cpu */ -int xen_rebind_evtchn_to_cpu (int evtchn,unsigned tcpu) +static int xen_rebind_evtchn_to_cpu (int evtchn,unsigned int tcpu) {struct evtchn_bind_vcpu bind_vcpu;int masked;
@@ -1327,7 +1327,6 @@ int xen_rebind_evtchn_to_cpu(int evtchn,return 0 ; } -EXPORT_SYMBOL_GPL (xen_rebind_evtchn_to_cpu);static int set_affinity_irq (struct irq_data *data,const struct cpumask *dest,bool force)
@@ -1341,6 +1340,15 @@ static int set_affinity_irq(struct irq_dreturn ret; } +/* To be called with desc->lock held. */ +int xen_set_affinity_evtchn (struct irq_desc *desc,unsigned int tcpu) +{ +struct irq_data *d =irq_desc_get_irq_data (desc); + +return set_affinity_irq (d,cpumask_of (tcpu), false); +} +EXPORT_SYMBOL_GPL (xen_set_affinity_evtchn); +static void enable_dynirq (struct irq_data *data) {int evtchn =evtchn_from_irq (data->irq);
drivers/xen/evtchn.c +1 -1
@@ -447,7 +447,7 @@ static void evtchn_bind_interdom_next_vcthis_cpu_write (bind_last_selected_cpu, selected_cpu);/* unmask expects irqs to be disabled */ -xen_rebind_evtchn_to_cpu (evtchn, selected_cpu); +xen_set_affinity_evtchn (desc, selected_cpu);raw_spin_unlock_irqrestore (&desc->lock, flags); }
include/xen/events.h +2 -1
@@ -3,6 +3,7 @@#define _XEN_EVENTS_H#include <linux/interrupt.h> +#include <linux/irq.h> #ifdef CONFIG_PCI_MSI #include <linux/msi.h> #endif
@@ -59,7 +60,7 @@ void evtchn_put(unsigned int evtchn);void xen_send_IPI_one (unsigned int cpu,enum ipi_vector vector);void rebind_evtchn_irq (int evtchn,int irq); -int xen_rebind_evtchn_to_cpu (int evtchn,unsigned tcpu); +int xen_set_affinity_evtchn (struct irq_desc *desc,unsigned int tcpu);static inline void notify_remote_via_evtchn (int port) {
Greg Kroah-Hartman
maintainerPATCH 318/371 9p/xen: Add cleanup path in p9_trans_xen_init
In reply to Greg Kroah-HartmanFrom: YueHaibing <[email protected]>
commit 80a316ff16276b36d0392a8f8b2f63259857ae98 upstream.
If xenbus_register_frontend() fails in p9_trans_xen_init, we should call v9fs_unregister_trans() to do cleanup.
--- net/9p/trans_xen.c | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-)
net/9p/trans_xen.c +7 -1
@@ -530,13 +530,19 @@ static struct xenbus_driver xen_9pfs_frostatic int p9_trans_xen_init (void ) { +int rc; +if (!xen_domain ())return -ENODEV ;pr_info ("Initialising Xen transport for 9pfs\n" );v9fs_register_trans (&p9_xen_trans); -return xenbus_register_frontend (&xen_9pfs_front_driver); + rc =xenbus_register_frontend (&xen_9pfs_front_driver); +if (rc) +v9fs_unregister_trans (&p9_xen_trans); + +return rc; }module_init (p9_trans_xen_init);
Greg Kroah-Hartman
maintainerPATCH 319/371 9p/virtio: Add cleanup path in p9_virtio_init
In reply to Greg Kroah-HartmanFrom: YueHaibing <[email protected]>
commit d4548543fc4ece56c6f04b8586f435fb4fd84c20 upstream.
KASAN report this:
BUG: unable to handle kernel paging request at ffffffffa0097000 PGD 3870067 P4D 3870067 PUD 3871063 PMD 2326e2067 PTE 0 Oops: 0000 [#1 CPU: 0 PID: 5340 Comm: modprobe Not tainted 5.1.0-rc7+ #25 Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS rel-1.9.3-0-ge2fc41e-prebuilt.qemu-project.org 04/01/2014 RIP: 0010:__list_add_valid+0x10/0x70 Code: c3 48 8b 06 55 48 89 e5 5d 48 39 07 0f 94 c0 0f b6 c0 c3 90 90 90 90 90 90 90 55 48 89 d0 48 8b 52 08 48 89 e5 48 39 f2 75 19 <48> 8b 32 48 39 f0 75 3a
RSP: 0018:ffffc90000e23c68 EFLAGS: 00010246 RAX: ffffffffa00ad000 RBX: ffffffffa009d000 RCX: 0000000000000000 RDX: ffffffffa0097000 RSI: ffffffffa0097000 RDI: ffffffffa009d000 RBP: ffffc90000e23c68 R08: 0000000000000001 R09: 0000000000000000 R10: 0000000000000000 R11: 0000000000000000 R12: ffffffffa0097000 R13: ffff888231797180 R14: 0000000000000000 R15: ffffc90000e23e78 FS: 00007fb215285540(0000) GS:ffff888237a00000(0000) knlGS:0000000000000000 CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 CR2: ffffffffa0097000 CR3: 000000022f144000 CR4: 00000000000006f0 Call Trace: v9fs_register_trans+0x2f/0x60 [9pnet ? 0xffffffffa0087000 p9_virtio_init+0x25/0x1000 [9pnet_virtio do_one_initcall+0x6c/0x3cc ? kmem_cache_alloc_trace+0x248/0x3b0 do_init_module+0x5b/0x1f1 load_module+0x1db1/0x2690 ? m_show+0x1d0/0x1d0 __do_sys_finit_module+0xc5/0xd0 __x64_sys_finit_module+0x15/0x20 do_syscall_64+0x6b/0x1d0 entry_SYSCALL_64_after_hwframe+0x49/0xbe RIP: 0033:0x7fb214d8e839 Code: 00 f3 c3 66 2e 0f 1f 84 00 00 00 00 00 0f 1f 40 00 48 89 f8 48 89 f7 48 89 d6 48 89 ca 4d 89 c2 4d 89 c8 4c 8b 4c 24 08 0f 05 <48> 3d 01 f0 ff ff 73 01
RSP: 002b:00007ffc96554278 EFLAGS: 00000246 ORIG_RAX: 0000000000000139
RAX: ffffffffffffffda RBX: 000055e67eed2aa0 RCX: 00007fb214d8e839
RDX: 0000000000000000 RSI: 000055e67ce95c2e RDI: 0000000000000003
RBP: 000055e67ce95c2e R08: 0000000000000000 R09: 000055e67eed2aa0
R10: 0000000000000003 R11: 0000000000000246 R12: 0000000000000000
R13: 000055e67eeda500 R14: 0000000000040000 R15: 000055e67eed2aa0
Modules linked in: 9pnet_virtio(+) 9pnet gre rfkill vmw_vsock_virtio_transport_common vsock [last unloaded: 9pnet_virtio CR2: ffffffffa0097000 ---[ end trace 4a52bb13ff07b761
If register_virtio_driver() fails in p9_virtio_init, we should call v9fs_unregister_trans() to do cleanup.
--- net/9p/trans_virtio.c | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-)
net/9p/trans_virtio.c +7 -1
@@ -782,10 +782,16 @@ static struct p9_trans_module p9_virtio_/* The standard init function */ static int __init p9_virtio_init (void ) { +int rc; +INIT_LIST_HEAD (&virtio_chan_list);v9fs_register_trans (&p9_virtio_trans); -return register_virtio_driver (&p9_virtio_drv); + rc =register_virtio_driver (&p9_virtio_drv); +if (rc) +v9fs_unregister_trans (&p9_virtio_trans); + +return rc; } static void __exit p9_virtio_cleanup(void)
Greg Kroah-Hartman
maintainerPATCH 320/371 rt2x00usb: fix rx queue hang
In reply to Greg Kroah-HartmanFrom: Soeren Moch <[email protected]>
commit 41a531ffa4c5aeb062f892227c00fabb3b4a9c91 upstream.
Since commit ed194d136769 ("usb: core: remove local_irq_save() around
->complete() handler") the handler rt2x00usb_interrupt_rxdone() is
not running with interrupts disabled anymore. So this completion handler is not guaranteed to run completely before workqueue processing starts for the same queue entry.
Be sure to set all other flags in the entry correctly before marking this entry ready for workqueue processing. This way we cannot miss error conditions that need to be signalled from the completion handler to the worker thread.
Note that rt2x00usb_work_rxdone() processes all available entries, not only such for which queue_work() was called.
This patch is similar to what commit df71c9cfceea ("rt2x00: fix order of entry flags modification") did for TX processing.
This fixes a regression on a RT5370 based wifi stick in AP mode, which suddenly stopped data transmission after some period of heavy load. Also stopping the hanging hostapd resulted in the error message "ieee80211
phy0: rt2x00queue_flush_queue: Warning - Queue 14 failed to flush". Other operation modes are probably affected as well, this just was the used testcase.
--- drivers/net/wireless/ralink/rt2x00/rt2x00usb.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-)
drivers/net/wireless/ralink/rt2x00/rt2x00usb.c +6 -6
@@ -367,15 +367,10 @@ static void rt2x00usb_interrupt_rxdone(sstruct queue_entry *entry = (struct queue_entry *)urb->context;struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev; -if (!test_and_clear_bit (ENTRY_OWNER_DEVICE_DATA , &entry->flags)) +if (!test_bit (ENTRY_OWNER_DEVICE_DATA , &entry->flags))return ;/* -* Report the frame as DMA done -*/ -rt2x00lib_dmadone (entry); - -/* * Check if the received data is simply too small * to be actually valid, or if the urb is signaling * a problem.
@@ -384,6 +379,11 @@ static void rt2x00usb_interrupt_rxdone(sset_bit (ENTRY_DATA_IO_FAILED , &entry->flags);/* +* Report the frame as DMA done +*/ +rt2x00lib_dmadone (entry); + +/* * Schedule the delayed work for reading the RX status * from the device. */
Greg Kroah-Hartman
maintainerPATCH 321/371 x86/boot: Fix memory leak in default_get_smp_config()
In reply to Greg Kroah-HartmanFrom: David Rientjes <[email protected]>
commit e74bd96989dd42a51a73eddb4a5510a6f5e42ac3 upstream.
When default_get_smp_config() is called with early == 1 and mpf->feature1 is non-zero, mpf is leaked because the return path does not do early_memunmap().
Fix this and share a common exit routine.
--- arch/x86/kernel/mpparse.c | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-)
arch/x86/kernel/mpparse.c +4 -6
@@ -546,17 +546,15 @@ void __init default_get_smp_config(unsig* local APIC has default address */ mp_lapic_addr =APIC_DEFAULT_PHYS_BASE ; -return ; + goto out; }pr_info ("Default MP configuration #%d\n" , mpf->feature1);construct_default_ISA_mptable (mpf->feature1); }else if (mpf->physptr) { -if (check_physptr (mpf, early)) { -early_memunmap (mpf,sizeof (*mpf)); -return ; - } +if (check_physptr (mpf, early)) + goto out; }else BUG ();
@@ -565,7 +563,7 @@ void __init default_get_smp_config(unsig/* * Only use the first configuration found. */ - +out:early_memunmap (mpf,sizeof (*mpf)); }
Greg Kroah-Hartman
maintainerPATCH 322/371 perf/x86/intel: Fix spurious NMI on fixed counter
In reply to Greg Kroah-HartmanFrom: Kan Liang <[email protected]>
commit e4557c1a46b0d32746bd309e1941914b5a6912b4 upstream.
If a user first sample a PEBS event on a fixed counter, then sample a non-PEBS event on the same fixed counter on Icelake, it will trigger spurious NMI. For example:
perf record -e 'cycles:p' -a
perf record -e 'cycles' -a
The error message for spurious NMI:
[June 21 15:38] Uhhuh. NMI received for unknown reason 30 on CPU 2.
[ +0.000000] Do you have a strange power saving mode enabled?
[ +0.000000] Dazed and confused, but trying to continue
The bug was introduced by the following commit:
commit 6f55967ad9d9 ("perf/x86/intel: Fix race in intel_pmu_disable_event()")
The commit moves the intel_pmu_pebs_disable() after intel_pmu_disable_fixed(), which returns immediately. The related bit of PEBS_ENABLE MSR will never be cleared for the fixed counter. Then a non-PEBS event runs on the fixed counter, but the bit on PEBS_ENABLE is still set, which triggers spurious NMIs.
Check and disable PEBS for fixed counters after intel_pmu_disable_fixed().
--- arch/x86/events/intel/core.c | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-)
arch/x86/events/intel/core.c +3 -5
@@ -2092,12 +2092,10 @@ static void intel_pmu_disable_event(stru cpuc->intel_ctrl_host_mask &= ~(1ull << hwc->idx); cpuc->intel_cp_status &= ~(1ull << hwc->idx); -if (unlikely (hwc->config_base ==MSR_ARCH_PERFMON_FIXED_CTR_CTRL )) { +if (unlikely (hwc->config_base ==MSR_ARCH_PERFMON_FIXED_CTR_CTRL ))intel_pmu_disable_fixed (hwc); -return ; - } - -x86_pmu_disable_event (event); +else +x86_pmu_disable_event (event);/* * Needs to be called after x86_pmu_disable_event,
Greg Kroah-Hartman
maintainerPATCH 323/371 perf/x86/amd/uncore: Do not set ThreadMask and SliceMask for non-L3 PMCs
In reply to Greg Kroah-HartmanFrom: Kim Phillips <[email protected]>
commit 16f4641166b10e199f0d7b68c2c5f004fef0bda3 upstream.
The following commit:
d7cbbe49a930 ("perf/x86/amd/uncore: Set ThreadMask and SliceMask for L3 Cache perf events")
enables L3 PMC events for all threads and slices by writing 1's in 'ChL3PmcCfg' (L3 PMC PERF_CTL) register fields.
Those bitfields overlap with high order event select bits in the Data Fabric PMC control register, however.
So when a user requests raw Data Fabric events (-e amd_df/event=0xYYY/), the two highest order bits get inadvertently set, changing the counter select to events that don't exist, and for which no counts are read.
This patch changes the logic to write the L3 masks only when dealing with L3 PMC counters.
AMD Family 16h and below Northbridge (NB) counters were not affected.
--- arch/x86/events/amd/uncore.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
arch/x86/events/amd/uncore.c +1 -1
@@ -209,7 +209,7 @@ static int amd_uncore_event_init(struct* SliceMask and ThreadMask need to be set for certain L3 events in * Family 17h. For other events, the two fields do not affect the count. */ -if (l3_mask) +if (l3_mask &&is_llc_event (event)) hwc->config |= (AMD64_L3_SLICE_MASK |AMD64_L3_THREAD_MASK );if (event->cpu <0 )
Greg Kroah-Hartman
maintainerPATCH 324/371 perf/x86/amd/uncore: Set the thread mask for F17h L3 PMCs
In reply to Greg Kroah-HartmanFrom: Kim Phillips <[email protected]>
commit 2f217d58a8a086d3399fecce39fb358848e799c4 upstream.
Fill in the L3 performance event select register ThreadMask bitfield, to enable per hardware thread accounting.
--- arch/x86/events/amd/uncore.c | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-)
arch/x86/events/amd/uncore.c +11 -4
@@ -205,15 +205,22 @@ static int amd_uncore_event_init(struct hwc->config = event->attr.config &AMD64_RAW_EVENT_MASK_NB ; hwc->idx =-1 ; +if (event->cpu <0 ) +return -EINVAL ; +/* * SliceMask and ThreadMask need to be set for certain L3 events in * Family 17h. For other events, the two fields do not affect the count. */ -if (l3_mask &&is_llc_event (event)) - hwc->config |= (AMD64_L3_SLICE_MASK |AMD64_L3_THREAD_MASK ); +if (l3_mask &&is_llc_event (event)) { +int thread =2 * (cpu_data (event->cpu).cpu_core_id %4 ); -if (event->cpu <0 ) -return -EINVAL ; +if (smp_num_siblings >1 ) + thread +=cpu_data (event->cpu).apicid &1 ; + + hwc->config |= (1ULL << (AMD64_L3_THREAD_SHIFT + thread) & +AMD64_L3_THREAD_MASK ) |AMD64_L3_SLICE_MASK ; + } uncore =event_to_amd_uncore (event);if (!uncore)
Greg Kroah-Hartman
maintainerPATCH 325/371 drm/edid: parse CEA blocks embedded in DisplayID
In reply to Greg Kroah-HartmanFrom: Andres Rodriguez <[email protected]>
commit e28ad544f462231d3fd081a7316339359efbb481 upstream.
DisplayID blocks allow embedding of CEA blocks. The payloads are identical to traditional top level CEA extension blocks, but the header is slightly different.
This change allows the CEA parser to find a CEA block inside a DisplayID block. Additionally, it adds support for parsing the embedded CTA header. No further changes are necessary due to payload parity.
This change fixes audio support for the Valve Index HMD.
--- drivers/gpu/drm/drm_edid.c | 81 ++++++++++++++++++++++++++++++++++++++------ include/drm/drm_displayid.h | 10 +++++ 2 files changed, 80 insertions(+), 11 deletions(-)
drivers/gpu/drm/drm_edid.c +70 -11
@@ -1349,6 +1349,7 @@ MODULE_PARM_DESC(edid_fixup,static void drm_get_displayid (struct drm_connector *connector,struct edid *edid); +static int validate_displayid (u8 *displayid,int length,int idx);static int drm_edid_block_checksum (const u8 *raw_edid) {
@@ -2932,16 +2933,46 @@ static u8 *drm_find_edid_extension(constreturn edid_ext; } -static u8 *drm_find_cea_extension (const struct edid *edid) -{ -return drm_find_edid_extension (edid,CEA_EXT ); -}static u8 *drm_find_displayid_extension (const struct edid *edid) {return drm_find_edid_extension (edid,DISPLAYID_EXT ); } +static u8 *drm_find_cea_extension (const struct edid *edid) +{ +int ret; +int idx =1 ; +int length =EDID_LENGTH ; +struct displayid_block *block; +u8 *cea; +u8 *displayid; + +/* Look for a top level CEA extension block */ + cea =drm_find_edid_extension (edid,CEA_EXT ); +if (cea) +return cea; + +/* CEA blocks can also be found embedded in a DisplayID block */ + displayid =drm_find_displayid_extension (edid); +if (!displayid) +return NULL ; + + ret =validate_displayid (displayid, length, idx); +if (ret) +return NULL ; + + idx +=sizeof (struct displayid_hdr ); +for_each_displayid_db (displayid, block, idx, length) { +if (block->tag ==DATA_BLOCK_CTA ) { + cea = (u8 *)block; +break ; + } + } + +return cea; +} +/* * Calculate the alternate clock for the CEA mode * (60Hz vs. 59.94Hz etc.)
@@ -3665,13 +3696,38 @@ cea_revision(const u8 *cea)static int cea_db_offsets (const u8 *cea,int *start,int *end) { -/* Data block offset in CEA extension block */ - *start =4 ; - *end = cea[2 ]; -if (*end ==0 ) - *end =127 ; -if (*end <4 || *end >127 ) -return -ERANGE ; +/* DisplayID CTA extension blocks and top-level CEA EDID +* block header definitions differ in the following bytes: +* 1) Byte 2 of the header specifies length differently, +* 2) Byte 3 is only present in the CEA top level block. +* +* The different definitions for byte 2 follow. +* +* DisplayID CTA extension block defines byte 2 as: +* Number of payload bytes +* +* CEA EDID block defines byte 2 as: +* Byte number (decimal) within this block where the 18-byte +* DTDs begin. If no non-DTD data is present in this extension +* block, the value should be set to 04h (the byte after next). +* If set to 00h, there are no DTDs present in this block and +* no non-DTD data. +*/ +if (cea[0 ] ==DATA_BLOCK_CTA ) { + *start =3 ; + *end = *start + cea[2 ]; + }else if (cea[0 ] ==CEA_EXT ) { +/* Data block offset in CEA extension block */ + *start =4 ; + *end = cea[2 ]; +if (*end ==0 ) + *end =127 ; +if (*end <4 || *end >127 ) +return -ERANGE ; + }else { +return -ENOTSUPP ; + } +return 0 ; }
@@ -5219,6 +5275,9 @@ static int drm_parse_display_id(struct dcase DATA_BLOCK_TYPE_1_DETAILED_TIMING :/* handled in mode gathering code. */ break ; +case DATA_BLOCK_CTA : +/* handled in the cea parser code. */ +break ;default :DRM_DEBUG_KMS ("found DisplayID tag 0x%x, unhandled\n" , block->tag);break ;
include/drm/drm_displayid.h +10 -0
@@ -40,6 +40,7 @@#define DATA_BLOCK_DISPLAY_INTERFACE 0x0f#define DATA_BLOCK_STEREO_DISPLAY_INTERFACE 0x10#define DATA_BLOCK_TILED_DISPLAY 0x12 +#define DATA_BLOCK_CTA 0x81#define DATA_BLOCK_VENDOR_SPECIFIC 0x7f
@@ -90,4 +91,13 @@ struct displayid_detailed_timing_block {struct displayid_block base; struct displayid_detailed_timings_1 timings[0]; }; + +#define for_each_displayid_db (displayid, block, idx, length) \ + for ((block) = (struct displayid_block *)&(displayid)[idx]; \ + (idx) + sizeof(struct displayid_block) <= (length) && \ + (idx) + sizeof(struct displayid_block) + (block)->num_bytes <= (length) && \ + (block)->num_bytes > 0; \ + (idx) += (block)->num_bytes + sizeof(struct displayid_block), \ + (block) = (struct displayid_block *)&(displayid)[idx]) +#endif
Greg Kroah-Hartman
maintainerPATCH 326/371 block: Allow mapping of vmalloc-ed buffers
In reply to Greg Kroah-HartmanFrom: Damien Le Moal <[email protected]>
commit b4c5875d36178e8df409bdce232f270cac89fafe upstream.
To allow the SCSI subsystem scsi_execute_req() function to issue requests using large buffers that are better allocated with vmalloc() rather than kmalloc(), modify bio_map_kern() to allow passing a buffer allocated with vmalloc().
To do so, detect vmalloc-ed buffers using is_vmalloc_addr(). For vmalloc-ed buffers, flush the buffer using flush_kernel_vmap_range(), use vmalloc_to_page() instead of virt_to_page() to obtain the pages of the buffer, and invalidate the buffer addresses with invalidate_kernel_vmap_range() on completion of read BIOs. This last point is executed using the function bio_invalidate_vmalloc_pages() which is defined only if the architecture defines ARCH_HAS_FLUSH_KERNEL_DCACHE_PAGE, that is, if the architecture actually needs the invalidation done.
--- block/bio.c | 28 +++++++++++++++++++++++++++- 1 file changed, 27 insertions(+), 1 deletion(-)
block/bio.c +27 -1
@@ -29,6 +29,7 @@#include <linux/workqueue.h> #include <linux/cgroup.h> #include <linux/blk-cgroup.h> +#include <linux/highmem.h> #include <trace/events/block.h> #include "blk.h"
@@ -1475,8 +1476,22 @@ void bio_unmap_user(struct bio *bio)bio_put (bio); } +static void bio_invalidate_vmalloc_pages (struct bio *bio) +{ +#ifdef ARCH_HAS_FLUSH_KERNEL_DCACHE_PAGE +if (bio->bi_private && !op_is_write (bio_op (bio))) { +unsigned long i, len =0 ; + +for (i =0 ; i < bio->bi_vcnt; i++) + len += bio->bi_io_vec[i].bv_len; +invalidate_kernel_vmap_range (bio->bi_private, len); + } +#endif +} +static void bio_map_kern_endio (struct bio *bio) { +bio_invalidate_vmalloc_pages (bio);bio_put (bio); }
@@ -1497,6 +1512,8 @@ struct bio *bio_map_kern(struct request_unsigned long end = (kaddr + len +PAGE_SIZE -1 ) >>PAGE_SHIFT ;unsigned long start = kaddr >>PAGE_SHIFT ;const int nr_pages = end - start; +bool is_vmalloc =is_vmalloc_addr (data); +struct page *page;int offset, i;struct bio *bio;
@@ -1504,6 +1521,11 @@ struct bio *bio_map_kern(struct request_if (!bio)return ERR_PTR (-ENOMEM ); +if (is_vmalloc) { +flush_kernel_vmap_range (data, len); + bio->bi_private = data; + } + offset =offset_in_page (kaddr);for (i =0 ; i < nr_pages; i++) {unsigned int bytes =PAGE_SIZE - offset;
@@ -1514,7 +1536,11 @@ struct bio *bio_map_kern(struct request_if (bytes > len) bytes = len; -if (bio_add_pc_page (q, bio,virt_to_page (data), bytes, +if (!is_vmalloc) + page =virt_to_page (data); +else + page =vmalloc_to_page (data); +if (bio_add_pc_page (q, bio, page, bytes, offset) < bytes) {/* we don't support partial mappings */ bio_put (bio);
Greg Kroah-Hartman
maintainerPATCH 327/371 block: Fix potential overflow in blk_report_zones()
In reply to Greg Kroah-HartmanFrom: Damien Le Moal <[email protected]>
commit 113ab72ed4794c193509a97d7c6d32a6886e1682 upstream.
For large values of the number of zones reported and/or large zone sizes, the sector increment calculated with
blk_queue_zone_sectors(q) * n
in blk_report_zones() loop can overflow the unsigned int type used for the calculation as both "n" and blk_queue_zone_sectors() value are unsigned int. E.g. for a device with 256 MB zones (524288 sectors), overflow happens with 8192 or more zones reported.
Changing the return type of blk_queue_zone_sectors() to sector_t, fixes this problem and avoids overflow problem for all other callers of this helper too. The same change is also applied to the bdev_zone_sectors() helper.
--- block/blk-zoned.c | 2 +- include/linux/blkdev.h | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
block/blk-zoned.c +1 -1
@@ -69,7 +69,7 @@ EXPORT_SYMBOL_GPL(__blk_req_zone_write_ustatic inline unsigned int __blkdev_nr_zones (struct request_queue *q,sector_t nr_sectors) { -unsigned long zone_sectors =blk_queue_zone_sectors (q); +sector_t zone_sectors =blk_queue_zone_sectors (q);return (nr_sectors + zone_sectors -1 ) >>ilog2 (zone_sectors); }
include/linux/blkdev.h +2 -2
@@ -662,7 +662,7 @@ static inline bool blk_queue_is_zoned(st } } -static inline unsigned int blk_queue_zone_sectors (struct request_queue *q) +static inline sector_t blk_queue_zone_sectors (struct request_queue *q) {return blk_queue_is_zoned (q) ? q->limits.chunk_sectors :0 ; }
@@ -1400,7 +1400,7 @@ static inline bool bdev_is_zoned(structreturn false; } -static inline unsigned int bdev_zone_sectors (struct block_device *bdev) +static inline sector_t bdev_zone_sectors (struct block_device *bdev) {struct request_queue *q =bdev_get_queue (bdev);
Greg Kroah-Hartman
maintainerPATCH 328/371 RDMA/srp: Accept again source addresses that do not have a port number
In reply to Greg Kroah-HartmanFrom: Bart Van Assche <[email protected]>
commit bcef5b7215681250c4bf8961dfe15e9e4fef97d0 upstream.
The function srp_parse_in() is used both for parsing source address specifications and for target address specifications. Target addresses must have a port number. Having to specify a port number for source addresses is inconvenient. Make sure that srp_parse_in() supports again parsing addresses with no port number.
--- drivers/infiniband/ulp/srp/ib_srp.c | 21 +++++++++++++++------ 1 file changed, 15 insertions(+), 6 deletions(-)
drivers/infiniband/ulp/srp/ib_srp.c +15 -6
@@ -3481,13 +3481,14 @@ static const match_table_t srp_opt_token* @net: [in] Network namespace. * @sa: [out] Address family, IP address and port number. * @addr_port_str: [in] IP address and port number. +* @has_port: [out] Whether or not @addr_port_str includes a port number. * * Parse the following address formats: * - IPv4: <ip_address>:<port>, e.g. 1.2.3.4:5. * - IPv6: \[<ipv6_address>\]:<port>, e.g. [1::2:3%4]:5. */ static int srp_parse_in (struct net *net,struct sockaddr_storage *sa, -const char *addr_port_str) +const char *addr_port_str,bool *has_port) {char *addr_end, *addr =kstrdup (addr_port_str,GFP_KERNEL );char *port_str;
@@ -3496,9 +3497,12 @@ static int srp_parse_in(struct net *net,if (!addr)return -ENOMEM ; port_str =strrchr (addr,':' ); -if (!port_str) -return -EINVAL ; - *port_str++ ='\0' ; +if (port_str &&strchr (port_str,']' )) + port_str =NULL ; +if (port_str) + *port_str++ ='\0' ; +if (has_port) + *has_port = port_str !=NULL ; ret =inet_pton_with_scope (net,AF_INET , addr, port_str, sa);if (ret && addr[0 ]) { addr_end = addr +strlen (addr) -1 ;
@@ -3520,6 +3524,7 @@ static int srp_parse_options(struct netchar *p;substring_t args[MAX_OPT_ARGS ];unsigned long long ull; +bool has_port;int opt_mask =0 ;int token;int ret = -EINVAL ;
@@ -3618,7 +3623,8 @@ static int srp_parse_options(struct net ret = -ENOMEM ; goto out; } - ret =srp_parse_in (net, &target->rdma_cm.src.ss, p); + ret =srp_parse_in (net, &target->rdma_cm.src.ss, p, +NULL );if (ret <0 ) {pr_warn ("bad source parameter '%s'\n" , p);kfree (p);
@@ -3634,7 +3640,10 @@ static int srp_parse_options(struct net ret = -ENOMEM ; goto out; } - ret =srp_parse_in (net, &target->rdma_cm.dst.ss, p); + ret =srp_parse_in (net, &target->rdma_cm.dst.ss, p, + &has_port); +if (!has_port) + ret = -EINVAL ;if (ret <0 ) {pr_warn ("bad dest parameter '%s'\n" , p);kfree (p);
Greg Kroah-Hartman
maintainerPATCH 329/371 intel_th: pci: Add Ice Lake NNPI support
In reply to Greg Kroah-HartmanFrom: Alexander Shishkin <[email protected]>
commit 4aa5aed2b6f267592705a526f57518a5d715b769 upstream.
This adds Ice Lake NNPI support to the Intel(R) Trace Hub.
--- drivers/hwtracing/intel_th/pci.c | 5 +++++ 1 file changed, 5 insertions(+)
drivers/hwtracing/intel_th/pci.c +5 -0
@@ -170,6 +170,11 @@ static const struct pci_device_id intel_ PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x02a6), .driver_data = (kernel_ulong_t)&intel_th_2x, }, + { +/* Ice Lake NNPI */ + PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x45c5), + .driver_data = (kernel_ulong_t)&intel_th_2x, + }, { 0 }, };
Greg Kroah-Hartman
maintainerPATCH 330/371 PCI: hv: Fix a use-after-free bug in hv_eject_device_work()
In reply to Greg Kroah-HartmanFrom: Dexuan Cui <[email protected]>
commit 4df591b20b80cb77920953812d894db259d85bd7 upstream.
Fix a use-after-free in hv_eject_device_work().
--- drivers/pci/controller/pci-hyperv.c | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-)
drivers/pci/controller/pci-hyperv.c +9 -6
@@ -1875,6 +1875,7 @@ static void hv_pci_devices_present(strucstatic void hv_eject_device_work (struct work_struct *work) {struct pci_eject_response *ejct_pkt; +struct hv_pcibus_device *hbus;struct hv_pci_dev *hpdev;struct pci_dev *pdev;unsigned long flags;
@@ -1885,6 +1886,7 @@ static void hv_eject_device_work(struct } ctxt; hpdev = container_of(work, struct hv_pci_dev, wrk); + hbus = hpdev->hbus;WARN_ON (hpdev->state != hv_pcichild_ejecting);
@@ -1895,8 +1897,7 @@ static void hv_eject_device_work(struct* because hbus->pci_bus may not exist yet. */ wslot =wslot_to_devfn (hpdev->desc.win_slot.slot); - pdev =pci_get_domain_bus_and_slot (hpdev->hbus->sysdata.domain,0 , - wslot); + pdev =pci_get_domain_bus_and_slot (hbus->sysdata.domain,0 , wslot);if (pdev) {pci_lock_rescan_remove ();pci_stop_and_remove_bus_device (pdev);
@@ -1904,9 +1905,9 @@ static void hv_eject_device_work(structpci_unlock_rescan_remove (); } -spin_lock_irqsave (&hpdev->hbus->device_list_lock, flags); +spin_lock_irqsave (&hbus->device_list_lock, flags);list_del (&hpdev->list_entry); -spin_unlock_irqrestore (&hpdev->hbus->device_list_lock, flags); +spin_unlock_irqrestore (&hbus->device_list_lock, flags);if (hpdev->pci_slot)pci_destroy_slot (hpdev->pci_slot);
@@ -1915,7 +1916,7 @@ static void hv_eject_device_work(struct ejct_pkt = (struct pci_eject_response *)&ctxt.pkt.message; ejct_pkt->message_type.type =PCI_EJECTION_COMPLETE ; ejct_pkt->wslot.slot = hpdev->desc.win_slot.slot; -vmbus_sendpacket (hpdev->hbus->hdev->channel, ejct_pkt, +vmbus_sendpacket (hbus->hdev->channel, ejct_pkt,sizeof (*ejct_pkt), (unsigned long )&ctxt.pkt,VM_PKT_DATA_INBAND ,0 );
@@ -1924,7 +1925,9 @@ static void hv_eject_device_work(struct/* For the two refs got in new_pcichild_device() */ put_pcichild (hpdev);put_pcichild (hpdev); -put_hvpcibus (hpdev->hbus); +/* hpdev has been freed. Do not use it any more. */ + +put_hvpcibus (hbus); }/**
Greg Kroah-Hartman
maintainerPATCH 331/371 PCI: Do not poll for PME if the device is in D3cold
In reply to Greg Kroah-HartmanFrom: Mika Westerberg <[email protected]>
commit 000dd5316e1c756a1c028f22e01d06a38249dd4d upstream.
PME polling does not take into account that a device that is directly connected to the host bridge may go into D3cold as well. This leads to a situation where the PME poll thread reads from a config space of a device that is in D3cold and gets incorrect information because the config space is not accessible.
Here is an example from Intel Ice Lake system where two PCIe root ports are in D3cold (I've instrumented the kernel to log the PMCSR register contents):
[ 62.971442] pcieport 0000:00:07.1: Check PME status, PMCSR=0xffff [ 62.971504] pcieport 0000:00:07.0: Check PME status, PMCSR=0xffff
Since 0xffff is interpreted so that PME is pending, the root ports will be runtime resumed. This repeats over and over again essentially blocking all runtime power management.
Prevent this from happening by checking whether the device is in D3cold before its PME status is read.
--- drivers/pci/pci.c | 7 +++++++ 1 file changed, 7 insertions(+)
drivers/pci/pci.c +7 -0
@@ -2052,6 +2052,13 @@ static void pci_pme_list_scan(struct wor*/ if (bridge && bridge->current_state !=PCI_D0 )continue ; +/* +* If the device is in D3cold it should not be +* polled either. +*/ +if (pme_dev->dev->current_state == PCI_D3cold) +continue ; +pci_pme_wakeup (pme_dev->dev,NULL ); }else {list_del (&pme_dev->list);
Greg Kroah-Hartman
maintainerPATCH 332/371 PCI: qcom: Ensure that PERST is asserted for at least 100 ms
In reply to Greg Kroah-HartmanFrom: Niklas Cassel <[email protected]>
commit 64adde31c8e996a6db6f7a1a4131180e363aa9f2 upstream.
Currently, there is only a 1 ms sleep after asserting PERST.
Reading the datasheets for different endpoints, some require PERST to be asserted for 10 ms in order for the endpoint to perform a reset, others require it to be asserted for 50 ms.
Several SoCs using this driver uses PCIe Mini Card, where we don't know what endpoint will be plugged in.
The PCI Express Card Electromechanical Specification r2.0, section 2.2, "PERST# Signal" specifies:
"On power up, the deassertion of PERST# is delayed 100 ms (TPVPERL) from the power rails achieving specified operating limits."
Add a sleep of 100 ms before deasserting PERST, in order to ensure that we are compliant with the spec.
--- drivers/pci/controller/dwc/pcie-qcom.c | 2 ++ 1 file changed, 2 insertions(+)
drivers/pci/controller/dwc/pcie-qcom.c +2 -0
@@ -178,6 +178,8 @@ static void qcom_ep_reset_assert(structstatic void qcom_ep_reset_deassert (struct qcom_pcie *pcie) { +/* Ensure that PERST has been asserted for at least 100 ms */ +msleep (100 );gpiod_set_value_cansleep (pcie->reset,0 );usleep_range (PERST_DELAY_US ,PERST_DELAY_US +500 ); }
Greg Kroah-Hartman
maintainerPATCH 333/371 Btrfs: fix data loss after inode eviction, renaming it, and fsync it
In reply to Greg Kroah-HartmanFrom: Filipe Manana <[email protected]>
commit d1d832a0b51dd9570429bb4b81b2a6c1759e681a upstream.
When we log an inode, regardless of logging it completely or only that it exists, we always update it as logged (logged_trans and last_log_commit fields of the inode are updated). This is generally fine and avoids future attempts to log it from having to do repeated work that brings no value.
However, if we write data to a file, then evict its inode after all the dealloc was flushed (and ordered extents completed), rename the file and fsync it, we end up not logging the new extents, since the rename may result in logging that the inode exists in case the parent directory was logged before. The following reproducer shows and explains how this can happen:
$ mkfs.btrfs -f /dev/sdb $ mount /dev/sdb /mnt
$ mkdir /mnt/dir $ touch /mnt/dir/foo $ touch /mnt/dir/bar
# Do a direct IO write instead of a buffered write because with a
# buffered write we would need to make sure dealloc gets flushed and # complete before we do the inode eviction later, and we can not do that # from user space with call to things such as sync(2) since that results # in a transaction commit as well. $ xfs_io -d -c "pwrite -S 0xd3 0 4K" /mnt/dir/bar
# Keep the directory dir in use while we evict inodes. We want our file # bar's inode to be evicted but we don't want our directory's inode to
# be evicted (if it were evicted too, we would not be able to reproduce # the issue since the first fsync below, of file foo, would result in a # transaction commit. $ ( cd /mnt/dir; while true; do :; done ) & $ pid=$!
# Wait a bit to give time for the background process to chdir.
$ sleep 0.1
# Evict all inodes, except the inode for the directory dir because it is
# currently in use by our background process. $ echo 2 > /proc/sys/vm/drop_caches
# fsync file foo, which ends up persisting information about the parent # directory because it is a new inode. $ xfs_io -c fsync /mnt/dir/foo
# Rename bar, this results in logging that this inode exists (inode item, # names, xattrs) because the parent directory is in the log.
$ mv /mnt/dir/bar /mnt/dir/baz
# Now fsync baz, which ends up doing absolutely nothing because of the
# rename operation which logged that the inode exists only. $ xfs_io -c fsync /mnt/dir/baz
<power failure>
$ mount /dev/sdb /mnt $ od -t x1 -A d /mnt/dir/baz 0000000
--> Empty file, data we wrote is missing.
Fix this by not updating last_sub_trans of an inode when we are logging only that it exists and the inode was not yet logged since it was loaded from disk (full_sync bit set), this is enough to make btrfs_inode_in_log() return false for this scenario and make us log the inode. The logged_trans of the inode is still always setsince that alone is used to track if names need to be deleted as part of unlink operations.
--- fs/btrfs/tree-log.c | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-)
fs/btrfs/tree-log.c +11 -1
@@ -5407,9 +5407,19 @@ log_extents: } } +/* +* Don't update last_log_commit if we logged that an inode exists after +* it was loaded to memory (full_sync bit set). +* This is to prevent data loss when we do a write to the inode, then +* the inode gets evicted after all delalloc was flushed, then we log +* it exists (due to a rename for example) and then fsync it. This last +* fsync would do nothing (not logging the extents previously written). +*/ spin_lock (&inode->lock); inode->logged_trans = trans->transid; - inode->last_log_commit = inode->last_sub_trans; +if (inode_only !=LOG_INODE_EXISTS || + !test_bit (BTRFS_INODE_NEEDS_FULL_SYNC , &inode->runtime_flags)) + inode->last_log_commit = inode->last_sub_trans;spin_unlock (&inode->lock); out_unlock:mutex_unlock (&inode->log_mutex);
Greg Kroah-Hartman
maintainerPATCH 334/371 Btrfs: fix fsync not persisting dentry deletions due to inode evictions
In reply to Greg Kroah-HartmanFrom: Filipe Manana <[email protected]>
commit 803f0f64d17769071d7287d9e3e3b79a3e1ae937 upstream.
In order to avoid searches on a log tree when unlinking an inode, we check if the inode being unlinked was logged in the current transaction, as well as the inode of its parent directory. When any of the inodes are logged, we proceed to delete directory items and inode reference items from the log, to ensure that if a subsequent fsync of only the inode being unlinked or only of the parent directory when the other is not fsync'ed as well, does not result in the entry still existing after a power failure.
That check however is not reliable when one of the inodes involved (the one being unlinked or its parent directory's inode) is evicted, since the logged_trans field is transient, that is, it is not stored on disk, so it is lost when the inode is evicted and loaded into memory again (which is set to zero on load). As a consequence the checks currently being done by btrfs_del_dir_entries_in_log() and btrfs_del_inode_ref_in_log() always return true if the inode was evicted before, regardless of the inode having been logged or not before (and in the current transaction), this results in the dentry being unlinked still existing after a log replay if after the unlink operation only one of the inodes involved is fsync'ed.
Example:
$ mkfs.btrfs -f /dev/sdb $ mount /dev/sdb /mnt
$ mkdir /mnt/dir $ touch /mnt/dir/foo $ xfs_io -c fsync /mnt/dir/foo
# Keep an open file descriptor on our directory while we evict inodes. # We just want to evict the file's inode, the directory's inode must not
# be evicted. $ ( cd /mnt/dir; while true; do :; done ) & $ pid=$!
# Wait a bit to give time to background process to chdir to our test
# directory. $ sleep 0.5
# Trigger eviction of the file's inode.
$ echo 2 > /proc/sys/vm/drop_caches
# Unlink our file and fsync the parent directory. After a power failure
# we don't expect to see the file anymore, since we fsync'ed the parent # directory. $ rm -f $SCRATCH_MNT/dir/foo $ xfs_io -c fsync /mnt/dir
<power failure>
$ mount /dev/sdb /mnt $ ls /mnt/dir foo $ --> file still there, unlink not persisted despite explicit fsync on dir
Fix this by checking if the inode has the full_sync bit set in its runtime flags as well, since that bit is set everytime an inode is loaded from disk, or for other less common cases such as after a shrinking truncate or failure to allocate extent maps for holes, and gets cleared after the first fsync. Also consider the inode as possibly logged only if it was last modified in the current transaction (besides having the full_fsync flag set).
--- fs/btrfs/tree-log.c | 28 ++++++++++++++++++++++++++-- 1 file changed, 26 insertions(+), 2 deletions(-)
fs/btrfs/tree-log.c +26 -2
@@ -3309,6 +3309,30 @@ int btrfs_free_log_root_tree(struct btrf }/* +* Check if an inode was logged in the current transaction. We can't always rely +* on an inode's logged_trans value, because it's an in-memory only field and +* therefore not persisted. This means that its value is lost if the inode gets +* evicted and loaded again from disk (in which case it has a value of 0, and +* certainly it is smaller then any possible transaction ID), when that happens +* the full_sync flag is set in the inode's runtime flags, so on that case we +* assume eviction happened and ignore the logged_trans value, assuming the +* worst case, that the inode was logged before in the current transaction. +*/ +static bool inode_logged (struct btrfs_trans_handle *trans, +struct btrfs_inode *inode) +{ +if (inode->logged_trans == trans->transid) +return true; + +if (inode->last_trans == trans->transid && +test_bit (BTRFS_INODE_NEEDS_FULL_SYNC , &inode->runtime_flags) && + !test_bit (BTRFS_FS_LOG_RECOVERING , &trans->fs_info->flags)) +return true; + +return false; +} + +/* * If both a file and directory are logged, and unlinks or renames are * mixed in, we have a few interesting corners: *
@@ -3342,7 +3366,7 @@ int btrfs_del_dir_entries_in_log(structint bytes_del =0 ;u64 dir_ino =btrfs_ino (dir); -if (dir->logged_trans < trans->transid) +if (!inode_logged (trans, dir))return 0 ; ret =join_running_log_trans (root);
@@ -3447,7 +3471,7 @@ int btrfs_del_inode_ref_in_log(struct btu64 index;int ret; -if (inode->logged_trans < trans->transid) +if (!inode_logged (trans, inode))return 0 ; ret =join_running_log_trans (root);
Greg Kroah-Hartman
maintainerPATCH 335/371 Btrfs: add missing inode version, ctime and mtime updates when punching hole
In reply to Greg Kroah-HartmanFrom: Filipe Manana <[email protected]>
commit 179006688a7e888cbff39577189f2e034786d06a upstream.
If the range for which we are punching a hole covers only part of a page, we end up updating the inode item but we skip the update of the inode's iversion, mtime and ctime. Fix that by ensuring we update those properties of the inode.
A patch for fstests test case generic/059 that tests this as been sent along with this fix.
--- fs/btrfs/file.c | 5 +++++ 1 file changed, 5 insertions(+)
fs/btrfs/file.c +5 -0
@@ -2713,6 +2713,11 @@ out_only_mutex:* for detecting, at fsync time, if the inode isn't yet in the * log tree or it's there but not up to date. */ +struct timespec64 now =current_time (inode); + +inode_inc_iversion (inode); + inode->i_mtime = now; + inode->i_ctime = now; trans =btrfs_start_transaction (root,1 );if (IS_ERR (trans)) { err =PTR_ERR (trans);
Greg Kroah-Hartman
maintainerPATCH 336/371 IB/mlx5: Report correctly tag matching rendezvous capability
In reply to Greg Kroah-HartmanFrom: Danit Goldberg <[email protected]>
commit 89705e92700170888236555fe91b45e4c1bb0985 upstream.
Userspace expects the IB_TM_CAP_RC bit to indicate that the device supports RC transport tag matching with rendezvous offload. However the firmware splits this into two capabilities for eager and rendezvous tag matching.
Only if the FW supports both modes should userspace be told the tag matching capability is available.
--- drivers/infiniband/hw/mlx5/main.c | 8 ++++++-- include/rdma/ib_verbs.h | 4 ++-- 2 files changed, 8 insertions(+), 4 deletions(-)
drivers/infiniband/hw/mlx5/main.c +6 -2
@@ -1041,15 +1041,19 @@ static int mlx5_ib_query_device(struct i }if (MLX5_CAP_GEN (mdev, tag_matching)) { - props->tm_caps.max_rndv_hdr_size =MLX5_TM_MAX_RNDV_MSG_SIZE ; props->tm_caps.max_num_tags = (1 <<MLX5_CAP_GEN (mdev, log_tag_matching_list_sz)) -1 ; - props->tm_caps.flags =IB_TM_CAP_RC ; props->tm_caps.max_ops =1 <<MLX5_CAP_GEN (mdev, log_max_qp_sz); props->tm_caps.max_sge =MLX5_TM_MAX_SGE ; } +if (MLX5_CAP_GEN (mdev, tag_matching) && +MLX5_CAP_GEN (mdev, rndv_offload_rc)) { + props->tm_caps.flags =IB_TM_CAP_RNDV_RC ; + props->tm_caps.max_rndv_hdr_size =MLX5_TM_MAX_RNDV_MSG_SIZE ; + } +if (MLX5_CAP_GEN (dev->mdev, cq_moderation)) { props->cq_caps.max_cq_moderation_count =MLX5_MAX_CQ_COUNT ;
include/rdma/ib_verbs.h +2 -2
@@ -293,8 +293,8 @@ struct ib_rss_caps { };enum ib_tm_cap_flags { -/* Support tag matching on RC transport */ -IB_TM_CAP_RC =1 <<0 , +/* Support tag matching with rendezvous offload for RC transport */ +IB_TM_CAP_RNDV_RC =1 <<0 , };struct ib_tm_caps {
Greg Kroah-Hartman
maintainerPATCH 337/371 HID: wacom: generic: only switch the mode on devices with LEDs
In reply to Greg Kroah-HartmanFrom: Aaron Armstrong Skomra <[email protected]>
commit d8e9806005f28bbb49899dab2068e3359e22ba35 upstream.
Currently, the driver will attempt to set the mode on all devices with a center button, but some devices with a center button lack LEDs, and attempting to set the LEDs on devices without LEDs results in the kernel error message of the form:
"leds input8::wacom-0.1: Setting an LED's brightness failed (-32)"
This is because the generic codepath erroneously assumes that the BUTTON_CENTER usage indicates that the device has LEDs, the previously ignored TOUCH_RING_SETTING usage is a more accurate indication of the existence of LEDs on the device.
--- drivers/hid/wacom_sys.c | 3 +++ drivers/hid/wacom_wac.c | 2 -- drivers/hid/wacom_wac.h | 1 + 3 files changed, 4 insertions(+), 2 deletions(-)
drivers/hid/wacom_sys.c +3 -0
@@ -307,6 +307,9 @@ static void wacom_feature_mapping(structwacom_hid_usage_quirk (hdev, field, usage);switch (equivalent_usage) { +case WACOM_HID_WD_TOUCH_RING_SETTING : + wacom->generic_has_leds = true; +break ;case HID_DG_CONTACTMAX :/* leave touch_max as is if predefined */ if (!features->touch_max) {
drivers/hid/wacom_wac.c +0 -2
@@ -1930,8 +1930,6 @@ static void wacom_wac_pad_usage_mapping( features->device_type |=WACOM_DEVICETYPE_PAD ;break ;case WACOM_HID_WD_BUTTONCENTER : - wacom->generic_has_leds = true; -/* fall through */ case WACOM_HID_WD_BUTTONHOME :case WACOM_HID_WD_BUTTONUP :case WACOM_HID_WD_BUTTONDOWN :
drivers/hid/wacom_wac.h +1 -0
@@ -145,6 +145,7 @@#define WACOM_HID_WD_OFFSETBOTTOM (WACOM_HID_UP_WACOMDIGITIZER | 0x0d33)#define WACOM_HID_WD_DATAMODE (WACOM_HID_UP_WACOMDIGITIZER | 0x1002)#define WACOM_HID_WD_DIGITIZERINFO (WACOM_HID_UP_WACOMDIGITIZER | 0x1013) +#define WACOM_HID_WD_TOUCH_RING_SETTING (WACOM_HID_UP_WACOMDIGITIZER | 0x1032)#define WACOM_HID_UP_G9 0xff090000#define WACOM_HID_G9_PEN (WACOM_HID_UP_G9 | 0x02)#define WACOM_HID_G9_TOUCHSCREEN (WACOM_HID_UP_G9 | 0x11)
Greg Kroah-Hartman
maintainerPATCH 338/371 HID: wacom: generic: Correct pad syncing
In reply to Greg Kroah-HartmanFrom: Aaron Armstrong Skomra <[email protected]>
commit d4b8efeb46d99a5d02e7f88ac4eaccbe49370770 upstream.
Only sync the pad once per report, not once per collection. Also avoid syncing the pad on battery reports.
--- drivers/hid/wacom_wac.c | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-)
drivers/hid/wacom_wac.c +8 -7
@@ -2121,14 +2121,12 @@ static void wacom_wac_pad_report(structbool active = wacom_wac->hid_data.inrange_state !=0 ;/* report prox for expresskey events */ -if ((wacom_equivalent_usage (field->physical) ==HID_DG_TABLETFUNCTIONKEY ) && - wacom_wac->hid_data.pad_input_event_flag) { +if (wacom_wac->hid_data.pad_input_event_flag) {input_event (input,EV_ABS ,ABS_MISC , active ?PAD_DEVICE_ID :0 );input_sync (input);if (!active) wacom_wac->hid_data.pad_input_event_flag = false; } - } static void wacom_wac_pen_usage_mapping(struct hid_device *hdev,
@@ -2704,9 +2702,7 @@ static int wacom_wac_collection(struct hif (report->type !=HID_INPUT_REPORT )return -1 ; -if (WACOM_PAD_FIELD (field) && wacom->wacom_wac.pad_input) -wacom_wac_pad_report (hdev, report, field); -else if (WACOM_PEN_FIELD (field) && wacom->wacom_wac.pen_input) +if (WACOM_PEN_FIELD (field) && wacom->wacom_wac.pen_input)wacom_wac_pen_report (hdev, report);else if (WACOM_FINGER_FIELD (field) && wacom->wacom_wac.touch_input)wacom_wac_finger_report (hdev, report);
@@ -2720,7 +2716,7 @@ void wacom_wac_report(struct hid_devicestruct wacom_wac *wacom_wac = &wacom->wacom_wac;struct hid_field *field;bool pad_in_hid_field = false, pen_in_hid_field = false, - finger_in_hid_field = false; + finger_in_hid_field = false, true_pad = false;int r;int prev_collection =-1 ;
@@ -2736,6 +2732,8 @@ void wacom_wac_report(struct hid_device pen_in_hid_field = true;if (WACOM_FINGER_FIELD (field)) finger_in_hid_field = true; +if (wacom_equivalent_usage (field->physical) ==HID_DG_TABLETFUNCTIONKEY ) + true_pad = true; }wacom_wac_battery_pre_report (hdev, report);
@@ -2759,6 +2757,9 @@ void wacom_wac_report(struct hid_device }wacom_wac_battery_report (hdev, report); + +if (true_pad && wacom->wacom_wac.pad_input) +wacom_wac_pad_report (hdev, report, field); }static int wacom_bpt_touch (struct wacom_wac *wacom)
Greg Kroah-Hartman
maintainerPATCH 339/371 HID: wacom: correct touch resolution x/y typo
In reply to Greg Kroah-HartmanFrom: Aaron Armstrong Skomra <[email protected]>
commit 68c20cc2164cc5c7c73f8012ae6491afdb1f7f72 upstream.
This affects the 2nd-gen Intuos Pro Medium and Large when using their Bluetooth connection.
--- drivers/hid/wacom_wac.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/hid/wacom_wac.c +1 -1
@@ -3716,7 +3716,7 @@ int wacom_setup_touch_input_capabilities 0, 5920, 4, 0); }input_abs_set_res (input_dev,ABS_MT_POSITION_X ,40 ); -input_abs_set_res (input_dev,ABS_MT_POSITION_X ,40 ); +input_abs_set_res (input_dev,ABS_MT_POSITION_Y ,40 );/* fall through */
Greg Kroah-Hartman
maintainerPATCH 340/371 mm/nvdimm: add is_ioremap_addr and use that to check ioremap address
In reply to Greg Kroah-HartmanFrom: Aneesh Kumar K.V <[email protected]>
commit 9bd3bb6703d8c0a5fb8aec8e3287bd55b7341dcd upstream.
Architectures like powerpc use different address range to map ioremap and vmalloc range. The memunmap() check used by the nvdimm layer was wrongly using is_vmalloc_addr() to check for ioremap range which fails for ppc64. This result in ppc64 not freeing the ioremap mapping. The side effect of this is an unbind failure during module unload with papr_scm nvdimm driver
--- arch/powerpc/include/asm/pgtable.h | 14 ++++++++++++++ include/linux/mm.h | 5 +++++ kernel/iomem.c | 2 +- 3 files changed, 20 insertions(+), 1 deletion(-)
arch/powerpc/include/asm/pgtable.h +14 -0
@@ -137,6 +137,20 @@ static inline void pte_frag_set(mm_conte }#endif +#ifdef CONFIG_PPC64 +#define is_ioremap_addr is_ioremap_addr +static inline bool is_ioremap_addr (const void *x) +{ +#ifdef CONFIG_MMU +unsigned long addr = (unsigned long )x; + +return addr >=IOREMAP_BASE && addr <IOREMAP_END ; +#else +return false; +#endif +} +#endif /* CONFIG_PPC64 */ +#endif /* __ASSEMBLY__ */ #endif /* _ASM_POWERPC_PGTABLE_H */
include/linux/mm.h +5 -0
@@ -590,6 +590,11 @@ static inline bool is_vmalloc_addr(constreturn false;#endif } + +#ifndef is_ioremap_addr +#define is_ioremap_addr (x) is_vmalloc_addr(x) +#endif +#ifdef CONFIG_MMU extern int is_vmalloc_or_module_addr (const void *x);#else
kernel/iomem.c +1 -1
@@ -121,7 +121,7 @@ EXPORT_SYMBOL(memremap);void memunmap (void *addr) { -if (is_vmalloc_addr (addr)) +if (is_ioremap_addr (addr))iounmap ((void __iomem *) addr); }EXPORT_SYMBOL (memunmap);
Greg Kroah-Hartman
maintainerPATCH 341/371 libnvdimm/pfn: fix fsdax-mode namespace info-block zero-fields
In reply to Greg Kroah-HartmanFrom: Dan Williams <[email protected]>
commit 7e3e888dfc138089f4c15a81b418e88f0978f744 upstream.
At namespace creation time there is the potential for the "expected to be zero" fields of a 'pfn' info-block to be filled with indeterminate data. While the kernel buffer is zeroed on allocation it is immediately overwritten by nd_pfn_validate() filling it with the current contents of the on-media info-block location. For fields like, 'flags' and the 'padding' it potentially means that future implementations can not rely on those fields being zero.
In preparation to stop using the 'start_pad' and 'end_trunc' fields for section alignment, arrange for fields that are not explicitly initialized to be guaranteed zero. Bump the minor version to indicate it is safe to assume the 'padding' and 'flags' are zero. Otherwise, this corruption is expected to benign since all other critical fields are explicitly initialized.
Note The cc: stable is about spreading this new policy to as many kernels as possible not fixing an issue in those kernels. It is not until the change titled "libnvdimm/pfn: Stop padding pmem namespaces to section alignment" where this improper initialization becomes a problem. So if someone decides to backport "libnvdimm/pfn: Stop padding pmem namespaces to section alignment" (which is not tagged for stable), make sure this pre-requisite is flagged.
--- drivers/nvdimm/dax_devs.c | 2 +- drivers/nvdimm/pfn.h | 1 + drivers/nvdimm/pfn_devs.c | 18 +++++++++++++++--- 3 files changed, 17 insertions(+), 4 deletions(-)
drivers/nvdimm/dax_devs.c +1 -1
@@ -126,7 +126,7 @@ int nd_dax_probe(struct device *dev, strnvdimm_bus_unlock (&ndns->dev);if (!dax_dev)return -ENOMEM ; - pfn_sb =devm_kzalloc (dev,sizeof (*pfn_sb),GFP_KERNEL ); + pfn_sb =devm_kmalloc (dev,sizeof (*pfn_sb),GFP_KERNEL ); nd_pfn->pfn_sb = pfn_sb; rc =nd_pfn_validate (nd_pfn,DAX_SIG );dev_dbg (dev,"dax: %s\n" , rc ==0 ?dev_name (dax_dev) :"<none>" );
drivers/nvdimm/pfn.h +1 -0
@@ -36,6 +36,7 @@ struct nd_pfn_sb {__le32 end_trunc;/* minor-version-2 record the base alignment of the mapping */ __le32 align; +/* minor-version-3 guarantee the padding and flags are zero */ u8 padding[4000 ];__le64 checksum; };
drivers/nvdimm/pfn_devs.c +15 -3
@@ -420,6 +420,15 @@ static int nd_pfn_clear_memmap_errors(streturn 0 ; } +/** +* nd_pfn_validate - read and validate info-block +* @nd_pfn: fsdax namespace runtime state / properties +* @sig: 'devdax' or 'fsdax' signature +* +* Upon return the info-block buffer contents (->pfn_sb) are +* indeterminate when validation fails, and a coherent info-block +* otherwise. +*/ int nd_pfn_validate (struct nd_pfn *nd_pfn,const char *sig) {u64 checksum, offset;
@@ -565,7 +574,7 @@ int nd_pfn_probe(struct device *dev, strnvdimm_bus_unlock (&ndns->dev);if (!pfn_dev)return -ENOMEM ; - pfn_sb =devm_kzalloc (dev,sizeof (*pfn_sb),GFP_KERNEL ); + pfn_sb =devm_kmalloc (dev,sizeof (*pfn_sb),GFP_KERNEL ); nd_pfn =to_nd_pfn (pfn_dev); nd_pfn->pfn_sb = pfn_sb; rc =nd_pfn_validate (nd_pfn,PFN_SIG );
@@ -702,7 +711,7 @@ static int nd_pfn_init(struct nd_pfn *ndu64 checksum;int rc; - pfn_sb =devm_kzalloc (&nd_pfn->dev,sizeof (*pfn_sb),GFP_KERNEL ); + pfn_sb =devm_kmalloc (&nd_pfn->dev,sizeof (*pfn_sb),GFP_KERNEL );if (!pfn_sb)return -ENOMEM ;
@@ -711,11 +720,14 @@ static int nd_pfn_init(struct nd_pfn *nd sig =DAX_SIG ; else sig =PFN_SIG ; + rc =nd_pfn_validate (nd_pfn, sig);if (rc != -ENODEV )return rc;/* no info block, do init */ ; +memset (pfn_sb,0 ,sizeof (*pfn_sb)); + nd_region =to_nd_region (nd_pfn->dev.parent);if (nd_region->ro) { dev_info(&nd_pfn->dev,
@@ -768,7 +780,7 @@ static int nd_pfn_init(struct nd_pfn *ndmemcpy (pfn_sb->uuid, nd_pfn->uuid,16 );memcpy (pfn_sb->parent_uuid,nd_dev_to_uuid (&ndns->dev),16 ); pfn_sb->version_major =cpu_to_le16 (1 ); - pfn_sb->version_minor =cpu_to_le16 (2 ); + pfn_sb->version_minor =cpu_to_le16 (3 ); pfn_sb->start_pad =cpu_to_le32 (start_pad); pfn_sb->end_trunc =cpu_to_le32 (end_trunc); pfn_sb->align =cpu_to_le32 (nd_pfn->align);
Greg Kroah-Hartman
maintainerPATCH 342/371 coda: pass the host file in vma->vm_file on mmap
In reply to Greg Kroah-HartmanFrom: Jan Harkes <[email protected]>
commit 7fa0a1da3dadfd9216df7745a1331fdaa0940d1c upstream.
Patch series "Coda updates".
The following patch series is a collection of various fixes for Coda, most of which were collected from linux-fsdevel or linux-kernel but which have as yet not found their way upstream.
This patch (of 22):
Various file systems expect that vma->vm_file points at their own file handle, several use file_inode(vma->vm_file) to get at their inode or use vma->vm_file->private_data. However the way Coda wrapped mmap on a host file broke this assumption, vm_file was still pointing at the Coda file and the host file systems would scribble over Coda's inode and private file data.
This patch fixes the incorrect expectation and wraps vm_ops->open and vm_ops->close to allow Coda to track when the vm_area_struct is destroyed so we still release the reference on the Coda file handle at the right time.
--- fs/coda/file.c | 70 +++++++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 68 insertions(+), 2 deletions(-)
fs/coda/file.c +68 -2
@@ -27,6 +27,13 @@#include "coda_linux.h" #include "coda_int.h" +struct coda_vm_ops { +atomic_t refcnt; +struct file *coda_file; +const struct vm_operations_struct *host_vm_ops; +struct vm_operations_struct vm_ops; +}; +static ssize_t coda_file_read_iter (struct kiocb *iocb,struct iov_iter *to) {
@@ -61,6 +68,34 @@ coda_file_write_iter(struct kiocb *iocb,return ret; } +static void +coda_vm_open (struct vm_area_struct *vma) +{ +struct coda_vm_ops *cvm_ops = + container_of(vma->vm_ops, struct coda_vm_ops, vm_ops); + +atomic_inc (&cvm_ops->refcnt); + +if (cvm_ops->host_vm_ops && cvm_ops->host_vm_ops->open) + cvm_ops->host_vm_ops->open (vma); +} + +static void +coda_vm_close (struct vm_area_struct *vma) +{ +struct coda_vm_ops *cvm_ops = + container_of(vma->vm_ops, struct coda_vm_ops, vm_ops); + +if (cvm_ops->host_vm_ops && cvm_ops->host_vm_ops->close) + cvm_ops->host_vm_ops->close (vma); + +if (atomic_dec_and_test (&cvm_ops->refcnt)) { + vma->vm_ops = cvm_ops->host_vm_ops; +fput (cvm_ops->coda_file); +kfree (cvm_ops); + } +} +static int coda_file_mmap (struct file *coda_file,struct vm_area_struct *vma) {
@@ -68,6 +103,8 @@ coda_file_mmap(struct file *coda_file, sstruct coda_inode_info *cii;struct file *host_file;struct inode *coda_inode, *host_inode; +struct coda_vm_ops *cvm_ops; +int ret; cfi =CODA_FTOC (coda_file);BUG_ON (!cfi || cfi->cfi_magic !=CODA_MAGIC );
@@ -76,6 +113,13 @@ coda_file_mmap(struct file *coda_file, sif (!host_file->f_op->mmap)return -ENODEV ; +if (WARN_ON (coda_file != vma->vm_file)) +return -EIO ; + + cvm_ops =kmalloc (sizeof (struct coda_vm_ops ),GFP_KERNEL ); +if (!cvm_ops) +return -ENOMEM ; + coda_inode =file_inode (coda_file); host_inode =file_inode (host_file);
@@ -89,6 +133,7 @@ coda_file_mmap(struct file *coda_file, s* the container file on us! */ else if (coda_inode->i_mapping != host_inode->i_mapping) {spin_unlock (&cii->c_lock); +kfree (cvm_ops);return -EBUSY ; }
@@ -97,7 +142,29 @@ coda_file_mmap(struct file *coda_file, s cfi->cfi_mapcount++;spin_unlock (&cii->c_lock); -return call_mmap (host_file, vma); + vma->vm_file =get_file (host_file); + ret =call_mmap (vma->vm_file, vma); + +if (ret) { +/* if call_mmap fails, our caller will put coda_file so we +* should drop the reference to the host_file that we got. +*/ +fput (host_file); +kfree (cvm_ops); + }else { +/* here we add redirects for the open/close vm_operations */ + cvm_ops->host_vm_ops = vma->vm_ops; +if (vma->vm_ops) + cvm_ops->vm_ops = *vma->vm_ops; + + cvm_ops->vm_ops.open = coda_vm_open; + cvm_ops->vm_ops.close = coda_vm_close; + cvm_ops->coda_file = coda_file; +atomic_set (&cvm_ops->refcnt,1 ); + + vma->vm_ops = &cvm_ops->vm_ops; + } +return ret; }int coda_open (struct inode *coda_inode,struct file *coda_file)
@@ -207,4 +274,3 @@ const struct file_operations coda_file_o .fsync = coda_fsync, .splice_read = generic_file_splice_read, }; -
Greg Kroah-Hartman
maintainerPATCH 343/371 include/asm-generic/bug.h: fix "cut here" for WARN_ON for __WARN_TAINT architectures
In reply to Greg Kroah-HartmanFrom: Drew Davenport <[email protected]>
commit 6b15f678fb7d5ef54e089e6ace72f007fe6e9895 upstream.
For architectures using __WARN_TAINT, the WARN_ON macro did not print out the "cut here" string. The other WARN_XXX macros would print "cut here" inside __warn_printk, which is not called for WARN_ON since it doesn't have a message to print.
--- include/asm-generic/bug.h | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)
include/asm-generic/bug.h +4 -2
@@ -104,8 +104,10 @@ extern void warn_slowpath_null(const cha warn_slowpath_fmt_taint(__FILE__, __LINE__, taint, arg)#else extern __printf(1, 2) void __warn_printk(const char *fmt, ...); -#define __WARN () __WARN_TAINT(TAINT_WARN) -#define __WARN_printf(arg...) do { __warn_printk(arg); __WARN(); } while (0) +#define __WARN () do { \ + printk(KERN_WARNING CUT_HERE); __WARN_TAINT(TAINT_WARN); \ +} while (0) +#define __WARN_printf(arg...) __WARN_printf_taint(TAINT_WARN, arg) #define __WARN_printf_taint(taint, arg...) \ do { __warn_printk(arg); __WARN_TAINT(taint); } while (0)#endif
Greg Kroah-Hartman
maintainerPATCH 344/371 resource: fix locking in find_next_iomem_res()
In reply to Greg Kroah-HartmanFrom: Nadav Amit <[email protected]>
commit 49f17c26c123b60fd1c74629eef077740d16ffc2 upstream.
Since resources can be removed, locking should ensure that the resource is not removed while accessing it. However, find_next_iomem_res() does not hold the lock while copying the data of the resource.
Keep holding the lock while the data is copied. While at it, change the return value to a more informative value. It is disregarded by the callers.
--- kernel/resource.c | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-)
kernel/resource.c +10 -10
@@ -325,7 +325,7 @@ EXPORT_SYMBOL(release_resource);* * If a resource is found, returns 0 and @*res is overwritten with the part * of the resource that's within [@start..@end]; if none is found, returns -* -1 or -EINVAL for other invalid parameters. +* -ENODEV. Returns -EINVAL for invalid parameters. * * This function walks the whole tree and not just first level children * unless @first_lvl is true.
@@ -364,16 +364,16 @@ static int find_next_iomem_res(resource_break ; } -read_unlock (&resource_lock); -if (!p) -return -1 ; +if (p) { +/* copy data */ + res->start =max (start, p->start); + res->end =min (end, p->end); + res->flags = p->flags; + res->desc = p->desc; + } -/* copy data */ - res->start =max (start, p->start); - res->end =min (end, p->end); - res->flags = p->flags; - res->desc = p->desc; -return 0 ; +read_unlock (&resource_lock); +return p ?0 : -ENODEV ; } static int __walk_iomem_res_desc(resource_size_t start, resource_size_t end,
Greg Kroah-Hartman
maintainerPATCH 345/371 xfs: abort unaligned nowait directio early
In reply to Greg Kroah-Hartman[ Upstream commit 1fdeaea4d92c69fb9f871a787af6ad00f32eeea7 ]
Dave Chinner noticed that xfs_file_dio_aio_write returns EAGAIN without dropping the IOLOCK when its deciding not to wait, which means that we leak the IOLOCK there. Since we now make unaligned directio always wait, we have the opportunity to bail out before trying to take the lock, which should reduce the overhead of this never-gonna-work case considerably while also solving the dropped lock problem.
--- fs/xfs/xfs_file.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
fs/xfs/xfs_file.c +3 -3
@@ -517,6 +517,9 @@ xfs_file_dio_aio_write( }if (iocb->ki_flags &IOCB_NOWAIT ) { +/* unaligned dio always waits, bail */ +if (unaligned_io) +return -EAGAIN ;if (!xfs_ilock_nowait (ip, iolock))return -EAGAIN ; }else {
@@ -536,9 +539,6 @@ xfs_file_dio_aio_write(* xfs_file_aio_write_checks() for other reasons. */ if (unaligned_io) { -/* unaligned dio always waits, bail */ -if (iocb->ki_flags &IOCB_NOWAIT ) -return -EAGAIN ;inode_dio_wait (inode); }else if (iolock ==XFS_IOLOCK_EXCL ) {xfs_ilock_demote (ip,XFS_IOLOCK_EXCL );
Signature · 1 line
2.20.1
Greg Kroah-Hartman
maintainerPATCH 346/371 gpu: ipu-v3: ipu-ic: Fix saturation bit offset in TPMEM
In reply to Greg Kroah-HartmanFrom: Steve Longerbeam <[email protected]>
commit 3d1f62c686acdedf5ed9642b763f3808d6a47d1e upstream.
The saturation bit was being set at bit 9 in the second 32-bit word of the TPMEM CSC. This isn't correct, the saturation bit is bit 42, which is bit 10 of the second word.
--- drivers/gpu/ipu-v3/ipu-ic.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/gpu/ipu-v3/ipu-ic.c +1 -1
@@ -257,7 +257,7 @@ static int init_csc(struct ipu_ic *ic,writel (param, base++); param = ((a[0 ] &0x1fe0 ) >>5 ) | (params->scale <<8 ) | - (params->sat <<9 ); + (params->sat <<10 );writel (param, base++); param = ((a[1] & 0x1f) << 27) | ((c[0][1] & 0x1ff) << 18) |
Greg Kroah-Hartman
maintainerPATCH 347/371 parisc: Ensure userspace privilege for ptraced processes in regset functions
In reply to Greg Kroah-HartmanFrom: Helge Deller <[email protected]>
commit 34c32fc603311a72cb558e5e337555434f64c27b upstream.
On parisc the privilege level of a process is stored in the lowest two bits of the instruction pointers (IAOQ0 and IAOQ1). On Linux we use privilege level 0 for the kernel and privilege level 3 for user-space. So userspace should not be allowed to modify IAOQ0 or IAOQ1 of a ptraced process to change it's privilege level to e.g. 0 to try to gain kernel privileges.
This patch prevents such modifications in the regset support functions by always setting the two lowest bits to one (which relates to privilege level 3 for user-space) if IAOQ0 or IAOQ1 are modified via ptrace regset calls.
--- arch/parisc/kernel/ptrace.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
arch/parisc/kernel/ptrace.c +2 -1
@@ -496,7 +496,8 @@ static void set_reg(struct pt_regs *regsreturn ;case RI (iaoq[0 ]):case RI (iaoq[1 ]): - regs->iaoq[num -RI (iaoq[0 ])] = val; +/* set 2 lowest bits to ensure userspace privilege: */ + regs->iaoq[num -RI (iaoq[0 ])] = val |3 ;return ;case RI (sar): regs->sar = val;return ;
Greg Kroah-Hartman
maintainerPATCH 348/371 parisc: Fix kernel panic due invalid values in IAOQ0 or IAOQ1
In reply to Greg Kroah-HartmanFrom: Helge Deller <[email protected]>
commit 10835c854685393a921b68f529bf740fa7c9984d upstream.
On parisc the privilege level of a process is stored in the lowest two bits of the instruction pointers (IAOQ0 and IAOQ1). On Linux we use privilege level 0 for the kernel and privilege level 3 for user-space. So userspace should not be allowed to modify IAOQ0 or IAOQ1 of a ptraced process to change it's privilege level to e.g. 0 to try to gain kernel privileges.
This patch prevents such modifications by always setting the two lowest bits to one (which relates to privilege level 3 for user-space) if IAOQ0 or IAOQ1 are modified via ptrace calls in the native and compat ptrace paths.
--- arch/parisc/kernel/ptrace.c | 28 ++++++++++++++++++---------- 1 file changed, 18 insertions(+), 10 deletions(-)
arch/parisc/kernel/ptrace.c +18 -10
@@ -167,6 +167,9 @@ long arch_ptrace(struct task_struct *chiif ((addr & (sizeof (unsigned long )-1 )) || addr >=sizeof (struct pt_regs ))break ; +if (addr ==PT_IAOQ0 || addr ==PT_IAOQ1 ) { + data |=3 ;/* ensure userspace privilege */ + } if ((addr >= PT_GR1 && addr <= PT_GR31) || addr == PT_IAOQ0 || addr == PT_IAOQ1 || (addr >= PT_FR0 && addr <= PT_FR31 + 4) ||
@@ -228,16 +231,18 @@ long arch_ptrace(struct task_struct *chistatic compat_ulong_t translate_usr_offset (compat_ulong_t offset) { -if (offset <0 ) -return sizeof (struct pt_regs ); -else if (offset <=32 *4 )/* gr[0..31] */ -return offset *2 +4 ; -else if (offset <=32 *4 +32 *8 )/* gr[0..31] + fr[0..31] */ -return offset +32 *4 ; -else if (offset <sizeof (struct pt_regs )/2 +32 *4 ) -return offset *2 +4 -32 *8 ; +compat_ulong_t pos; + +if (offset <32 *4 )/* gr[0..31] */ + pos = offset *2 +4 ; +else if (offset <32 *4 +32 *8 )/* fr[0] ... fr[31] */ + pos = (offset -32 *4 ) +PT_FR0 ; +else if (offset <sizeof (struct pt_regs )/2 +32 *4 )/* sr[0] ... ipsw */ + pos = (offset -32 *4 -32 *8 ) *2 +PT_SR0 +4 ;else -return sizeof (struct pt_regs ); + pos =sizeof (struct pt_regs ); + +return pos; } long compat_arch_ptrace(struct task_struct *child, compat_long_t request,
@@ -281,9 +286,12 @@ long compat_arch_ptrace(struct task_stru addr =translate_usr_offset (addr);if (addr >=sizeof (struct pt_regs ))break ; +if (addr ==PT_IAOQ0 +4 || addr ==PT_IAOQ1 +4 ) { + data |=3 ;/* ensure userspace privilege */ + }if (addr >=PT_FR0 && addr <=PT_FR31 +4 ) {/* Special case, fp regs are 64 bits anyway */ - *(__u64 *) ((char *)task_regs (child) + addr) = data; + *(__u32 *) ((char *)task_regs (child) + addr) = data; ret =0 ; } else if ((addr >= PT_GR1+4 && addr <= PT_GR31+4) ||
Greg Kroah-Hartman
maintainerPATCH 349/371 powerpc/32s: fix suspend/resume when IBATs 4-7 are used
In reply to Greg Kroah-HartmanFrom: Christophe Leroy <[email protected]>
commit 6ecb78ef56e08d2119d337ae23cb951a640dc52d upstream.
Previously, only IBAT1 and IBAT2 were used to map kernel linear mem. Since commit 63b2bc619565 ("powerpc/mm/32s: Use BATs for STRICT_KERNEL_RWX"), we may have all 8 BATs used for mapping kernel text. But the suspend/restore functions only save/restore BATs 0 to 3, and clears BATs 4 to 7.
Make suspend and restore functions respectively save and reload the 8 BATs on CPUs having MMU_FTR_USE_HIGH_BATS feature.
--- arch/powerpc/kernel/swsusp_32.S | 73 ++++++++++++++++++++++++++++---- arch/powerpc/platforms/powermac/sleep.S | 68 +++++++++++++++++++++++++++-- 2 files changed, 128 insertions(+), 13 deletions(-)
arch/powerpc/kernel/swsusp_32.S +65 -8
@@ -25,11 +25,19 @@ #define SL_IBAT2 0x48 #define SL_DBAT3 0x50 #define SL_IBAT3 0x58 -#define SL_TB 0x60 -#define SL_R2 0x68 -#define SL_CR 0x6c -#define SL_LR 0x70 -#define SL_R12 0x74 /* r12 to r31 */ +#define SL_DBAT4 0x60 +#define SL_IBAT4 0x68 +#define SL_DBAT5 0x70 +#define SL_IBAT5 0x78 +#define SL_DBAT6 0x80 +#define SL_IBAT6 0x88 +#define SL_DBAT7 0x90 +#define SL_IBAT7 0x98 +#define SL_TB 0xa0 +#define SL_R2 0xa8 +#define SL_CR 0xac +#define SL_LR 0xb0 +#define SL_R12 0xb4 /* r12 to r31 */ #define SL_SIZE (SL_R12 + 80) .section .data
@@ -114,6 +122,41 @@ _GLOBAL(swsusp_arch_suspend) mfibatl r4,3 stw r4,SL_IBAT3+4(r11) +BEGIN_MMU_FTR_SECTION + mfspr r4,SPRN_DBAT4U + stw r4,SL_DBAT4(r11) + mfspr r4,SPRN_DBAT4L + stw r4,SL_DBAT4+4(r11) + mfspr r4,SPRN_DBAT5U + stw r4,SL_DBAT5(r11) + mfspr r4,SPRN_DBAT5L + stw r4,SL_DBAT5+4(r11) + mfspr r4,SPRN_DBAT6U + stw r4,SL_DBAT6(r11) + mfspr r4,SPRN_DBAT6L + stw r4,SL_DBAT6+4(r11) + mfspr r4,SPRN_DBAT7U + stw r4,SL_DBAT7(r11) + mfspr r4,SPRN_DBAT7L + stw r4,SL_DBAT7+4(r11) + mfspr r4,SPRN_IBAT4U + stw r4,SL_IBAT4(r11) + mfspr r4,SPRN_IBAT4L + stw r4,SL_IBAT4+4(r11) + mfspr r4,SPRN_IBAT5U + stw r4,SL_IBAT5(r11) + mfspr r4,SPRN_IBAT5L + stw r4,SL_IBAT5+4(r11) + mfspr r4,SPRN_IBAT6U + stw r4,SL_IBAT6(r11) + mfspr r4,SPRN_IBAT6L + stw r4,SL_IBAT6+4(r11) + mfspr r4,SPRN_IBAT7U + stw r4,SL_IBAT7(r11) + mfspr r4,SPRN_IBAT7L + stw r4,SL_IBAT7+4(r11) +END_MMU_FTR_SECTION_IFSET(MMU_FTR_USE_HIGH_BATS) + #if 0 /* Backup various CPU config stuffs */ bl __save_cpu_setup
@@ -279,27 +322,41 @@ END_FTR_SECTION_IFSET(CPU_FTR_ALTIVEC) mtibatu 3,r4 lwz r4,SL_IBAT3+4(r11) mtibatl 3,r4 -#endif - BEGIN_MMU_FTR_SECTION - li r4,0 + lwz r4,SL_DBAT4(r11) mtspr SPRN_DBAT4U,r4 + lwz r4,SL_DBAT4+4(r11) mtspr SPRN_DBAT4L,r4 + lwz r4,SL_DBAT5(r11) mtspr SPRN_DBAT5U,r4 + lwz r4,SL_DBAT5+4(r11) mtspr SPRN_DBAT5L,r4 + lwz r4,SL_DBAT6(r11) mtspr SPRN_DBAT6U,r4 + lwz r4,SL_DBAT6+4(r11) mtspr SPRN_DBAT6L,r4 + lwz r4,SL_DBAT7(r11) mtspr SPRN_DBAT7U,r4 + lwz r4,SL_DBAT7+4(r11) mtspr SPRN_DBAT7L,r4 + lwz r4,SL_IBAT4(r11) mtspr SPRN_IBAT4U,r4 + lwz r4,SL_IBAT4+4(r11) mtspr SPRN_IBAT4L,r4 + lwz r4,SL_IBAT5(r11) mtspr SPRN_IBAT5U,r4 + lwz r4,SL_IBAT5+4(r11) mtspr SPRN_IBAT5L,r4 + lwz r4,SL_IBAT6(r11) mtspr SPRN_IBAT6U,r4 + lwz r4,SL_IBAT6+4(r11) mtspr SPRN_IBAT6L,r4 + lwz r4,SL_IBAT7(r11) mtspr SPRN_IBAT7U,r4 + lwz r4,SL_IBAT7+4(r11) mtspr SPRN_IBAT7L,r4 END_MMU_FTR_SECTION_IFSET(MMU_FTR_USE_HIGH_BATS) +#endif /* Flush all TLBs */ lis r4,0x1000
arch/powerpc/platforms/powermac/sleep.S +63 -5
101 lines not on this page · raw message
Greg Kroah-Hartman
maintainerPATCH 350/371 powerpc/mm/32s: fix condition that is always true
In reply to Greg Kroah-HartmanFrom: Andreas Schwab <[email protected]>
commit 46c2478af610efb3212b8b08f74389d69899ef70 upstream.
Move a misplaced paren that makes the condition always true.
--- arch/powerpc/mm/pgtable_32.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
arch/powerpc/mm/pgtable_32.c +1 -1
@@ -353,7 +353,7 @@ void mark_initmem_nx(void)unsigned long numpages =PFN_UP ((unsigned long )_einittext) -PFN_DOWN ((unsigned long )_sinittext); -if (v_block_mapped ((unsigned long )_stext) +1 ) +if (v_block_mapped ((unsigned long )_stext +1 ))mmu_mark_initmem_nx ();else change_page_attr (page, numpages,PAGE_KERNEL );
Greg Kroah-Hartman
maintainerPATCH 351/371 powerpc/watchpoint: Restore NV GPRs while returning from exception
In reply to Greg Kroah-HartmanFrom: Ravi Bangoria <[email protected]>
commit f474c28fbcbe42faca4eb415172c07d76adcb819 upstream.
powerpc hardware triggers watchpoint before executing the instruction. To make trigger-after-execute behavior, kernel emulates the instruction. If the instruction is 'load something into non-volatile register', exception handler should restore emulated register state while returning back, otherwise there will be register state corruption. eg, adding a watchpoint on a list can corrput the list:
# cat /proc/kallsyms | grep kthread_create_list c00000000121c8b8 d kthread_create_list
Add watchpoint on kthread_create_list->prev:
# perf record -e mem:0xc00000000121c8c0
Run some workload such that new kthread gets invoked. eg, I just logged out from console:
list_add corruption. next->prev should be prev (c000000001214e00), \ but was c00000000121c8b8. (next=c00000000121c8b8). WARNING: CPU: 59 PID: 309 at lib/list_debug.c:25 __list_add_valid+0xb4/0xc0 CPU: 59 PID: 309 Comm: kworker/59:0 Kdump: loaded Not tainted 5.1.0-rc7+ #69 ... NIP __list_add_valid+0xb4/0xc0 LR __list_add_valid+0xb0/0xc0 Call Trace: __list_add_valid+0xb0/0xc0 (unreliable) __kthread_create_on_node+0xe0/0x260 kthread_create_on_node+0x34/0x50 create_worker+0xe8/0x260 worker_thread+0x444/0x560 kthread+0x160/0x1a0 ret_from_kernel_thread+0x5c/0x70
List corruption happened because it uses 'load into non-volatile register' instruction:
Snippet from __kthread_create_on_node:
c000000000136be8: addis r29,r2,-19
c000000000136bec: ld r29,31424(r29)
if (!__list_add_valid(new, prev, next))
c000000000136bf0: mr r3,r30
c000000000136bf4: mr r5,r28
c000000000136bf8: mr r4,r29
c000000000136bfc: bl c00000000059a2f8 <__list_add_valid+0x8>Register state from WARN_ON():
GPR00: c00000000059a3a0 c000007ff23afb50 c000000001344e00 0000000000000075
GPR04: 0000000000000000 0000000000000000 0000001852af8bc1 0000000000000000
GPR08: 0000000000000001 0000000000000007 0000000000000006 00000000000004aa
GPR12: 0000000000000000 c000007ffffeb080 c000000000137038 c000005ff62aaa00
GPR16: 0000000000000000 0000000000000000 c000007fffbe7600 c000007fffbe7370
GPR20: c000007fffbe7320 c000007fffbe7300 c000000001373a00 0000000000000000
GPR24: fffffffffffffef7 c00000000012e320 c000007ff23afcb0 c000000000cb8628
GPR28: c00000000121c8b8 c000000001214e00 c000007fef5b17e8 c000007fef5b17c0
Watchpoint hit at 0xc000000000136bec.
addis r29,r2,-19
=> r29 = 0xc000000001344e00 + (-19 << 16)
=> r29 = 0xc000000001214e00
ld r29,31424(r29)
=> r29 = *(0xc000000001214e00 + 31424)
=> r29 = *(0xc00000000121c8c0)
0xc00000000121c8c0 is where we placed a watchpoint and thus this instruction was emulated by emulate_step. But because handle_dabr_fault did not restore emulated register state, r29 still contains stale value in above register state.
--- arch/powerpc/kernel/exceptions-64s.S | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-)
arch/powerpc/kernel/exceptions-64s.S +7 -2
@@ -1738,7 +1738,7 @@ handle_page_fault: addi r3,r1,STACK_FRAME_OVERHEAD bl do_page_fault cmpdi r3,0 - beq+ 12f + beq+ ret_from_except_lite bl save_nvgprs mr r5,r3 addi r3,r1,STACK_FRAME_OVERHEAD
@@ -1753,7 +1753,12 @@ handle_dabr_fault: ld r5,_DSISR(r1) addi r3,r1,STACK_FRAME_OVERHEAD bl do_break -12: b ret_from_except_lite + /* + * do_break() may have changed the NV GPRS while handling a breakpoint. + * If so, we need to restore them with their updated values. Don't use + * ret_from_except_lite here. + */ + b ret_from_except #ifdef CONFIG_PPC_BOOK3S_64
Greg Kroah-Hartman
maintainerPATCH 352/371 powerpc/powernv/npu: Fix reference leak
In reply to Greg Kroah-HartmanFrom: Greg Kurz <[email protected]>
commit 02c5f5394918b9b47ff4357b1b18335768cd867d upstream.
Since 902bdc57451c, get_pci_dev() calls pci_get_domain_bus_and_slot(). This has the effect of incrementing the reference count of the PCI device, as explained in drivers/pci/search.c:
* Given a PCI domain, bus, and slot/function number, the desired PCI
* device is located in the list of PCI devices. If the device is
* found, its reference count is increased and this function returns a
* pointer to its data structure. The caller must decrement the
* reference count by calling pci_dev_put(). If no device is found,
* %NULL is returned.
Nothing was done to call pci_dev_put() and the reference count of GPU and NPU PCI devices rockets up.
A natural way to fix this would be to teach the callers about the change, so that they call pci_dev_put() when done with the pointer. This turns out to be quite intrusive, as it affects many paths in npu-dma.c, pci-ioda.c and vfio_pci_nvlink2.c. Also, the issue appeared in 4.16 and some affected code got moved around since then: it would be problematic to backport the fix to stable releases.
All that code never cared for reference counting anyway. Call pci_dev_put() from get_pci_dev() to revert to the previous behavior.
--- arch/powerpc/platforms/powernv/npu-dma.c | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-)
arch/powerpc/platforms/powernv/npu-dma.c +14 -1
@@ -31,9 +31,22 @@ static DEFINE_SPINLOCK(npu_context_lock)static struct pci_dev *get_pci_dev (struct device_node *dn) {struct pci_dn *pdn =PCI_DN (dn); +struct pci_dev *pdev; -return pci_get_domain_bus_and_slot (pci_domain_nr (pdn->phb->bus), + pdev =pci_get_domain_bus_and_slot (pci_domain_nr (pdn->phb->bus), pdn->busno, pdn->devfn); + +/* +* pci_get_domain_bus_and_slot() increased the reference count of +* the PCI device, but callers don't need that actually as the PE +* already holds a reference to the device. Since callers aren't +* aware of the reference count change, call pci_dev_put() now to +* avoid leaks. +*/ +if (pdev) +pci_dev_put (pdev); + +return pdev; }/* Given a NPU device get the associated PCI device. */
Greg Kroah-Hartman
maintainerPATCH 353/371 powerpc/powernv: Fix stale iommu table base after VFIO
In reply to Greg Kroah-HartmanFrom: Alexey Kardashevskiy <[email protected]>
commit 5636427d087a55842c1a199dfb839e6545d30e5d upstream.
The powernv platform uses @dma_iommu_ops for non-bypass DMA. These ops need an iommu_table pointer which is stored in dev->archdata.iommu_table_base. It is initialized during pcibios_setup_device() which handles boot time devices. However when a device is taken from the system in order to pass it through, the default IOMMU table is destroyed but the pointer in a device is not updated; also when a device is returned back to the system, a new table pointer is not stored in dev->archdata.iommu_table_base either. So when a just returned device tries using IOMMU, it crashes on accessing stale iommu_table or its members.
This calls set_iommu_table_base() when the default window is created. Note it used to be there before but was wrongly removed (see "fixes"). It did not appear before as these days most devices simply use bypass.
This adds set_iommu_table_base(NULL) when a device is taken from the system to make it clear that IOMMU DMA cannot be used past that point.
--- arch/powerpc/platforms/powernv/pci-ioda.c | 10 ++++++++++ 1 file changed, 10 insertions(+)
arch/powerpc/platforms/powernv/pci-ioda.c +10 -0
@@ -2459,6 +2459,14 @@ static long pnv_pci_ioda2_setup_default_if (!pnv_iommu_bypass_disabled)pnv_pci_ioda2_set_bypass (pe, true); +/* +* Set table base for the case of IOMMU DMA use. Usually this is done +* from dma_dev_setup() which is not called when a device is returned +* from VFIO so do it here. +*/ +if (pe->pdev) +set_iommu_table_base (&pe->pdev->dev, tbl); +return 0 ; }
@@ -2546,6 +2554,8 @@ static void pnv_ioda2_take_ownership(strpnv_pci_ioda2_unset_window (&pe->table_group,0 );if (pe->pbus)pnv_ioda_setup_bus_dma (pe, pe->pbus); +else if (pe->pdev) +set_iommu_table_base (&pe->pdev->dev,NULL );iommu_tce_table_put (tbl); }
Greg Kroah-Hartman
maintainerPATCH 354/371 powerpc/pseries: Fix xive=off command line
In reply to Greg Kroah-HartmanFrom: Greg Kurz <[email protected]>
commit a3bf9fbdad600b1e4335dd90979f8d6072e4f602 upstream.
On POWER9, if the hypervisor supports XIVE exploitation mode, the guest OS will unconditionally requests for the XIVE interrupt mode even if XIVE was deactivated with the kernel command line xive=off. Later on, when the spapr XIVE init code handles xive=off, it disables XIVE and tries to fall back on the legacy mode XICS.
This discrepency causes a kernel panic because the hypervisor is configured to provide the XIVE interrupt mode to the guest :
kernel BUG at arch/powerpc/sysdev/xics/xics-common.c:135!
...
NIP xics_smp_probe+0x38/0x98
LR xics_smp_probe+0x2c/0x98
Call Trace:
xics_smp_probe+0x2c/0x98 (unreliable)
pSeries_smp_probe+0x40/0xa0
smp_prepare_cpus+0x62c/0x6ec
kernel_init_freeable+0x148/0x448
kernel_init+0x2c/0x148
ret_from_kernel_thread+0x5c/0x68Look for xive=off during prom_init and don't ask for XIVE in this case. One exception though: if the host only supports XIVE, we still want to boot so we ignore xive=off.
Similarly, have the spapr XIVE init code to looking at the interrupt mode negotiated during CAS, and ignore xive=off if the hypervisor only supports XIVE.
--- arch/powerpc/kernel/prom_init.c | 16 +++++++++++- arch/powerpc/sysdev/xive/spapr.c | 52 ++++++++++++++++++++++++++++++++++++++- 2 files changed, 66 insertions(+), 2 deletions(-)
arch/powerpc/kernel/prom_init.c +15 -1
@@ -174,6 +174,7 @@ static unsigned long __prombss prom_tce_#ifdef CONFIG_PPC_PSERIES static bool __prombss prom_radix_disable; +static bool __prombss prom_xive_disable;#endif struct platform_support {
@@ -684,6 +685,12 @@ static void __init early_cmdline_parse(v }if (prom_radix_disable)prom_debug ("Radix disabled from cmdline\n" ); + + opt =prom_strstr (prom_cmd_line,"xive=off" ); +if (opt) { + prom_xive_disable = true; +prom_debug ("XIVE disabled from cmdline\n" ); + }#endif /* CONFIG_PPC_PSERIES */ }
@@ -1092,10 +1099,17 @@ static void __init prom_parse_xive_modelswitch (val) {case OV5_FEAT (OV5_XIVE_EITHER ):/* Either Available */ prom_debug ("XIVE - either mode supported\n" ); - support->xive = true; + support->xive = !prom_xive_disable;break ;case OV5_FEAT (OV5_XIVE_EXPLOIT ):/* Only Exploitation mode */ prom_debug ("XIVE - exploitation mode supported\n" ); +if (prom_xive_disable) { +/* +* If we __have__ to do XIVE, we're better off ignoring +* the command line rather than not booting. +*/ +prom_printf ("WARNING: Ignoring cmdline option xive=off\n" ); + } support->xive = true;break ;case OV5_FEAT (OV5_XIVE_LEGACY ):/* Only Legacy mode */
arch/powerpc/sysdev/xive/spapr.c +51 -1
70 lines not on this page · raw message
Greg Kroah-Hartman
maintainerPATCH 355/371 powerpc/pseries: Fix oops in hotplug memory notifier
In reply to Greg Kroah-HartmanFrom: Nathan Lynch <[email protected]>
commit 0aa82c482ab2ece530a6f44897b63b274bb43c8e upstream.
During post-migration device tree updates, we can oops in pseries_update_drconf_memory() if the source device tree has an ibm,dynamic-memory-v2 property and the destination has a ibm,dynamic_memory (v1) property. The notifier processes an "update" for the ibm,dynamic-memory property but it's really an add in this scenario. So make sure the old property object is there before dereferencing it.
--- arch/powerpc/platforms/pseries/hotplug-memory.c | 3 +++ 1 file changed, 3 insertions(+)
arch/powerpc/platforms/pseries/hotplug-memory.c +3 -0
@@ -980,6 +980,9 @@ static int pseries_update_drconf_memory(if (!memblock_size)return -EINVAL ; +if (!pr->old_prop) +return 0 ; + p = (__be32 *) pr->old_prop->value;if (!p)return -EINVAL ;
Greg Kroah-Hartman
maintainerPATCH 356/371 mmc: sdhci-msm: fix mutex while in spinlock
In reply to Greg Kroah-HartmanFrom: Jorge Ramirez-Ortiz <[email protected]>
commit 5e6b6651d22de109ebf48ca00d0373bc2c0cc080 upstream.
mutexes can sleep and therefore should not be taken while holding a spinlock. move clk_get_rate (can sleep) outside the spinlock protected region.
--- drivers/mmc/host/sdhci-msm.c | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-)
drivers/mmc/host/sdhci-msm.c +6 -3
@@ -584,11 +584,14 @@ static int msm_init_cm_dll(struct sdhci_struct sdhci_pltfm_host *pltfm_host =sdhci_priv (host);struct sdhci_msm_host *msm_host =sdhci_pltfm_priv (pltfm_host);int wait_cnt =50 ; -unsigned long flags; +unsigned long flags, xo_clk =0 ;u32 config;const struct sdhci_msm_offset *msm_offset = msm_host->offset; +if (msm_host->use_14lpp_dll_reset && !IS_ERR_OR_NULL (msm_host->xo_clk)) + xo_clk =clk_get_rate (msm_host->xo_clk); +spin_lock_irqsave (&host->lock, flags);/*
@@ -636,10 +639,10 @@ static int msm_init_cm_dll(struct sdhci_ config &=CORE_FLL_CYCLE_CNT ;if (config) mclk_freq =DIV_ROUND_CLOSEST_ULL ((host->clock *8 ), -clk_get_rate (msm_host->xo_clk)); + xo_clk);else mclk_freq =DIV_ROUND_CLOSEST_ULL ((host->clock *4 ), -clk_get_rate (msm_host->xo_clk)); + xo_clk); config =readl_relaxed (host->ioaddr + msm_offset->core_dll_config_2);
Greg Kroah-Hartman
maintainerPATCH 357/371 eCryptfs: fix a couple type promotion bugs
In reply to Greg Kroah-HartmanFrom: Dan Carpenter <[email protected]>
commit 0bdf8a8245fdea6f075a5fede833a5fcf1b3466c upstream.
ECRYPTFS_SIZE_AND_MARKER_BYTES is type size_t, so if "rc" is negative that gets type promoted to a high positive value and treated as success.
--- fs/ecryptfs/crypto.c | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-)
fs/ecryptfs/crypto.c +8 -4
@@ -1019,8 +1019,10 @@ int ecryptfs_read_and_validate_header_re rc =ecryptfs_read_lower (file_size,0 ,ECRYPTFS_SIZE_AND_MARKER_BYTES , inode); -if (rc <ECRYPTFS_SIZE_AND_MARKER_BYTES ) -return rc >=0 ? -EINVAL : rc; +if (rc <0 ) +return rc; +else if (rc <ECRYPTFS_SIZE_AND_MARKER_BYTES ) +return -EINVAL ; rc =ecryptfs_validate_marker (marker);if (!rc)ecryptfs_i_size_init (file_size, inode);
@@ -1382,8 +1384,10 @@ int ecryptfs_read_and_validate_xattr_regecryptfs_inode_to_lower (inode),ECRYPTFS_XATTR_NAME , file_size, ECRYPTFS_SIZE_AND_MARKER_BYTES); -if (rc <ECRYPTFS_SIZE_AND_MARKER_BYTES ) -return rc >=0 ? -EINVAL : rc; +if (rc <0 ) +return rc; +else if (rc <ECRYPTFS_SIZE_AND_MARKER_BYTES ) +return -EINVAL ; rc =ecryptfs_validate_marker (marker);if (!rc)ecryptfs_i_size_init (file_size, inode);
Greg Kroah-Hartman
maintainerPATCH 358/371 mtd: rawnand: mtk: Correct low level time calculation of r/w cycle
In reply to Greg Kroah-HartmanFrom: Xiaolei Li <[email protected]>
commit e1884ffddacc0424d7e785e6f8087bd12f7196db upstream.
At present, the flow of calculating AC timing of read/write cycle in SDR mode is that:
At first, calculate high hold time which is valid for both read and write cycle using the max value between tREH_min and tWH_min. Secondly, calculate WE# pulse width using tWP_min.
Thridly, calculate RE# pulse width using the bigger one between tREA_max and tRP_min.
But NAND SPEC shows that Controller should also meet write/read cycle time. That is write cycle time should be more than tWC_min and read cycle should be more than tRC_min. Obviously, we do not achieve that now.
This patch corrects the low level time calculation to meet minimum read/write cycle time required. After getting the high hold time, WE# low level time will be promised to meet tWP_min and tWC_min requirement, and RE# low level time will be promised to meet tREA_max, tRP_min and tRC_min requirement.
--- drivers/mtd/nand/raw/mtk_nand.c | 24 +++++++++++++++++++++--- 1 file changed, 21 insertions(+), 3 deletions(-)
drivers/mtd/nand/raw/mtk_nand.c +21 -3
@@ -508,7 +508,8 @@ static int mtk_nfc_setup_data_interface( {struct mtk_nfc *nfc =nand_get_controller_data (chip);const struct nand_sdr_timings *timings; -u32 rate, tpoecs, tprecs, tc2r, tw2r, twh, twst, trlt; +u32 rate, tpoecs, tprecs, tc2r, tw2r, twh, twst =0 , trlt =0 ; +u32 thold; timings =nand_get_sdr_timings (conf);if (IS_ERR (timings))
@@ -544,11 +545,28 @@ static int mtk_nfc_setup_data_interface( twh =DIV_ROUND_UP (twh * rate,1000000 ) -1 ; twh &=0xf ; - twst = timings->tWP_min /1000 ; +/* Calculate real WE#/RE# hold time in nanosecond */ + thold = (twh +1 ) *1000000 / rate; +/* nanosecond to picosecond */ + thold *=1000 ; + +/* +* WE# low level time should be expaned to meet WE# pulse time +* and WE# cycle time at the same time. +*/ +if (thold < timings->tWC_min) + twst = timings->tWC_min - thold; + twst =max (timings->tWP_min, twst) /1000 ; twst =DIV_ROUND_UP (twst * rate,1000000 ) -1 ; twst &=0xf ; - trlt =max (timings->tREA_max, timings->tRP_min) /1000 ; +/* +* RE# low level time should be expaned to meet RE# pulse time, +* RE# access time and RE# cycle time at the same time. +*/ +if (thold < timings->tRC_min) + trlt = timings->tRC_min - thold; + trlt =max3 (trlt, timings->tREA_max, timings->tRP_min) /1000 ; trlt =DIV_ROUND_UP (trlt * rate,1000000 ) -1 ; trlt &=0xf ;
Greg Kroah-Hartman
maintainerPATCH 359/371 mtd: spinand: read returns badly if the last page has bitflips
In reply to Greg Kroah-HartmanFrom: liaoweixiong <[email protected]>
commit b83408b580eccf8d2797cd6cb9ae42c2a28656a7 upstream.
In case of the last page containing bitflips (ret > 0), spinand_mtd_read() will return that number of bitflips for the last page while it should instead return max_bitflips like it does when the last page read returns with 0.
--- drivers/mtd/nand/spi/core.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/mtd/nand/spi/core.c +1 -1
@@ -572,12 +572,12 @@ static int spinand_mtd_read(struct mtd_iif (ret == -EBADMSG ) { ecc_failed = true; mtd->ecc_stats.failed++; - ret =0 ; }else { mtd->ecc_stats.corrected += ret; max_bitflips = max_t(unsigned int, max_bitflips, ret); } + ret =0 ; ops->retlen += iter.req.datalen; ops->oobretlen += iter.req.ooblen; }
Greg Kroah-Hartman
maintainerPATCH 360/371 intel_th: msu: Fix single mode with disabled IOMMU
In reply to Greg Kroah-HartmanFrom: Alexander Shishkin <[email protected]>
commit 918b8646497b5dba6ae82d4a7325f01b258972b9 upstream.
Commit 4e0eaf239fb3 ("intel_th: msu: Fix single mode with IOMMU") switched the single mode code to use dma mapping pages obtained from the page allocator, but with IOMMU disabled, that may lead to using SWIOTLB bounce buffers and without additional sync'ing, produces empty trace buffers.
Fix this by using a DMA32 GFP flag to the page allocation in single mode, as the device supports full 32-bit DMA addressing.
--- drivers/hwtracing/intel_th/msu.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/hwtracing/intel_th/msu.c +1 -1
@@ -632,7 +632,7 @@ static int msc_buffer_contig_alloc(struc goto err_out; ret = -ENOMEM ; - page =alloc_pages (GFP_KERNEL | __GFP_ZERO, order); + page =alloc_pages (GFP_KERNEL | __GFP_ZERO |GFP_DMA32 , order);if (!page) goto err_free_sgt;
Greg Kroah-Hartman
maintainerPATCH 361/371 Bluetooth: Add SMP workaround Microsoft Surface Precision Mouse bug
In reply to Greg Kroah-HartmanFrom: Szymon Janc <[email protected]>
commit 1d87b88ba26eabd4745e158ecfd87c93a9b51dc2 upstream.
Microsoft Surface Precision Mouse provides bogus identity address when pairing. It connects with Static Random address but provides Public Address in SMP Identity Address Information PDU. Address has same value but type is different. Workaround this by dropping IRK if ID address discrepancy is detected.
Quoted 1 line
HCI Event: LE Meta Event (
0x3e) plen 19
LE Connection Complete (0x01)
Status: Success (0x00)
Handle: 75
Role: Master (0x00)
Peer address type: Random (0x01)
Peer address: E0:52:33:93:3B:21 (Static)
Connection interval: 50.00 msec (0x0028)
Connection latency: 0 (0x0000)
Supervision timeout: 420 msec (0x002a)
Master clock accuracy: 0x00....
Quoted 1 line
ACL Data RX: Handle 75 flags
0x02dlen 12
SMP: Identity Address Information (0x09) len 7
Address type: Public (0x00)
Address: E0:52:33:93:3B:21Bugzilla: https://bugzilla.kernel.org/show_bug.cgi?id=199461
--- net/bluetooth/smp.c | 13 +++++++++++++ 1 file changed, 13 insertions(+)
net/bluetooth/smp.c +13 -0
@@ -2580,6 +2580,19 @@ static int smp_cmd_ident_addr_info(struc goto distribute; } +/* Drop IRK if peer is using identity address during pairing but is +* providing different address as identity information. +* +* Microsoft Surface Precision Mouse is known to have this bug. +*/ +if (hci_is_identity_address (&hcon->dst, hcon->dst_type) && + (bacmp (&info->bdaddr, &hcon->dst) || + info->addr_type != hcon->dst_type)) { +bt_dev_err (hcon->hdev, +"ignoring IRK with invalid identity address" ); + goto distribute; + } +bacpy (&smp->id_addr, &info->bdaddr); smp->id_addr_type = info->addr_type;
Greg Kroah-Hartman
maintainerPATCH 362/371 dax: Fix missed wakeup with PMD faults
In reply to Greg Kroah-HartmanFrom: Matthew Wilcox (Oracle) <[email protected]>
commit 23c84eb7837514e16d79ed6d849b13745e0ce688 upstream.
RocksDB can hang indefinitely when using a DAX file. This is due to a bug in the XArray conversion when handling a PMD fault and finding a PTE entry. We use the wrong index in the hash and end up waiting on the wrong waitqueue.
There's actually no need to wait; if we find a PTE entry while looking for a PMD entry, we can return immediately as we know we should fall back to a PTE fault (which may not conflict with the lock held).
We reuse the XA_RETRY_ENTRY to signal a conflicting entry was found. This value can never be found in an XArray while holding its lock, so it does not create an ambiguity.
--- fs/dax.c | 53 +++++++++++++++++++++++++++++++++-------------------- 1 file changed, 33 insertions(+), 20 deletions(-)
fs/dax.c +33 -20
@@ -132,6 +132,15 @@ static int dax_is_empty_entry(void *entr }/* +* true if the entry that was found is of a smaller order than the entry +* we were looking for +*/ +static bool dax_is_conflict (void *entry) +{ +return entry ==XA_RETRY_ENTRY ; +} + +/* * DAX page cache entry locking */ struct exceptional_entry_key {
@@ -203,11 +212,13 @@ static void dax_wake_entry(struct xa_sta* Look up entry in page cache, wait for it to become unlocked if it * is a DAX entry and return it. The caller must subsequently call * put_unlocked_entry() if it did not lock the entry or dax_unlock_entry() -* if it did. +* if it did. The entry returned may have a larger order than @order. +* If @order is larger than the order of the entry found in i_pages, this +* function returns a dax_is_conflict entry. * * Must be called with the i_pages lock held. */ -static void *get_unlocked_entry (struct xa_state *xas) +static void *get_unlocked_entry (struct xa_state *xas,unsigned int order) {void *entry;struct wait_exceptional_entry_queue ewait;
@@ -218,6 +229,8 @@ static void *get_unlocked_entry(struct xfor (;;) { entry =xas_find_conflict (xas); +if (dax_entry_order (entry) < order) +return XA_RETRY_ENTRY ;if (!entry ||WARN_ON_ONCE (!xa_is_value (entry)) || !dax_is_locked (entry))return entry;
@@ -262,7 +275,7 @@ static void wait_entry_unlocked(struct xstatic void put_unlocked_entry (struct xa_state *xas,void *entry) {/* If we were the only waiter woken, wake the next one */ -if (entry) +if (entry &&dax_is_conflict (entry))dax_wake_entry (xas, entry, false); }
@@ -469,7 +482,7 @@ void dax_unlock_page(struct page *page,* overlap with xarray value entries. */ static void *grab_mapping_entry (struct xa_state *xas, -struct address_space *mapping,unsigned long size_flag) +struct address_space *mapping,unsigned int order) {unsigned long index = xas->xa_index;bool pmd_downgrade = false;/* splitting PMD entry into PTE entries? */
@@ -477,20 +490,17 @@ static void *grab_mapping_entry(struct x retry:xas_lock_irq (xas); - entry =get_unlocked_entry (xas); + entry =get_unlocked_entry (xas, order);if (entry) { +if (dax_is_conflict (entry)) + goto fallback;if (!xa_is_value (entry)) {xas_set_err (xas,EIO ); goto out_unlock; } -if (size_flag &DAX_PMD ) { -if (dax_is_pte_entry (entry)) { -put_unlocked_entry (xas, entry); - goto fallback; - } - }else {/* trying to grab a PTE entry */ +if (order ==0 ) {if (dax_is_pmd_entry (entry) && (dax_is_zero_entry (entry) ||dax_is_empty_entry (entry))) {
@@ -531,7 +541,11 @@ retry:if (entry) {dax_lock_entry (xas, entry); }else { - entry =dax_make_entry (pfn_to_pfn_t (0 ), size_flag |DAX_EMPTY ); +unsigned long flags =DAX_EMPTY ; + +if (order >0 ) + flags |=DAX_PMD ; + entry =dax_make_entry (pfn_to_pfn_t (0 ), flags);dax_lock_entry (xas, entry);if (xas_error (xas)) goto out_unlock;
@@ -602,7 +616,7 @@ struct page *dax_layout_busy_page(structif (WARN_ON_ONCE (!xa_is_value (entry)))continue ;if (unlikely (dax_is_locked (entry))) - entry =get_unlocked_entry (&xas); + entry =get_unlocked_entry (&xas,0 );if (entry) page =dax_busy_page (entry);put_unlocked_entry (&xas, entry);
@@ -629,7 +643,7 @@ static int __dax_invalidate_entry(structvoid *entry;xas_lock_irq (&xas); - entry =get_unlocked_entry (&xas); + entry =get_unlocked_entry (&xas,0 );if (!entry ||WARN_ON_ONCE (!xa_is_value (entry))) goto out; if (!trunc &&
@@ -856,7 +870,7 @@ static int dax_writeback_one(struct xa_sif (unlikely (dax_is_locked (entry))) {void *old_entry = entry; - entry =get_unlocked_entry (xas); + entry =get_unlocked_entry (xas,0 );/* Entry got punched out / reallocated? */ if (!entry ||WARN_ON_ONCE (!xa_is_value (entry)))
@@ -1517,7 +1531,7 @@ static vm_fault_t dax_iomap_pmd_fault(st* entry is already in the array, for instance), it will return * VM_FAULT_FALLBACK. */ - entry =grab_mapping_entry (&xas, mapping,DAX_PMD ); + entry =grab_mapping_entry (&xas, mapping,PMD_ORDER );if (xa_is_internal (entry)) { result =xa_to_internal (entry); goto fallback;
@@ -1666,11 +1680,10 @@ dax_insert_pfn_mkwrite(struct vm_fault *vm_fault_t ret;xas_lock_irq (&xas); - entry =get_unlocked_entry (&xas); + entry =get_unlocked_entry (&xas, order);/* Did we race with someone splitting entry or so? */ -if (!entry || - (order ==0 && !dax_is_pte_entry (entry)) || - (order ==PMD_ORDER && !dax_is_pmd_entry (entry))) { +if (!entry ||dax_is_conflict (entry) || + (order ==0 && !dax_is_pte_entry (entry))) {put_unlocked_entry (&xas, entry);xas_unlock_irq (&xas); trace_dax_insert_pfn_mkwrite_no_entry(mapping->host, vmf,
Greg Kroah-Hartman
maintainerPATCH 363/371 usb: Handle USB3 remote wakeup for LPM enabled devices correctly
In reply to Greg Kroah-HartmanFrom: Lee, Chiasheng <[email protected]>
commit e244c4699f859cf7149b0781b1894c7996a8a1df upstream.
With Link Power Management (LPM) enabled USB3 links transition to low power U1/U2 link states from U0 state automatically.
Current hub code detects USB3 remote wakeups by checking if the software state still shows suspended, but the link has transitioned from suspended U3 to enabled U0 state.
As it takes some time before the hub thread reads the port link state after a USB3 wake notification, the link may have transitioned from U0 to U1/U2, and wake is not detected by hub code.
Fix this by handling U1/U2 states in the same way as U0 in USB3 wakeup handling
This patch should be added to stable kernels since 4.13 where LPM was kept enabled during suspend/resume
--- drivers/usb/core/hub.c | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-)
drivers/usb/core/hub.c +5 -2
@@ -3616,6 +3616,7 @@ static int hub_handle_remote_wakeup(strustruct usb_device *hdev;struct usb_device *udev;int connect_change =0 ; +u16 link_state;int ret; hdev = hub->hdev;
@@ -3625,9 +3626,11 @@ static int hub_handle_remote_wakeup(strureturn 0 ;usb_clear_port_feature (hdev, port,USB_PORT_FEAT_C_SUSPEND ); }else { + link_state = portstatus &USB_PORT_STAT_LINK_STATE ;if (!udev || udev->state !=USB_STATE_SUSPENDED || - (portstatus &USB_PORT_STAT_LINK_STATE ) != -USB_SS_PORT_LS_U0 ) + (link_state !=USB_SS_PORT_LS_U0 && + link_state !=USB_SS_PORT_LS_U1 && + link_state !=USB_SS_PORT_LS_U2 ))return 0 ; }
Greg Kroah-Hartman
maintainerPATCH 364/371 blk-throttle: fix zero wait time for iops throttled group
In reply to Greg Kroah-HartmanFrom: Konstantin Khlebnikov <[email protected]>
commit 3a10f999ffd464d01c5a05592a15470a3c4bbc36 upstream.
After commit 991f61fe7e1d ("Blk-throttle: reduce tail io latency when iops limit is enforced") wait time could be zero even if group is throttled and cannot issue requests right now. As a result throtl_select_dispatch() turns into busy-loop under irq-safe queue spinlock.
Fix is simple: always round up target time to the next throttle slice.
--- block/blk-throttle.c | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-)
block/blk-throttle.c +3 -6
@@ -881,13 +881,10 @@ static bool tg_with_in_iops_limit(structunsigned long jiffy_elapsed, jiffy_wait, jiffy_elapsed_rnd;u64 tmp; - jiffy_elapsed = jiffy_elapsed_rnd = jiffies - tg->slice_start[rw]; + jiffy_elapsed = jiffies - tg->slice_start[rw]; -/* Slice has just started. Consider one slice interval */ -if (!jiffy_elapsed) - jiffy_elapsed_rnd = tg->td->throtl_slice; - - jiffy_elapsed_rnd =roundup (jiffy_elapsed_rnd, tg->td->throtl_slice); +/* Round up to the next throttle slice, wait time must be nonzero */ + jiffy_elapsed_rnd =roundup (jiffy_elapsed +1 , tg->td->throtl_slice);/* * jiffy_elapsed_rnd should not be a big value as minimum iops can be
Greg Kroah-Hartman
maintainerPATCH 365/371 clk: imx: imx8mm: correct audio_pll2_clk to audio_pll2_out
In reply to Greg Kroah-HartmanFrom: Peng Fan <[email protected]>
commit 5b933e28d8b1fbdc7fbac4bfc569f3b152c3dd59 upstream.
There is no audio_pll2_clk registered, it should be audio_pll2_out.
--- drivers/clk/imx/clk-imx8mm.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
drivers/clk/imx/clk-imx8mm.c +3 -3
@@ -325,7 +325,7 @@ static const char *imx8mm_dsi_dbi_sels[] "sys_pll2_1000m", "sys_pll3_out", "audio_pll2_out", "video_pll1_out", };static const char *imx8mm_usdhc3_sels[] = {"osc_24m" ,"sys_pll1_400m" ,"sys_pll1_800m" ,"sys_pll2_500m" , -"sys_pll3_out" ,"sys_pll1_266m" ,"audio_pll2_clk" ,"sys_pll1_100m" , }; +"sys_pll3_out" ,"sys_pll1_266m" ,"audio_pll2_out" ,"sys_pll1_100m" , };static const char *imx8mm_csi1_core_sels[] = {"osc_24m" ,"sys_pll1_266m" ,"sys_pll2_250m" ,"sys_pll1_800m" ,"sys_pll2_1000m" ,"sys_pll3_out" ,"audio_pll2_out" ,"video_pll1_out" , };
@@ -361,11 +361,11 @@ static const char *imx8mm_pdm_sels[] = { "sys_pll2_1000m", "sys_pll3_out", "clk_ext3", "audio_pll2_out", };static const char *imx8mm_vpu_h1_sels[] = {"osc_24m" ,"vpu_pll_out" ,"sys_pll1_800m" ,"sys_pll2_1000m" , -"audio_pll2_clk" ,"sys_pll2_125m" ,"sys_pll3_clk" ,"audio_pll1_out" , }; +"audio_pll2_out" ,"sys_pll2_125m" ,"sys_pll3_clk" ,"audio_pll1_out" , };static const char *imx8mm_dram_core_sels[] = {"dram_pll_out" ,"dram_alt_root" , }; -static const char *imx8mm_clko1_sels[] = {"osc_24m" ,"sys_pll1_800m" ,"osc_27m" ,"sys_pll1_200m" ,"audio_pll2_clk" , +static const char *imx8mm_clko1_sels[] = {"osc_24m" ,"sys_pll1_800m" ,"osc_27m" ,"sys_pll1_200m" ,"audio_pll2_out" ,"vpu_pll" ,"sys_pll1_80m" , };static struct clk *clks[IMX8MM_CLK_END ];
Greg Kroah-Hartman
maintainerPATCH 366/371 blk-iolatency: clear use_delay when io.latency is set to zero
In reply to Greg Kroah-HartmanFrom: Tejun Heo <[email protected]>
commit 5de0073fcd50cc1f150895a7bb04d3cf8067b1d7 upstream.
If use_delay was non-zero when the latency target of a cgroup was set to zero, it will stay stuck until io.latency is enabled on the cgroup again. This keeps readahead disabled for the cgroup impacting performance negatively.
--- block/blk-iolatency.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
block/blk-iolatency.c +3 -1
@@ -758,8 +758,10 @@ static int iolatency_set_min_lat_nsec(stif (!oldval && val)return 1 ; -if (oldval && !val) +if (oldval && !val) { +blkcg_clear_delay (blkg);return -1 ; + }return 0 ; }
Greg Kroah-Hartman
maintainerPATCH 367/371 blkcg: update blkcg_print_stat() to handle larger outputs
In reply to Greg Kroah-HartmanFrom: Tejun Heo <[email protected]>
commit f539da82f2158916e154d206054e0efd5df7ab61 upstream.
Depending on the number of devices, blkcg stats can go over the default seqfile buf size. seqfile normally retries with a larger buffer but since the ->pd_stat() addition, blkcg_print_stat() doesn't tell seqfile that overflow has happened and the output gets printed truncated. Fix it by calling seq_commit() w/ -1 on possible overflows.
--- block/blk-cgroup.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-)
block/blk-cgroup.c +6 -2
@@ -1005,8 +1005,12 @@ static int blkcg_print_stat(struct seq_f } next:if (has_stats) { - off +=scnprintf (buf+off, size-off,"\n" ); -seq_commit (sf, off); +if (off < size -1 ) { + off +=scnprintf (buf+off, size-off,"\n" ); +seq_commit (sf, off); + }else { +seq_commit (sf,-1 ); + } } }
Greg Kroah-Hartman
maintainerPATCH 368/371 net: mvmdio: allow up to four clocks to be specified for orion-mdio
In reply to Greg Kroah-HartmanFrom: Josua Mayer <[email protected]>
commit 4aabed699c400810981d3dda170f05fa4d782905 upstream.
Allow up to four clocks to be specified and enabled for the orion-mdio interface, which are required by the Armada 8k and defined in armada-cp110.dtsi.
Fixes a hang in probing the mvmdio driver that was encountered on the Clearfog GT 8K with all drivers built as modules, but also affects other boards such as the MacchiatoBIN.
--- drivers/net/ethernet/marvell/mvmdio.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/net/ethernet/marvell/mvmdio.c +1 -1
@@ -64,7 +64,7 @@struct orion_mdio_dev {void __iomem *regs; -struct clk *clk[3 ]; +struct clk *clk[4 ];/* * If we have access to the error interrupt pin (which is * somewhat misnamed as it not only reflects internal errors
stable-rc/linux-5.1.y boot: 137 boots: 2 failed, 134 passed with 1 offline (v5.1.19-372-g7da17d99564d)
stable-rc/linux-5.1.y boot: 137 boots: 2 failed, 134 passed with 1 offline (v5.1.19-372-g7da17d99564d)
Full Boot Summary: https://kernelci.org/boot/all/job/stable-rc/branch/linux-5.1.y/kernel/v5.1.19-372-g7da17d99564d/
Full Build Summary: https://kernelci.org/build/stable-rc/branch/linux-5.1.y/kernel/v5.1.19-372-g7da17d99564d/
Tree: stable-rc
Branch: linux-5.1.y
Git Describe: v5.1.19-372-g7da17d99564d
Git Commit: 7da17d99564d84f797e66a578ec5fb34f43fa58f
Git URL: https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable-rc.git
Tested: 79 unique boards, 27 SoC families, 17 builds out of 209
Boot Failures Detected:
arm:
multi_v7_defconfig:
gcc-8:
bcm4708-smartrg-sr400ac: 1 failed labarm64:
defconfig:
gcc-8:
meson-gxl-s905x-nexbox-a95x: 1 failed labOffline Platforms:
arm64:
defconfig:
gcc-8
meson-gxbb-odroidc2: 1 offline lab
---
For more info write to <[email protected]>
Quoted 14 lines · Greg Kroah-Hartman
This is the start of the stable review cycle for the 5.1.20 release. There are 371 patches in this series, all will be posted as a response to this one. If anyone has any issues with these being applied, please let me know.
Responses should be made by Fri 26 Jul 2019 07:13:35 PM UTC. Anything received after that time might be too late.
The whole patch series can be found in one patch at:
https://www.kernel.org/pub/linux/kernel/v5.x/stable-review/patch-5.1.20-rc1.gzor in the git tree and branch at:
git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable-rc.gitlinux-5.1.y
and the diffstat can be found below.
Quoted 5 lines
thanks,
greg k-h
-------------
Hello,
Compiled and booted. No regressions on x86_64.
THX,
Jiunn
Quoted 10 lines · Greg Kroah-Hartman
This is the start of the stable review cycle for the 5.1.20 release. There are 371 patches in this series, all will be posted as a response to this one. If anyone has any issues with these being applied, please let me know.
Responses should be made by Fri 26 Jul 2019 07:13:35 PM UTC. Anything received after that time might be too late.
The whole patch series can be found in one patch at:
Quoted 8 lines
https://www.kernel.org/pub/linux/kernel/v5.x/stable-review/patch-5.1.20-rc1.gzor in the git tree and branch at:
git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable-rc.gitlinux-5.1.y
and the diffstat can be found below.thanks,
greg k-h
Results from Linaro’s test farm.
No regressions on arm64, arm, x86_64, and i386.
Summary
------------------------------------------------------------------------
kernel: 5.1.20-rc1
git repo: https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable-rc.git
git branch: linux-5.1.y
git commit: 21e90543f836d29dae6ec06215a6e52419913d7b
git describe: v5.1.19-372-g21e90543f836
Test details: https://qa-reports.linaro.org/lkft/linux-stable-rc-5.1-oe/build/v5.1.19-372-g21e90543f836
No regressions (compared to build v5.1.19)
No fixes (compared to build v5.1.19)
Ran 22773 total tests in the following environments and test suites.
Environments
--------------
- dragonboard-410c
- hi6220-hikey
- i386
- juno-r2
- qemu_arm
- qemu_arm64
- qemu_i386
- qemu_x86_64
- x15
- x86
Test Suites
-----------
* build
* install-android-platform-tools-r2600
* kselftest
* libgpiod
* libhugetlbfs
* ltp-cap_bounds-tests
* ltp-commands-tests
* ltp-containers-tests
* ltp-cpuhotplug-tests
* ltp-cve-tests
* ltp-dio-tests
* ltp-fcntl-locktests-tests
* ltp-filecaps-tests
* ltp-fs-tests
* ltp-fs_bind-tests
* ltp-fs_perms_simple-tests
* ltp-fsx-tests
* ltp-hugetlb-tests
* ltp-io-tests
* ltp-ipc-tests
* ltp-math-tests
* ltp-mm-tests
* ltp-nptl-tests
* ltp-pty-tests
* ltp-sched-tests
* ltp-securebits-tests
* ltp-syscalls-tests
* ltp-timers-tests
* network-basic-tests
* perf
* spectre-meltdown-checker-test
* v4l2-compliance
* ltp-open-posix-tests
* kvm-unit-tests
* kselftest-vsyscall-mode-native
* kselftest-vsyscall-mode-none
Signature · 2 lines
Linaro LKFT https://lkft.linaro.org
Greg Kroah-Hartman
maintainerPATCH 369/371 dt-bindings: allow up to four clocks for orion-mdio
In reply to Greg Kroah-HartmanFrom: Josua Mayer <[email protected]>
commit 80785f5a22e9073e2ded5958feb7f220e066d17b upstream.
Armada 8040 needs four clocks to be enabled for MDIO accesses to work. Update the binding to allow the extra clock to be specified.
--- Documentation/devicetree/bindings/net/marvell-orion-mdio.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
Documentation/devicetree/bindings/net/marvell-orion-mdio.txt +1 -1
@@ -16,7 +16,7 @@ Required properties: Optional properties: - interrupts: interrupt line number for the SMI error/done interrupt -- clocks: phandle for up to three required clocks for the MDIO instance +- clocks: phandle for up to four required clocks for the MDIO instance The child nodes of the MDIO driver are the individual PHY devices connected to this MDIO bus. They must have a "reg" property given the
Greg Kroah-Hartman
maintainerPATCH 370/371 pstore: Fix double-free in pstore_mkfile() failure path
In reply to Greg Kroah-HartmanFrom: Norbert Manthey <[email protected]>
commit 4c6d80e1144bdf48cae6b602ae30d41f3e5c76a9 upstream.
The pstore_mkfile() function is passed a pointer to a struct pstore_record. On success it consumes this 'record' pointer and references it from the created inode.
On failure, however, it may or may not free the record. There are even two different code paths which return -ENOMEM -- one of which does and the other doesn't free the record.
Make the behaviour deterministic by never consuming and freeing the record when returning failure, allowing the caller to do the cleanup consistently.
--- fs/pstore/inode.c | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-)
fs/pstore/inode.c +6 -7
@@ -330,22 +330,21 @@ int pstore_mkfile(struct dentry *root, s goto fail; inode->i_mode =S_IFREG |0444 ; inode->i_fop = &pstore_file_operations; - private =kzalloc (sizeof (*private),GFP_KERNEL ); -if (!private) - goto fail_alloc; - private->record = record; -scnprintf (name,sizeof (name),"%s-%s-%llu%s" ,pstore_type_to_name (record->type), record->psi->name, record->id, record->compressed ?".enc.z" :"" ); + private =kzalloc (sizeof (*private),GFP_KERNEL ); +if (!private) + goto fail_inode; + dentry =d_alloc_name (root, name);if (!dentry) goto fail_private; + private->record = record; inode->i_size = private->total_size = size; - inode->i_private = private;if (record->time.tv_sec)
@@ -361,7 +360,7 @@ int pstore_mkfile(struct dentry *root, s fail_private:free_pstore_private (private); -fail_alloc: +fail_inode:iput (inode); fail:
Greg Kroah-Hartman
maintainerPATCH 371/371 dm bufio: fix deadlock with loop device
In reply to Greg Kroah-HartmanFrom: Junxiao Bi <[email protected]>
commit bd293d071ffe65e645b4d8104f9d8fe15ea13862 upstream.
When thin-volume is built on loop device, if available memory is low, the following deadlock can be triggered:
One process P1 allocates memory with GFP_FS flag, direct alloc fails, memory reclaim invokes memory shrinker in dm_bufio, dm_bufio_shrink_scan() runs, mutex dm_bufio_client->lock is acquired, then P1 waits for dm_buffer IO to complete in __try_evict_buffer().
But this IO may never complete if issued to an underlying loop device that forwards it using direct-IO, which allocates memory using GFP_KERNEL (see: do_blockdev_direct_IO()). If allocation fails, memory reclaim will invoke memory shrinker in dm_bufio, dm_bufio_shrink_scan() will be invoked, and since the mutex is already held by P1 the loop thread will hang, and IO will never complete. Resulting in ABBA deadlock.
--- drivers/md/dm-bufio.c | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-)
drivers/md/dm-bufio.c +1 -3
@@ -1602,9 +1602,7 @@ dm_bufio_shrink_scan(struct shrinker *shunsigned long freed; c = container_of(shrink, struct dm_bufio_client, shrinker); -if (sc->gfp_mask & __GFP_FS) -dm_bufio_lock (c); -else if (!dm_bufio_trylock (c)) +if (!dm_bufio_trylock (c))return SHRINK_STOP ; freed =__scan (c, sc->nr_to_scan, sc->gfp_mask);
Jon Hunter
maintainerQuoted 9 lines · Greg Kroah-Hartman
This is the start of the stable review cycle for the 5.1.20 release. There are 371 patches in this series, all will be posted as a response to this one. If anyone has any issues with these being applied, please let me know.
Responses should be made by Fri 26 Jul 2019 07:13:35 PM UTC. Anything received after that time might be too late.
The whole patch series can be found in one patch at:
Quoted 8 lines
https://www.kernel.org/pub/linux/kernel/v5.x/stable-review/patch-5.1.20-rc1.gzor in the git tree and branch at:
git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable-rc.gitlinux-5.1.y
and the diffstat can be found below.thanks,
greg k-h
All tests are passing for Tegra ...
Test results for stable-v5.1:
12 builds: 12 pass, 0 fail
22 boots: 22 pass, 0 fail
32 tests: 32 pass, 0 failLinux version: 5.1.20-rc1-g21e90543f836
Boards tested: tegra124-jetson-tk1, tegra186-p2771-0000,
tegra194-p2972-0000, tegra20-ventana,
tegra210-p2371-2180, tegra30-cardhu-a04Cheers
Jon
Signature · 1 line
nvpublic
Quoted 9 lines · Greg Kroah-Hartman
This is the start of the stable review cycle for the 5.1.20 release. There are 371 patches in this series, all will be posted as a response to this one. If anyone has any issues with these being applied, please let me know.
Responses should be made by Fri 26 Jul 2019 07:13:35 PM UTC. Anything received after that time might be too late.
The whole patch series can be found in one patch at:
Quoted 9 lines
https://www.kernel.org/pub/linux/kernel/v5.x/stable-review/patch-5.1.20-rc1.gzor in the git tree and branch at:
git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable-rc.gitlinux-5.1.y
and the diffstat can be found below.thanks,
greg k-h
Compiled and booted on my test system. No dmesg regressions.
thanks,
-- Shuah
Quoted 8 lines · Greg Kroah-Hartman
This is the start of the stable review cycle for the 5.1.20 release. There are 371 patches in this series, all will be posted as a response to this one. If anyone has any issues with these being applied, please let me know.
Responses should be made by Fri 26 Jul 2019 07:13:35 PM UTC. Anything received after that time might be too late.
Building powerpc:defconfig ... failed
Building powerpc:allmodconfig ... failed
arch/powerpc/kernel/prom_init.c: In function ‘early_cmdline_parse’:arch/powerpc/kernel/prom_init.c:689:8: error: implicit declaration of function ‘prom_strstr’
plus several qemu tests failing to build for the same reason.
Guenter
Greg Kroah-Hartman
maintainerQuoted 10 lines · Guenter Roeck
Quoted 8 lines · Greg Kroah-Hartman
This is the start of the stable review cycle for the 5.1.20 release. There are 371 patches in this series, all will be posted as a response to this one. If anyone has any issues with these being applied, please let me know.
Responses should be made by Fri 26 Jul 2019 07:13:35 PM UTC. Anything received after that time might be too late.
Quoted 7 lines
Building powerpc:defconfig ... failed
Building powerpc:allmodconfig ... failed
arch/powerpc/kernel/prom_init.c: In function ‘early_cmdline_parse’:arch/powerpc/kernel/prom_init.c:689:8: error: implicit declaration of function ‘prom_strstr’plus several qemu tests failing to build for the same reason.
Found it, it's a powerpc patch. I've now dropped it and am pushing out a -rc2 right now with that patch removed.
thanks,
greg k-h
Quoted 8 lines · Greg Kroah-Hartman
This is the start of the stable review cycle for the 5.1.20 release. There are 371 patches in this series, all will be posted as a response to this one. If anyone has any issues with these being applied, please let me know.
Responses should be made by Fri 26 Jul 2019 07:13:35 PM UTC. Anything received after that time might be too late.
For v5.1.19-370-gfb6ea525ffcf:
Build results:
total: 159 pass: 159 fail: 0 Qemu test results: total: 364 pass: 364 fail: 0
Guenter
Greg Kroah-Hartman
maintainerQuoted 10 lines · Guenter Roeck
Quoted 8 lines · Greg Kroah-Hartman
This is the start of the stable review cycle for the 5.1.20 release. There are 371 patches in this series, all will be posted as a response to this one. If anyone has any issues with these being applied, please let me know.
Responses should be made by Fri 26 Jul 2019 07:13:35 PM UTC. Anything received after that time might be too late.
Quoted 6 lines
For v5.1.19-370-gfb6ea525ffcf:
Build results:
total: 159 pass: 159 fail: 0 Qemu test results: total: 364 pass: 364 fail: 0
Wonderful, glad it is all now working. Thanks for testing all of these and letting me know.
greg k-h
Quoted 9 lines · Greg Kroah-Hartman
This is the start of the stable review cycle for the 5.1.20 release. There are 371 patches in this series, all will be posted as a response to this one. If anyone has any issues with these being applied, please let me know.
Responses should be made by Fri 26 Jul 2019 07:13:35 PM UTC. Anything received after that time might be too late.
The whole patch series can be found in one patch at:
Quoted 8 lines
https://www.kernel.org/pub/linux/kernel/v5.x/stable-review/patch-5.1.20-rc1.gzor in the git tree and branch at:
git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable-rc.gitlinux-5.1.y
and the diffstat can be found below.thanks,
greg k-h
Compiled and booted with no regressions on my system.
Cheers,
Kelsey
Built and booted on my x86_64 test system. No dmesg regressions.
Thank you
Bharath