tjh.dev / kernel
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.17-20250828' of git://git.kernel.dk/linux

Pull block fixes from Jens Axboe:

- Fix a lockdep spotted issue on recursive locking for zoned writes, in
case of errors

- Update bcache MAINTAINERS entry address for Coly

- Fix for a ublk release issue, with selftests

- Fix for a regression introduced in this cycle, where it assumed
q->rq_qos was always set if the bio flag indicated that

- Fix for a regression introduced in this cycle, where loop retrieving
block device sizes got broken

* tag 'block-6.17-20250828' of git://git.kernel.dk/linux:
bcache: change maintainer's email address
ublk selftests: add --no_ublk_fixed_fd for not using registered ublk char device
ublk: avoid ublk_io_release() called after ublk char dev is closed
block: validate QoS before calling __rq_qos_done_bio()
blk-zoned: Fix a lockdep complaint about recursive locking
loop: fix zero sized loop for block special file

Linus Torvalds d1cf752d 220374ab

+175 -56
+1 -1
MAINTAINERS
··· 4205 4205 F: drivers/net/hamradio/baycom* 4206 4206 4207 4207 BCACHE (BLOCK LAYER CACHE) 4208 - M: Coly Li <colyli@kernel.org> 4208 + M: Coly Li <colyli@fnnas.com> 4209 4209 M: Kent Overstreet <kent.overstreet@linux.dev> 4210 4210 L: linux-bcache@vger.kernel.org 4211 4211 S: Maintained
+8 -5
block/blk-rq-qos.h
··· 149 149 q = bdev_get_queue(bio->bi_bdev); 150 150 151 151 /* 152 - * If a bio has BIO_QOS_xxx set, it implicitly implies that 153 - * q->rq_qos is present. So, we skip re-checking q->rq_qos 154 - * here as an extra optimization and directly call 155 - * __rq_qos_done_bio(). 152 + * A BIO may carry BIO_QOS_* flags even if the associated request_queue 153 + * does not have rq_qos enabled. This can happen with stacked block 154 + * devices — for example, NVMe multipath, where it's possible that the 155 + * bottom device has QoS enabled but the top device does not. Therefore, 156 + * always verify that q->rq_qos is present and QoS is enabled before 157 + * calling __rq_qos_done_bio(). 156 158 */ 157 - __rq_qos_done_bio(q->rq_qos, bio); 159 + if (test_bit(QUEUE_FLAG_QOS_ENABLED, &q->queue_flags) && q->rq_qos) 160 + __rq_qos_done_bio(q->rq_qos, bio); 158 161 } 159 162 160 163 static inline void rq_qos_throttle(struct request_queue *q, struct bio *bio)
+6 -5
block/blk-zoned.c
··· 1286 1286 struct block_device *bdev; 1287 1287 unsigned long flags; 1288 1288 struct bio *bio; 1289 + bool prepared; 1289 1290 1290 1291 /* 1291 1292 * Submit the next plugged BIO. If we do not have any, clear 1292 1293 * the plugged flag. 1293 1294 */ 1294 - spin_lock_irqsave(&zwplug->lock, flags); 1295 - 1296 1295 again: 1296 + spin_lock_irqsave(&zwplug->lock, flags); 1297 1297 bio = bio_list_pop(&zwplug->bio_list); 1298 1298 if (!bio) { 1299 1299 zwplug->flags &= ~BLK_ZONE_WPLUG_PLUGGED; ··· 1304 1304 trace_blk_zone_wplug_bio(zwplug->disk->queue, zwplug->zone_no, 1305 1305 bio->bi_iter.bi_sector, bio_sectors(bio)); 1306 1306 1307 - if (!blk_zone_wplug_prepare_bio(zwplug, bio)) { 1307 + prepared = blk_zone_wplug_prepare_bio(zwplug, bio); 1308 + spin_unlock_irqrestore(&zwplug->lock, flags); 1309 + 1310 + if (!prepared) { 1308 1311 blk_zone_wplug_bio_io_error(zwplug, bio); 1309 1312 goto again; 1310 1313 } 1311 - 1312 - spin_unlock_irqrestore(&zwplug->lock, flags); 1313 1314 1314 1315 bdev = bio->bi_bdev; 1315 1316
+16 -10
drivers/block/loop.c
··· 139 139 140 140 static loff_t lo_calculate_size(struct loop_device *lo, struct file *file) 141 141 { 142 - struct kstat stat; 143 142 loff_t loopsize; 144 143 int ret; 145 144 146 - /* 147 - * Get the accurate file size. This provides better results than 148 - * cached inode data, particularly for network filesystems where 149 - * metadata may be stale. 150 - */ 151 - ret = vfs_getattr_nosec(&file->f_path, &stat, STATX_SIZE, 0); 152 - if (ret) 153 - return 0; 145 + if (S_ISBLK(file_inode(file)->i_mode)) { 146 + loopsize = i_size_read(file->f_mapping->host); 147 + } else { 148 + struct kstat stat; 154 149 155 - loopsize = stat.size; 150 + /* 151 + * Get the accurate file size. This provides better results than 152 + * cached inode data, particularly for network filesystems where 153 + * metadata may be stale. 154 + */ 155 + ret = vfs_getattr_nosec(&file->f_path, &stat, STATX_SIZE, 0); 156 + if (ret) 157 + return 0; 158 + 159 + loopsize = stat.size; 160 + } 161 + 156 162 if (lo->lo_offset > 0) 157 163 loopsize -= lo->lo_offset; 158 164 /* offset is beyond i_size, weird but possible */
+70 -2
drivers/block/ublk_drv.c
··· 239 239 struct mutex cancel_mutex; 240 240 bool canceling; 241 241 pid_t ublksrv_tgid; 242 + struct delayed_work exit_work; 242 243 }; 243 244 244 245 /* header of ublk_params */ ··· 1596 1595 ublk_get_queue(ub, i)->canceling = canceling; 1597 1596 } 1598 1597 1599 - static int ublk_ch_release(struct inode *inode, struct file *filp) 1598 + static bool ublk_check_and_reset_active_ref(struct ublk_device *ub) 1600 1599 { 1601 - struct ublk_device *ub = filp->private_data; 1600 + int i, j; 1601 + 1602 + if (!(ub->dev_info.flags & (UBLK_F_SUPPORT_ZERO_COPY | 1603 + UBLK_F_AUTO_BUF_REG))) 1604 + return false; 1605 + 1606 + for (i = 0; i < ub->dev_info.nr_hw_queues; i++) { 1607 + struct ublk_queue *ubq = ublk_get_queue(ub, i); 1608 + 1609 + for (j = 0; j < ubq->q_depth; j++) { 1610 + struct ublk_io *io = &ubq->ios[j]; 1611 + unsigned int refs = refcount_read(&io->ref) + 1612 + io->task_registered_buffers; 1613 + 1614 + /* 1615 + * UBLK_REFCOUNT_INIT or zero means no active 1616 + * reference 1617 + */ 1618 + if (refs != UBLK_REFCOUNT_INIT && refs != 0) 1619 + return true; 1620 + 1621 + /* reset to zero if the io hasn't active references */ 1622 + refcount_set(&io->ref, 0); 1623 + io->task_registered_buffers = 0; 1624 + } 1625 + } 1626 + return false; 1627 + } 1628 + 1629 + static void ublk_ch_release_work_fn(struct work_struct *work) 1630 + { 1631 + struct ublk_device *ub = 1632 + container_of(work, struct ublk_device, exit_work.work); 1602 1633 struct gendisk *disk; 1603 1634 int i; 1635 + 1636 + /* 1637 + * For zero-copy and auto buffer register modes, I/O references 1638 + * might not be dropped naturally when the daemon is killed, but 1639 + * io_uring guarantees that registered bvec kernel buffers are 1640 + * unregistered finally when freeing io_uring context, then the 1641 + * active references are dropped. 1642 + * 1643 + * Wait until active references are dropped for avoiding use-after-free 1644 + * 1645 + * registered buffer may be unregistered in io_ring's release hander, 1646 + * so have to wait by scheduling work function for avoiding the two 1647 + * file release dependency. 1648 + */ 1649 + if (ublk_check_and_reset_active_ref(ub)) { 1650 + schedule_delayed_work(&ub->exit_work, 1); 1651 + return; 1652 + } 1604 1653 1605 1654 /* 1606 1655 * disk isn't attached yet, either device isn't live, or it has ··· 1724 1673 ublk_reset_ch_dev(ub); 1725 1674 out: 1726 1675 clear_bit(UB_STATE_OPEN, &ub->state); 1676 + 1677 + /* put the reference grabbed in ublk_ch_release() */ 1678 + ublk_put_device(ub); 1679 + } 1680 + 1681 + static int ublk_ch_release(struct inode *inode, struct file *filp) 1682 + { 1683 + struct ublk_device *ub = filp->private_data; 1684 + 1685 + /* 1686 + * Grab ublk device reference, so it won't be gone until we are 1687 + * really released from work function. 1688 + */ 1689 + ublk_get_device(ub); 1690 + 1691 + INIT_DELAYED_WORK(&ub->exit_work, ublk_ch_release_work_fn); 1692 + schedule_delayed_work(&ub->exit_work, 0); 1727 1693 return 0; 1728 1694 } 1729 1695
+5 -5
tools/testing/selftests/ublk/file_backed.c
··· 20 20 struct io_uring_sqe *sqe[1]; 21 21 22 22 ublk_io_alloc_sqes(t, sqe, 1); 23 - io_uring_prep_fsync(sqe[0], 1 /*fds[1]*/, IORING_FSYNC_DATASYNC); 23 + io_uring_prep_fsync(sqe[0], ublk_get_registered_fd(q, 1) /*fds[1]*/, IORING_FSYNC_DATASYNC); 24 24 io_uring_sqe_set_flags(sqe[0], IOSQE_FIXED_FILE); 25 25 /* bit63 marks us as tgt io */ 26 26 sqe[0]->user_data = build_user_data(tag, ublk_op, 0, q->q_id, 1); ··· 42 42 if (!sqe[0]) 43 43 return -ENOMEM; 44 44 45 - io_uring_prep_rw(op, sqe[0], 1 /*fds[1]*/, 45 + io_uring_prep_rw(op, sqe[0], ublk_get_registered_fd(q, 1) /*fds[1]*/, 46 46 addr, 47 47 iod->nr_sectors << 9, 48 48 iod->start_sector << 9); ··· 56 56 57 57 ublk_io_alloc_sqes(t, sqe, 3); 58 58 59 - io_uring_prep_buf_register(sqe[0], 0, tag, q->q_id, ublk_get_io(q, tag)->buf_index); 59 + io_uring_prep_buf_register(sqe[0], q, tag, q->q_id, ublk_get_io(q, tag)->buf_index); 60 60 sqe[0]->flags |= IOSQE_CQE_SKIP_SUCCESS | IOSQE_IO_HARDLINK; 61 61 sqe[0]->user_data = build_user_data(tag, 62 62 ublk_cmd_op_nr(sqe[0]->cmd_op), 0, q->q_id, 1); 63 63 64 - io_uring_prep_rw(op, sqe[1], 1 /*fds[1]*/, 0, 64 + io_uring_prep_rw(op, sqe[1], ublk_get_registered_fd(q, 1) /*fds[1]*/, 0, 65 65 iod->nr_sectors << 9, 66 66 iod->start_sector << 9); 67 67 sqe[1]->buf_index = tag; 68 68 sqe[1]->flags |= IOSQE_FIXED_FILE | IOSQE_IO_HARDLINK; 69 69 sqe[1]->user_data = build_user_data(tag, ublk_op, 0, q->q_id, 1); 70 70 71 - io_uring_prep_buf_unregister(sqe[2], 0, tag, q->q_id, ublk_get_io(q, tag)->buf_index); 71 + io_uring_prep_buf_unregister(sqe[2], q, tag, q->q_id, ublk_get_io(q, tag)->buf_index); 72 72 sqe[2]->user_data = build_user_data(tag, ublk_cmd_op_nr(sqe[2]->cmd_op), 0, q->q_id, 1); 73 73 74 74 return 2;
+31 -7
tools/testing/selftests/ublk/kublk.c
··· 432 432 } 433 433 } 434 434 435 - static int ublk_queue_init(struct ublk_queue *q, unsigned extra_flags) 435 + static int ublk_queue_init(struct ublk_queue *q, unsigned long long extra_flags) 436 436 { 437 437 struct ublk_dev *dev = q->dev; 438 438 int depth = dev->dev_info.queue_depth; ··· 445 445 q->q_depth = depth; 446 446 q->flags = dev->dev_info.flags; 447 447 q->flags |= extra_flags; 448 + 449 + /* Cache fd in queue for fast path access */ 450 + q->ublk_fd = dev->fds[0]; 448 451 449 452 cmd_buf_size = ublk_queue_cmd_buf_sz(q); 450 453 off = UBLKSRV_CMD_BUF_OFFSET + q->q_id * ublk_queue_max_cmd_buf_sz(); ··· 484 481 return -ENOMEM; 485 482 } 486 483 487 - static int ublk_thread_init(struct ublk_thread *t) 484 + static int ublk_thread_init(struct ublk_thread *t, unsigned long long extra_flags) 488 485 { 489 486 struct ublk_dev *dev = t->dev; 487 + unsigned long long flags = dev->dev_info.flags | extra_flags; 490 488 int ring_depth = dev->tgt.sq_depth, cq_depth = dev->tgt.cq_depth; 491 489 int ret; 492 490 ··· 516 512 517 513 io_uring_register_ring_fd(&t->ring); 518 514 519 - ret = io_uring_register_files(&t->ring, dev->fds, dev->nr_fds); 515 + if (flags & UBLKS_Q_NO_UBLK_FIXED_FD) { 516 + /* Register only backing files starting from index 1, exclude ublk control device */ 517 + if (dev->nr_fds > 1) { 518 + ret = io_uring_register_files(&t->ring, &dev->fds[1], dev->nr_fds - 1); 519 + } else { 520 + /* No backing files to register, skip file registration */ 521 + ret = 0; 522 + } 523 + } else { 524 + ret = io_uring_register_files(&t->ring, dev->fds, dev->nr_fds); 525 + } 520 526 if (ret) { 521 527 ublk_err("ublk dev %d thread %d register files failed %d\n", 522 528 t->dev->dev_info.dev_id, t->idx, ret); ··· 640 626 641 627 /* These fields should be written once, never change */ 642 628 ublk_set_sqe_cmd_op(sqe[0], cmd_op); 643 - sqe[0]->fd = 0; /* dev->fds[0] */ 629 + sqe[0]->fd = ublk_get_registered_fd(q, 0); /* dev->fds[0] */ 644 630 sqe[0]->opcode = IORING_OP_URING_CMD; 645 - sqe[0]->flags = IOSQE_FIXED_FILE; 631 + if (q->flags & UBLKS_Q_NO_UBLK_FIXED_FD) 632 + sqe[0]->flags = 0; /* Use raw FD, not fixed file */ 633 + else 634 + sqe[0]->flags = IOSQE_FIXED_FILE; 646 635 sqe[0]->rw_flags = 0; 647 636 cmd->tag = io->tag; 648 637 cmd->q_id = q->q_id; ··· 849 832 unsigned idx; 850 833 sem_t *ready; 851 834 cpu_set_t *affinity; 835 + unsigned long long extra_flags; 852 836 }; 853 837 854 838 static void *ublk_io_handler_fn(void *data) ··· 862 844 t->dev = info->dev; 863 845 t->idx = info->idx; 864 846 865 - ret = ublk_thread_init(t); 847 + ret = ublk_thread_init(t, info->extra_flags); 866 848 if (ret) { 867 849 ublk_err("ublk dev %d thread %u init failed\n", 868 850 dev_id, t->idx); ··· 952 934 953 935 if (ctx->auto_zc_fallback) 954 936 extra_flags = UBLKS_Q_AUTO_BUF_REG_FALLBACK; 937 + if (ctx->no_ublk_fixed_fd) 938 + extra_flags |= UBLKS_Q_NO_UBLK_FIXED_FD; 955 939 956 940 for (i = 0; i < dinfo->nr_hw_queues; i++) { 957 941 dev->q[i].dev = dev; ··· 971 951 tinfo[i].dev = dev; 972 952 tinfo[i].idx = i; 973 953 tinfo[i].ready = &ready; 954 + tinfo[i].extra_flags = extra_flags; 974 955 975 956 /* 976 957 * If threads are not tied 1:1 to queues, setting thread ··· 1492 1471 printf("%s %s -t [null|loop|stripe|fault_inject] [-q nr_queues] [-d depth] [-n dev_id]\n", 1493 1472 exe, recovery ? "recover" : "add"); 1494 1473 printf("\t[--foreground] [--quiet] [-z] [--auto_zc] [--auto_zc_fallback] [--debug_mask mask] [-r 0|1 ] [-g]\n"); 1495 - printf("\t[-e 0|1 ] [-i 0|1]\n"); 1474 + printf("\t[-e 0|1 ] [-i 0|1] [--no_ublk_fixed_fd]\n"); 1496 1475 printf("\t[--nthreads threads] [--per_io_tasks]\n"); 1497 1476 printf("\t[target options] [backfile1] [backfile2] ...\n"); 1498 1477 printf("\tdefault: nr_queues=2(max 32), depth=128(max 1024), dev_id=-1(auto allocation)\n"); ··· 1555 1534 { "size", 1, NULL, 's'}, 1556 1535 { "nthreads", 1, NULL, 0 }, 1557 1536 { "per_io_tasks", 0, NULL, 0 }, 1537 + { "no_ublk_fixed_fd", 0, NULL, 0 }, 1558 1538 { 0, 0, 0, 0 } 1559 1539 }; 1560 1540 const struct ublk_tgt_ops *ops = NULL; ··· 1635 1613 ctx.nthreads = strtol(optarg, NULL, 10); 1636 1614 if (!strcmp(longopts[option_idx].name, "per_io_tasks")) 1637 1615 ctx.per_io_tasks = 1; 1616 + if (!strcmp(longopts[option_idx].name, "no_ublk_fixed_fd")) 1617 + ctx.no_ublk_fixed_fd = 1; 1638 1618 break; 1639 1619 case '?': 1640 1620 /*
+31 -14
tools/testing/selftests/ublk/kublk.h
··· 77 77 unsigned int recovery:1; 78 78 unsigned int auto_zc_fallback:1; 79 79 unsigned int per_io_tasks:1; 80 + unsigned int no_ublk_fixed_fd:1; 80 81 81 82 int _evtfd; 82 83 int _shmid; ··· 167 166 168 167 /* borrow one bit of ublk uapi flags, which may never be used */ 169 168 #define UBLKS_Q_AUTO_BUF_REG_FALLBACK (1ULL << 63) 169 + #define UBLKS_Q_NO_UBLK_FIXED_FD (1ULL << 62) 170 170 __u64 flags; 171 + int ublk_fd; /* cached ublk char device fd */ 171 172 struct ublk_io ios[UBLK_QUEUE_DEPTH]; 172 173 }; 173 174 ··· 276 273 return nr_sqes; 277 274 } 278 275 279 - static inline void io_uring_prep_buf_register(struct io_uring_sqe *sqe, 280 - int dev_fd, int tag, int q_id, __u64 index) 276 + static inline int ublk_get_registered_fd(struct ublk_queue *q, int fd_index) 277 + { 278 + if (q->flags & UBLKS_Q_NO_UBLK_FIXED_FD) { 279 + if (fd_index == 0) 280 + /* Return the raw ublk FD for index 0 */ 281 + return q->ublk_fd; 282 + /* Adjust index for backing files (index 1 becomes 0, etc.) */ 283 + return fd_index - 1; 284 + } 285 + return fd_index; 286 + } 287 + 288 + static inline void __io_uring_prep_buf_reg_unreg(struct io_uring_sqe *sqe, 289 + struct ublk_queue *q, int tag, int q_id, __u64 index) 281 290 { 282 291 struct ublksrv_io_cmd *cmd = (struct ublksrv_io_cmd *)sqe->cmd; 292 + int dev_fd = ublk_get_registered_fd(q, 0); 283 293 284 294 io_uring_prep_read(sqe, dev_fd, 0, 0, 0); 285 295 sqe->opcode = IORING_OP_URING_CMD; 286 - sqe->flags |= IOSQE_FIXED_FILE; 287 - sqe->cmd_op = UBLK_U_IO_REGISTER_IO_BUF; 296 + if (q->flags & UBLKS_Q_NO_UBLK_FIXED_FD) 297 + sqe->flags &= ~IOSQE_FIXED_FILE; 298 + else 299 + sqe->flags |= IOSQE_FIXED_FILE; 288 300 289 301 cmd->tag = tag; 290 302 cmd->addr = index; 291 303 cmd->q_id = q_id; 292 304 } 293 305 294 - static inline void io_uring_prep_buf_unregister(struct io_uring_sqe *sqe, 295 - int dev_fd, int tag, int q_id, __u64 index) 306 + static inline void io_uring_prep_buf_register(struct io_uring_sqe *sqe, 307 + struct ublk_queue *q, int tag, int q_id, __u64 index) 296 308 { 297 - struct ublksrv_io_cmd *cmd = (struct ublksrv_io_cmd *)sqe->cmd; 309 + __io_uring_prep_buf_reg_unreg(sqe, q, tag, q_id, index); 310 + sqe->cmd_op = UBLK_U_IO_REGISTER_IO_BUF; 311 + } 298 312 299 - io_uring_prep_read(sqe, dev_fd, 0, 0, 0); 300 - sqe->opcode = IORING_OP_URING_CMD; 301 - sqe->flags |= IOSQE_FIXED_FILE; 313 + static inline void io_uring_prep_buf_unregister(struct io_uring_sqe *sqe, 314 + struct ublk_queue *q, int tag, int q_id, __u64 index) 315 + { 316 + __io_uring_prep_buf_reg_unreg(sqe, q, tag, q_id, index); 302 317 sqe->cmd_op = UBLK_U_IO_UNREGISTER_IO_BUF; 303 - 304 - cmd->tag = tag; 305 - cmd->addr = index; 306 - cmd->q_id = q_id; 307 318 } 308 319 309 320 static inline void *ublk_get_sqe_cmd(const struct io_uring_sqe *sqe)
+2 -2
tools/testing/selftests/ublk/null.c
··· 63 63 64 64 ublk_io_alloc_sqes(t, sqe, 3); 65 65 66 - io_uring_prep_buf_register(sqe[0], 0, tag, q->q_id, ublk_get_io(q, tag)->buf_index); 66 + io_uring_prep_buf_register(sqe[0], q, tag, q->q_id, ublk_get_io(q, tag)->buf_index); 67 67 sqe[0]->user_data = build_user_data(tag, 68 68 ublk_cmd_op_nr(sqe[0]->cmd_op), 0, q->q_id, 1); 69 69 sqe[0]->flags |= IOSQE_CQE_SKIP_SUCCESS | IOSQE_IO_HARDLINK; ··· 71 71 __setup_nop_io(tag, iod, sqe[1], q->q_id); 72 72 sqe[1]->flags |= IOSQE_IO_HARDLINK; 73 73 74 - io_uring_prep_buf_unregister(sqe[2], 0, tag, q->q_id, ublk_get_io(q, tag)->buf_index); 74 + io_uring_prep_buf_unregister(sqe[2], q, tag, q->q_id, ublk_get_io(q, tag)->buf_index); 75 75 sqe[2]->user_data = build_user_data(tag, ublk_cmd_op_nr(sqe[2]->cmd_op), 0, q->q_id, 1); 76 76 77 77 // buf register is marked as IOSQE_CQE_SKIP_SUCCESS
+2 -2
tools/testing/selftests/ublk/stripe.c
··· 142 142 ublk_io_alloc_sqes(t, sqe, s->nr + extra); 143 143 144 144 if (zc) { 145 - io_uring_prep_buf_register(sqe[0], 0, tag, q->q_id, io->buf_index); 145 + io_uring_prep_buf_register(sqe[0], q, tag, q->q_id, io->buf_index); 146 146 sqe[0]->flags |= IOSQE_CQE_SKIP_SUCCESS | IOSQE_IO_HARDLINK; 147 147 sqe[0]->user_data = build_user_data(tag, 148 148 ublk_cmd_op_nr(sqe[0]->cmd_op), 0, q->q_id, 1); ··· 168 168 if (zc) { 169 169 struct io_uring_sqe *unreg = sqe[s->nr + 1]; 170 170 171 - io_uring_prep_buf_unregister(unreg, 0, tag, q->q_id, io->buf_index); 171 + io_uring_prep_buf_unregister(unreg, q, tag, q->q_id, io->buf_index); 172 172 unreg->user_data = build_user_data( 173 173 tag, ublk_cmd_op_nr(unreg->cmd_op), 0, q->q_id, 1); 174 174 }
+3 -3
tools/testing/selftests/ublk/test_stress_04.sh
··· 28 28 _create_backfile 1 128M 29 29 _create_backfile 2 128M 30 30 31 - ublk_io_and_kill_daemon 8G -t null -q 4 -z & 32 - ublk_io_and_kill_daemon 256M -t loop -q 4 -z "${UBLK_BACKFILES[0]}" & 31 + ublk_io_and_kill_daemon 8G -t null -q 4 -z --no_ublk_fixed_fd & 32 + ublk_io_and_kill_daemon 256M -t loop -q 4 -z --no_ublk_fixed_fd "${UBLK_BACKFILES[0]}" & 33 33 ublk_io_and_kill_daemon 256M -t stripe -q 4 -z "${UBLK_BACKFILES[1]}" "${UBLK_BACKFILES[2]}" & 34 34 35 35 if _have_feature "AUTO_BUF_REG"; then 36 36 ublk_io_and_kill_daemon 8G -t null -q 4 --auto_zc & 37 37 ublk_io_and_kill_daemon 256M -t loop -q 4 --auto_zc "${UBLK_BACKFILES[0]}" & 38 - ublk_io_and_kill_daemon 256M -t stripe -q 4 --auto_zc "${UBLK_BACKFILES[1]}" "${UBLK_BACKFILES[2]}" & 38 + ublk_io_and_kill_daemon 256M -t stripe -q 4 --auto_zc --no_ublk_fixed_fd "${UBLK_BACKFILES[1]}" "${UBLK_BACKFILES[2]}" & 39 39 ublk_io_and_kill_daemon 8G -t null -q 4 -z --auto_zc --auto_zc_fallback & 40 40 fi 41 41