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

[libc] move clock_time to time.

This commit is contained in:
BernardXiong 2017-12-31 16:43:08 +08:00
parent 1383a97737
commit d3da3bd9b2
8 changed files with 306 additions and 240 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

372
components/libc/compilers/newlib/syscalls.c
View File

@ -17,86 +17,86 @@ int
_close_r(struct _reent *ptr, int fd)
{
#ifndef RT_USING_DFS
return 0;
return 0;
#else
return close(fd);
return close(fd);
#endif
}
int
_execve_r(struct _reent *ptr, const char * name, char *const *argv, char *const *env)
{
/* return "not supported" */
ptr->_errno = ENOTSUP;
return -1;
/* return "not supported" */
ptr->_errno = ENOTSUP;
return -1;
}
int
_fcntl_r(struct _reent *ptr, int fd, int cmd, int arg)
{
/* return "not supported" */
ptr->_errno = ENOTSUP;
return -1;
/* return "not supported" */
ptr->_errno = ENOTSUP;
return -1;
}
int
_fork_r(struct _reent *ptr)
{
/* return "not supported" */
ptr->_errno = ENOTSUP;
return -1;
/* return "not supported" */
ptr->_errno = ENOTSUP;
return -1;
}
int
_fstat_r(struct _reent *ptr, int fd, struct stat *pstat)
{
/* return "not supported" */
ptr->_errno = ENOTSUP;
return -1;
/* return "not supported" */
ptr->_errno = ENOTSUP;
return -1;
}
int
_getpid_r(struct _reent *ptr)
{
return 0;
return 0;
}
int
_isatty_r(struct _reent *ptr, int fd)
{
if (fd >=0 && fd < 3) return 1;
if (fd >=0 && fd < 3) return 1;
/* return "not supported" */
ptr->_errno = ENOTSUP;
return -1;
/* return "not supported" */
ptr->_errno = ENOTSUP;
return -1;
}
int
_kill_r(struct _reent *ptr, int pid, int sig)
{
/* return "not supported" */
ptr->_errno = ENOTSUP;
return -1;
/* return "not supported" */
ptr->_errno = ENOTSUP;
return -1;
}
int
_link_r(struct _reent *ptr, const char *old, const char *new)
{
/* return "not supported" */
ptr->_errno = ENOTSUP;
return -1;
/* return "not supported" */
ptr->_errno = ENOTSUP;
return -1;
}
_off_t
_lseek_r(struct _reent *ptr, int fd, _off_t pos, int whence)
{
#ifndef RT_USING_DFS
return 0;
return 0;
#else
_off_t rc;
_off_t rc;
rc = lseek(fd, pos, whence);
return rc;
rc = lseek(fd, pos, whence);
return rc;
#endif
}
@ -104,12 +104,12 @@ int
_mkdir_r(struct _reent *ptr, const char *name, int mode)
{
#ifndef RT_USING_DFS
return 0;
return 0;
#else
int rc;
int rc;
rc = mkdir(name, mode);
return rc;
rc = mkdir(name, mode);
return rc;
#endif
}
@ -117,12 +117,12 @@ int
_open_r(struct _reent *ptr, const char *file, int flags, int mode)
{
#ifndef RT_USING_DFS
return 0;
return 0;
#else
int rc;
int rc;
rc = open(file, flags, mode);
return rc;
rc = open(file, flags, mode);
return rc;
#endif
}
@ -130,12 +130,12 @@ _ssize_t
_read_r(struct _reent *ptr, int fd, void *buf, size_t nbytes)
{
#ifndef RT_USING_DFS
return 0;
return 0;
#else
_ssize_t rc;
_ssize_t rc;
rc = read(fd, buf, nbytes);
return rc;
rc = read(fd, buf, nbytes);
return rc;
#endif
}
@ -143,62 +143,62 @@ int
_rename_r(struct _reent *ptr, const char *old, const char *new)
{
#ifndef RT_USING_DFS
return 0;
return 0;
#else
int rc;
int rc;
rc = rename(old, new);
return rc;
rc = rename(old, new);
return rc;
#endif
}
void *
_sbrk_r(struct _reent *ptr, ptrdiff_t incr)
{
/* no use this routine to get memory */
return RT_NULL;
/* no use this routine to get memory */
return RT_NULL;
}
int
_stat_r(struct _reent *ptr, const char *file, struct stat *pstat)
{
#ifndef RT_USING_DFS
return 0;
return 0;
#else
int rc;
int rc;
rc = stat(file, pstat);
return rc;
rc = stat(file, pstat);
return rc;
#endif
}
_CLOCK_T_
_times_r(struct _reent *ptr, struct tms *ptms)
{
/* return "not supported" */
ptr->_errno = ENOTSUP;
return -1;
/* return "not supported" */
ptr->_errno = ENOTSUP;
return -1;
}
int
_unlink_r(struct _reent *ptr, const char *file)
{
#ifndef RT_USING_DFS
return 0;
return 0;
#else
int rc;
int rc;
rc = unlink(file);
return rc;
rc = unlink(file);
return rc;
#endif
}
int
_wait_r(struct _reent *ptr, int *status)
{
/* return "not supported" */
ptr->_errno = ENOTSUP;
return -1;
/* return "not supported" */
ptr->_errno = ENOTSUP;
return -1;
}
#ifdef RT_USING_DEVICE
@ -206,133 +206,127 @@ _ssize_t
_write_r(struct _reent *ptr, int fd, const void *buf, size_t nbytes)
{
#ifndef RT_USING_DFS
if (fd == 0)
{
rt_device_t console;
if (fd == 0)
{
rt_device_t console;
console = rt_console_get_device();
if (console) return rt_device_write(console, -1, buf, nbytes);
}
console = rt_console_get_device();
if (console) return rt_device_write(console, -1, buf, nbytes);
}
return 0;
#else
_ssize_t rc;
_ssize_t rc;
rc = write(fd, buf, nbytes);
return rc;
rc = write(fd, buf, nbytes);
return rc;
#endif
}
#endif
#ifndef RT_USING_PTHREADS
#ifdef RT_USING_PTHREADS
#ifndef MILLISECOND_PER_SECOND
#define MILLISECOND_PER_SECOND 1000UL
#endif
#include <clock_time.h>
/* POSIX timer provides clock_gettime function */
#include <time.h>
int
_gettimeofday_r(struct _reent *ptr, struct timeval *__tp, void *__tzp)
{
struct timespec tp;
#ifndef MICROSECOND_PER_SECOND
#define MICROSECOND_PER_SECOND 1000000UL
#endif
if (clock_gettime(CLOCK_REALTIME, &tp) == 0)
{
if (__tp != RT_NULL)
{
__tp->tv_sec = tp.tv_sec;
__tp->tv_usec = tp.tv_nsec / 1000UL;
}
#ifndef NANOSECOND_PER_SECOND
#define NANOSECOND_PER_SECOND 1000000000UL
#endif
return tp.tv_sec;
}
#define MILLISECOND_PER_TICK (MILLISECOND_PER_SECOND / RT_TICK_PER_SECOND)
#define MICROSECOND_PER_TICK (MICROSECOND_PER_SECOND / RT_TICK_PER_SECOND)
#define NANOSECOND_PER_TICK (NANOSECOND_PER_SECOND / RT_TICK_PER_SECOND)
/* return "not supported" */
ptr->_errno = ENOTSUP;
return -1;
}
#else
#define MILLISECOND_PER_SECOND 1000UL
#define MICROSECOND_PER_SECOND 1000000UL
#define NANOSECOND_PER_SECOND 1000000000UL
#define MILLISECOND_PER_TICK (MILLISECOND_PER_SECOND / RT_TICK_PER_SECOND)
#define MICROSECOND_PER_TICK (MICROSECOND_PER_SECOND / RT_TICK_PER_SECOND)
#define NANOSECOND_PER_TICK (NANOSECOND_PER_SECOND / RT_TICK_PER_SECOND)
struct timeval _timevalue = {0};
#ifdef RT_USING_DEVICE
static void libc_system_time_init(void)
{
time_t time;
rt_tick_t tick;
rt_device_t device;
time_t time;
rt_tick_t tick;
rt_device_t device;
time = 0;
device = rt_device_find("rtc");
if (device != RT_NULL)
{
/* get realtime seconds */
rt_device_control(device, RT_DEVICE_CTRL_RTC_GET_TIME, &time);
}
time = 0;
device = rt_device_find("rtc");
if (device != RT_NULL)
{
/* get realtime seconds */
rt_device_control(device, RT_DEVICE_CTRL_RTC_GET_TIME, &time);
}
/* get tick */
tick = rt_tick_get();
/* get tick */
tick = rt_tick_get();
_timevalue.tv_usec = MICROSECOND_PER_SECOND - (tick%RT_TICK_PER_SECOND) * MICROSECOND_PER_TICK;
_timevalue.tv_sec = time - tick/RT_TICK_PER_SECOND - 1;
_timevalue.tv_usec = MICROSECOND_PER_SECOND - (tick%RT_TICK_PER_SECOND) * MICROSECOND_PER_TICK;
_timevalue.tv_sec = time - tick/RT_TICK_PER_SECOND - 1;
}
#endif
int libc_get_time(struct timespec *time)
{
rt_tick_t tick;
static rt_bool_t inited = 0;
rt_tick_t tick;
static rt_bool_t inited = 0;
RT_ASSERT(time != RT_NULL);
RT_ASSERT(time != RT_NULL);
/* initialize system time */
if (inited == 0)
{
libc_system_time_init();
inited = 1;
}
/* initialize system time */
if (inited == 0)
{
libc_system_time_init();
inited = 1;
}
/* get tick */
tick = rt_tick_get();
/* get tick */
tick = rt_tick_get();
time->tv_sec = _timevalue.tv_sec + tick / RT_TICK_PER_SECOND;
time->tv_nsec = (_timevalue.tv_usec + (tick % RT_TICK_PER_SECOND) * MICROSECOND_PER_TICK) * 1000;
time->tv_sec = _timevalue.tv_sec + tick / RT_TICK_PER_SECOND;
time->tv_nsec = (_timevalue.tv_usec + (tick % RT_TICK_PER_SECOND) * MICROSECOND_PER_TICK) * 1000;
return 0;
return 0;
}
int
_gettimeofday_r(struct _reent *ptr, struct timeval *__tp, void *__tzp)
{
struct timespec tp;
struct timespec tp;
if (libc_get_time(&tp) == 0)
{
if (__tp != RT_NULL)
{
__tp->tv_sec = tp.tv_sec;
__tp->tv_usec = tp.tv_nsec / 1000UL;
}
if (libc_get_time(&tp) == 0)
{
if (__tp != RT_NULL)
{
__tp->tv_sec = tp.tv_sec;
__tp->tv_usec = tp.tv_nsec / 1000UL;
}
return tp.tv_sec;
}
return tp.tv_sec;
}
/* return "not supported" */
ptr->_errno = ENOTSUP;
return -1;
}
#else
/* POSIX thread provides clock_gettime function */
#include <time.h>
int
_gettimeofday_r(struct _reent *ptr, struct timeval *__tp, void *__tzp)
{
struct timespec tp;
if (clock_gettime(CLOCK_REALTIME, &tp) == 0)
{
if (__tp != RT_NULL)
{
__tp->tv_sec = tp.tv_sec;
__tp->tv_usec = tp.tv_nsec / 1000UL;
}
return tp.tv_sec;
}
/* return "not supported" */
ptr->_errno = ENOTSUP;
return -1;
/* return "not supported" */
ptr->_errno = ENOTSUP;
return -1;
}
#endif
@ -340,64 +334,64 @@ _gettimeofday_r(struct _reent *ptr, struct timeval *__tp, void *__tzp)
void *
_malloc_r (struct _reent *ptr, size_t size)
{
void* result;
void* result;
result = (void*)rt_malloc (size);
if (result == RT_NULL)
{
ptr->_errno = ENOMEM;
}
result = (void*)rt_malloc (size);
if (result == RT_NULL)
{
ptr->_errno = ENOMEM;
}
return result;
return result;
}
void *
_realloc_r (struct _reent *ptr, void *old, size_t newlen)
{
void* result;
void* result;
result = (void*)rt_realloc (old, newlen);
if (result == RT_NULL)
{
ptr->_errno = ENOMEM;
}
result = (void*)rt_realloc (old, newlen);
if (result == RT_NULL)
{
ptr->_errno = ENOMEM;
}
return result;
return result;
}
void *_calloc_r (struct _reent *ptr, size_t size, size_t len)
{
void* result;
void* result;
result = (void*)rt_calloc (size, len);
if (result == RT_NULL)
{
ptr->_errno = ENOMEM;
}
result = (void*)rt_calloc (size, len);
if (result == RT_NULL)
{
ptr->_errno = ENOMEM;
}
return result;
return result;
}
void
_free_r (struct _reent *ptr, void *addr)
{
rt_free (addr);
rt_free (addr);
}
void
_exit (int status)
{
#ifdef RT_USING_MODULE
rt_module_t module;
rt_module_t module;
module = rt_module_self();
if (module != RT_NULL)
{
struct rt_list_node *list;
struct rt_object *object;
module = rt_module_self();
if (module != RT_NULL)
{
struct rt_list_node *list;
struct rt_object *object;
rt_enter_critical();
rt_enter_critical();
/* delete all threads in the module */
list = &module->module_object[RT_Object_Class_Thread].object_list;
while (list->next != list)
@ -414,19 +408,19 @@ _exit (int status)
rt_thread_delete((rt_thread_t)object);
}
}
/* delete main thread */
rt_thread_delete(module->module_thread);
rt_exit_critical();
/* delete main thread */
rt_thread_delete(module->module_thread);
rt_exit_critical();
/* re-schedule */
rt_schedule();
}
/* re-schedule */
rt_schedule();
}
#endif
rt_kprintf("thread:%s exit with %d\n", rt_thread_self()->name, status);
RT_ASSERT(0);
rt_kprintf("thread:%s exit with %d\n", rt_thread_self()->name, status);
RT_ASSERT(0);
while (1);
while (1);
}
void
@ -438,7 +432,7 @@ _system(const char *s)
void __libc_init_array(void)
{
/* we not use __libc init_aray to initialize C++ objects */
/* we not use __libc init_aray to initialize C++ objects */
}
void abort(void)
@ -453,5 +447,5 @@ void abort(void)
rt_schedule();
}
while (1);
while (1);
}

