libs/rt-thread-official
libs
/
rt-thread-official
mirror of https://github.com/RT-Thread/rt-thread.git
4
0
Fork 0
Code Issues Releases Wiki Activity

Fixed issues with timerfd (#8102)

This commit is contained in:
zmq810150896 2023-10-13 19:20:50 +08:00 committed by GitHub
parent 8e57b5fdd4
commit a289ae1b18
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 99 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

127
components/libc/posix/io/timerfd/timerfd.c
View File

@ -35,8 +35,9 @@ struct rt_timerfd
rt_timer_t timer;
struct rt_mutex lock;
struct timespec pre_time;
rt_uint64_t timeout_num;
int ticks;
rt_atomic_t timeout_num;
struct rt_wqueue_node wqn;
rt_atomic_t ticks;
int clockid;
int isperiodic;
int tick_out;
@ -75,6 +76,8 @@ static int timerfd_close(struct dfs_file *file)
tfd->timer = RT_NULL;
}
rt_wqueue_remove(&tfd->wqn);
rt_mutex_detach(&tfd->lock);
rt_free(tfd);
}
@ -93,11 +96,11 @@ static int timerfd_poll(struct dfs_file *file, struct rt_pollreq *req)
rt_poll_add(&tfd->timerfd_queue, req);
if (tfd->ticks)
events |= POLLIN;
rt_mutex_release(&tfd->lock);
if (rt_atomic_load(&(tfd->ticks)) > 0)
events |= POLLIN;
return events;
}
@ -109,6 +112,7 @@ static ssize_t timerfd_read(struct dfs_file *file, void *buf, size_t count, off_
{
struct rt_timerfd *tfd;
rt_uint64_t *buffer;
int ret = 0;
buffer = (rt_uint64_t *)buf;
@ -126,29 +130,45 @@ static ssize_t timerfd_read(struct dfs_file *file, void *buf, size_t count, off_
return -1;
}
if ((tfd->ticks == 0) && (file->flags & O_NONBLOCK))
if ((rt_atomic_load(&(tfd->ticks)) == 0) && (file->flags & O_NONBLOCK))
{
rt_set_errno(EAGAIN);
return -EAGAIN;
}
else
{
if (tfd->ticks == 0)
if (rt_atomic_load(&(tfd->ticks)) == 0)
{
rt_wqueue_wait(&tfd->timerfd_queue, 0, RT_WAITING_FOREVER);
tfd->wqn.polling_thread = rt_thread_self();
rt_wqueue_remove(&tfd->wqn);
rt_wqueue_add(&tfd->timerfd_queue, &tfd->wqn);
ret = rt_thread_suspend_with_flag(tfd->wqn.polling_thread, RT_INTERRUPTIBLE);
if (ret == RT_EOK)
{
rt_schedule();
}
else
{
return ret;
}
}
rt_mutex_take(&tfd->lock, RT_WAITING_FOREVER);
(*buffer) = tfd->timeout_num;
rt_mutex_release(&tfd->lock);
}
(*buffer) = rt_atomic_load(&(tfd->timeout_num));
tfd->ticks = 0;
rt_atomic_store(&(tfd->ticks), 0);
}
return sizeof(buffer);
}
static int timerfd_create_do(int clockid, int flags)
static int timerfd_wqueue_callback(struct rt_wqueue_node *wait, void *key)
{
return 0;
}
static int timerfd_do_create(int clockid, int flags)
{
struct rt_timerfd *tfd = RT_NULL;
struct dfs_file *df;
@ -189,6 +209,8 @@ static int timerfd_create_do(int clockid, int flags)
tfd = (struct rt_timerfd *)rt_malloc(sizeof(struct rt_timerfd));
if (tfd)
{
rt_mutex_init(&tfd->lock, TIMERFD_MUTEX_NAME, RT_IPC_FLAG_FIFO);
rt_wqueue_init(&tfd->timerfd_queue);
@ -200,18 +222,19 @@ static int timerfd_create_do(int clockid, int flags)
tfd->timer = RT_NULL;
tfd->pre_time.tv_sec = 0;
tfd->pre_time.tv_nsec = 0;
tfd->wqn.polling_thread = rt_thread_self();
rt_list_init(&(tfd->wqn.list));
tfd->wqn.wakeup = timerfd_wqueue_callback;
if (tfd)
{
df->vnode = (struct dfs_vnode *)rt_malloc(sizeof(struct dfs_vnode));
if (df->vnode)
{
dfs_vnode_init(df->vnode, FT_REGULAR, &timerfd_fops);
df->vnode->data = tfd;
#ifdef RT_USING_DFS_V2
#ifdef RT_USING_DFS_V2
df->fops = &timerfd_fops;
#endif
#endif
}
else
{
@ -276,17 +299,20 @@ static void timerfd_timeout(void *parameter)
rt_wqueue_wakeup(&tfd->timerfd_queue, (void *)POLLIN);
rt_mutex_take(&tfd->lock, RT_WAITING_FOREVER);
rt_atomic_store(&(tfd->ticks), 1);
rt_atomic_add(&(tfd->timeout_num), 1);
tfd->ticks = 1;
tfd->timeout_num ++;
rt_mutex_take(&tfd->lock, RT_WAITING_FOREVER);
get_current_time(tfd, RT_NULL);
if (tfd->isperiodic == OPEN_PERIODIC)
{
if (tfd->timer)
{
rt_timer_stop(tfd->timer);
rt_timer_delete(tfd->timer);
tfd->timer = RT_NULL;
}
tfd->isperiodic = ENTER_PERIODIC;
tfd->timer = rt_timer_create(TIMERFD_MUTEX_NAME, timerfd_timeout,
tfd, tfd->tick_out,
@ -307,9 +333,15 @@ static void timerfd_time_operation(time_t *sec, long *nsec)
*nsec = 1 * SEC_TO_NSEC + *nsec;
}
}
if (*sec < 0 || *nsec < 0)
{
*sec = 0;
*nsec = 0;
}
}
static int timerfd_settime_do(int fd, int flags, const struct itimerspec *new, struct itimerspec *old)
static int timerfd_do_settime(int fd, int flags, const struct itimerspec *new, struct itimerspec *old)
{
int ret = 0;
struct rt_timerfd *tfd;
@ -331,7 +363,9 @@ static int timerfd_settime_do(int fd, int flags, const struct itimerspec *new, s
return -EINVAL;
tfd = df->vnode->data;
tfd->timeout_num = 0;
rt_atomic_store(&(tfd->ticks), 0);
rt_atomic_store(&(tfd->timeout_num), 0);
rt_mutex_take(&tfd->lock, RT_WAITING_FOREVER);
tfd->isperiodic = INIT_PERIODIC;
@ -346,6 +380,18 @@ static int timerfd_settime_do(int fd, int flags, const struct itimerspec *new, s
if (new)
{
if (tfd->timer != RT_NULL)
{
rt_timer_stop(tfd->timer);
rt_timer_delete(tfd->timer);
tfd->timer = RT_NULL;
}
if (new->it_value.tv_nsec == 0 && new->it_value.tv_sec == 0)
{
return 0;
}
value_msec = (new->it_value.tv_nsec / MSEC_TO_NSEC) + (new->it_value.tv_sec * SEC_TO_MSEC);
interval_msec = (new->it_interval.tv_nsec / MSEC_TO_NSEC) + (new->it_interval.tv_sec * SEC_TO_MSEC);
@ -369,13 +415,16 @@ static int timerfd_settime_do(int fd, int flags, const struct itimerspec *new, s
tfd->ittimer.it_value.tv_nsec = new->it_value.tv_nsec - current_time.tv_nsec;
timerfd_time_operation(&tfd->ittimer.it_value.tv_sec, &tfd->ittimer.it_value.tv_nsec);
if (tfd->timer != RT_NULL)
if ((interval_msec > 0) && (interval_msec <= TIME_INT32_MAX))
{
rt_timer_stop(tfd->timer);
rt_timer_delete(tfd->timer);
tfd->timer = RT_NULL;
tfd->tick_out = rt_tick_from_millisecond(interval_msec);
if (tfd->tick_out < 0)
return -EINVAL;
tfd->isperiodic = OPEN_PERIODIC;
}
get_current_time(tfd, RT_NULL);
if (value_msec > 0)
{
if (value_msec > TIME_INT32_MAX)
@ -385,20 +434,15 @@ static int timerfd_settime_do(int fd, int flags, const struct itimerspec *new, s
if (tick_out < 0)
return -EINVAL;
if ((interval_msec > 0) && (interval_msec <= TIME_INT32_MAX))
{
tfd->tick_out = rt_tick_from_millisecond(interval_msec);
if (tfd->tick_out < 0)
return -EINVAL;
tfd->isperiodic = OPEN_PERIODIC;
}
get_current_time(tfd, RT_NULL);
tfd->timer = rt_timer_create(TIMERFD_MUTEX_NAME, timerfd_timeout,
tfd, tick_out,
RT_TIMER_FLAG_ONE_SHOT | RT_TIMER_FLAG_SOFT_TIMER);
rt_timer_start(tfd->timer);
}
else
{
timerfd_timeout(tfd);
}
}
else
{
@ -411,7 +455,7 @@ static int timerfd_settime_do(int fd, int flags, const struct itimerspec *new, s
return ret;
}
static int timerfd_gettime_do(int fd, struct itimerspec *cur)
static int timerfd_do_gettime(int fd, struct itimerspec *cur)
{
struct rt_timerfd *tfd;
struct dfs_file *df = RT_NULL;
@ -443,10 +487,11 @@ static int timerfd_gettime_do(int fd, struct itimerspec *cur)
{
cur->it_value.tv_nsec = tfd->ittimer.it_interval.tv_nsec - tv_nsec;
cur->it_value.tv_sec = tfd->ittimer.it_interval.tv_sec - tv_sec;
timerfd_time_operation(&cur->it_value.tv_sec, &cur->it_value.tv_nsec);
}
else
{
if (tfd->timeout_num == 1)
if (rt_atomic_load(&(tfd->timeout_num)) == 1)
{
cur->it_value.tv_nsec = 0;
cur->it_value.tv_sec = 0;
@ -466,15 +511,15 @@ static int timerfd_gettime_do(int fd, struct itimerspec *cur)
int timerfd_create(int clockid, int flags)
{
return timerfd_create_do(clockid, flags);
return timerfd_do_create(clockid, flags);
}
int timerfd_settime(int fd, int flags, const struct itimerspec *new, struct itimerspec *old)
{
return timerfd_settime_do(fd, flags, new, old);
return timerfd_do_settime(fd, flags, new, old);
}
int timerfd_gettime(int fd, struct itimerspec *cur)
{
return timerfd_gettime_do(fd, cur);
return timerfd_do_gettime(fd, cur);
}