task-utils.c

   1 /*
   2  * This program is free software; you can redistribute it and/or
   3  * modify it under the terms of the GNU General Public
   4  * License v2 as published by the Free Software Foundation.
   5  *
   6  * This program is distributed in the hope that it will be useful,
   7  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   8  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   9  * General Public License for more details.
  10  *
  11  * You should have received a copy of the GNU General Public
  12  * License along with this program; if not, write to the
  13  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  14  * Boston, MA 021110-1307, USA.
  15  */
  16
  17 #include <pthread.h>
  18 #include <sys/timerfd.h>
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <unistd.h>
  22 #include <time.h>
  23
  24 #include "task-utils.h"
  25
  26 struct task_info *task_init(void *(*threadfn)(void *), int (*postfn)(void *),
  27                             void *thread_private)
  28 {
  29         struct task_info *info = calloc(1, sizeof(struct task_info));
  30
  31         if (!info)
  32                 return NULL;
  33
  34         info->private_data = thread_private;
  35         info->threadfn = threadfn;
  36         info->postfn = postfn;
  37
  38         return info;
  39 }
  40
  41 int task_start(struct task_info *info, time_t *start_time, u64 *item_count)
  42 {
  43         int ret;
  44
  45         if (!info)
  46                 return -1;
  47
  48         if (!info->threadfn)
  49                 return -1;
  50
  51         if (start_time)
  52                 *start_time = time(NULL);
  53         if (item_count)
  54                 *item_count = 0;
  55
  56         ret = pthread_create(&info->id, NULL, info->threadfn,
  57                              info->private_data);
  58
  59         if (ret)
  60                 info->id = 0;
  61
  62         return ret;
  63 }
  64
  65 void task_stop(struct task_info *info)
  66 {
  67         if (!info)
  68                 return;
  69
  70         if (info->id > 0) {
  71                 pthread_cancel(info->id);
  72                 pthread_join(info->id, NULL);
  73                 info->id = 0;
  74         }
  75
  76         if (info->periodic.timer_fd) {
  77                 close(info->periodic.timer_fd);
  78                 info->periodic.timer_fd = 0;
  79         }
  80
  81         if (info->postfn)
  82                 info->postfn(info->private_data);
  83 }
  84
  85 void task_deinit(struct task_info *info)
  86 {
  87         if (!info)
  88                 return;
  89
  90         free(info);
  91 }
  92
  93 int task_period_start(struct task_info *info, unsigned int period_ms)
  94 {
  95         unsigned int ns;
  96         unsigned int sec;
  97         struct itimerspec itval;
  98
  99         if (!info)
 100                 return -1;
 101
 102         info->periodic.timer_fd = timerfd_create(CLOCK_MONOTONIC, 0);
 103         if (info->periodic.timer_fd == -1) {
 104                 info->periodic.timer_fd = 0;
 105                 return info->periodic.timer_fd;
 106         }
 107
 108         info->periodic.wakeups_missed = 0;
 109
 110         sec = period_ms / 1000;
 111         ns = (period_ms - (sec * 1000)) * 1000 * 1000;
 112         itval.it_interval.tv_sec = sec;
 113         itval.it_interval.tv_nsec = ns;
 114         itval.it_value.tv_sec = sec;
 115         itval.it_value.tv_nsec = ns;
 116
 117         return timerfd_settime(info->periodic.timer_fd, 0, &itval, NULL);
 118 };
 119
 120 void task_period_wait(struct task_info *info)
 121 {
 122         unsigned long long missed;
 123         int ret;
 124
 125         if (!info)
 126                 return;
 127
 128         if (info->periodic.timer_fd == 0)
 129                 return;
 130
 131         ret = read(info->periodic.timer_fd, &missed, sizeof (missed));
 132         if (ret == -1)
 133                 return;
 134
 135         if (missed > 0)
 136                 info->periodic.wakeups_missed += (missed - 1);
 137 }
 138
 139 void task_period_stop(struct task_info *info)
 140 {
 141         if (!info)
 142                 return;
 143
 144         if (info->periodic.timer_fd) {
 145                 timerfd_settime(info->periodic.timer_fd, 0, NULL, NULL);
 146                 close(info->periodic.timer_fd);
 147                 info->periodic.timer_fd = -1;
 148         }
 149 }