3
components/libc/pthreads/pthread.c
View File

@ -27,9 +27,6 @@
int pthread_system_init(void)
{
/* initialize clock and time */
clock_time_system_init();
/* initialize key area */
pthread_key_system_init();
/* initialize posix mqueue */

31
components/libc/pthreads/pthread.h
View File

@ -276,35 +276,4 @@ int pthread_barrier_init(pthread_barrier_t *barrier,
int pthread_barrier_wait(pthread_barrier_t *barrier);
/* posix clock and timer */
#define MILLISECOND_PER_SECOND 1000UL
#define MICROSECOND_PER_SECOND 1000000UL
#define NANOSECOND_PER_SECOND 1000000000UL
#define MILLISECOND_PER_TICK (MILLISECOND_PER_SECOND / RT_TICK_PER_SECOND)
#define MICROSECOND_PER_TICK (MICROSECOND_PER_SECOND / RT_TICK_PER_SECOND)
#define NANOSECOND_PER_TICK (NANOSECOND_PER_SECOND / RT_TICK_PER_SECOND)
#ifndef CLOCK_REALTIME
#define CLOCK_REALTIME 1
#endif
#define CLOCK_CPUTIME_ID 2
#ifndef CLOCK_PROCESS_CPUTIME_ID
#define CLOCK_PROCESS_CPUTIME_ID CLOCK_CPUTIME_ID
#endif
#ifndef CLOCK_THREAD_CPUTIME_ID
#define CLOCK_THREAD_CPUTIME_ID CLOCK_CPUTIME_ID
#endif
#ifndef CLOCK_MONOTONIC
#define CLOCK_MONOTONIC 4
#endif
int clock_getres (clockid_t clockid, struct timespec *res);
int clock_gettime (clockid_t clockid, struct timespec *tp);
int clock_settime (clockid_t clockid, const struct timespec *tp);
#endif

2
components/libc/pthreads/pthread_internal.h
View File

@ -83,7 +83,7 @@ rt_inline _pthread_data_t *_pthread_get_data(pthread_t thread)
}
int clock_time_to_tick(const struct timespec *time);
void clock_time_system_init(void);
void posix_mq_system_init(void);
void posix_sem_system_init(void);
void pthread_key_system_init(void);

4
components/libc/timer/SConscript → components/libc/time/SConscript
View File

@ -6,7 +6,7 @@ cwd = GetCurrentDir()
src = Glob('*.c') + Glob('*.cpp')
CPPPATH = [cwd]
group = DefineGroup('libc', src,
depend = ['RT_USING_LIBC', 'RT_USING_POSIX_TIMER'], CPPPATH = CPPPATH)
group = DefineGroup('pthreads', src,
depend = ['RT_USING_PTHREADS'], CPPPATH = CPPPATH)
Return('group')

76
components/libc/pthreads/clock_time.c → components/libc/time/clock_time.c
View File

@ -24,10 +24,13 @@
*/
#include <rtthread.h>
#include <rtdevice.h>
#include <pthread.h>
#include "clock_time.h"
struct timeval _timevalue;
void clock_time_system_init()
int clock_time_system_init()
{
time_t time;
rt_tick_t tick;
@ -46,7 +49,10 @@ void clock_time_system_init()
_timevalue.tv_usec = (tick%RT_TICK_PER_SECOND) * MICROSECOND_PER_TICK;
_timevalue.tv_sec = time - tick/RT_TICK_PER_SECOND - 1;
return 0;
}
INIT_COMPONENT_EXPORT(clock_time_system_init);
int clock_time_to_tick(const struct timespec *time)
{
@ -83,38 +89,80 @@ RTM_EXPORT(clock_time_to_tick);
int clock_getres(clockid_t clockid, struct timespec *res)
{
if ((clockid != CLOCK_REALTIME) || (res == RT_NULL))
int ret = 0;
if (res == RT_NULL)
{
rt_set_errno(EINVAL);
return -1;
}
res->tv_sec = 0;
res->tv_nsec = NANOSECOND_PER_SECOND/RT_TICK_PER_SECOND;
switch (clockid)
{
case CLOCK_REALTIME:
res->tv_sec = 0;
res->tv_nsec = NANOSECOND_PER_SECOND/RT_TICK_PER_SECOND;
break;
return 0;
#ifdef RT_USING_CPUTIME
case CLOCK_CPUTIME_ID:
res->tv_sec = 0;
res->tv_nsec = clock_cpu_getres();
break;
#endif
default:
ret = -1;
rt_set_errno(EINVAL);
break;
}
return ret;
}
RTM_EXPORT(clock_getres);
int clock_gettime(clockid_t clockid, struct timespec *tp)
{
rt_tick_t tick;
int ret = 0;
if ((clockid != CLOCK_REALTIME) || (tp == RT_NULL))
if (tp == RT_NULL)
{
rt_set_errno(EINVAL);
return -1;
}
/* get tick */
tick = rt_tick_get();
switch (clockid)
{
case CLOCK_REALTIME:
{
/* get tick */
int tick = rt_tick_get();
tp->tv_sec = _timevalue.tv_sec + tick / RT_TICK_PER_SECOND;
tp->tv_nsec = (_timevalue.tv_usec + (tick % RT_TICK_PER_SECOND) * MICROSECOND_PER_TICK) * 1000;
tp->tv_sec = _timevalue.tv_sec + tick / RT_TICK_PER_SECOND;
tp->tv_nsec = (_timevalue.tv_usec + (tick % RT_TICK_PER_SECOND) * MICROSECOND_PER_TICK) * 1000;
}
break;
return 0;
#ifdef RT_USING_CPUTIME
case CLOCK_CPUTIME_ID:
{
float unit = 0;
long long cpu_tick;
unit = clock_cpu_getres();
cpu_tick = clock_cpu_gettime();
tp->tv_sec = ((int)(cpu_tick * unit)) / NANOSECOND_PER_SECOND;
tp->tv_nsec = ((int)(cpu_tick * unit)) % NANOSECOND_PER_SECOND;
}
break;
#endif
default:
rt_set_errno(EINVAL);
ret = -1;
}
return ret;
}
RTM_EXPORT(clock_gettime);

58
components/libc/time/clock_time.h Normal file
View File

@ -0,0 +1,58 @@
/*
* File : clock_time.h
* This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2006 - 2017, RT-Thread Development Team
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Change Logs:
* Date Author Notes
* 2017-12-31 Bernard the first version
*/
#ifndef CLOCK_TIME_H__
#define CLOCK_TIME_H__
/* posix clock and timer */
#define MILLISECOND_PER_SECOND 1000UL
#define MICROSECOND_PER_SECOND 1000000UL
#define NANOSECOND_PER_SECOND 1000000000UL
#define MILLISECOND_PER_TICK (MILLISECOND_PER_SECOND / RT_TICK_PER_SECOND)
#define MICROSECOND_PER_TICK (MICROSECOND_PER_SECOND / RT_TICK_PER_SECOND)
#define NANOSECOND_PER_TICK (NANOSECOND_PER_SECOND / RT_TICK_PER_SECOND)
#ifndef CLOCK_REALTIME
#define CLOCK_REALTIME 1
#endif
#define CLOCK_CPUTIME_ID 2
#ifndef CLOCK_PROCESS_CPUTIME_ID
#define CLOCK_PROCESS_CPUTIME_ID CLOCK_CPUTIME_ID
#endif
#ifndef CLOCK_THREAD_CPUTIME_ID
#define CLOCK_THREAD_CPUTIME_ID CLOCK_CPUTIME_ID
#endif
#ifndef CLOCK_MONOTONIC
#define CLOCK_MONOTONIC 4
#endif
int clock_getres (clockid_t clockid, struct timespec *res);
int clock_gettime (clockid_t clockid, struct timespec *tp);
int clock_settime (clockid_t clockid, const struct timespec *tp);
#endif

0
components/libc/timer/posix_sleep.c → components/libc/time/posix_sleep.c
View File