1 /* 2 * include/types/task.h 3 * Macros, variables and structures for task management. 4 * 5 * Copyright (C) 2000-2010 Willy Tarreau - w@1wt.eu 6 * 7 * This library is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU Lesser General Public 9 * License as published by the Free Software Foundation, version 2.1 10 * exclusively. 11 * 12 * This library is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * Lesser General Public License for more details. 16 * 17 * You should have received a copy of the GNU Lesser General Public 18 * License along with this library; if not, write to the Free Software 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 20 */ 21 22 #ifndef _TYPES_TASK_H 23 #define _TYPES_TASK_H 24 25 #include <sys/time.h> 26 27 #include <common/config.h> 28 #include <common/mini-clist.h> 29 #include <eb32sctree.h> 30 #include <eb32tree.h> 31 32 /* values for task->state */ 33 #define TASK_SLEEPING 0x0000 /* task sleeping */ 34 #define TASK_RUNNING 0x0001 /* the task is currently running */ 35 #define TASK_GLOBAL 0x0002 /* The task is currently in the global runqueue */ 36 #define TASK_QUEUED 0x0004 /* The task has been (re-)added to the run queue */ 37 #define TASK_SHARED_WQ 0x0008 /* The task's expiration may be updated by other 38 * threads, must be set before first queue/wakeup */ 39 40 #define TASK_WOKEN_INIT 0x0100 /* woken up for initialisation purposes */ 41 #define TASK_WOKEN_TIMER 0x0200 /* woken up because of expired timer */ 42 #define TASK_WOKEN_IO 0x0400 /* woken up because of completed I/O */ 43 #define TASK_WOKEN_SIGNAL 0x0800 /* woken up by a system signal */ 44 #define TASK_WOKEN_MSG 0x1000 /* woken up by another task's message */ 45 #define TASK_WOKEN_RES 0x2000 /* woken up because of available resource */ 46 #define TASK_WOKEN_OTHER 0x4000 /* woken up for an unspecified reason */ 47 48 /* use this to check a task state or to clean it up before queueing */ 49 #define TASK_WOKEN_ANY (TASK_WOKEN_OTHER|TASK_WOKEN_INIT|TASK_WOKEN_TIMER| \ 50 TASK_WOKEN_IO|TASK_WOKEN_SIGNAL|TASK_WOKEN_MSG| \ 51 TASK_WOKEN_RES) 52 53 struct notification { 54 struct list purge_me; /* Part of the list of signals to be purged in the 55 case of the LUA execution stack crash. */ 56 struct list wake_me; /* Part of list of signals to be targeted if an 57 event occurs. */ 58 struct task *task; /* The task to be wake if an event occurs. */ 59 __decl_hathreads(HA_SPINLOCK_T lock); 60 }; 61 62 /* force to split per-thread stuff into separate cache lines */ 63 struct task_per_thread { 64 struct eb_root timers; /* tree constituting the per-thread wait queue */ 65 struct eb_root rqueue; /* tree constituting the per-thread run queue */ 66 struct list task_list; /* List of tasks to be run, mixing tasks and tasklets */ 67 struct mt_list shared_tasklet_list; /* Tasklet to be run, woken up by other threads */ 68 int task_list_size; /* Number of tasks in the task_list */ 69 int rqueue_size; /* Number of elements in the per-thread run queue */ 70 struct task *current; /* current task (not tasklet) */ 71 __attribute__((aligned(64))) char end[0]; 72 }; 73 74 /* This part is common between struct task and struct tasklet so that tasks 75 * can be used as-is as tasklets. 76 */ 77 #define TASK_COMMON \ 78 struct { \ 79 unsigned short state; /* task state : bitfield of TASK_ */ \ 80 short nice; /* task prio from -1024 to +1024, or -32768 for tasklets */ \ 81 unsigned int calls; /* number of times process was called */ \ 82 struct task *(*process)(struct task *t, void *ctx, unsigned short state); /* the function which processes the task */ \ 83 void *context; /* the task's context */ \ 84 } 85 86 /* The base for all tasks */ 87 struct task { 88 TASK_COMMON; /* must be at the beginning! */ 89 struct eb32sc_node rq; /* ebtree node used to hold the task in the run queue */ 90 struct eb32_node wq; /* ebtree node used to hold the task in the wait queue */ 91 int expire; /* next expiration date for this task, in ticks */ 92 unsigned long thread_mask; /* mask of thread IDs authorized to process the task */ 93 uint64_t call_date; /* date of the last task wakeup or call */ 94 uint64_t lat_time; /* total latency time experienced */ 95 uint64_t cpu_time; /* total CPU time consumed */ 96 }; 97 98 /* lightweight tasks, without priority, mainly used for I/Os */ 99 struct tasklet { 100 TASK_COMMON; /* must be at the beginning! */ 101 struct list list; 102 int tid; /* TID of the tasklet owner, <0 if local */ 103 }; 104 105 #define TASK_IS_TASKLET(t) ((t)->nice == -32768) 106 107 /* 108 * The task callback (->process) is responsible for updating ->expire. It must 109 * return a pointer to the task itself, except if the task has been deleted, in 110 * which case it returns NULL so that the scheduler knows it must not check the 111 * expire timer. The scheduler will requeue the task at the proper location. 112 */ 113 114 115 /* A work_list is a thread-safe way to enqueue some work to be run on another 116 * thread. It consists of a list, a task and a general-purpose argument. 117 * A work is appended to the list by atomically adding a list element to the 118 * list and waking up the associated task, which is done using work_add(). The 119 * caller must be careful about how operations are run as it will definitely 120 * happen that the element being enqueued is processed by the other thread 121 * before the call returns. Some locking conventions between the caller and the 122 * callee might sometimes be necessary. The task is always woken up with reason 123 * TASK_WOKEN_OTHER and a context pointing to the work_list entry. 124 */ 125 struct work_list { 126 struct mt_list head; 127 struct task *task; 128 void *arg; 129 }; 130 131 #endif /* _TYPES_TASK_H */ 132 133 /* 134 * Local variables: 135 * c-indent-level: 8 136 * c-basic-offset: 8 137 * End: 138 */ 139