5.4.48-rc1 review
Subsystems (5)
Greg Kroah-Hartman
maintainerPATCH 145/261 iwlwifi: mvm: fix aux station leak
In reply to Greg Kroah-HartmanFrom: Sharon <[email protected]>
[ Upstream commit f327236df2afc8c3c711e7e070f122c26974f4da ]
When mvm is initialized we alloc aux station with aux queue. We later free the station memory when driver is stopped, but we never free the queue's memory, which casues a leak.
Add a proper de-initialization of the station.
--- .../net/wireless/intel/iwlwifi/mvm/mac80211.c | 5 ++--- drivers/net/wireless/intel/iwlwifi/mvm/sta.c | 18 +++++++++++++----- drivers/net/wireless/intel/iwlwifi/mvm/sta.h | 6 +++--- 3 files changed, 18 insertions(+), 11 deletions(-)
drivers/net/wireless/intel/iwlwifi/mvm/mac80211.c +2 -3
@@ -1193,14 +1193,13 @@ void __iwl_mvm_mac_stop(struct iwl_mvm *mvm)*/ flush_work (&mvm->roc_done_wk); +iwl_mvm_rm_aux_sta (mvm); +iwl_mvm_stop_device (mvm);iwl_mvm_async_handlers_purge (mvm);/* async_handlers_list is empty and will stay empty: HW is stopped */ -/* the fw is stopped, the aux sta is dead: clean up driver state */ -iwl_mvm_del_aux_sta (mvm); -/* * Clear IN_HW_RESTART and HW_RESTART_REQUESTED flag when stopping the * hw (as restart_complete() won't be called in this case) and mac80211
drivers/net/wireless/intel/iwlwifi/mvm/sta.c +13 -5
@@ -2080,16 +2080,24 @@ int iwl_mvm_rm_snif_sta(struct iwl_mvm *mvm, struct ieee80211_vif *vif)return ret; } -void iwl_mvm_dealloc_snif_sta (struct iwl_mvm *mvm) +int iwl_mvm_rm_aux_sta (struct iwl_mvm *mvm) { -iwl_mvm_dealloc_int_sta (mvm, &mvm->snif_sta); -} +int ret; -void iwl_mvm_del_aux_sta (struct iwl_mvm *mvm) -{lockdep_assert_held (&mvm->mutex); +iwl_mvm_disable_txq (mvm,NULL , mvm->aux_queue,IWL_MAX_TID_COUNT ,0 ); + ret =iwl_mvm_rm_sta_common (mvm, mvm->aux_sta.sta_id); +if (ret) +IWL_WARN (mvm,"Failed sending remove station\n" );iwl_mvm_dealloc_int_sta (mvm, &mvm->aux_sta); + +return ret; +} + +void iwl_mvm_dealloc_snif_sta (struct iwl_mvm *mvm) +{ +iwl_mvm_dealloc_int_sta (mvm, &mvm->snif_sta); }/*
drivers/net/wireless/intel/iwlwifi/mvm/sta.h +3 -3
@@ -8,7 +8,7 @@* Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved. * Copyright(c) 2013 - 2014 Intel Mobile Communications GmbH * Copyright(c) 2015 - 2016 Intel Deutschland GmbH -* Copyright(c) 2018 - 2019 Intel Corporation +* Copyright(c) 2018 - 2020 Intel Corporation * * This program is free software; you can redistribute it and/or modify * it under the terms of version 2 of the GNU General Public License as
@@ -31,7 +31,7 @@* Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved. * Copyright(c) 2013 - 2014 Intel Mobile Communications GmbH * Copyright(c) 2015 - 2016 Intel Deutschland GmbH -* Copyright(c) 2018 - 2019 Intel Corporation +* Copyright(c) 2018 - 2020 Intel Corporation * All rights reserved. * * Redistribution and use in source and binary forms, with or without
@@ -541,7 +541,7 @@ int iwl_mvm_sta_tx_agg(struct iwl_mvm *mvm, struct ieee80211_sta *sta, int tid, u8 queue, bool start);int iwl_mvm_add_aux_sta (struct iwl_mvm *mvm); -void iwl_mvm_del_aux_sta (struct iwl_mvm *mvm); +int iwl_mvm_rm_aux_sta (struct iwl_mvm *mvm);int iwl_mvm_alloc_bcast_sta (struct iwl_mvm *mvm,struct ieee80211_vif *vif);int iwl_mvm_send_add_bcast_sta (struct iwl_mvm *mvm,struct ieee80211_vif *vif);
Signature · 1 line
2.25.1
Greg Kroah-Hartman
maintainerPATCH 146/261 mmc: sdhci-esdhc-imx: fix the mask for tuning start point
In reply to Greg Kroah-HartmanFrom: Haibo Chen <[email protected]>
[ Upstream commit 1194be8c949b8190b2882ad8335a5d98aa50c735 ]
According the RM, the bit[6~0] of register ESDHC_TUNING_CTRL is TUNING_START_TAP, bit[7] of this register is to disable the command CRC check for standard tuning. So fix it here.
--- drivers/mmc/host/sdhci-esdhc-imx.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/mmc/host/sdhci-esdhc-imx.c +1 -1
@@ -87,7 +87,7 @@#define ESDHC_STD_TUNING_EN (1 << 24)/* NOTE: the minimum valid tuning start tap for mx6sl is 1 */ #define ESDHC_TUNING_START_TAP_DEFAULT 0x1 -#define ESDHC_TUNING_START_TAP_MASK 0xff +#define ESDHC_TUNING_START_TAP_MASK 0x7f#define ESDHC_TUNING_STEP_MASK 0x00070000#define ESDHC_TUNING_STEP_SHIFT 16
Signature · 1 line
2.25.1
Greg Kroah-Hartman
maintainerPATCH 147/261 spi: dw: Return any value retrieved from the dma_transfer callback
In reply to Greg Kroah-HartmanFrom: Serge Semin <[email protected]>
[ Upstream commit f0410bbf7d0fb80149e3b17d11d31f5b5197873e ]
DW APB SSI DMA-part of the driver may need to perform the requested SPI-transfer synchronously. In that case the dma_transfer() callback will return 0 as a marker of the SPI transfer being finished so the SPI core doesn't need to wait and may proceed with the SPI message trasnfers pumping procedure. This will be needed to fix the problem when DMA transactions are finished, but there is still data left in the SPI Tx/Rx FIFOs being sent/received. But for now make dma_transfer to return 1 as the normal dw_spi_transfer_one() method.
--- drivers/spi/spi-dw-mid.c | 2 +- drivers/spi/spi-dw.c | 7 ++----- 2 files changed, 3 insertions(+), 6 deletions(-)
drivers/spi/spi-dw-mid.c +1 -1
@@ -266,7 +266,7 @@ static int mid_spi_dma_transfer(struct dw_spi *dws, struct spi_transfer *xfer)dma_async_issue_pending (dws->txchan); } -return 0 ; +return 1 ; }static void mid_spi_dma_stop (struct dw_spi *dws)
drivers/spi/spi-dw.c +2 -5
@@ -381,11 +381,8 @@ static int dw_spi_transfer_one(struct spi_controller *master,spi_enable_chip (dws,1 ); -if (dws->dma_mapped) { - ret = dws->dma_ops->dma_transfer (dws, transfer); -if (ret <0 ) -return ret; - } +if (dws->dma_mapped) +return dws->dma_ops->dma_transfer (dws, transfer);if (chip->poll_mode)return poll_transfer (dws);
Signature · 1 line
2.25.1
Greg Kroah-Hartman
maintainerPATCH 148/261 cpuidle: Fix three reference count leaks
In reply to Greg Kroah-HartmanFrom: Qiushi Wu <[email protected]>
[ Upstream commit c343bf1ba5efcbf2266a1fe3baefec9cc82f867f ]
kobject_init_and_add() takes reference even when it fails. If this function returns an error, kobject_put() must be called to properly clean up the memory associated with the object.
Previous commit "b8eb718348b8" fixed a similar problem.
--- drivers/cpuidle/sysfs.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
drivers/cpuidle/sysfs.c +3 -3
@@ -480,7 +480,7 @@ static int cpuidle_add_state_sysfs(struct cpuidle_device *device) ret =kobject_init_and_add (&kobj->kobj, &ktype_state_cpuidle, &kdev->kobj,"state%d" , i);if (ret) { -kfree (kobj); +kobject_put (&kobj->kobj); goto error_state; }cpuidle_add_s2idle_attr_group (kobj);
@@ -611,7 +611,7 @@ static int cpuidle_add_driver_sysfs(struct cpuidle_device *dev) ret =kobject_init_and_add (&kdrv->kobj, &ktype_driver_cpuidle, &kdev->kobj,"driver" );if (ret) { -kfree (kdrv); +kobject_put (&kdrv->kobj);return ret; }
@@ -705,7 +705,7 @@ int cpuidle_add_sysfs(struct cpuidle_device *dev) error =kobject_init_and_add (&kdev->kobj, &ktype_cpuidle, &cpu_dev->kobj,"cpuidle" );if (error) { -kfree (kdev); +kobject_put (&kdev->kobj);return error; }
Signature · 1 line
2.25.1
Greg Kroah-Hartman
maintainerPATCH 149/261 platform/x86: hp-wmi: Convert simple_strtoul() to kstrtou32()
In reply to Greg Kroah-HartmanFrom: Andy Shevchenko <[email protected]>
[ Upstream commit 5cdc45ed3948042f0d73c6fec5ee9b59e637d0d2 ]
First of all, unsigned long can overflow u32 value on 64-bit machine. Second, simple_strtoul() doesn't check for overflow in the input.
Convert simple_strtoul() to kstrtou32() to eliminate above issues.
--- drivers/platform/x86/hp-wmi.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-)
drivers/platform/x86/hp-wmi.c +8 -2
@@ -461,8 +461,14 @@ static ssize_t postcode_show(struct device *dev, struct device_attribute *attr,static ssize_t als_store (struct device *dev,struct device_attribute *attr,const char *buf,size_t count) { -u32 tmp =simple_strtoul (buf,NULL ,10 ); -int ret =hp_wmi_perform_query (HPWMI_ALS_QUERY ,HPWMI_WRITE , &tmp, +u32 tmp; +int ret; + + ret =kstrtou32 (buf,10 , &tmp); +if (ret) +return ret; + + ret =hp_wmi_perform_query (HPWMI_ALS_QUERY ,HPWMI_WRITE , &tmp,sizeof (tmp),sizeof (tmp));if (ret)return ret <0 ? ret : -EINVAL ;
Signature · 1 line
2.25.1
Greg Kroah-Hartman
maintainerPATCH 150/261 platform/x86: intel-hid: Add a quirk to support HP Spectre X2 (2015)
In reply to Greg Kroah-HartmanFrom: Nickolai Kozachenko <[email protected]>
[ Upstream commit 8fe63eb757ac6e661a384cc760792080bdc738dc ]
HEBC method reports capabilities of 5 button array but HP Spectre X2 (2015) does not have this control method (the same was for Wacom MobileStudio Pro). Expand previous DMI quirk by Alex Hung to also enable 5 button array for this system.
--- drivers/platform/x86/intel-hid.c | 7 +++++++ 1 file changed, 7 insertions(+)
drivers/platform/x86/intel-hid.c +7 -0
@@ -77,6 +77,13 @@ static const struct dmi_system_id button_array_table[] = { DMI_MATCH(DMI_PRODUCT_NAME, "Wacom MobileStudio Pro 16"), }, }, + { + .ident = "HP Spectre x2 (2015)", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "HP"), + DMI_MATCH(DMI_PRODUCT_NAME, "HP Spectre x2 Detachable"), + }, + }, { } };
Signature · 1 line
2.25.1
Greg Kroah-Hartman
maintainerPATCH 151/261 platform/x86: intel-vbtn: Only blacklist SW_TABLET_MODE on the 9 / "Laptop" chasis-type
In reply to Greg Kroah-HartmanFrom: Hans de Goede <[email protected]>
[ Upstream commit cfae58ed681c5fe0185db843013ecc71cd265ebf ]
The HP Stream x360 11-p000nd no longer report SW_TABLET_MODE state / events with recent kernels. This model reports a chassis-type of 10 / "Notebook" which is not on the recently introduced chassis-type whitelist
Commit de9647efeaa9 ("platform/x86: intel-vbtn: Only activate tablet mode switch on 2-in-1's") added a chassis-type whitelist and only listed 31 / "Convertible" as being capable of generating valid SW_TABLET_MOD events.
Commit 1fac39fd0316 ("platform/x86: intel-vbtn: Also handle tablet-mode switch on "Detachable" and "Portable" chassis-types") extended the whitelist with chassis-types 8 / "Portable" and 32 / "Detachable".
And now we need to exten the whitelist again with 10 / "Notebook"...
The issue original fixed by the whitelist is really a ACPI DSDT bug on the Dell XPS 9360 where it has a VGBS which reports it is in tablet mode even though it is not a 2-in-1 at all, but a regular laptop.
So since this is a workaround for a DSDT issue on that specific model, instead of extending the whitelist over and over again, lets switch to a blacklist and only blacklist the chassis-type of the model for which the chassis-type check was added.
Note this also fixes the current version of the code no longer checking if dmi_get_system_info(DMI_CHASSIS_TYPE) returns NULL.
--- drivers/platform/x86/intel-vbtn.c | 19 ++++++++----------- 1 file changed, 8 insertions(+), 11 deletions(-)
drivers/platform/x86/intel-vbtn.c +8 -11
@@ -157,21 +157,18 @@ static void detect_tablet_mode(struct platform_device *device)static bool intel_vbtn_has_switches (acpi_handle handle) {const char *chassis_type =dmi_get_system_info (DMI_CHASSIS_TYPE ); -unsigned long chassis_type_int;unsigned long long vgbs;acpi_status status; -if (kstrtoul (chassis_type,10 , &chassis_type_int)) -return false; - -switch (chassis_type_int) { -case 8 :/* Portable */ -case 31 :/* Convertible */ -case 32 :/* Detachable */ -break ; -default : +/* +* Some normal laptops have a VGBS method despite being non-convertible +* and their VGBS method always returns 0, causing detect_tablet_mode() +* to report SW_TABLET_MODE=1 to userspace, which causes issues. +* These laptops have a DMI chassis_type of 9 ("Laptop"), do not report +* switches on any devices with a DMI chassis_type of 9. +*/ +if (chassis_type &&strcmp (chassis_type,"9" ) ==0 )return false; - } status =acpi_evaluate_integer (handle,"VGBS" ,NULL , &vgbs);return ACPI_SUCCESS (status);
Signature · 1 line
2.25.1
Greg Kroah-Hartman
maintainerPATCH 152/261 platform/x86: asus_wmi: Reserve more space for struct bias_args
In reply to Greg Kroah-HartmanFrom: Chris Chiu <[email protected]>
[ Upstream commit 7b91f1565fbfbe5a162d91f8a1f6c5580c2fc1d0 ]
On the ASUS laptop UX325JA/UX425JA, most of the media keys are not
working due to the ASUS WMI driver fails to be loaded. The ACPI error
as follows leads to the failure of asus_wmi_evaluate_method.
ACPI BIOS Error (bug): AE_AML_BUFFER_LIMIT, Field [IIA3] at bit offset/length 96/32 exceeds size of target Buffer (96 bits) (20200326/dsopcode-203) No Local Variables are initialized for Method [WMNB]
ACPI Error: Aborting method \_SB.ATKD.WMNB due to previous error (AE_AML_BUFFER_LIMIT) (20200326/psparse-531)
The DSDT for the WMNB part shows that 5 DWORD required for local variables and the 3rd variable IIA3 hit the buffer limit.
Method (WMNB, 3, Serialized)
{ ..
CreateDWordField (Arg2, Zero, IIA0)
CreateDWordField (Arg2, 0x04, IIA1)
CreateDWordField (Arg2, 0x08, IIA2)
CreateDWordField (Arg2, 0x0C, IIA3)
CreateDWordField (Arg2, 0x10, IIA4)
Local0 = (Arg1 & 0xFFFFFFFF)
If ((Local0 == 0x54494E49)) ..
}
The limitation is determined by the input acpi_buffer size passed to the wmi_evaluate_method. Since the struct bios_args is the data structure used as input buffer by default for all ASUS WMI calls, the size needs to be expanded to fix the problem.
--- drivers/platform/x86/asus-wmi.c | 2 ++ 1 file changed, 2 insertions(+)
drivers/platform/x86/asus-wmi.c +2 -0
@@ -111,6 +111,8 @@ struct bios_args {u32 arg0;u32 arg1;u32 arg2;/* At least TUF Gaming series uses 3 dword input buffer. */ +u32 arg4; +u32 arg5; } __packed;/*
Signature · 1 line
2.25.1
Greg Kroah-Hartman
maintainerPATCH 153/261 libbpf: Fix perf_buffer__free() API for sparse allocs
In reply to Greg Kroah-HartmanFrom: Eelco Chaudron <[email protected]>
[ Upstream commit 601b05ca6edb0422bf6ce313fbfd55ec7bbbc0fd ]
In case the cpu_bufs are sparsely allocated they are not all free'ed. These changes will fix this.
--- tools/lib/bpf/libbpf.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)
tools/lib/bpf/libbpf.c +4 -1
@@ -5358,9 +5358,12 @@ void perf_buffer__free(struct perf_buffer *pb)if (!pb)return ;if (pb->cpu_bufs) { -for (i =0 ; i < pb->cpu_cnt && pb->cpu_bufs[i]; i++) { +for (i =0 ; i < pb->cpu_cnt; i++) {struct perf_cpu_buf *cpu_buf = pb->cpu_bufs[i]; +if (!cpu_buf) +continue ; +bpf_map_delete_elem (pb->map_fd, &cpu_buf->map_key);perf_buffer__free_cpu_buf (pb, cpu_buf); }
Signature · 1 line
2.25.1
Greg Kroah-Hartman
maintainerPATCH 154/261 bpf: Fix map permissions check
In reply to Greg Kroah-HartmanFrom: Anton Protopopov <[email protected]>
[ Upstream commit 1ea0f9120c8ce105ca181b070561df5cbd6bc049 ]
The map_lookup_and_delete_elem() function should check for both FMODE_CAN_WRITE and FMODE_CAN_READ permissions because it returns a map element to user space.
--- kernel/bpf/syscall.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
kernel/bpf/syscall.c +2 -1
@@ -1118,7 +1118,8 @@ static int map_lookup_and_delete_elem(union bpf_attr *attr) map =__bpf_map_get (f);if (IS_ERR (map))return PTR_ERR (map); -if (!(map_get_sys_perms (map, f) &FMODE_CAN_WRITE )) { +if (!(map_get_sys_perms (map, f) &FMODE_CAN_READ ) || + !(map_get_sys_perms (map, f) &FMODE_CAN_WRITE )) { err = -EPERM ; goto err_put; }
Signature · 1 line
2.25.1
Greg Kroah-Hartman
maintainerPATCH 155/261 bpf: Refactor sockmap redirect code so its easy to reuse
In reply to Greg Kroah-HartmanFrom: John Fastabend <[email protected]>
[ Upstream commit ca2f5f21dbbd5e3a00cd3e97f728aa2ca0b2e011 ]
We will need this block of code called from tls context shortly lets refactor the redirect logic so its easy to use. This also cleans up the switch stmt so we have fewer fallthrough cases.
No logic changes are intended.
--- net/core/skmsg.c | 55 ++++++++++++++++++++++++++++++------------------ 1 file changed, 34 insertions(+), 21 deletions(-)
net/core/skmsg.c +34 -21
@@ -686,13 +686,43 @@ static struct sk_psock *sk_psock_from_strp(struct strparser *strp) return container_of(parser, struct sk_psock, parser); } -static void sk_psock_verdict_apply (struct sk_psock *psock, -struct sk_buff *skb,int verdict) +static void sk_psock_skb_redirect (struct sk_psock *psock,struct sk_buff *skb) {struct sk_psock *psock_other;struct sock *sk_other;bool ingress; + sk_other =tcp_skb_bpf_redirect_fetch (skb); +if (unlikely (!sk_other)) { +kfree_skb (skb); +return ; + } + psock_other =sk_psock (sk_other); +if (!psock_other ||sock_flag (sk_other,SOCK_DEAD ) || + !sk_psock_test_state (psock_other,SK_PSOCK_TX_ENABLED )) { +kfree_skb (skb); +return ; + } + + ingress =tcp_skb_bpf_ingress (skb); +if ((!ingress &&sock_writeable (sk_other)) || + (ingress && +atomic_read (&sk_other->sk_rmem_alloc) <= + sk_other->sk_rcvbuf)) { +if (!ingress) +skb_set_owner_w (skb, sk_other); +skb_queue_tail (&psock_other->ingress_skb, skb); +schedule_work (&psock_other->work); + }else { +kfree_skb (skb); + } +} + +static void sk_psock_verdict_apply (struct sk_psock *psock, +struct sk_buff *skb,int verdict) +{ +struct sock *sk_other; +switch (verdict) {case __SK_PASS: sk_other = psock->sk;
@@ -711,25 +741,8 @@ static void sk_psock_verdict_apply(struct sk_psock *psock, } goto out_free;case __SK_REDIRECT: - sk_other =tcp_skb_bpf_redirect_fetch (skb); -if (unlikely (!sk_other)) - goto out_free; - psock_other =sk_psock (sk_other); -if (!psock_other ||sock_flag (sk_other,SOCK_DEAD ) || - !sk_psock_test_state (psock_other,SK_PSOCK_TX_ENABLED )) - goto out_free; - ingress =tcp_skb_bpf_ingress (skb); -if ((!ingress &&sock_writeable (sk_other)) || - (ingress && -atomic_read (&sk_other->sk_rmem_alloc) <= - sk_other->sk_rcvbuf)) { -if (!ingress) -skb_set_owner_w (skb, sk_other); -skb_queue_tail (&psock_other->ingress_skb, skb); -schedule_work (&psock_other->work); -break ; - } -/* fall-through */ +sk_psock_skb_redirect (psock, skb); +break ;case __SK_DROP:/* fall-through */ default :
Signature · 1 line
2.25.1
Greg Kroah-Hartman
maintainerPATCH 156/261 bpf: Fix running sk_skb program types with ktls
In reply to Greg Kroah-HartmanFrom: John Fastabend <[email protected]>
[ Upstream commit e91de6afa81c10e9f855c5695eb9a53168d96b73 ]
KTLS uses a stream parser to collect TLS messages and send them to the upper layer tls receive handler. This ensures the tls receiver has a full TLS header to parse when it is run. However, when a socket has BPF_SK_SKB_STREAM_VERDICT program attached before KTLS is enabled we end up with two stream parsers running on the same socket.
The result is both try to run on the same socket. First the KTLS stream parser runs and calls read_sock() which will tcp_read_sock which in turn calls tcp_rcv_skb(). This dequeues the skb from the sk_receive_queue. When this is done KTLS code then data_ready() callback which because we stacked KTLS on top of the bpf stream verdict program has been replaced with sk_psock_start_strp(). This will in turn kick the stream parser again and eventually do the same thing KTLS did above calling into tcp_rcv_skb() and dequeuing a skb from the sk_receive_queue.
At this point the data stream is broke. Part of the stream was handled by the KTLS side some other bytes may have been handled by the BPF side. Generally this results in either missing data or more likely a "Bad Message" complaint from the kTLS receive handler as the BPF program steals some bytes meant to be in a TLS header and/or the TLS header length is no longer correct.
We've already broke the idealized model where we can stack ULPs in any order with generic callbacks on the TX side to handle this. So in this patch we do the same thing but for RX side. We add a sk_psock_strp_enabled() helper so TLS can learn a BPF verdict program is running and add a tls_sw_has_ctx_rx() helper so BPF side can learn there is a TLS ULP on the socket.
Then on BPF side we omit calling our stream parser to avoid breaking the data stream for the KTLS receiver. Then on the KTLS side we call BPF_SK_SKB_STREAM_VERDICT once the KTLS receiver is done with the packet but before it posts the msg to userspace. This gives us symmetry between the TX and RX halfs and IMO makes it usable again. On the TX side we process packets in this order BPF -> TLS -> TCP and on the receive side in the reverse order TCP -> TLS -> BPF.
Discovered while testing OpenSSL 3.0 Alpha2.0 release.
--- include/linux/skmsg.h | 8 ++++++++ include/net/tls.h | 9 +++++++++ net/core/skmsg.c | 43 ++++++++++++++++++++++++++++++++++++++++--- net/tls/tls_sw.c | 20 ++++++++++++++++++-- 4 files changed, 75 insertions(+), 5 deletions(-)
include/linux/skmsg.h +8 -0
@@ -457,4 +457,12 @@ static inline void psock_progs_drop(struct sk_psock_progs *progs) psock_set_prog(&progs->skb_verdict, NULL); } +int sk_psock_tls_strp_read (struct sk_psock *psock,struct sk_buff *skb); + +static inline bool sk_psock_strp_enabled (struct sk_psock *psock) +{ +if (!psock) +return false; +return psock->parser.enabled; +}#endif /* _LINUX_SKMSG_H */
include/net/tls.h +9 -0
@@ -590,6 +590,15 @@ static inline bool tls_sw_has_ctx_tx(const struct sock *sk)return !!tls_sw_ctx_tx (ctx); } +static inline bool tls_sw_has_ctx_rx (const struct sock *sk) +{ +struct tls_context *ctx =tls_get_ctx (sk); + +if (!ctx) +return false; +return !!tls_sw_ctx_rx (ctx); +} +void tls_sw_write_space (struct sock *sk,struct tls_context *ctx);void tls_device_write_space (struct sock *sk,struct tls_context *ctx);
net/core/skmsg.c +40 -3
61 lines not on this page · raw message
net/tls/tls_sw.c +18 -2
@@ -1737,6 +1737,7 @@ int tls_sw_recvmsg(struct sock *sk,long timeo;bool is_kvec =iov_iter_is_kvec (&msg->msg_iter);bool is_peek = flags &MSG_PEEK ; +bool bpf_strp_enabled;int num_async =0 ;int pending;
@@ -1747,6 +1748,7 @@ int tls_sw_recvmsg(struct sock *sk, psock =sk_psock_get (sk);lock_sock (sk); + bpf_strp_enabled =sk_psock_strp_enabled (psock);/* Process pending decrypted records. It must be non-zero-copy */ err = process_rx_list(ctx, msg, &control, &cmsg, 0, len, false,
@@ -1800,11 +1802,12 @@ int tls_sw_recvmsg(struct sock *sk,if (to_decrypt <= len && !is_kvec && !is_peek && ctx->control ==TLS_RECORD_TYPE_DATA && - prot->version !=TLS_1_3_VERSION ) + prot->version !=TLS_1_3_VERSION && + !bpf_strp_enabled) zc = true;/* Do not use async mode if record is non-data */ -if (ctx->control ==TLS_RECORD_TYPE_DATA ) +if (ctx->control ==TLS_RECORD_TYPE_DATA && !bpf_strp_enabled) async_capable = ctx->async_capable;else async_capable = false;
@@ -1854,6 +1857,19 @@ int tls_sw_recvmsg(struct sock *sk, goto pick_next_record;if (!zc) { +if (bpf_strp_enabled) { + err =sk_psock_tls_strp_read (psock, skb); +if (err != __SK_PASS) { + rxm->offset = rxm->offset + rxm->full_len; + rxm->full_len =0 ; +if (err == __SK_DROP) +consume_skb (skb); + ctx->recv_pkt =NULL ; +__strp_unpause (&ctx->strp); +continue ; + } + } +if (rxm->full_len > len) { retain_skb = true; chunk = len;
Signature · 1 line
2.25.1
Greg Kroah-Hartman
maintainerPATCH 157/261 selftests/bpf, flow_dissector: Close TAP device FD after the test
In reply to Greg Kroah-HartmanFrom: Jakub Sitnicki <[email protected]>
[ Upstream commit b8215dce7dfd817ca38807f55165bf502146cd68 ]
test_flow_dissector leaves a TAP device after it's finished, potentially interfering with other tests that will run after it. Fix it by closing the TAP descriptor on cleanup.
--- tools/testing/selftests/bpf/prog_tests/flow_dissector.c | 1 + 1 file changed, 1 insertion(+)
tools/testing/selftests/bpf/prog_tests/flow_dissector.c +1 -0
@@ -523,6 +523,7 @@ void test_flow_dissector(void)CHECK_ATTR (err, tests[i].name,"bpf_map_delete_elem %d\n" , err); } +close (tap_fd);bpf_prog_detach (prog_fd,BPF_FLOW_DISSECTOR );bpf_object__close (obj); }
Signature · 1 line
2.25.1
Greg Kroah-Hartman
maintainerPATCH 158/261 kasan: stop tests being eliminated as dead code with FORTIFY_SOURCE
In reply to Greg Kroah-HartmanFrom: Daniel Axtens <[email protected]>
[ Upstream commit adb72ae1915db28f934e9e02c18bfcea2f3ed3b7 ]
Patch series "Fix some incompatibilites between KASAN and FORTIFY_SOURCE", v4.
3 KASAN self-tests fail on a kernel with both KASAN and FORTIFY_SOURCE:
memchr, memcmp and strlen.
When FORTIFY_SOURCE is on, a number of functions are replaced with fortified versions, which attempt to check the sizes of the operands. However, these functions often directly invoke __builtin_foo() once they have performed the fortify check. The compiler can detect that the results of these functions are not used, and knows that they have no other side effects, and so can eliminate them as dead code.
Why are only memchr, memcmp and strlen affected?
================================================
Of string and string-like functions, kasan_test tests:
* strchr -> not affected, no fortified version * strrchr -> likewise * strcmp -> likewise * strncmp -> likewise
* strnlen -> not affected, the fortify source implementation calls the underlying strnlen implementation which is instrumented, not a builtin
* strlen -> affected, the fortify souce implementation calls a __builtin version which the compiler can determine is dead.
* memchr -> likewise * memcmp -> likewise
* memset -> not affected, the compiler knows that memset writes to its
first argument and therefore is not dead.
Why does this not affect the functions normally?
================================================
In string.h, these functions are not marked as __pure, so the compiler cannot know that they do not have side effects. If relevant functions are marked as __pure in string.h, we see the following warnings and the functions are elided:
lib/test_kasan.c: In function `kasan_memchr':lib/test_kasan.c:606:2: warning: statement with no effect [-Wunused-value]
memchr(ptr, '1', size + 1);
^~~~~~~~~~~~~~~~~~~~~~~~~~lib/test_kasan.c: In function `kasan_memcmp':lib/test_kasan.c:622:2: warning: statement with no effect [-Wunused-value]
memcmp(ptr, arr, size+1);
^~~~~~~~~~~~~~~~~~~~~~~~lib/test_kasan.c: In function `kasan_strings':lib/test_kasan.c:645:2: warning: statement with no effect [-Wunused-value]
strchr(ptr, '1');
^~~~~~~~~~~~~~~~
...
This annotation would make sense to add and could be added at any point, so the behaviour of test_kasan.c should change.
The fix
=======
Make all the functions that are pure write their results to a global, which makes them live. The strlen and memchr tests now pass.
The memcmp test still fails to trigger, which is addressed in the next patch.
--- lib/test_kasan.c | 29 +++++++++++++++++++---------- 1 file changed, 19 insertions(+), 10 deletions(-)
lib/test_kasan.c +19 -10
@@ -22,6 +22,14 @@#include <asm/page.h> +/* +* We assign some test results to these globals to make sure the tests +* are not eliminated as dead code. +*/ + +int kasan_int_result; +void *kasan_ptr_result; +/* * Note: test functions are marked noinline so that their names appear in * reports.
@@ -603,7 +611,7 @@ static noinline void __init kasan_memchr(void)if (!ptr)return ; -memchr (ptr,'1' , size +1 ); + kasan_ptr_result =memchr (ptr,'1' , size +1 );kfree (ptr); }
@@ -619,7 +627,7 @@ static noinline void __init kasan_memcmp(void)return ;memset (arr,0 ,sizeof (arr)); -memcmp (ptr, arr, size+1 ); + kasan_int_result =memcmp (ptr, arr, size +1 );kfree (ptr); }
@@ -642,22 +650,22 @@ static noinline void __init kasan_strings(void)* will likely point to zeroed byte. */ ptr +=16 ; -strchr (ptr,'1' ); + kasan_ptr_result =strchr (ptr,'1' );pr_info ("use-after-free in strrchr\n" ); -strrchr (ptr,'1' ); + kasan_ptr_result =strrchr (ptr,'1' );pr_info ("use-after-free in strcmp\n" ); -strcmp (ptr,"2" ); + kasan_int_result =strcmp (ptr,"2" );pr_info ("use-after-free in strncmp\n" ); -strncmp (ptr,"2" ,1 ); + kasan_int_result =strncmp (ptr,"2" ,1 );pr_info ("use-after-free in strlen\n" ); -strlen (ptr); + kasan_int_result =strlen (ptr);pr_info ("use-after-free in strnlen\n" ); -strnlen (ptr,1 ); + kasan_int_result =strnlen (ptr,1 ); } static noinline void __init kasan_bitops(void)
@@ -724,11 +732,12 @@ static noinline void __init kasan_bitops(void)__test_and_change_bit (BITS_PER_LONG +BITS_PER_BYTE , bits);pr_info ("out-of-bounds in test_bit\n" ); - (void )test_bit (BITS_PER_LONG +BITS_PER_BYTE , bits); + kasan_int_result =test_bit (BITS_PER_LONG +BITS_PER_BYTE , bits);#if defined(clear_bit_unlock_is_negative_byte)pr_info ("out-of-bounds in clear_bit_unlock_is_negative_byte\n" ); -clear_bit_unlock_is_negative_byte (BITS_PER_LONG +BITS_PER_BYTE , bits); + kasan_int_result =clear_bit_unlock_is_negative_byte (BITS_PER_LONG + +BITS_PER_BYTE , bits);#endif kfree (bits); }
Signature · 1 line
2.25.1
Greg Kroah-Hartman
maintainerPATCH 159/261 string.h: fix incompatibility between FORTIFY_SOURCE and KASAN
In reply to Greg Kroah-HartmanFrom: Daniel Axtens <[email protected]>
[ Upstream commit 47227d27e2fcb01a9e8f5958d8997cf47a820afc ]
The memcmp KASAN self-test fails on a kernel with both KASAN and FORTIFY_SOURCE.
When FORTIFY_SOURCE is on, a number of functions are replaced with fortified versions, which attempt to check the sizes of the operands. However, these functions often directly invoke __builtin_foo() once they have performed the fortify check. Using __builtins may bypass KASAN checks if the compiler decides to inline it's own implementation as sequence of instructions, rather than emit a function call that goes out to a KASAN-instrumented implementation.
Why is only memcmp affected?
============================
Of the string and string-like functions that kasan_test tests, only memcmp is replaced by an inline sequence of instructions in my testing on x86 with gcc version 9.2.1 20191008 (Ubuntu 9.2.1-9ubuntu2).
I believe this is due to compiler heuristics. For example, if I annotate kmalloc calls with the alloc_size annotation (and disable some fortify compile-time checking!), the compiler will replace every memset except the one in kmalloc_uaf_memset with inline instructions. (I have some WIP patches to add this annotation.)
Does this affect other functions in string.h?
=============================================
Yes. Anything that uses __builtin_* rather than __real_* could be affected. This looks like:
- strncpy
- strcat
- strlen
- strlcpy maybe, under some circumstances?
- strncat under some circumstances
- memset
- memcpy
- memmove
- memcmp (as noted)
- memchr
- strcpy
Whether a function call is emitted always depends on the compiler. Most bugs should get caught by FORTIFY_SOURCE, but the missed memcmp test shows that this is not always the case.
Isn't FORTIFY_SOURCE disabled with KASAN?
========================================-
The string headers on all arches supporting KASAN disable fortify with kasan, but only when address sanitisation is _also_ disabled. For example from x86:
#if defined(CONFIG_KASAN) && !defined(__SANITIZE_ADDRESS__) /*
* For files that are not instrumented (e.g. mm/slub.c) we
* should use not instrumented version of mem* functions. */
#define memcpy(dst, src, len) __memcpy(dst, src, len) #define memmove(dst, src, len) __memmove(dst, src, len) #define memset(s, c, n) __memset(s, c, n)
#ifndef __NO_FORTIFY
#define __NO_FORTIFY /* FORTIFY_SOURCE uses __builtin_memcpy, etc. */ #endif
#endif
This comes from commit 6974f0c4555e ("include/linux/string.h: add the option of fortified string.h functions"), and doesn't work when KASAN is enabled and the file is supposed to be sanitised - as with test_kasan.c
I'm pretty sure this is not wrong, but not as expansive it should be:
* we shouldn't use __builtin_memcpy etc in files where we don't have instrumentation - it could devolve into a function call to memcpy, which will be instrumented. Rather, we should use __memcpy which by convention is not instrumented.
* we also shouldn't be using __builtin_memcpy when we have a KASAN instrumented file, because it could be replaced with inline asm that will not be instrumented.
What is correct behaviour?
==========================
Firstly, there is some overlap between fortification and KASAN: both provide some level of _runtime_ checking. Only fortify provides compile-time checking.
KASAN and fortify can pick up different things at runtime:
- Some fortify functions, notably the string functions, could easily be modified to consider sub-object sizes (e.g. members within a struct), and I have some WIP patches to do this. KASAN cannot detect these because it cannot insert poision between members of a struct.
- KASAN can detect many over-reads/over-writes when the sizes of both operands are unknown, which fortify cannot.
So there are a couple of options:
1) Flip the test: disable fortify in santised files and enable it in unsanitised files. This at least stops us missing KASAN checking, but we lose the fortify checking.
2) Make the fortify code always call out to real versions. Do this only for KASAN, for fear of losing the inlining opportunities we get from __builtin_*.
(We can't use kasan_check_{read,write}: because the fortify functions are _extern inline_, you can't include _static_ inline functions without a compiler warning. kasan_check_{read,write} are static inline so we can't use them even when they would otherwise be suitable.)
Take approach 2 and call out to real versions when KASAN is enabled.
Use __underlying_foo to distinguish from __real_foo: __real_foo always refers to the kernel's implementation of foo, __underlying_foo could be either the kernel implementation or the __builtin_foo implementation.
This is sometimes enough to make the memcmp test succeed with FORTIFY_SOURCE enabled. It is at least enough to get the function call into the module. One more fix is needed to make it reliable: see the next patch.
--- include/linux/string.h | 60 +++++++++++++++++++++++++++++++++--------- 1 file changed, 48 insertions(+), 12 deletions(-)
include/linux/string.h +48 -12
@@ -269,6 +269,31 @@ void __read_overflow3(void) __compiletime_error("detected read beyond size of ob void __write_overflow(void) __compiletime_error("detected write beyond size of object passed as 1st parameter");#if !defined(__NO_FORTIFY) && defined(__OPTIMIZE__) && defined(CONFIG_FORTIFY_SOURCE ) + +#ifdef CONFIG_KASAN +extern void *__underlying_memchr (const void *p,int c,__kernel_size_t size)__RENAME (memchr); +extern int __underlying_memcmp(const void *p, const void *q, __kernel_size_t size) __RENAME(memcmp); +extern void *__underlying_memcpy (void *p,const void *q,__kernel_size_t size)__RENAME (memcpy); +extern void *__underlying_memmove (void *p,const void *q,__kernel_size_t size)__RENAME (memmove); +extern void *__underlying_memset (void *p,int c,__kernel_size_t size)__RENAME (memset); +extern char *__underlying_strcat (char *p,const char *q)__RENAME (strcat); +extern char *__underlying_strcpy (char *p,const char *q)__RENAME (strcpy); +extern __kernel_size_t __underlying_strlen(const char *p) __RENAME(strlen); +extern char *__underlying_strncat (char *p,const char *q,__kernel_size_t count)__RENAME (strncat); +extern char *__underlying_strncpy (char *p,const char *q,__kernel_size_t size)__RENAME (strncpy); +#else +#define __underlying_memchr __builtin_memchr +#define __underlying_memcmp __builtin_memcmp +#define __underlying_memcpy __builtin_memcpy +#define __underlying_memmove __builtin_memmove +#define __underlying_memset __builtin_memset +#define __underlying_strcat __builtin_strcat +#define __underlying_strcpy __builtin_strcpy +#define __underlying_strlen __builtin_strlen +#define __underlying_strncat __builtin_strncat +#define __underlying_strncpy __builtin_strncpy +#endif + __FORTIFY_INLINE char *strncpy(char *p, const char *q, __kernel_size_t size) {size_t p_size =__builtin_object_size (p,0 );
@@ -276,14 +301,14 @@ __FORTIFY_INLINE char *strncpy(char *p, const char *q, __kernel_size_t size)__write_overflow ();if (p_size < size)fortify_panic (__func__); -return __builtin_strncpy (p, q, size); +return __underlying_strncpy (p, q, size); } __FORTIFY_INLINE char *strcat(char *p, const char *q) {size_t p_size =__builtin_object_size (p,0 );if (p_size == (size_t )-1 ) -return __builtin_strcat (p, q); +return __underlying_strcat (p, q);if (strlcat (p, q, p_size) >= p_size)fortify_panic (__func__);return p;
@@ -297,7 +322,7 @@ __FORTIFY_INLINE __kernel_size_t strlen(const char *p)/* Work around gcc excess stack consumption issue */ if (p_size == (size_t )-1 || (__builtin_constant_p (p[p_size -1 ]) && p[p_size -1 ] =='\0' )) -return __builtin_strlen (p); +return __underlying_strlen (p); ret =strnlen (p, p_size);if (p_size <= ret)fortify_panic (__func__);
@@ -330,7 +355,7 @@ __FORTIFY_INLINE size_t strlcpy(char *p, const char *q, size_t size)__write_overflow ();if (len >= p_size)fortify_panic (__func__); -__builtin_memcpy (p, q, len); +__underlying_memcpy (p, q, len); p[len] ='\0' ; }return ret;
@@ -343,12 +368,12 @@ __FORTIFY_INLINE char *strncat(char *p, const char *q, __kernel_size_t count)size_t p_size =__builtin_object_size (p,0 );size_t q_size =__builtin_object_size (q,0 );if (p_size == (size_t )-1 && q_size == (size_t )-1 ) -return __builtin_strncat (p, q, count); +return __underlying_strncat (p, q, count); p_len =strlen (p); copy_len =strnlen (q, count);if (p_size < p_len + copy_len +1 )fortify_panic (__func__); -__builtin_memcpy (p + p_len, q, copy_len); +__underlying_memcpy (p + p_len, q, copy_len); p[p_len + copy_len] ='\0' ;return p; }
@@ -360,7 +385,7 @@ __FORTIFY_INLINE void *memset(void *p, int c, __kernel_size_t size)__write_overflow ();if (p_size < size)fortify_panic (__func__); -return __builtin_memset (p, c, size); +return __underlying_memset (p, c, size); } __FORTIFY_INLINE void *memcpy(void *p, const void *q, __kernel_size_t size)
@@ -375,7 +400,7 @@ __FORTIFY_INLINE void *memcpy(void *p, const void *q, __kernel_size_t size) }if (p_size < size || q_size < size)fortify_panic (__func__); -return __builtin_memcpy (p, q, size); +return __underlying_memcpy (p, q, size); } __FORTIFY_INLINE void *memmove(void *p, const void *q, __kernel_size_t size)
@@ -390,7 +415,7 @@ __FORTIFY_INLINE void *memmove(void *p, const void *q, __kernel_size_t size) }if (p_size < size || q_size < size)fortify_panic (__func__); -return __builtin_memmove (p, q, size); +return __underlying_memmove (p, q, size); }extern void *__real_memscan (void *,int ,__kernel_size_t )__RENAME (memscan);
@@ -416,7 +441,7 @@ __FORTIFY_INLINE int memcmp(const void *p, const void *q, __kernel_size_t size) }if (p_size < size || q_size < size)fortify_panic (__func__); -return __builtin_memcmp (p, q, size); +return __underlying_memcmp (p, q, size); } __FORTIFY_INLINE void *memchr(const void *p, int c, __kernel_size_t size)
@@ -426,7 +451,7 @@ __FORTIFY_INLINE void *memchr(const void *p, int c, __kernel_size_t size)__read_overflow ();if (p_size < size)fortify_panic (__func__); -return __builtin_memchr (p, c, size); +return __underlying_memchr (p, c, size); }void *__real_memchr_inv (const void *s,int c,size_t n)__RENAME (memchr_inv);
@@ -457,11 +482,22 @@ __FORTIFY_INLINE char *strcpy(char *p, const char *q)size_t p_size =__builtin_object_size (p,0 );size_t q_size =__builtin_object_size (q,0 );if (p_size == (size_t )-1 && q_size == (size_t )-1 ) -return __builtin_strcpy (p, q); +return __underlying_strcpy (p, q);memcpy (p, q,strlen (q) +1 ); return p; } +/* Don't use these outside the FORITFY_SOURCE implementation */ +#undef __underlying_memchr +#undef __underlying_memcmp +#undef __underlying_memcpy +#undef __underlying_memmove +#undef __underlying_memset +#undef __underlying_strcat +#undef __underlying_strcpy +#undef __underlying_strlen +#undef __underlying_strncat +#undef __underlying_strncpy#endif /**
Signature · 1 line
2.25.1
Greg Kroah-Hartman
maintainerPATCH 160/261 btrfs: free alien device after device add
In reply to Greg Kroah-HartmanFrom: Anand Jain <[email protected]>
commit 7f551d969037cc128eca60688d9c5a300d84e665 upstream.
When an old device has new fsid through 'btrfs device add -f <dev>' our fs_devices list has an alien device in one of the fs_devices lists.
By having an alien device in fs_devices, we have two issues so far
1. missing device does not not show as missing in the userland
2. degraded mount will fail
Both issues are caused by the fact that there's an alien device in the fs_devices list. (Alien means that it does not belong to the filesystem, identified by fsid, or does not contain btrfs filesystem at all, eg. due to overwrite).
A device can be scanned/added through the control device ioctls SCAN_DEV, DEVICES_READY or by ADD_DEV.
And device coming through the control device is checked against the all other devices in the lists, but this was not the case for ADD_DEV.
This patch fixes both issues above by removing the alien device.
--- fs/btrfs/volumes.c | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-)
fs/btrfs/volumes.c +11 -1
@@ -2769,8 +2769,18 @@ int btrfs_init_new_device(struct btrfs_f ret =btrfs_commit_transaction (trans); } -/* Update ctime/mtime for libblkid */ +/* +* Now that we have written a new super block to this device, check all +* other fs_devices list if device_path alienates any other scanned +* device. +* We can ignore the return value as it typically returns -EINVAL and +* only succeeds if the device was an alien. +*/ +btrfs_forget_devices (device_path); + +/* Update ctime/mtime for blkid or udev */ update_dev_time (device_path); +return ret; error_sysfs:
Greg Kroah-Hartman
maintainerPATCH 161/261 btrfs: include non-missing as a qualifier for the latest_bdev
In reply to Greg Kroah-HartmanFrom: Anand Jain <[email protected]>
commit 998a0671961f66e9fad4990ed75f80ba3088c2f1 upstream.
btrfs_free_extra_devids() updates fs_devices::latest_bdev to point to the bdev with greatest device::generation number. For a typical-missing device the generation number is zero so fs_devices::latest_bdev will never point to it.
But if the missing device is due to alienation [1], then device::generation is not zero and if it is greater or equal to the rest of device generations in the list, then fs_devices::latest_bdev ends up pointing to the missing device and reports the error like [2].
[1] We maintain devices of a fsid (as in fs_device::fsid) in the fs_devices::devices list, a device is considered as an alien device if its fsid does not match with the fs_device::fsid
Consider a working filesystem with raid1:
$ mkfs.btrfs -f -d raid1 -m raid1 /dev/sda /dev/sdb $ mount /dev/sda /mnt-raid1 $ umount /mnt-raid1
While mnt-raid1 was unmounted the user force-adds one of its devices to another btrfs filesystem:
$ mkfs.btrfs -f /dev/sdc $ mount /dev/sdc /mnt-single $ btrfs dev add -f /dev/sda /mnt-single
Now the original mnt-raid1 fails to mount in degraded mode, because fs_devices::latest_bdev is pointing to the alien device.
$ mount -o degraded /dev/sdb /mnt-raid1
[2]
mount: wrong fs type, bad option, bad superblock on /dev/sdb,
missing codepage or helper program, or other error
In some cases useful info is found in syslog - try dmesg | tail or so.
kernel: BTRFS warning (device sdb): devid 1 uuid 072a0192-675b-4d5a-8640-a5cf2b2c704d is missing
kernel: BTRFS error (device sdb): failed to read devices
kernel: BTRFS error (device sdb): open_ctree failed
Fix the root cause by checking if the device is not missing before it can be considered for the fs_devices::latest_bdev.
--- fs/btrfs/volumes.c | 2 ++ 1 file changed, 2 insertions(+)
fs/btrfs/volumes.c +2 -0
@@ -1223,6 +1223,8 @@ again: &device->dev_state)) {if (!test_bit (BTRFS_DEV_STATE_REPLACE_TGT , &device->dev_state) && + !test_bit (BTRFS_DEV_STATE_MISSING , + &device->dev_state) && (!latest_dev || device->generation > latest_dev->generation)) { latest_dev = device;
Greg Kroah-Hartman
maintainerPATCH 162/261 btrfs: send: emit file capabilities after chown
In reply to Greg Kroah-HartmanFrom: Marcos Paulo de Souza <[email protected]>
commit 89efda52e6b6930f80f5adda9c3c9edfb1397191 upstream.
Whenever a chown is executed, all capabilities of the file being touched are lost. When doing incremental send with a file with capabilities, there is a situation where the capability can be lost on the receiving side. The sequence of actions bellow shows the problem:
$ mount /dev/sda fs1 $ mount /dev/sdb fs2
$ touch fs1/foo.bar $ setcap cap_sys_nice+ep fs1/foo.bar $ btrfs subvolume snapshot -r fs1 fs1/snap_init $ btrfs send fs1/snap_init | btrfs receive fs2
$ chgrp adm fs1/foo.bar $ setcap cap_sys_nice+ep fs1/foo.bar
$ btrfs subvolume snapshot -r fs1 fs1/snap_complete $ btrfs subvolume snapshot -r fs1 fs1/snap_incremental
$ btrfs send fs1/snap_complete | btrfs receive fs2 $ btrfs send -p fs1/snap_init fs1/snap_incremental | btrfs receive fs2
At this point, only a chown was emitted by "btrfs send" since only the group was changed. This makes the cap_sys_nice capability to be dropped from fs2/snap_incremental/foo.bar
To fix that, only emit capabilities after chown is emitted. The current code first checks for xattrs that are new/changed, emits them, and later emit the chown. Now, __process_new_xattr skips capabilities, letting only finish_inode_if_needed to emit them, if they exist, for the inode being processed.
This behavior was being worked around in "btrfs receive" side by caching the capability and only applying it after chown. Now, xattrs are only emmited _after_ chown, making that workaround not needed anymore.
--- fs/btrfs/send.c | 67 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 67 insertions(+)
fs/btrfs/send.c +67 -0
@@ -23,6 +23,7 @@#include "btrfs_inode.h" #include "transaction.h" #include "compression.h" +#include "xattr.h" /* * Maximum number of references an extent can have in order for us to attempt to
@@ -4536,6 +4537,10 @@ static int __process_new_xattr(int num,struct fs_path *p;struct posix_acl_xattr_header dummy_acl; +/* Capabilities are emitted by finish_inode_if_needed */ +if (!strncmp (name,XATTR_NAME_CAPS , name_len)) +return 0 ; + p =fs_path_alloc ();if (!p)return -ENOMEM ;
@@ -5098,6 +5103,64 @@ static int send_extent_data(struct send_return 0 ; } +/* +* Search for a capability xattr related to sctx->cur_ino. If the capability is +* found, call send_set_xattr function to emit it. +* +* Return 0 if there isn't a capability, or when the capability was emitted +* successfully, or < 0 if an error occurred. +*/ +static int send_capabilities (struct send_ctx *sctx) +{ +struct fs_path *fspath =NULL ; +struct btrfs_path *path; +struct btrfs_dir_item *di; +struct extent_buffer *leaf; +unsigned long data_ptr; +char *buf =NULL ; +int buf_len; +int ret =0 ; + + path =alloc_path_for_send (); +if (!path) +return -ENOMEM ; + + di =btrfs_lookup_xattr (NULL , sctx->send_root, path, sctx->cur_ino, +XATTR_NAME_CAPS ,strlen (XATTR_NAME_CAPS ),0 ); +if (!di) { +/* There is no xattr for this inode */ + goto out; + }else if (IS_ERR (di)) { + ret =PTR_ERR (di); + goto out; + } + + leaf = path->nodes[0 ]; + buf_len =btrfs_dir_data_len (leaf, di); + + fspath =fs_path_alloc (); + buf =kmalloc (buf_len,GFP_KERNEL ); +if (!fspath || !buf) { + ret = -ENOMEM ; + goto out; + } + + ret =get_cur_path (sctx, sctx->cur_ino, sctx->cur_inode_gen, fspath); +if (ret <0 ) + goto out; + + data_ptr = (unsigned long )(di +1 ) +btrfs_dir_name_len (leaf, di); +read_extent_buffer (leaf, buf, data_ptr, buf_len); + + ret =send_set_xattr (sctx, fspath,XATTR_NAME_CAPS , +strlen (XATTR_NAME_CAPS ), buf, buf_len); +out: +kfree (buf); +fs_path_free (fspath); +btrfs_free_path (path); +return ret; +} + static int clone_range(struct send_ctx *sctx, struct clone_root *clone_root, const u64 disk_byte,
@@ -6001,6 +6064,10 @@ static int finish_inode_if_needed(struct goto out; } + ret =send_capabilities (sctx); +if (ret <0 ) + goto out; +/* * If other directory inodes depended on our current directory * inode's move/rename, now do their move/rename operations.
Greg Kroah-Hartman
maintainerPATCH 163/261 btrfs: force chunk allocation if our global rsv is larger than metadata
In reply to Greg Kroah-HartmanFrom: Josef Bacik <[email protected]>
commit 9c343784c4328781129bcf9e671645f69fe4b38a upstream.
Nikolay noticed a bunch of test failures with my global rsv steal patches. At first he thought they were introduced by them, but they've been failing for a while with 64k nodes.
The problem is with 64k nodes we have a global reserve that calculates out to 13MiB on a freshly made file system, which only has 8MiB of metadata space. Because of changes I previously made we no longer account for the global reserve in the overcommit logic, which means we correctly allow overcommit to happen even though we are already overcommitted.
However in some corner cases, for example btrfs/170, we will allocate the entire file system up with data chunks before we have enough space pressure to allocate a metadata chunk. Then once the fs is full we ENOSPC out because we cannot overcommit and the global reserve is taking up all of the available space.
The most ideal way to deal with this is to change our space reservation stuff to take into account the height of the tree's that we're modifying, so that our global reserve calculation does not end up so obscenely large.
However that is a huge undertaking. Instead fix this by forcing a chunk allocation if the global reserve is larger than the total metadata space. This gives us essentially the same behavior that happened before, we get a chunk allocated and these tests can pass.
This is meant to be a stop-gap measure until we can tackle the "tree height only" project.
--- fs/btrfs/block-rsv.c | 3 +++ fs/btrfs/transaction.c | 18 ++++++++++++++++++ 2 files changed, 21 insertions(+)
fs/btrfs/block-rsv.c +3 -0
@@ -5,6 +5,7 @@#include "block-rsv.h" #include "space-info.h" #include "transaction.h" +#include "block-group.h" static u64 block_rsv_release_bytes(struct btrfs_fs_info *fs_info, struct btrfs_block_rsv *block_rsv,
@@ -313,6 +314,8 @@ void btrfs_update_global_block_rsv(strucelse block_rsv->full =0 ; +if (block_rsv->size >= sinfo->total_bytes) + sinfo->force_alloc =CHUNK_ALLOC_FORCE ;spin_unlock (&block_rsv->lock);spin_unlock (&sinfo->lock); }
fs/btrfs/transaction.c +18 -0
@@ -21,6 +21,7 @@#include "dev-replace.h" #include "qgroup.h" #include "block-group.h" +#include "space-info.h" #define BTRFS_ROOT_TRANS_TAG 0
@@ -451,6 +452,7 @@ start_transaction(struct btrfs_root *roou64 num_bytes =0 ;u64 qgroup_reserved =0 ;bool reloc_reserved = false; +bool do_chunk_alloc = false;int ret;/* Send isn't supposed to start transactions. */
@@ -513,6 +515,9 @@ start_transaction(struct btrfs_root *roo delayed_refs_bytes); num_bytes -= delayed_refs_bytes; } + +if (rsv->space_info->force_alloc) + do_chunk_alloc = true; }else if (num_items ==0 && flush ==BTRFS_RESERVE_FLUSH_ALL && !delayed_refs_rsv->full) {/*
@@ -595,6 +600,19 @@ got_it: current->journal_info = h;/* +* If the space_info is marked ALLOC_FORCE then we'll get upgraded to +* ALLOC_FORCE the first run through, and then we won't allocate for +* anybody else who races in later. We don't care about the return +* value here. +*/ +if (do_chunk_alloc && num_bytes) { +u64 flags = h->block_rsv->space_info->flags; + +btrfs_chunk_alloc (h,btrfs_get_alloc_profile (fs_info, flags), +CHUNK_ALLOC_NO_FORCE ); + } + +/* * btrfs_record_root_in_trans() needs to alloc new extents, and may * call btrfs_join_transaction() while we're also starting a * transaction.
Greg Kroah-Hartman
maintainerPATCH 164/261 btrfs: fix error handling when submitting direct I/O bio
In reply to Greg Kroah-HartmanFrom: Omar Sandoval <[email protected]>
commit 6d3113a193e3385c72240096fe397618ecab6e43 upstream.
In btrfs_submit_direct_hook(), if a direct I/O write doesn't span a RAID stripe or chunk, we submit orig_bio without cloning it. In this case, we don't increment pending_bios. Then, if btrfs_submit_dio_bio() fails, we decrement pending_bios to -1, and we never complete orig_bio. Fix it by initializing pending_bios to 1 instead of incrementing later.
Fixing this exposes another bug: we put orig_bio prematurely and then put it again from end_io. Fix it by not putting orig_bio.
After this change, pending_bios is really more of a reference count, but I'll leave that cleanup separate to keep the fix small.
--- fs/btrfs/inode.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
fs/btrfs/inode.c +3 -3
@@ -8534,7 +8534,6 @@ static int btrfs_submit_direct_hook(stru/* bio split */ ASSERT (geom.len <=INT_MAX ); -atomic_inc (&dip->pending_bios); do { clone_len = min_t(int, submit_len, geom.len);
@@ -8584,7 +8583,8 @@ submit:if (!status)return 0 ; -bio_put (bio); +if (bio != orig_bio) +bio_put (bio); out_err: dip->errors =1 ;/*
@@ -8625,7 +8625,7 @@ static void btrfs_submit_direct(struct b bio->bi_private = dip; dip->orig_bio = bio; dip->dio_bio = dio_bio; -atomic_set (&dip->pending_bios,0 ); +atomic_set (&dip->pending_bios,1 ); io_bio =btrfs_io_bio (bio); io_bio->logical = file_offset;
Greg Kroah-Hartman
maintainerPATCH 165/261 btrfs: fix wrong file range cleanup after an error filling dealloc range
In reply to Greg Kroah-HartmanFrom: Filipe Manana <[email protected]>
commit e2c8e92d1140754073ad3799eb6620c76bab2078 upstream.
If an error happens while running dellaloc in COW mode for a range, we can end up calling extent_clear_unlock_delalloc() for a range that goes beyond our range's end offset by 1 byte, which affects 1 extra page. This results in clearing bits and doing page operations (such as a page unlock) outside our target range.
Fix that by calling extent_clear_unlock_delalloc() with an inclusive end offset, instead of an exclusive end offset, at cow_file_range().
--- fs/btrfs/inode.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
fs/btrfs/inode.c +1 -1
@@ -1132,7 +1132,7 @@ out_unlock:*/ if (extent_reserved) {extent_clear_unlock_delalloc (inode, start, - start + cur_alloc_size, + start + cur_alloc_size -1 , locked_page, clear_bits, page_ops);
Greg Kroah-Hartman
maintainerPATCH 166/261 btrfs: fix space_info bytes_may_use underflow after nocow buffered write
In reply to Greg Kroah-HartmanFrom: Filipe Manana <[email protected]>
commit 467dc47ea99c56e966e99d09dae54869850abeeb upstream.
When doing a buffered write we always try to reserve data space for it, even when the file has the NOCOW bit set or the write falls into a file range covered by a prealloc extent. This is done both because it is expensive to check if we can do a nocow write (checking if an extent is shared through reflinks or if there's a hole in the range for example), and because when writeback starts we might actually need to fallback to COW mode (for example the block group containing the target extents was turned into RO mode due to a scrub or balance).
When we are unable to reserve data space we check if we can do a nocow write, and if we can, we proceed with dirtying the pages and setting up the range for delalloc. In this case the bytes_may_use counter of the data space_info object is not incremented, unlike in the case where we are able to reserve data space (done through btrfs_check_data_free_space() which calls btrfs_alloc_data_chunk_ondemand()).
Later when running delalloc we attempt to start writeback in nocow mode but we might revert back to cow mode, for example because in the meanwhile a block group was turned into RO mode by a scrub or relocation. The cow path after successfully allocating an extent ends up calling btrfs_add_reserved_bytes(), which expects the bytes_may_use counter of the data space_info object to have been incremented before - but we did not do it when the buffered write started, since there was not enough available data space. So btrfs_add_reserved_bytes() ends up decrementing the bytes_may_use counter anyway, and when the counter's current value is smaller then the size of the allocated extent we get a stack trace like the following:
------------[ cut here ]------------ WARNING: CPU: 0 PID: 20138 at fs/btrfs/space-info.h:115 btrfs_add_reserved_bytes+0x3d6/0x4e0 [btrfs] Modules linked in: btrfs blake2b_generic xor raid6_pq libcrc32c (...) CPU: 0 PID: 20138 Comm: kworker/u8:15 Not tainted 5.6.0-rc7-btrfs-next-58 #5 Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS rel-1.12.0-59-gc9ba5276e321-prebuilt.qemu.org 04/01/2014 Workqueue: writeback wb_workfn (flush-btrfs-1754) RIP: 0010:btrfs_add_reserved_bytes+0x3d6/0x4e0 [btrfs] Code: ff ff 48 (...) RSP: 0018:ffffbda18a4b3568 EFLAGS: 00010287 RAX: 0000000000000000 RBX: ffff9ca076f5d800 RCX: 0000000000000000 RDX: 0000000000000002 RSI: 0000000000000000 RDI: ffff9ca068470410 RBP: fffffffffffff000 R08: 0000000000000001 R09: 0000000000000000 R10: ffff9ca079d58040 R11: 0000000000000000 R12: ffff9ca068470400 R13: ffff9ca0408b2000 R14: 0000000000001000 R15: ffff9ca076f5d800 FS: 0000000000000000(0000) GS:ffff9ca07a600000(0000) knlGS:0000000000000000 CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 CR2: 00005605dbfe7048 CR3: 0000000138570006 CR4: 00000000003606f0 DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000 DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400 Call Trace: find_free_extent+0x4a0/0x16c0 [btrfs] btrfs_reserve_extent+0x91/0x180 [btrfs] cow_file_range+0x12d/0x490 [btrfs] run_delalloc_nocow+0x341/0xa40 [btrfs] btrfs_run_delalloc_range+0x1ea/0x6d0 [btrfs] ? find_lock_delalloc_range+0x221/0x250 [btrfs] writepage_delalloc+0xe8/0x150 [btrfs] __extent_writepage+0xe8/0x4c0 [btrfs] extent_write_cache_pages+0x237/0x530 [btrfs] ? btrfs_wq_submit_bio+0x9f/0xc0 [btrfs] extent_writepages+0x44/0xa0 [btrfs] do_writepages+0x23/0x80 __writeback_single_inode+0x59/0x700 writeback_sb_inodes+0x267/0x5f0 __writeback_inodes_wb+0x87/0xe0 wb_writeback+0x382/0x590 ? wb_workfn+0x4a2/0x6c0 wb_workfn+0x4a2/0x6c0 process_one_work+0x26d/0x6a0 worker_thread+0x4f/0x3e0 ? process_one_work+0x6a0/0x6a0 kthread+0x103/0x140 ? kthread_create_worker_on_cpu+0x70/0x70 ret_from_fork+0x3a/0x50 irq event stamp: 0 hardirqs last enabled at (0): [<0000000000000000>] 0x0 hardirqs last disabled at (0): [<ffffffff94ebdedf>] copy_process+0x74f/0x2020 softirqs last enabled at (0): [<ffffffff94ebdedf>] copy_process+0x74f/0x2020 softirqs last disabled at (0): [<0000000000000000>] 0x0 ---[ end trace f9f6ef8ec4cd8ec9 ]---
So to fix this, when falling back into cow mode check if space was not reserved, by testing for the bit EXTENT_NORESERVE in the respective file range, and if not, increment the bytes_may_use counter for the data space_info object. Also clear the EXTENT_NORESERVE bit from the range, so that if the cow path fails it decrements the bytes_may_use counter when clearing the delalloc range (through the btrfs_clear_delalloc_extent() callback).
--- fs/btrfs/inode.c | 61 ++++++++++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 56 insertions(+), 5 deletions(-)
fs/btrfs/inode.c +56 -5
@@ -49,6 +49,7 @@#include "qgroup.h" #include "delalloc-space.h" #include "block-group.h" +#include "space-info.h" struct btrfs_iget_args {struct btrfs_key *location;
@@ -1322,6 +1323,56 @@ static noinline int csum_exist_in_range(return 1 ; } +static int fallback_to_cow (struct inode *inode,struct page *locked_page, +const u64 start,const u64 end, +int *page_started,unsigned long *nr_written) +{ +struct extent_io_tree *io_tree = &BTRFS_I (inode)->io_tree; +u64 range_start = start; +u64 count; + +/* +* If EXTENT_NORESERVE is set it means that when the buffered write was +* made we had not enough available data space and therefore we did not +* reserve data space for it, since we though we could do NOCOW for the +* respective file range (either there is prealloc extent or the inode +* has the NOCOW bit set). +* +* However when we need to fallback to COW mode (because for example the +* block group for the corresponding extent was turned to RO mode by a +* scrub or relocation) we need to do the following: +* +* 1) We increment the bytes_may_use counter of the data space info. +* If COW succeeds, it allocates a new data extent and after doing +* that it decrements the space info's bytes_may_use counter and +* increments its bytes_reserved counter by the same amount (we do +* this at btrfs_add_reserved_bytes()). So we need to increment the +* bytes_may_use counter to compensate (when space is reserved at +* buffered write time, the bytes_may_use counter is incremented); +* +* 2) We clear the EXTENT_NORESERVE bit from the range. We do this so +* that if the COW path fails for any reason, it decrements (through +* extent_clear_unlock_delalloc()) the bytes_may_use counter of the +* data space info, which we incremented in the step above. +*/ + count =count_range_bits (io_tree, &range_start, end, end +1 - start, +EXTENT_NORESERVE ,0 ); +if (count >0 ) { +struct btrfs_fs_info *fs_info =BTRFS_I (inode)->root->fs_info; +struct btrfs_space_info *sinfo = fs_info->data_sinfo; + +spin_lock (&sinfo->lock); +btrfs_space_info_update_bytes_may_use (fs_info, sinfo, count); +spin_unlock (&sinfo->lock); + +clear_extent_bit (io_tree, start, end,EXTENT_NORESERVE ,0 ,0 , +NULL ); + } + +return cow_file_range (inode, locked_page, start, end, page_started, + nr_written,1 ); +} +/* * when nowcow writeback call back. This checks for snapshots or COW copies * of the extents that exist in the file, and COWs the file as required.
@@ -1569,9 +1620,9 @@ out_check:* NOCOW, following one which needs to be COW'ed */ if (cow_start != (u64)-1 ) { - ret =cow_file_range (inode, locked_page, - cow_start, found_key.offset -1 , - page_started, nr_written,1 ); + ret =fallback_to_cow (inode, locked_page, cow_start, + found_key.offset -1 , + page_started, nr_written);if (ret) {if (nocow) btrfs_dec_nocow_writers(fs_info,
@@ -1660,8 +1711,8 @@ out_check:if (cow_start != (u64)-1 ) { cur_offset = end; - ret =cow_file_range (inode, locked_page, cow_start, end, - page_started, nr_written,1 ); + ret =fallback_to_cow (inode, locked_page, cow_start, end, + page_started, nr_written);if (ret) goto error; }
Greg Kroah-Hartman
maintainerPATCH 167/261 btrfs: fix space_info bytes_may_use underflow during space cache writeout
In reply to Greg Kroah-HartmanFrom: Filipe Manana <[email protected]>
commit 2166e5edce9ac1edf3b113d6091ef72fcac2d6c4 upstream.
We always preallocate a data extent for writing a free space cache, which causes writeback to always try the nocow path first, since the free space inode has the prealloc bit set in its flags.
However if the block group that contains the data extent for the space cache has been turned to RO mode due to a running scrub or balance for example, we have to fallback to the cow path. In that case once a new data extent is allocated we end up calling btrfs_add_reserved_bytes(), which decrements the counter named bytes_may_use from the data space_info object with the expection that this counter was previously incremented with the same amount (the size of the data extent).
However when we started writeout of the space cache at cache_save_setup(), we incremented the value of the bytes_may_use counter through a call to btrfs_check_data_free_space() and then decremented it through a call to btrfs_prealloc_file_range_trans() immediately after. So when starting the writeback if we fallback to cow mode we have to increment the counter bytes_may_use of the data space_info again to compensate for the extent allocation done by the cow path.
When this issue happens we are incorrectly decrementing the bytes_may_use counter and when its current value is smaller then the amount we try to subtract we end up with the following warning:
------------[ cut here ]------------ WARNING: CPU: 3 PID: 657 at fs/btrfs/space-info.h:115 btrfs_add_reserved_bytes+0x3d6/0x4e0 [btrfs] Modules linked in: btrfs blake2b_generic xor raid6_pq libcrc32c (...) CPU: 3 PID: 657 Comm: kworker/u8:7 Tainted: G W 5.6.0-rc7-btrfs-next-58 #5 Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS rel-1.12.0-59-gc9ba5276e321-prebuilt.qemu.org 04/01/2014 Workqueue: writeback wb_workfn (flush-btrfs-1591) RIP: 0010:btrfs_add_reserved_bytes+0x3d6/0x4e0 [btrfs] Code: ff ff 48 (...) RSP: 0000:ffffa41608f13660 EFLAGS: 00010287 RAX: 0000000000001000 RBX: ffff9615b93ae400 RCX: 0000000000000000 RDX: 0000000000000002 RSI: 0000000000000000 RDI: ffff9615b96ab410 RBP: fffffffffffee000 R08: 0000000000000001 R09: 0000000000000000 R10: ffff961585e62a40 R11: 0000000000000000 R12: ffff9615b96ab400 R13: ffff9615a1a2a000 R14: 0000000000012000 R15: ffff9615b93ae400 FS: 0000000000000000(0000) GS:ffff9615bb200000(0000) knlGS:0000000000000000 CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 CR2: 000055cbbc2ae178 CR3: 0000000115794006 CR4: 00000000003606e0 DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000 DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400 Call Trace: find_free_extent+0x4a0/0x16c0 [btrfs] btrfs_reserve_extent+0x91/0x180 [btrfs] cow_file_range+0x12d/0x490 [btrfs] btrfs_run_delalloc_range+0x9f/0x6d0 [btrfs] ? find_lock_delalloc_range+0x221/0x250 [btrfs] writepage_delalloc+0xe8/0x150 [btrfs] __extent_writepage+0xe8/0x4c0 [btrfs] extent_write_cache_pages+0x237/0x530 [btrfs] extent_writepages+0x44/0xa0 [btrfs] do_writepages+0x23/0x80 __writeback_single_inode+0x59/0x700 writeback_sb_inodes+0x267/0x5f0 __writeback_inodes_wb+0x87/0xe0 wb_writeback+0x382/0x590 ? wb_workfn+0x4a2/0x6c0 wb_workfn+0x4a2/0x6c0 process_one_work+0x26d/0x6a0 worker_thread+0x4f/0x3e0 ? process_one_work+0x6a0/0x6a0 kthread+0x103/0x140 ? kthread_create_worker_on_cpu+0x70/0x70 ret_from_fork+0x3a/0x50 irq event stamp: 0 hardirqs last enabled at (0): [<0000000000000000>] 0x0 hardirqs last disabled at (0): [<ffffffffb2abdedf>] copy_process+0x74f/0x2020 softirqs last enabled at (0): [<ffffffffb2abdedf>] copy_process+0x74f/0x2020 softirqs last disabled at (0): [<0000000000000000>] 0x0 ---[ end trace bd7c03622e0b0a52 ]--- ------------[ cut here ]------------
So fix this by incrementing the bytes_may_use counter of the data space_info when we fallback to the cow path. If the cow path is successful the counter is decremented after extent allocation (by btrfs_add_reserved_bytes()), if it fails it ends up being decremented as well when clearing the delalloc range (extent_clear_unlock_delalloc()).
This could be triggered sporadically by the test case btrfs/061 from fstests.
--- fs/btrfs/inode.c | 20 +++++++++++++++----- 1 file changed, 15 insertions(+), 5 deletions(-)
fs/btrfs/inode.c +15 -5
@@ -1327,6 +1327,8 @@ static int fallback_to_cow(struct inode const u64 start, const u64 end, int *page_started, unsigned long *nr_written) { + const bool is_space_ino = btrfs_is_free_space_inode(BTRFS_I(inode)); +const u64 range_bytes = end +1 - start;struct extent_io_tree *io_tree = &BTRFS_I (inode)->io_tree;u64 range_start = start;u64 count;
@@ -1354,19 +1356,27 @@ static int fallback_to_cow(struct inode* that if the COW path fails for any reason, it decrements (through * extent_clear_unlock_delalloc()) the bytes_may_use counter of the * data space info, which we incremented in the step above. +* +* If we need to fallback to cow and the inode corresponds to a free +* space cache inode, we must also increment bytes_may_use of the data +* space_info for the same reason. Space caches always get a prealloc +* extent for them, however scrub or balance may have set the block +* group that contains that extent to RO mode. */ - count =count_range_bits (io_tree, &range_start, end, end +1 - start, + count =count_range_bits (io_tree, &range_start, end, range_bytes,EXTENT_NORESERVE ,0 ); -if (count >0 ) { +if (count >0 || is_space_ino) { +const u64 bytes = is_space_ino ? range_bytes : count;struct btrfs_fs_info *fs_info =BTRFS_I (inode)->root->fs_info;struct btrfs_space_info *sinfo = fs_info->data_sinfo;spin_lock (&sinfo->lock); -btrfs_space_info_update_bytes_may_use (fs_info, sinfo, count); +btrfs_space_info_update_bytes_may_use (fs_info, sinfo, bytes);spin_unlock (&sinfo->lock); -clear_extent_bit (io_tree, start, end,EXTENT_NORESERVE ,0 ,0 , -NULL ); +if (count >0 ) +clear_extent_bit (io_tree, start, end,EXTENT_NORESERVE , +0 ,0 ,NULL ); } return cow_file_range(inode, locked_page, start, end, page_started,
Greg Kroah-Hartman
maintainerPATCH 168/261 powerpc/mm: Fix conditions to perform MMU specific management by blocks on PPC32.
In reply to Greg Kroah-HartmanFrom: Christophe Leroy <[email protected]>
commit 4e3319c23a66dabfd6c35f4d2633d64d99b68096 upstream.
Setting init mem to NX shall depend on sinittext being mapped by block, not on stext being mapped by block.
Setting text and rodata to RO shall depend on stext being mapped by block, not on sinittext being mapped by block.
--- arch/powerpc/mm/pgtable_32.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
arch/powerpc/mm/pgtable_32.c +2 -2
@@ -207,7 +207,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 )_sinittext))mmu_mark_initmem_nx ();else change_page_attr (page, numpages,PAGE_KERNEL );
@@ -219,7 +219,7 @@ void mark_rodata_ro(void)struct page *page;unsigned long numpages; -if (v_block_mapped ((unsigned long )_sinittext)) { +if (v_block_mapped ((unsigned long )_stext +1 )) {mmu_mark_rodata_ro ();ptdump_check_wx ();return ;
Greg Kroah-Hartman
maintainerPATCH 169/261 mm: thp: make the THP mapcount atomic against __split_huge_pmd_locked()
In reply to Greg Kroah-HartmanFrom: Andrea Arcangeli <[email protected]>
commit c444eb564fb16645c172d550359cb3d75fe8a040 upstream.
Write protect anon page faults require an accurate mapcount to decide if to break the COW or not. This is implemented in the THP path with reuse_swap_page() -> page_trans_huge_map_swapcount()/page_trans_huge_mapcount().
If the COW triggers while the other processes sharing the page are under a huge pmd split, to do an accurate reading, we must ensure the mapcount isn't computed while it's being transferred from the head page to the tail pages.
reuse_swap_cache() already runs serialized by the page lock, so it's enough to add the page lock around __split_huge_pmd_locked too, in order to add the missing serialization.
Note: the commit in "Fixes" is just to facilitate the backporting, because the code before such commit didn't try to do an accurate THP mapcount calculation and it instead used the page_count() to decide if to COW or not. Both the page_count and the pin_count are THP-wide refcounts, so they're inaccurate if used in reuse_swap_page(). Reverting such commit (besides the unrelated fix to the local anon_vma assignment) would have also opened the window for memory corruption side effects to certain workloads as documented in such commit header.
--- mm/huge_memory.c | 31 ++++++++++++++++++++++++++++--- 1 file changed, 28 insertions(+), 3 deletions(-)
mm/huge_memory.c +28 -3
@@ -2301,6 +2301,8 @@ void __split_huge_pmd(struct vm_area_str {spinlock_t *ptl;struct mmu_notifier_range range; +bool was_locked = false; +pmd_t _pmd; mmu_notifier_range_init(&range, MMU_NOTIFY_CLEAR, 0, vma, vma->vm_mm, address & HPAGE_PMD_MASK,
@@ -2313,11 +2315,32 @@ void __split_huge_pmd(struct vm_area_str* pmd against. Otherwise we can end up replacing wrong page. */ VM_BUG_ON (freeze && !page); -if (page && page !=pmd_page (*pmd)) - goto out; +if (page) { +VM_WARN_ON_ONCE (!PageLocked (page)); + was_locked = true; +if (page !=pmd_page (*pmd)) + goto out; + } +repeat:if (pmd_trans_huge (*pmd)) { - page =pmd_page (*pmd); +if (!page) { + page =pmd_page (*pmd); +if (unlikely (!trylock_page (page))) { +get_page (page); + _pmd = *pmd; +spin_unlock (ptl); +lock_page (page); +spin_lock (ptl); +if (unlikely (!pmd_same (*pmd, _pmd))) { +unlock_page (page); +put_page (page); + page =NULL ; + goto repeat; + } +put_page (page); + } + }if (PageMlocked (page))clear_page_mlock (page); }else if (!(pmd_devmap (*pmd) ||is_pmd_migration_entry (*pmd)))
@@ -2325,6 +2348,8 @@ void __split_huge_pmd(struct vm_area_str__split_huge_pmd_locked (vma, pmd, range.start, freeze); out:spin_unlock (ptl); +if (!was_locked && page) +unlock_page (page);/* * No need to double call mmu_notifier->invalidate_range() callback. * They are 3 cases to consider inside __split_huge_pmd_locked():
Greg Kroah-Hartman
maintainerPATCH 170/261 mm: initialize deferred pages with interrupts enabled
In reply to Greg Kroah-HartmanFrom: Pavel Tatashin <[email protected]>
commit 3d060856adfc59afb9d029c233141334cfaba418 upstream.
Initializing struct pages is a long task and keeping interrupts disabled for the duration of this operation introduces a number of problems.
1. jiffies are not updated for long period of time, and thus incorrect time is reported. See proposed solution and discussion here:
lkml/[email protected]
2. It prevents farther improving deferred page initialization by allowing intra-node multi-threading.
We are keeping interrupts disabled to solve a rather theoretical problem that was never observed in real world (See 3a2d7fa8a3d5).
Let's keep interrupts enabled. In case we ever encounter a scenario where an interrupt thread wants to allocate large amount of memory this early in boot we can deal with that by growing zone (see deferred_grow_zone()) by the needed amount before starting deferred_init_memmap() threads.
Before:
[ 1.232459] node 0 initialised, 12058412 pages in 1ms
After:
[ 1.632580] node 0 initialised, 12051227 pages in 436ms
--- include/linux/mmzone.h | 2 ++ mm/page_alloc.c | 20 +++++++------------- 2 files changed, 9 insertions(+), 13 deletions(-)
include/linux/mmzone.h +2 -0
@@ -709,6 +709,8 @@ typedef struct pglist_data {/* * Must be held any time you expect node_start_pfn, * node_present_pages, node_spanned_pages or nr_zones to stay constant. +* Also synchronizes pgdat->first_deferred_pfn during deferred page +* init. * * pgdat_resize_lock() and pgdat_resize_unlock() are provided to * manipulate node_size_lock without checking for CONFIG_MEMORY_HOTPLUG
mm/page_alloc.c +7 -13
@@ -1793,6 +1793,13 @@ static int __init deferred_init_memmap(vBUG_ON (pgdat->first_deferred_pfn >pgdat_end_pfn (pgdat)); pgdat->first_deferred_pfn =ULONG_MAX ; +/* +* Once we unlock here, the zone cannot be grown anymore, thus if an +* interrupt thread must allocate this early in boot, zone must be +* pre-grown prior to start of deferred page initialization. +*/ +pgdat_resize_unlock (pgdat, &flags); +/* Only the highest zone is deferred so find it */ for (zid =0 ; zid <MAX_NR_ZONES ; zid++) { zone = pgdat->node_zones + zid;
@@ -1813,8 +1820,6 @@ static int __init deferred_init_memmap(vwhile (spfn < epfn) nr_pages +=deferred_init_maxorder (&i, zone, &spfn, &epfn); zone_empty: -pgdat_resize_unlock (pgdat, &flags); -/* Sanity check that the next zone really is unpopulated */ WARN_ON (++zid <MAX_NR_ZONES &&populated_zone (++zone));
@@ -1857,17 +1862,6 @@ deferred_grow_zone(struct zone *zone, unpgdat_resize_lock (pgdat, &flags);/* -* If deferred pages have been initialized while we were waiting for -* the lock, return true, as the zone was grown. The caller will retry -* this zone. We won't return to this function since the caller also -* has this static branch. -*/ -if (!static_branch_unlikely (&deferred_pages)) { -pgdat_resize_unlock (pgdat, &flags); -return true; - } - -/* * If someone grew this zone while we were waiting for spinlock, return * true, as there might be enough pages already. */
Greg Kroah-Hartman
maintainerPATCH 171/261 MIPS: CPU_LOONGSON2EF need software to maintain cache consistency
In reply to Greg Kroah-HartmanFrom: Lichao Liu <[email protected]>
commit a202bf71f08b3ef15356db30535e30b03cf23aec upstream.
CPU_LOONGSON2EF need software to maintain cache consistency, so modify the 'cpu_needs_post_dma_flush' function to return true when the cpu type is CPU_LOONGSON2EF.
--- arch/mips/mm/dma-noncoherent.c | 1 + 1 file changed, 1 insertion(+)
arch/mips/mm/dma-noncoherent.c +1 -0
@@ -33,6 +33,7 @@ static inline bool cpu_needs_post_dma_flcase CPU_R10000 :case CPU_R12000 :case CPU_BMIPS5000 : +case CPU_LOONGSON2EF :return true;default :/*
Greg Kroah-Hartman
maintainerPATCH 172/261 mm/pagealloc.c: call touch_nmi_watchdog() on max order boundaries in deferred init
In reply to Greg Kroah-HartmanFrom: Daniel Jordan <[email protected]>
commit 117003c32771df617acf66e140fbdbdeb0ac71f5 upstream.
Patch series "initialize deferred pages with interrupts enabled", v4.
Keep interrupts enabled during deferred page initialization in order to make code more modular and allow jiffies to update.
Original approach, and discussion can be found here:
http://lkml.kernel.org/r/[email protected]
This patch (of 3):
deferred_init_memmap() disables interrupts the entire time, so it calls touch_nmi_watchdog() periodically to avoid soft lockup splats. Soon it will run with interrupts enabled, at which point cond_resched() should be used instead.
deferred_grow_zone() makes the same watchdog calls through code shared with deferred init but will continue to run with interrupts disabled, so it can't call cond_resched().
Pull the watchdog calls up to these two places to allow the first to be changed later, independently of the second. The frequency reduces from twice per pageblock (init and free) to once per max order block.
--- mm/page_alloc.c | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-)
mm/page_alloc.c +4 -3
@@ -1640,7 +1640,6 @@ static void __init deferred_free_pages(u }else if (!(pfn & nr_pgmask)) {deferred_free_range (pfn - nr_free, nr_free); nr_free =1 ; -touch_nmi_watchdog (); }else { nr_free++; }
@@ -1670,7 +1669,6 @@ static unsigned long __init deferred_incontinue ; }else if (!page || !(pfn & nr_pgmask)) { page =pfn_to_page (pfn); -touch_nmi_watchdog (); }else { page++; }
@@ -1817,8 +1815,10 @@ static int __init deferred_init_memmap(v* that we can avoid introducing any issues with the buddy * allocator. */ -while (spfn < epfn) +while (spfn < epfn) { nr_pages +=deferred_init_maxorder (&i, zone, &spfn, &epfn); +touch_nmi_watchdog (); + } zone_empty:/* Sanity check that the next zone really is unpopulated */ WARN_ON (++zid <MAX_NR_ZONES &&populated_zone (++zone));
@@ -1889,6 +1889,7 @@ deferred_grow_zone(struct zone *zone, un first_deferred_pfn = spfn; nr_pages +=deferred_init_maxorder (&i, zone, &spfn, &epfn); +touch_nmi_watchdog ();/* We should only stop along section boundaries */ if ((first_deferred_pfn ^ spfn) <PAGES_PER_SECTION )
Greg Kroah-Hartman
maintainerPATCH 173/261 mm: call cond_resched() from deferred_init_memmap()
In reply to Greg Kroah-HartmanFrom: Pavel Tatashin <[email protected]>
commit da97f2d56bbd880b4138916a7ef96f9881a551b2 upstream.
Now that deferred pages are initialized with interrupts enabled we can replace touch_nmi_watchdog() with cond_resched(), as it was before 3a2d7fa8a3d5.
For now, we cannot do the same in deferred_grow_zone() as it is still initializes pages with interrupts disabled.
This change fixes RCU problem described in
https://lkml.kernel.org/r/[email protected]
[ 60.474005] rcu: INFO: rcu_sched detected stalls on CPUs/tasks: [ 60.475000] rcu: 1-...0: (0 ticks this GP) idle=02a/1/0x4000000000000000 softirq=1/1 fqs=15000 [ 60.475000] rcu: (detected by 0, t=60002 jiffies, g=-1199, q=1) [ 60.475000] Sending NMI from CPU 0 to CPUs 1: [ 1.760091] NMI backtrace for cpu 1 [ 1.760091] CPU: 1 PID: 20 Comm: pgdatinit0 Not tainted 4.18.0-147.9.1.el8_1.x86_64 #1 [ 1.760091] Hardware name: Red Hat KVM, BIOS 1.13.0-1.module+el8.2.0+5520+4e5817f3 04/01/2014 [ 1.760091] RIP: 0010:__init_single_page.isra.65+0x10/0x4f [ 1.760091] Code: 48 83 cf 63 48 89 f8 0f 1f 40 00 48 89 c6 48 89 d7 e8 6b 18 80 ff 66 90 5b c3 31 c0 b9 10 00 00 00 49 89 f8 48 c1 e6 33 f3 ab <b8> 07 00 00 00 48 c1 e2 36 41 c7 40 34 01 00 00 00 48 c1 e0 33 41 [ 1.760091] RSP: 0000:ffffba783123be40 EFLAGS: 00000006 [ 1.760091] RAX: 0000000000000000 RBX: fffffad34405e300 RCX: 0000000000000000 [ 1.760091] RDX: 0000000000000000 RSI: 0010000000000000 RDI: fffffad34405e340 [ 1.760091] RBP: 0000000033f3177e R08: fffffad34405e300 R09: 0000000000000002 [ 1.760091] R10: 000000000000002b R11: ffff98afb691a500 R12: 0000000000000002 [ 1.760091] R13: 0000000000000000 R14: 000000003f03ea00 R15: 000000003e10178c [ 1.760091] FS: 0000000000000000(0000) GS:ffff9c9ebeb00000(0000) knlGS:0000000000000000 [ 1.760091] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 [ 1.760091] CR2: 00000000ffffffff CR3: 000000a1cf20a001 CR4: 00000000003606e0 [ 1.760091] DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000 [ 1.760091] DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400 [ 1.760091] Call Trace: [ 1.760091] deferred_init_pages+0x8f/0xbf [ 1.760091] deferred_init_memmap+0x184/0x29d [ 1.760091] ? deferred_free_pages.isra.97+0xba/0xba [ 1.760091] kthread+0x112/0x130 [ 1.760091] ? kthread_flush_work_fn+0x10/0x10 [ 1.760091] ret_from_fork+0x35/0x40 [ 89.123011] node 0 initialised, 1055935372 pages in 88650ms
--- mm/page_alloc.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
mm/page_alloc.c +1 -1
@@ -1817,7 +1817,7 @@ static int __init deferred_init_memmap(v*/ while (spfn < epfn) { nr_pages +=deferred_init_maxorder (&i, zone, &spfn, &epfn); -touch_nmi_watchdog (); +cond_resched (); } zone_empty:/* Sanity check that the next zone really is unpopulated */
Greg Kroah-Hartman
maintainerPATCH 174/261 ima: Fix ima digest hash table key calculation
In reply to Greg Kroah-HartmanFrom: Krzysztof Struczynski <[email protected]>
commit 1129d31b55d509f15e72dc68e4b5c3a4d7b4da8d upstream.
Function hash_long() accepts unsigned long, while currently only one byte is passed from ima_hash_key(), which calculates a key for ima_htable.
Given that hashing the digest does not give clear benefits compared to using the digest itself, remove hash_long() and return the modulus calculated on the first two bytes of the digest with the number of slots. Also reduce the depth of the hash table by doubling the number of slots.
--- security/integrity/ima/ima.h | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-)
security/integrity/ima/ima.h +4 -3
@@ -36,7 +36,7 @@ enum tpm_pcrs { TPM_PCR0 = 0, TPM_PCR8 =#define IMA_DIGEST_SIZE SHA1_DIGEST_SIZE#define IMA_EVENT_NAME_LEN_MAX 255 -#define IMA_HASH_BITS 9 +#define IMA_HASH_BITS 10#define IMA_MEASURE_HTABLE_SIZE (1 << IMA_HASH_BITS)#define IMA_TEMPLATE_FIELD_ID_MAX_LEN 16
@@ -175,9 +175,10 @@ struct ima_h_table { };extern struct ima_h_table ima_htable; -static inline unsigned long ima_hash_key (u8 *digest) +static inline unsigned int ima_hash_key (u8 *digest) { -return hash_long (*digest,IMA_HASH_BITS ); +/* there is no point in taking a hash of part of a digest */ +return (digest[0 ] | digest[1 ] <<8 ) %IMA_MEASURE_HTABLE_SIZE ; }#define __ima_hooks (hook) \
Greg Kroah-Hartman
maintainerPATCH 175/261 ima: Switch to ima_hash_algo for boot aggregate
In reply to Greg Kroah-HartmanFrom: Roberto Sassu <[email protected]>
commit 6f1a1d103b48b1533a9c804e7a069e2c8e937ce7 upstream.
boot_aggregate is the first entry of IMA measurement list. Its purpose is to link pre-boot measurements to IMA measurements. As IMA was designed to work with a TPM 1.2, the SHA1 PCR bank was always selected even if a TPM 2.0 with support for stronger hash algorithms is available.
This patch first tries to find a PCR bank with the IMA default hash algorithm. If it does not find it, it selects the SHA256 PCR bank for TPM 2.0 and SHA1 for TPM 1.2. Ultimately, it selects SHA1 also for TPM 2.0 if the SHA256 PCR bank is not found.
If none of the PCR banks above can be found, boot_aggregate file digest is filled with zeros, as for TPM bypass, making it impossible to perform a remote attestation of the system.
--- security/integrity/ima/ima_crypto.c | 47 +++++++++++++++++++++++++++++++----- security/integrity/ima/ima_init.c | 20 ++++++++++++--- 2 files changed, 57 insertions(+), 10 deletions(-)
security/integrity/ima/ima_crypto.c +41 -6
@@ -655,18 +655,29 @@ static void __init ima_pcrread(u32 idx, }/* -* Calculate the boot aggregate hash +* The boot_aggregate is a cumulative hash over TPM registers 0 - 7. With +* TPM 1.2 the boot_aggregate was based on reading the SHA1 PCRs, but with +* TPM 2.0 hash agility, TPM chips could support multiple TPM PCR banks, +* allowing firmware to configure and enable different banks. +* +* Knowing which TPM bank is read to calculate the boot_aggregate digest +* needs to be conveyed to a verifier. For this reason, use the same +* hash algorithm for reading the TPM PCRs as for calculating the boot +* aggregate digest as stored in the measurement list. */ -static int __init ima_calc_boot_aggregate_tfm (char *digest, +static int __init ima_calc_boot_aggregate_tfm (char *digest,u16 alg_id,struct crypto_shash *tfm) { -struct tpm_digest d = { .alg_id =TPM_ALG_SHA1 , .digest = {0 } }; +struct tpm_digest d = { .alg_id = alg_id, .digest = {0 } };int rc;u32 i;SHASH_DESC_ON_STACK (shash, tfm); shash->tfm = tfm; +pr_devel ("calculating the boot-aggregate based on TPM bank: %04x\n" , + d.alg_id); + rc =crypto_shash_init (shash);if (rc !=0 )return rc;
@@ -675,7 +686,8 @@ static int __init ima_calc_boot_aggregatfor (i =TPM_PCR0 ; i <TPM_PCR8 ; i++) {ima_pcrread (i, &d);/* now accumulate with current aggregate */ - rc =crypto_shash_update (shash, d.digest,TPM_DIGEST_SIZE ); + rc =crypto_shash_update (shash, d.digest, +crypto_shash_digestsize (tfm)); }if (!rc)crypto_shash_final (shash, digest);
@@ -685,14 +697,37 @@ static int __init ima_calc_boot_aggregatint __init ima_calc_boot_aggregate (struct ima_digest_data *hash) {struct crypto_shash *tfm; -int rc; +u16 crypto_id, alg_id; +int rc, i, bank_idx =-1 ; + +for (i =0 ; i < ima_tpm_chip->nr_allocated_banks; i++) { + crypto_id = ima_tpm_chip->allocated_banks[i].crypto_id; +if (crypto_id == hash->algo) { + bank_idx = i; +break ; + } + +if (crypto_id ==HASH_ALGO_SHA256 ) + bank_idx = i; + +if (bank_idx ==-1 && crypto_id ==HASH_ALGO_SHA1 ) + bank_idx = i; + } + +if (bank_idx ==-1 ) { +pr_err ("No suitable TPM algorithm for boot aggregate\n" ); +return 0 ; + } + + hash->algo = ima_tpm_chip->allocated_banks[bank_idx].crypto_id; tfm =ima_alloc_tfm (hash->algo);if (IS_ERR (tfm))return PTR_ERR (tfm); hash->length =crypto_shash_digestsize (tfm); - rc =ima_calc_boot_aggregate_tfm (hash->digest, tfm); + alg_id = ima_tpm_chip->allocated_banks[bank_idx].alg_id; + rc =ima_calc_boot_aggregate_tfm (hash->digest, alg_id, tfm);ima_free_tfm (tfm);
security/integrity/ima/ima_init.c +16 -4
@@ -27,7 +27,7 @@ struct tpm_chip *ima_tpm_chip;/* Add the boot aggregate to the IMA measurement list and extend * the PCR register. * -* Calculate the boot aggregate, a SHA1 over tpm registers 0-7, +* Calculate the boot aggregate, a hash over tpm registers 0-7, * assuming a TPM chip exists, and zeroes if the TPM chip does not * exist. Add the boot aggregate measurement to the measurement * list and extend the PCR register.
@@ -51,15 +51,27 @@ static int __init ima_add_boot_aggregateint violation =0 ;struct {struct ima_digest_data hdr; -char digest[TPM_DIGEST_SIZE ]; +char digest[TPM_MAX_DIGEST_SIZE ]; } hash;memset (iint,0 ,sizeof (*iint));memset (&hash,0 ,sizeof (hash)); iint->ima_hash = &hash.hdr; - iint->ima_hash->algo =HASH_ALGO_SHA1 ; - iint->ima_hash->length =SHA1_DIGEST_SIZE ; + iint->ima_hash->algo = ima_hash_algo; + iint->ima_hash->length = hash_digest_size[ima_hash_algo]; +/* +* With TPM 2.0 hash agility, TPM chips could support multiple TPM +* PCR banks, allowing firmware to configure and enable different +* banks. The SHA1 bank is not necessarily enabled. +* +* Use the same hash algorithm for reading the TPM PCRs as for +* calculating the boot aggregate digest. Preference is given to +* the configured IMA default hash algorithm. Otherwise, use the +* TCG required banks - SHA256 for TPM 2.0, SHA1 for TPM 1.2. +* Ultimately select SHA1 also for TPM 2.0 if the SHA256 PCR bank +* is not found. +*/ if (ima_tpm_chip) { result =ima_calc_boot_aggregate (&hash.hdr);if (result <0 ) {
Greg Kroah-Hartman
maintainerPATCH 176/261 ima: Evaluate error in init_ima()
In reply to Greg Kroah-HartmanFrom: Roberto Sassu <[email protected]>
commit e144d6b265415ddbdc54b3f17f4f95133effa5a8 upstream.
Evaluate error in init_ima() before register_blocking_lsm_notifier() and return if not zero.
--- security/integrity/ima/ima_main.c | 3 +++ 1 file changed, 3 insertions(+)
security/integrity/ima/ima_main.c +3 -0
@@ -712,6 +712,9 @@ static int __init init_ima(void) error =ima_init (); } +if (error) +return error; + error =register_blocking_lsm_notifier (&ima_lsm_policy_notifier);if (error)pr_warn ("Couldn't register LSM notifier, error %d\n" , error);
Greg Kroah-Hartman
maintainerPATCH 177/261 ima: Directly assign the ima_default_policy pointer to ima_rules
In reply to Greg Kroah-HartmanFrom: Roberto Sassu <[email protected]>
commit 067a436b1b0aafa593344fddd711a755a58afb3b upstream.
This patch prevents the following oops:
[ 10.771813] BUG: kernel NULL pointer dereference, address: 0000000000000 [...] [ 10.779790] RIP: 0010:ima_match_policy+0xf7/0xb80 [...] [ 10.798576] Call Trace: [ 10.798993] ? ima_lsm_policy_change+0x2b0/0x2b0 [ 10.799753] ? inode_init_owner+0x1a0/0x1a0 [ 10.800484] ? _raw_spin_lock+0x7a/0xd0 [ 10.801592] ima_must_appraise.part.0+0xb6/0xf0 [ 10.802313] ? ima_fix_xattr.isra.0+0xd0/0xd0 [ 10.803167] ima_must_appraise+0x4f/0x70 [ 10.804004] ima_post_path_mknod+0x2e/0x80 [ 10.804800] do_mknodat+0x396/0x3c0
It occurs when there is a failure during IMA initialization, and ima_init_policy() is not called. IMA hooks still call ima_match_policy() but ima_rules is NULL. This patch prevents the crash by directly assigning the ima_default_policy pointer to ima_rules when ima_rules is defined. This wouldn't alter the existing behavior, as ima_rules is always set at the end of ima_init_policy().
--- security/integrity/ima/ima_policy.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)
security/integrity/ima/ima_policy.c +1 -2
@@ -204,7 +204,7 @@ static struct ima_rule_entry *arch_policstatic LIST_HEAD (ima_default_rules);static LIST_HEAD (ima_policy_rules);static LIST_HEAD (ima_temp_rules); -static struct list_head *ima_rules; +static struct list_head *ima_rules = &ima_default_rules;static int ima_policy__initdata ;
@@ -712,7 +712,6 @@ void __init ima_init_policy(void)ARRAY_SIZE (default_appraise_rules), IMA_DEFAULT_POLICY); - ima_rules = &ima_default_rules;ima_update_policy_flag (); }
Greg Kroah-Hartman
maintainerPATCH 178/261 ima: Call ima_calc_boot_aggregate() in ima_eventdigest_init()
In reply to Greg Kroah-HartmanFrom: Roberto Sassu <[email protected]>
commit 6cc7c266e5b47d3cd2b5bb7fd3aac4e6bb2dd1d2 upstream.
If the template field 'd' is chosen and the digest to be added to the measurement entry was not calculated with SHA1 or MD5, it is recalculated with SHA1, by using the passed file descriptor. However, this cannot be done for boot_aggregate, because there is no file descriptor.
This patch adds a call to ima_calc_boot_aggregate() in ima_eventdigest_init(), so that the digest can be recalculated also for the boot_aggregate entry.
--- security/integrity/ima/ima.h | 3 ++- security/integrity/ima/ima_crypto.c | 6 +++--- security/integrity/ima/ima_init.c | 2 +- security/integrity/ima/ima_template_lib.c | 18 ++++++++++++++++++ 4 files changed, 24 insertions(+), 5 deletions(-)
security/integrity/ima/ima.h +2 -1
@@ -52,6 +52,7 @@ extern int ima_policy_flag;extern int ima_hash_algo;extern int ima_appraise;extern struct tpm_chip *ima_tpm_chip; +extern const char boot_aggregate_name[];/* IMA event related data */ struct ima_event_data {
@@ -140,7 +141,7 @@ int ima_calc_buffer_hash(const void *bufint ima_calc_field_array_hash (struct ima_field_data *field_data,struct ima_template_desc *desc,int num_fields,struct ima_digest_data *hash); -int __init ima_calc_boot_aggregate (struct ima_digest_data *hash); +int ima_calc_boot_aggregate (struct ima_digest_data *hash);void ima_add_violation (struct file *file,const unsigned char *filename,struct integrity_iint_cache *iint,const char *op,const char *cause);
security/integrity/ima/ima_crypto.c +3 -3
@@ -665,8 +665,8 @@ static void __init ima_pcrread(u32 idx,* hash algorithm for reading the TPM PCRs as for calculating the boot * aggregate digest as stored in the measurement list. */ -static int __init ima_calc_boot_aggregate_tfm (char *digest,u16 alg_id, -struct crypto_shash *tfm) +static int ima_calc_boot_aggregate_tfm (char *digest,u16 alg_id, +struct crypto_shash *tfm) {struct tpm_digest d = { .alg_id = alg_id, .digest = {0 } };int rc;
@@ -694,7 +694,7 @@ static int __init ima_calc_boot_aggregatreturn rc; } -int __init ima_calc_boot_aggregate (struct ima_digest_data *hash) +int ima_calc_boot_aggregate (struct ima_digest_data *hash) {struct crypto_shash *tfm;u16 crypto_id, alg_id;
security/integrity/ima/ima_init.c +1 -1
@@ -21,7 +21,7 @@#include "ima.h" /* name for boot aggregate entry */ -static const char boot_aggregate_name[] ="boot_aggregate" ; +const char boot_aggregate_name[] ="boot_aggregate" ;struct tpm_chip *ima_tpm_chip;/* Add the boot aggregate to the IMA measurement list and extend
security/integrity/ima/ima_template_lib.c +18 -0
@@ -288,6 +288,24 @@ int ima_eventdigest_init(struct ima_even goto out; } +if ((const char *)event_data->filename == boot_aggregate_name) { +if (ima_tpm_chip) { + hash.hdr.algo =HASH_ALGO_SHA1 ; + result =ima_calc_boot_aggregate (&hash.hdr); + +/* algo can change depending on available PCR banks */ +if (!result && hash.hdr.algo !=HASH_ALGO_SHA1 ) + result = -EINVAL ; + +if (result <0 ) +memset (&hash,0 ,sizeof (hash)); + } + + cur_digest = hash.hdr.digest; + cur_digestsize = hash_digest_size[HASH_ALGO_SHA1 ]; + goto out; + } +if (!event_data->file)/* missing info to re-calculate the digest */ return -EINVAL ;
Greg Kroah-Hartman
maintainerPATCH 179/261 ima: Remove __init annotation from ima_pcrread()
In reply to Greg Kroah-HartmanFrom: Roberto Sassu <[email protected]>
commit 8b8c704d913b0fe490af370631a4200e26334ec0 upstream.
Commit 6cc7c266e5b4 ("ima: Call ima_calc_boot_aggregate() in ima_eventdigest_init()") added a call to ima_calc_boot_aggregate() so that the digest can be recalculated for the boot_aggregate measurement entry if the 'd' template field has been requested. For the 'd' field, only SHA1 and MD5 digests are accepted.
Given that ima_eventdigest_init() does not have the __init annotation, all functions called should not have it. This patch removes __init from ima_pcrread().
--- security/integrity/ima/ima_crypto.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
security/integrity/ima/ima_crypto.c +1 -1
@@ -645,7 +645,7 @@ int ima_calc_buffer_hash(const void *bufreturn calc_buffer_shash (buf, len, hash); } -static void __init ima_pcrread (u32 idx,struct tpm_digest *d) +static void ima_pcrread (u32 idx,struct tpm_digest *d) {if (!ima_tpm_chip)return ;
Greg Kroah-Hartman
maintainerPATCH 180/261 evm: Fix possible memory leak in evm_calc_hmac_or_hash()
In reply to Greg Kroah-HartmanFrom: Roberto Sassu <[email protected]>
commit 0c4395fb2aa77341269ea619c5419ea48171883f upstream.
Don't immediately return if the signature is portable and security.ima is not present. Just set error so that memory allocated is freed before returning from evm_calc_hmac_or_hash().
--- security/integrity/evm/evm_crypto.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
security/integrity/evm/evm_crypto.c +1 -1
@@ -243,7 +243,7 @@ static int evm_calc_hmac_or_hash(struct/* Portable EVM signatures must include an IMA hash */ if (type ==EVM_XATTR_PORTABLE_DIGSIG && !ima_present) -return -EPERM ; + error = -EPERM ; out:kfree (xattr_value);kfree (desc);
Greg Kroah-Hartman
maintainerPATCH 181/261 ext4: fix EXT_MAX_EXTENT/INDEX to check for zeroed eh_max
In reply to Greg Kroah-HartmanFrom: Harshad Shirwadkar <[email protected]>
commit c36a71b4e35ab35340facdd6964a00956b9fef0a upstream.
If eh->eh_max is 0, EXT_MAX_EXTENT/INDEX would evaluate to unsigned (-1) resulting in illegal memory accesses. Although there is no consistent repro, we see that generic/019 sometimes crashes because of this bug.
Ran gce-xfstests smoke and verified that there were no regressions.
--- fs/ext4/ext4_extents.h | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-)
fs/ext4/ext4_extents.h +6 -3
@@ -170,10 +170,13 @@ struct partial_cluster { (EXT_FIRST_EXTENT((__hdr__)) + le16_to_cpu((__hdr__)->eh_entries) - 1)#define EXT_LAST_INDEX (__hdr__) \ (EXT_FIRST_INDEX((__hdr__)) + le16_to_cpu((__hdr__)->eh_entries) - 1) -#define EXT_MAX_EXTENT (__hdr__) \ - (EXT_FIRST_EXTENT((__hdr__)) + le16_to_cpu((__hdr__)->eh_max) - 1) +#define EXT_MAX_EXTENT (__hdr__) \ + ((le16_to_cpu((__hdr__)->eh_max)) ? \ + ((EXT_FIRST_EXTENT((__hdr__)) + le16_to_cpu((__hdr__)->eh_max) - 1)) \ + : 0)#define EXT_MAX_INDEX (__hdr__) \ - (EXT_FIRST_INDEX((__hdr__)) + le16_to_cpu((__hdr__)->eh_max) - 1) + ((le16_to_cpu((__hdr__)->eh_max)) ? \ + ((EXT_FIRST_INDEX((__hdr__)) + le16_to_cpu((__hdr__)->eh_max) - 1)) : 0)static inline struct ext4_extent_header *ext_inode_hdr (struct inode *inode) {
Greg Kroah-Hartman
maintainerPATCH 182/261 ext4: fix error pointer dereference
In reply to Greg Kroah-HartmanFrom: Jeffle Xu <[email protected]>
commit 8418897f1bf87da0cb6936489d57a4320c32c0af upstream.
Don't pass error pointers to brelse().
commit 7159a986b420 ("ext4: fix some error pointer dereferences") has fixed some cases, fix the remaining one case.
Once ext4_xattr_block_find()->ext4_sb_bread() failed, error pointer is stored in @bs->bh, which will be passed to brelse() in the cleanup routine of ext4_xattr_set_handle(). This will then cause a NULL panic crash in __brelse().
BUG: unable to handle kernel NULL pointer dereference at 000000000000005b RIP: 0010:__brelse+0x1b/0x50 Call Trace: ext4_xattr_set_handle+0x163/0x5d0 ext4_xattr_set+0x95/0x110 __vfs_setxattr+0x6b/0x80 __vfs_setxattr_noperm+0x68/0x1b0 vfs_setxattr+0xa0/0xb0 setxattr+0x12c/0x1a0 path_setxattr+0x8d/0xc0 __x64_sys_setxattr+0x27/0x30 do_syscall_64+0x60/0x250 entry_SYSCALL_64_after_hwframe+0x49/0xbe
In this case, @bs->bh stores '-EIO' actually.
--- fs/ext4/xattr.c | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-)
fs/ext4/xattr.c +5 -2
@@ -1820,8 +1820,11 @@ ext4_xattr_block_find(struct inode *inodif (EXT4_I (inode)->i_file_acl) {/* The inode already has an extended attribute block. */ bs->bh =ext4_sb_bread (sb,EXT4_I (inode)->i_file_acl,REQ_PRIO ); -if (IS_ERR (bs->bh)) -return PTR_ERR (bs->bh); +if (IS_ERR (bs->bh)) { + error =PTR_ERR (bs->bh); + bs->bh =NULL ; +return error; + }ea_bdebug (bs->bh,"b_count=%d, refcount=%d" ,atomic_read (&(bs->bh->b_count)),le32_to_cpu (BHDR (bs->bh)->h_refcount));
Greg Kroah-Hartman
maintainerPATCH 183/261 ext4: fix race between ext4_sync_parent() and rename()
In reply to Greg Kroah-HartmanFrom: Eric Biggers <[email protected]>
commit 08adf452e628b0e2ce9a01048cfbec52353703d7 upstream.
'igrab(d_inode(dentry->d_parent))' without holding dentry->d_lock is broken because without d_lock, d_parent can be concurrently changed due to a rename(). Then if the old directory is immediately deleted, old d_parent->inode can be NULL. That causes a NULL dereference in igrab().
To fix this, use dget_parent() to safely grab a reference to the parent dentry, which pins the inode. This also eliminates the need to use d_find_any_alias() other than for the initial inode, as we no longer throw away the dentry at each step.
This is an extremely hard race to hit, but it is possible. Adding a udelay() in between the reads of ->d_parent and its ->d_inode makes it reproducible on a no-journal filesystem using the following program:
#include <fcntl.h>
#include <unistd.h>
int main()
{
if (fork()) {
for (;;) {
mkdir("dir1", 0700);
int fd = open("dir1/file", O_RDWR|O_CREAT|O_SYNC);
write(fd, "X", 1);
close(fd);
}
} else {
mkdir("dir2", 0700);
for (;;) {
rename("dir1/file", "dir2/file");
rmdir("dir1");
}
}
}--- fs/ext4/fsync.c | 28 +++++++++++++--------------- 1 file changed, 13 insertions(+), 15 deletions(-)
fs/ext4/fsync.c +13 -15
@@ -44,30 +44,28 @@*/ static int ext4_sync_parent (struct inode *inode) { -struct dentry *dentry =NULL ; -struct inode *next; +struct dentry *dentry, *next;int ret =0 ;if (!ext4_test_inode_state (inode,EXT4_STATE_NEWENTRY ))return 0 ; - inode =igrab (inode); + dentry =d_find_any_alias (inode); +if (!dentry) +return 0 ;while (ext4_test_inode_state (inode,EXT4_STATE_NEWENTRY )) {ext4_clear_inode_state (inode,EXT4_STATE_NEWENTRY ); - dentry =d_find_any_alias (inode); -if (!dentry) -break ; - next =igrab (d_inode (dentry->d_parent)); + + next =dget_parent (dentry);dput (dentry); -if (!next) -break ; -iput (inode); - inode = next; + dentry = next; + inode = dentry->d_inode; +/* * The directory inode may have gone through rmdir by now. But * the inode itself and its blocks are still allocated (we hold -* a reference to the inode so it didn't go through -* ext4_evict_inode()) and so we are safe to flush metadata -* blocks and the inode. +* a reference to the inode via its dentry), so it didn't go +* through ext4_evict_inode()) and so we are safe to flush +* metadata blocks and the inode. */ ret =sync_mapping_buffers (inode->i_mapping);if (ret)
@@ -76,7 +74,7 @@ static int ext4_sync_parent(struct inodeif (ret)break ; } -iput (inode); +dput (dentry);return ret; }
Quoted 8 lines · Greg Kroah-Hartman
This is the start of the stable review cycle for the 5.4.48 release. There are 261 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 Sun, 21 Jun 2020 14:15:50 +0000. Anything received after that time might be too late.
Building mips:defconfig ... failed
--------------
Error log:arch/mips/mm/dma-noncoherent.c: In function 'cpu_needs_post_dma_flush':arch/mips/mm/dma-noncoherent.c:36:7: error: 'CPU_LOONGSON2EF' undeclared
Also affects v4.19.y.queue, and causes almost all mips builds to fail.
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.4.48 release. There are 261 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 Sun, 21 Jun 2020 14:15:50 +0000. Anything received after that time might be too late.
Quoted 7 lines
Building mips:defconfig ... failed
--------------
Error log:arch/mips/mm/dma-noncoherent.c: In function 'cpu_needs_post_dma_flush':arch/mips/mm/dma-noncoherent.c:36:7: error: 'CPU_LOONGSON2EF' undeclaredAlso affects v4.19.y.queue, and causes almost all mips builds to fail.
Thanks, I've dropped the offending patch from both trees now.
greg k-h
Greg Kroah-Hartman
maintainerQuoted 17 lines · Greg Kroah-Hartman
Quoted 16 lines · Guenter Roeck
Quoted 8 lines · Greg Kroah-Hartman
This is the start of the stable review cycle for the 5.4.48 release. There are 261 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 Sun, 21 Jun 2020 14:15:50 +0000. Anything received after that time might be too late.
Building mips:defconfig ... failed
--------------
Error log:arch/mips/mm/dma-noncoherent.c: In function 'cpu_needs_post_dma_flush':arch/mips/mm/dma-noncoherent.c:36:7: error: 'CPU_LOONGSON2EF' undeclared
Quoted 3 lines
Quoted 1 line
Also affects v4.19.y.queue, and causes almost all mips builds to fail.
Thanks, I've dropped the offending patch from both trees now.
And pushed out -rc2 for 5.4.y and 4.19.y with that change, and some other patches dropped.
thanks,
greg k-h
Greg Kroah-Hartman
maintainerPATCH 184/261 PCI: Avoid Pericom USB controller OHCI/EHCI PME# defect
In reply to Greg Kroah-HartmanFrom: Kai-Heng Feng <[email protected]>
[ Upstream commit 68f5fc4ea9ddf9f77720d568144219c4e6452cde ]
Both Pericom OHCI and EHCI devices advertise PME# support from all power states:
06:00.0 USB controller [0c03]: Pericom Semiconductor PI7C9X442SL USB OHCI Controller [12d8:400e] (rev 01) (prog-if 10 [OHCI])
Subsystem: Pericom Semiconductor PI7C9X442SL USB OHCI Controller [12d8:400e]
Capabilities: [80] Power Management version 3
Flags: PMEClk- DSI- D1+ D2+ AuxCurrent=375mA PME(D0+,D1+,D2+,D3hot+,D3cold+)
06:00.2 USB controller [0c03]: Pericom Semiconductor PI7C9X442SL USB EHCI Controller [12d8:400f] (rev 01) (prog-if 20 [EHCI])
Subsystem: Pericom Semiconductor PI7C9X442SL USB EHCI Controller [12d8:400f]
Capabilities: [80] Power Management version 3
Flags: PMEClk- DSI- D1+ D2+ AuxCurrent=375mA PME(D0+,D1+,D2+,D3hot+,D3cold+)
But testing shows that it's unreliable: there is a 20% chance PME# won't be asserted when a USB device is plugged.
Remove PME support for both devices to make USB plugging work reliably.
Bugzilla: https://bugzilla.kernel.org/show_bug.cgi?id=205981
--- drivers/pci/quirks.c | 13 +++++++++++++ 1 file changed, 13 insertions(+)
drivers/pci/quirks.c +13 -0
@@ -5551,6 +5551,19 @@ static void pci_fixup_no_d0_pme(struct pci_dev *dev) }DECLARE_PCI_FIXUP_FINAL (PCI_VENDOR_ID_ASMEDIA ,0x2142 , pci_fixup_no_d0_pme); +/* +* Device [12d8:0x400e] and [12d8:0x400f] +* These devices advertise PME# support in all power states but don't +* reliably assert it. +*/ +static void pci_fixup_no_pme (struct pci_dev *dev) +{ +pci_info (dev,"PME# is unreliable, disabling it\n" ); + dev->pme_support =0 ; +} +DECLARE_PCI_FIXUP_FINAL (PCI_VENDOR_ID_PERICOM ,0x400e , pci_fixup_no_pme); +DECLARE_PCI_FIXUP_FINAL (PCI_VENDOR_ID_PERICOM ,0x400f , pci_fixup_no_pme); +static void apex_pci_fixup_class (struct pci_dev *pdev) { pdev->class = (PCI_CLASS_SYSTEM_OTHER <<8 ) | pdev->class;
Signature · 1 line
2.25.1
Greg Kroah-Hartman
maintainerPATCH 185/261 PCI: Avoid FLR for AMD Matisse HD Audio & USB 3.0
In reply to Greg Kroah-HartmanFrom: Marcos Scriven <[email protected]>
[ Upstream commit 0d14f06cd6657ba3446a5eb780672da487b068e7 ]
The AMD Matisse HD Audio & USB 3.0 devices advertise Function Level Reset support, but hang when an FLR is triggered.
To reproduce the problem, attach the device to a VM, then detach and try to attach again.
Rename the existing quirk_intel_no_flr(), which was not Intel-specific, to quirk_no_flr(), and apply it to prevent the use of FLR on these AMD devices.
--- drivers/pci/quirks.c | 18 ++++++++++++++---- 1 file changed, 14 insertions(+), 4 deletions(-)
drivers/pci/quirks.c +14 -4
@@ -5130,13 +5130,23 @@ static void quirk_intel_qat_vf_cap(struct pci_dev *pdev) }DECLARE_PCI_FIXUP_EARLY (PCI_VENDOR_ID_INTEL ,0x443 , quirk_intel_qat_vf_cap); -/* FLR may cause some 82579 devices to hang */ -static void quirk_intel_no_flr (struct pci_dev *dev) +/* +* FLR may cause the following to devices to hang: +* +* AMD Starship/Matisse HD Audio Controller 0x1487 +* AMD Matisse USB 3.0 Host Controller 0x149c +* Intel 82579LM Gigabit Ethernet Controller 0x1502 +* Intel 82579V Gigabit Ethernet Controller 0x1503 +* +*/ +static void quirk_no_flr (struct pci_dev *dev) { dev->dev_flags |=PCI_DEV_FLAGS_NO_FLR_RESET ; } -DECLARE_PCI_FIXUP_EARLY (PCI_VENDOR_ID_INTEL ,0x1502 , quirk_intel_no_flr); -DECLARE_PCI_FIXUP_EARLY (PCI_VENDOR_ID_INTEL ,0x1503 , quirk_intel_no_flr); +DECLARE_PCI_FIXUP_EARLY (PCI_VENDOR_ID_AMD ,0x1487 , quirk_no_flr); +DECLARE_PCI_FIXUP_EARLY (PCI_VENDOR_ID_AMD ,0x149c , quirk_no_flr); +DECLARE_PCI_FIXUP_EARLY (PCI_VENDOR_ID_INTEL ,0x1502 , quirk_no_flr); +DECLARE_PCI_FIXUP_EARLY (PCI_VENDOR_ID_INTEL ,0x1503 , quirk_no_flr);static void quirk_no_ext_tags (struct pci_dev *pdev) {
Signature · 1 line
2.25.1
Greg Kroah-Hartman
maintainerPATCH 186/261 PCI: Avoid FLR for AMD Starship USB 3.0
In reply to Greg Kroah-HartmanFrom: Kevin Buettner <[email protected]>
[ Upstream commit 5727043c73fdfe04597971b5f3f4850d879c1f4f ]
The AMD Starship USB 3.0 host controller advertises Function Level Reset support, but it apparently doesn't work. Add a quirk to prevent use of FLR on this device.
Without this quirk, when attempting to assign (pass through) an AMD Starship USB 3.0 host controller to a guest OS, the system becomes increasingly unresponsive over the course of several minutes, eventually requiring a hard reset. Shortly after attempting to start the guest, I see these messages:
vfio-pci 0000:05:00.3: not ready 1023ms after FLR; waiting vfio-pci 0000:05:00.3: not ready 2047ms after FLR; waiting vfio-pci 0000:05:00.3: not ready 4095ms after FLR; waiting vfio-pci 0000:05:00.3: not ready 8191ms after FLR; waiting
And then eventually:
vfio-pci 0000:05:00.3: not ready 65535ms after FLR; giving up
INFO: NMI handler (perf_event_nmi_handler) took too long to run: 0.000 msecs
perf: interrupt took too long (642744 > 2500), lowering kernel.perf_event_max_sample_rate to 1000
INFO: NMI handler (perf_event_nmi_handler) took too long to run: 82.270 msecs
INFO: NMI handler (perf_event_nmi_handler) took too long to run: 680.608 msecs
INFO: NMI handler (perf_event_nmi_handler) took too long to run: 100.952 msecs
...
watchdog: BUG: soft lockup - CPU#3 stuck for 22s! [qemu-system-x86:7487]
Tested on a Micro-Star International Co., Ltd. MS-7C59/Creator TRX40 motherboard with an AMD Ryzen Threadripper 3970X.
--- drivers/pci/quirks.c | 2 ++ 1 file changed, 2 insertions(+)
drivers/pci/quirks.c +2 -0
@@ -5134,6 +5134,7 @@ DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_INTEL, 0x443, quirk_intel_qat_vf_cap);* FLR may cause the following to devices to hang: * * AMD Starship/Matisse HD Audio Controller 0x1487 +* AMD Starship USB 3.0 Host Controller 0x148c * AMD Matisse USB 3.0 Host Controller 0x149c * Intel 82579LM Gigabit Ethernet Controller 0x1502 * Intel 82579V Gigabit Ethernet Controller 0x1503
@@ -5144,6 +5145,7 @@ static void quirk_no_flr(struct pci_dev *dev) dev->dev_flags |=PCI_DEV_FLAGS_NO_FLR_RESET ; }DECLARE_PCI_FIXUP_EARLY (PCI_VENDOR_ID_AMD ,0x1487 , quirk_no_flr); +DECLARE_PCI_FIXUP_EARLY (PCI_VENDOR_ID_AMD ,0x148c , quirk_no_flr);DECLARE_PCI_FIXUP_EARLY (PCI_VENDOR_ID_AMD ,0x149c , quirk_no_flr);DECLARE_PCI_FIXUP_EARLY (PCI_VENDOR_ID_INTEL ,0x1502 , quirk_no_flr);DECLARE_PCI_FIXUP_EARLY (PCI_VENDOR_ID_INTEL ,0x1503 , quirk_no_flr);
Signature · 1 line
2.25.1
Greg Kroah-Hartman
maintainerPATCH 187/261 PCI: Add ACS quirk for Intel Root Complex Integrated Endpoints
In reply to Greg Kroah-HartmanFrom: Ashok Raj <[email protected]>
[ Upstream commit 3247bd10a4502a3075ce8e1c3c7d31ef76f193ce ]
All Intel platforms guarantee that all root complex implementations must send transactions up to IOMMU for address translations. Hence for Intel RCiEP devices, we can assume some ACS-type isolation even without an ACS capability.
Quoted 1 line
From the Intel VT-d spec, r3.1, sec 3.16 ("Root-Complex Peer to Peer
Considerations"):
When DMA remapping is enabled, peer-to-peer requests through the Root-Complex must be handled as follows:
- The input address in the request is translated (through first-level, second-level or nested translation) to a host physical address (HPA). The address decoding for peer addresses must be done only on the translated HPA. Hardware implementations are free to further limit peer-to-peer accesses to specific host physical address regions (or to completely disallow peer-forwarding of translated requests).
- Since address translation changes the contents (address field) of the PCI Express Transaction Layer Packet (TLP), for PCI Express peer-to-peer requests with ECRC, the Root-Complex hardware must use the new ECRC (re-computed with the translated address) if it decides to forward the TLP as a peer request.
- Root-ports, and multi-function root-complex integrated endpoints, may support additional peer-to-peer control features by supporting PCI Express Access Control Services (ACS) capability. Refer to ACS capability in PCI Express specifications for details.
Since Linux didn't give special treatment to allow this exception, certain RCiEP MFD devices were grouped in a single IOMMU group. This doesn't permit a single device to be assigned to a guest for instance.
In one vendor system: Device 14.x were grouped in a single IOMMU group.
/sys/kernel/iommu_groups/5/devices/0000:00:14.0
/sys/kernel/iommu_groups/5/devices/0000:00:14.2
/sys/kernel/iommu_groups/5/devices/0000:00:14.3
After this patch:
/sys/kernel/iommu_groups/5/devices/0000:00:14.0 /sys/kernel/iommu_groups/5/devices/0000:00:14.2 /sys/kernel/iommu_groups/6/devices/0000:00:14.3 <<< new group
14.0 and 14.2 are integrated devices, but legacy end points, whereas 14.3 was a PCIe-compliant RCiEP.
00:14.3 Network controller: Intel Corporation Device 9df0 (rev 30)
Capabilities: [40] Express (v2) Root Complex Integrated Endpoint, MSI 00
This permits assigning this device to a guest VM.
--- drivers/pci/quirks.c | 15 +++++++++++++++ 1 file changed, 15 insertions(+)
drivers/pci/quirks.c +15 -0
@@ -4683,6 +4683,20 @@ static int pci_quirk_mf_endpoint_acs(struct pci_dev *dev, u16 acs_flags) PCI_ACS_CR | PCI_ACS_UF | PCI_ACS_DT); } +static int pci_quirk_rciep_acs (struct pci_dev *dev,u16 acs_flags) +{ +/* +* Intel RCiEP's are required to allow p2p only on translated +* addresses. Refer to Intel VT-d specification, r3.1, sec 3.16, +* "Root-Complex Peer to Peer Considerations". +*/ +if (pci_pcie_type (dev) !=PCI_EXP_TYPE_RC_END ) +return -ENOTTY ; + +return pci_acs_ctrl_enabled (acs_flags, +PCI_ACS_SV |PCI_ACS_RR |PCI_ACS_CR |PCI_ACS_UF ); +} +static int pci_quirk_brcm_acs (struct pci_dev *dev,u16 acs_flags) {/*
@@ -4765,6 +4779,7 @@ static const struct pci_dev_acs_enabled {/* I219 */ { PCI_VENDOR_ID_INTEL, 0x15b7, pci_quirk_mf_endpoint_acs }, { PCI_VENDOR_ID_INTEL, 0x15b8, pci_quirk_mf_endpoint_acs }, + { PCI_VENDOR_ID_INTEL, PCI_ANY_ID, pci_quirk_rciep_acs },/* QCOM QDF2xxx root ports */ { PCI_VENDOR_ID_QCOM, 0x0400, pci_quirk_qcom_rp_acs }, { PCI_VENDOR_ID_QCOM, 0x0401, pci_quirk_qcom_rp_acs },
Signature · 1 line
2.25.1
Greg Kroah-Hartman
maintainerPATCH 188/261 PCI: vmd: Add device id for VMD device 8086:9A0B
In reply to Greg Kroah-HartmanFrom: Jon Derrick <[email protected]>
[ Upstream commit ec11e5c213cc20cac5e8310728b06793448b9f6d ]
This patch adds support for this VMD device which supports the bus restriction mode.
--- drivers/pci/controller/vmd.c | 2 ++ include/linux/pci_ids.h | 1 + 2 files changed, 3 insertions(+)
drivers/pci/controller/vmd.c +2 -0
@@ -854,6 +854,8 @@ static const struct pci_device_id vmd_ids[] = { {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_VMD_28C0), .driver_data =VMD_FEAT_HAS_MEMBAR_SHADOW | VMD_FEAT_HAS_BUS_RESTRICTIONS,}, + {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_VMD_9A0B), + .driver_data = VMD_FEAT_HAS_BUS_RESTRICTIONS,}, {0,} };MODULE_DEVICE_TABLE (pci, vmd_ids);
include/linux/pci_ids.h +1 -0
@@ -3008,6 +3008,7 @@#define PCI_DEVICE_ID_INTEL_84460GX 0x84ea#define PCI_DEVICE_ID_INTEL_IXP4XX 0x8500#define PCI_DEVICE_ID_INTEL_IXP2800 0x9004 +#define PCI_DEVICE_ID_INTEL_VMD_9A0B 0x9a0b#define PCI_DEVICE_ID_INTEL_S21152BB 0xb152#define PCI_VENDOR_ID_SCALEMP 0x8686
Signature · 1 line
2.25.1
Greg Kroah-Hartman
maintainerPATCH 189/261 x86/amd_nb: Add Family 19h PCI IDs
In reply to Greg Kroah-HartmanFrom: Yazen Ghannam <[email protected]>
[ Upstream commit b3f79ae45904ae987a7c06a9e8d6084d7b73e67f ]
Add the new PCI Device 18h IDs for AMD Family 19h systems. Note that Family 19h systems will not have a new PCI root device ID.
--- arch/x86/kernel/amd_nb.c | 3 +++ include/linux/pci_ids.h | 1 + 2 files changed, 4 insertions(+)
arch/x86/kernel/amd_nb.c +3 -0
@@ -22,6 +22,7 @@#define PCI_DEVICE_ID_AMD_17H_M10H_DF_F4 0x15ec#define PCI_DEVICE_ID_AMD_17H_M30H_DF_F4 0x1494#define PCI_DEVICE_ID_AMD_17H_M70H_DF_F4 0x1444 +#define PCI_DEVICE_ID_AMD_19H_DF_F4 0x1654/* Protect the PCI config register pairs used for SMN and DF indirect access. */ static DEFINE_MUTEX (smn_mutex);
@@ -52,6 +53,7 @@ const struct pci_device_id amd_nb_misc_ids[] = { { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_17H_M30H_DF_F3) }, { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_CNB17H_F3) }, { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_17H_M70H_DF_F3) }, + { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_19H_DF_F3) }, {} };EXPORT_SYMBOL_GPL (amd_nb_misc_ids);
@@ -66,6 +68,7 @@ static const struct pci_device_id amd_nb_link_ids[] = { { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_17H_M10H_DF_F4) }, { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_17H_M30H_DF_F4) }, { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_17H_M70H_DF_F4) }, + { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_19H_DF_F4) }, { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_CNB17H_F4) }, {} };
include/linux/pci_ids.h +1 -0
@@ -549,6 +549,7 @@#define PCI_DEVICE_ID_AMD_17H_M10H_DF_F3 0x15eb#define PCI_DEVICE_ID_AMD_17H_M30H_DF_F3 0x1493#define PCI_DEVICE_ID_AMD_17H_M70H_DF_F3 0x1443 +#define PCI_DEVICE_ID_AMD_19H_DF_F3 0x1653#define PCI_DEVICE_ID_AMD_CNB17H_F3 0x1703#define PCI_DEVICE_ID_AMD_LANCE 0x2000#define PCI_DEVICE_ID_AMD_LANCE_HOME 0x2001
Signature · 1 line
2.25.1
Greg Kroah-Hartman
maintainerPATCH 190/261 PCI: Add Loongson vendor ID
In reply to Greg Kroah-HartmanFrom: Tiezhu Yang <[email protected]>
[ Upstream commit 9acb9fe18d863aacc99948963f8d5d447dc311be ]
Add the Loongson vendor ID to pci_ids.h to be used by the controller driver in the future.
The Loongson vendor ID can be found at the following link:
https://git.kernel.org/pub/scm/utils/pciutils/pciutils.git/tree/pci.ids
--- include/linux/pci_ids.h | 2 ++ 1 file changed, 2 insertions(+)
include/linux/pci_ids.h +2 -0
@@ -148,6 +148,8 @@/* Vendors and devices. Sort key: vendor first, device next. */ +#define PCI_VENDOR_ID_LOONGSON 0x0014 +#define PCI_VENDOR_ID_TTTECH 0x0357#define PCI_DEVICE_ID_TTTECH_MC322 0x000a
Signature · 1 line
2.25.1
Greg Kroah-Hartman
maintainerPATCH 191/261 serial: 8250_pci: Move Pericom IDs to pci_ids.h
In reply to Greg Kroah-HartmanFrom: Kai-Heng Feng <[email protected]>
[ Upstream commit 62a7f3009a460001eb46984395280dd900bc4ef4 ]
Move the IDs to pci_ids.h so it can be used by next patch.
--- drivers/tty/serial/8250/8250_pci.c | 6 ------ include/linux/pci_ids.h | 6 ++++++ 2 files changed, 6 insertions(+), 6 deletions(-)
drivers/tty/serial/8250/8250_pci.c +0 -6
@@ -1871,12 +1871,6 @@ pci_moxa_setup(struct serial_private *priv,#define PCIE_DEVICE_ID_WCH_CH384_4S 0x3470#define PCIE_DEVICE_ID_WCH_CH382_2S 0x3253 -#define PCI_VENDOR_ID_PERICOM 0x12D8 -#define PCI_DEVICE_ID_PERICOM_PI7C9X7951 0x7951 -#define PCI_DEVICE_ID_PERICOM_PI7C9X7952 0x7952 -#define PCI_DEVICE_ID_PERICOM_PI7C9X7954 0x7954 -#define PCI_DEVICE_ID_PERICOM_PI7C9X7958 0x7958 -#define PCI_VENDOR_ID_ACCESIO 0x494f#define PCI_DEVICE_ID_ACCESIO_PCIE_COM_2SDB 0x1051#define PCI_DEVICE_ID_ACCESIO_MPCIE_COM_2S 0x1053
include/linux/pci_ids.h +6 -0
@@ -1832,6 +1832,12 @@#define PCI_VENDOR_ID_NVIDIA_SGS 0x12d2#define PCI_DEVICE_ID_NVIDIA_SGS_RIVA128 0x0018 +#define PCI_VENDOR_ID_PERICOM 0x12D8 +#define PCI_DEVICE_ID_PERICOM_PI7C9X7951 0x7951 +#define PCI_DEVICE_ID_PERICOM_PI7C9X7952 0x7952 +#define PCI_DEVICE_ID_PERICOM_PI7C9X7954 0x7954 +#define PCI_DEVICE_ID_PERICOM_PI7C9X7958 0x7958 +#define PCI_SUBVENDOR_ID_CHASE_PCIFAST 0x12E0#define PCI_SUBDEVICE_ID_CHASE_PCIFAST4 0x0031#define PCI_SUBDEVICE_ID_CHASE_PCIFAST8 0x0021
Signature · 1 line
2.25.1
Greg Kroah-Hartman
maintainerPATCH 192/261 x86/amd_nb: Add AMD family 17h model 60h PCI IDs
In reply to Greg Kroah-HartmanFrom: Alexander Monakov <[email protected]>
[ Upstream commit a4e91825d7e1252f7cba005f1451e5464b23c15d ]
Add PCI IDs for AMD Renoir (4000-series Ryzen CPUs). This is necessary to enable support for temperature sensors via the k10temp module.
--- arch/x86/kernel/amd_nb.c | 5 +++++ include/linux/pci_ids.h | 1 + 2 files changed, 6 insertions(+)
arch/x86/kernel/amd_nb.c +5 -0
@@ -18,9 +18,11 @@#define PCI_DEVICE_ID_AMD_17H_ROOT 0x1450#define PCI_DEVICE_ID_AMD_17H_M10H_ROOT 0x15d0#define PCI_DEVICE_ID_AMD_17H_M30H_ROOT 0x1480 +#define PCI_DEVICE_ID_AMD_17H_M60H_ROOT 0x1630#define PCI_DEVICE_ID_AMD_17H_DF_F4 0x1464#define PCI_DEVICE_ID_AMD_17H_M10H_DF_F4 0x15ec#define PCI_DEVICE_ID_AMD_17H_M30H_DF_F4 0x1494 +#define PCI_DEVICE_ID_AMD_17H_M60H_DF_F4 0x144c#define PCI_DEVICE_ID_AMD_17H_M70H_DF_F4 0x1444#define PCI_DEVICE_ID_AMD_19H_DF_F4 0x1654
@@ -33,6 +35,7 @@ static const struct pci_device_id amd_root_ids[] = { { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_17H_ROOT) }, { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_17H_M10H_ROOT) }, { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_17H_M30H_ROOT) }, + { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_17H_M60H_ROOT) }, {} };
@@ -51,6 +54,7 @@ const struct pci_device_id amd_nb_misc_ids[] = { { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_17H_DF_F3) }, { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_17H_M10H_DF_F3) }, { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_17H_M30H_DF_F3) }, + { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_17H_M60H_DF_F3) }, { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_CNB17H_F3) }, { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_17H_M70H_DF_F3) }, { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_19H_DF_F3) },
@@ -67,6 +71,7 @@ static const struct pci_device_id amd_nb_link_ids[] = { { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_17H_DF_F4) }, { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_17H_M10H_DF_F4) }, { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_17H_M30H_DF_F4) }, + { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_17H_M60H_DF_F4) }, { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_17H_M70H_DF_F4) }, { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_19H_DF_F4) }, { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_CNB17H_F4) },
include/linux/pci_ids.h +1 -0
@@ -550,6 +550,7 @@#define PCI_DEVICE_ID_AMD_17H_DF_F3 0x1463#define PCI_DEVICE_ID_AMD_17H_M10H_DF_F3 0x15eb#define PCI_DEVICE_ID_AMD_17H_M30H_DF_F3 0x1493 +#define PCI_DEVICE_ID_AMD_17H_M60H_DF_F3 0x144b#define PCI_DEVICE_ID_AMD_17H_M70H_DF_F3 0x1443#define PCI_DEVICE_ID_AMD_19H_DF_F3 0x1653#define PCI_DEVICE_ID_AMD_CNB17H_F3 0x1703
Signature · 1 line
2.25.1
Greg Kroah-Hartman
maintainerPATCH 193/261 ima: Remove redundant policy rule set in add_rules()
In reply to Greg Kroah-HartmanFrom: Krzysztof Struczynski <[email protected]>
[ Upstream commit 6ee28442a465ab4c4be45e3b15015af24b1ba906 ]
Function ima_appraise_flag() returns the flag to be set in temp_ima_appraise depending on the hook identifier passed as an argument. It is not necessary to set the flag again for the POLICY_CHECK hook.
--- security/integrity/ima/ima_policy.c | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-)
security/integrity/ima/ima_policy.c +1 -4
@@ -590,11 +590,8 @@ static void add_rules(struct ima_rule_entry *entries, int count,list_add_tail (&entry->list, &ima_policy_rules); } -if (entries[i].action ==APPRAISE ) { +if (entries[i].action ==APPRAISE ) temp_ima_appraise |=ima_appraise_flag (entries[i].func); -if (entries[i].func ==POLICY_CHECK ) - temp_ima_appraise |=IMA_APPRAISE_POLICY ; - } } }
Signature · 1 line
2.25.1
Greg Kroah-Hartman
maintainerPATCH 194/261 ima: Set again build_ima_appraise variable
In reply to Greg Kroah-HartmanFrom: Krzysztof Struczynski <[email protected]>
[ Upstream commit b59fda449cf07f2db3be3a67142e6c000f5e8d79 ]
After adding the new add_rule() function in commit c52657d93b05 ("ima: refactor ima_init_policy()"), all appraisal flags are added to the temp_ima_appraise variable. Revert to the previous behavior instead of removing build_ima_appraise, to benefit from the protection offered by __ro_after_init.
The mentioned commit introduced a bug, as it makes all the flags modifiable, while build_ima_appraise flags can be protected with __ro_after_init.
--- security/integrity/ima/ima_policy.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-)
security/integrity/ima/ima_policy.c +8 -2
@@ -590,8 +590,14 @@ static void add_rules(struct ima_rule_entry *entries, int count,list_add_tail (&entry->list, &ima_policy_rules); } -if (entries[i].action ==APPRAISE ) - temp_ima_appraise |=ima_appraise_flag (entries[i].func); +if (entries[i].action ==APPRAISE ) { +if (entries != build_appraise_rules) + temp_ima_appraise |= +ima_appraise_flag (entries[i].func); +else + build_ima_appraise |= +ima_appraise_flag (entries[i].func); + } } }
Signature · 1 line
2.25.1
Greg Kroah-Hartman
maintainerPATCH 195/261 PCI: Program MPS for RCiEP devices
In reply to Greg Kroah-HartmanFrom: Ashok Raj <[email protected]>
commit aa0ce96d72dd2e1b0dfd0fb868f82876e7790878 upstream.
Root Complex Integrated Endpoints (RCiEPs) do not have an upstream bridge, so pci_configure_mps() previously ignored them, which may result in reduced performance.
Instead, program the Max_Payload_Size of RCiEPs to the maximum supported value (unless it is limited for the PCIE_BUS_PEER2PEER case). This also affects the subsequent programming of Max_Read_Request_Size because Linux programs MRRS based on the MPS value.
--- drivers/pci/probe.c | 22 +++++++++++++++++++++- 1 file changed, 21 insertions(+), 1 deletion(-)
drivers/pci/probe.c +21 -1
@@ -1889,13 +1889,33 @@ static void pci_configure_mps(struct pcistruct pci_dev *bridge =pci_upstream_bridge (dev);int mps, mpss, p_mps, rc; -if (!pci_is_pcie (dev) || !bridge || !pci_is_pcie (bridge)) +if (!pci_is_pcie (dev))return ;/* MPS and MRRS fields are of type 'RsvdP' for VFs, short-circuit out */ if (dev->is_virtfn)return ; +/* +* For Root Complex Integrated Endpoints, program the maximum +* supported value unless limited by the PCIE_BUS_PEER2PEER case. +*/ +if (pci_pcie_type (dev) ==PCI_EXP_TYPE_RC_END ) { +if (pcie_bus_config ==PCIE_BUS_PEER2PEER ) + mps =128 ; +else + mps =128 << dev->pcie_mpss; + rc =pcie_set_mps (dev, mps); +if (rc) { +pci_warn (dev,"can't set Max Payload Size to %d; if necessary, use \"pci=pcie_bus_safe\" and report a bug\n" , + mps); + } +return ; + } + +if (!bridge || !pci_is_pcie (bridge)) +return ; + mps =pcie_get_mps (dev); p_mps =pcie_get_mps (bridge);
Greg Kroah-Hartman
maintainerPATCH 196/261 e1000e: Disable TSO for buffer overrun workaround
In reply to Greg Kroah-HartmanFrom: Kai-Heng Feng <[email protected]>
commit f29801030ac67bf98b7a65d3aea67b30769d4f7c upstream.
Commit b10effb92e27 ("e1000e: fix buffer overrun while the I219 is processing DMA transactions") imposes roughly 30% performance penalty.
The commit log states that "Disabling TSO eliminates performance loss for TCP traffic without a noticeable impact on CPU performance", so let's disable TSO by default to regain the loss.
--- drivers/net/ethernet/intel/e1000e/netdev.c | 4 ++++ 1 file changed, 4 insertions(+)
drivers/net/ethernet/intel/e1000e/netdev.c +4 -0
@@ -5289,6 +5289,10 @@ static void e1000_watchdog_task(struct w/* oops */ break ; } +if (hw->mac.type == e1000_pch_spt) { + netdev->features &= ~NETIF_F_TSO ; + netdev->features &= ~NETIF_F_TSO6 ; + } }/* enable transmits in the hardware, need to do this
Greg Kroah-Hartman
maintainerPATCH 197/261 e1000e: Relax condition to trigger reset for ME workaround
In reply to Greg Kroah-HartmanFrom: Punit Agrawal <[email protected]>
commit d601afcae2febc49665008e9a79e701248d56c50 upstream.
It's an error if the value of the RX/TX tail descriptor does not match what was written. The error condition is true regardless the duration of the interference from ME. But the driver only performs the reset if E1000_ICH_FWSM_PCIM2PCI_COUNT (2000) iterations of 50us delay have transpired. The extra condition can lead to inconsistency between the state of hardware as expected by the driver.
Fix this by dropping the check for number of delay iterations.
While at it, also make __ew32_prepare() static as it's not used anywhere else.
--- drivers/net/ethernet/intel/e1000e/e1000.h | 1 - drivers/net/ethernet/intel/e1000e/netdev.c | 12 +++++------- 2 files changed, 5 insertions(+), 8 deletions(-)
drivers/net/ethernet/intel/e1000e/e1000.h +0 -1
@@ -576,7 +576,6 @@ static inline u32 __er32(struct e1000_hw#define er32 (reg) __er32(hw, E1000_##reg) -s32 __ew32_prepare (struct e1000_hw *hw);void __ew32 (struct e1000_hw *hw,unsigned long reg,u32 val);#define ew32 (reg, val) __ew32(hw, E1000_##reg, (val))
drivers/net/ethernet/intel/e1000e/netdev.c +5 -7
@@ -119,14 +119,12 @@ static const struct e1000_reg_info e1000* has bit 24 set while ME is accessing MAC CSR registers, wait if it is set * and try again a number of times. **/ -s32 __ew32_prepare (struct e1000_hw *hw) +static void __ew32_prepare (struct e1000_hw *hw) {s32 i =E1000_ICH_FWSM_PCIM2PCI_COUNT ;while ((er32 (FWSM ) &E1000_ICH_FWSM_PCIM2PCI ) && --i)udelay (50 ); - -return i; }void __ew32 (struct e1000_hw *hw,unsigned long reg,u32 val)
@@ -607,11 +605,11 @@ static void e1000e_update_rdt_wa(struct {struct e1000_adapter *adapter = rx_ring->adapter;struct e1000_hw *hw = &adapter->hw; -s32 ret_val =__ew32_prepare (hw); +__ew32_prepare (hw);writel (i, rx_ring->tail); -if (unlikely (!ret_val && (i !=readl (rx_ring->tail)))) { +if (unlikely (i !=readl (rx_ring->tail))) {u32 rctl =er32 (RCTL );ew32 (RCTL , rctl & ~E1000_RCTL_EN );
@@ -624,11 +622,11 @@ static void e1000e_update_tdt_wa(struct {struct e1000_adapter *adapter = tx_ring->adapter;struct e1000_hw *hw = &adapter->hw; -s32 ret_val =__ew32_prepare (hw); +__ew32_prepare (hw);writel (i, tx_ring->tail); -if (unlikely (!ret_val && (i !=readl (tx_ring->tail)))) { +if (unlikely (i !=readl (tx_ring->tail))) {u32 tctl =er32 (TCTL );ew32 (TCTL , tctl & ~E1000_TCTL_EN );
Greg Kroah-Hartman
maintainerPATCH 198/261 carl9170: remove P2P_GO support
In reply to Greg Kroah-HartmanFrom: Christian Lamparter <[email protected]>
commit b14fba7ebd04082f7767a11daea7f12f3593de22 upstream.
This patch follows up on a bug-report by Frank Schäfer that discovered P2P GO wasn't working with wpa_supplicant. This patch removes part of the broken P2P GO support but keeps the vif switchover code in place.
--- drivers/net/wireless/ath/carl9170/fw.c | 4 +--- drivers/net/wireless/ath/carl9170/main.c | 21 ++++----------------- 2 files changed, 5 insertions(+), 20 deletions(-)
drivers/net/wireless/ath/carl9170/fw.c +1 -3
@@ -338,9 +338,7 @@ static int carl9170_fw(struct ar9170 *ar ar->hw->wiphy->interface_modes |=BIT (NL80211_IFTYPE_ADHOC );if (SUPP (CARL9170FW_WLANTX_CAB )) { - if_comb_types |= -BIT (NL80211_IFTYPE_AP ) | -BIT (NL80211_IFTYPE_P2P_GO ); + if_comb_types |=BIT (NL80211_IFTYPE_AP );#ifdef CONFIG_MAC80211_MESH if_comb_types |=
drivers/net/wireless/ath/carl9170/main.c +4 -17
@@ -582,11 +582,10 @@ static int carl9170_init_interface(struc ar->disable_offload |= ((vif->type !=NL80211_IFTYPE_STATION ) && (vif->type !=NL80211_IFTYPE_AP )); -/* While the driver supports HW offload in a single -* P2P client configuration, it doesn't support HW -* offload in the favourit, concurrent P2P GO+CLIENT -* configuration. Hence, HW offload will always be -* disabled for P2P. +/* The driver used to have P2P GO+CLIENT support, +* but since this was dropped and we don't know if +* there are any gremlins lurking in the shadows, +* so best we keep HW offload disabled for P2P. */ ar->disable_offload |= vif->p2p;
@@ -639,18 +638,6 @@ static int carl9170_op_add_interface(strif (vif->type ==NL80211_IFTYPE_STATION )break ; -/* P2P GO [master] use-case -* Because the P2P GO station is selected dynamically -* by all participating peers of a WIFI Direct network, -* the driver has be able to change the main interface -* operating mode on the fly. -*/ -if (main_vif->p2p && vif->p2p && - vif->type ==NL80211_IFTYPE_AP ) { - old_main = main_vif; -break ; - } - err = -EBUSY ;rcu_read_unlock ();
Greg Kroah-Hartman
maintainerPATCH 199/261 media: go7007: fix a miss of snd_card_free
In reply to Greg Kroah-HartmanFrom: Chuhong Yuan <[email protected]>
commit 9453264ef58638ce8976121ac44c07a3ef375983 upstream.
go7007_snd_init() misses a snd_card_free() in an error path. Add the missed call to fix it.
--- drivers/media/usb/go7007/snd-go7007.c | 35 ++++++++++++++++------------------ 1 file changed, 17 insertions(+), 18 deletions(-)
drivers/media/usb/go7007/snd-go7007.c +17 -18
@@ -236,22 +236,18 @@ int go7007_snd_init(struct go7007 *go) gosnd->capturing =0 ; ret =snd_card_new (go->dev, index[dev], id[dev],THIS_MODULE ,0 , &gosnd->card); -if (ret <0 ) { -kfree (gosnd); -return ret; - } +if (ret <0 ) + goto free_snd; + ret =snd_device_new (gosnd->card,SNDRV_DEV_LOWLEVEL , go, &go7007_snd_device_ops); -if (ret <0 ) { -kfree (gosnd); -return ret; - } +if (ret <0 ) + goto free_card; + ret =snd_pcm_new (gosnd->card,"go7007" ,0 ,0 ,1 , &gosnd->pcm); -if (ret <0 ) { -snd_card_free (gosnd->card); -kfree (gosnd); -return ret; - } +if (ret <0 ) + goto free_card; +strscpy (gosnd->card->driver,"go7007" ,sizeof (gosnd->card->driver));strscpy (gosnd->card->shortname, go->name,sizeof (gosnd->card->shortname)); strscpy(gosnd->card->longname, gosnd->card->shortname,
@@ -262,11 +258,8 @@ int go7007_snd_init(struct go7007 *go) &go7007_snd_capture_ops); ret =snd_card_register (gosnd->card); -if (ret <0 ) { -snd_card_free (gosnd->card); -kfree (gosnd); -return ret; - } +if (ret <0 ) + goto free_card; gosnd->substream =NULL ; go->snd_context = gosnd;
@@ -274,6 +267,12 @@ int go7007_snd_init(struct go7007 *go) ++dev;return 0 ; + +free_card: +snd_card_free (gosnd->card); +free_snd: +kfree (gosnd); +return ret; }EXPORT_SYMBOL (go7007_snd_init);
Greg Kroah-Hartman
maintainerPATCH 200/261 media: cedrus: Program output format during each run
In reply to Greg Kroah-HartmanFrom: Samuel Holland <[email protected]>
commit a8876c22eab9a871834f85de83e98bbf7e6e264d upstream.
Previously, the output format was programmed as part of the ioctl() handler. However, this has two problems:
1) If there are multiple active streams with different output formats, the hardware will use whichever format was set last for both streams. Similarly, an ioctl() done in an inactive context will wrongly affect other active contexts.
2) The registers are written while the device is not actively streaming. To enable runtime PM tied to the streaming state, all hardware access needs to be moved inside cedrus_device_run().
The call to cedrus_dst_format_set() is now placed just before the codec-specific callback that programs the hardware.
--- drivers/staging/media/sunxi/cedrus/cedrus_dec.c | 2 ++ drivers/staging/media/sunxi/cedrus/cedrus_video.c | 3 --- 2 files changed, 2 insertions(+), 3 deletions(-)
drivers/staging/media/sunxi/cedrus/cedrus_dec.c +2 -0
@@ -65,6 +65,8 @@ void cedrus_device_run(void *priv)v4l2_m2m_buf_copy_metadata (run.src, run.dst, true); +cedrus_dst_format_set (dev, &ctx->dst_fmt); + dev->dec_ops[ctx->current_codec]->setup (ctx, &run);/* Complete request(s) controls if needed. */
drivers/staging/media/sunxi/cedrus/cedrus_video.c +0 -3
@@ -286,7 +286,6 @@ static int cedrus_s_fmt_vid_cap(struct f struct v4l2_format *f) {struct cedrus_ctx *ctx =cedrus_file2ctx (file); -struct cedrus_dev *dev = ctx->dev;struct vb2_queue *vq;int ret;
@@ -300,8 +299,6 @@ static int cedrus_s_fmt_vid_cap(struct f ctx->dst_fmt = f->fmt.pix; -cedrus_dst_format_set (dev, &ctx->dst_fmt); -return 0 ; }
Greg Kroah-Hartman
maintainerPATCH 201/261 serial: 8250: Avoid error message on reprobe
In reply to Greg Kroah-HartmanFrom: Lukas Wunner <[email protected]>
commit e0a851fe6b9b619527bd928aa93caaddd003f70c upstream.
If the call to uart_add_one_port() in serial8250_register_8250_port() fails, a half-initialized entry in the serial_8250ports[] array is left behind.
A subsequent reprobe of the same serial port causes that entry to be reused. Because uart->port.dev is set, uart_remove_one_port() is called for the half-initialized entry and bails out with an error message:
bcm2835-aux-uart 3f215040.serial: Removing wrong port: (null) != (ptrval)
The same happens on failure of mctrl_gpio_init() since commit 4a96895f74c9 ("tty/serial/8250: use mctrl_gpio helpers").
Fix by zeroing the uart->port.dev pointer in the probe error path.
The bug was introduced in v2.6.10 by historical commit befff6f5bf5f ("[SERIAL] Add new port registration/unregistration functions."):
https://git.kernel.org/tglx/history/c/befff6f5bf5f
The commit added an unconditional call to uart_remove_one_port() in serial8250_register_port(). In v3.7, commit 835d844d1a28 ("8250_pnp:
do pnp probe before legacy probe") made that call conditional on uart->port.dev which allows me to fix the issue by zeroing that pointer in the error path. Thus, the present commit will fix the problem as far back as v3.7 whereas still older versions need to also cherry-pick 835d844d1a28.
--- drivers/tty/serial/8250/8250_core.c | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-)
drivers/tty/serial/8250/8250_core.c +10 -4
@@ -1026,7 +1026,7 @@ int serial8250_register_8250_port(struct gpios =mctrl_gpio_init (&uart->port,0 );if (IS_ERR (gpios)) { ret =PTR_ERR (gpios); - goto out_unlock; + goto err; }else { uart->gpios = gpios; }
@@ -1075,8 +1075,10 @@ int serial8250_register_8250_port(structserial8250_apply_quirks (uart); ret =uart_add_one_port (&serial8250_reg, &uart->port); -if (ret ==0 ) - ret = uart->port.line; +if (ret) + goto err; + + ret = uart->port.line; }else { dev_info(uart->port.dev, "skipping CIR port at 0x%lx / 0x%llx, IRQ %d\n",
@@ -1098,10 +1100,14 @@ int serial8250_register_8250_port(struct } } -out_unlock:mutex_unlock (&serial_mutex);return ret; + +err: + uart->port.dev =NULL ; +mutex_unlock (&serial_mutex); +return ret; }EXPORT_SYMBOL (serial8250_register_8250_port);
Greg Kroah-Hartman
maintainerPATCH 202/261 Bluetooth: hci_bcm: fix freeing not-requested IRQ
In reply to Greg Kroah-HartmanFrom: Michał Mirosław <[email protected]>
commit 81bd5d0c62437c02caac6b3f942fcda874063cb0 upstream.
When BT module can't be initialized, but it has an IRQ, unloading the driver WARNs when trying to free not-yet-requested IRQ. Fix it by noting whether the IRQ was requested.
WARNING: CPU: 2 PID: 214 at kernel/irq/devres.c:144 devm_free_irq+0x49/0x4ca [...] WARNING: CPU: 2 PID: 214 at kernel/irq/manage.c:1746 __free_irq+0x8b/0x27c Trying to free already-free IRQ 264 Modules linked in: hci_uart(-) btbcm bluetooth ecdh_generic ecc libaes CPU: 2 PID: 214 Comm: rmmod Tainted: G W 5.6.1mq-00044-ga5f9ea098318-dirty #928
[...]
[<b016aefb>] (devm_free_irq) from [<af8ba1ff>] (bcm_close+0x97/0x118 [hci_uart]) [<af8ba1ff>] (bcm_close [hci_uart]) from [<af8b736f>] (hci_uart_unregister_device+0x33/0x3c [hci_uart]) [<af8b736f>] (hci_uart_unregister_device [hci_uart]) from [<b035930b>] (serdev_drv_remove+0x13/0x20) [<b035930b>] (serdev_drv_remove) from [<b037093b>] (device_release_driver_internal+0x97/0x118) [<b037093b>] (device_release_driver_internal) from [<b0370a0b>] (driver_detach+0x2f/0x58) [<b0370a0b>] (driver_detach) from [<b036f855>] (bus_remove_driver+0x41/0x94) [<b036f855>] (bus_remove_driver) from [<af8ba8db>] (bcm_deinit+0x1b/0x740 [hci_uart]) [<af8ba8db>] (bcm_deinit [hci_uart]) from [<af8ba86f>] (hci_uart_exit+0x13/0x30 [hci_uart]) [<af8ba86f>] (hci_uart_exit [hci_uart]) from [<b01900bd>] (sys_delete_module+0x109/0x1d0) [<b01900bd>] (sys_delete_module) from [<b0101001>] (ret_fast_syscall+0x1/0x5a)
[...]
--- drivers/bluetooth/hci_bcm.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)
drivers/bluetooth/hci_bcm.c +4 -1
@@ -107,6 +107,7 @@ struct bcm_device {u32 oper_speed;int irq;bool irq_active_low; +bool irq_acquired;#ifdef CONFIG_PM struct hci_uart *hu;
@@ -319,6 +320,8 @@ static int bcm_request_irq(struct bcm_da goto unlock; } + bdev->irq_acquired = true; +device_init_wakeup (bdev->dev, true); pm_runtime_set_autosuspend_delay(bdev->dev,
@@ -487,7 +490,7 @@ static int bcm_close(struct hci_uart *hu }if (bdev) { -if (IS_ENABLED (CONFIG_PM ) && bdev->irq >0 ) { +if (IS_ENABLED (CONFIG_PM ) && bdev->irq_acquired) {devm_free_irq (bdev->dev, bdev->irq, bdev);device_init_wakeup (bdev->dev, false);pm_runtime_disable (bdev->dev);
Greg Kroah-Hartman
maintainerPATCH 203/261 b43legacy: Fix case where channel status is corrupted
In reply to Greg Kroah-HartmanFrom: Larry Finger <[email protected]>
commit ec4d3e3a054578de34cd0b587ab8a1ac36f629d9 upstream.
This patch fixes commit 75388acd0cd8 ("add mac80211-based driver for legacy BCM43xx devices")
In https://bugzilla.kernel.org/show_bug.cgi?id=207093, a defect in b43legacy is reported. Upon testing, thus problem exists on PPC and X86 platforms, is present in the oldest kernel tested (3.2), and has been present in the driver since it was first added to the kernel.
The problem is a corrupted channel status received from the device. Both the internal card in a PowerBook G4 and the PCMCIA version (Broadcom BCM4306 with PCI ID 14e4:4320) have the problem. Only Rev, 2 (revision 4 of the 802.11 core) of the chip has been tested. No other devices using b43legacy are available for testing.
Various sources of the problem were considered. Buffer overrun and other sources of corruption within the driver were rejected because the faulty channel status is always the same, not a random value. It was concluded that the faulty data is coming from the device, probably due to a firmware bug. As that source is not available, the driver must take appropriate action to recover.
At present, the driver reports the error, and them continues to process the bad packet. This is believed that to be a mistake, and the correct action is to drop the correpted packet.
Reported-and-tested by: F. Erhard <[email protected]>
--- drivers/net/wireless/broadcom/b43legacy/xmit.c | 1 + 1 file changed, 1 insertion(+)
drivers/net/wireless/broadcom/b43legacy/xmit.c +1 -0
@@ -558,6 +558,7 @@ void b43legacy_rx(struct b43legacy_wldevdefault :b43legacywarn (dev->wl,"Unexpected value for chanstat (0x%X)\n" , chanstat); + goto drop; }memcpy (IEEE80211_SKB_RXCB (skb), &status,sizeof (status));
Greg Kroah-Hartman
maintainerPATCH 204/261 b43: Fix connection problem with WPA3
In reply to Greg Kroah-HartmanFrom: Larry Finger <[email protected]>
commit 75d057bda1fbca6ade21378aa45db712e5f7d962 upstream.
Since the driver was first introduced into the kernel, it has only handled the ciphers associated with WEP, WPA, and WPA2. It fails with WPA3 even though mac80211 can handle those additional ciphers in software, b43 did not report that it could handle them. By setting MFP_CAPABLE using ieee80211_set_hw(), the problem is fixed.
With this change, b43 will handle the ciphers it knows in hardware, and let mac80211 handle the others in software. It is not necessary to use the module parameter NOHWCRYPT to turn hardware encryption off. Although this change essentially eliminates that module parameter, I am choosing to keep it for cases where the hardware is broken, and software encryption is required for all ciphers.
--- drivers/net/wireless/broadcom/b43/main.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/net/wireless/broadcom/b43/main.c +1 -1
@@ -5569,7 +5569,7 @@ static struct b43_wl *b43_wireless_init(/* fill hw info */ ieee80211_hw_set (hw,RX_INCLUDES_FCS );ieee80211_hw_set (hw,SIGNAL_DBM ); - +ieee80211_hw_set (hw,MFP_CAPABLE ); hw->wiphy->interface_modes =BIT (NL80211_IFTYPE_AP ) | BIT(NL80211_IFTYPE_MESH_POINT) |
Greg Kroah-Hartman
maintainerPATCH 205/261 b43_legacy: Fix connection problem with WPA3
In reply to Greg Kroah-HartmanFrom: Larry Finger <[email protected]>
commit 6a29d134c04a8acebb7a95251acea7ad7abba106 upstream.
Since the driver was first introduced into the kernel, it has only handled the ciphers associated with WEP, WPA, and WPA2. It fails with WPA3 even though mac80211 can handle those additional ciphers in software, b43legacy did not report that it could handle them. By setting MFP_CAPABLE using ieee80211_set_hw(), the problem is fixed.
With this change, b43legacy will handle the ciphers it knows in hardware, and let mac80211 handle the others in software. It is not necessary to use the module parameter NOHWCRYPT to turn hardware encryption off. Although this change essentially eliminates that module parameter, I am choosing to keep it for cases where the hardware is broken, and software encryption is required for all ciphers.
--- drivers/net/wireless/broadcom/b43legacy/main.c | 1 + 1 file changed, 1 insertion(+)
drivers/net/wireless/broadcom/b43legacy/main.c +1 -0
@@ -3801,6 +3801,7 @@ static int b43legacy_wireless_init(struc/* fill hw info */ ieee80211_hw_set (hw,RX_INCLUDES_FCS );ieee80211_hw_set (hw,SIGNAL_DBM ); +ieee80211_hw_set (hw,MFP_CAPABLE );/* Allow WPA3 in software */ hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_AP) |
Greg Kroah-Hartman
maintainerPATCH 206/261 media: ov5640: fix use of destroyed mutex
In reply to Greg Kroah-HartmanFrom: Tomi Valkeinen <[email protected]>
commit bfcba38d95a0aed146a958a84a2177af1459eddc upstream.
v4l2_ctrl_handler_free() uses hdl->lock, which in ov5640 driver is set to sensor's own sensor->lock. In ov5640_remove(), the driver destroys the sensor->lock first, and then calls v4l2_ctrl_handler_free(), resulting in the use of the destroyed mutex.
Fix this by calling moving the mutex_destroy() to the end of the cleanup sequence, as there's no need to destroy the mutex as early as possible.
--- drivers/media/i2c/ov5640.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/media/i2c/ov5640.c +2 -2
@@ -3068,8 +3068,8 @@ static int ov5640_probe(struct i2c_clien free_ctrls:v4l2_ctrl_handler_free (&sensor->ctrls.handler); entity_cleanup: -mutex_destroy (&sensor->lock);media_entity_cleanup (&sensor->sd.entity); +mutex_destroy (&sensor->lock);return ret; }
@@ -3079,9 +3079,9 @@ static int ov5640_remove(struct i2c_cliestruct ov5640_dev *sensor =to_ov5640_dev (sd);v4l2_async_unregister_subdev (&sensor->sd); -mutex_destroy (&sensor->lock);media_entity_cleanup (&sensor->sd.entity);v4l2_ctrl_handler_free (&sensor->ctrls.handler); +mutex_destroy (&sensor->lock);return 0 ; }
Greg Kroah-Hartman
maintainerPATCH 207/261 clk: mediatek: assign the initial value to clk_init_data of mtk_mux
In reply to Greg Kroah-HartmanFrom: Weiyi Lu <[email protected]>
commit 571cfadcc628dd5591444f7289e27445ea732f4c upstream.
When some new clock supports are introduced, e.g. [1] it might lead to an error although it should be NULL because clk_init_data is on the stack and it might have random values if using without initialization.
Add the missing initial value to clk_init_data.
[1] https://android-review.googlesource.com/c/kernel/common/+/1278046
--- drivers/clk/mediatek/clk-mux.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/clk/mediatek/clk-mux.c +1 -1
@@ -160,7 +160,7 @@ struct clk *mtk_clk_register_mux(const s spinlock_t *lock) {struct mtk_clk_mux *clk_mux; -struct clk_init_data init; +struct clk_init_data init = {};struct clk *clk; clk_mux =kzalloc (sizeof (*clk_mux),GFP_KERNEL );
Greg Kroah-Hartman
maintainerPATCH 208/261 igb: Report speed and duplex as unknown when device is runtime suspended
In reply to Greg Kroah-HartmanFrom: Kai-Heng Feng <[email protected]>
commit 165ae7a8feb53dc47fb041357e4b253bfc927cf9 upstream.
igb device gets runtime suspended when there's no link partner. We can't get correct speed under that state:
$ cat /sys/class/net/enp3s0/speed 1000
In addition to that, an error can also be spotted in dmesg:
[ 385.991957] igb 0000:03:00.0 enp3s0: PCIe link lost
Since device can only be runtime suspended when there's no link partner, we can skip reading register and let the following logic set speed and duplex with correct status.
The more generic approach will be wrap get_link_ksettings() with begin() and complete() callbacks. However, for this particular issue, begin() calls igb_runtime_resume() , which tries to rtnl_lock() while the lock is already hold by upper ethtool layer.
So let's take this approach until the igb_runtime_resume() no longer needs to hold rtnl_lock.
--- drivers/net/ethernet/intel/igb/igb_ethtool.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
drivers/net/ethernet/intel/igb/igb_ethtool.c +2 -1
@@ -143,7 +143,8 @@ static int igb_get_link_ksettings(structu32 speed;u32 supported, advertising; - status =rd32 (E1000_STATUS ); + status =pm_runtime_suspended (&adapter->pdev->dev) ? +0 :rd32 (E1000_STATUS );if (hw->phy.media_type == e1000_media_type_copper) { supported = (SUPPORTED_10baseT_Half |
Greg Kroah-Hartman
maintainerPATCH 209/261 hwmon: (k10temp) Add AMD family 17h model 60h PCI match
In reply to Greg Kroah-HartmanFrom: Alexander Monakov <[email protected]>
commit 279f0b3a4b80660fba6faadc2ca2fa426bf3f7e9 upstream.
Add support for retrieving Tdie and Tctl on AMD Renoir (4000-series Ryzen CPUs).
It appears SMU offsets for reading current/voltage and CCD temperature have changed for this generation (reads from currently used offsets yield zeros), so those features cannot be enabled so trivially.
--- drivers/hwmon/k10temp.c | 1 + 1 file changed, 1 insertion(+)
drivers/hwmon/k10temp.c +1 -0
@@ -349,6 +349,7 @@ static const struct pci_device_id k10tem { PCI_VDEVICE(AMD, PCI_DEVICE_ID_AMD_17H_DF_F3) }, { PCI_VDEVICE(AMD, PCI_DEVICE_ID_AMD_17H_M10H_DF_F3) }, { PCI_VDEVICE(AMD, PCI_DEVICE_ID_AMD_17H_M30H_DF_F3) }, + { PCI_VDEVICE(AMD, PCI_DEVICE_ID_AMD_17H_M60H_DF_F3) }, { PCI_VDEVICE(AMD, PCI_DEVICE_ID_AMD_17H_M70H_DF_F3) }, { PCI_VDEVICE(HYGON, PCI_DEVICE_ID_AMD_17H_DF_F3) }, {}
Greg Kroah-Hartman
maintainerPATCH 210/261 EDAC/amd64: Add AMD family 17h model 60h PCI IDs
In reply to Greg Kroah-HartmanFrom: Alexander Monakov <[email protected]>
commit b6bea24d41519e8c31e4798f1c1a3f67e540c5d0 upstream.
Add support for AMD Renoir (4000-series Ryzen CPUs).
--- drivers/edac/amd64_edac.c | 13 +++++++++++++ drivers/edac/amd64_edac.h | 3 +++ 2 files changed, 16 insertions(+)
drivers/edac/amd64_edac.c +13 -0
@@ -2317,6 +2317,15 @@ static struct amd64_family_type family_t .dbam_to_cs = f17_addr_mask_to_cs_size, } }, + [F17_M60H_CPUS] = { + .ctl_name = "F17h_M60h", + .f0_id = PCI_DEVICE_ID_AMD_17H_M60H_DF_F0, + .f6_id = PCI_DEVICE_ID_AMD_17H_M60H_DF_F6, + .ops = { + .early_channel_count = f17_early_channel_count, + .dbam_to_cs = f17_addr_mask_to_cs_size, + } + }, [F17_M70H_CPUS] = { .ctl_name = "F17h_M70h", .f0_id = PCI_DEVICE_ID_AMD_17H_M70H_DF_F0,
@@ -3366,6 +3375,10 @@ static struct amd64_family_type *per_fam fam_type = &family_types[F17_M30H_CPUS ]; pvt->ops = &family_types[F17_M30H_CPUS ].ops;break ; + }else if (pvt->model >=0x60 && pvt->model <=0x6f ) { + fam_type = &family_types[F17_M60H_CPUS ]; + pvt->ops = &family_types[F17_M60H_CPUS ].ops; +break ; }else if (pvt->model >=0x70 && pvt->model <=0x7f ) { fam_type = &family_types[F17_M70H_CPUS ]; pvt->ops = &family_types[F17_M70H_CPUS ].ops;
drivers/edac/amd64_edac.h +3 -0
@@ -120,6 +120,8 @@#define PCI_DEVICE_ID_AMD_17H_M10H_DF_F6 0x15ee#define PCI_DEVICE_ID_AMD_17H_M30H_DF_F0 0x1490#define PCI_DEVICE_ID_AMD_17H_M30H_DF_F6 0x1496 +#define PCI_DEVICE_ID_AMD_17H_M60H_DF_F0 0x1448 +#define PCI_DEVICE_ID_AMD_17H_M60H_DF_F6 0x144e#define PCI_DEVICE_ID_AMD_17H_M70H_DF_F0 0x1440#define PCI_DEVICE_ID_AMD_17H_M70H_DF_F6 0x1446
@@ -291,6 +293,7 @@ enum amd_families {F17_CPUS ,F17_M10H_CPUS ,F17_M30H_CPUS , +F17_M60H_CPUS ,F17_M70H_CPUS , NUM_FAMILIES, };
Greg Kroah-Hartman
maintainerPATCH 211/261 power: vexpress: add suppress_bind_attrs to true
In reply to Greg Kroah-HartmanFrom: Anders Roxell <[email protected]>
commit 73174acc9c75960af2daa7dcbdb9781fc0d135cb upstream.
Make sure that the POWER_RESET_VEXPRESS driver won't have bind/unbind attributes available via the sysfs, so lets be explicit here and use ".suppress_bind_attrs = true" to prevent userspace from doing something silly.
--- drivers/power/reset/vexpress-poweroff.c | 1 + 1 file changed, 1 insertion(+)
drivers/power/reset/vexpress-poweroff.c +1 -0
@@ -143,6 +143,7 @@ static struct platform_driver vexpress_r .driver = { .name = "vexpress-reset", .of_match_table = vexpress_reset_of_match, + .suppress_bind_attrs = true, }, };
Greg Kroah-Hartman
maintainerPATCH 212/261 power: supply: core: fix HWMON temperature labels
In reply to Greg Kroah-HartmanFrom: Michał Mirosław <[email protected]>
commit 6b20464ad9fb5fd76ef6f219ce62156aa9639dcc upstream.
tempX_label files are swapped compared to what power_supply_hwmon_temp_to_property() uses. Make them match.
--- drivers/power/supply/power_supply_hwmon.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/power/supply/power_supply_hwmon.c +1 -1
@@ -144,7 +144,7 @@ static int power_supply_hwmon_read_strin u32 attr, int channel, const char **str) { - *str = channel ?"temp" :"temp ambient" ; + *str = channel ?"temp ambient" :"temp" ;return 0 ; }
Greg Kroah-Hartman
maintainerPATCH 213/261 power: supply: core: fix memory leak in HWMON error path
In reply to Greg Kroah-HartmanFrom: Qiushi Wu <[email protected]>
commit 1d7a7128a2e9e1f137c99b0a44e94d70a77343e3 upstream.
In function power_supply_add_hwmon_sysfs(), psyhw->props is allocated by bitmap_zalloc(). But this pointer is not deallocated when devm_add_action fail, which lead to a memory leak bug. To fix this, we replace devm_add_action with devm_add_action_or_reset.
--- drivers/power/supply/power_supply_hwmon.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/power/supply/power_supply_hwmon.c +1 -1
@@ -304,7 +304,7 @@ int power_supply_add_hwmon_sysfs(struct goto error; } - ret =devm_add_action (dev, power_supply_hwmon_bitmap_free, + ret =devm_add_action_or_reset (dev, power_supply_hwmon_bitmap_free, psyhw->props);if (ret) goto error;
Greg Kroah-Hartman
maintainerPATCH 214/261 pinctrl: samsung: Correct setting of eint wakeup mask on s5pv210
In reply to Greg Kroah-HartmanFrom: Jonathan Bakker <[email protected]>
commit b577a279914085c6b657c33e9f39ef56d96a3302 upstream.
Commit a8be2af0218c ("pinctrl: samsung: Write external wakeup interrupt mask") started writing the eint wakeup mask from the pinctrl driver. Unfortunately, it made the assumption that the private retention data was always a regmap while in the case of s5pv210 it is a raw pointer to the clock base (as the eint wakeup mask not in the PMU as with newer Exynos platforms).
--- drivers/pinctrl/samsung/pinctrl-exynos.c | 73 ++++++++++++++++++++----------- 1 file changed, 49 insertions(+), 24 deletions(-)
drivers/pinctrl/samsung/pinctrl-exynos.c +49 -24
@@ -40,6 +40,8 @@ struct exynos_irq_chip {u32 eint_pend;u32 eint_wake_mask_value;u32 eint_wake_mask_reg; +void (*set_eint_wakeup_mask)(struct samsung_pinctrl_drv_data *drvdata, +struct exynos_irq_chip *irq_chip); };static inline struct exynos_irq_chip *to_exynos_irq_chip (struct irq_chip *chip)
@@ -342,6 +344,47 @@ static int exynos_wkup_irq_set_wake(strureturn 0 ; } +static void +exynos_pinctrl_set_eint_wakeup_mask (struct samsung_pinctrl_drv_data *drvdata, +struct exynos_irq_chip *irq_chip) +{ +struct regmap *pmu_regs; + +if (!drvdata->retention_ctrl || !drvdata->retention_ctrl->priv) { +dev_warn (drvdata->dev, +"No retention data configured bank with external wakeup interrupt. Wake-up mask will not be set.\n" ); +return ; + } + + pmu_regs = drvdata->retention_ctrl->priv; +dev_info (drvdata->dev, +"Setting external wakeup interrupt mask: 0x%x\n" , + irq_chip->eint_wake_mask_value); + +regmap_write (pmu_regs, irq_chip->eint_wake_mask_reg, + irq_chip->eint_wake_mask_value); +} + +static void +s5pv210_pinctrl_set_eint_wakeup_mask (struct samsung_pinctrl_drv_data *drvdata, +struct exynos_irq_chip *irq_chip) + +{ +void __iomem *clk_base; + +if (!drvdata->retention_ctrl || !drvdata->retention_ctrl->priv) { +dev_warn (drvdata->dev, +"No retention data configured bank with external wakeup interrupt. Wake-up mask will not be set.\n" ); +return ; + } + + + clk_base = (void __iomem *) drvdata->retention_ctrl->priv; + +__raw_writel (irq_chip->eint_wake_mask_value, + clk_base + irq_chip->eint_wake_mask_reg); +} +/* * irq_chip for wakeup interrupts */
@@ -360,8 +403,9 @@ static const struct exynos_irq_chip s5pv .eint_mask = EXYNOS_WKUP_EMASK_OFFSET, .eint_pend = EXYNOS_WKUP_EPEND_OFFSET, .eint_wake_mask_value = EXYNOS_EINT_WAKEUP_MASK_DISABLED, - /* Only difference with exynos4210_wkup_irq_chip: */ + /* Only differences with exynos4210_wkup_irq_chip: */ .eint_wake_mask_reg = S5PV210_EINT_WAKEUP_MASK, + .set_eint_wakeup_mask = s5pv210_pinctrl_set_eint_wakeup_mask, };static const struct exynos_irq_chip exynos4210_wkup_irq_chip__initconst = {
@@ -380,6 +424,7 @@ static const struct exynos_irq_chip exyn .eint_pend = EXYNOS_WKUP_EPEND_OFFSET, .eint_wake_mask_value = EXYNOS_EINT_WAKEUP_MASK_DISABLED, .eint_wake_mask_reg = EXYNOS_EINT_WAKEUP_MASK, + .set_eint_wakeup_mask = exynos_pinctrl_set_eint_wakeup_mask, };static const struct exynos_irq_chip exynos7_wkup_irq_chip__initconst = {
@@ -398,6 +443,7 @@ static const struct exynos_irq_chip exyn .eint_pend = EXYNOS7_WKUP_EPEND_OFFSET, .eint_wake_mask_value = EXYNOS_EINT_WAKEUP_MASK_DISABLED, .eint_wake_mask_reg = EXYNOS5433_EINT_WAKEUP_MASK, + .set_eint_wakeup_mask = exynos_pinctrl_set_eint_wakeup_mask, };/* list of external wakeup controllers supported */
@@ -574,27 +620,6 @@ int exynos_eint_wkup_init(struct samsungreturn 0 ; } -static void -exynos_pinctrl_set_eint_wakeup_mask (struct samsung_pinctrl_drv_data *drvdata, -struct exynos_irq_chip *irq_chip) -{ -struct regmap *pmu_regs; - -if (!drvdata->retention_ctrl || !drvdata->retention_ctrl->priv) { -dev_warn (drvdata->dev, -"No retention data configured bank with external wakeup interrupt. Wake-up mask will not be set.\n" ); -return ; - } - - pmu_regs = drvdata->retention_ctrl->priv; -dev_info (drvdata->dev, -"Setting external wakeup interrupt mask: 0x%x\n" , - irq_chip->eint_wake_mask_value); - -regmap_write (pmu_regs, irq_chip->eint_wake_mask_reg, - irq_chip->eint_wake_mask_value); -} -static void exynos_pinctrl_suspend_bank (struct samsung_pinctrl_drv_data *drvdata,struct samsung_pin_bank *bank)
@@ -626,8 +651,8 @@ void exynos_pinctrl_suspend(struct samsuelse if (bank->eint_type ==EINT_TYPE_WKUP ) {if (!irq_chip) { irq_chip = bank->irq_chip; -exynos_pinctrl_set_eint_wakeup_mask (drvdata, - irq_chip); + irq_chip->set_eint_wakeup_mask (drvdata, + irq_chip); }else if (bank->irq_chip != irq_chip) { dev_warn(drvdata->dev, "More than one external wakeup interrupt chip configured (bank: %s). This is not supported by hardware nor by driver.\n",
Greg Kroah-Hartman
maintainerPATCH 215/261 pinctrl: samsung: Save/restore eint_mask over suspend for EINT_TYPE GPIOs
In reply to Greg Kroah-HartmanFrom: Jonathan Bakker <[email protected]>
commit f354157a7d184db430c1a564c506434e33b1bec5 upstream.
Currently, for EINT_TYPE GPIOs, the CON and FLTCON registers are saved and restored over a suspend/resume cycle. However, the EINT_MASK registers are not.
On S5PV210 at the very least, these registers are not retained over suspend, leading to the interrupts remaining masked upon resume and therefore no interrupts being triggered for the device. There should be no effect on any SoCs that do retain these registers as theoretically we would just be re-writing what was already there.
--- drivers/pinctrl/samsung/pinctrl-exynos.c | 9 +++++++++ 1 file changed, 9 insertions(+)
drivers/pinctrl/samsung/pinctrl-exynos.c +9 -0
@@ -267,6 +267,7 @@ struct exynos_eint_gpio_save {u32 eint_con;u32 eint_fltcon0;u32 eint_fltcon1; +u32 eint_mask; };/*
@@ -633,10 +634,13 @@ static void exynos_pinctrl_suspend_bank( + 2 * bank->eint_offset); save->eint_fltcon1 =readl (regs +EXYNOS_GPIO_EFLTCON_OFFSET +2 * bank->eint_offset +4 ); + save->eint_mask =readl (regs + bank->irq_chip->eint_mask + + bank->eint_offset);pr_debug ("%s: save con %#010x\n" , bank->name, save->eint_con);pr_debug ("%s: save fltcon0 %#010x\n" , bank->name, save->eint_fltcon0);pr_debug ("%s: save fltcon1 %#010x\n" , bank->name, save->eint_fltcon1); +pr_debug ("%s: save mask %#010x\n" , bank->name, save->eint_mask); }void exynos_pinctrl_suspend (struct samsung_pinctrl_drv_data *drvdata)
@@ -678,6 +682,9 @@ static void exynos_pinctrl_resume_bank(pr_debug ("%s: fltcon1 %#010x => %#010x\n" , bank->name,readl (regs +EXYNOS_GPIO_EFLTCON_OFFSET +2 * bank->eint_offset +4 ), save->eint_fltcon1); +pr_debug ("%s: mask %#010x => %#010x\n" , bank->name, +readl (regs + bank->irq_chip->eint_mask + + bank->eint_offset), save->eint_mask);writel (save->eint_con, regs +EXYNOS_GPIO_ECON_OFFSET + bank->eint_offset);
@@ -685,6 +692,8 @@ static void exynos_pinctrl_resume_bank( + 2 * bank->eint_offset);writel (save->eint_fltcon1, regs +EXYNOS_GPIO_EFLTCON_OFFSET +2 * bank->eint_offset +4 ); +writel (save->eint_mask, regs + bank->irq_chip->eint_mask + + bank->eint_offset); }void exynos_pinctrl_resume (struct samsung_pinctrl_drv_data *drvdata)
Greg Kroah-Hartman
maintainerPATCH 216/261 gnss: sirf: fix error return code in sirf_probe()
In reply to Greg Kroah-HartmanFrom: Wei Yongjun <[email protected]>
commit 43d7ce70ae43dd8523754b17f567417e0e75dbce upstream.
Fix to return a negative error code from the error handling case instead of 0, as done elsewhere in this function.
This avoids a use-after-free in case the driver is later unbound.
--- drivers/gnss/sirf.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-)
drivers/gnss/sirf.c +6 -2
@@ -439,14 +439,18 @@ static int sirf_probe(struct serdev_devi data->on_off =devm_gpiod_get_optional (dev,"sirf,onoff" ,GPIOD_OUT_LOW ); -if (IS_ERR (data->on_off)) +if (IS_ERR (data->on_off)) { + ret =PTR_ERR (data->on_off); goto err_put_device; + }if (data->on_off) { data->wakeup =devm_gpiod_get_optional (dev,"sirf,wakeup" ,GPIOD_IN ); -if (IS_ERR (data->wakeup)) +if (IS_ERR (data->wakeup)) { + ret =PTR_ERR (data->wakeup); goto err_put_device; + } ret =regulator_enable (data->vcc);if (ret)
Greg Kroah-Hartman
maintainerPATCH 217/261 sparc32: fix register window handling in genregs32_[gs]et()
In reply to Greg Kroah-HartmanFrom: Al Viro <[email protected]>
commit cf51e129b96847f969bfb8af1ee1516a01a70b39 upstream.
It needs access_process_vm() if the traced process does not share mm with the caller. Solution is similar to what sparc64 does. Note that genregs32_set() is only ever called with pos being 0 or 32 * sizeof(u32) (the latter - as part of PTRACE_SETREGS handling).
--- arch/sparc/kernel/ptrace_32.c | 230 ++++++++++++++++++------------------------ 1 file changed, 99 insertions(+), 131 deletions(-)
arch/sparc/kernel/ptrace_32.c +99 -131
@@ -46,82 +46,79 @@ enum sparc_regset { REGSET_FP, }; +static int regwindow32_get (struct task_struct *target, +const struct pt_regs *regs, +u32 *uregs) +{ +unsigned long reg_window = regs->u_regs[UREG_I6 ]; +int size =16 *sizeof (u32); + +if (target == current) { +if (copy_from_user (uregs, (void __user *)reg_window, size)) +return -EFAULT ; + }else { +if (access_process_vm (target, reg_window, uregs, size, +FOLL_FORCE ) != size) +return -EFAULT ; + } +return 0 ; +} + +static int regwindow32_set (struct task_struct *target, +const struct pt_regs *regs, +u32 *uregs) +{ +unsigned long reg_window = regs->u_regs[UREG_I6 ]; +int size =16 *sizeof (u32); + +if (target == current) { +if (copy_to_user ((void __user *)reg_window, uregs, size)) +return -EFAULT ; + }else { +if (access_process_vm (target, reg_window, uregs, size, +FOLL_FORCE |FOLL_WRITE ) != size) +return -EFAULT ; + } +return 0 ; +} +static int genregs32_get (struct task_struct *target,const struct user_regset *regset,unsigned int pos,unsigned int count,void *kbuf,void __user *ubuf) {const struct pt_regs *regs = target->thread.kregs; -unsigned long __user *reg_window; -unsigned long *k = kbuf; -unsigned long __user *u = ubuf; -unsigned long reg; +u32 uregs[16 ]; +int ret;if (target == current)flush_user_windows (); - pos /=sizeof (reg); - count /=sizeof (reg); + ret =user_regset_copyout (&pos, &count, &kbuf, &ubuf, + regs->u_regs, +0 ,16 *sizeof (u32)); +if (ret || !count) +return ret; -if (kbuf) { -for (; count >0 && pos <16 ; count--) - *k++ = regs->u_regs[pos++]; - - reg_window = (unsigned long __user *) regs->u_regs[UREG_I6 ]; - reg_window -=16 ; -for (; count >0 && pos <32 ; count--) { -if (get_user (*k++, ®_window[pos++])) -return -EFAULT ; - } - }else { -for (; count >0 && pos <16 ; count--) { -if (put_user (regs->u_regs[pos++], u++)) -return -EFAULT ; - } - - reg_window = (unsigned long __user *) regs->u_regs[UREG_I6 ]; - reg_window -=16 ; -for (; count >0 && pos <32 ; count--) { -if (get_user (reg, ®_window[pos++]) || -put_user (reg, u++)) -return -EFAULT ; - } - } -while (count >0 ) { -switch (pos) { -case 32 :/* PSR */ - reg = regs->psr; -break ; -case 33 :/* PC */ - reg = regs->pc; -break ; -case 34 :/* NPC */ - reg = regs->npc; -break ; -case 35 :/* Y */ - reg = regs->y; -break ; -case 36 :/* WIM */ -case 37 :/* TBR */ - reg =0 ; -break ; -default : - goto finish; - } - -if (kbuf) - *k++ = reg; -else if (put_user (reg, u++)) +if (pos <32 *sizeof (u32)) { +if (regwindow32_get (target, regs, uregs))return -EFAULT ; - pos++; - count--; + ret =user_regset_copyout (&pos, &count, &kbuf, &ubuf, + uregs, +16 *sizeof (u32),32 *sizeof (u32)); +if (ret || !count) +return ret; } -finish: - pos *=sizeof (reg); - count *=sizeof (reg); -return user_regset_copyout_zero (&pos, &count, &kbuf, &ubuf, -38 *sizeof (reg),-1 ); + uregs[0 ] = regs->psr; + uregs[1 ] = regs->pc; + uregs[2 ] = regs->npc; + uregs[3 ] = regs->y; + uregs[4 ] =0 ;/* WIM */ + uregs[5 ] =0 ;/* TBR */ +return user_regset_copyout (&pos, &count, &kbuf, &ubuf, + uregs, +32 *sizeof (u32),38 *sizeof (u32)); } static int genregs32_set(struct task_struct *target,
@@ -130,82 +127,53 @@ static int genregs32_set(struct task_str const void *kbuf, const void __user *ubuf) { struct pt_regs *regs = target->thread.kregs; -unsigned long __user *reg_window; -const unsigned long *k = kbuf; -const unsigned long __user *u = ubuf; -unsigned long reg; +u32 uregs[16 ]; +u32 psr; +int ret;if (target == current)flush_user_windows (); - pos /=sizeof (reg); - count /=sizeof (reg); - -if (kbuf) { -for (; count >0 && pos <16 ; count--) - regs->u_regs[pos++] = *k++; - - reg_window = (unsigned long __user *) regs->u_regs[UREG_I6 ]; - reg_window -=16 ; -for (; count >0 && pos <32 ; count--) { -if (put_user (*k++, ®_window[pos++])) -return -EFAULT ; - } - }else { -for (; count >0 && pos <16 ; count--) { -if (get_user (reg, u++)) -return -EFAULT ; - regs->u_regs[pos++] = reg; - } - - reg_window = (unsigned long __user *) regs->u_regs[UREG_I6 ]; - reg_window -=16 ; -for (; count >0 && pos <32 ; count--) { -if (get_user (reg, u++) || -put_user (reg, ®_window[pos++])) -return -EFAULT ; - } - } -while (count >0 ) { -unsigned long psr; - -if (kbuf) - reg = *k++; -else if (get_user (reg, u++)) -return -EFAULT ; - -switch (pos) { -case 32 :/* PSR */ - psr = regs->psr; - psr &= ~(PSR_ICC |PSR_SYSCALL ); - psr |= (reg & (PSR_ICC |PSR_SYSCALL )); - regs->psr = psr; -break ; -case 33 :/* PC */ - regs->pc = reg; -break ; -case 34 :/* NPC */ - regs->npc = reg; -break ; -case 35 :/* Y */ - regs->y = reg; -break ; -case 36 :/* WIM */ -case 37 :/* TBR */ -break ; -default : - goto finish; - } + ret =user_regset_copyin (&pos, &count, &kbuf, &ubuf, + regs->u_regs, +0 ,16 *sizeof (u32)); +if (ret || !count) +return ret; - pos++; - count--; +if (pos <32 *sizeof (u32)) { +if (regwindow32_get (target, regs, uregs)) +return -EFAULT ; + ret =user_regset_copyin (&pos, &count, &kbuf, &ubuf, + uregs, +16 *sizeof (u32),32 *sizeof (u32)); +if (ret) +return ret; +if (regwindow32_set (target, regs, uregs)) +return -EFAULT ; +if (!count) +return 0 ; } -finish: - pos *=sizeof (reg); - count *=sizeof (reg); - + ret =user_regset_copyin (&pos, &count, &kbuf, &ubuf, + &psr, +32 *sizeof (u32),33 *sizeof (u32)); +if (ret) +return ret; + regs->psr = (regs->psr & ~(PSR_ICC |PSR_SYSCALL )) | + (psr & (PSR_ICC |PSR_SYSCALL )); +if (!count) +return 0 ; + ret =user_regset_copyin (&pos, &count, &kbuf, &ubuf, + ®s->pc, +33 *sizeof (u32),34 *sizeof (u32)); +if (ret || !count) +return ret; + ret =user_regset_copyin (&pos, &count, &kbuf, &ubuf, + ®s->y, +34 *sizeof (u32),35 *sizeof (u32)); +if (ret || !count) +return ret;return user_regset_copyin_ignore (&pos, &count, &kbuf, &ubuf, -38 *sizeof (reg),-1 ); +35 *sizeof (u32),38 *sizeof (u32)); } static int fpregs32_get(struct task_struct *target,
Greg Kroah-Hartman
maintainerPATCH 218/261 sparc64: fix misuses of access_process_vm() in genregs32_[sg]et()
In reply to Greg Kroah-HartmanFrom: Al Viro <[email protected]>
commit 142cd25293f6a7ecbdff4fb0af17de6438d46433 upstream.
We do need access_process_vm() to access the target's reg_window. However, access to caller's memory (storing the result in genregs32_get(), fetching the new values in case of genregs32_set()) should be done by normal uaccess primitives.
--- arch/sparc/kernel/ptrace_64.c | 17 +++-------------- 1 file changed, 3 insertions(+), 14 deletions(-)
arch/sparc/kernel/ptrace_64.c +3 -14
@@ -572,19 +572,13 @@ static int genregs32_get(struct task_strfor (; count >0 && pos <32 ; count--) {if (access_process_vm (target, (unsigned long ) - ®_window[pos], + ®_window[pos++], ®,sizeof (reg),FOLL_FORCE ) !=sizeof (reg))return -EFAULT ; -if (access_process_vm (target, - (unsigned long ) u, - ®,sizeof (reg), -FOLL_FORCE |FOLL_WRITE ) - !=sizeof (reg)) +if (put_user (reg, u++))return -EFAULT ; - pos++; - u++; } } }
@@ -684,12 +678,7 @@ static int genregs32_set(struct task_str } }else {for (; count >0 && pos <32 ; count--) { -if (access_process_vm (target, - (unsigned long ) - u, - ®,sizeof (reg), -FOLL_FORCE ) - !=sizeof (reg)) +if (get_user (reg, u++))return -EFAULT ; if (access_process_vm(target, (unsigned long)
Greg Kroah-Hartman
maintainerPATCH 219/261 dm crypt: avoid truncating the logical block size
In reply to Greg Kroah-HartmanFrom: Eric Biggers <[email protected]>
commit 64611a15ca9da91ff532982429c44686f4593b5f upstream.
queue_limits::logical_block_size got changed from unsigned short to unsigned int, but it was forgotten to update crypt_io_hints() to use the new type. Fix it.
--- drivers/md/dm-crypt.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/md/dm-crypt.c +1 -1
@@ -2957,7 +2957,7 @@ static void crypt_io_hints(struct dm_tar limits->max_segment_size =PAGE_SIZE ; limits->logical_block_size = - max_t(unsigned short, limits->logical_block_size, cc->sector_size); +max_t (unsigned, limits->logical_block_size, cc->sector_size); limits->physical_block_size =max_t (unsigned, limits->physical_block_size, cc->sector_size); limits->io_min =max_t (unsigned, limits->io_min, cc->sector_size);
Greg Kroah-Hartman
maintainerPATCH 220/261 alpha: fix memory barriers so that they conform to the specification
In reply to Greg Kroah-HartmanFrom: Mikulas Patocka <[email protected]>
commit 54505a1e2083fc54cbe8779b97479f969cd30a00 upstream.
The commits cd0e00c10672 and 92d7223a7423 broke boot on the Alpha Avanti platform. The patches move memory barriers after a write before the write. The result is that if there's iowrite followed by ioread, there is no barrier between them.
The Alpha architecture allows reordering of the accesses to the I/O space, and the missing barrier between write and read causes hang with serial port and real time clock.
This patch makes barriers confiorm to the specification.
1. We add mb() before readX_relaxed and writeX_relaxed - memory-barriers.txt claims that these functions must be ordered w.r.t. each other. Alpha doesn't order them, so we need an explicit barrier.
2. We add mb() before reads from the I/O space - so that if there's a write followed by a read, there should be a barrier between them.
--- arch/alpha/include/asm/io.h | 74 +++++++++++++++++++++++++++++++++++--------- arch/alpha/kernel/io.c | 60 +++++++++++++++++++++++++++++++---- 2 files changed, 112 insertions(+), 22 deletions(-)
arch/alpha/include/asm/io.h +59 -15
@@ -322,14 +322,18 @@ static inline int __is_mmio(const volati#if IO_CONCAT (__IO_PREFIX,trivial_io_bw)extern inline unsigned int ioread8 (void __iomem *addr) { -unsigned int ret =IO_CONCAT (__IO_PREFIX,ioread8)(addr); +unsigned int ret; +mb (); + ret =IO_CONCAT (__IO_PREFIX,ioread8)(addr);mb ();return ret; }extern inline unsigned int ioread16 (void __iomem *addr) { -unsigned int ret =IO_CONCAT (__IO_PREFIX,ioread16)(addr); +unsigned int ret; +mb (); + ret =IO_CONCAT (__IO_PREFIX,ioread16)(addr);mb ();return ret; }
@@ -370,7 +374,9 @@ extern inline void outw(u16 b, unsigned#if IO_CONCAT (__IO_PREFIX,trivial_io_lq)extern inline unsigned int ioread32 (void __iomem *addr) { -unsigned int ret =IO_CONCAT (__IO_PREFIX,ioread32)(addr); +unsigned int ret; +mb (); + ret =IO_CONCAT (__IO_PREFIX,ioread32)(addr);mb ();return ret; }
@@ -415,14 +421,18 @@ extern inline void __raw_writew(u16 b, vextern inline u8 readb (const volatile void __iomem *addr) { -u8 ret =__raw_readb (addr); +u8 ret; +mb (); + ret =__raw_readb (addr);mb ();return ret; }extern inline u16 readw (const volatile void __iomem *addr) { -u16 ret =__raw_readw (addr); +u16 ret; +mb (); + ret =__raw_readw (addr);mb ();return ret; }
@@ -463,14 +473,18 @@ extern inline void __raw_writeq(u64 b, vextern inline u32 readl (const volatile void __iomem *addr) { -u32 ret =__raw_readl (addr); +u32 ret; +mb (); + ret =__raw_readl (addr);mb ();return ret; }extern inline u64 readq (const volatile void __iomem *addr) { -u64 ret =__raw_readq (addr); +u64 ret; +mb (); + ret =__raw_readq (addr);mb ();return ret; }
@@ -499,14 +513,44 @@ extern inline void writeq(u64 b, volatil#define outb_p outb#define outw_p outw#define outl_p outl -#define readb_relaxed (addr) __raw_readb(addr) -#define readw_relaxed (addr) __raw_readw(addr) -#define readl_relaxed (addr) __raw_readl(addr) -#define readq_relaxed (addr) __raw_readq(addr) -#define writeb_relaxed (b, addr) __raw_writeb(b, addr) -#define writew_relaxed (b, addr) __raw_writew(b, addr) -#define writel_relaxed (b, addr) __raw_writel(b, addr) -#define writeq_relaxed (b, addr) __raw_writeq(b, addr) + +extern u8 readb_relaxed (const volatile void __iomem *addr); +extern u16 readw_relaxed (const volatile void __iomem *addr); +extern u32 readl_relaxed (const volatile void __iomem *addr); +extern u64 readq_relaxed (const volatile void __iomem *addr); + +#if IO_CONCAT (__IO_PREFIX,trivial_io_bw) +extern inline u8 readb_relaxed (const volatile void __iomem *addr) +{ +mb (); +return __raw_readb (addr); +} + +extern inline u16 readw_relaxed (const volatile void __iomem *addr) +{ +mb (); +return __raw_readw (addr); +} +#endif + +#if IO_CONCAT (__IO_PREFIX,trivial_io_lq) +extern inline u32 readl_relaxed (const volatile void __iomem *addr) +{ +mb (); +return __raw_readl (addr); +} + +extern inline u64 readq_relaxed (const volatile void __iomem *addr) +{ +mb (); +return __raw_readq (addr); +} +#endif + +#define writeb_relaxed writeb +#define writew_relaxed writew +#define writel_relaxed writel +#define writeq_relaxed writeq/* * String version of IO memory access ops:
arch/alpha/kernel/io.c +53 -7
108 lines not on this page · raw message
Greg Kroah-Hartman
maintainerPATCH 221/261 powerpc/fadump: use static allocation for reserved memory ranges
In reply to Greg Kroah-HartmanFrom: Hari Bathini <[email protected]>
commit 02c04e374e176ae3a3f64a682f80702f8d2fb65d upstream.
At times, memory ranges have to be looked up during early boot, when kernel couldn't be initialized for dynamic memory allocation. In fact, reserved-ranges look up is needed during FADump memory reservation. Without accounting for reserved-ranges in reserving memory for FADump, MPIPL boot fails with memory corruption issues. So, extend memory ranges handling to support static allocation and populate reserved memory ranges during early boot.
--- arch/powerpc/include/asm/fadump-internal.h | 4 + arch/powerpc/kernel/fadump.c | 77 ++++++++++++++++------------- 2 files changed, 48 insertions(+), 33 deletions(-)
arch/powerpc/include/asm/fadump-internal.h +3 -1
@@ -64,12 +64,14 @@ struct fadump_memory_range { };/* fadump memory ranges info */ +#define RNG_NAME_SZ 16struct fadump_mrange_info { -char name[16 ]; +char name[RNG_NAME_SZ ];struct fadump_memory_range *mem_ranges;u32 mem_ranges_sz;u32 mem_range_cnt;u32 max_mem_ranges; +bool is_static; };/* Platform specific callback functions */
arch/powerpc/kernel/fadump.c +45 -32
134 lines not on this page · raw message
Greg Kroah-Hartman
maintainerPATCH 222/261 powerpc/fadump: consider reserved ranges while reserving memory
In reply to Greg Kroah-HartmanFrom: Hari Bathini <[email protected]>
commit 140777a3d8dfdb3d3f20ea7707c0f1c0ce1b0aa5 upstream.
Commit 0962e8004e97 ("powerpc/prom: Scan reserved-ranges node for memory reservations") enabled support to parse reserved-ranges DT node and reserve kernel memory falling in these ranges for F/W purposes. Memory reserved for FADump should not overlap with these ranges as it could corrupt memory meant for F/W or crash'ed kernel memory to be exported as vmcore.
But since commit 579ca1a27675 ("powerpc/fadump: make use of memblock's bottom up allocation mode"), memblock_find_in_range() is being used to find the appropriate area to reserve memory for FADump, which can't account for reserved-ranges as these ranges are reserved only after FADump memory reservation.
With reserved-ranges now being populated during early boot, look out for these memory ranges while reserving memory for FADump. Without this change, MPIPL on PowerNV systems aborts with hostboot failure, when memory reserved for FADump is less than 4096MB.
--- arch/powerpc/kernel/fadump.c | 76 +++++++++++++++++++++++++++++++++++++------ 1 file changed, 67 insertions(+), 9 deletions(-)
arch/powerpc/kernel/fadump.c +67 -9
@@ -443,10 +443,72 @@ static int __init fadump_get_boot_mem_rereturn ret; } +/* +* Returns true, if the given range overlaps with reserved memory ranges +* starting at idx. Also, updates idx to index of overlapping memory range +* with the given memory range. +* False, otherwise. +*/ +static bool overlaps_reserved_ranges (u64 base,u64 end,int *idx) +{ +bool ret = false; +int i; + +for (i = *idx; i < reserved_mrange_info.mem_range_cnt; i++) { +u64 rbase = reserved_mrange_info.mem_ranges[i].base; +u64 rend = rbase + reserved_mrange_info.mem_ranges[i].size; + +if (end <= rbase) +break ; + +if ((end > rbase) && (base < rend)) { + *idx = i; + ret = true; +break ; + } + } + +return ret; +} + +/* +* Locate a suitable memory area to reserve memory for FADump. While at it, +* lookup reserved-ranges & avoid overlap with them, as they are used by F/W. +*/ +static u64 __init fadump_locate_reserve_mem (u64 base,u64 size) +{ +struct fadump_memory_range *mrngs; +phys_addr_t mstart, mend; +int idx =0 ; +u64 i, ret =0 ; + + mrngs = reserved_mrange_info.mem_ranges; +for_each_free_mem_range (i,NUMA_NO_NODE ,MEMBLOCK_NONE , + &mstart, &mend,NULL ) { +pr_debug ("%llu) mstart: %llx, mend: %llx, base: %llx\n" , + i, mstart, mend, base); + +if (mstart > base) + base =PAGE_ALIGN (mstart); + +while ((mend > base) && ((mend - base) >= size)) { +if (!overlaps_reserved_ranges (base, base+size, &idx)) { + ret = base; + goto out; + } + + base = mrngs[idx].base + mrngs[idx].size; + base =PAGE_ALIGN (base); + } + } + +out: +return ret; +} +int __init fadump_reserve_mem (void ) { -u64 base, size, mem_boundary, bootmem_min, align =PAGE_SIZE ; -bool is_memblock_bottom_up =memblock_bottom_up (); +u64 base, size, mem_boundary, bootmem_min;int ret =1 ;if (!fw_dump.fadump_enabled)
@@ -467,9 +529,9 @@ int __init fadump_reserve_mem(void)PAGE_ALIGN (fadump_calculate_reserve_size ());#ifdef CONFIG_CMA if (!fw_dump.nocma) { - align =FADUMP_CMA_ALIGNMENT ; fw_dump.boot_memory_size = -ALIGN (fw_dump.boot_memory_size, align); +ALIGN (fw_dump.boot_memory_size, +FADUMP_CMA_ALIGNMENT ); }#endif
@@ -537,11 +599,7 @@ int __init fadump_reserve_mem(void)* Reserve memory at an offset closer to bottom of the RAM to * minimize the impact of memory hot-remove operation. */ -memblock_set_bottom_up (true); - base =memblock_find_in_range (base, mem_boundary, size, align); - -/* Restore the previous allocation mode */ -memblock_set_bottom_up (is_memblock_bottom_up); + base =fadump_locate_reserve_mem (base, size);if (!base) {pr_err ("Failed to find memory chunk for reservation!\n" );
Greg Kroah-Hartman
maintainerPATCH 223/261 powerpc/fadump: Account for memory_limit while reserving memory
In reply to Greg Kroah-HartmanFrom: Hari Bathini <[email protected]>
commit 9a2921e5baca1d25eb8d21f21d1e90581a6d0f68 upstream.
If the memory chunk found for reserving memory overshoots the memory limit imposed, do not proceed with reserving memory. Default behavior was this until commit 140777a3d8df ("powerpc/fadump: consider reserved ranges while reserving memory") changed it unwittingly.
--- arch/powerpc/kernel/fadump.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
arch/powerpc/kernel/fadump.c +1 -1
@@ -601,7 +601,7 @@ int __init fadump_reserve_mem(void)*/ base =fadump_locate_reserve_mem (base, size); -if (!base) { +if (!base || (base + size > mem_boundary)) {pr_err ("Failed to find memory chunk for reservation!\n" ); goto error_out; }
Greg Kroah-Hartman
maintainerPATCH 224/261 kernel/cpu_pm: Fix uninitted local in cpu_pm
In reply to Greg Kroah-HartmanFrom: Douglas Anderson <[email protected]>
commit b5945214b76a1f22929481724ffd448000ede914 upstream.
cpu_pm_notify() is basically a wrapper of notifier_call_chain(). notifier_call_chain() doesn't initialize *nr_calls to 0 before it starts incrementing it--presumably it's up to the callers to do this.
Unfortunately the callers of cpu_pm_notify() don't init *nr_calls. This potentially means you could get too many or two few calls to CPU_PM_ENTER_FAILED or CPU_CLUSTER_PM_ENTER_FAILED depending on the luck of the stack.
Let's fix this.
--- kernel/cpu_pm.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
kernel/cpu_pm.c +2 -2
@@ -80,7 +80,7 @@ EXPORT_SYMBOL_GPL(cpu_pm_unregister_noti*/ int cpu_pm_enter (void ) { -int nr_calls; +int nr_calls =0 ;int ret =0 ; ret =cpu_pm_notify (CPU_PM_ENTER ,-1 , &nr_calls);
@@ -131,7 +131,7 @@ EXPORT_SYMBOL_GPL(cpu_pm_exit);*/ int cpu_cluster_pm_enter (void ) { -int nr_calls; +int nr_calls =0 ;int ret =0 ; ret =cpu_pm_notify (CPU_CLUSTER_PM_ENTER ,-1 , &nr_calls);
Greg Kroah-Hartman
maintainerPATCH 225/261 ARM: tegra: Correct PL310 Auxiliary Control Register initialization
In reply to Greg Kroah-HartmanFrom: Dmitry Osipenko <[email protected]>
commit 35509737c8f958944e059d501255a0bf18361ba0 upstream.
The PL310 Auxiliary Control Register shouldn't have the "Full line of zero" optimization bit being set before L2 cache is enabled. The L2X0 driver takes care of enabling the optimization by itself.
This patch fixes a noisy error message on Tegra20 and Tegra30 telling that cache optimization is erroneously enabled without enabling it for the CPU:
L2C-310: enabling full line of zeros but not enabled in Cortex-A9
--- arch/arm/mach-tegra/tegra.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
arch/arm/mach-tegra/tegra.c +2 -2
@@ -106,8 +106,8 @@ static const char * const tegra_dt_board };DT_MACHINE_START (TEGRA_DT ,"NVIDIA Tegra SoC (Flattened Device Tree)" ) - .l2c_aux_val = 0x3c400001, - .l2c_aux_mask = 0xc20fc3fe, + .l2c_aux_val = 0x3c400000, + .l2c_aux_mask = 0xc20fc3ff, .smp = smp_ops(tegra_smp_ops), .map_io = tegra_map_common_io, .init_early = tegra_init_early,
Greg Kroah-Hartman
maintainerPATCH 226/261 soc/tegra: pmc: Select GENERIC_PINCONF
In reply to Greg Kroah-HartmanFrom: Corentin Labbe <[email protected]>
commit 5098e2b95e8e6f56266c2d5c180c75917090082a upstream.
I have hit the following build error:
armv7a-hardfloat-linux-gnueabi-ld: drivers/soc/tegra/pmc.o: in function `pinconf_generic_dt_node_to_map_pin':
pmc.c:(.text+0x500): undefined reference to pinconf_generic_dt_node_to_map' armv7a-hardfloat-linux-gnueabi-ld: drivers/soc/tegra/pmc.o:(.rodata+0x1f88): undefined reference to pinconf_generic_dt_free_map'
So SOC_TEGRA_PMC should select GENERIC_PINCONF.
--- drivers/soc/tegra/Kconfig | 1 + 1 file changed, 1 insertion(+)
drivers/soc/tegra/Kconfig +1 -0
@@ -130,6 +130,7 @@ config SOC_TEGRA_FLOWCTRL config SOC_TEGRA_PMC bool + select GENERIC_PINCONF config SOC_TEGRA_POWERGATE_BPMP def_bool y
Greg Kroah-Hartman
maintainerPATCH 227/261 ARM: dts: exynos: Fix GPIO polarity for thr GalaxyS3 CM36651 sensors bus
In reply to Greg Kroah-HartmanFrom: Marek Szyprowski <[email protected]>
commit 8807d356bfea92b0a8f04ce421800ed83400cd22 upstream.
GPIO lines for the CM36651 sensor I2C bus use the normal not the inverted polarity. This bug has been there since adding the CM36651 sensor by commit 85cb4e0bd229 ("ARM: dts: add cm36651 light/proximity sensor node for exynos4412-trats2"), but went unnoticed because the "i2c-gpio" driver ignored the GPIO polarity specified in the device-tree.
The recent conversion of "i2c-gpio" driver to the new, descriptor based GPIO API, automatically made it the DT-specified polarity aware, what broke the CM36651 sensor operation.
--- arch/arm/boot/dts/exynos4412-galaxy-s3.dtsi | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
arch/arm/boot/dts/exynos4412-galaxy-s3.dtsi +1 -1
@@ -68,7 +68,7 @@ i2c_cm36651: i2c-gpio-2 { compatible = "i2c-gpio"; - gpios = <&gpf0 0 GPIO_ACTIVE_LOW>, <&gpf0 1 GPIO_ACTIVE_LOW>; + gpios = <&gpf0 0 GPIO_ACTIVE_HIGH>, <&gpf0 1 GPIO_ACTIVE_HIGH>; i2c-gpio,delay-us = <2>; #address-cells = <1>; #size-cells = <0>;
Greg Kroah-Hartman
maintainerPATCH 228/261 ARM: dts: at91: sama5d2_ptc_ek: fix vbus pin
In reply to Greg Kroah-HartmanFrom: Ludovic Desroches <[email protected]>
commit baa998aecb75c04d62be0a4ab6b724af6d73a0f9 upstream.
The gpio property for the vbus pin doesn't match the pinctrl and is not correct.
--- arch/arm/boot/dts/at91-sama5d2_ptc_ek.dts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
arch/arm/boot/dts/at91-sama5d2_ptc_ek.dts +1 -1
@@ -40,7 +40,7 @@ ahb { usb0: gadget@300000 { - atmel,vbus-gpio = <&pioA PIN_PA27 GPIO_ACTIVE_HIGH>; + atmel,vbus-gpio = <&pioA PIN_PB11 GPIO_ACTIVE_HIGH>; pinctrl-names = "default"; pinctrl-0 = <&pinctrl_usba_vbus>; status = "okay";
Greg Kroah-Hartman
maintainerPATCH 229/261 ARM: dts: s5pv210: Set keep-power-in-suspend for SDHCI1 on Aries
In reply to Greg Kroah-HartmanFrom: Jonathan Bakker <[email protected]>
commit 869d42e6eba821905e1a0950623aadafe1a6e6d3 upstream.
SDHCI1 is connected to a BCM4329 WiFi/BT chip which requires power to be kept over suspend. As the surrounding hardware supports this, mark it as such. This fixes WiFi after a suspend/resume cycle.
--- arch/arm/boot/dts/s5pv210-aries.dtsi | 1 + 1 file changed, 1 insertion(+)
arch/arm/boot/dts/s5pv210-aries.dtsi +1 -0
@@ -454,6 +454,7 @@ pinctrl-names = "default"; cap-sd-highspeed; cap-mmc-highspeed; + keep-power-in-suspend; mmc-pwrseq = <&wifi_pwrseq>; non-removable;
Greg Kroah-Hartman
maintainerPATCH 230/261 drivers/macintosh: Fix memleak in windfarm_pm112 driver
In reply to Greg Kroah-HartmanFrom: Michael Ellerman <[email protected]>
commit 93900337b9ac2f4eca427eff6d187be2dc3b5551 upstream.
create_cpu_loop() calls smu_sat_get_sdb_partition() which does kmalloc() and returns the allocated buffer. In fact it's called twice, and neither buffer is freed.
This results in a memory leak as reported by Erhard:
unreferenced object 0xc00000047081f840 (size 32):
comm "kwindfarm", pid 203, jiffies 4294880630 (age 5552.877s)
hex dump (first 32 bytes):
c8 06 02 7f ff 02 ff 01 fb bf 00 41 00 20 00 00 ...........A. ..
00 07 89 37 00 a0 00 00 00 00 00 00 00 00 00 00 ...7............
backtrace:
[<0000000083f0a65c>] .smu_sat_get_sdb_partition+0xc4/0x2d0 [windfarm_smu_sat]
[<000000003010fcb7>] .pm112_wf_notify+0x104c/0x13bc [windfarm_pm112]
[<00000000b958b2dd>] .notifier_call_chain+0xa8/0x180
[<0000000070490868>] .blocking_notifier_call_chain+0x64/0x90
[<00000000131d8149>] .wf_thread_func+0x114/0x1a0
[<000000000d54838d>] .kthread+0x13c/0x190
[<00000000669b72bc>] .ret_from_kernel_thread+0x58/0x64
unreferenced object 0xc0000004737089f0 (size 16):
comm "kwindfarm", pid 203, jiffies 4294880879 (age 5552.050s)
hex dump (first 16 bytes):
c4 04 01 7f 22 11 e0 e6 ff 55 7b 12 ec 11 00 00 ...."....U{.....
backtrace:
[<0000000083f0a65c>] .smu_sat_get_sdb_partition+0xc4/0x2d0 [windfarm_smu_sat]
[<00000000b94ef7e1>] .pm112_wf_notify+0x1294/0x13bc [windfarm_pm112]
[<00000000b958b2dd>] .notifier_call_chain+0xa8/0x180
[<0000000070490868>] .blocking_notifier_call_chain+0x64/0x90
[<00000000131d8149>] .wf_thread_func+0x114/0x1a0
[<000000000d54838d>] .kthread+0x13c/0x190
[<00000000669b72bc>] .ret_from_kernel_thread+0x58/0x64Fix it by rearranging the logic so we deal with each buffer separately, which then makes it easy to free the buffer once we're done with it.
--- drivers/macintosh/windfarm_pm112.c | 21 +++++++++++++-------- 1 file changed, 13 insertions(+), 8 deletions(-)
drivers/macintosh/windfarm_pm112.c +13 -8
@@ -132,14 +132,6 @@ static int create_cpu_loop(int cpu)s32 tmax;int fmin; -/* Get PID params from the appropriate SAT */ - hdr =smu_sat_get_sdb_partition (chip,0xC8 + core,NULL ); -if (hdr ==NULL ) { -printk (KERN_WARNING "windfarm: can't get CPU PID fan config\n" ); -return -EINVAL ; - } - piddata = (struct smu_sdbp_cpupiddata *)&hdr[1 ]; -/* Get FVT params to get Tmax; if not found, assume default */ hdr =smu_sat_get_sdb_partition (chip,0xC4 + core,NULL );if (hdr) {
@@ -152,6 +144,16 @@ static int create_cpu_loop(int cpu)if (tmax < cpu_all_tmax) cpu_all_tmax = tmax; +kfree (hdr); + +/* Get PID params from the appropriate SAT */ + hdr =smu_sat_get_sdb_partition (chip,0xC8 + core,NULL ); +if (hdr ==NULL ) { +printk (KERN_WARNING "windfarm: can't get CPU PID fan config\n" ); +return -EINVAL ; + } + piddata = (struct smu_sdbp_cpupiddata *)&hdr[1 ]; +/* * Darwin has a minimum fan speed of 1000 rpm for the 4-way and * 515 for the 2-way. That appears to be overkill, so for now,
@@ -174,6 +176,9 @@ static int create_cpu_loop(int cpu) pid.min = fmin;wf_cpu_pid_init (&cpu_pid[cpu], &pid); + +kfree (hdr); +return 0 ; }
Greg Kroah-Hartman
maintainerPATCH 231/261 powerpc/32s: Fix another build failure with CONFIG_PPC_KUAP_DEBUG
In reply to Greg Kroah-HartmanFrom: Christophe Leroy <[email protected]>
commit 74016701fe5f873ae23bf02835407227138d874d upstream.
'thread' doesn't exist in kuap_check() macro.
Use 'current' instead.
--- arch/powerpc/include/asm/book3s/32/kup.h | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
arch/powerpc/include/asm/book3s/32/kup.h +2 -1
@@ -2,6 +2,7 @@#ifndef _ASM_POWERPC_BOOK3S_32_KUP_H#define _ASM_POWERPC_BOOK3S_32_KUP_H +#include <asm/bug.h> #include <asm/book3s/32/mmu-hash.h> #ifdef __ASSEMBLY__
@@ -75,7 +76,7 @@ .macro kuap_check current, gpr#ifdef CONFIG_PPC_KUAP_DEBUG - lwz \gpr, KUAP(thread) + lwz \gpr, THREAD + KUAP(\current) 999: twnei \gpr, 0 EMIT_BUG_ENTRY 999b, __FILE__, __LINE__, (BUGFLAG_WARNING | BUGFLAG_ONCE) #endif
Greg Kroah-Hartman
maintainerPATCH 232/261 powerpc/kasan: Fix issues by lowering KASAN_SHADOW_END
In reply to Greg Kroah-HartmanFrom: Christophe Leroy <[email protected]>
commit 3a66a24f6060e6775f8c02ac52329ea0152d7e58 upstream.
At the time being, KASAN_SHADOW_END is 0x100000000, which is 0 in 32 bits representation.
This leads to a couple of issues:
- kasan_remap_early_shadow_ro() does nothing because the comparison k_cur < k_end is always false.
- In ptdump, address comparison for markers display fails and the marker's name is printed at the start of the KASAN area instead of being printed at the end.
However, there is no need to shadow the KASAN shadow area itself, so the KASAN shadow area can stop shadowing memory at the start of itself.
With a PAGE_OFFSET set to 0xc0000000, KASAN shadow area is then going from 0xf8000000 to 0xff000000.
--- arch/powerpc/include/asm/kasan.h | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-)
arch/powerpc/include/asm/kasan.h +1 -3
@@ -23,9 +23,7 @@#define KASAN_SHADOW_OFFSET ASM_CONST(CONFIG_KASAN_SHADOW_OFFSET) -#define KASAN_SHADOW_END 0UL - -#define KASAN_SHADOW_SIZE (KASAN_SHADOW_END - KASAN_SHADOW_START) +#define KASAN_SHADOW_END (-(-KASAN_SHADOW_START >> KASAN_SHADOW_SCALE_SHIFT))#ifdef CONFIG_KASAN void kasan_early_init (void );
Greg Kroah-Hartman
maintainerPATCH 233/261 powerpc/kasan: Fix shadow pages allocation failure
In reply to Greg Kroah-HartmanFrom: Christophe Leroy <[email protected]>
commit d2a91cef9bbdeb87b7449fdab1a6be6000930210 upstream.
Doing kasan pages allocation in MMU_init is too early, kernel doesn't have access yet to the entire memory space and memblock_alloc() fails when the kernel is a bit big.
Do it from kasan_init() instead.
--- arch/powerpc/include/asm/kasan.h | 2 -- arch/powerpc/mm/init_32.c | 2 -- arch/powerpc/mm/kasan/kasan_init_32.c | 4 +++- 3 files changed, 3 insertions(+), 5 deletions(-)
arch/powerpc/include/asm/kasan.h +0 -2
@@ -27,11 +27,9 @@#ifdef CONFIG_KASAN void kasan_early_init (void ); -void kasan_mmu_init (void );void kasan_init (void );#else static inline void kasan_init (void ) { } -static inline void kasan_mmu_init (void ) { }#endif #endif /* __ASSEMBLY */
arch/powerpc/mm/init_32.c +0 -2
@@ -175,8 +175,6 @@ void __init MMU_init(void)btext_unmap ();#endif -kasan_mmu_init (); -setup_kup ();/* Shortly after that, the entire linear mapping will be available */
arch/powerpc/mm/kasan/kasan_init_32.c +3 -1
@@ -129,7 +129,7 @@ static void __init kasan_remap_early_shaflush_tlb_kernel_range (KASAN_SHADOW_START ,KASAN_SHADOW_END ); } -void __init kasan_mmu_init (void ) +static void __init kasan_mmu_init (void ) {int ret;struct memblock_region *reg;
@@ -156,6 +156,8 @@ void __init kasan_mmu_init(void)void __init kasan_init (void ) { +kasan_mmu_init (); +kasan_remap_early_shadow_ro ();clear_page (kasan_early_shadow_page);
Greg Kroah-Hartman
maintainerPATCH 234/261 powerpc/32: Disable KASAN with pages bigger than 16k
In reply to Greg Kroah-HartmanFrom: Christophe Leroy <[email protected]>
commit 888468ce725a4cd56d72dc7e5096078f7a9251a0 upstream.
Mapping of early shadow area is implemented by using a single static page table having all entries pointing to the same early shadow page. The shadow area must therefore occupy full PGD entries.
The shadow area has a size of 128MB starting at 0xf8000000. With 4k pages, a PGD entry is 4MB
With 16k pages, a PGD entry is 64MB
With 64k pages, a PGD entry is 1GB which is too big.
Until we rework the early shadow mapping, disable KASAN when the page size is too big.
--- arch/powerpc/Kconfig | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
arch/powerpc/Kconfig +1 -1
@@ -171,7 +171,7 @@ config PPC select HAVE_ARCH_AUDITSYSCALL select HAVE_ARCH_HUGE_VMAP if PPC_BOOK3S_64 && PPC_RADIX_MMU select HAVE_ARCH_JUMP_LABEL - select HAVE_ARCH_KASAN if PPC32 + select HAVE_ARCH_KASAN if PPC32 && PPC_PAGE_SHIFT <= 14 select HAVE_ARCH_KGDB select HAVE_ARCH_MMAP_RND_BITS select HAVE_ARCH_MMAP_RND_COMPAT_BITS if COMPAT
Greg Kroah-Hartman
maintainerPATCH 235/261 powerpc/64s: Dont let DT CPU features set FSCR_DSCR
In reply to Greg Kroah-HartmanFrom: Michael Ellerman <[email protected]>
commit 993e3d96fd08c3ebf7566e43be9b8cd622063e6d upstream.
The device tree CPU features binding includes FSCR bit numbers which Linux is instructed to set by firmware.
Whether that's a good idea or not, in the case of the DSCR the Linux implementation has a hard requirement that the FSCR_DSCR bit not be set by default. We use it to track when a process reads/writes to DSCR, so it must be clear to begin with.
So if firmware tells us to set FSCR_DSCR we must ignore it.
Currently this does not cause a bug in our DSCR handling because the value of FSCR that the device tree CPU features code establishes is only used by swapper. All other tasks use the value hard coded in init_task.thread.fscr.
However we'd like to fix that in a future commit, at which point this will become necessary.
--- arch/powerpc/kernel/dt_cpu_ftrs.c | 8 ++++++++ 1 file changed, 8 insertions(+)
arch/powerpc/kernel/dt_cpu_ftrs.c +8 -0
@@ -346,6 +346,14 @@ static int __init feat_enable_dscr(struc {u64 lpcr; +/* +* Linux relies on FSCR[DSCR] being clear, so that we can take the +* facility unavailable interrupt and track the task's usage of DSCR. +* See facility_unavailable_exception(). +* Clear the bit here so that feat_enable() doesn't set it. +*/ + f->fscr_bit_nr =-1 ; +feat_enable (f); lpcr =mfspr (SPRN_LPCR );
Greg Kroah-Hartman
maintainerPATCH 236/261 powerpc/64s: Save FSCR to init_task.thread.fscr after feature init
In reply to Greg Kroah-HartmanFrom: Michael Ellerman <[email protected]>
commit 912c0a7f2b5daa3cbb2bc10f303981e493de73bd upstream.
At boot the FSCR is initialised via one of two paths. On most systems it's set to a hard coded value in __init_FSCR().
On newer skiboot systems we use the device tree CPU features binding, where firmware can tell Linux what bits to set in FSCR (and HFSCR).
In both cases the value that's configured at boot is not propagated into the init_task.thread.fscr value prior to the initial fork of init (pid 1), which means the value is not used by any processes other than swapper (the idle task).
For the __init_FSCR() case this is OK, because the value in init_task.thread.fscr is initialised to something sensible. However it does mean that the value set in __init_FSCR() is not used other than for swapper, which is odd and confusing.
The bigger problem is for the device tree CPU features case it prevents firmware from setting (or clearing) FSCR bits for use by user space. This means all existing kernels can not have features enabled/disabled by firmware if those features require setting/clearing FSCR bits.
We can handle both cases by saving the FSCR value into init_task.thread.fscr after we have initialised it at boot. This fixes the bug for device tree CPU features, and will allow us to simplify the initialisation for the __init_FSCR() case in a future patch.
--- arch/powerpc/kernel/prom.c | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+)
arch/powerpc/kernel/prom.c +19 -0
@@ -685,6 +685,23 @@ static void __init tm_init(void)static void tm_init (void ) { }#endif /* CONFIG_PPC_TRANSACTIONAL_MEM */ +#ifdef CONFIG_PPC64 +static void __init save_fscr_to_task (void ) +{ +/* +* Ensure the init_task (pid 0, aka swapper) uses the value of FSCR we +* have configured via the device tree features or via __init_FSCR(). +* That value will then be propagated to pid 1 (init) and all future +* processes. +*/ +if (early_cpu_has_feature (CPU_FTR_ARCH_207S )) + init_task.thread.fscr =mfspr (SPRN_FSCR ); +} +#else +static inline void save_fscr_to_task (void ) {}; +#endif + +void __init early_init_devtree (void *params) {phys_addr_t limit;
@@ -773,6 +790,8 @@ void __init early_init_devtree(void *parBUG (); } +save_fscr_to_task (); +#if defined(CONFIG_SMP ) && defined(CONFIG_PPC64 )/* We'll later wait for secondaries to check in; there are * NCPUS-1 non-boot CPUs :-)
Greg Kroah-Hartman
maintainerPATCH 237/261 kbuild: force to build vmlinux if CONFIG_MODVERSION=y
In reply to Greg Kroah-HartmanFrom: Masahiro Yamada <[email protected]>
commit 4b50c8c4eaf06a825d1c005c0b1b4a8307087b83 upstream.
This code does not work as stated in the comment.
$(CONFIG_MODVERSIONS) is always empty because it is expanded before include/config/auto.conf is included. Hence, 'make modules' with CONFIG_MODVERSION=y cannot record the version CRCs.
This has been broken since 2003, commit ("kbuild: Enable modules to be build using the "make dir/" syntax"). [1]
--- Makefile | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-)
Makefile +8 -5
@@ -587,12 +587,8 @@ KBUILD_MODULES := KBUILD_BUILTIN := 1 # If we have only "make modules", don't compile built-in objects. -# When we're building modules with modversions, we need to consider -# the built-in objects during the descend as well, in order to -# make sure the checksums are up to date before we record them. - ifeq ($(MAKECMDGOALS),modules) - KBUILD_BUILTIN := $(if $(CONFIG_MODVERSIONS),1) + KBUILD_BUILTIN := endif # If we have "make <whatever> modules", compile modules
@@ -1282,6 +1278,13 @@ ifdef CONFIG_MODULES all: modules +# When we're building modules with modversions, we need to consider +# the built-in objects during the descend as well, in order to +# make sure the checksums are up to date before we record them. +ifdef CONFIG_MODVERSIONS + KBUILD_BUILTIN := 1 +endif + # Build modules # # A module can be listed more than once in obj-m resulting in
Greg Kroah-Hartman
maintainerPATCH 238/261 sunrpc: svcauth_gss_register_pseudoflavor must reject duplicate registrations.
In reply to Greg Kroah-HartmanFrom: NeilBrown <[email protected]>
commit d47a5dc2888fd1b94adf1553068b8dad76cec96c upstream.
There is no valid case for supporting duplicate pseudoflavor registrations.
Currently the silent acceptance of such registrations is hiding a bug. The rpcsec_gss_krb5 module registers 2 flavours but does not unregister them, so if you load, unload, reload the module, it will happily continue to use the old registration which now has pointers to the memory were the module was originally loaded. This could lead to unexpected results.
So disallow duplicate registrations.
--- net/sunrpc/auth_gss/svcauth_gss.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)
net/sunrpc/auth_gss/svcauth_gss.c +4 -2
@@ -817,9 +817,11 @@ svcauth_gss_register_pseudoflavor(u32 ps new->h.flavour = &svcauthops_gss; new->pseudoflavor = pseudoflavor; - stat =0 ; test =auth_domain_lookup (name, &new->h); -if (test != &new->h) {/* Duplicate registration */ +if (test != &new->h) { +pr_warn ("svc: duplicate registration of gss pseudo flavour %s.\n" , + name); + stat = -EADDRINUSE ;auth_domain_put (test);kfree (new->h.name); goto out_free_dom;
Greg Kroah-Hartman
maintainerPATCH 239/261 sunrpc: clean up properly in gss_mech_unregister()
In reply to Greg Kroah-HartmanFrom: NeilBrown <[email protected]>
commit 24c5efe41c29ee3e55bcf5a1c9f61ca8709622e8 upstream.
gss_mech_register() calls svcauth_gss_register_pseudoflavor() for each flavour, but gss_mech_unregister() does not call auth_domain_put(). This is unbalanced and makes it impossible to reload the module.
Change svcauth_gss_register_pseudoflavor() to return the registered auth_domain, and save it for later release.
--- include/linux/sunrpc/gss_api.h | 1 + include/linux/sunrpc/svcauth_gss.h | 3 ++- net/sunrpc/auth_gss/gss_mech_switch.c | 12 +++++++++--- net/sunrpc/auth_gss/svcauth_gss.c | 12 ++++++------ 4 files changed, 18 insertions(+), 10 deletions(-)
include/linux/sunrpc/gss_api.h +1 -0
@@ -85,6 +85,7 @@ struct pf_desc {u32 service;char *name;char *auth_domain_name; +struct auth_domain *domain;bool datatouch; };
include/linux/sunrpc/svcauth_gss.h +2 -1
@@ -21,7 +21,8 @@ int gss_svc_init(void);void gss_svc_shutdown (void );int gss_svc_init_net (struct net *net);void gss_svc_shutdown_net (struct net *net); -int svcauth_gss_register_pseudoflavor (u32 pseudoflavor,char * name); +struct auth_domain *svcauth_gss_register_pseudoflavor (u32 pseudoflavor, +char *name);u32 svcauth_gss_flavor (struct auth_domain *dom);#endif /* __KERNEL__ */
net/sunrpc/auth_gss/gss_mech_switch.c +9 -3
@@ -36,6 +36,8 @@ gss_mech_free(struct gss_api_mech *gm)for (i =0 ; i < gm->gm_pf_num; i++) { pf = &gm->gm_pfs[i]; +if (pf->domain) +auth_domain_put (pf->domain);kfree (pf->auth_domain_name); pf->auth_domain_name =NULL ; }
@@ -58,6 +60,7 @@ make_auth_domain_name(char *name)static int gss_mech_svc_setup (struct gss_api_mech *gm) { +struct auth_domain *dom;struct pf_desc *pf;int i, status;
@@ -67,10 +70,13 @@ gss_mech_svc_setup(struct gss_api_mech * status = -ENOMEM ;if (pf->auth_domain_name ==NULL ) goto out; - status =svcauth_gss_register_pseudoflavor (pf->pseudoflavor, - pf->auth_domain_name); -if (status) + dom =svcauth_gss_register_pseudoflavor ( + pf->pseudoflavor, pf->auth_domain_name); +if (IS_ERR (dom)) { + status =PTR_ERR (dom); goto out; + } + pf->domain = dom; }return 0 ; out:
net/sunrpc/auth_gss/svcauth_gss.c +6 -6
@@ -800,7 +800,7 @@ u32 svcauth_gss_flavor(struct auth_domaiEXPORT_SYMBOL_GPL (svcauth_gss_flavor); -int +struct auth_domain *svcauth_gss_register_pseudoflavor (u32 pseudoflavor,char * name) {struct gss_domain *new;
@@ -823,17 +823,17 @@ svcauth_gss_register_pseudoflavor(u32 ps name); stat = -EADDRINUSE ;auth_domain_put (test); -kfree (new->h.name); - goto out_free_dom; + goto out_free_name; } -return 0 ; +return test; +out_free_name: +kfree (new->h.name); out_free_dom:kfree (new); out: -return stat; +return ERR_PTR (stat); } -EXPORT_SYMBOL_GPL (svcauth_gss_register_pseudoflavor); static inline int
Greg Kroah-Hartman
maintainerPATCH 240/261 mtd: rawnand: Fix nand_gpio_waitrdy()
In reply to Greg Kroah-HartmanFrom: Boris Brezillon <[email protected]>
commit e45a4b652dbd2f8b5a3b8e97e89f602a58cb28aa upstream.
Mimic what's done in nand_soft_waitrdy() and add one to the jiffies timeout so we don't end up waiting less than actually required.
--- drivers/mtd/nand/raw/nand_base.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-)
drivers/mtd/nand/raw/nand_base.c +8 -2
@@ -731,8 +731,14 @@ EXPORT_SYMBOL_GPL(nand_soft_waitrdy);int nand_gpio_waitrdy (struct nand_chip *chip,struct gpio_desc *gpiod,unsigned long timeout_ms) { -/* Wait until R/B pin indicates chip is ready or timeout occurs */ - timeout_ms = jiffies +msecs_to_jiffies (timeout_ms); + +/* +* Wait until R/B pin indicates chip is ready or timeout occurs. +* +1 below is necessary because if we are now in the last fraction +* of jiffy and msecs_to_jiffies is 1 then we will wait only that +* small jiffy fraction - possibly leading to false timeout. +*/ + timeout_ms = jiffies +msecs_to_jiffies (timeout_ms) +1 ; do { if (gpiod_get_value_cansleep(gpiod)) return 0;
Greg Kroah-Hartman
maintainerPATCH 241/261 mtd: rawnand: onfi: Fix redundancy detection check
In reply to Greg Kroah-HartmanFrom: Miquel Raynal <[email protected]>
commit 1d5d08ee9b28cff907326b4ad5a2463fd2808be1 upstream.
During ONFI detection, the CRC derived from the parameter page and the CRC supposed to be at the end of the parameter page are compared. If they do not match, the second then the third copies of the page are tried.
The current implementation compares the newly derived CRC with the CRC contained in the first page only. So if this particular CRC area has been corrupted, then the detection will fail for a wrong reason.
Fix this issue by checking the derived CRC against the right one.
--- drivers/mtd/nand/raw/nand_onfi.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/mtd/nand/raw/nand_onfi.c +1 -1
@@ -173,7 +173,7 @@ int nand_onfi_detect(struct nand_chip *c }if (onfi_crc16 (ONFI_CRC_BASE , (u8 *)&p[i],254 ) == -le16_to_cpu (p->crc)) { +le16_to_cpu (p[i].crc)) {if (i)memcpy (p, &p[i],sizeof (*p));break ;
Greg Kroah-Hartman
maintainerPATCH 242/261 mtd: rawnand: brcmnand: fix hamming oob layout
In reply to Greg Kroah-HartmanFrom: Álvaro Fernández Rojas <[email protected]>
commit 130bbde4809b011faf64f99dddc14b4b01f440c3 upstream.
First 2 bytes are used in large-page nand.
--- drivers/mtd/nand/raw/brcmnand/brcmnand.c | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-)
drivers/mtd/nand/raw/brcmnand/brcmnand.c +7 -4
@@ -1019,11 +1019,14 @@ static int brcmnand_hamming_ooblayout_frif (!section) {/* * Small-page NAND use byte 6 for BBI while large-page -* NAND use byte 0. +* NAND use bytes 0 and 1. */ -if (cfg->page_size >512 ) - oobregion->offset++; - oobregion->length--; +if (cfg->page_size >512 ) { + oobregion->offset +=2 ; + oobregion->length -=2 ; + }else { + oobregion->length--; + } } }
Greg Kroah-Hartman
maintainerPATCH 243/261 mtd: rawnand: diskonchip: Fix the probe error path
In reply to Greg Kroah-HartmanFrom: Miquel Raynal <[email protected]>
commit c5be12e45940f1aa1b5dfa04db5d15ad24f7c896 upstream.
Not sure nand_cleanup() is the right function to call here but in any case it is not nand_release(). Indeed, even a comment says that calling nand_release() is a bit of a hack as there is no MTD device to unregister. So switch to nand_cleanup() for now and drop this comment.
There is no Fixes tag applying here as the use of nand_release()
in this driver predates by far the introduction of nand_cleanup() in
commit d44154f969a4 ("mtd: nand: Provide nand_cleanup() function to free NAND related resources") which makes this change possible. However, pointing this commit as the
culprit for backporting purposes makes sense even if it did not intruce
any bug.
--- drivers/mtd/nand/raw/diskonchip.c | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-)
drivers/mtd/nand/raw/diskonchip.c +2 -5
@@ -1609,13 +1609,10 @@ static int __init doc_probe(unsigned lon numchips =doc2001_init (mtd);if ((ret =nand_scan (nand, numchips)) || (ret = doc->late_init (mtd))) { -/* DBB note: i believe nand_release is necessary here, as +/* DBB note: i believe nand_cleanup is necessary here, as buffers may have been allocated in nand_base. Check with Thomas. FIX ME! */ -/* nand_release will call mtd_device_unregister, but we -haven't yet added it. This is handled without incident by -mtd_device_unregister, as far as I can tell. */ -nand_release (nand); +nand_cleanup (nand); goto fail; }
Greg Kroah-Hartman
maintainerPATCH 244/261 mtd: rawnand: sharpsl: Fix the probe error path
In reply to Greg Kroah-HartmanFrom: Miquel Raynal <[email protected]>
commit 0f44b3275b3798ccb97a2f51ac85871c30d6fbbc upstream.
nand_release() is supposed be called after MTD device registration. Here, only nand_scan() happened, so use nand_cleanup() instead.
There is no Fixes tag applying here as the use of nand_release()
in this driver predates by far the introduction of nand_cleanup() in
commit d44154f969a4 ("mtd: nand: Provide nand_cleanup() function to free NAND related resources") which makes this change possible. However, pointing this commit as the
culprit for backporting purposes makes sense.
--- drivers/mtd/nand/raw/sharpsl.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/mtd/nand/raw/sharpsl.c +1 -1
@@ -183,7 +183,7 @@ static int sharpsl_nand_probe(struct plareturn 0 ; err_add: -nand_release (this); +nand_cleanup (this); err_scan:iounmap (sharpsl->io);
Greg Kroah-Hartman
maintainerPATCH 245/261 mtd: rawnand: ingenic: Fix the probe error path
In reply to Greg Kroah-HartmanFrom: Miquel Raynal <[email protected]>
commit de17cade0e034e9b721a6db9b488014effac1e5a upstream.
nand_release() is supposed be called after MTD device registration. Here, only nand_scan() happened, so use nand_cleanup() instead.
There is no real Fixes tag applying here as the use of nand_release()
in this driver predates the introduction of nand_cleanup() in
commit d44154f969a4 ("mtd: nand: Provide nand_cleanup() function to free NAND related resources") which makes this change possible. Hence, pointing it as the commit to
fix for backporting purposes, even if this commit is not introducing
any bug makes sense.
--- drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c +1 -1
@@ -376,7 +376,7 @@ static int ingenic_nand_init_chip(struct ret =mtd_device_register (mtd,NULL ,0 );if (ret) { -nand_release (chip); +nand_cleanup (chip);return ret; }
Greg Kroah-Hartman
maintainerPATCH 246/261 mtd: rawnand: xway: Fix the probe error path
In reply to Greg Kroah-HartmanFrom: Miquel Raynal <[email protected]>
commit 34531be5e804a8e1abf314a6c3a19fe342e4a154 upstream.
nand_release() is supposed be called after MTD device registration. Here, only nand_scan() happened, so use nand_cleanup() instead.
There is no real Fixes tag applying here as the use of nand_release()
in this driver predates the introduction of nand_cleanup() in
commit d44154f969a4 ("mtd: nand: Provide nand_cleanup() function to free NAND related resources") which makes this change possible. However, pointing this commit as the
culprit for backporting purposes makes sense even if this commit is not introducing any bug.
--- drivers/mtd/nand/raw/xway_nand.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/mtd/nand/raw/xway_nand.c +1 -1
@@ -210,7 +210,7 @@ static int xway_nand_probe(struct platfo err =mtd_device_register (mtd,NULL ,0 );if (err) -nand_release (&data->chip); +nand_cleanup (&data->chip);return err; }
Greg Kroah-Hartman
maintainerPATCH 247/261 mtd: rawnand: orion: Fix the probe error path
In reply to Greg Kroah-HartmanFrom: Miquel Raynal <[email protected]>
commit be238fbf78e4c7c586dac235ab967d3e565a4d1a upstream.
nand_release() is supposed be called after MTD device registration. Here, only nand_scan() happened, so use nand_cleanup() instead.
There is no real Fixes tag applying here as the use of nand_release()
in this driver predates by far the introduction of nand_cleanup() in
commit d44154f969a4 ("mtd: nand: Provide nand_cleanup() function to free NAND related resources") which makes this change possible. However, pointing this commit as the
culprit for backporting purposes makes sense even if this commit is not introducing any bug.
--- drivers/mtd/nand/raw/orion_nand.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/mtd/nand/raw/orion_nand.c +1 -1
@@ -180,7 +180,7 @@ static int __init orion_nand_probe(struc mtd->name ="orion_nand" ; ret =mtd_device_register (mtd, board->parts, board->nr_parts);if (ret) { -nand_release (nc); +nand_cleanup (nc); goto no_dev; }
Greg Kroah-Hartman
maintainerPATCH 248/261 mtd: rawnand: socrates: Fix the probe error path
In reply to Greg Kroah-HartmanFrom: Miquel Raynal <[email protected]>
commit 9c6c2e5cc77119ce0dacb4f9feedb73ce0354421 upstream.
nand_release() is supposed be called after MTD device registration. Here, only nand_scan() happened, so use nand_cleanup() instead.
There is no real Fixes tag applying here as the use of nand_release()
in this driver predates by far the introduction of nand_cleanup() in
commit d44154f969a4 ("mtd: nand: Provide nand_cleanup() function to free NAND related resources") which makes this change possible. However, pointing this commit as the
culprit for backporting purposes makes sense even if this commit is not introducing any bug.
--- drivers/mtd/nand/raw/socrates_nand.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/mtd/nand/raw/socrates_nand.c +1 -1
@@ -169,7 +169,7 @@ static int socrates_nand_probe(struct plif (!res)return res; -nand_release (nand_chip); +nand_cleanup (nand_chip); out:iounmap (host->io_base);
Greg Kroah-Hartman
maintainerPATCH 249/261 mtd: rawnand: oxnas: Fix the probe error path
In reply to Greg Kroah-HartmanFrom: Miquel Raynal <[email protected]>
commit 154298e2a3f6c9ce1d76cdb48d89fd5b107ea1a3 upstream.
nand_release() is supposed be called after MTD device registration. Here, only nand_scan() happened, so use nand_cleanup() instead.
While at it, be consistent and move the function call in the error path thanks to a goto statement.
--- drivers/mtd/nand/raw/oxnas_nand.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)
drivers/mtd/nand/raw/oxnas_nand.c +4 -4
@@ -140,10 +140,8 @@ static int oxnas_nand_probe(struct platf goto err_release_child; err =mtd_device_register (mtd,NULL ,0 ); -if (err) { -nand_release (chip); - goto err_release_child; - } +if (err) + goto err_cleanup_nand; oxnas->chips[nchips] = chip; ++nchips;
@@ -159,6 +157,8 @@ static int oxnas_nand_probe(struct platfreturn 0 ; +err_cleanup_nand: +nand_cleanup (chip); err_release_child:of_node_put (nand_np); err_clk_unprepare:
Greg Kroah-Hartman
maintainerPATCH 250/261 mtd: rawnand: sunxi: Fix the probe error path
In reply to Greg Kroah-HartmanFrom: Miquel Raynal <[email protected]>
commit 3d84515ffd8fb657e10fa5b1215e9f095fa7efca upstream.
nand_release() is supposed be called after MTD device registration. Here, only nand_scan() happened, so use nand_cleanup() instead.
--- drivers/mtd/nand/raw/sunxi_nand.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/mtd/nand/raw/sunxi_nand.c +1 -1
@@ -2003,7 +2003,7 @@ static int sunxi_nand_chip_init(struct d ret =mtd_device_register (mtd,NULL ,0 );if (ret) {dev_err (dev,"failed to register mtd device: %d\n" , ret); -nand_release (nand); +nand_cleanup (nand);return ret; }
Greg Kroah-Hartman
maintainerPATCH 251/261 mtd: rawnand: plat_nand: Fix the probe error path
In reply to Greg Kroah-HartmanFrom: Miquel Raynal <[email protected]>
commit 5284024b4dac5e94f7f374ca905c7580dbc455e9 upstream.
nand_release() is supposed be called after MTD device registration. Here, only nand_scan() happened, so use nand_cleanup() instead.
There is no real Fixes tag applying here as the use of nand_release()
in this driver predates by far the introduction of nand_cleanup() in
commit d44154f969a4 ("mtd: nand: Provide nand_cleanup() function to free NAND related resources") which makes this change possible, hence pointing it as the commit to
fix for backporting purposes, even if this commit is not introducing
any bug.
--- drivers/mtd/nand/raw/plat_nand.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/mtd/nand/raw/plat_nand.c +1 -1
@@ -92,7 +92,7 @@ static int plat_nand_probe(struct platfoif (!err)return err; -nand_release (&data->chip); +nand_cleanup (&data->chip); out:if (pdata->ctrl.remove) pdata->ctrl.remove (pdev);
Greg Kroah-Hartman
maintainerPATCH 252/261 mtd: rawnand: pasemi: Fix the probe error path
In reply to Greg Kroah-HartmanFrom: Miquel Raynal <[email protected]>
commit f51466901c07e6930435d30b02a21f0841174f61 upstream.
nand_cleanup() is supposed to be called on error after a successful call to nand_scan() to free all NAND resources.
There is no real Fixes tag applying here as the use of nand_release()
in this driver predates by far the introduction of nand_cleanup() in
commit d44154f969a4 ("mtd: nand: Provide nand_cleanup() function to free NAND related resources") which makes this change possible, hence pointing it as the commit to
fix for backporting purposes, even if this commit is not introducing
any bug.
--- drivers/mtd/nand/raw/pasemi_nand.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
drivers/mtd/nand/raw/pasemi_nand.c +3 -1
@@ -146,7 +146,7 @@ static int pasemi_nand_probe(struct platif (mtd_device_register (pasemi_nand_mtd,NULL ,0 )) {dev_err (dev,"Unable to register MTD device\n" ); err = -ENODEV ; - goto out_lpc; + goto out_cleanup_nand; } dev_info(dev, "PA Semi NAND flash at %pR, control at I/O %x\n", &res,
@@ -154,6 +154,8 @@ static int pasemi_nand_probe(struct platreturn 0 ; + out_cleanup_nand: +nand_cleanup (chip); out_lpc:release_region (lpcctl,4 ); out_ior:
Greg Kroah-Hartman
maintainerPATCH 253/261 mtd: rawnand: mtk: Fix the probe error path
In reply to Greg Kroah-HartmanFrom: Miquel Raynal <[email protected]>
commit 8a82bbcadec877f5f938c54026278dfc1f05a332 upstream.
nand_release() is supposed be called after MTD device registration. Here, only nand_scan() happened, so use nand_cleanup() instead.
There is no real Fixes tag applying here as the use of nand_release()
in this driver predates the introduction of nand_cleanup() in
commit d44154f969a4 ("mtd: nand: Provide nand_cleanup() function to free NAND related resources") which makes this change possible. However, pointing this commit as the
culprit for backporting purposes makes sense even if this commit is not introducing any bug.
--- drivers/mtd/nand/raw/mtk_nand.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/mtd/nand/raw/mtk_nand.c +1 -1
@@ -1419,7 +1419,7 @@ static int mtk_nfc_nand_chip_init(struct ret =mtd_device_register (mtd,NULL ,0 );if (ret) {dev_err (dev,"mtd parse partition error\n" ); -nand_release (nand); +nand_cleanup (nand);return ret; }
Greg Kroah-Hartman
maintainerPATCH 254/261 mtd: rawnand: tmio: Fix the probe error path
In reply to Greg Kroah-HartmanFrom: Miquel Raynal <[email protected]>
commit 75e9a330a9bd48f97a55a08000236084fe3dae56 upstream.
nand_release() is supposed be called after MTD device registration. Here, only nand_scan() happened, so use nand_cleanup() instead.
There is no real Fixes tag applying here as the use of nand_release()
in this driver predates by far the introduction of nand_cleanup() in
commit d44154f969a4 ("mtd: nand: Provide nand_cleanup() function to free NAND related resources") which makes this change possible. However, pointing this commit as the
culprit for backporting purposes makes sense even if this commit is not introducing any bug.
--- drivers/mtd/nand/raw/tmio_nand.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/mtd/nand/raw/tmio_nand.c +1 -1
@@ -448,7 +448,7 @@ static int tmio_probe(struct platform_deif (!retval)return retval; -nand_release (nand_chip); +nand_cleanup (nand_chip); err_irq:tmio_hw_stop (dev, tmio);
Greg Kroah-Hartman
maintainerPATCH 255/261 w1: omap-hdq: cleanup to add missing newline for some dev_dbg
In reply to Greg Kroah-HartmanFrom: H. Nikolaus Schaller <[email protected]>
commit 5e02f3b31704e24537697bce54f8156bdb72b7a6 upstream.
Otherwise it will corrupt the console log during debugging.
--- drivers/w1/masters/omap_hdq.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-)
drivers/w1/masters/omap_hdq.c +5 -5
@@ -176,7 +176,7 @@ static int hdq_write_byte(struct hdq_dat/* check irqstatus */ if (!(*status &OMAP_HDQ_INT_STATUS_TXCOMPLETE )) {dev_dbg (hdq_data->dev,"timeout waiting for" -" TXCOMPLETE/RXCOMPLETE, %x" , *status); +" TXCOMPLETE/RXCOMPLETE, %x\n" , *status); ret = -ETIMEDOUT ; goto out; }
@@ -187,7 +187,7 @@ static int hdq_write_byte(struct hdq_dat OMAP_HDQ_FLAG_CLEAR, &tmp_status);if (ret) {dev_dbg (hdq_data->dev,"timeout waiting GO bit" -" return to zero, %x" , tmp_status); +" return to zero, %x\n" , tmp_status); } out:
@@ -203,7 +203,7 @@ static irqreturn_t hdq_isr(int irq, voidspin_lock_irqsave (&hdq_data->hdq_spinlock, irqflags); hdq_data->hdq_irqstatus =hdq_reg_in (hdq_data,OMAP_HDQ_INT_STATUS );spin_unlock_irqrestore (&hdq_data->hdq_spinlock, irqflags); -dev_dbg (hdq_data->dev,"hdq_isr: %x" , hdq_data->hdq_irqstatus); +dev_dbg (hdq_data->dev,"hdq_isr: %x\n" , hdq_data->hdq_irqstatus); if (hdq_data->hdq_irqstatus & (OMAP_HDQ_INT_STATUS_TXCOMPLETE | OMAP_HDQ_INT_STATUS_RXCOMPLETE
@@ -311,7 +311,7 @@ static int omap_hdq_break(struct hdq_dat tmp_status = hdq_data->hdq_irqstatus;/* check irqstatus */ if (!(tmp_status &OMAP_HDQ_INT_STATUS_TIMEOUT )) { -dev_dbg (hdq_data->dev,"timeout waiting for TIMEOUT, %x" , +dev_dbg (hdq_data->dev,"timeout waiting for TIMEOUT, %x\n" , tmp_status); ret = -ETIMEDOUT ; goto out;
@@ -338,7 +338,7 @@ static int omap_hdq_break(struct hdq_dat &tmp_status);if (ret)dev_dbg (hdq_data->dev,"timeout waiting INIT&GO bits" -" return to zero, %x" , tmp_status); +" return to zero, %x\n" , tmp_status); out:mutex_unlock (&hdq_data->hdq_mutex);
Greg Kroah-Hartman
maintainerPATCH 256/261 f2fs: fix checkpoint=disable:%u%%
In reply to Greg Kroah-HartmanFrom: Jaegeuk Kim <[email protected]>
commit 1ae18f71cb522684bac1718f5c188fb5e30eb23d upstream.
When parsing the mount option, we don't have sbi->user_block_count. Should do it after getting it.
--- fs/f2fs/f2fs.h | 1 + fs/f2fs/super.c | 25 +++++++++++++++++++------ 2 files changed, 20 insertions(+), 6 deletions(-)
fs/f2fs/f2fs.h +1 -0
@@ -138,6 +138,7 @@ struct f2fs_mount_info {int alloc_mode;/* segment allocation policy */ int fsync_mode;/* fsync policy */ bool test_dummy_encryption;/* test dummy encryption */ +block_t unusable_cap_perc;/* percentage for cap */ block_t unusable_cap;/* Amount of space allowed to be * unusable when disabling checkpoint */
fs/f2fs/super.c +19 -6
@@ -277,6 +277,22 @@ static inline void limit_reserve_root(st F2FS_OPTION(sbi).s_resgid)); } +static inline void adjust_unusable_cap_perc (struct f2fs_sb_info *sbi) +{ +if (!F2FS_OPTION (sbi).unusable_cap_perc) +return ; + +if (F2FS_OPTION (sbi).unusable_cap_perc ==100 ) +F2FS_OPTION (sbi).unusable_cap = sbi->user_block_count; +else +F2FS_OPTION (sbi).unusable_cap = (sbi->user_block_count /100 ) * +F2FS_OPTION (sbi).unusable_cap_perc; + +f2fs_info (sbi,"Adjust unusable cap for checkpoint=disable = %u / %u%%" , +F2FS_OPTION (sbi).unusable_cap, +F2FS_OPTION (sbi).unusable_cap_perc); +} +static void init_once (void *foo) {struct f2fs_inode_info *fi = (struct f2fs_inode_info *) foo;
@@ -790,12 +806,7 @@ static int parse_options(struct super_blreturn -EINVAL ;if (arg <0 || arg >100 )return -EINVAL ; -if (arg ==100 ) -F2FS_OPTION (sbi).unusable_cap = - sbi->user_block_count; -else -F2FS_OPTION (sbi).unusable_cap = - (sbi->user_block_count /100 ) * arg; +F2FS_OPTION (sbi).unusable_cap_perc = arg;set_opt (sbi,DISABLE_CHECKPOINT );break ;case Opt_checkpoint_disable_cap:
@@ -1735,6 +1746,7 @@ skip: (test_opt (sbi,POSIX_ACL ) ?SB_POSIXACL :0 );limit_reserve_root (sbi); +adjust_unusable_cap_perc (sbi); *flags = (*flags & ~SB_LAZYTIME ) | (sb->s_flags &SB_LAZYTIME );return 0 ; restore_gc:
@@ -3397,6 +3409,7 @@ try_onemore: sbi->reserved_blocks =0 ; sbi->current_reserved_blocks =0 ;limit_reserve_root (sbi); +adjust_unusable_cap_perc (sbi);for (i =0 ; i <NR_INODE_TYPE ; i++) {INIT_LIST_HEAD (&sbi->inode_list[i]);
Greg Kroah-Hartman
maintainerPATCH 257/261 perf probe: Do not show the skipped events
In reply to Greg Kroah-HartmanFrom: Masami Hiramatsu <[email protected]>
commit f41ebe9defacddeae96a872a33f0f22ced0bfcef upstream.
When a probe point is expanded to several places (like inlined) and if some of them are skipped because of blacklisted or __init function, those trace_events has no event name. It must be skipped while showing results.
Without this fix, you can see "(null):(null)" on the list,
# ./perf probe request_resource
reserve_setup is out of .text, skip it.
Added new events:
(null):(null) (on request_resource)
probe:request_resource (on request_resource)You can now use it in all perf tools, such as:
perf record -e probe:request_resource -aR sleep 1
#
With this fix, it is ignored:
# ./perf probe request_resource
reserve_setup is out of .text, skip it.
Added new events:
probe:request_resource (on request_resource)You can now use it in all perf tools, such as:
perf record -e probe:request_resource -aR sleep 1
#
--- tools/perf/builtin-probe.c | 3 +++ 1 file changed, 3 insertions(+)
tools/perf/builtin-probe.c +3 -0
@@ -364,6 +364,9 @@ static int perf_add_probe_events(structfor (k =0 ; k < pev->ntevs; k++) {struct probe_trace_event *tev = &pev->tevs[k]; +/* Skipped events have no event name */ +if (!tev->event) +continue ;/* We use tev's name for showing new events */ show_perf_probe_event(tev->group, tev->event, pev,
Greg Kroah-Hartman
maintainerPATCH 258/261 perf probe: Fix to check blacklist address correctly
In reply to Greg Kroah-HartmanFrom: Masami Hiramatsu <[email protected]>
commit 80526491c2ca6abc028c0f0dbb0707a1f35fb18a upstream.
Fix to check kprobe blacklist address correctly with relocated address by adjusting debuginfo address.
Since the address in the debuginfo is same as objdump, it is different from relocated kernel address with KASLR. Thus, 'perf probe' always misses to catch the blacklisted addresses.
Without this patch, 'perf probe' can not detect the blacklist addresses on a KASLR enabled kernel.
# perf probe kprobe_dispatcher
Failed to write event: Invalid argument
Error: Failed to add events.
#With this patch, it correctly shows the error message.
# perf probe kprobe_dispatcher
kprobe_dispatcher is blacklisted function, skip it.
Probe point 'kprobe_dispatcher' not found.
Error: Failed to add events.
#--- tools/perf/util/probe-event.c | 21 +++++++++++++++------ 1 file changed, 15 insertions(+), 6 deletions(-)
tools/perf/util/probe-event.c +15 -6
@@ -102,7 +102,7 @@ void exit_probe_symbol_maps(void)symbol__exit (); } -static struct ref_reloc_sym *kernel_get_ref_reloc_sym (void ) +static struct ref_reloc_sym *kernel_get_ref_reloc_sym (struct map **pmap) {/* kmap->ref_reloc_sym should be set if host_machine is initialized */ struct kmap *kmap;
@@ -114,6 +114,10 @@ static struct ref_reloc_sym *kernel_get_ kmap =map__kmap (map);if (!kmap)return NULL ; + +if (pmap) + *pmap = map; +return kmap->ref_reloc_sym; }
@@ -125,7 +129,7 @@ static int kernel_get_symbol_address_by_struct map *map;/* ref_reloc_sym is just a label. Need a special fix*/ - reloc_sym =kernel_get_ref_reloc_sym (); + reloc_sym =kernel_get_ref_reloc_sym (NULL );if (reloc_sym &&strcmp (name, reloc_sym->name) ==0 ) *addr = (reloc) ? reloc_sym->addr : reloc_sym->unrelocated_addr;else {
@@ -745,6 +749,7 @@ post_process_kernel_probe_trace_events(s int ntevs) {struct ref_reloc_sym *reloc_sym; +struct map *map;char *tmp;int i, skipped =0 ;
@@ -753,7 +758,7 @@ post_process_kernel_probe_trace_events(sreturn post_process_offline_probe_trace_events (tevs, ntevs, symbol_conf.vmlinux_name); - reloc_sym =kernel_get_ref_reloc_sym (); + reloc_sym =kernel_get_ref_reloc_sym (&map);if (!reloc_sym) {pr_warning ("Relocated base symbol is not found!\n" );return -EINVAL ;
@@ -764,9 +769,13 @@ post_process_kernel_probe_trace_events(scontinue ;if (tevs[i].point.retprobe && !kretprobe_offset_is_supported ())continue ; -/* If we found a wrong one, mark it by NULL symbol */ +/* +* If we found a wrong one, mark it by NULL symbol. +* Since addresses in debuginfo is same as objdump, we need +* to convert it to addresses on memory. +*/ if (kprobe_warn_out_range (tevs[i].point.symbol, - tevs[i].point.address)) { +map__objdump_2mem (map, tevs[i].point.address))) { tmp =NULL ; skipped++; }else {
@@ -2922,7 +2931,7 @@ static int find_probe_trace_events_from_/* Note that the symbols in the kmodule are not relocated */ if (!pev->uprobes && !pev->target && (!pp->retprobe ||kretprobe_offset_is_supported ())) { - reloc_sym =kernel_get_ref_reloc_sym (); + reloc_sym =kernel_get_ref_reloc_sym (NULL );if (!reloc_sym) {pr_warning ("Relocated base symbol is not found!\n" ); ret = -EINVAL ;
Greg Kroah-Hartman
maintainerPATCH 259/261 perf probe: Check address correctness by map instead of _etext
In reply to Greg Kroah-HartmanFrom: Masami Hiramatsu <[email protected]>
commit 2ae5d0d7d8868df7c05c2013c0b9cddd4d40610e upstream.
Since commit 03db8b583d1c ("perf tools: Fix maps__find_symbol_by_name()") introduced map address range check in maps__find_symbol_by_name(), we can not get "_etext" from kernel map because _etext is placed on the edge of the kernel .text section (= kernel map in perf.)
To fix this issue, this checks the address correctness by map address range information (map->start and map->end) instead of using _etext address.
This can cause an error if the target inlined function is embedded in both __init function and normal function.
For exaample, request_resource() is a normal function but also embedded in __init reserve_setup(). In this case, the probe point in reserve_setup() must be skipped.
However, without this fix, it failes to setup all probe points:
# ./perf probe -v request_resource
probe-definition(0): request_resource
symbol:request_resource file:(null) line:0 offset:0 return:0 lazy:(null)
0 arguments
Looking at the vmlinux_path (8 entries long)
Using /usr/lib/debug/lib/modules/5.5.17-200.fc31.x86_64/vmlinux for symbols
Open Debuginfo file: /usr/lib/debug/lib/modules/5.5.17-200.fc31.x86_64/vmlinux
Try to find probe point from debuginfo.
Matched function: request_resource [15e29ad]
found inline addr: 0xffffffff82fbf892
Probe point found: reserve_setup+204
found inline addr: 0xffffffff810e9790
Probe point found: request_resource+0
Found 2 probe_trace_events.
Opening /sys/kernel/debug/tracing//kprobe_events write=1
Opening /sys/kernel/debug/tracing//README write=0
Writing event: p:probe/request_resource _text+33290386
Failed to write event: Invalid argument
Error: Failed to add events. Reason: Invalid argument (Code: -22)
#With this fix,
# ./perf probe request_resource
reserve_setup is out of .text, skip it.
Added new events:
(null):(null) (on request_resource)
probe:request_resource (on request_resource)You can now use it in all perf tools, such as:
perf record -e probe:request_resource -aR sleep 1
#
--- tools/perf/util/probe-event.c | 25 +++++++++++++------------ 1 file changed, 13 insertions(+), 12 deletions(-)
tools/perf/util/probe-event.c +13 -12
@@ -236,21 +236,22 @@ static void clear_probe_trace_events(strstatic bool kprobe_blacklist__listed (unsigned long address);static bool kprobe_warn_out_range (const char *symbol,unsigned long address) { -u64 etext_addr =0 ; -int ret; +struct map *map; +bool ret = false; -/* Get the address of _etext for checking non-probable text symbol */ - ret =kernel_get_symbol_address_by_name ("_etext" , &etext_addr, - false, false); - -if (ret ==0 && etext_addr < address) -pr_warning ("%s is out of .text, skip it.\n" , symbol); -else if (kprobe_blacklist__listed (address)) + map =kernel_get_module_map (NULL ); +if (map) { + ret = address <= map->start || map->end < address; +if (ret) +pr_warning ("%s is out of .text, skip it.\n" , symbol); +map__put (map); + } +if (!ret &&kprobe_blacklist__listed (address)) {pr_warning ("%s is blacklisted function, skip it.\n" , symbol); -else -return false; + ret = true; + } -return true; +return ret; }/*
Greg Kroah-Hartman
maintainerPATCH 260/261 perf symbols: Fix debuginfo search for Ubuntu
In reply to Greg Kroah-HartmanFrom: Adrian Hunter <[email protected]>
commit 85afd35575a3c1a3a905722dde5ee70b49282e70 upstream.
Reportedly, from 19.10 Ubuntu has begun mixing up the location of some debug symbol files, putting files expected to be in /usr/lib/debug/usr/lib into /usr/lib/debug/lib instead. Fix by adding another dso_binary_type.
Example on Ubuntu 20.04
Before:
$ perf record -e intel_pt//u uname
Linux
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.030 MB perf.data ]
$ perf script --call-trace | head -5
uname 14003 [005] 15321.764958566: cbr: 42 freq: 4219 MHz (156%)
uname 14003 [005] 15321.764958566: (/usr/lib/x86_64-linux-gnu/ld-2.31.so ) 7f1e71cc4100
uname 14003 [005] 15321.764961566: (/usr/lib/x86_64-linux-gnu/ld-2.31.so ) 7f1e71cc4df0
uname 14003 [005] 15321.764961900: (/usr/lib/x86_64-linux-gnu/ld-2.31.so ) 7f1e71cc4e18
uname 14003 [005] 15321.764963233: (/usr/lib/x86_64-linux-gnu/ld-2.31.so ) 7f1e71cc5128After:
$ perf script --call-trace | head -5
uname 14003 [005] 15321.764958566: cbr: 42 freq: 4219 MHz (156%)
uname 14003 [005] 15321.764958566: (/usr/lib/x86_64-linux-gnu/ld-2.31.so ) _start
uname 14003 [005] 15321.764961566: (/usr/lib/x86_64-linux-gnu/ld-2.31.so ) _dl_start
uname 14003 [005] 15321.764961900: (/usr/lib/x86_64-linux-gnu/ld-2.31.so ) _dl_start
uname 14003 [005] 15321.764963233: (/usr/lib/x86_64-linux-gnu/ld-2.31.so ) _dl_start--- tools/perf/util/dso.c | 16 ++++++++++++++++ tools/perf/util/dso.h | 1 + tools/perf/util/probe-finder.c | 1 + tools/perf/util/symbol.c | 2 ++ 4 files changed, 20 insertions(+)
tools/perf/util/dso.c +16 -0
@@ -47,6 +47,7 @@ char dso__symtab_origin(const struct dso [DSO_BINARY_TYPE__BUILD_ID_CACHE_DEBUGINFO] = 'D', [DSO_BINARY_TYPE__FEDORA_DEBUGINFO] = 'f', [DSO_BINARY_TYPE__UBUNTU_DEBUGINFO] = 'u', + [DSO_BINARY_TYPE__MIXEDUP_UBUNTU_DEBUGINFO] = 'x', [DSO_BINARY_TYPE__OPENEMBEDDED_DEBUGINFO] = 'o', [DSO_BINARY_TYPE__BUILDID_DEBUGINFO] = 'b', [DSO_BINARY_TYPE__SYSTEM_PATH_DSO] = 'd',
@@ -129,6 +130,21 @@ int dso__read_binary_type_filename(constsnprintf (filename + len, size - len,"%s" , dso->long_name);break ; +case DSO_BINARY_TYPE__MIXEDUP_UBUNTU_DEBUGINFO : +/* +* Ubuntu can mixup /usr/lib with /lib, putting debuginfo in +* /usr/lib/debug/lib when it is expected to be in +* /usr/lib/debug/usr/lib +*/ +if (strlen (dso->long_name) <9 || +strncmp (dso->long_name,"/usr/lib/" ,9 )) { + ret =-1 ; +break ; + } + len =__symbol__join_symfs (filename, size,"/usr/lib/debug" ); +snprintf (filename + len, size - len,"%s" , dso->long_name +4 ); +break ; +case DSO_BINARY_TYPE__OPENEMBEDDED_DEBUGINFO : {const char *last_slash;
tools/perf/util/dso.h +1 -0
@@ -30,6 +30,7 @@ enum dso_binary_type {DSO_BINARY_TYPE__BUILD_ID_CACHE_DEBUGINFO ,DSO_BINARY_TYPE__FEDORA_DEBUGINFO ,DSO_BINARY_TYPE__UBUNTU_DEBUGINFO , +DSO_BINARY_TYPE__MIXEDUP_UBUNTU_DEBUGINFO ,DSO_BINARY_TYPE__BUILDID_DEBUGINFO ,DSO_BINARY_TYPE__SYSTEM_PATH_DSO , DSO_BINARY_TYPE__GUEST_KMODULE,
tools/perf/util/probe-finder.c +1 -0
@@ -101,6 +101,7 @@ enum dso_binary_type distro_dwarf_types[DSO_BINARY_TYPE__UBUNTU_DEBUGINFO ,DSO_BINARY_TYPE__OPENEMBEDDED_DEBUGINFO ,DSO_BINARY_TYPE__BUILDID_DEBUGINFO , +DSO_BINARY_TYPE__MIXEDUP_UBUNTU_DEBUGINFO , DSO_BINARY_TYPE__NOT_FOUND, };
tools/perf/util/symbol.c +2 -0
@@ -79,6 +79,7 @@ static enum dso_binary_type binary_type_DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE ,DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE_COMP ,DSO_BINARY_TYPE__OPENEMBEDDED_DEBUGINFO , +DSO_BINARY_TYPE__MIXEDUP_UBUNTU_DEBUGINFO , DSO_BINARY_TYPE__NOT_FOUND, };
@@ -1530,6 +1531,7 @@ static bool dso__is_compatible_symtab_tycase DSO_BINARY_TYPE__SYSTEM_PATH_DSO :case DSO_BINARY_TYPE__FEDORA_DEBUGINFO :case DSO_BINARY_TYPE__UBUNTU_DEBUGINFO : +case DSO_BINARY_TYPE__MIXEDUP_UBUNTU_DEBUGINFO :case DSO_BINARY_TYPE__BUILDID_DEBUGINFO :case DSO_BINARY_TYPE__OPENEMBEDDED_DEBUGINFO :return !kmod && dso->kernel ==DSO_TYPE_USER ;
Greg Kroah-Hartman
maintainerPATCH 261/261 perf symbols: Fix kernel maps for kcore and eBPF
In reply to Greg Kroah-HartmanFrom: Adrian Hunter <[email protected]>
commit 0affd0e5262b6d40f5f63466d88933e99698e240 upstream.
Adjust 'map->pgoff' also when moving a map's start address.
Example with v5.4.34 based kernel:
Before:
$ sudo tools/perf/perf record -a --kcore -e intel_pt//k sleep 1
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 1.958 MB perf.data ]
$ sudo tools/perf/perf script --itrace=e >/dev/null
Warning:
961 instruction trace errorsAfter:
$ sudo tools/perf/perf script --itrace=e >/dev/null
$Committer testing:
# uname -a Linux seventh 5.6.10-100.fc30.x86_64 #1 SMP Mon May 4 15:36:44 UTC 2020 x86_64 x86_64 x86_64 GNU/Linux #
Before:
# perf record -a --kcore -e intel_pt//k sleep 1 [ perf record: Woken up 1 times to write data ] [ perf record: Captured and wrote 0.923 MB perf.data ] # perf script --itrace=e >/dev/null Warning: 295 instruction trace errors #
After:
# perf record -a --kcore -e intel_pt//k sleep 1 [ perf record: Woken up 1 times to write data ] [ perf record: Captured and wrote 0.919 MB perf.data ] # perf script --itrace=e >/dev/null #
--- tools/perf/util/symbol.c | 2 ++ 1 file changed, 2 insertions(+)
tools/perf/util/symbol.c +2 -0
@@ -1221,6 +1221,7 @@ int map_groups__merge_in(struct map_grou m->end = old_map->start;list_add_tail (&m->node, &merged); + new_map->pgoff += old_map->end - new_map->start; new_map->start = old_map->end; } }else {
@@ -1241,6 +1242,7 @@ int map_groups__merge_in(struct map_grou* |new......| -> |new...| * |old....| -> |old....| */ + new_map->pgoff += old_map->end - new_map->start; new_map->start = old_map->end; } }
Hello!
Quoted 9 lines · Greg Kroah-Hartman
This is the start of the stable review cycle for the 5.4.48 release. There are 261 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 Sun, 21 Jun 2020 14:15:50 +0000. 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.4.48-rc1.gzor in the git tree and branch at:
git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable-rc.gitlinux-5.4.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.4.48-rc1
git repo: https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable-rc.git
git branch: linux-5.4.y
git commit: 1b895c62ebf44a0852908c0f7ce05f53006fddf0
git describe: v5.4.46-394-g1b895c62ebf4
Test details: https://qa-reports.linaro.org/lkft/linux-stable-rc-5.4-oe/build/v5.4.46-394-g1b895c62ebf4
No regressions (compared to build v5.4.47)
No fixes (compared to build v5.4.47)
Ran 32839 total tests in the following environments and test suites.
Environments
--------------
- dragonboard-410c
- hi6220-hikey
- i386
- juno-r2
- juno-r2-compat
- juno-r2-kasan
- nxp-ls2088
- qemu_arm
- qemu_arm64
- qemu_i386
- qemu_x86_64
- x15
- x86
- x86-kasan
Test Suites
-----------
* build
* kselftest
* kselftest/drivers
* kselftest/filesystems
* kselftest/net
* kselftest-vsyscall-mode-native
* kselftest-vsyscall-mode-native/drivers
* kselftest-vsyscall-mode-native/filesystems
* kselftest-vsyscall-mode-native/net
* kselftest-vsyscall-mode-none
* kselftest-vsyscall-mode-none/drivers
* kselftest-vsyscall-mode-none/filesystems
* kselftest-vsyscall-mode-none/net
* kvm-unit-tests
* libhugetlbfs
* linux-log-parser
* ltp-cap_bounds-tests
* ltp-commands-tests
* ltp-containers-tests
* ltp-controllers-tests
* ltp-cpuhotplug-tests
* ltp-crypto-tests
* ltp-cve-tests
* ltp-dio-tests
* ltp-fcntl-locktests-tests
* ltp-filecaps-tests
* ltp-fs_bind-tests
* ltp-fs_perms_simple-tests
* ltp-fs-tests
* ltp-fsx-tests
* ltp-hugetlb-tests
* ltp-io-tests
* ltp-ipc-tests
* ltp-math-tests
* ltp-mm-tests
* ltp-nptl-tests
* ltp-open-posix-tests
* ltp-pty-tests
* ltp-sched-tests
* ltp-securebits-tests
* ltp-syscalls-tests
* network-basic-tests
* perf
* v4l2-compliance
Greetings!
Daniel Díaz
[email protected]
Signature · 2 lines
Linaro LKFT https://lkft.linaro.org
Quoted 8 lines · Greg Kroah-Hartman
This is the start of the stable review cycle for the 5.4.48 release. There are 261 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 Sun, 21 Jun 2020 14:15:50 +0000. Anything received after that time might be too late.
Build results:
total: 157 pass: 146 fail: 11 Failed builds: <most mips> Qemu test results: total: 429 pass: 370 fail: 59
Failed tests:
<all mips>
arch/mips/mm/dma-noncoherent.c: In function 'cpu_needs_post_dma_flush':arch/mips/mm/dma-noncoherent.c:36:7: error: 'CPU_LOONGSON2EF' undeclared
Guenter