15#include <linux/unistd.h>
20#include <sys/resource.h>
21#include <sys/syscall.h>
27#define ABORT { dsyslog("ABORT!"); cBackTrace::BackTrace(); abort(); }
34#define dbglocking(a...) fprintf(stderr, a)
36#define dbglocking(a...)
39static bool GetAbsTime(
struct timespec *Abstime,
int MillisecondsFromNow)
42 if (gettimeofday(&now, NULL) == 0) {
43 now.tv_sec += MillisecondsFromNow / 1000;
44 now.tv_usec += (MillisecondsFromNow % 1000) * 1000;
45 if (now.tv_usec >= 1000000) {
47 now.tv_usec -= 1000000;
49 Abstime->tv_sec = now.tv_sec;
50 Abstime->tv_nsec = now.tv_usec * 1000;
61 pthread_mutex_init(&
mutex, NULL);
62 pthread_cond_init(&
cond, NULL);
67 pthread_cond_broadcast(&
cond);
68 pthread_cond_destroy(&
cond);
69 pthread_mutex_destroy(&
mutex);
80 pthread_mutex_lock(&
mutex);
83 struct timespec abstime;
86 if (pthread_cond_timedwait(&
cond, &
mutex, &abstime) == ETIMEDOUT)
96 pthread_mutex_unlock(&
mutex);
102 pthread_mutex_lock(&
mutex);
104 pthread_cond_broadcast(&
cond);
105 pthread_mutex_unlock(&
mutex);
112 pthread_cond_init(&
cond, 0);
117 pthread_cond_broadcast(&
cond);
118 pthread_cond_destroy(&
cond);
124 int locked = Mutex.
locked;
137 struct timespec abstime;
139 int locked = Mutex.
locked;
142 if (pthread_cond_timedwait(&
cond, &Mutex.
mutex, &abstime) == ETIMEDOUT)
152 pthread_cond_broadcast(&
cond);
161 pthread_rwlockattr_t attr;
162 pthread_rwlockattr_init(&attr);
163 pthread_rwlockattr_setkind_np(&attr, PreferWriter ? PTHREAD_RWLOCK_PREFER_WRITER_NP : PTHREAD_RWLOCK_PREFER_READER_NP);
164 pthread_rwlock_init(&
rwlock, &attr);
169 pthread_rwlock_destroy(&
rwlock);
175 struct timespec abstime;
181 Result = TimeoutMs ? pthread_rwlock_timedwrlock(&
rwlock, &abstime) : pthread_rwlock_wrlock(&
rwlock);
190 Result = TimeoutMs ? pthread_rwlock_timedrdlock(&
rwlock, &abstime) : pthread_rwlock_rdlock(&
rwlock);
203 pthread_rwlock_unlock(&
rwlock);
211 pthread_mutexattr_t attr;
212 pthread_mutexattr_init(&attr);
213 pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK_NP);
214 pthread_mutex_init(&
mutex, &attr);
219 pthread_mutex_destroy(&
mutex);
224 pthread_mutex_lock(&
mutex);
231 pthread_mutex_unlock(&
mutex);
257 if (setpriority(PRIO_PROCESS, 0, Priority) < 0)
263 if (syscall(SYS_ioprio_set, 1, 0, (Priority & 0xff) | (3 << 13)) < 0)
273 va_start(ap, Description);
285 if (prctl(PR_SET_NAME, Thread->
description, 0, 0, 0) < 0)
301#define THREAD_STOP_TIMEOUT 3000
302#define THREAD_STOP_SLEEP 30
316 if (pthread_create(&
childTid, NULL, (
void *(*) (
void *))&
StartThread, (
void *)
this) == 0) {
342 if ((err = pthread_kill(
childTid, 0)) != 0) {
357 if (
active && WaitSeconds > -1) {
358 if (WaitSeconds > 0) {
359 for (time_t t0 = time(NULL) + WaitSeconds; time(NULL) < t0; ) {
374 return syscall(__NR_gettid);
402 if (Mutex && !
mutex) {
439#define BT_BUF_SIZE 100
444 char *Function = NULL;
446 char *Address = NULL;
448 for (
char *q = Module; *q; q++) {
453 else if (*q ==
'+') {
461 else if (*q ==
']') {
467 char *DemangledFunction = NULL;
470 DemangledFunction = abi::__cxa_demangle(Function, NULL, 0, &status);
471 if (DemangledFunction)
472 Function = DemangledFunction;
478 unsigned long long addr = Address ? strtoull(Address, NULL, 0) : 0;
479 unsigned long long offs = Offset ? strtoull(Offset, NULL, 0) : 0;
485 while (e = strstr(e,
".so"))
487 if (p && !strchr(p,
'/')) {
489 if (dladdr(
reinterpret_cast<void*
>(addr), &dlinfo)) {
490 if ((strcmp(Module, dlinfo.dli_fname) == 0) && dlinfo.dli_fbase) {
491 unsigned long long base =
reinterpret_cast<unsigned long long>(dlinfo.dli_fbase);
499 cString cmd =
cString::sprintf(
"addr2line --functions --demangle --inlines --basename --exe=%s 0x%llx", Module, Function ? addr : offs);
501 if (p.
Open(cmd,
"r")) {
504 while (
char *l = rl.
Read(p)) {
506 if (Function && strcmp(l, Function))
515 free(DemangledFunction);
523 if (
char **s = backtrace_symbols(b, n)) {
524 for (
int i =
max(Level, 0) + 1; i < n; i++)
534 for (
int i = 0; i < sl.
Size(); i++) {
536 fprintf(f,
"%s\n", sl[i]);
545 Level =
max(Level, 0) + 1;
548 if (
char **s = backtrace_symbols(b, n)) {
550 Caller = Mangled ? s[Level] : *
Demangle(s[Level]);
560#define SLL_LENGTH 512
561#define SLL_THREADS 20
562#define SLL_MAX_LIST 9
563#define SLL_WRITE_FLAG 0x80000000
564#define SLL_LOCK_FLAG 0x40000000
582 void Check(
const char *Name,
bool Lock,
bool Write =
false);
591 memset(logCaller, 0,
sizeof(logCaller));
599 dsyslog(
"--- begin invalid lock sequence report");
601 for (
int i = 0; i <
SLL_SIZE; i++) {
605 q += sprintf(q,
"%5d", tid);
610 int Changed = LastFlags ^ Flags;
615 if ((Flags & b) != 0)
617 if ((Changed & b) != 0)
618 c = Lock ? Write ?
'W' :
'R' :
'U';
619 q += sprintf(q,
" %c", c);
621 q += sprintf(q,
" %c", Lock ?
'L' :
'U');
633 dsyslog(
"%5d invalid lock sequence: %s", ThreadId, Name);
636 dsyslog(
"--- end invalid lock sequence report");
637 dsyslog(
"--- THERE WILL BE NO FURTHER REPORTS UNTIL VDR IS RESTARTED!");
638 fprintf(stderr,
"invalid lock sequence at %s\n", *
DayDateTime(time(NULL)));
644 int n = *Name -
'0' - 1;
650 int AvailableIndex = -1;
651 for (
int i = 0; i <
threadIds.Size(); i++) {
660 if (AvailableIndex < 0) {
666 Index = AvailableIndex;
672 esyslog(
"ERROR: too many threads holding list locks at the same time - stopped logging locks!");
678 if ((
flags[Index] & ~b) < b)
680 else if ((
flags[Index] & b) == 0)
689 if (
flags[Index] == 0)
697 Dump(Name, ThreadId);
706#define dbglockseq(n, l, w) StateLockLog.Check(n, l, w)
708#define dbglockseq(n, l, w)
732 if (
rwLock.Lock(Write, TimeoutMs)) {
738 StateKey.
write =
true;
752 else if (TimeoutMs) {
757 static bool DoubleWriteLockReported =
false;
758 if (!DoubleWriteLockReported) {
759 dsyslog(
"WARNING: attempt to acquire write lock while already holding a write lock in the same thread - this may crash! (backtrace follows)");
761 DoubleWriteLockReported =
true;
771 esyslog(
"ERROR: cStateLock::Unlock() called with an unused key (tid=%d, lock=%s)",
threadId,
name);
776 esyslog(
"ERROR: cStateLock::Unlock() called without holding a write lock (tid=%d, lock=%s)",
threadId,
name);
787 if (StateKey.
write) {
788 StateKey.
write =
false;
801 esyslog(
"ERROR: cStateLock::SetSyncStateKey() called without holding a write lock (tid=%d, lock=%s)",
threadId,
name);
806 esyslog(
"ERROR: cStateLock::SetSyncStateKey() called with locked key (tid=%d, lock=%s)",
threadId,
name);
811 esyslog(
"ERROR: cStateLock::SetSyncStateKey() called twice (tid=%d, lock=%s)",
threadId,
name);
821 esyslog(
"ERROR: cStateLock::SetExplicitModify() called without holding a write lock (tid=%d, lock=%s)",
threadId,
name);
826 esyslog(
"ERROR: cStateLock::SetExplicitModify() called twice (tid=%d, lock=%s)",
threadId,
name);
836 esyslog(
"ERROR: cStateLock::SetModified() called without holding a write lock (tid=%d, lock=%s)",
threadId,
name);
857 esyslog(
"ERROR: cStateKey::~cStateKey() called without releasing the lock first (tid=%d, lock=%s, key=%p)",
stateLock->threadId,
stateLock->name,
this);
872 esyslog(
"ERROR: cStateKey::Remove() called without holding a lock (key=%p)",
this);
880 esyslog(
"ERROR: cStateKey::StateChanged() called without holding a lock (tid=%d, key=%p)",
cThread::ThreadId(),
this);
955 if ((
pid = fork()) < 0) {
962 const char *mode =
"w";
966 if (strcmp(Mode,
"r") == 0) {
971 if ((
f = fdopen(fd[1 - iopipe], mode)) == NULL) {
973 close(fd[1 - iopipe]);
978 int iofd = STDOUT_FILENO;
979 if (strcmp(Mode,
"w") == 0) {
984 if (dup2(fd[1 - iopipe], iofd) == -1) {
985 close(fd[1 - iopipe]);
989 int MaxPossibleFileDescriptors = getdtablesize();
990 for (
int i = STDERR_FILENO + 1; i < MaxPossibleFileDescriptors; i++)
992 if (execl(
"/bin/sh",
"sh",
"-c", Command, NULL) == -1) {
993 close(fd[1 - iopipe]);
1014 ret = waitpid(
pid, &status, WNOHANG);
1016 if (errno != EINTR && errno != ECHILD) {
1021 else if (ret ==
pid)
1030 else if (ret == -1 || !WIFEXITED(status))
1044 if ((pid = fork()) < 0) {
1051 if (waitpid(pid, &status, 0) < 0) {
1063 pid_t sid = setsid();
1067 int devnull = open(
"/dev/null", O_RDONLY);
1068 if (devnull < 0 || dup2(devnull, 0) < 0)
1071 int MaxPossibleFileDescriptors = getdtablesize();
1072 for (
int i = STDERR_FILENO + 1; i < MaxPossibleFileDescriptors; i++)
1074 if (execl(
"/bin/sh",
"sh",
"-c", Command, NULL) == -1)
static void BackTrace(cStringList &StringList, int Level=0, bool Mangled=false)
Produces a backtrace and stores it in the given StringList.
static cString GetCaller(int Level=0, bool Mangled=false)
Returns the caller at the given Level (or the immediate caller, if Level is 0).
static cString Demangle(char *s)
Demangles the function name in the given string and returns the converted version of s.
bool TimedWait(cMutex &Mutex, int TimeoutMs)
bool Wait(int TimeoutMs=0)
Waits at most TimeoutMs milliseconds for a call to Signal(), or forever if TimeoutMs is 0.
void Signal(void)
Signals a caller of Wait() that the condition it is waiting for is met.
static void SleepMs(int TimeoutMs)
Creates a cCondWait object and uses it to sleep for TimeoutMs milliseconds, immediately giving up the...
void Activate(void)
Activates the global I/O throttling mechanism.
void Release(void)
Releases the global I/O throttling mechanism.
static bool Engaged(void)
Returns true if any I/O throttling object is currently active.
cMutexLock(cMutex *Mutex=NULL)
bool Open(const char *Command, const char *Mode)
tThreadId writeLockThreadId
cRwLock(bool PreferWriter=false)
bool Lock(bool Write, int TimeoutMs=0)
cStateKey(bool IgnoreFirst=false)
Sets up a new state key.
void Remove(bool IncState=true)
Removes this key from the lock it was previously used with.
void Reset(void)
Resets the state of this key, so that the next call to a lock's Lock() function with this key will re...
bool StateChanged(void)
Returns true if this key is used for obtaining a write lock, and the lock's state differs from that o...
cVector< tThreadId > threadIds
uint8_t logCounter[SLL_THREADS][SLL_MAX_LIST]
void Check(const char *Name, bool Lock, bool Write=false)
tThreadId logThreadIds[SLL_SIZE]
void Dump(const char *Name, tThreadId ThreadId)
void SetExplicitModify(void)
If you have obtained a write lock on this lock, and you don't want its state to be automatically incr...
cStateLock(const char *Name=NULL)
void Unlock(cStateKey &StateKey, bool IncState=true)
Releases a lock that has been obtained by a previous call to Lock() with the given StateKey.
void SetSyncStateKey(cStateKey &StateKey)
Sets the given StateKey to be synchronized to the state of this lock.
void SetModified(void)
Sets this lock to have its state incremented when the current write lock state key is removed.
bool Lock(cStateKey &StateKey, bool Write=false, int TimeoutMs=0)
Tries to get a lock and returns true if successful.
static cString static cString vsprintf(const char *fmt, va_list &ap)
static cString sprintf(const char *fmt,...) __attribute__((format(printf
cThreadLock(cThread *Thread=NULL)
bool Lock(cThread *Thread)
void SetIOPriority(int Priority)
static void SetMainThreadId(void)
virtual void Action(void)=0
A derived cThread class must implement the code it wants to execute as a separate thread in this func...
void bool Start(void)
Sets the description of this thread, which will be used when logging starting or stopping of the thre...
void SetDescription(const char *Description,...) __attribute__((format(printf
void SetPriority(int Priority)
cThread(const char *Description=NULL, bool LowPriority=false)
Creates a new thread.
static void * StartThread(cThread *Thread)
void Cancel(int WaitSeconds=0)
Cancels the thread by first setting 'running' to false, so that the Action() loop can finish in an or...
static tThreadId mainThreadId
bool Active(void)
Checks whether the thread is still alive.
static tThreadId ThreadId(void)
uint64_t Elapsed(void) const
virtual void Append(T Data)
static bool GetAbsTime(struct timespec *Abstime, int MillisecondsFromNow)
#define dbglockseq(n, l, w)
#define THREAD_STOP_SLEEP
int SystemExec(const char *Command, bool Detached)
#define THREAD_STOP_TIMEOUT
static cStateLockLog StateLockLog