2022-05-25 14:59:19 +03:00
// SPDX-License-Identifier: GPL-2.0
# include <linux/kernel.h>
# include <linux/errno.h>
# include <linux/file.h>
# include <linux/io_uring.h>
2022-07-15 22:16:22 +03:00
# include <linux/security.h>
2022-09-30 09:27:39 +03:00
# include <linux/nospec.h>
2022-05-25 14:59:19 +03:00
# include <uapi/linux/io_uring.h>
2023-06-27 16:44:24 +03:00
# include <uapi/asm-generic/ioctls.h>
2022-05-25 14:59:19 +03:00
# include "io_uring.h"
2022-09-30 09:27:38 +03:00
# include "rsrc.h"
2022-05-25 14:59:19 +03:00
# include "uring_cmd.h"
2023-09-28 15:43:25 +03:00
static void io_uring_cmd_del_cancelable ( struct io_uring_cmd * cmd ,
unsigned int issue_flags )
{
struct io_kiocb * req = cmd_to_io_kiocb ( cmd ) ;
struct io_ring_ctx * ctx = req - > ctx ;
if ( ! ( cmd - > flags & IORING_URING_CMD_CANCELABLE ) )
return ;
cmd - > flags & = ~ IORING_URING_CMD_CANCELABLE ;
io_ring_submit_lock ( ctx , issue_flags ) ;
hlist_del ( & req - > hash_node ) ;
io_ring_submit_unlock ( ctx , issue_flags ) ;
}
/*
* Mark this command as concelable , then io_uring_try_cancel_uring_cmd ( )
* will try to cancel this issued command by sending - > uring_cmd ( ) with
* issue_flags of IO_URING_F_CANCEL .
*
* The command is guaranteed to not be done when calling - > uring_cmd ( )
* with IO_URING_F_CANCEL , but it is driver ' s responsibility to deal
* with race between io_uring canceling and normal completion .
*/
void io_uring_cmd_mark_cancelable ( struct io_uring_cmd * cmd ,
unsigned int issue_flags )
{
struct io_kiocb * req = cmd_to_io_kiocb ( cmd ) ;
struct io_ring_ctx * ctx = req - > ctx ;
if ( ! ( cmd - > flags & IORING_URING_CMD_CANCELABLE ) ) {
cmd - > flags | = IORING_URING_CMD_CANCELABLE ;
io_ring_submit_lock ( ctx , issue_flags ) ;
hlist_add_head ( & req - > hash_node , & ctx - > cancelable_uring_cmd ) ;
io_ring_submit_unlock ( ctx , issue_flags ) ;
}
}
EXPORT_SYMBOL_GPL ( io_uring_cmd_mark_cancelable ) ;
struct task_struct * io_uring_cmd_get_task ( struct io_uring_cmd * cmd )
{
return cmd_to_io_kiocb ( cmd ) - > task ;
}
EXPORT_SYMBOL_GPL ( io_uring_cmd_get_task ) ;
2023-03-27 18:38:15 +03:00
static void io_uring_cmd_work ( struct io_kiocb * req , struct io_tw_state * ts )
2022-05-25 14:59:19 +03:00
{
2022-08-11 10:11:15 +03:00
struct io_uring_cmd * ioucmd = io_kiocb_to_cmd ( req , struct io_uring_cmd ) ;
2023-03-27 18:38:15 +03:00
unsigned issue_flags = ts - > locked ? 0 : IO_URING_F_UNLOCKED ;
2022-05-25 14:59:19 +03:00
2023-03-21 05:01:25 +03:00
ioucmd - > task_work_cb ( ioucmd , issue_flags ) ;
2022-05-25 14:59:19 +03:00
}
2023-05-15 15:54:42 +03:00
void __io_uring_cmd_do_in_task ( struct io_uring_cmd * ioucmd ,
void ( * task_work_cb ) ( struct io_uring_cmd * , unsigned ) ,
unsigned flags )
2022-05-25 14:59:19 +03:00
{
struct io_kiocb * req = cmd_to_io_kiocb ( ioucmd ) ;
ioucmd - > task_work_cb = task_work_cb ;
req - > io_task_work . func = io_uring_cmd_work ;
2023-05-15 15:54:42 +03:00
__io_req_task_work_add ( req , flags ) ;
}
EXPORT_SYMBOL_GPL ( __io_uring_cmd_do_in_task ) ;
void io_uring_cmd_do_in_task_lazy ( struct io_uring_cmd * ioucmd ,
void ( * task_work_cb ) ( struct io_uring_cmd * , unsigned ) )
{
__io_uring_cmd_do_in_task ( ioucmd , task_work_cb , IOU_F_TWQ_LAZY_WAKE ) ;
2022-05-25 14:59:19 +03:00
}
2023-05-15 15:54:42 +03:00
EXPORT_SYMBOL_GPL ( io_uring_cmd_do_in_task_lazy ) ;
2022-05-25 14:59:19 +03:00
static inline void io_req_set_cqe32_extra ( struct io_kiocb * req ,
u64 extra1 , u64 extra2 )
{
2023-08-25 01:53:25 +03:00
req - > big_cqe . extra1 = extra1 ;
req - > big_cqe . extra2 = extra2 ;
2022-05-25 14:59:19 +03:00
}
/*
* Called by consumers of io_uring_cmd , if they originally returned
* - EIOCBQUEUED upon receiving the command .
*/
2023-03-21 05:01:25 +03:00
void io_uring_cmd_done ( struct io_uring_cmd * ioucmd , ssize_t ret , ssize_t res2 ,
unsigned issue_flags )
2022-05-25 14:59:19 +03:00
{
struct io_kiocb * req = cmd_to_io_kiocb ( ioucmd ) ;
2023-09-28 15:43:25 +03:00
io_uring_cmd_del_cancelable ( ioucmd , issue_flags ) ;
2022-05-25 14:59:19 +03:00
if ( ret < 0 )
req_set_fail ( req ) ;
2022-08-03 15:07:57 +03:00
io_req_set_res ( req , ret , 0 ) ;
2022-05-25 14:59:19 +03:00
if ( req - > ctx - > flags & IORING_SETUP_CQE32 )
io_req_set_cqe32_extra ( req , res2 , 0 ) ;
2023-04-12 21:07:36 +03:00
if ( req - > ctx - > flags & IORING_SETUP_IOPOLL ) {
2022-08-23 19:14:41 +03:00
/* order with io_iopoll_req_issued() checking ->iopoll_complete */
smp_store_release ( & req - > iopoll_completed , 1 ) ;
2023-04-12 21:07:36 +03:00
} else {
struct io_tw_state ts = {
. locked = ! ( issue_flags & IO_URING_F_UNLOCKED ) ,
} ;
io_req_task_complete ( req , & ts ) ;
}
2022-05-25 14:59:19 +03:00
}
EXPORT_SYMBOL_GPL ( io_uring_cmd_done ) ;
int io_uring_cmd_prep_async ( struct io_kiocb * req )
{
2022-08-11 10:11:15 +03:00
struct io_uring_cmd * ioucmd = io_kiocb_to_cmd ( req , struct io_uring_cmd ) ;
2022-05-25 14:59:19 +03:00
io_uring: Pass whole sqe to commands
Currently uring CMD operation relies on having large SQEs, but future
operations might want to use normal SQE.
The io_uring_cmd currently only saves the payload (cmd) part of the SQE,
but, for commands that use normal SQE size, it might be necessary to
access the initial SQE fields outside of the payload/cmd block. So,
saves the whole SQE other than just the pdu.
This changes slightly how the io_uring_cmd works, since the cmd
structures and callbacks are not opaque to io_uring anymore. I.e, the
callbacks can look at the SQE entries, not only, in the cmd structure.
The main advantage is that we don't need to create custom structures for
simple commands.
Creates io_uring_sqe_cmd() that returns the cmd private data as a null
pointer and avoids casting in the callee side.
Also, make most of ublk_drv's sqe->cmd priv structure into const, and use
io_uring_sqe_cmd() to get the private structure, removing the unwanted
cast. (There is one case where the cast is still needed since the
header->{len,addr} is updated in the private structure)
Suggested-by: Pavel Begunkov <asml.silence@gmail.com>
Signed-off-by: Breno Leitao <leitao@debian.org>
Reviewed-by: Keith Busch <kbusch@kernel.org>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Pavel Begunkov <asml.silence@gmail.com>
Link: https://lore.kernel.org/r/20230504121856.904491-3-leitao@debian.org
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2023-05-04 15:18:55 +03:00
memcpy ( req - > async_data , ioucmd - > sqe , uring_sqe_size ( req - > ctx ) ) ;
ioucmd - > sqe = req - > async_data ;
2022-05-25 14:59:19 +03:00
return 0 ;
}
int io_uring_cmd_prep ( struct io_kiocb * req , const struct io_uring_sqe * sqe )
{
2022-08-11 10:11:15 +03:00
struct io_uring_cmd * ioucmd = io_kiocb_to_cmd ( req , struct io_uring_cmd ) ;
2022-05-25 14:59:19 +03:00
2022-09-30 09:27:39 +03:00
if ( sqe - > __pad1 )
2022-05-25 14:59:19 +03:00
return - EINVAL ;
2022-09-30 09:27:39 +03:00
ioucmd - > flags = READ_ONCE ( sqe - > uring_cmd_flags ) ;
2023-09-28 15:43:24 +03:00
if ( ioucmd - > flags & ~ IORING_URING_CMD_MASK )
2022-09-30 09:27:39 +03:00
return - EINVAL ;
if ( ioucmd - > flags & IORING_URING_CMD_FIXED ) {
struct io_ring_ctx * ctx = req - > ctx ;
u16 index ;
req - > buf_index = READ_ONCE ( sqe - > buf_index ) ;
if ( unlikely ( req - > buf_index > = ctx - > nr_user_bufs ) )
return - EFAULT ;
index = array_index_nospec ( req - > buf_index , ctx - > nr_user_bufs ) ;
req - > imu = ctx - > user_bufs [ index ] ;
io_req_set_rsrc_node ( req , ctx , 0 ) ;
}
io_uring: Pass whole sqe to commands
Currently uring CMD operation relies on having large SQEs, but future
operations might want to use normal SQE.
The io_uring_cmd currently only saves the payload (cmd) part of the SQE,
but, for commands that use normal SQE size, it might be necessary to
access the initial SQE fields outside of the payload/cmd block. So,
saves the whole SQE other than just the pdu.
This changes slightly how the io_uring_cmd works, since the cmd
structures and callbacks are not opaque to io_uring anymore. I.e, the
callbacks can look at the SQE entries, not only, in the cmd structure.
The main advantage is that we don't need to create custom structures for
simple commands.
Creates io_uring_sqe_cmd() that returns the cmd private data as a null
pointer and avoids casting in the callee side.
Also, make most of ublk_drv's sqe->cmd priv structure into const, and use
io_uring_sqe_cmd() to get the private structure, removing the unwanted
cast. (There is one case where the cast is still needed since the
header->{len,addr} is updated in the private structure)
Suggested-by: Pavel Begunkov <asml.silence@gmail.com>
Signed-off-by: Breno Leitao <leitao@debian.org>
Reviewed-by: Keith Busch <kbusch@kernel.org>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Pavel Begunkov <asml.silence@gmail.com>
Link: https://lore.kernel.org/r/20230504121856.904491-3-leitao@debian.org
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2023-05-04 15:18:55 +03:00
ioucmd - > sqe = sqe ;
2022-05-25 14:59:19 +03:00
ioucmd - > cmd_op = READ_ONCE ( sqe - > cmd_op ) ;
return 0 ;
}
int io_uring_cmd ( struct io_kiocb * req , unsigned int issue_flags )
{
2022-08-11 10:11:15 +03:00
struct io_uring_cmd * ioucmd = io_kiocb_to_cmd ( req , struct io_uring_cmd ) ;
2022-05-25 14:59:19 +03:00
struct io_ring_ctx * ctx = req - > ctx ;
struct file * file = req - > file ;
int ret ;
2023-03-08 19:26:13 +03:00
if ( ! file - > f_op - > uring_cmd )
2022-05-25 14:59:19 +03:00
return - EOPNOTSUPP ;
2022-07-15 22:16:22 +03:00
ret = security_uring_cmd ( ioucmd ) ;
if ( ret )
return ret ;
2022-05-25 14:59:19 +03:00
if ( ctx - > flags & IORING_SETUP_SQE128 )
issue_flags | = IO_URING_F_SQE128 ;
if ( ctx - > flags & IORING_SETUP_CQE32 )
issue_flags | = IO_URING_F_CQE32 ;
2023-10-16 16:47:43 +03:00
if ( ctx - > compat )
issue_flags | = IO_URING_F_COMPAT ;
2022-08-23 19:14:41 +03:00
if ( ctx - > flags & IORING_SETUP_IOPOLL ) {
2023-03-08 19:26:13 +03:00
if ( ! file - > f_op - > uring_cmd_iopoll )
return - EOPNOTSUPP ;
2022-05-25 14:59:19 +03:00
issue_flags | = IO_URING_F_IOPOLL ;
2022-08-23 19:14:41 +03:00
req - > iopoll_completed = 0 ;
WRITE_ONCE ( ioucmd - > cookie , NULL ) ;
}
2022-05-25 14:59:19 +03:00
ret = file - > f_op - > uring_cmd ( ioucmd , issue_flags ) ;
if ( ret = = - EAGAIN ) {
if ( ! req_has_async_data ( req ) ) {
if ( io_alloc_async_data ( req ) )
return - ENOMEM ;
io_uring_cmd_prep_async ( req ) ;
}
return - EAGAIN ;
}
if ( ret ! = - EIOCBQUEUED ) {
2022-08-11 12:14:59 +03:00
if ( ret < 0 )
req_set_fail ( req ) ;
io_req_set_res ( req , ret , 0 ) ;
2022-08-23 18:10:22 +03:00
return ret ;
2022-05-25 14:59:19 +03:00
}
return IOU_ISSUE_SKIP_COMPLETE ;
}
2022-09-30 09:27:38 +03:00
int io_uring_cmd_import_fixed ( u64 ubuf , unsigned long len , int rw ,
struct iov_iter * iter , void * ioucmd )
{
struct io_kiocb * req = cmd_to_io_kiocb ( ioucmd ) ;
return io_import_fixed ( rw , iter , req - > imu , ubuf , len ) ;
}
EXPORT_SYMBOL_GPL ( io_uring_cmd_import_fixed ) ;
2023-06-27 16:44:24 +03:00
2023-10-16 16:47:47 +03:00
static inline int io_uring_cmd_getsockopt ( struct socket * sock ,
struct io_uring_cmd * cmd ,
unsigned int issue_flags )
{
bool compat = ! ! ( issue_flags & IO_URING_F_COMPAT ) ;
int optlen , optname , level , err ;
void __user * optval ;
level = READ_ONCE ( cmd - > sqe - > level ) ;
if ( level ! = SOL_SOCKET )
return - EOPNOTSUPP ;
optval = u64_to_user_ptr ( READ_ONCE ( cmd - > sqe - > optval ) ) ;
optname = READ_ONCE ( cmd - > sqe - > optname ) ;
optlen = READ_ONCE ( cmd - > sqe - > optlen ) ;
err = do_sock_getsockopt ( sock , compat , level , optname ,
USER_SOCKPTR ( optval ) ,
KERNEL_SOCKPTR ( & optlen ) ) ;
if ( err )
return err ;
/* On success, return optlen */
return optlen ;
}
2023-10-16 16:47:46 +03:00
# if defined(CONFIG_NET)
2023-06-27 16:44:24 +03:00
int io_uring_cmd_sock ( struct io_uring_cmd * cmd , unsigned int issue_flags )
{
struct socket * sock = cmd - > file - > private_data ;
struct sock * sk = sock - > sk ;
struct proto * prot = READ_ONCE ( sk - > sk_prot ) ;
int ret , arg = 0 ;
if ( ! prot | | ! prot - > ioctl )
return - EOPNOTSUPP ;
switch ( cmd - > sqe - > cmd_op ) {
case SOCKET_URING_OP_SIOCINQ :
ret = prot - > ioctl ( sk , SIOCINQ , & arg ) ;
if ( ret )
return ret ;
return arg ;
case SOCKET_URING_OP_SIOCOUTQ :
ret = prot - > ioctl ( sk , SIOCOUTQ , & arg ) ;
if ( ret )
return ret ;
return arg ;
2023-10-16 16:47:47 +03:00
case SOCKET_URING_OP_GETSOCKOPT :
return io_uring_cmd_getsockopt ( sock , cmd , issue_flags ) ;
2023-06-27 16:44:24 +03:00
default :
return - EOPNOTSUPP ;
}
}
EXPORT_SYMBOL_GPL ( io_uring_cmd_sock ) ;
2023-10-16 16:47:46 +03:00
# endif