Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
io_uring/timeout: migrate reqs from ts64 to ktime
It'll be more convenient for next patches to keep ktime in requests
instead of timespec64. Convert everything to ktime right after user
argument parsing at request prep time.
Signed-off-by: Pavel Begunkov <asml.silence@gmail.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
authored by
Pavel Begunkov
and committed by
Jens Axboe
0e78aa18
6e3f5943
+16
-17
+15
-16
io_uring/timeout.c
+15
-16
io_uring/timeout.c
···
30
30
u64 addr;
31
31
32
32
/* timeout update */
33
-
struct timespec64 ts;
33
+
ktime_t time;
34
34
u32 flags;
35
35
bool ltimeout;
36
36
};
37
37
38
-
static int io_parse_user_time(struct timespec64 *ts_out, u64 arg)
38
+
static int io_parse_user_time(ktime_t *time, u64 arg)
39
39
{
40
40
struct timespec64 ts;
41
41
···
43
43
return -EFAULT;
44
44
if (ts.tv_sec < 0 || ts.tv_nsec < 0)
45
45
return -EINVAL;
46
-
*ts_out = ts;
46
+
*time = timespec64_to_ktime(ts);
47
47
return 0;
48
48
}
49
49
···
92
92
/* re-arm timer */
93
93
raw_spin_lock_irq(&ctx->timeout_lock);
94
94
list_add(&timeout->list, ctx->timeout_list.prev);
95
-
hrtimer_start(&data->timer, timespec64_to_ktime(data->ts), data->mode);
95
+
hrtimer_start(&data->timer, data->time, data->mode);
96
96
raw_spin_unlock_irq(&ctx->timeout_lock);
97
97
return;
98
98
}
···
407
407
}
408
408
409
409
static int io_linked_timeout_update(struct io_ring_ctx *ctx, __u64 user_data,
410
-
struct timespec64 *ts, enum hrtimer_mode mode)
410
+
ktime_t ts, enum hrtimer_mode mode)
411
411
__must_hold(&ctx->timeout_lock)
412
412
{
413
413
struct io_timeout_data *io;
···
429
429
if (hrtimer_try_to_cancel(&io->timer) == -1)
430
430
return -EALREADY;
431
431
hrtimer_setup(&io->timer, io_link_timeout_fn, io_timeout_get_clock(io), mode);
432
-
hrtimer_start(&io->timer, timespec64_to_ktime(*ts), mode);
432
+
hrtimer_start(&io->timer, ts, mode);
433
433
return 0;
434
434
}
435
435
436
436
static int io_timeout_update(struct io_ring_ctx *ctx, __u64 user_data,
437
-
struct timespec64 *ts, enum hrtimer_mode mode)
437
+
ktime_t time, enum hrtimer_mode mode)
438
438
__must_hold(&ctx->timeout_lock)
439
439
{
440
440
struct io_cancel_data cd = { .ctx = ctx, .data = user_data, };
···
447
447
448
448
timeout->off = 0; /* noseq */
449
449
data = req->async_data;
450
-
data->ts = *ts;
450
+
data->time = time;
451
451
452
452
list_add_tail(&timeout->list, &ctx->timeout_list);
453
453
hrtimer_setup(&data->timer, io_timeout_fn, io_timeout_get_clock(data), mode);
454
-
hrtimer_start(&data->timer, timespec64_to_ktime(data->ts), mode);
454
+
hrtimer_start(&data->timer, data->time, mode);
455
455
return 0;
456
456
}
457
457
···
477
477
tr->ltimeout = true;
478
478
if (tr->flags & ~(IORING_TIMEOUT_UPDATE_MASK|IORING_TIMEOUT_ABS))
479
479
return -EINVAL;
480
-
ret = io_parse_user_time(&tr->ts, READ_ONCE(sqe->addr2));
480
+
ret = io_parse_user_time(&tr->time, READ_ONCE(sqe->addr2));
481
481
if (ret)
482
482
return ret;
483
483
} else if (tr->flags) {
···
514
514
515
515
raw_spin_lock_irq(&ctx->timeout_lock);
516
516
if (tr->ltimeout)
517
-
ret = io_linked_timeout_update(ctx, tr->addr, &tr->ts, mode);
517
+
ret = io_linked_timeout_update(ctx, tr->addr, tr->time, mode);
518
518
else
519
-
ret = io_timeout_update(ctx, tr->addr, &tr->ts, mode);
519
+
ret = io_timeout_update(ctx, tr->addr, tr->time, mode);
520
520
raw_spin_unlock_irq(&ctx->timeout_lock);
521
521
}
522
522
···
574
574
data->req = req;
575
575
data->flags = flags;
576
576
577
-
ret = io_parse_user_time(&data->ts, READ_ONCE(sqe->addr));
577
+
ret = io_parse_user_time(&data->time, READ_ONCE(sqe->addr));
578
578
if (ret)
579
579
return ret;
580
580
···
652
652
}
653
653
add:
654
654
list_add(&timeout->list, entry);
655
-
hrtimer_start(&data->timer, timespec64_to_ktime(data->ts), data->mode);
655
+
hrtimer_start(&data->timer, data->time, data->mode);
656
656
raw_spin_unlock_irq(&ctx->timeout_lock);
657
657
return IOU_ISSUE_SKIP_COMPLETE;
658
658
}
···
670
670
if (timeout->head) {
671
671
struct io_timeout_data *data = req->async_data;
672
672
673
-
hrtimer_start(&data->timer, timespec64_to_ktime(data->ts),
674
-
data->mode);
673
+
hrtimer_start(&data->timer, data->time, data->mode);
675
674
list_add_tail(&timeout->list, &ctx->ltimeout_list);
676
675
}
677
676
raw_spin_unlock_irq(&ctx->timeout_lock);