/*
Bacula® - The Network Backup Solution
- Copyright (C) 2000-2007 Free Software Foundation Europe e.V.
+ Copyright (C) 2000-2008 Free Software Foundation Europe e.V.
The main author of Bacula is Kern Sibbald, with contributions from
many others, a complete list can be found in the file AUTHORS.
This program is Free Software; you can redistribute it and/or
modify it under the terms of version two of the GNU General Public
- License as published by the Free Software Foundation plus additions
- that are listed in the file LICENSE.
+ License as published by the Free Software Foundation and included
+ in the file LICENSE.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.
- Bacula® is a registered trademark of John Walker.
+ Bacula® is a registered trademark of Kern Sibbald.
The licensor of Bacula is the Free Software Foundation Europe
(FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
Switzerland, email:ftf@fsfeurope.org.
#include <grp.h>
#endif
+#ifdef HAVE_AIX_OS
+extern "C" int initgroups(const char *,int);
+#endif
+
+
static pthread_mutex_t timer_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t timer = PTHREAD_COND_INITIALIZER;
* to recall this routine if he/she REALLY wants to sleep the
* requested time.
*/
-int bmicrosleep(time_t sec, long usec)
+int bmicrosleep(int32_t sec, int32_t usec)
{
struct timespec timeout;
struct timeval tv;
timeout.tv_sec++;
}
- Dmsg2(200, "pthread_cond_timedwait sec=%d usec=%d\n", sec, usec);
+ Dmsg2(200, "pthread_cond_timedwait sec=%lld usec=%d\n", sec, usec);
/* Note, this unlocks mutex during the sleep */
P(timer_mutex);
stat = pthread_cond_timedwait(&timer, &timer_mutex, &timeout);
return stat;
}
-/*
- * These are mutex routines that do error checking
- * for deadlock and such. Normally not turned on.
- */
-#ifdef DEBUG_MUTEX
-void _p(char *file, int line, pthread_mutex_t *m)
-{
- int errstat;
- if ((errstat = pthread_mutex_trylock(m))) {
- e_msg(file, line, M_ERROR, 0, _("Possible mutex deadlock.\n"));
- /* We didn't get the lock, so do it definitely now */
- if ((errstat=pthread_mutex_lock(m))) {
- berrno be;
- e_msg(file, line, M_ABORT, 0, _("Mutex lock failure. ERR=%s\n"),
- be.bstrerror(errstat));
- } else {
- e_msg(file, line, M_ERROR, 0, _("Possible mutex deadlock resolved.\n"));
- }
-
- }
-}
-
-void _v(char *file, int line, pthread_mutex_t *m)
-{
- int errstat;
-
- /* Note, this trylock *should* fail if the mutex is locked */
- if ((errstat=pthread_mutex_trylock(m)) == 0) {
- berrno be;
- e_msg(file, line, M_ERROR, 0, _("Mutex unlock not locked. ERR=%s\n"),
- be.bstrerror(errstat));
- }
- if ((errstat=pthread_mutex_unlock(m))) {
- berrno be;
- e_msg(file, line, M_ABORT, 0, _("Mutex unlock failure. ERR=%s\n"),
- be.bstrerror(errstat));
- }
-}
-
-#else
-
-void _p(pthread_mutex_t *m)
-{
- int errstat;
- if ((errstat=pthread_mutex_lock(m))) {
- berrno be;
- e_msg(__FILE__, __LINE__, M_ABORT, 0, _("Mutex lock failure. ERR=%s\n"),
- be.bstrerror(errstat));
- }
-}
-
-void _v(pthread_mutex_t *m)
-{
- int errstat;
- if ((errstat=pthread_mutex_unlock(m))) {
- berrno be;
- e_msg(__FILE__, __LINE__, M_ABORT, 0, _("Mutex unlock failure. ERR=%s\n"),
- be.bstrerror(errstat));
- }
-}
-
-#endif /* DEBUG_MUTEX */
-
#ifdef DEBUG_MEMSET
/* These routines are not normally turned on */
#undef memset
if ((pidfd = open(fname, O_RDONLY|O_BINARY, 0)) < 0 ||
read(pidfd, &pidbuf, sizeof(pidbuf)) < 0 ||
sscanf(pidbuf, "%d", &oldpid) != 1) {
- Emsg2(M_ERROR_TERM, 0, _("Cannot open pid file. %s ERR=%s\n"), fname, strerror(errno));
+ berrno be;
+ Emsg2(M_ERROR_TERM, 0, _("Cannot open pid file. %s ERR=%s\n"), fname,
+ be.bstrerror());
}
/* Some OSes (IRIX) don't bother to clean out the old pid files after a crash, and
* since they use a deterministic algorithm for assigning PIDs, we can have
close(pidfd);
del_pid_file_ok = TRUE; /* we created it so we can delete it */
} else {
- Emsg2(M_ERROR_TERM, 0, _("Could not open pid file. %s ERR=%s\n"), fname, strerror(errno));
+ berrno be;
+ Emsg2(M_ERROR_TERM, 0, _("Could not open pid file. %s ERR=%s\n"), fname,
+ be.bstrerror());
}
free_pool_memory(fname);
#endif
static struct s_state_hdr state_hdr = {
"Bacula State\n",
- 3,
+ 4,
0
};
/* If file exists, see what we have */
// Dmsg1(10, "O_BINARY=%d\n", O_BINARY);
if ((sfd = open(fname, O_RDONLY|O_BINARY)) < 0) {
+ berrno be;
Dmsg3(010, "Could not open state file. sfd=%d size=%d: ERR=%s\n",
- sfd, sizeof(hdr), strerror(errno));
+ sfd, sizeof(hdr), be.bstrerror());
goto bail_out;
}
if ((stat=read(sfd, &hdr, hdr_size)) != hdr_size) {
+ berrno be;
Dmsg4(010, "Could not read state file. sfd=%d stat=%d size=%d: ERR=%s\n",
- sfd, (int)stat, hdr_size, strerror(errno));
+ sfd, (int)stat, hdr_size, be.bstrerror());
goto bail_out;
}
if (hdr.version != state_hdr.version) {