#include <sys/sysinfo.h>
#include <stdio.h>
#include <stdlib.h>

int main(int s_argc, char **s_argv)
{
    struct sysinfo s_sysinfo_local;

    (void)s_argc;
    (void)s_argv;

    if(sysinfo((struct sysinfo *)(&s_sysinfo_local)) == 0) {
        (void)fprintf(stdout, "uptime is %ld sec\n",
(long)s_sysinfo_local.uptime);
    }

    return(EXIT_SUCCESS);
}

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main(int s_argc, char **s_argv)
{
    time_t s_time_local;

    if(time((time_t *)(&s_time_local)) != ((time_t)(-1))) {
        struct tm s_tm_local;

        (void)memcpy((void *)(&s_tm_local), localtime((time_t
*)(&s_time_local)), sizeof(struct tm));
        (void)fprintf(stdout, "지역시간: %d/%d/%d %02d:%02d:%02d\n",
s_tm_local.tm_year + 19000, s_tm_local.tm_mon + 1, s_tm_local.tm_mday,
s_tm_local.tm_hour, s_tm_local.tm_min, s_tm_local.tm_sec);

        (void)memcpy((void *)(&s_tm_local), gmtime((time_t
*)(&s_time_local)), sizeof(struct tm));
        (void)fprintf(stdout, "그리니치 표준시: %d/%d/%d %02d:%02d:%
02d\n", s_tm_local.tm_year + 19000, s_tm_local.tm_mon + 1,
s_tm_local.tm_mday, s_tm_local.tm_hour, s_tm_local.tm_min,
s_tm_local.tm_sec);

    }

    return(EXIT_SUCCESS);
}

#include <time.h>

...

struct tm s_set_tm_local;
time_t s_set_time_local;

(void)memset((void *)(&s_set_tm_local), 0, sizeof(s_set_tm_local));
s_set_tm_local.tm_year = <년도> - 1900;
s_set_tm_local.tm_mon = <월> - 1;
s_set_tm_local.tm_mday = <일>;
s_set_tm_local.tm_hour = <시>;
s_set_tm_local.tm_min = <분>;
s_set_tm_local.tm_sec = <초>;
s_set_time_local = mktime((struct tm *)(&s_set_tm_local)); /* struct
tm구조체형식을 time_t 형식으로 변환 */

if(stime((time_t *)(&s_set_time_local)) == 0) {
    /* 설정완료 */
}

...

#include <sys/time.h>
#include <time.h>
#include <unistd.h>

typedef unsigned long long __mz_time_stamp_t;
#define mz_time_stamp_t __mz_time_stamp_t

typedef struct mz_timer_ts {

    /* need shadow */
    long clock_tick;
    clock_t prev_clock;
    mz_time_stamp_t time_stamp;

}__mz_timer_t;
#define mz_timer_t __mz_timer_t

static mz_time_stamp_t __mz_timer_time_stamp(mz_timer_t *s_timer)
{
    clock_t s_clock;

#if defined(__linux__)
    /* get linux kernel's jiffes (tick counter) */
    s_clock = times((struct tms *)0);
#else
    do {
        struct tms s_tms;
        s_clock = times((struct tms *)(&s_tms));
    }while(0);
#endif

    if(s_clock == ((clock_t)(-1))) {
        /* overflow clock timing */
        return(s_timer->time_stamp);
    }

    if(s_timer->clock_tick <= 0l) {
        /* get ticks per second */
        s_timer->clock_tick = sysconf(_SC_CLK_TCK);
        if(s_timer->clock_tick <= 0l) {
            /* invalid clock tick */
            return(s_timer->time_stamp);
        }

        s_timer->prev_clock = s_clock;
    }

    /* update time stamp (clock to upscale) */
    s_timer->time_stamp += (((mz_time_stamp_t)(s_clock -
s_timer->prev_clock)) * ((mz_time_stamp_t)1000)) /
((mz_time_stamp_t)s_timer->clock_tick);
    s_timer->prev_clock = s_clock;

    return(s_timer->time_stamp);
}

