[PATCH 371/437] drivers/ntb: convert to read/write iterators

Jens Axboe
2024-04-11T15:42:05Z

drivers/ntb/hw/amd/ntb_hw_amd.c | 10 +-
drivers/ntb/hw/idt/ntb_hw_idt.c | 29 ++-
drivers/ntb/hw/intel/ntb_hw_gen1.c | 21 +-
drivers/ntb/hw/intel/ntb_hw_gen3.c | 8 +-
drivers/ntb/hw/intel/ntb_hw_gen3.h | 3 +-
drivers/ntb/hw/intel/ntb_hw_gen4.c | 8 +-
drivers/ntb/hw/intel/ntb_hw_gen4.h | 5 +-
drivers/ntb/ntb_transport.c | 9 +-
drivers/ntb/test/ntb_perf.c | 49 +++--
drivers/ntb/test/ntb_tool.c | 307 +++++++++++++----------------
10 files changed, 203 insertions(+), 246 deletions(-)

diff --git a/drivers/ntb/hw/amd/ntb_hw_amd.c b/drivers/ntb/hw/amd/ntb_hw_amd.c
index d687e8c2cc78..027bcfb2bb11 100644
--- a/drivers/ntb/hw/amd/ntb_hw_amd.c
+++ b/drivers/ntb/hw/amd/ntb_hw_amd.c
@@ -835,8 +835,7 @@ static void ndev_deinit_isr(struct amd_ntb_dev *ndev)
}
}

