genirq: PM: Use runtime PM for chained interrupts
Subsystems (9)
Sasha Levin
maintainerPATCH 1/22 genirq: PM: Use runtime PM for chained interrupts
From: Marc Zyngier <[email protected]>
[ Upstream commit 668a9fe5c6a1bcac6b65d5e9b91a9eca86f782a3 ]
When requesting an interrupt, we correctly call into the runtime PM framework to guarantee that the underlying interrupt controller is up and running.
However, we fail to do so for chained interrupt controllers, as the mux interrupt is not requested along the same path.
Augment __irq_do_set_handler() to call into the runtime PM code in this case, making sure the PM flow is the same for all interrupts.
--- kernel/irq/chip.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)
kernel/irq/chip.c +4 -1
@@ -1006,8 +1006,10 @@ __irq_do_set_handler(struct irq_desc *desc, irq_flow_handler_t handle,if (desc->irq_data.chip != &no_irq_chip)mask_ack_irq (desc);irq_state_set_disabled (desc); -if (is_chained) +if (is_chained) { desc->action =NULL ; +WARN_ON (irq_chip_pm_put (irq_desc_get_irq_data (desc))); + } desc->depth =1 ; } desc->handle_irq = handle;
@@ -1033,6 +1035,7 @@ __irq_do_set_handler(struct irq_desc *desc, irq_flow_handler_t handle,irq_settings_set_norequest (desc);irq_settings_set_nothread (desc); desc->action = &chained_action; +WARN_ON (irq_chip_pm_get (irq_desc_get_irq_data (desc)));irq_activate_and_startup (desc,IRQ_RESEND ); } }
Signature · 1 line
2.35.1
Sasha Levin
maintainerPATCH 2/22 irqchip/uniphier-aidet: Add compatible string for NX1 SoC
From: Kunihiko Hayashi <[email protected]>
[ Upstream commit e3f056a7aafabe4ac3ad4b7465ba821b44a7e639 ]
Add the compatible string to support UniPhier NX1 SoC, which has the same kinds of controls as the other UniPhier SoCs.
--- drivers/irqchip/irq-uniphier-aidet.c | 1 + 1 file changed, 1 insertion(+)
drivers/irqchip/irq-uniphier-aidet.c +1 -0
@@ -237,6 +237,7 @@ static const struct of_device_id uniphier_aidet_match[] = { { .compatible = "socionext,uniphier-ld11-aidet" }, { .compatible = "socionext,uniphier-ld20-aidet" }, { .compatible = "socionext,uniphier-pxs3-aidet" }, + { .compatible = "socionext,uniphier-nx1-aidet" }, {/* sentinel */ } };
Signature · 7 lines
2.35.1 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Sasha Levin
maintainerPATCH 3/22 staging: rtl8723bs: Allocate full pwep structure
In reply to Sasha LevinFrom: Kees Cook <[email protected]>
[ Upstream commit 67ea0a2adbf667cd6da4965fbcfd0da741035084 ]
The pwep allocation was always being allocated smaller than the true structure size. Avoid this by always allocating the full structure. Found with GCC 12 and -Warray-bounds:
../drivers/staging/rtl8723bs/os_dep/ioctl_linux.c: In function 'rtw_set_encryption':../drivers/staging/rtl8723bs/os_dep/ioctl_linux.c:591:29: warning: array subscript 'struct ndis_802_11_wep[0]' is partly outside array bounds of 'void[25]' [-Warray-bounds]
591 | pwep->length = wep_total_len;
| ^~
--- drivers/staging/rtl8723bs/os_dep/ioctl_linux.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)
drivers/staging/rtl8723bs/os_dep/ioctl_linux.c +4 -2
@@ -90,7 +90,8 @@ static int wpa_set_encryption(struct net_device *dev, struct ieee_param *param,if (wep_key_len >0 ) { wep_key_len = wep_key_len <=5 ?5 :13 ; wep_total_len = wep_key_len + FIELD_OFFSET(struct ndis_802_11_wep, key_material); - pwep =kzalloc (wep_total_len,GFP_KERNEL ); +/* Allocate a full structure to avoid potentially running off the end. */ + pwep =kzalloc (sizeof (*pwep),GFP_KERNEL );if (!pwep) { ret = -ENOMEM ; goto exit;
@@ -582,7 +583,8 @@ static int rtw_set_encryption(struct net_device *dev, struct ieee_param *param,if (wep_key_len >0 ) { wep_key_len = wep_key_len <=5 ?5 :13 ; wep_total_len = wep_key_len + FIELD_OFFSET(struct ndis_802_11_wep, key_material); - pwep =kzalloc (wep_total_len,GFP_KERNEL ); +/* Allocate a full structure to avoid potentially running off the end. */ + pwep =kzalloc (sizeof (*pwep),GFP_KERNEL );if (!pwep) goto exit;
Signature · 1 line
2.35.1
Sasha Levin
maintainerPATCH 4/22 mei: me: set internal pg flag to off on hardware reset
In reply to Sasha LevinFrom: Alexander Usyskin <[email protected]>
[ Upstream commit 9f4639373e6756e1ccf0029f861f1061db3c3616 ]
Link reset flow is always performed in the runtime resumed state. The internal PG state may be left as ON after the suspend and will not be updated upon the resume if the D0i3 is not supported.
Ensure that the internal PG state is set to the right value on the flow entrance in case the firmware does not support D0i3.
--- drivers/misc/mei/hw-me.c | 2 ++ 1 file changed, 2 insertions(+)
drivers/misc/mei/hw-me.c +2 -0
@@ -1154,6 +1154,8 @@ static int mei_me_hw_reset(struct mei_device *dev, bool intr_enable) ret =mei_me_d0i3_exit_sync (dev);if (ret)return ret; + }else { + hw->pg_state =MEI_PG_OFF ; } }
Signature · 1 line
2.35.1
Sasha Levin
maintainerPATCH 5/22 eeprom: at25: Split reads into chunks and cap write size
In reply to Sasha LevinFrom: Brad Bishop <[email protected]>
[ Upstream commit 0a35780c755ccec097d15c6b4ff8b246a89f1689 ]
Make use of spi_max_transfer_size to avoid requesting transfers that are too large for some spi controllers.
--- drivers/misc/eeprom/at25.c | 93 ++++++++++++++++++++++---------------- 1 file changed, 53 insertions(+), 40 deletions(-)
drivers/misc/eeprom/at25.c +53 -40
@@ -79,6 +79,11 @@ static int at25_ee_read(void *priv, unsigned int offset, {struct at25_data *at25 = priv;char *buf = val; +size_t max_chunk =spi_max_transfer_size (at25->spi); +size_t num_msgs =DIV_ROUND_UP (count, max_chunk); +size_t nr_bytes =0 ; +unsigned int msg_offset; +size_t msg_count;u8 *cp;ssize_t status;struct spi_transfer t[2 ];
@@ -92,54 +97,59 @@ static int at25_ee_read(void *priv, unsigned int offset,if (unlikely (!count))return -EINVAL ; - cp = at25->command; + msg_offset = (unsigned int )offset; + msg_count =min (count, max_chunk); +while (num_msgs) { + cp = at25->command; - instr =AT25_READ ; -if (at25->chip.flags &EE_INSTR_BIT3_IS_ADDR ) -if (offset >=BIT (at25->addrlen *8 )) - instr |=AT25_INSTR_BIT3 ; + instr =AT25_READ ; +if (at25->chip.flags &EE_INSTR_BIT3_IS_ADDR ) +if (msg_offset >=BIT (at25->addrlen *8 )) + instr |=AT25_INSTR_BIT3 ; -mutex_lock (&at25->lock); +mutex_lock (&at25->lock); - *cp++ = instr; - -/* 8/16/24-bit address is written MSB first */ -switch (at25->addrlen) { -default :/* case 3 */ - *cp++ = offset >>16 ; - fallthrough; -case 2 : - *cp++ = offset >>8 ; - fallthrough; -case 1 : -case 0 :/* can't happen: for better code generation */ - *cp++ = offset >>0 ; - } + *cp++ = instr; -spi_message_init (&m); -memset (t,0 ,sizeof (t)); +/* 8/16/24-bit address is written MSB first */ +switch (at25->addrlen) { +default :/* case 3 */ + *cp++ = msg_offset >>16 ; + fallthrough; +case 2 : + *cp++ = msg_offset >>8 ; + fallthrough; +case 1 : +case 0 :/* can't happen: for better code generation */ + *cp++ = msg_offset >>0 ; + } - t[0 ].tx_buf = at25->command; - t[0 ].len = at25->addrlen +1 ; -spi_message_add_tail (&t[0 ], &m); +spi_message_init (&m); +memset (t,0 ,sizeof (t)); - t[1 ].rx_buf = buf; - t[1 ].len = count; -spi_message_add_tail (&t[1 ], &m); + t[0 ].tx_buf = at25->command; + t[0 ].len = at25->addrlen +1 ; +spi_message_add_tail (&t[0 ], &m); -/* -* Read it all at once. -* -* REVISIT that's potentially a problem with large chips, if -* other devices on the bus need to be accessed regularly or -* this chip is clocked very slowly. -*/ - status =spi_sync (at25->spi, &m); -dev_dbg (&at25->spi->dev,"read %zu bytes at %d --> %zd\n" , - count, offset, status); + t[1 ].rx_buf = buf + nr_bytes; + t[1 ].len = msg_count; +spi_message_add_tail (&t[1 ], &m); -mutex_unlock (&at25->lock); -return status; + status =spi_sync (at25->spi, &m); + +mutex_unlock (&at25->lock); + +if (status) +return status; + + --num_msgs; + msg_offset += msg_count; + nr_bytes += msg_count; + } + +dev_dbg (&at25->spi->dev,"read %zu bytes at %d\n" , + count, offset); +return 0 ; }/* Read extra registers as ID or serial number */
@@ -190,6 +200,7 @@ ATTRIBUTE_GROUPS(sernum);static int at25_ee_write (void *priv,unsigned int off,void *val,size_t count) {struct at25_data *at25 = priv; +size_t maxsz =spi_max_transfer_size (at25->spi);const char *buf = val;int status =0 ;unsigned buf_size;
@@ -253,6 +264,8 @@ static int at25_ee_write(void *priv, unsigned int off, void *val, size_t count) segment = buf_size - (offset % buf_size);if (segment > count) segment = count; +if (segment > maxsz) + segment = maxsz;memcpy (cp, buf, segment); status =spi_write (at25->spi, bounce, segment + at25->addrlen +1 );
Signature · 1 line
2.35.1
Re: [PATCH AUTOSEL 5.18 05/22] eeprom: at25: Split reads into chunks and cap write size
Hi Sasha,
Quoted 7 lines · Sasha Levin
From: Brad Bishop <[email protected]>
[ Upstream commit
0a35780c755ccec097d15c6b4ff8b246a89f1689]Make use of
spi_max_transfer_sizeto avoid requesting transfers that are too large for some spi controllers.
Quoted 6 lines
Signed-off-by Brad Bishop <[email protected]>Signed-off-by Eddie James <[email protected]>Signed-off-by Joel Stanley <[email protected]>Signed-off-by Greg Kroah-Hartman <[email protected]>Signed-off-by Sasha Levin <[email protected]>
Please drop this, as it breaks operation on devices that don't need the split, and may cause a buffer overflow on those that do.
Gr{oetje,eeting}s,
Geert
--
Geert Uytterhoeven -- There's lots of Linux beyond ia32 -- [email protected]
In personal conversations with technical people, I call myself a hacker. But when I'm talking to journalists I just say "programmer" or something like that.
-- Linus Torvalds
Sasha Levin
maintainerPATCH 6/22 nvme: add bug report info for global duplicate id
In reply to Sasha LevinFrom: Keith Busch <[email protected]>
[ Upstream commit 2f0dad1719cbbd690e916a42d937b7605ee63964 ]
The recent global id check is finding poorly implemented devices in the wild. Include relavant device information in the output to help quicken an appropriate quirk patch.
--- drivers/nvme/host/core.c | 1 + drivers/nvme/host/nvme.h | 28 ++++++++++++++++++++++++++++ drivers/nvme/host/pci.c | 16 ++++++++++++++++ 3 files changed, 45 insertions(+)
drivers/nvme/host/core.c +1 -0
@@ -3803,6 +3803,7 @@ static int nvme_init_ns_head(struct nvme_ns *ns, unsigned nsid,if (ret) {dev_err (ctrl->device,"globally duplicate IDs for nsid %d\n" , nsid); +nvme_print_device_info (ctrl);return ret; }
drivers/nvme/host/nvme.h +28 -0
@@ -502,6 +502,7 @@ struct nvme_ctrl_ops {void (*submit_async_event)(struct nvme_ctrl *ctrl);void (*delete_ctrl)(struct nvme_ctrl *ctrl);int (*get_address)(struct nvme_ctrl *ctrl,char *buf,int size); +void (*print_device_info)(struct nvme_ctrl *ctrl); };/*
@@ -547,6 +548,33 @@ static inline struct request *nvme_cid_to_rq(struct blk_mq_tags *tags,return blk_mq_tag_to_rq (tags,nvme_tag_from_cid (command_id)); } +/* +* Return the length of the string without the space padding +*/ +static inline int nvme_strlen (char *s,int len) +{ +while (s[len -1 ] ==' ' ) + len--; +return len; +} + +static inline void nvme_print_device_info (struct nvme_ctrl *ctrl) +{ +struct nvme_subsystem *subsys = ctrl->subsys; + +if (ctrl->ops->print_device_info) { + ctrl->ops->print_device_info (ctrl); +return ; + } + +dev_err (ctrl->device, +"VID:%04x model:%.*s firmware:%.*s\n" , subsys->vendor_id, +nvme_strlen (subsys->model,sizeof (subsys->model)), + subsys->model,nvme_strlen (subsys->firmware_rev, +sizeof (subsys->firmware_rev)), + subsys->firmware_rev); +} +#ifdef CONFIG_FAULT_INJECTION_DEBUG_FS void nvme_fault_inject_init (struct nvme_fault_inject *fault_inj,const char *dev_name);
drivers/nvme/host/pci.c +16 -0
@@ -2970,6 +2970,21 @@ static int nvme_pci_get_address(struct nvme_ctrl *ctrl, char *buf, int size)return snprintf (buf, size,"%s\n" ,dev_name (&pdev->dev)); } + +static void nvme_pci_print_device_info (struct nvme_ctrl *ctrl) +{ +struct pci_dev *pdev =to_pci_dev (to_nvme_dev (ctrl)->dev); +struct nvme_subsystem *subsys = ctrl->subsys; + +dev_err (ctrl->device, +"VID:DID %04x:%04x model:%.*s firmware:%.*s\n" , + pdev->vendor, pdev->device, +nvme_strlen (subsys->model,sizeof (subsys->model)), + subsys->model,nvme_strlen (subsys->firmware_rev, +sizeof (subsys->firmware_rev)), + subsys->firmware_rev); +} +static const struct nvme_ctrl_ops nvme_pci_ctrl_ops = { .name ="pcie" , .module =THIS_MODULE ,
@@ -2981,6 +2996,7 @@ static const struct nvme_ctrl_ops nvme_pci_ctrl_ops = { .free_ctrl = nvme_pci_free_ctrl, .submit_async_event = nvme_pci_submit_async_event, .get_address = nvme_pci_get_address, + .print_device_info = nvme_pci_print_device_info, };static int nvme_dev_map (struct nvme_dev *dev)
Signature · 1 line
2.35.1
Sasha Levin
maintainerPATCH 7/22 nvme-pci: add trouble shooting steps for timeouts
In reply to Sasha LevinFrom: Keith Busch <[email protected]>
[ Upstream commit 4641a8e6e145f595059e695f0f8dbbe608134086 ]
Many users have encountered IO timeouts with a CSTS value of 0xffffffff, which indicates a failure to read the register. While there are various potential causes for this observation, faulty NVMe APST has been the culprit quite frequently. Add the recommended troubleshooting steps in the error output when this condition occurs.
--- drivers/nvme/host/pci.c | 8 ++++++++ 1 file changed, 8 insertions(+)
drivers/nvme/host/pci.c +8 -0
@@ -1334,6 +1334,14 @@ static void nvme_warn_reset(struct nvme_dev *dev, u32 csts)dev_warn (dev->ctrl.device,"controller is down; will reset: CSTS=0x%x, PCI_STATUS read failed (%d)\n" , csts, result); + +if (csts != ~0 ) +return ; + +dev_warn (dev->ctrl.device, +"Does your device have a faulty power saving mode enabled?\n" ); +dev_warn (dev->ctrl.device, +"Try \"nvme_core.default_ps_max_latency_us=0 pcie_aspm=off\" and report a bug\n" ); }static enum blk_eh_timer_return nvme_timeout (struct request *req,bool reserved)
Signature · 1 line
2.35.1
Sasha Levin
maintainerPATCH 8/22 nvme-pci: add NVME_QUIRK_BOGUS_NID for ADATA XPG GAMMIX S50
In reply to Sasha LevinFrom: Stefan Reiter <[email protected]>
[ Upstream commit 3765fad508964f433ac111c127d6bedd19bdfa04 ]
ADATA XPG GAMMIX S50 drives report bogus eui64 values that appear to be the same across drives in one system. Quirk them out so they are not marked as "non globally unique" duplicates.
--- drivers/nvme/host/pci.c | 2 ++ 1 file changed, 2 insertions(+)
drivers/nvme/host/pci.c +2 -0
@@ -3479,6 +3479,8 @@ static const struct pci_device_id nvme_id_table[] = { .driver_data = NVME_QUIRK_BOGUS_NID, }, { PCI_DEVICE(0x1e4B, 0x1202), /* MAXIO MAP1202 */ .driver_data = NVME_QUIRK_BOGUS_NID, }, + { PCI_DEVICE(0x1cc1, 0x5350), /* ADATA XPG GAMMIX S50 */ + .driver_data = NVME_QUIRK_BOGUS_NID, }, { PCI_DEVICE(PCI_VENDOR_ID_AMAZON, 0x0061), .driver_data = NVME_QUIRK_DMA_ADDRESS_BITS_48, }, { PCI_DEVICE(PCI_VENDOR_ID_AMAZON, 0x0065),
Signature · 1 line
2.35.1
Sasha Levin
maintainerPATCH 9/22 nvme-pci: phison e12 has bogus namespace ids
In reply to Sasha LevinFrom: Keith Busch <[email protected]>
[ Upstream commit 2cf7a77ed5f8903606f4f7833d02d67b08650442 ]
Add the quirk.
--- drivers/nvme/host/pci.c | 2 ++ 1 file changed, 2 insertions(+)
drivers/nvme/host/pci.c +2 -0
@@ -3455,6 +3455,8 @@ static const struct pci_device_id nvme_id_table[] = { .driver_data = NVME_QUIRK_DELAY_BEFORE_CHK_RDY | NVME_QUIRK_DISABLE_WRITE_ZEROES| NVME_QUIRK_IGNORE_DEV_SUBNQN, }, + { PCI_DEVICE(0x1987, 0x5012), /* Phison E12 */ + .driver_data = NVME_QUIRK_BOGUS_NID, }, { PCI_DEVICE(0x1987, 0x5016), /* Phison E16 */ .driver_data = NVME_QUIRK_IGNORE_DEV_SUBNQN, }, { PCI_DEVICE(0x1b4b, 0x1092), /* Lexar 256 GB SSD */
Signature · 1 line
2.35.1
Sasha Levin
maintainerPATCH 10/22 nvme-pci: smi has bogus namespace ids
In reply to Sasha LevinFrom: Keith Busch <[email protected]>
[ Upstream commit c98a879312caf775c9768faed25ce1c013b4df04 ]
Add the quirk.
--- drivers/nvme/host/pci.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
drivers/nvme/host/pci.c +2 -1
@@ -3439,7 +3439,8 @@ static const struct pci_device_id nvme_id_table[] = { { PCI_VDEVICE(REDHAT, 0x0010), /* Qemu emulated controller */ .driver_data = NVME_QUIRK_BOGUS_NID, }, { PCI_DEVICE(0x126f, 0x2263), /* Silicon Motion unidentified */ - .driver_data = NVME_QUIRK_NO_NS_DESC_LIST, }, + .driver_data = NVME_QUIRK_NO_NS_DESC_LIST | + NVME_QUIRK_BOGUS_NID, }, { PCI_DEVICE(0x1bb1, 0x0100), /* Seagate Nytro Flash Storage */ .driver_data = NVME_QUIRK_DELAY_BEFORE_CHK_RDY | NVME_QUIRK_NO_NS_DESC_LIST, },
Signature · 1 line
2.35.1
Sasha Levin
maintainerPATCH 11/22 nvme-pci: sk hynix p31 has bogus namespace ids
In reply to Sasha LevinFrom: Keith Busch <[email protected]>
[ Upstream commit c4f01a776b28378f4f61b53f8cb0e358f4fa3721 ]
Add the quirk.
--- drivers/nvme/host/pci.c | 2 ++ 1 file changed, 2 insertions(+)
drivers/nvme/host/pci.c +2 -0
@@ -3470,6 +3470,8 @@ static const struct pci_device_id nvme_id_table[] = { NVME_QUIRK_IGNORE_DEV_SUBNQN, }, { PCI_DEVICE(0x1c5c, 0x1504), /* SK Hynix PC400 */ .driver_data = NVME_QUIRK_DISABLE_WRITE_ZEROES, }, + { PCI_DEVICE(0x1c5c, 0x174a), /* SK Hynix P31 SSD */ + .driver_data = NVME_QUIRK_BOGUS_NID, }, { PCI_DEVICE(0x15b7, 0x2001), /* Sandisk Skyhawk */ .driver_data = NVME_QUIRK_DISABLE_WRITE_ZEROES, }, { PCI_DEVICE(0x1d97, 0x2263), /* SPCC */
Signature · 1 line
2.35.1
Sasha Levin
maintainerPATCH 12/22 nvme-pci: avoid the deepest sleep state on ZHITAI TiPro7000 SSDs
In reply to Sasha LevinFrom: Ning Wang <[email protected]>
[ Upstream commit 6b961bce50e489186232cef51036ddb8d672bc3b ]
When ZHITAI TiPro7000 SSDs entered deepest power state(ps4) it has the same APST sleep problem as Kingston A2000. by chance the system crashes and displays the same dmesg info:
https://bugzilla.kernel.org/show_bug.cgi?id=195039#c65
As the Archlinux wiki suggest (enlat + exlat) < 25000 is fine and my testing shows no system crashes ever since.
Therefore disabling the deepest power state will fix the APST sleep issue.
https://wiki.archlinux.org/title/Solid_state_drive/NVMe
This is the APST data from 'nvme id-ctrl /dev/nvme1'
NVME Identify Controller:
vid : 0x1e49
ssvid : 0x1e49
sn : [...]
mn : ZHITAI TiPro7000 1TB
fr : ZTA32F3Y
[...]
ps 0 : mp:3.50W operational enlat:5 exlat:5 rrt:0 rrl:0
rwt:0 rwl:0 idle_power:- active_power:-
ps 1 : mp:3.30W operational enlat:50 exlat:100 rrt:1 rrl:1
rwt:1 rwl:1 idle_power:- active_power:-
ps 2 : mp:2.80W operational enlat:50 exlat:200 rrt:2 rrl:2
rwt:2 rwl:2 idle_power:- active_power:-
ps 3 : mp:0.1500W non-operational enlat:500 exlat:5000 rrt:3 rrl:3
rwt:3 rwl:3 idle_power:- active_power:-
ps 4 : mp:0.0200W non-operational enlat:2000 exlat:60000 rrt:4 rrl:4
rwt:4 rwl:4 idle_power:- active_power:---- drivers/nvme/host/pci.c | 2 ++ 1 file changed, 2 insertions(+)
drivers/nvme/host/pci.c +2 -0
@@ -3486,6 +3486,8 @@ static const struct pci_device_id nvme_id_table[] = { .driver_data = NVME_QUIRK_BOGUS_NID, }, { PCI_DEVICE(0x1cc1, 0x5350), /* ADATA XPG GAMMIX S50 */ .driver_data = NVME_QUIRK_BOGUS_NID, }, + { PCI_DEVICE(0x1e49, 0x0041), /* ZHITAI TiPro7000 NVMe SSD */ + .driver_data = NVME_QUIRK_NO_DEEPEST_PS, }, { PCI_DEVICE(PCI_VENDOR_ID_AMAZON, 0x0061), .driver_data = NVME_QUIRK_DMA_ADDRESS_BITS_48, }, { PCI_DEVICE(PCI_VENDOR_ID_AMAZON, 0x0065),
Signature · 1 line
2.35.1
Sasha Levin
maintainerPATCH 13/22 nvme-pci: disable write zeros support on UMIC and Samsung SSDs
In reply to Sasha LevinFrom: "rasheed.hsueh" <[email protected]>
[ Upstream commit 43047e082b90ead395c44b0e8497bc853bd13845 ]
Like commit 5611ec2b9814 ("nvme-pci: prevent SK hynix PC400 from using Write Zeroes command"), UMIS and Samsung has the same issue:
[ 6305.633887] blk_update_request: operation not supported error,
dev nvme0n1, sector 340812032 op 0x9:(WRITE_ZEROES) flags 0x0 phys_seg 0 prio class 0
So also disable Write Zeroes command on UMIS and Samsung.
--- drivers/nvme/host/pci.c | 8 ++++++++ 1 file changed, 8 insertions(+)
drivers/nvme/host/pci.c +8 -0
@@ -3476,6 +3476,14 @@ static const struct pci_device_id nvme_id_table[] = { .driver_data = NVME_QUIRK_DISABLE_WRITE_ZEROES, }, { PCI_DEVICE(0x1d97, 0x2263), /* SPCC */ .driver_data = NVME_QUIRK_DISABLE_WRITE_ZEROES, }, + { PCI_DEVICE(0x144d, 0xa80b), /* Samsung PM9B1 256G and 512G */ + .driver_data = NVME_QUIRK_DISABLE_WRITE_ZEROES, }, + { PCI_DEVICE(0x144d, 0xa809), /* Samsung MZALQ256HBJD 256G */ + .driver_data = NVME_QUIRK_DISABLE_WRITE_ZEROES, }, + { PCI_DEVICE(0x1cc4, 0x6303), /* UMIS RPJTJ512MGE1QDY 512G */ + .driver_data = NVME_QUIRK_DISABLE_WRITE_ZEROES, }, + { PCI_DEVICE(0x1cc4, 0x6302), /* UMIS RPJTJ256MGE1QDY 256G */ + .driver_data = NVME_QUIRK_DISABLE_WRITE_ZEROES, }, { PCI_DEVICE(0x2646, 0x2262), /* KINGSTON SKC2000 NVMe SSD */ .driver_data = NVME_QUIRK_NO_DEEPEST_PS, }, { PCI_DEVICE(0x2646, 0x2263), /* KINGSTON A2000 NVMe SSD */
Signature · 1 line
2.35.1
Sasha Levin
maintainerPATCH 14/22 net: usb: ax88179_178a needs FLAG_SEND_ZLP
In reply to Sasha LevinFrom: Jose Alonso <[email protected]>
[ Upstream commit 36a15e1cb134c0395261ba1940762703f778438c ]
The extra byte inserted by usbnet.c when
(length % dev->maxpacket == 0) is causing problems to device.
This patch sets FLAG_SEND_ZLP to avoid this.
Tested with: 0b95:1790 ASIX Electronics Corp. AX88179 Gigabit Ethernet
Problems observed:
======================================================================
1) Using ssh/sshfs. The remote sshd daemon can abort with the message:
"message authentication code incorrect"
This happens because the tcp message sent is corrupted during the USB "Bulk out". The device calculate the tcp checksum and send a valid tcp message to the remote sshd. Then the encryption detects the error and aborts.
2) NETDEV WATCHDOG: ... (ax88179_178a): transmit queue 0 timed out
3) Stop normal work without any log message.
The "Bulk in" continue receiving packets normally.
The host sends "Bulk out" and the device responds with -ECONNRESET. (The netusb.c code tx_complete ignore -ECONNRESET)
Under normal conditions these errors take days to happen and in intense usage take hours.
A test with ping gives packet loss, showing that something is wrong:
ping -4 -s 462 {destination} # 462 = 512 - 42 - 8
Not all packets fail.
My guess is that the device tries to find another packet starting at the extra byte and will fail or not depending on the next bytes (old buffer content).
======================================================================
--- drivers/net/usb/ax88179_178a.c | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-)
drivers/net/usb/ax88179_178a.c +13 -13
@@ -1750,7 +1750,7 @@ static const struct driver_info ax88179_info = { .link_reset = ax88179_link_reset, .reset = ax88179_reset, .stop = ax88179_stop, - .flags = FLAG_ETHER | FLAG_FRAMING_AX, + .flags = FLAG_ETHER | FLAG_FRAMING_AX | FLAG_SEND_ZLP, .rx_fixup = ax88179_rx_fixup, .tx_fixup = ax88179_tx_fixup, };
@@ -1763,7 +1763,7 @@ static const struct driver_info ax88178a_info = { .link_reset = ax88179_link_reset, .reset = ax88179_reset, .stop = ax88179_stop, - .flags = FLAG_ETHER | FLAG_FRAMING_AX, + .flags = FLAG_ETHER | FLAG_FRAMING_AX | FLAG_SEND_ZLP, .rx_fixup = ax88179_rx_fixup, .tx_fixup = ax88179_tx_fixup, };
@@ -1776,7 +1776,7 @@ static const struct driver_info cypress_GX3_info = { .link_reset = ax88179_link_reset, .reset = ax88179_reset, .stop = ax88179_stop, - .flags = FLAG_ETHER | FLAG_FRAMING_AX, + .flags = FLAG_ETHER | FLAG_FRAMING_AX | FLAG_SEND_ZLP, .rx_fixup = ax88179_rx_fixup, .tx_fixup = ax88179_tx_fixup, };
@@ -1789,7 +1789,7 @@ static const struct driver_info dlink_dub1312_info = { .link_reset = ax88179_link_reset, .reset = ax88179_reset, .stop = ax88179_stop, - .flags = FLAG_ETHER | FLAG_FRAMING_AX, + .flags = FLAG_ETHER | FLAG_FRAMING_AX | FLAG_SEND_ZLP, .rx_fixup = ax88179_rx_fixup, .tx_fixup = ax88179_tx_fixup, };
@@ -1802,7 +1802,7 @@ static const struct driver_info sitecom_info = { .link_reset = ax88179_link_reset, .reset = ax88179_reset, .stop = ax88179_stop, - .flags = FLAG_ETHER | FLAG_FRAMING_AX, + .flags = FLAG_ETHER | FLAG_FRAMING_AX | FLAG_SEND_ZLP, .rx_fixup = ax88179_rx_fixup, .tx_fixup = ax88179_tx_fixup, };
@@ -1815,7 +1815,7 @@ static const struct driver_info samsung_info = { .link_reset = ax88179_link_reset, .reset = ax88179_reset, .stop = ax88179_stop, - .flags = FLAG_ETHER | FLAG_FRAMING_AX, + .flags = FLAG_ETHER | FLAG_FRAMING_AX | FLAG_SEND_ZLP, .rx_fixup = ax88179_rx_fixup, .tx_fixup = ax88179_tx_fixup, };
@@ -1828,7 +1828,7 @@ static const struct driver_info lenovo_info = { .link_reset = ax88179_link_reset, .reset = ax88179_reset, .stop = ax88179_stop, - .flags = FLAG_ETHER | FLAG_FRAMING_AX, + .flags = FLAG_ETHER | FLAG_FRAMING_AX | FLAG_SEND_ZLP, .rx_fixup = ax88179_rx_fixup, .tx_fixup = ax88179_tx_fixup, };
@@ -1841,7 +1841,7 @@ static const struct driver_info belkin_info = { .link_reset = ax88179_link_reset, .reset = ax88179_reset, .stop = ax88179_stop, - .flags = FLAG_ETHER | FLAG_FRAMING_AX, + .flags = FLAG_ETHER | FLAG_FRAMING_AX | FLAG_SEND_ZLP, .rx_fixup = ax88179_rx_fixup, .tx_fixup = ax88179_tx_fixup, };
@@ -1854,7 +1854,7 @@ static const struct driver_info toshiba_info = { .link_reset = ax88179_link_reset, .reset = ax88179_reset, .stop = ax88179_stop, - .flags = FLAG_ETHER | FLAG_FRAMING_AX, + .flags = FLAG_ETHER | FLAG_FRAMING_AX | FLAG_SEND_ZLP, .rx_fixup = ax88179_rx_fixup, .tx_fixup = ax88179_tx_fixup, };
@@ -1867,7 +1867,7 @@ static const struct driver_info mct_info = { .link_reset = ax88179_link_reset, .reset = ax88179_reset, .stop = ax88179_stop, - .flags = FLAG_ETHER | FLAG_FRAMING_AX, + .flags = FLAG_ETHER | FLAG_FRAMING_AX | FLAG_SEND_ZLP, .rx_fixup = ax88179_rx_fixup, .tx_fixup = ax88179_tx_fixup, };
@@ -1880,7 +1880,7 @@ static const struct driver_info at_umc2000_info = { .link_reset = ax88179_link_reset, .reset = ax88179_reset, .stop = ax88179_stop, - .flags = FLAG_ETHER | FLAG_FRAMING_AX, + .flags = FLAG_ETHER | FLAG_FRAMING_AX | FLAG_SEND_ZLP, .rx_fixup = ax88179_rx_fixup, .tx_fixup = ax88179_tx_fixup, };
@@ -1893,7 +1893,7 @@ static const struct driver_info at_umc200_info = { .link_reset = ax88179_link_reset, .reset = ax88179_reset, .stop = ax88179_stop, - .flags = FLAG_ETHER | FLAG_FRAMING_AX, + .flags = FLAG_ETHER | FLAG_FRAMING_AX | FLAG_SEND_ZLP, .rx_fixup = ax88179_rx_fixup, .tx_fixup = ax88179_tx_fixup, };
@@ -1906,7 +1906,7 @@ static const struct driver_info at_umc2000sp_info = { .link_reset = ax88179_link_reset, .reset = ax88179_reset, .stop = ax88179_stop, - .flags = FLAG_ETHER | FLAG_FRAMING_AX, + .flags = FLAG_ETHER | FLAG_FRAMING_AX | FLAG_SEND_ZLP, .rx_fixup = ax88179_rx_fixup, .tx_fixup = ax88179_tx_fixup, };
Signature · 1 line
2.35.1
Sasha Levin
maintainerPATCH 15/22 ext2: fix fs corruption when trying to remove a non-empty directory with IO error
In reply to Sasha LevinFrom: Ye Bin <[email protected]>
[ Upstream commit 27cfa258951a465e3eae63ee1e715e902cd45578 ]
We got issue as follows:
[home]# mount /dev/sdd test
[home]# cd test
[test]# ls
dir1 lost+found
[test]# rmdir dir1ext2_empty_dir: inject fault
[test]# ls
lost+found
[test]# cd ..
[home]# umount test
[home]# fsck.ext2 -fn /dev/sdd
e2fsck 1.42.9 (28-Dec-2013)
Pass 1: Checking inodes, blocks, and sizes
Inode 4065, i_size is 0, should be 1024. Fix? no
Pass 2: Checking directory structure
Pass 3: Checking directory connectivity
Unconnected directory inode 4065 (/???)
Connect to /lost+found? no
'..' in ... (4065) is / (2), should be <The NULL inode> (0). Fix? no
Pass 4: Checking reference counts
Inode 2 ref count is 3, should be 4. Fix? no
Inode 4065 ref count is 2, should be 3. Fix? no
Pass 5: Checking group summary information
/dev/sdd: ********** WARNING: Filesystem still has errors **********
/dev/sdd: 14/128016 files (0.0% non-contiguous), 18477/512000 blocks
Reason is same with commit 7aab5c84a0f6. We can't assume directory is empty when read directory entry failed.
--- fs/ext2/dir.c | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-)
fs/ext2/dir.c +3 -6
@@ -672,17 +672,14 @@ int ext2_empty_dir (struct inode * inode)void *page_addr =NULL ;struct page *page =NULL ;unsigned long i, npages =dir_pages (inode); -int dir_has_error =0 ;for (i =0 ; i < npages; i++) {char *kaddr;ext2_dirent * de; - page =ext2_get_page (inode, i, dir_has_error, &page_addr); + page =ext2_get_page (inode, i,0 , &page_addr); -if (IS_ERR (page)) { - dir_has_error =1 ; -continue ; - } +if (IS_ERR (page)) + goto not_empty; kaddr = page_addr; de = (ext2_dirent *)kaddr;
Signature · 1 line
2.35.1
Sasha Levin
maintainerPATCH 16/22 ext4: fix warning when submitting superblock in ext4_commit_super()
In reply to Sasha LevinFrom: Zhang Yi <[email protected]>
[ Upstream commit 15baa7dcadf1c4f0b4f752dc054191855ff2d78e ]
We have already check the io_error and uptodate flag before submitting the superblock buffer, and re-set the uptodate flag if it has been failed to write out. But it was lockless and could be raced by another ext4_commit_super(), and finally trigger '!uptodate' WARNING when marking buffer dirty. Fix it by submit buffer directly.
--- fs/ext4/super.c | 22 ++++++++++++++++------ 1 file changed, 16 insertions(+), 6 deletions(-)
fs/ext4/super.c +16 -6
@@ -6022,7 +6022,6 @@ static void ext4_update_super(struct super_block *sb)static int ext4_commit_super (struct super_block *sb) {struct buffer_head *sbh =EXT4_SB (sb)->s_sbh; -int error =0 ;if (!sbh)return -EINVAL ;
@@ -6031,6 +6030,13 @@ static int ext4_commit_super(struct super_block *sb)ext4_update_super (sb); +lock_buffer (sbh); +/* Buffer got discarded which means block device got invalidated */ +if (!buffer_mapped (sbh)) { +unlock_buffer (sbh); +return -EIO ; + } +if (buffer_write_io_error (sbh) || !buffer_uptodate (sbh)) {/* * Oh, dear. A previous attempt to write the
@@ -6045,17 +6051,21 @@ static int ext4_commit_super(struct super_block *sb)clear_buffer_write_io_error (sbh);set_buffer_uptodate (sbh); } -BUFFER_TRACE (sbh,"marking dirty" ); -mark_buffer_dirty (sbh); - error =__sync_dirty_buffer (sbh, -REQ_SYNC | (test_opt (sb,BARRIER ) ?REQ_FUA :0 )); +get_bh (sbh); +/* Clear potential dirty bit if it was journalled update */ +clear_buffer_dirty (sbh); + sbh->b_end_io = end_buffer_write_sync; +submit_bh (REQ_OP_WRITE , +REQ_SYNC | (test_opt (sb,BARRIER ) ?REQ_FUA :0 ), sbh); +wait_on_buffer (sbh);if (buffer_write_io_error (sbh)) {ext4_msg (sb,KERN_ERR ,"I/O error while writing " "superblock" );clear_buffer_write_io_error (sbh);set_buffer_uptodate (sbh); +return -EIO ; } -return error; +return 0 ; }/*
Signature · 1 line
2.35.1
Sasha Levin
maintainerPATCH 17/22 ext4: improve write performance with disabled delalloc
In reply to Sasha LevinFrom: Jan Kara <[email protected]>
[ Upstream commit 8d5459c11f548131ce48b2fbf45cccc5c382558f ]
When delayed allocation is disabled (either through mount option or because we are running low on free space), ext4_write_begin() allocates blocks with EXT4_GET_BLOCKS_IO_CREATE_EXT flag. With this flag extent merging is disabled and since ext4_write_begin() is called for each page separately, we end up with a *lot* of 1 block extents in the extent tree and following writeback is writing 1 block at a time which results in very poor write throughput (4 MB/s instead of 200 MB/s). These days when ext4_get_block_unwritten() is used only by ext4_write_begin(), ext4_page_mkwrite() and inline data conversion, we can safely allow extent merging to happen from these paths since following writeback will happen on different boundaries anyway. So use EXT4_GET_BLOCKS_CREATE_UNRIT_EXT instead which restores the performance.
--- fs/ext4/inode.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
fs/ext4/inode.c +1 -1
@@ -822,7 +822,7 @@ int ext4_get_block_unwritten(struct inode *inode, sector_t iblock,ext4_debug ("ext4_get_block_unwritten: inode %lu, create flag %d\n" , inode->i_ino, create);return _ext4_get_block (inode, iblock, bh_result, -EXT4_GET_BLOCKS_IO_CREATE_EXT ); +EXT4_GET_BLOCKS_CREATE_UNWRIT_EXT ); }/* Maximum number of blocks we map for direct IO at once. */
Signature · 1 line
2.35.1
Sasha Levin
maintainerPATCH 18/22 blk-mq: protect q->elevator by ->sysfs_lock in blk_mq_elv_switch_none
In reply to Sasha LevinFrom: Ming Lei <[email protected]>
[ Upstream commit 5fd7a84a09e640016fe106dd3e992f5210e23dc7 ]
elevator can be tore down by sysfs switch interface or disk release, so hold ->sysfs_lock before referring to q->elevator, then potential use-after-free can be avoided.
--- block/blk-mq.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
block/blk-mq.c +3 -1
@@ -4436,12 +4436,14 @@ static bool blk_mq_elv_switch_none(struct list_head *head,if (!qe)return false; +/* q->elevator needs protection from ->sysfs_lock */ +mutex_lock (&q->sysfs_lock); +INIT_LIST_HEAD (&qe->node); qe->q = q; qe->type = q->elevator->type;list_add (&qe->node, head); -mutex_lock (&q->sysfs_lock);/* * After elevator_switch_mq, the previous elevator_queue will be * released by elevator_release. The reference of the io scheduler
Signature · 1 line
2.35.1
Sasha Levin
maintainerPATCH 19/22 blk-mq: avoid to touch q->elevator without any protection
In reply to Sasha LevinFrom: Ming Lei <[email protected]>
[ Upstream commit 4d337cebcb1c27d9b48c48b9a98e939d4552d584 ]
q->elevator is referred in blk_mq_has_sqsched() without any protection, no .q_usage_counter is held, no queue srcu and rcu read lock is held, so potential use-after-free may be triggered.
Fix the issue by adding one queue flag for checking if the elevator uses single queue style dispatch. Meantime the elevator feature flag of ELEVATOR_F_MQ_AWARE isn't needed any more.
--- block/bfq-iosched.c | 3 +++ block/blk-mq-sched.c | 1 + block/blk-mq.c | 18 ++---------------- block/kyber-iosched.c | 3 ++- block/mq-deadline.c | 3 +++ include/linux/blkdev.h | 4 ++-- 6 files changed, 13 insertions(+), 19 deletions(-)
block/bfq-iosched.c +3 -0
@@ -7183,6 +7183,9 @@ static int bfq_init_queue(struct request_queue *q, struct elevator_type *e)bfq_init_root_group (bfqd->root_group, bfqd);bfq_init_entity (&bfqd->oom_bfqq.entity, bfqd->root_group); +/* We dispatch from request queue wide instead of hw queue */ +blk_queue_flag_set (QUEUE_FLAG_SQ_SCHED , q); +wbt_disable_default (q);return 0 ;
block/blk-mq-sched.c +1 -0
@@ -564,6 +564,7 @@ int blk_mq_init_sched(struct request_queue *q, struct elevator_type *e)int ret;if (!e) { +blk_queue_flag_clear (QUEUE_FLAG_SQ_SCHED , q); q->elevator =NULL ; q->nr_requests = q->tag_set->queue_depth;return 0 ;
block/blk-mq.c +2 -16
@@ -2104,20 +2104,6 @@ void blk_mq_run_hw_queue(struct blk_mq_hw_ctx *hctx, bool async) }EXPORT_SYMBOL (blk_mq_run_hw_queue); -/* -* Is the request queue handled by an IO scheduler that does not respect -* hardware queues when dispatching? -*/ -static bool blk_mq_has_sqsched (struct request_queue *q) -{ -struct elevator_queue *e = q->elevator; - -if (e && e->type->ops.dispatch_request && - !(e->type->elevator_features &ELEVATOR_F_MQ_AWARE )) -return true; -return false; -} -/* * Return prefered queue to dispatch from (if any) for non-mq aware IO * scheduler.
@@ -2150,7 +2136,7 @@ void blk_mq_run_hw_queues(struct request_queue *q, bool async)unsigned long i; sq_hctx =NULL ; -if (blk_mq_has_sqsched (q)) +if (blk_queue_sq_sched (q)) sq_hctx =blk_mq_get_sq_hctx (q);queue_for_each_hw_ctx (q, hctx, i) {if (blk_mq_hctx_stopped (hctx))
@@ -2178,7 +2164,7 @@ void blk_mq_delay_run_hw_queues(struct request_queue *q, unsigned long msecs)unsigned long i; sq_hctx =NULL ; -if (blk_mq_has_sqsched (q)) +if (blk_queue_sq_sched (q)) sq_hctx =blk_mq_get_sq_hctx (q);queue_for_each_hw_ctx (q, hctx, i) {if (blk_mq_hctx_stopped (hctx))
block/kyber-iosched.c +2 -1
@@ -421,6 +421,8 @@ static int kyber_init_sched(struct request_queue *q, struct elevator_type *e)blk_stat_enable_accounting (q); +blk_queue_flag_clear (QUEUE_FLAG_SQ_SCHED , q); + eq->elevator_data = kqd; q->elevator = eq;
@@ -1033,7 +1035,6 @@ static struct elevator_type kyber_sched = {#endif .elevator_attrs = kyber_sched_attrs, .elevator_name = "kyber", - .elevator_features = ELEVATOR_F_MQ_AWARE, .elevator_owner = THIS_MODULE, };
block/mq-deadline.c +3 -0
@@ -642,6 +642,9 @@ static int dd_init_sched(struct request_queue *q, struct elevator_type *e)spin_lock_init (&dd->lock);spin_lock_init (&dd->zone_lock); +/* We dispatch from request queue wide instead of hw queue */ +blk_queue_flag_set (QUEUE_FLAG_SQ_SCHED , q); + q->elevator = eq;return 0 ;
include/linux/blkdev.h +2 -2
@@ -561,6 +561,7 @@ struct request_queue {#define QUEUE_FLAG_RQ_ALLOC_TIME 27/* record rq->alloc_time_ns */ #define QUEUE_FLAG_HCTX_ACTIVE 28/* at least one blk-mq hctx is active */ #define QUEUE_FLAG_NOWAIT 29/* device supports NOWAIT */ +#define QUEUE_FLAG_SQ_SCHED 30/* single queue style io dispatch */ #define QUEUE_FLAG_MQ_DEFAULT ((1 << QUEUE_FLAG_IO_STAT) | \ (1 << QUEUE_FLAG_SAME_COMP) | \
@@ -606,6 +607,7 @@ bool blk_queue_flag_test_and_set(unsigned int flag, struct request_queue *q);#define blk_queue_fua (q) test_bit(QUEUE_FLAG_FUA, &(q)->queue_flags)#define blk_queue_registered (q) test_bit(QUEUE_FLAG_REGISTERED, &(q)->queue_flags)#define blk_queue_nowait (q) test_bit(QUEUE_FLAG_NOWAIT, &(q)->queue_flags) +#define blk_queue_sq_sched (q) test_bit(QUEUE_FLAG_SQ_SCHED, &(q)->queue_flags)extern void blk_set_pm_only (struct request_queue *q);extern void blk_clear_pm_only (struct request_queue *q);
@@ -994,8 +996,6 @@ void disk_set_independent_access_ranges(struct gendisk *disk,*/ /* Supports zoned block devices sequential write constraint */ #define ELEVATOR_F_ZBD_SEQ_WRITE (1U << 0) -/* Supports scheduling on multiple hardware queues */ -#define ELEVATOR_F_MQ_AWARE (1U << 1)extern void blk_queue_required_elevator_features (struct request_queue *q,unsigned int features);
Signature · 1 line
2.35.1
Sasha Levin
maintainerPATCH 20/22 blk-mq: don't clear flush_rq from tags->rqs[]
In reply to Sasha LevinFrom: Ming Lei <[email protected]>
[ Upstream commit 6cfeadbff3f8905f2854735ebb88e581402c16c4 ]
commit 364b61818f65 ("blk-mq: clearing flush request reference in tags->rqs[]") is added to clear the to-be-free flush request from tags->rqs[] for avoiding use-after-free on the flush rq.
Yu Kuai reported that blk_mq_clear_flush_rq_mapping() slows down boot time by ~8s because running scsi probe which may create and remove lots of unpresent LUNs on megaraid-sas which uses BLK_MQ_F_TAG_HCTX_SHARED and each request queue has lots of hw queues.
Improve the situation by not running blk_mq_clear_flush_rq_mapping if disk isn't added when there can't be any flush request issued.
--- block/blk-mq.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-)
block/blk-mq.c +3 -2
@@ -3427,8 +3427,9 @@ static void blk_mq_exit_hctx(struct request_queue *q,if (blk_mq_hw_queue_mapped (hctx))blk_mq_tag_idle (hctx); -blk_mq_clear_flush_rq_mapping (set->tags[hctx_idx], - set->queue_depth, flush_rq); +if (blk_queue_init_done (q)) +blk_mq_clear_flush_rq_mapping (set->tags[hctx_idx], + set->queue_depth, flush_rq);if (set->ops->exit_request) set->ops->exit_request (set, flush_rq, hctx_idx);
Signature · 1 line
2.35.1
Sasha Levin
maintainerPATCH 21/22 cifs: when a channel is not found for server, log its connection id
In reply to Sasha LevinFrom: Shyam Prasad N <[email protected]>
[ Upstream commit 5d24968f5b7e00bae564b1646c3b9e0e3750aabe ]
cifs_ses_get_chan_index gets the index for a given server pointer. When a match is not found, we warn about a possible bug. However, printing details about the non-matching server could be more useful to debug here.
--- fs/cifs/sess.c | 3 +++ 1 file changed, 3 insertions(+)
fs/cifs/sess.c +3 -0
@@ -81,6 +81,9 @@ cifs_ses_get_chan_index(struct cifs_ses *ses, }/* If we didn't find the channel, it is likely a bug */ +if (server) +cifs_dbg (VFS ,"unable to get chan index for server: 0x%llx" , + server->conn_id);WARN_ON (1 );return 0 ; }
Signature · 1 line
2.35.1
Sasha Levin
maintainerPATCH 22/22 ext4: correct the judgment of BUG in ext4_mb_normalize_request
In reply to Sasha LevinFrom: Baokun Li <[email protected]>
[ Upstream commit cf4ff938b47fc5c00b0ccce53a3b50eca9b32281 ]
ext4_mb_normalize_request() can move logical start of allocated blocks to reduce fragmentation and better utilize preallocation. However logical block requested as a start of allocation (ac->ac_o_ex.fe_logical) should always be covered by allocated blocks so we should check that by modifying and to or in the assertion.
--- fs/ext4/mballoc.c | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-)
fs/ext4/mballoc.c +16 -1
@@ -4179,7 +4179,22 @@ ext4_mb_normalize_request(struct ext4_allocation_context *ac, }rcu_read_unlock (); -if (start + size <= ac->ac_o_ex.fe_logical && +/* +* In this function "start" and "size" are normalized for better +* alignment and length such that we could preallocate more blocks. +* This normalization is done such that original request of +* ac->ac_o_ex.fe_logical & fe_len should always lie within "start" and +* "size" boundaries. +* (Note fe_len can be relaxed since FS block allocation API does not +* provide gurantee on number of contiguous blocks allocation since that +* depends upon free space left, etc). +* In case of inode pa, later we use the allocated blocks +* [pa_start + fe_logical - pa_lstart, fe_len/size] from the preallocated +* range of goal/best blocks [start, size] to put it at the +* ac_o_ex.fe_logical extent of this inode. +* (See ext4_mb_use_inode_pa() for more details) +*/ +if (start + size <= ac->ac_o_ex.fe_logical || start > ac->ac_o_ex.fe_logical) { ext4_msg(ac->ac_sb, KERN_ERR, "start %lu, size %lu, fe_logical %lu",
Signature · 1 line
2.35.1