Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

Merge tag 'block-6.3-2023-03-30' of git://git.kernel.dk/linux

Pull block fixes from Jens Axboe:

- NVMe pull request via Christoph:
- Mark Lexar NM760 as IGNORE_DEV_SUBNQN (Juraj Pecigos)
- Fix a possible UAF when failing to allocate an TCP io queue (Sagi
Grimberg)

- MD pull request via Song:
- Fix a null pointer deference in 6.3-rc (Yu Kuai)

- uevent partition fix (Alyssa)

* tag 'block-6.3-2023-03-30' of git://git.kernel.dk/linux:
nvme-tcp: fix a possible UAF when failing to allocate an io queue
md: fix regression for null-ptr-deference in __md_stop()
nvme-pci: mark Lexar NM760 as IGNORE_DEV_SUBNQN
loop: LOOP_CONFIGURE: send uevents for partitions

+39 -31
+9 -9
drivers/block/loop.c
··· 1010 1010 /* This is safe, since we have a reference from open(). */ 1011 1011 __module_get(THIS_MODULE); 1012 1012 1013 - /* suppress uevents while reconfiguring the device */ 1014 - dev_set_uevent_suppress(disk_to_dev(lo->lo_disk), 1); 1015 - 1016 1013 /* 1017 1014 * If we don't hold exclusive handle for the device, upgrade to it 1018 1015 * here to avoid changing device under exclusive owner. ··· 1064 1067 } 1065 1068 } 1066 1069 1070 + /* suppress uevents while reconfiguring the device */ 1071 + dev_set_uevent_suppress(disk_to_dev(lo->lo_disk), 1); 1072 + 1067 1073 disk_force_media_change(lo->lo_disk, DISK_EVENT_MEDIA_CHANGE); 1068 1074 set_disk_ro(lo->lo_disk, (lo->lo_flags & LO_FLAGS_READ_ONLY) != 0); 1069 1075 ··· 1109 1109 if (partscan) 1110 1110 clear_bit(GD_SUPPRESS_PART_SCAN, &lo->lo_disk->state); 1111 1111 1112 + /* enable and uncork uevent now that we are done */ 1113 + dev_set_uevent_suppress(disk_to_dev(lo->lo_disk), 0); 1114 + 1112 1115 loop_global_unlock(lo, is_loop); 1113 1116 if (partscan) 1114 1117 loop_reread_partitions(lo); 1118 + 1115 1119 if (!(mode & FMODE_EXCL)) 1116 1120 bd_abort_claiming(bdev, loop_configure); 1117 1121 1118 - error = 0; 1119 - done: 1120 - /* enable and uncork uevent now that we are done */ 1121 - dev_set_uevent_suppress(disk_to_dev(lo->lo_disk), 0); 1122 - return error; 1122 + return 0; 1123 1123 1124 1124 out_unlock: 1125 1125 loop_global_unlock(lo, is_loop); ··· 1130 1130 fput(file); 1131 1131 /* This is safe: open() is still holding a reference. */ 1132 1132 module_put(THIS_MODULE); 1133 - goto done; 1133 + return error; 1134 1134 } 1135 1135 1136 1136 static void __loop_clr_fd(struct loop_device *lo, bool release)
+2 -1
drivers/md/md.c
··· 6260 6260 module_put(pers->owner); 6261 6261 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery); 6262 6262 6263 - percpu_ref_exit(&mddev->writes_pending); 6264 6263 percpu_ref_exit(&mddev->active_io); 6265 6264 bioset_exit(&mddev->bio_set); 6266 6265 bioset_exit(&mddev->sync_set); ··· 6272 6273 */ 6273 6274 __md_stop_writes(mddev); 6274 6275 __md_stop(mddev); 6276 + percpu_ref_exit(&mddev->writes_pending); 6275 6277 } 6276 6278 6277 6279 EXPORT_SYMBOL_GPL(md_stop); ··· 7843 7843 { 7844 7844 struct mddev *mddev = disk->private_data; 7845 7845 7846 + percpu_ref_exit(&mddev->writes_pending); 7846 7847 mddev_free(mddev); 7847 7848 } 7848 7849
+2 -1
drivers/nvme/host/pci.c
··· 3441 3441 { PCI_DEVICE(0x1d97, 0x1d97), /* Lexar NM620 */ 3442 3442 .driver_data = NVME_QUIRK_BOGUS_NID, }, 3443 3443 { PCI_DEVICE(0x1d97, 0x2269), /* Lexar NM760 */ 3444 - .driver_data = NVME_QUIRK_BOGUS_NID, }, 3444 + .driver_data = NVME_QUIRK_BOGUS_NID | 3445 + NVME_QUIRK_IGNORE_DEV_SUBNQN, }, 3445 3446 { PCI_DEVICE(PCI_VENDOR_ID_AMAZON, 0x0061), 3446 3447 .driver_data = NVME_QUIRK_DMA_ADDRESS_BITS_48, }, 3447 3448 { PCI_DEVICE(PCI_VENDOR_ID_AMAZON, 0x0065),
+26 -20
drivers/nvme/host/tcp.c
··· 1620 1620 if (ret) 1621 1621 goto err_init_connect; 1622 1622 1623 - queue->rd_enabled = true; 1624 1623 set_bit(NVME_TCP_Q_ALLOCATED, &queue->flags); 1625 - nvme_tcp_init_recv_ctx(queue); 1626 - 1627 - write_lock_bh(&queue->sock->sk->sk_callback_lock); 1628 - queue->sock->sk->sk_user_data = queue; 1629 - queue->state_change = queue->sock->sk->sk_state_change; 1630 - queue->data_ready = queue->sock->sk->sk_data_ready; 1631 - queue->write_space = queue->sock->sk->sk_write_space; 1632 - queue->sock->sk->sk_data_ready = nvme_tcp_data_ready; 1633 - queue->sock->sk->sk_state_change = nvme_tcp_state_change; 1634 - queue->sock->sk->sk_write_space = nvme_tcp_write_space; 1635 - #ifdef CONFIG_NET_RX_BUSY_POLL 1636 - queue->sock->sk->sk_ll_usec = 1; 1637 - #endif 1638 - write_unlock_bh(&queue->sock->sk->sk_callback_lock); 1639 1624 1640 1625 return 0; 1641 1626 ··· 1640 1655 return ret; 1641 1656 } 1642 1657 1643 - static void nvme_tcp_restore_sock_calls(struct nvme_tcp_queue *queue) 1658 + static void nvme_tcp_restore_sock_ops(struct nvme_tcp_queue *queue) 1644 1659 { 1645 1660 struct socket *sock = queue->sock; 1646 1661 ··· 1655 1670 static void __nvme_tcp_stop_queue(struct nvme_tcp_queue *queue) 1656 1671 { 1657 1672 kernel_sock_shutdown(queue->sock, SHUT_RDWR); 1658 - nvme_tcp_restore_sock_calls(queue); 1673 + nvme_tcp_restore_sock_ops(queue); 1659 1674 cancel_work_sync(&queue->io_work); 1660 1675 } 1661 1676 ··· 1673 1688 mutex_unlock(&queue->queue_lock); 1674 1689 } 1675 1690 1691 + static void nvme_tcp_setup_sock_ops(struct nvme_tcp_queue *queue) 1692 + { 1693 + write_lock_bh(&queue->sock->sk->sk_callback_lock); 1694 + queue->sock->sk->sk_user_data = queue; 1695 + queue->state_change = queue->sock->sk->sk_state_change; 1696 + queue->data_ready = queue->sock->sk->sk_data_ready; 1697 + queue->write_space = queue->sock->sk->sk_write_space; 1698 + queue->sock->sk->sk_data_ready = nvme_tcp_data_ready; 1699 + queue->sock->sk->sk_state_change = nvme_tcp_state_change; 1700 + queue->sock->sk->sk_write_space = nvme_tcp_write_space; 1701 + #ifdef CONFIG_NET_RX_BUSY_POLL 1702 + queue->sock->sk->sk_ll_usec = 1; 1703 + #endif 1704 + write_unlock_bh(&queue->sock->sk->sk_callback_lock); 1705 + } 1706 + 1676 1707 static int nvme_tcp_start_queue(struct nvme_ctrl *nctrl, int idx) 1677 1708 { 1678 1709 struct nvme_tcp_ctrl *ctrl = to_tcp_ctrl(nctrl); 1710 + struct nvme_tcp_queue *queue = &ctrl->queues[idx]; 1679 1711 int ret; 1712 + 1713 + queue->rd_enabled = true; 1714 + nvme_tcp_init_recv_ctx(queue); 1715 + nvme_tcp_setup_sock_ops(queue); 1680 1716 1681 1717 if (idx) 1682 1718 ret = nvmf_connect_io_queue(nctrl, idx); ··· 1705 1699 ret = nvmf_connect_admin_queue(nctrl); 1706 1700 1707 1701 if (!ret) { 1708 - set_bit(NVME_TCP_Q_LIVE, &ctrl->queues[idx].flags); 1702 + set_bit(NVME_TCP_Q_LIVE, &queue->flags); 1709 1703 } else { 1710 - if (test_bit(NVME_TCP_Q_ALLOCATED, &ctrl->queues[idx].flags)) 1711 - __nvme_tcp_stop_queue(&ctrl->queues[idx]); 1704 + if (test_bit(NVME_TCP_Q_ALLOCATED, &queue->flags)) 1705 + __nvme_tcp_stop_queue(queue); 1712 1706 dev_err(nctrl->device, 1713 1707 "failed to connect queue: %d ret=%d\n", idx, ret); 1714 1708 }