-static ssize_t ndev_debugfs_read(struct file *filp, char __user *ubuf,
- size_t count, loff_t *offp)
+static ssize_t ndev_debugfs_read(struct kiocb *iocb, struct iov_iter *to)
{
struct amd_ntb_dev *ndev;
void __iomem *mmio;
@@ -844,8 +843,9 @@ static ssize_t ndev_debugfs_read(struct file *filp, char __user *ubuf,
size_t buf_size;
ssize_t ret, off;
union { u64 v64; u32 v32; u16 v16; } u;
+ size_t count = iov_iter_count(to);

- ndev = filp->private_data;
+ ndev = iocb->ki_filp->private_data;
mmio = ndev->self_mmio;

buf_size = min(count, 0x800ul);
@@ -927,7 +927,7 @@ static ssize_t ndev_debugfs_read(struct file *filp, char __user *ubuf,
off += scnprintf(buf + off, buf_size - off,
"LMT45 -\t\t\t%#018llx\n", u.v64);

- ret = simple_read_from_buffer(ubuf, count, offp, buf, off);
+ ret = simple_copy_to_iter(buf, &iocb->ki_pos, off, to);
kfree(buf);
return ret;
}
@@ -1299,7 +1299,7 @@ static void amd_ntb_pci_shutdown(struct pci_dev *pdev)
static const struct file_operations amd_ntb_debugfs_info = {
.owner = THIS_MODULE,
.open = simple_open,
- .read = ndev_debugfs_read,
+ .read_iter = ndev_debugfs_read,
};

static const struct ntb_dev_data dev_data[] = {
diff --git a/drivers/ntb/hw/idt/ntb_hw_idt.c b/drivers/ntb/hw/idt/ntb_hw_idt.c
index 48823b53ede3..9213ba1eb36f 100644
--- a/drivers/ntb/hw/idt/ntb_hw_idt.c
+++ b/drivers/ntb/hw/idt/ntb_hw_idt.c
@@ -2312,18 +2312,6 @@ static void idt_unregister_device(struct idt_ntb_dev *ndev)
*=============================================================================
*/

-static ssize_t idt_dbgfs_info_read(struct file *filp, char __user *ubuf,
- size_t count, loff_t *offp);
-
-/*
- * Driver DebugFS info file operations
- */
-static const struct file_operations idt_dbgfs_info_ops = {
- .owner = THIS_MODULE,
- .open = simple_open,
- .read = idt_dbgfs_info_read
-};
-
/*
* idt_dbgfs_info_read() - DebugFS read info node callback
* @file: File node descriptor.
@@ -2331,10 +2319,10 @@ static const struct file_operations idt_dbgfs_info_ops = {
* @count: Size of the buffer
* @offp: Offset within the buffer
*/
-static ssize_t idt_dbgfs_info_read(struct file *filp, char __user *ubuf,
- size_t count, loff_t *offp)
+static ssize_t idt_dbgfs_info_read(struct kiocb *iocb, struct iov_iter *to)
{
- struct idt_ntb_dev *ndev = filp->private_data;
+ struct idt_ntb_dev *ndev = iocb->ki_filp->private_data;
+ size_t count = iov_iter_count(to);
unsigned char idx, pidx, cnt;
unsigned long irqflags, mdeg;
ssize_t ret = 0, off = 0;
@@ -2492,12 +2480,21 @@ static ssize_t idt_dbgfs_info_read(struct file *filp, char __user *ubuf,
idt_get_deg(mdeg), idt_get_deg_frac(mdeg));

/* Copy the buffer to the User Space */
- ret = simple_read_from_buffer(ubuf, count, offp, strbuf, off);
+ ret = simple_copy_to_iter(strbuf, &iocb->ki_pos, off, to);
kfree(strbuf);

return ret;
}

+/*
+ * Driver DebugFS info file operations
+ */
+static const struct file_operations idt_dbgfs_info_ops = {
+ .owner = THIS_MODULE,
+ .open = simple_open,
+ .read_iter = idt_dbgfs_info_read
+};
+
/*
* idt_init_dbgfs() - initialize DebugFS node
* @ndev: IDT NTB hardware driver descriptor
diff --git a/drivers/ntb/hw/intel/ntb_hw_gen1.c b/drivers/ntb/hw/intel/ntb_hw_gen1.c
index 9ab836d0d4f1..de31b75f3d20 100644
--- a/drivers/ntb/hw/intel/ntb_hw_gen1.c
+++ b/drivers/ntb/hw/intel/ntb_hw_gen1.c
@@ -488,8 +488,7 @@ static void ndev_deinit_isr(struct intel_ntb_dev *ndev)
}
}

-static ssize_t ndev_ntb_debugfs_read(struct file *filp, char __user *ubuf,
- size_t count, loff_t *offp)
+static ssize_t ndev_ntb_debugfs_read(struct kiocb *iocb, struct iov_iter *to)
{
struct intel_ntb_dev *ndev;
struct pci_dev *pdev;
@@ -498,8 +497,9 @@ static ssize_t ndev_ntb_debugfs_read(struct file *filp, char __user *ubuf,
size_t buf_size;
ssize_t ret, off;
union { u64 v64; u32 v32; u16 v16; u8 v8; } u;
+ size_t count = iov_iter_count(to);

- ndev = filp->private_data;
+ ndev = iocb->ki_filp->private_data;
pdev = ndev->ntb.pdev;
mmio = ndev->self_mmio;

@@ -749,22 +749,21 @@ static ssize_t ndev_ntb_debugfs_read(struct file *filp, char __user *ubuf,
"CORERRSTS -\t\t%#06x\n", u.v32);
}

- ret = simple_read_from_buffer(ubuf, count, offp, buf, off);
+ ret = simple_copy_to_iter(buf, &iocb->ki_pos, off, to);
kfree(buf);
return ret;
}

-static ssize_t ndev_debugfs_read(struct file *filp, char __user *ubuf,
- size_t count, loff_t *offp)
+static ssize_t ndev_debugfs_read(struct kiocb *iocb, struct iov_iter *to)
{
- struct intel_ntb_dev *ndev = filp->private_data;
+ struct intel_ntb_dev *ndev = iocb->ki_filp->private_data;

if (pdev_is_gen1(ndev->ntb.pdev))
- return ndev_ntb_debugfs_read(filp, ubuf, count, offp);
+ return ndev_ntb_debugfs_read(iocb, to);
else if (pdev_is_gen3(ndev->ntb.pdev))
- return ndev_ntb3_debugfs_read(filp, ubuf, count, offp);
+ return ndev_ntb3_debugfs_read(iocb, to);
else if (pdev_is_gen4(ndev->ntb.pdev) || pdev_is_gen5(ndev->ntb.pdev))
- return ndev_ntb4_debugfs_read(filp, ubuf, count, offp);
+ return ndev_ntb4_debugfs_read(iocb, to);

return -ENXIO;
}
@@ -2021,7 +2020,7 @@ static const struct ntb_dev_ops intel_ntb_ops = {
static const struct file_operations intel_ntb_debugfs_info = {
.owner = THIS_MODULE,
.open = simple_open,
- .read = ndev_debugfs_read,
+ .read_iter = ndev_debugfs_read,
};

static const struct pci_device_id intel_ntb_pci_tbl[] = {
diff --git a/drivers/ntb/hw/intel/ntb_hw_gen3.c b/drivers/ntb/hw/intel/ntb_hw_gen3.c
index ffcfc3e02c35..56caeb639016 100644
--- a/drivers/ntb/hw/intel/ntb_hw_gen3.c
+++ b/drivers/ntb/hw/intel/ntb_hw_gen3.c
@@ -252,8 +252,7 @@ int gen3_init_dev(struct intel_ntb_dev *ndev)
return gen3_init_isr(ndev);
}

-ssize_t ndev_ntb3_debugfs_read(struct file *filp, char __user *ubuf,
- size_t count, loff_t *offp)
+ssize_t ndev_ntb3_debugfs_read(struct kiocb *iocb, struct iov_iter *to)
{
struct intel_ntb_dev *ndev;
void __iomem *mmio;
@@ -261,8 +260,9 @@ ssize_t ndev_ntb3_debugfs_read(struct file *filp, char __user *ubuf,
size_t buf_size;
ssize_t ret, off;
union { u64 v64; u32 v32; u16 v16; } u;
+ size_t count = iov_iter_count(to);

- ndev = filp->private_data;
+ ndev = iocb->ki_filp->private_data;
mmio = ndev->self_mmio;

buf_size = min(count, 0x800ul);
@@ -410,7 +410,7 @@ ssize_t ndev_ntb3_debugfs_read(struct file *filp, char __user *ubuf,
off += scnprintf(buf + off, buf_size - off,
"CORERRSTS -\t\t%#06x\n", u.v32);

- ret = simple_read_from_buffer(ubuf, count, offp, buf, off);
+ ret = simple_copy_to_iter(buf, &iocb->ki_pos, off, to);
kfree(buf);
return ret;
}
diff --git a/drivers/ntb/hw/intel/ntb_hw_gen3.h b/drivers/ntb/hw/intel/ntb_hw_gen3.h
index dea93989942d..0eddbee39972 100644
--- a/drivers/ntb/hw/intel/ntb_hw_gen3.h
+++ b/drivers/ntb/hw/intel/ntb_hw_gen3.h
@@ -101,8 +101,7 @@ static inline void gen3_db_iowrite(u64 bits, void __iomem *mmio)
iowrite64(bits, mmio);
}

-ssize_t ndev_ntb3_debugfs_read(struct file *filp, char __user *ubuf,
- size_t count, loff_t *offp);
+ssize_t ndev_ntb3_debugfs_read(struct kiocb *iocb, struct iov_iter *to);
int gen3_init_dev(struct intel_ntb_dev *ndev);
int intel_ntb3_link_enable(struct ntb_dev *ntb, enum ntb_speed max_speed,
enum ntb_width max_width);
diff --git a/drivers/ntb/hw/intel/ntb_hw_gen4.c b/drivers/ntb/hw/intel/ntb_hw_gen4.c
index 22cac7975b3c..7fb3d963abec 100644
--- a/drivers/ntb/hw/intel/ntb_hw_gen4.c
+++ b/drivers/ntb/hw/intel/ntb_hw_gen4.c
@@ -216,8 +216,7 @@ int gen4_init_dev(struct intel_ntb_dev *ndev)
return gen4_init_isr(ndev);
}

-ssize_t ndev_ntb4_debugfs_read(struct file *filp, char __user *ubuf,
- size_t count, loff_t *offp)
+ssize_t ndev_ntb4_debugfs_read(struct kiocb *iocb, struct iov_iter *to)
{
struct intel_ntb_dev *ndev;
void __iomem *mmio;
@@ -225,8 +224,9 @@ ssize_t ndev_ntb4_debugfs_read(struct file *filp, char __user *ubuf,
size_t buf_size;
ssize_t ret, off;
union { u64 v64; u32 v32; u16 v16; } u;
+ size_t count = iov_iter_count(to);

- ndev = filp->private_data;
+ ndev = iocb->ki_filp->private_data;
mmio = ndev->self_mmio;

buf_size = min(count, 0x800ul);
@@ -329,7 +329,7 @@ ssize_t ndev_ntb4_debugfs_read(struct file *filp, char __user *ubuf,
off += scnprintf(buf + off, buf_size - off,
"CORERRSTS -\t\t%#06x\n", u.v32);

- ret = simple_read_from_buffer(ubuf, count, offp, buf, off);
+ ret = simple_copy_to_iter(buf, &iocb->ki_pos, off, to);
kfree(buf);
return ret;
}
diff --git a/drivers/ntb/hw/intel/ntb_hw_gen4.h b/drivers/ntb/hw/intel/ntb_hw_gen4.h
index f91323eaf5ce..6c0fa8c99715 100644
--- a/drivers/ntb/hw/intel/ntb_hw_gen4.h
+++ b/drivers/ntb/hw/intel/ntb_hw_gen4.h
@@ -103,11 +103,8 @@
#define NTB_LTR_IDLE_LATSCALE 0x0800 /* 1us scale */
#define NTB_LTR_IDLE_REQMNT 0x8000 /* snoop req enable */

-ssize_t ndev_ntb4_debugfs_read(struct file *filp, char __user *ubuf,
- size_t count, loff_t *offp);
+ssize_t ndev_ntb4_debugfs_read(struct kiocb *iocb, struct iov_iter *to);
int gen4_init_dev(struct intel_ntb_dev *ndev);
-ssize_t ndev_ntb4_debugfs_read(struct file *filp, char __user *ubuf,
- size_t count, loff_t *offp);

extern const struct ntb_dev_ops intel_ntb4_ops;

diff --git a/drivers/ntb/ntb_transport.c b/drivers/ntb/ntb_transport.c
index f9e7847a378e..bc69e3d81350 100644
--- a/drivers/ntb/ntb_transport.c
+++ b/drivers/ntb/ntb_transport.c
@@ -460,14 +460,13 @@ void ntb_transport_unregister_client(struct ntb_transport_client *drv)
}
EXPORT_SYMBOL_GPL(ntb_transport_unregister_client);

-static ssize_t debugfs_read(struct file *filp, char __user *ubuf, size_t count,
- loff_t *offp)
+static ssize_t debugfs_read(struct kiocb *iocb, struct iov_iter *to)
{
struct ntb_transport_qp *qp;
char *buf;
ssize_t ret, out_offset, out_count;

- qp = filp->private_data;
+ qp = iocb->ki_filp->private_data;

if (!qp || !qp->link_is_up)
return 0;
@@ -548,7 +547,7 @@ static ssize_t debugfs_read(struct file *filp, char __user *ubuf, size_t count,
if (out_offset > out_count)
out_offset = out_count;

- ret = simple_read_from_buffer(ubuf, count, offp, buf, out_offset);
+ ret = simple_copy_to_iter(buf, &iocb->ki_pos, out_offset, to);
kfree(buf);
return ret;
}
@@ -556,7 +555,7 @@ static ssize_t debugfs_read(struct file *filp, char __user *ubuf, size_t count,
static const struct file_operations ntb_qp_debugfs_stats = {
.owner = THIS_MODULE,
.open = simple_open,
- .read = debugfs_read,
+ .read_iter = debugfs_read,
};

static void ntb_list_add(spinlock_t *lock, struct list_head *entry,
diff --git a/drivers/ntb/test/ntb_perf.c b/drivers/ntb/test/ntb_perf.c
index 553f1f46bc66..d3f9d2f5015d 100644
--- a/drivers/ntb/test/ntb_perf.c
+++ b/drivers/ntb/test/ntb_perf.c
@@ -1179,10 +1179,10 @@ static void perf_clear_threads(struct perf_ctx *perf)
*==============================================================================
*/

-static ssize_t perf_dbgfs_read_info(struct file *filep, char __user *ubuf,
- size_t size, loff_t *offp)
+static ssize_t perf_dbgfs_read_info(struct kiocb *iocb, struct iov_iter *to)
{
- struct perf_ctx *perf = filep->private_data;
+ struct perf_ctx *perf = iocb->ki_filp->private_data;
+ size_t size = iov_iter_count(to);
struct perf_peer *peer;
size_t buf_size;
ssize_t pos = 0;
@@ -1251,7 +1251,7 @@ static ssize_t perf_dbgfs_read_info(struct file *filep, char __user *ubuf,
"\tIn buffer xlat %pad[p]\n", &peer->inbuf_xlat);
}

- ret = simple_read_from_buffer(ubuf, size, offp, buf, pos);
+ ret = simple_copy_to_iter(buf, &iocb->ki_pos, pos, to);
kfree(buf);

return ret;
@@ -1259,13 +1259,12 @@ static ssize_t perf_dbgfs_read_info(struct file *filep, char __user *ubuf,

static const struct file_operations perf_dbgfs_info = {
.open = simple_open,
- .read = perf_dbgfs_read_info
+ .read_iter = perf_dbgfs_read_info
};

-static ssize_t perf_dbgfs_read_run(struct file *filep, char __user *ubuf,
- size_t size, loff_t *offp)
+static ssize_t perf_dbgfs_read_run(struct kiocb *iocb, struct iov_iter *to)
{
- struct perf_ctx *perf = filep->private_data;
+ struct perf_ctx *perf = iocb->ki_filp->private_data;
ssize_t ret, pos = 0;
char *buf;

@@ -1277,21 +1276,21 @@ static ssize_t perf_dbgfs_read_run(struct file *filep, char __user *ubuf,
if (ret)
goto err_free;

- ret = simple_read_from_buffer(ubuf, size, offp, buf, pos);
+ ret = simple_copy_to_iter(buf, &iocb->ki_pos, pos, to);
err_free:
kfree(buf);

return ret;
}

-static ssize_t perf_dbgfs_write_run(struct file *filep, const char __user *ubuf,
- size_t size, loff_t *offp)
+static ssize_t perf_dbgfs_write_run(struct kiocb *iocb, struct iov_iter *from)
{
- struct perf_ctx *perf = filep->private_data;
+ struct perf_ctx *perf = iocb->ki_filp->private_data;
+ size_t size = iov_iter_count(from);
struct perf_peer *peer;
int pidx, ret;

- ret = kstrtoint_from_user(ubuf, size, 0, &pidx);
+ ret = kstrtoint_from_iter(from, size, 0, &pidx);
if (ret)
return ret;

@@ -1309,31 +1308,29 @@ static ssize_t perf_dbgfs_write_run(struct file *filep, const char __user *ubuf,

static const struct file_operations perf_dbgfs_run = {
.open = simple_open,
- .read = perf_dbgfs_read_run,
- .write = perf_dbgfs_write_run
+ .read_iter = perf_dbgfs_read_run,
+ .write_iter = perf_dbgfs_write_run,
};

-static ssize_t perf_dbgfs_read_tcnt(struct file *filep, char __user *ubuf,
- size_t size, loff_t *offp)
+static ssize_t perf_dbgfs_read_tcnt(struct kiocb *iocb, struct iov_iter *to)
{
- struct perf_ctx *perf = filep->private_data;
+ struct perf_ctx *perf = iocb->ki_filp->private_data;
char buf[8];
ssize_t pos;

pos = scnprintf(buf, sizeof(buf), "%hhu\n", perf->tcnt);

- return simple_read_from_buffer(ubuf, size, offp, buf, pos);
+ return simple_copy_to_iter(buf, &iocb->ki_pos, pos, to);
}

-static ssize_t perf_dbgfs_write_tcnt(struct file *filep,
- const char __user *ubuf,
- size_t size, loff_t *offp)
+static ssize_t perf_dbgfs_write_tcnt(struct kiocb *iocb, struct iov_iter *from)
{
- struct perf_ctx *perf = filep->private_data;
+ struct perf_ctx *perf = iocb->ki_filp->private_data;
+ size_t size = iov_iter_count(from);
int ret;
u8 val;

- ret = kstrtou8_from_user(ubuf, size, 0, &val);
+ ret = kstrtou8_from_iter(from, size, 0, &val);
if (ret)
return ret;

@@ -1346,8 +1343,8 @@ static ssize_t perf_dbgfs_write_tcnt(struct file *filep,

static const struct file_operations perf_dbgfs_tcnt = {
.open = simple_open,
- .read = perf_dbgfs_read_tcnt,
- .write = perf_dbgfs_write_tcnt
+ .read_iter = perf_dbgfs_read_tcnt,
+ .write_iter = perf_dbgfs_write_tcnt,
};

static void perf_setup_dbgfs(struct perf_ctx *perf)
diff --git a/drivers/ntb/test/ntb_tool.c b/drivers/ntb/test/ntb_tool.c
index 641cb7e05a47..e3988468c92f 100644
--- a/drivers/ntb/test/ntb_tool.c
+++ b/drivers/ntb/test/ntb_tool.c
@@ -273,8 +273,8 @@ struct tool_ctx {
const struct file_operations __name = { \
.owner = THIS_MODULE, \
.open = simple_open, \
- .read = __read, \
- .write = __write, \
+ .read_iter = __read, \
+ .write_iter = __write, \
}

#define TOOL_BUF_LEN 32
@@ -338,8 +338,8 @@ static const struct ntb_ctx_ops tool_ops = {
*==============================================================================
*/

-static ssize_t tool_fn_read(struct tool_ctx *tc, char __user *ubuf,
- size_t size, loff_t *offp,
+static ssize_t tool_fn_read(struct tool_ctx *tc, struct kiocb *iocb,
+ struct iov_iter *to,
u64 (*fn_read)(struct ntb_dev *))
{
size_t buf_size;
@@ -349,28 +349,28 @@ static ssize_t tool_fn_read(struct tool_ctx *tc, char __user *ubuf,
if (!fn_read)
return -EINVAL;

- buf_size = min(size, sizeof(buf));
+ buf_size = min(iov_iter_count(to), sizeof(buf));

pos = scnprintf(buf, buf_size, "%#llx\n", fn_read(tc->ntb));

- return simple_read_from_buffer(ubuf, size, offp, buf, pos);
+ return simple_copy_to_iter(buf, &iocb->ki_pos, pos, to);
}

-static ssize_t tool_fn_write(struct tool_ctx *tc,
- const char __user *ubuf,
- size_t size, loff_t *offp,
+static ssize_t tool_fn_write(struct tool_ctx *tc, struct kiocb *iocb,
+ struct iov_iter *from,
int (*fn_set)(struct ntb_dev *, u64),
int (*fn_clear)(struct ntb_dev *, u64))
{
+ size_t size = iov_iter_count(from);
char *buf, cmd;
ssize_t ret;
u64 bits;
int n;

- if (*offp)
+ if (iocb->ki_pos)
return 0;

- buf = memdup_user_nul(ubuf, size);
+ buf = iterdup_nul(from, size);
if (IS_ERR(buf))
return PTR_ERR(buf);

@@ -402,26 +402,24 @@ static ssize_t tool_fn_write(struct tool_ctx *tc,
*==============================================================================
*/

-static ssize_t tool_port_read(struct file *filep, char __user *ubuf,
- size_t size, loff_t *offp)
+static ssize_t tool_port_read(struct kiocb *iocb, struct iov_iter *to)
{
- struct tool_ctx *tc = filep->private_data;
+ struct tool_ctx *tc = iocb->ki_filp->private_data;
char buf[TOOL_BUF_LEN];
int pos;

pos = scnprintf(buf, sizeof(buf), "%d\n", ntb_port_number(tc->ntb));

- return simple_read_from_buffer(ubuf, size, offp, buf, pos);
+ return simple_copy_to_iter(buf, &iocb->ki_pos, pos, to);
}

static TOOL_FOPS_RDWR(tool_port_fops,
tool_port_read,
NULL);

-static ssize_t tool_peer_port_read(struct file *filep, char __user *ubuf,
- size_t size, loff_t *offp)
+static ssize_t tool_peer_port_read(struct kiocb *iocb, struct iov_iter *to)
{
- struct tool_peer *peer = filep->private_data;
+ struct tool_peer *peer = iocb->ki_filp->private_data;
struct tool_ctx *tc = peer->tc;
char buf[TOOL_BUF_LEN];
int pos;
@@ -429,7 +427,7 @@ static ssize_t tool_peer_port_read(struct file *filep, char __user *ubuf,
pos = scnprintf(buf, sizeof(buf), "%d\n",
ntb_peer_port_number(tc->ntb, peer->pidx));

- return simple_read_from_buffer(ubuf, size, offp, buf, pos);
+ return simple_copy_to_iter(buf, &iocb->ki_pos, pos, to);
}

static TOOL_FOPS_RDWR(tool_peer_port_fops,
@@ -459,14 +457,14 @@ static int tool_init_peers(struct tool_ctx *tc)
*==============================================================================
*/

-static ssize_t tool_link_write(struct file *filep, const char __user *ubuf,
- size_t size, loff_t *offp)
+static ssize_t tool_link_write(struct kiocb *iocb, struct iov_iter *from)
{
- struct tool_ctx *tc = filep->private_data;
+ struct tool_ctx *tc = iocb->ki_filp->private_data;
+ size_t size = iov_iter_count(from);
bool val;
int ret;

- ret = kstrtobool_from_user(ubuf, size, &val);
+ ret = kstrtobool_from_iter(from, size, &val);
if (ret)
return ret;

@@ -485,10 +483,9 @@ static TOOL_FOPS_RDWR(tool_link_fops,
NULL,
tool_link_write);

-static ssize_t tool_peer_link_read(struct file *filep, char __user *ubuf,
- size_t size, loff_t *offp)
+static ssize_t tool_peer_link_read(struct kiocb *iocb, struct iov_iter *to)
{
- struct tool_peer *peer = filep->private_data;
+ struct tool_peer *peer = iocb->ki_filp->private_data;
struct tool_ctx *tc = peer->tc;
char buf[3];

@@ -499,24 +496,24 @@ static ssize_t tool_peer_link_read(struct file *filep, char __user *ubuf,
buf[1] = '\n';
buf[2] = '\0';

- return simple_read_from_buffer(ubuf, size, offp, buf, 2);
+ return simple_copy_to_iter(buf, &iocb->ki_pos, 2, to);
}

static TOOL_FOPS_RDWR(tool_peer_link_fops,
tool_peer_link_read,
NULL);

-static ssize_t tool_peer_link_event_write(struct file *filep,
- const char __user *ubuf,
- size_t size, loff_t *offp)
+static ssize_t tool_peer_link_event_write(struct kiocb *iocb,
+ struct iov_iter *from)
{
- struct tool_peer *peer = filep->private_data;
+ struct tool_peer *peer = iocb->ki_filp->private_data;
+ size_t size = iov_iter_count(from);
struct tool_ctx *tc = peer->tc;
u64 link_msk;
bool val;
int ret;

- ret = kstrtobool_from_user(ubuf, size, &val);
+ ret = kstrtobool_from_iter(from, size, &val);
if (ret)
return ret;

@@ -538,28 +535,25 @@ static TOOL_FOPS_RDWR(tool_peer_link_event_fops,
*==============================================================================
*/

-static ssize_t tool_mw_read(struct file *filep, char __user *ubuf,
- size_t size, loff_t *offp)
+static ssize_t tool_mw_read(struct kiocb *iocb, struct iov_iter *to)
{
- struct tool_mw *inmw = filep->private_data;
+ struct tool_mw *inmw = iocb->ki_filp->private_data;

if (inmw->mm_base == NULL)
return -ENXIO;

- return simple_read_from_buffer(ubuf, size, offp,
- inmw->mm_base, inmw->size);
+ return simple_copy_to_iter(inmw->mm_base, &iocb->ki_pos, inmw->size, to);
}

-static ssize_t tool_mw_write(struct file *filep, const char __user *ubuf,
- size_t size, loff_t *offp)
+static ssize_t tool_mw_write(struct kiocb *iocb, struct iov_iter *from)
{
- struct tool_mw *inmw = filep->private_data;
+ struct tool_mw *inmw = iocb->ki_filp->private_data;

if (inmw->mm_base == NULL)
return -ENXIO;

- return simple_write_to_buffer(inmw->mm_base, inmw->size, offp,
- ubuf, size);
+ return simple_copy_from_iter(inmw->mm_base, &iocb->ki_pos, inmw->size,
+ from);
}

static TOOL_FOPS_RDWR(tool_mw_fops,
@@ -634,10 +628,10 @@ static void tool_free_mw(struct tool_ctx *tc, int pidx, int widx)
inmw->dbgfs_file = NULL;
}

-static ssize_t tool_mw_trans_read(struct file *filep, char __user *ubuf,
- size_t size, loff_t *offp)
+static ssize_t tool_mw_trans_read(struct kiocb *iocb, struct iov_iter *to)
{
- struct tool_mw *inmw = filep->private_data;
+ struct tool_mw *inmw = iocb->ki_filp->private_data;
+ size_t size = iov_iter_count(to);
resource_size_t addr_align;
resource_size_t size_align;
resource_size_t size_max;
@@ -688,7 +682,7 @@ static ssize_t tool_mw_trans_read(struct file *filep, char __user *ubuf,
"Size Max \t%pap\n",
&size_max);

- ret = simple_read_from_buffer(ubuf, size, offp, buf, off);
+ ret = simple_copy_to_iter(buf, &iocb->ki_pos, off, to);

err:
kfree(buf);
@@ -696,14 +690,14 @@ static ssize_t tool_mw_trans_read(struct file *filep, char __user *ubuf,
return ret;
}

-static ssize_t tool_mw_trans_write(struct file *filep, const char __user *ubuf,
- size_t size, loff_t *offp)
+static ssize_t tool_mw_trans_write(struct kiocb *iocb, struct iov_iter *from)
{
- struct tool_mw *inmw = filep->private_data;
+ struct tool_mw *inmw = iocb->ki_filp->private_data;
+ size_t size = iov_iter_count(from);
unsigned int val;
int ret;

- ret = kstrtouint_from_user(ubuf, size, 0, &val);
+ ret = kstrtouint_from_iter(from, size, 0, &val);
if (ret)
return ret;

@@ -721,11 +715,11 @@ static TOOL_FOPS_RDWR(tool_mw_trans_fops,
tool_mw_trans_read,
tool_mw_trans_write);

-static ssize_t tool_peer_mw_read(struct file *filep, char __user *ubuf,
- size_t size, loff_t *offp)
+static ssize_t tool_peer_mw_read(struct kiocb *iocb, struct iov_iter *to)
{
- struct tool_mw *outmw = filep->private_data;
- loff_t pos = *offp;
+ struct tool_mw *outmw = iocb->ki_filp->private_data;
+ size_t size = iov_iter_count(to);
+ loff_t pos = iocb->ki_pos;
ssize_t ret;
void *buf;

@@ -743,14 +737,14 @@ static ssize_t tool_peer_mw_read(struct file *filep, char __user *ubuf,
return -ENOMEM;

memcpy_fromio(buf, outmw->io_base + pos, size);
- ret = copy_to_user(ubuf, buf, size);
- if (ret == size) {
+ ret = copy_to_iter(buf, size, to);
+ if (!ret) {
ret = -EFAULT;
goto err_free;
}

size -= ret;
- *offp = pos + size;
+ iocb->ki_pos = pos + size;
ret = size;

err_free:
@@ -759,12 +753,12 @@ static ssize_t tool_peer_mw_read(struct file *filep, char __user *ubuf,
return ret;
}

-static ssize_t tool_peer_mw_write(struct file *filep, const char __user *ubuf,
- size_t size, loff_t *offp)
+static ssize_t tool_peer_mw_write(struct kiocb *iocb, struct iov_iter *from)
{
- struct tool_mw *outmw = filep->private_data;
+ struct tool_mw *outmw = iocb->ki_filp->private_data;
+ size_t size = iov_iter_count(from);
ssize_t ret;
- loff_t pos = *offp;
+ loff_t pos = iocb->ki_pos;
void *buf;

if (outmw->io_base == NULL)
@@ -779,14 +773,14 @@ static ssize_t tool_peer_mw_write(struct file *filep, const char __user *ubuf,
if (!buf)
return -ENOMEM;

- ret = copy_from_user(buf, ubuf, size);
- if (ret == size) {
+ ret = copy_from_iter(buf, size, from);
+ if (!ret) {
ret = -EFAULT;
goto err_free;
}

size -= ret;
- *offp = pos + size;
+ iocb->ki_pos = pos + size;
ret = size;

memcpy_toio(outmw->io_base + pos, buf, size);
@@ -862,11 +856,11 @@ static void tool_free_peer_mw(struct tool_ctx *tc, int widx)
outmw->dbgfs_file = NULL;
}

-static ssize_t tool_peer_mw_trans_read(struct file *filep, char __user *ubuf,
- size_t size, loff_t *offp)
+static ssize_t tool_peer_mw_trans_read(struct kiocb *iocb, struct iov_iter *to)
{
- struct tool_mw_wrap *outmw_wrap = filep->private_data;
+ struct tool_mw_wrap *outmw_wrap = iocb->ki_filp->private_data;
struct tool_mw *outmw = outmw_wrap->mw;
+ size_t size = iov_iter_count(to);
resource_size_t map_size;
phys_addr_t map_base;
ssize_t off = 0;
@@ -913,25 +907,25 @@ static ssize_t tool_peer_mw_trans_read(struct file *filep, char __user *ubuf,
off += scnprintf(buf + off, buf_size - off,
"Window Size \t%pap\n", &outmw->size);

- ret = simple_read_from_buffer(ubuf, size, offp, buf, off);
+ ret = simple_copy_to_iter(buf, &iocb->ki_pos, off, to);
kfree(buf);

return ret;
}

-static ssize_t tool_peer_mw_trans_write(struct file *filep,
- const char __user *ubuf,
- size_t size, loff_t *offp)
+static ssize_t tool_peer_mw_trans_write(struct kiocb *iocb,
+ struct iov_iter *from)
{
- struct tool_mw_wrap *outmw_wrap = filep->private_data;
+ struct tool_mw_wrap *outmw_wrap = iocb->ki_filp->private_data;
struct tool_mw *outmw = outmw_wrap->mw;
+ size_t size = iov_iter_count(from);
size_t buf_size, wsize;
char buf[TOOL_BUF_LEN];
int ret, n;
u64 addr;

buf_size = min(size, (sizeof(buf) - 1));
- if (copy_from_user(buf, ubuf, buf_size))
+ if (!copy_from_iter_full(buf, buf_size, from))
return -EFAULT;

buf[buf_size] = '\0';
@@ -1022,20 +1016,18 @@ static void tool_clear_mws(struct tool_ctx *tc)
*==============================================================================
*/

-static ssize_t tool_db_read(struct file *filep, char __user *ubuf,
- size_t size, loff_t *offp)
+static ssize_t tool_db_read(struct kiocb *iocb, struct iov_iter *to)
{
- struct tool_ctx *tc = filep->private_data;
+ struct tool_ctx *tc = iocb->ki_filp->private_data;

- return tool_fn_read(tc, ubuf, size, offp, tc->ntb->ops->db_read);
+ return tool_fn_read(tc, iocb, to, tc->ntb->ops->db_read);
}

-static ssize_t tool_db_write(struct file *filep, const char __user *ubuf,
- size_t size, loff_t *offp)
+static ssize_t tool_db_write(struct kiocb *iocb, struct iov_iter *from)
{
- struct tool_ctx *tc = filep->private_data;
+ struct tool_ctx *tc = iocb->ki_filp->private_data;

- return tool_fn_write(tc, ubuf, size, offp, tc->ntb->ops->db_set,
+ return tool_fn_write(tc, iocb, from, tc->ntb->ops->db_set,
tc->ntb->ops->db_clear);
}

@@ -1043,32 +1035,29 @@ static TOOL_FOPS_RDWR(tool_db_fops,
tool_db_read,
tool_db_write);

-static ssize_t tool_db_valid_mask_read(struct file *filep, char __user *ubuf,
- size_t size, loff_t *offp)
+static ssize_t tool_db_valid_mask_read(struct kiocb *iocb, struct iov_iter *to)
{
- struct tool_ctx *tc = filep->private_data;
+ struct tool_ctx *tc = iocb->ki_filp->private_data;

- return tool_fn_read(tc, ubuf, size, offp, tc->ntb->ops->db_valid_mask);
+ return tool_fn_read(tc, iocb, to, tc->ntb->ops->db_valid_mask);
}

static TOOL_FOPS_RDWR(tool_db_valid_mask_fops,
tool_db_valid_mask_read,
NULL);

-static ssize_t tool_db_mask_read(struct file *filep, char __user *ubuf,
- size_t size, loff_t *offp)
+static ssize_t tool_db_mask_read(struct kiocb *iocb, struct iov_iter *to)
{
- struct tool_ctx *tc = filep->private_data;
+ struct tool_ctx *tc = iocb->ki_filp->private_data;

- return tool_fn_read(tc, ubuf, size, offp, tc->ntb->ops->db_read_mask);
+ return tool_fn_read(tc, iocb, to, tc->ntb->ops->db_read_mask);
}

-static ssize_t tool_db_mask_write(struct file *filep, const char __user *ubuf,
- size_t size, loff_t *offp)
+static ssize_t tool_db_mask_write(struct kiocb *iocb, struct iov_iter *from)
{
- struct tool_ctx *tc = filep->private_data;
+ struct tool_ctx *tc = iocb->ki_filp->private_data;

- return tool_fn_write(tc, ubuf, size, offp, tc->ntb->ops->db_set_mask,
+ return tool_fn_write(tc, iocb, from, tc->ntb->ops->db_set_mask,
tc->ntb->ops->db_clear_mask);
}

@@ -1076,20 +1065,18 @@ static TOOL_FOPS_RDWR(tool_db_mask_fops,
tool_db_mask_read,
tool_db_mask_write);

-static ssize_t tool_peer_db_read(struct file *filep, char __user *ubuf,
- size_t size, loff_t *offp)
+static ssize_t tool_peer_db_read(struct kiocb *iocb, struct iov_iter *to)
{
- struct tool_ctx *tc = filep->private_data;
+ struct tool_ctx *tc = iocb->ki_filp->private_data;

- return tool_fn_read(tc, ubuf, size, offp, tc->ntb->ops->peer_db_read);
+ return tool_fn_read(tc, iocb, to, tc->ntb->ops->peer_db_read);
}

-static ssize_t tool_peer_db_write(struct file *filep, const char __user *ubuf,
- size_t size, loff_t *offp)
+static ssize_t tool_peer_db_write(struct kiocb *iocb, struct iov_iter *from)
{
- struct tool_ctx *tc = filep->private_data;
+ struct tool_ctx *tc = iocb->ki_filp->private_data;

- return tool_fn_write(tc, ubuf, size, offp, tc->ntb->ops->peer_db_set,
+ return tool_fn_write(tc, iocb, from, tc->ntb->ops->peer_db_set,
tc->ntb->ops->peer_db_clear);
}

@@ -1097,23 +1084,18 @@ static TOOL_FOPS_RDWR(tool_peer_db_fops,
tool_peer_db_read,
tool_peer_db_write);

-static ssize_t tool_peer_db_mask_read(struct file *filep, char __user *ubuf,
- size_t size, loff_t *offp)
+static ssize_t tool_peer_db_mask_read(struct kiocb *iocb, struct iov_iter *to)
{
- struct tool_ctx *tc = filep->private_data;
+ struct tool_ctx *tc = iocb->ki_filp->private_data;

- return tool_fn_read(tc, ubuf, size, offp,
- tc->ntb->ops->peer_db_read_mask);
+ return tool_fn_read(tc, iocb, to, tc->ntb->ops->peer_db_read_mask);
}

-static ssize_t tool_peer_db_mask_write(struct file *filep,
- const char __user *ubuf,
- size_t size, loff_t *offp)
+static ssize_t tool_peer_db_mask_write(struct kiocb *iocb, struct iov_iter *from)
{
- struct tool_ctx *tc = filep->private_data;
+ struct tool_ctx *tc = iocb->ki_filp->private_data;

- return tool_fn_write(tc, ubuf, size, offp,
- tc->ntb->ops->peer_db_set_mask,
+ return tool_fn_write(tc, iocb, from, tc->ntb->ops->peer_db_set_mask,
tc->ntb->ops->peer_db_clear_mask);
}

@@ -1121,15 +1103,14 @@ static TOOL_FOPS_RDWR(tool_peer_db_mask_fops,
tool_peer_db_mask_read,
tool_peer_db_mask_write);

-static ssize_t tool_db_event_write(struct file *filep,
- const char __user *ubuf,
- size_t size, loff_t *offp)
+static ssize_t tool_db_event_write(struct kiocb *iocb, struct iov_iter *from)
{
- struct tool_ctx *tc = filep->private_data;
+ struct tool_ctx *tc = iocb->ki_filp->private_data;
+ size_t size = iov_iter_count(from);
u64 val;
int ret;

- ret = kstrtou64_from_user(ubuf, size, 0, &val);
+ ret = kstrtou64_from_iter(from, size, 0, &val);
if (ret)
return ret;

@@ -1148,10 +1129,9 @@ static TOOL_FOPS_RDWR(tool_db_event_fops,
*==============================================================================
*/

-static ssize_t tool_spad_read(struct file *filep, char __user *ubuf,
- size_t size, loff_t *offp)
+static ssize_t tool_spad_read(struct kiocb *iocb, struct iov_iter *to)
{
- struct tool_spad *spad = filep->private_data;
+ struct tool_spad *spad = iocb->ki_filp->private_data;
char buf[TOOL_BUF_LEN];
ssize_t pos;

@@ -1161,13 +1141,13 @@ static ssize_t tool_spad_read(struct file *filep, char __user *ubuf,
pos = scnprintf(buf, sizeof(buf), "%#x\n",
ntb_spad_read(spad->tc->ntb, spad->sidx));

- return simple_read_from_buffer(ubuf, size, offp, buf, pos);
+ return simple_copy_to_iter(buf, &iocb->ki_pos, pos, to);
}

-static ssize_t tool_spad_write(struct file *filep, const char __user *ubuf,
- size_t size, loff_t *offp)
+static ssize_t tool_spad_write(struct kiocb *iocb, struct iov_iter *from)
{
- struct tool_spad *spad = filep->private_data;
+ struct tool_spad *spad = iocb->ki_filp->private_data;
+ size_t size = iov_iter_count(from);
u32 val;
int ret;

@@ -1176,7 +1156,7 @@ static ssize_t tool_spad_write(struct file *filep, const char __user *ubuf,
return -EINVAL;
}

- ret = kstrtou32_from_user(ubuf, size, 0, &val);
+ ret = kstrtou32_from_iter(from, size, 0, &val);
if (ret)
return ret;

@@ -1189,10 +1169,9 @@ static TOOL_FOPS_RDWR(tool_spad_fops,
tool_spad_read,
tool_spad_write);

-static ssize_t tool_peer_spad_read(struct file *filep, char __user *ubuf,
- size_t size, loff_t *offp)
+static ssize_t tool_peer_spad_read(struct kiocb *iocb, struct iov_iter *to)
{
- struct tool_spad *spad = filep->private_data;
+ struct tool_spad *spad = iocb->ki_filp->private_data;
char buf[TOOL_BUF_LEN];
ssize_t pos;

@@ -1202,13 +1181,13 @@ static ssize_t tool_peer_spad_read(struct file *filep, char __user *ubuf,
pos = scnprintf(buf, sizeof(buf), "%#x\n",
ntb_peer_spad_read(spad->tc->ntb, spad->pidx, spad->sidx));

- return simple_read_from_buffer(ubuf, size, offp, buf, pos);
+ return simple_copy_to_iter(buf, &iocb->ki_pos, pos, to);
}

-static ssize_t tool_peer_spad_write(struct file *filep, const char __user *ubuf,
- size_t size, loff_t *offp)
+static ssize_t tool_peer_spad_write(struct kiocb *iocb, struct iov_iter *from)
{
- struct tool_spad *spad = filep->private_data;
+ struct tool_spad *spad = iocb->ki_filp->private_data;
+ size_t size = iov_iter_count(from);
u32 val;
int ret;

@@ -1217,7 +1196,7 @@ static ssize_t tool_peer_spad_write(struct file *filep, const char __user *ubuf,
return -EINVAL;
}

- ret = kstrtou32_from_user(ubuf, size, 0, &val);
+ ret = kstrtou32_from_iter(from, size, 0, &val);
if (ret)
return ret;

@@ -1271,10 +1250,9 @@ static int tool_init_spads(struct tool_ctx *tc)
*==============================================================================
*/

-static ssize_t tool_inmsg_read(struct file *filep, char __user *ubuf,
- size_t size, loff_t *offp)
+static ssize_t tool_inmsg_read(struct kiocb *iocb, struct iov_iter *to)
{
- struct tool_msg *msg = filep->private_data;
+ struct tool_msg *msg = iocb->ki_filp->private_data;
char buf[TOOL_BUF_LEN];
ssize_t pos;
u32 data;
@@ -1284,22 +1262,21 @@ static ssize_t tool_inmsg_read(struct file *filep, char __user *ubuf,

pos = scnprintf(buf, sizeof(buf), "0x%08x<-%d\n", data, pidx);

- return simple_read_from_buffer(ubuf, size, offp, buf, pos);
+ return simple_copy_to_iter(buf, &iocb->ki_pos, pos, to);
}

static TOOL_FOPS_RDWR(tool_inmsg_fops,
tool_inmsg_read,
NULL);

-static ssize_t tool_outmsg_write(struct file *filep,
- const char __user *ubuf,
- size_t size, loff_t *offp)
+static ssize_t tool_outmsg_write(struct kiocb *iocb, struct iov_iter *from)
{
- struct tool_msg *msg = filep->private_data;
+ struct tool_msg *msg = iocb->ki_filp->private_data;
+ size_t size = iov_iter_count(from);
u32 val;
int ret;

- ret = kstrtou32_from_user(ubuf, size, 0, &val);
+ ret = kstrtou32_from_iter(from, size, 0, &val);
if (ret)
return ret;

@@ -1312,58 +1289,51 @@ static TOOL_FOPS_RDWR(tool_outmsg_fops,
NULL,
tool_outmsg_write);

-static ssize_t tool_msg_sts_read(struct file *filep, char __user *ubuf,
- size_t size, loff_t *offp)
+static ssize_t tool_msg_sts_read(struct kiocb *iocb, struct iov_iter *to)
{
- struct tool_ctx *tc = filep->private_data;
+ struct tool_ctx *tc = iocb->ki_filp->private_data;

- return tool_fn_read(tc, ubuf, size, offp, tc->ntb->ops->msg_read_sts);
+ return tool_fn_read(tc, iocb, to, tc->ntb->ops->msg_read_sts);
}

-static ssize_t tool_msg_sts_write(struct file *filep, const char __user *ubuf,
- size_t size, loff_t *offp)
+static ssize_t tool_msg_sts_write(struct kiocb *iocb, struct iov_iter *from)
{
- struct tool_ctx *tc = filep->private_data;
+ struct tool_ctx *tc = iocb->ki_filp->private_data;

- return tool_fn_write(tc, ubuf, size, offp, NULL,
- tc->ntb->ops->msg_clear_sts);
+ return tool_fn_write(tc, iocb, from, NULL, tc->ntb->ops->msg_clear_sts);
}

static TOOL_FOPS_RDWR(tool_msg_sts_fops,
tool_msg_sts_read,
tool_msg_sts_write);

-static ssize_t tool_msg_inbits_read(struct file *filep, char __user *ubuf,
- size_t size, loff_t *offp)
+static ssize_t tool_msg_inbits_read(struct kiocb *iocb, struct iov_iter *to)
{
- struct tool_ctx *tc = filep->private_data;
+ struct tool_ctx *tc = iocb->ki_filp->private_data;

- return tool_fn_read(tc, ubuf, size, offp, tc->ntb->ops->msg_inbits);
+ return tool_fn_read(tc, iocb, to, tc->ntb->ops->msg_inbits);
}

static TOOL_FOPS_RDWR(tool_msg_inbits_fops,
tool_msg_inbits_read,
NULL);

-static ssize_t tool_msg_outbits_read(struct file *filep, char __user *ubuf,
- size_t size, loff_t *offp)
+static ssize_t tool_msg_outbits_read(struct kiocb *iocb, struct iov_iter *to)
{
- struct tool_ctx *tc = filep->private_data;
+ struct tool_ctx *tc = iocb->ki_filp->private_data;

- return tool_fn_read(tc, ubuf, size, offp, tc->ntb->ops->msg_outbits);
+ return tool_fn_read(tc, iocb, to, tc->ntb->ops->msg_outbits);
}

static TOOL_FOPS_RDWR(tool_msg_outbits_fops,
tool_msg_outbits_read,
NULL);

-static ssize_t tool_msg_mask_write(struct file *filep, const char __user *ubuf,
- size_t size, loff_t *offp)
+static ssize_t tool_msg_mask_write(struct kiocb *iocb, struct iov_iter *from)
{
- struct tool_ctx *tc = filep->private_data;
+ struct tool_ctx *tc = iocb->ki_filp->private_data;

- return tool_fn_write(tc, ubuf, size, offp,
- tc->ntb->ops->msg_set_mask,
+ return tool_fn_write(tc, iocb, from, tc->ntb->ops->msg_set_mask,
tc->ntb->ops->msg_clear_mask);
}

@@ -1371,15 +1341,14 @@ static TOOL_FOPS_RDWR(tool_msg_mask_fops,
NULL,
tool_msg_mask_write);

-static ssize_t tool_msg_event_write(struct file *filep,
- const char __user *ubuf,
- size_t size, loff_t *offp)
+static ssize_t tool_msg_event_write(struct kiocb *iocb, struct iov_iter *from)
{
- struct tool_ctx *tc = filep->private_data;
+ struct tool_ctx *tc = iocb->ki_filp->private_data;
+ size_t size = iov_iter_count(from);
u64 val;
int ret;

- ret = kstrtou64_from_user(ubuf, size, 0, &val);
+ ret = kstrtou64_from_iter(from, size, 0, &val);
if (ret)
return ret;

--
2.43.0