static mz_time_stamp_t mz_get_time_stamp_msec(mz_timer_t *s_timer)
{
    statuc mz_timer_t g_global_timer_local = {
        0l, (clock_t)0, (mz_time_stamp_t)1000u
    };

    return(__mz_timer_time_stamp((mz_timer_t
*)(&g_global_timer_local));
}

unsigned long long int mz_get_cpu_clock(void)
{
    unsigned long long int s_qword;

    __asm__ volatile(
        "rdtsc\n\t" : "=A"(s_qword)
    );

    return(s_qword);
}

/*
  Copyright (C) JAEHYUK CHO
  All rights reserved.
  Code by JaeHyuk Cho <mailto:minzkn@minzkn.com>
*/

#include <sys/types.h>
#include <sys/time.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <time.h>
#include <unistd.h>
#include <errno.h>

#include <pthread.h>

#define def_mztimer_realtime_signal SIGRTMIN
    
static long g_mztimer_interval_usec;

static void mztimer_handler(int s_signal, siginfo_t *s_siginfo, void *s_user_context)
{
    static unsigned int s_tick = 0;
    timer_t *s_timer_id_ptr;
    int s_overrun_count;

    (void)s_signal;
    (void)s_siginfo;
    (void)s_user_context;

    s_timer_id_ptr = (timer_t *)s_siginfo->si_value.sival_ptr;
    s_overrun_count = timer_getoverrun(*s_timer_id_ptr);
    if(s_overrun_count == (-1)) {
        s_overrun_count = 0;
    }

    (void)fprintf(stdout, "tick=%u, overrun_count=%d", s_tick, s_overrun_count);

#if 1L /* DEBUG: compare with system time */
    do {
        static unsigned long long s_start_time_usec = 0ull;
        unsigned long long s_current_time_usec;
        struct timeval s_timeval;
        unsigned long long s_duration_usec, s_diff_usec;

        s_duration_usec = s_tick * g_mztimer_interval_usec;

        (void)gettimeofday(&s_timeval, NULL);
        s_current_time_usec = (s_timeval.tv_sec * 1000000) + s_timeval.tv_usec;
        if(s_start_time_usec == 0ull) {
            s_start_time_usec = s_current_time_usec;
        }
        s_current_time_usec -= s_start_time_usec;

	if(s_duration_usec > s_current_time_usec) {
	    s_diff_usec = s_duration_usec - s_current_time_usec;
	}
	else {
	    s_diff_usec = s_current_time_usec - s_duration_usec;
	}

        fprintf(stdout, ", real=%llu.%03llu, diff=%llu.%llu",
            s_current_time_usec / 1000ull,
            s_current_time_usec % 1000ull,
            s_diff_usec / 1000ull,
            s_diff_usec % 1000ull);
    }while(0);
#endif

    (void)fprintf(stdout, "\n");

    s_tick += 1 + s_overrun_count;
}
  
static void *mztimer_thread(void *s_argument)
{
    static timer_t s_timer_id;
    struct sigevent s_sigevent;
    struct itimerspec s_itimerspec;
    sigset_t s_mask;
    struct sigaction s_sigaction;
    clockid_t s_clock_id = CLOCK_REALTIME;

    /* establish handler for timer signal */
    s_sigaction.sa_flags = SA_SIGINFO;
    s_sigaction.sa_sigaction = mztimer_handler;
    sigemptyset(&s_sigaction.sa_mask);
    if(sigaction(def_mztimer_realtime_signal, &s_sigaction, NULL) == (-1)) {
        return(NULL);
    }

    /* block timer signal temporarily */
    sigemptyset(&s_mask);
    sigaddset(&s_mask, def_mztimer_realtime_signal);
    if(sigprocmask(SIG_SETMASK, &s_mask, NULL) == (-1)) {
        return(NULL);
    }

    /* create timer */
    s_sigevent.sigev_notify = SIGEV_SIGNAL;
    s_sigevent.sigev_signo = def_mztimer_realtime_signal;
    s_sigevent.sigev_value.sival_ptr = &s_timer_id;
    if(timer_create(s_clock_id, &s_sigevent, &s_timer_id) == (-1)) {
        return(NULL);
    }

    /* start the timer */
    s_itimerspec.it_value.tv_sec = g_mztimer_interval_usec / 1000000l;
    s_itimerspec.it_value.tv_nsec = (g_mztimer_interval_usec % 1000000l) * 1000l;
    s_itimerspec.it_interval.tv_sec = s_itimerspec.it_value.tv_sec;
    s_itimerspec.it_interval.tv_nsec = s_itimerspec.it_value.tv_nsec;
    if(timer_settime(s_timer_id, 0, &s_itimerspec, NULL) == (-1)) {
        return(NULL);
    }
   
    /* unlock the timer signal */
    if(sigprocmask(SIG_UNBLOCK, &s_mask, NULL) == (-1)) {
        return(NULL);
    }

    for(;;) {
        pause();
    }

    return(NULL);
}

int mztimer_start(long s_interval_usec)
{
    pthread_t s_thread_handle;
    sigset_t s_mask;

    g_mztimer_interval_usec = s_interval_usec;

    if(pthread_create(&s_thread_handle, NULL, mztimer_thread, NULL) == (-1)) {
        return(-1);
    }
    (void)pthread_detach(s_thread_handle);
    
    sigemptyset(&s_mask);
    sigaddset(&s_mask, def_mztimer_realtime_signal);
    (void)sigprocmask(SIG_BLOCK, &s_mask, NULL);

    return(0);
}

int main(void)
{
    (void)mztimer_start(1000l);

    for(;;) {
        
        sleep(1);
	
	(void)fprintf(stdout, "\x1b[1;33msleep loop\x1b[0m\n");
    }
    

    return(EXIT_SUCCESS);
}

/* End of source *