X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=bacula%2Fsrc%2Fdird%2Fjob.c;h=f26f2b369ca3a7f6ab633bfb557467c9b2a6b152;hb=7ebf8f564b27ca8448a9a7365ba73b130ae69c21;hp=b35be631d1f82cd4601cd02aa3f9d26002692be1;hpb=6a41e15944691f6428fdf667afd80ffb0e63e1c5;p=bacula%2Fbacula diff --git a/bacula/src/dird/job.c b/bacula/src/dird/job.c index b35be631d1..f26f2b369c 100644 --- a/bacula/src/dird/job.c +++ b/bacula/src/dird/job.c @@ -7,7 +7,7 @@ * Version $Id$ */ /* - Copyright (C) 2000-2003 Kern Sibbald and John Walker + Copyright (C) 2000-2004 Kern Sibbald and John Walker This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as @@ -31,54 +31,43 @@ /* Forward referenced subroutines */ static void *job_thread(void *arg); -static char *edit_run_codes(JCR *jcr, char *omsg, char *imsg); -static void release_resource_locks(JCR *jcr); -static int acquire_resource_locks(JCR *jcr); -#ifdef USE_SEMAPHORE -static void backoff_resource_locks(JCR *jcr, int count); -#endif +static void job_monitor_watchdog(watchdog_t *self); +static void job_monitor_destructor(watchdog_t *self); +static bool job_check_maxwaittime(JCR *control_jcr, JCR *jcr); +static bool job_check_maxruntime(JCR *control_jcr, JCR *jcr); /* Exported subroutines */ -void run_job(JCR *jcr); - /* Imported subroutines */ extern void term_scheduler(); extern void term_ua_server(); extern int do_backup(JCR *jcr); +extern int do_admin(JCR *jcr); extern int do_restore(JCR *jcr); extern int do_verify(JCR *jcr); -extern void backup_cleanup(void); -#ifdef USE_SEMAPHORE -static semlock_t job_lock; -static pthread_mutex_t mutex; -static pthread_cond_t resource_wait; -#else -/* Queue of jobs to be run */ -workq_t job_wq; /* our job work queue */ -#endif +/* Imported variables */ +extern time_t watchdog_time; + +jobq_t job_queue; void init_job_server(int max_workers) { int stat; -#ifdef USE_SEMAPHORE - if ((stat = sem_init(&job_lock, max_workers)) != 0) { - Emsg1(M_ABORT, 0, _("Could not init job lock: ERR=%s\n"), strerror(stat)); - } - if ((stat = pthread_mutex_init(&mutex, NULL)) != 0) { - Emsg1(M_ABORT, 0, _("Could not init resource mutex: ERR=%s\n"), strerror(stat)); - } - if ((stat = pthread_cond_init(&resource_wait, NULL)) != 0) { - Emsg1(M_ABORT, 0, _("Could not init resource wait: ERR=%s\n"), strerror(stat)); - } - -#else - if ((stat = workq_init(&job_wq, max_workers, job_thread)) != 0) { - Emsg1(M_ABORT, 0, _("Could not init job work queue: ERR=%s\n"), strerror(stat)); - } -#endif - return; + watchdog_t *wd; + + if ((stat = jobq_init(&job_queue, max_workers, job_thread)) != 0) { + Emsg1(M_ABORT, 0, _("Could not init job queue: ERR=%s\n"), strerror(stat)); + } + if ((wd = new_watchdog()) == NULL) { + Emsg0(M_ABORT, 0, _("Could not init job monitor watchdogs\n")); + } + wd->callback = job_monitor_watchdog; + wd->destructor = job_monitor_destructor; + wd->one_shot = false; + wd->interval = 60; + wd->data = new_control_jcr("*JobMonitor*", JT_SYSTEM); + register_watchdog(wd); } /* @@ -89,29 +78,25 @@ void init_job_server(int max_workers) void run_job(JCR *jcr) { int stat, errstat; -#ifdef USE_SEMAPHORE - pthread_t tid; -#else - workq_ele_t *work_item; -#endif - sm_check(__FILE__, __LINE__, True); + P(jcr->mutex); + sm_check(__FILE__, __LINE__, true); init_msg(jcr, jcr->messages); create_unique_job_name(jcr, jcr->job->hdr.name); + set_jcr_job_status(jcr, JS_Created); jcr->jr.SchedTime = jcr->sched_time; jcr->jr.StartTime = jcr->start_time; + jcr->jr.EndTime = 0; /* perhaps rescheduled, clear it */ jcr->jr.Type = jcr->JobType; jcr->jr.Level = jcr->JobLevel; jcr->jr.JobStatus = jcr->JobStatus; - strcpy(jcr->jr.Name, jcr->job->hdr.name); - strcpy(jcr->jr.Job, jcr->Job); + bstrncpy(jcr->jr.Name, jcr->job->hdr.name, sizeof(jcr->jr.Name)); + bstrncpy(jcr->jr.Job, jcr->Job, sizeof(jcr->jr.Job)); /* Initialize termination condition variable */ if ((errstat = pthread_cond_init(&jcr->term_wait, NULL)) != 0) { Jmsg1(jcr, M_FATAL, 0, _("Unable to init job cond variable: ERR=%s\n"), strerror(errstat)); - set_jcr_job_status(jcr, JS_ErrorTerminated); - free_jcr(jcr); - return; + goto bail_out; } /* @@ -121,12 +106,13 @@ void run_job(JCR *jcr) jcr->db=db_init_database(jcr, jcr->catalog->db_name, jcr->catalog->db_user, jcr->catalog->db_password, jcr->catalog->db_address, jcr->catalog->db_port, jcr->catalog->db_socket); - if (!db_open_database(jcr, jcr->db)) { - Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db)); - db_close_database(jcr, jcr->db); - set_jcr_job_status(jcr, JS_ErrorTerminated); - free_jcr(jcr); - return; + if (!jcr->db || !db_open_database(jcr, jcr->db)) { + Jmsg(jcr, M_FATAL, 0, _("Could not open database \"%s\".\n"), + jcr->catalog->db_name); + if (jcr->db) { + Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db)); + } + goto bail_out; } Dmsg0(50, "DB opened\n"); @@ -136,74 +122,84 @@ void run_job(JCR *jcr) jcr->jr.JobStatus = jcr->JobStatus; if (!db_create_job_record(jcr, jcr->db, &jcr->jr)) { Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db)); - db_close_database(jcr, jcr->db); - set_jcr_job_status(jcr, JS_ErrorTerminated); - free_jcr(jcr); - return; + goto bail_out; } jcr->JobId = jcr->jr.JobId; - ASSERT(jcr->jr.JobId > 0); - Dmsg4(30, "Created job record JobId=%d Name=%s Type=%c Level=%c\n", + Dmsg4(50, "Created job record JobId=%d Name=%s Type=%c Level=%c\n", jcr->JobId, jcr->Job, jcr->jr.Type, jcr->jr.Level); Dmsg0(200, "Add jrc to work queue\n"); -#ifdef USE_SEMAPHORE - if ((stat = pthread_create(&tid, NULL, job_thread, (void *)jcr)) != 0) { - Emsg1(M_ABORT, 0, _("Unable to create job thread: ERR=%s\n"), strerror(stat)); - } -#else /* Queue the job to be run */ - if ((stat = workq_add(&job_wq, (void *)jcr, &work_item, 0)) != 0) { - Emsg1(M_ABORT, 0, _("Could not add job to work queue: ERR=%s\n"), strerror(stat)); + if ((stat = jobq_add(&job_queue, jcr)) != 0) { + Jmsg(jcr, M_FATAL, 0, _("Could not add job queue: ERR=%s\n"), strerror(stat)); + goto bail_out; } - jcr->work_item = work_item; -#endif - Dmsg0(200, "Done run_job()\n"); + Dmsg0(100, "Done run_job()\n"); + + V(jcr->mutex); + return; + +bail_out: + set_jcr_job_status(jcr, JS_ErrorTerminated); + V(jcr->mutex); + return; + } + /* - * This is the engine called by workq_add() when we were pulled + * This is the engine called by jobq.c:jobq_add() when we were pulled * from the work queue. - * At this point, we are running in our own thread + * At this point, we are running in our own thread and all + * necessary resources are allocated -- see jobq.c */ static void *job_thread(void *arg) { - time_t now; JCR *jcr = (JCR *)arg; - pthread_detach(pthread_self()); - time(&now); - sm_check(__FILE__, __LINE__, True); - - if (!acquire_resource_locks(jcr)) { - set_jcr_job_status(jcr, JS_Cancelled); - } + jcr->my_thread_id = pthread_self(); + pthread_detach(jcr->my_thread_id); + sm_check(__FILE__, __LINE__, true); - Dmsg0(200, "=====Start Job=========\n"); - jcr->start_time = now; /* set the real start time */ - Dmsg2(200, "jcr->JobStatus=%d %c\n", jcr->JobStatus, (char)jcr->JobStatus); - if (job_cancelled(jcr)) { - update_job_end_record(jcr); - } else if (jcr->job->MaxStartDelay != 0 && jcr->job->MaxStartDelay < - (utime_t)(jcr->start_time - jcr->sched_time)) { - Jmsg(jcr, M_FATAL, 0, _("Job cancelled because max start delay time exceeded.\n")); - set_jcr_job_status(jcr, JS_Cancelled); - update_job_end_record(jcr); - } else { + for ( ;; ) { - /* Run Job */ + Dmsg0(200, "=====Start Job=========\n"); + jcr->start_time = time(NULL); /* set the real start time */ set_jcr_job_status(jcr, JS_Running); - if (jcr->job->RunBeforeJob) { - POOLMEM *before = get_pool_memory(PM_FNAME); - int status; - - before = edit_run_codes(jcr, before, jcr->job->RunBeforeJob); - status = run_program(before, 0, NULL); - free_pool_memory(before); - } - switch (jcr->JobType) { + if (job_canceled(jcr)) { + update_job_end_record(jcr); + } else if (jcr->job->MaxStartDelay != 0 && jcr->job->MaxStartDelay < + (utime_t)(jcr->start_time - jcr->sched_time)) { + Jmsg(jcr, M_FATAL, 0, _("Job canceled because max start delay time exceeded.\n")); + set_jcr_job_status(jcr, JS_Canceled); + update_job_end_record(jcr); + } else { + + /* Run Job */ + if (jcr->job->RunBeforeJob) { + POOLMEM *before = get_pool_memory(PM_FNAME); + int status; + BPIPE *bpipe; + char line[MAXSTRING]; + + before = edit_job_codes(jcr, before, jcr->job->RunBeforeJob, ""); + bpipe = open_bpipe(before, 0, "r"); + free_pool_memory(before); + while (fgets(line, sizeof(line), bpipe->rfd)) { + Jmsg(jcr, M_INFO, 0, _("RunBefore: %s"), line); + } + status = close_bpipe(bpipe); + if (status != 0) { + Jmsg(jcr, M_FATAL, 0, _("RunBeforeJob returned non-zero status=%d\n"), + status); + set_jcr_job_status(jcr, JS_FatalError); + update_job_end_record(jcr); + goto bail_out; + } + } + switch (jcr->JobType) { case JT_BACKUP: do_backup(jcr); if (jcr->JobStatus == JS_Terminated) { @@ -223,126 +219,296 @@ static void *job_thread(void *arg) } break; case JT_ADMIN: - /* No actual job */ - do_autoprune(jcr); - set_jcr_job_status(jcr, JS_Terminated); + do_admin(jcr); + if (jcr->JobStatus == JS_Terminated) { + do_autoprune(jcr); + } break; default: Pmsg1(0, "Unimplemented job type: %d\n", jcr->JobType); break; } - if (jcr->job->RunAfterJob) { - POOLMEM *after = get_pool_memory(PM_FNAME); - int status; - - after = edit_run_codes(jcr, after, jcr->job->RunAfterJob); - status = run_program(after, 0, NULL); - free_pool_memory(after); + if ((jcr->job->RunAfterJob && jcr->JobStatus == JS_Terminated) || + (jcr->job->RunAfterFailedJob && jcr->JobStatus != JS_Terminated)) { + POOLMEM *after = get_pool_memory(PM_FNAME); + int status; + BPIPE *bpipe; + char line[MAXSTRING]; + + if (jcr->JobStatus == JS_Terminated) { + after = edit_job_codes(jcr, after, jcr->job->RunAfterJob, ""); + } else { + after = edit_job_codes(jcr, after, jcr->job->RunAfterFailedJob, ""); + } + bpipe = open_bpipe(after, 0, "r"); + free_pool_memory(after); + while (fgets(line, sizeof(line), bpipe->rfd)) { + Jmsg(jcr, M_INFO, 0, _("RunAfter: %s"), line); + } + status = close_bpipe(bpipe); + /* + * Note, if we get an error here, do not mark the + * job in error, simply report the error condition. + */ + if (status != 0) { + if (jcr->JobStatus == JS_Terminated) { + Jmsg(jcr, M_WARNING, 0, _("RunAfterJob returned non-zero status=%d\n"), + status); + } else { + Jmsg(jcr, M_FATAL, 0, _("RunAfterFailedJob returned non-zero status=%d\n"), + status); + } + } + } + /* Send off any queued messages */ + if (jcr->msg_queue->size() > 0) { + dequeue_messages(jcr); + } } +bail_out: + break; } - release_resource_locks(jcr); - Dmsg0(50, "Before free jcr\n"); - free_jcr(jcr); + Dmsg0(50, "======== End Job ==========\n"); - sm_check(__FILE__, __LINE__, True); + sm_check(__FILE__, __LINE__, true); return NULL; } -static int acquire_resource_locks(JCR *jcr) -{ -#ifdef USE_SEMAPHORE - int stat; - if (jcr->store->sem.valid != SEMLOCK_VALID) { - if ((stat = sem_init(&jcr->store->sem, jcr->store->MaxConcurrentJobs)) != 0) { - Emsg1(M_ABORT, 0, _("Could not init Storage semaphore: ERR=%s\n"), strerror(stat)); - } - } - if (jcr->client->sem.valid != SEMLOCK_VALID) { - if ((stat = sem_init(&jcr->client->sem, jcr->client->MaxConcurrentJobs)) != 0) { - Emsg1(M_ABORT, 0, _("Could not init Client semaphore: ERR=%s\n"), strerror(stat)); - } - } - if (jcr->job->sem.valid != SEMLOCK_VALID) { - if ((stat = sem_init(&jcr->job->sem, jcr->job->MaxConcurrentJobs)) != 0) { - Emsg1(M_ABORT, 0, _("Could not init Job semaphore: ERR=%s\n"), strerror(stat)); +/* + * Cancel a job -- typically called by the UA (Console program), but may also + * be called by the job watchdog. + * + * Returns: 1 if cancel appears to be successful + * 0 on failure. Message sent to ua->jcr. + */ +int cancel_job(UAContext *ua, JCR *jcr) +{ + BSOCK *sd, *fd; + + switch (jcr->JobStatus) { + case JS_Created: + case JS_WaitJobRes: + case JS_WaitClientRes: + case JS_WaitStoreRes: + case JS_WaitPriority: + case JS_WaitMaxJobs: + case JS_WaitStartTime: + set_jcr_job_status(jcr, JS_Canceled); + bsendmsg(ua, _("JobId %d, Job %s marked to be canceled.\n"), + jcr->JobId, jcr->Job); + jobq_remove(&job_queue, jcr); /* attempt to remove it from queue */ + return 1; + + default: + set_jcr_job_status(jcr, JS_Canceled); + + /* Cancel File daemon */ + if (jcr->file_bsock) { + ua->jcr->client = jcr->client; + if (!connect_to_file_daemon(ua->jcr, 10, FDConnectTimeout, 1)) { + bsendmsg(ua, _("Failed to connect to File daemon.\n")); + return 0; + } + Dmsg0(200, "Connected to file daemon\n"); + fd = ua->jcr->file_bsock; + bnet_fsend(fd, "cancel Job=%s\n", jcr->Job); + while (bnet_recv(fd) >= 0) { + bsendmsg(ua, "%s", fd->msg); + } + bnet_sig(fd, BNET_TERMINATE); + bnet_close(fd); + ua->jcr->file_bsock = NULL; } - } - for ( ;; ) { - /* Acquire semaphore */ - set_jcr_job_status(jcr, JS_WaitJobRes); - if ((stat = sem_lock(&jcr->job->sem)) != 0) { - Emsg1(M_ABORT, 0, _("Could not acquire Job max jobs lock: ERR=%s\n"), strerror(stat)); - } - set_jcr_job_status(jcr, JS_WaitClientRes); - if ((stat = sem_trylock(&jcr->client->sem)) != 0) { - if (stat == EBUSY) { - backoff_resource_locks(jcr, 1); - goto wait; - } else { - Emsg1(M_ABORT, 0, _("Could not acquire Client max jobs lock: ERR=%s\n"), strerror(stat)); + /* Cancel Storage daemon */ + if (jcr->store_bsock) { + ua->jcr->store = jcr->store; + if (!connect_to_storage_daemon(ua->jcr, 10, SDConnectTimeout, 1)) { + bsendmsg(ua, _("Failed to connect to Storage daemon.\n")); + return 0; } - } - set_jcr_job_status(jcr, JS_WaitStoreRes); - if ((stat = sem_trylock(&jcr->store->sem)) != 0) { - if (stat == EBUSY) { - backoff_resource_locks(jcr, 2); - goto wait; - } else { - Emsg1(M_ABORT, 0, _("Could not acquire Storage max jobs lock: ERR=%s\n"), strerror(stat)); + Dmsg0(200, "Connected to storage daemon\n"); + sd = ua->jcr->store_bsock; + bnet_fsend(sd, "cancel Job=%s\n", jcr->Job); + while (bnet_recv(sd) >= 0) { + bsendmsg(ua, "%s", sd->msg); } + bnet_sig(sd, BNET_TERMINATE); + bnet_close(sd); + ua->jcr->store_bsock = NULL; } - set_jcr_job_status(jcr, JS_WaitMaxJobs); - if ((stat = sem_trylock(&job_lock)) != 0) { - if (stat == EBUSY) { - backoff_resource_locks(jcr, 3); - goto wait; - } else { - Emsg1(M_ABORT, 0, _("Could not acquire max jobs lock: ERR=%s\n"), strerror(stat)); - } + } + + return 1; +} + + +static void job_monitor_destructor(watchdog_t *self) +{ + JCR *control_jcr = (JCR *) self->data; + + free_jcr(control_jcr); +} + +static void job_monitor_watchdog(watchdog_t *self) +{ + JCR *control_jcr, *jcr; + + control_jcr = (JCR *)self->data; + + Dmsg1(400, "job_monitor_watchdog %p called\n", self); + + lock_jcr_chain(); + + foreach_jcr(jcr) { + bool cancel; + + if (jcr->JobId == 0) { + Dmsg2(400, "Skipping JCR %p (%s) with JobId 0\n", + jcr, jcr->Job); + /* Keep reference counts correct */ + free_locked_jcr(jcr); + continue; } - break; -wait: - P(mutex); - /* Wait for some resource to be released */ - pthread_cond_wait(&resource_wait, &mutex); - V(mutex); - /* Try again */ + /* check MaxWaitTime */ + cancel = job_check_maxwaittime(control_jcr, jcr); + + /* check MaxRunTime */ + cancel |= job_check_maxruntime(control_jcr, jcr); + + if (cancel) { + Dmsg3(200, "Cancelling JCR %p jobid %d (%s)\n", + jcr, jcr->JobId, jcr->Job); + + UAContext *ua = new_ua_context(jcr); + ua->jcr = control_jcr; + cancel_job(ua, jcr); + free_ua_context(ua); + + Dmsg1(200, "Have cancelled JCR %p\n", jcr); + } + + /* Keep reference counts correct */ + free_locked_jcr(jcr); } -#endif - return 1; + unlock_jcr_chain(); } -#ifdef USE_SEMAPHORE -static void backoff_resource_locks(JCR *jcr, int count) +/* + * Check if the maxwaittime has expired and it is possible + * to cancel the job. + */ +static bool job_check_maxwaittime(JCR *control_jcr, JCR *jcr) { - switch (count) { - case 3: - sem_unlock(&jcr->store->sem); - case 2: - sem_unlock(&jcr->client->sem); - case 1: - sem_unlock(&jcr->job->sem); + bool cancel = false; + + if (jcr->job->MaxWaitTime == 0) { + return false; + } + if ((watchdog_time - jcr->start_time) < jcr->job->MaxWaitTime) { + Dmsg3(200, "Job %p (%s) with MaxWaitTime %d not expired\n", + jcr, jcr->Job, jcr->job->MaxWaitTime); + return false; + } + Dmsg3(200, "Job %d (%s): MaxWaitTime of %d seconds exceeded, " + "checking status\n", + jcr->JobId, jcr->Job, jcr->job->MaxWaitTime); + switch (jcr->JobStatus) { + case JS_Created: + case JS_Blocked: + case JS_WaitFD: + case JS_WaitSD: + case JS_WaitStoreRes: + case JS_WaitClientRes: + case JS_WaitJobRes: + case JS_WaitPriority: + case JS_WaitMaxJobs: + case JS_WaitStartTime: + cancel = true; + Dmsg0(200, "JCR blocked in #1\n"); break; + case JS_Running: + Dmsg0(200, "JCR running, checking SD status\n"); + switch (jcr->SDJobStatus) { + case JS_WaitMount: + case JS_WaitMedia: + case JS_WaitFD: + cancel = true; + Dmsg0(200, "JCR blocked in #2\n"); + break; + default: + Dmsg0(200, "JCR not blocked in #2\n"); + break; + } + break; + case JS_Terminated: + case JS_ErrorTerminated: + case JS_Canceled: + case JS_FatalError: + Dmsg0(200, "JCR already dead in #3\n"); + break; + default: + Jmsg1(jcr, M_ERROR, 0, _("Unhandled job status code %d\n"), + jcr->JobStatus); } + Dmsg3(200, "MaxWaitTime result: %scancel JCR %p (%s)\n", + cancel ? "" : "do not ", jcr, jcr->job); + + return cancel; } -#endif -static void release_resource_locks(JCR *jcr) +/* + * Check if maxruntime has expired and if the job can be + * canceled. + */ +static bool job_check_maxruntime(JCR *control_jcr, JCR *jcr) { -#ifdef USE_SEMAPHORE - P(mutex); - sem_unlock(&jcr->store->sem); - sem_unlock(&jcr->client->sem); - sem_unlock(&jcr->job->sem); - sem_unlock(&job_lock); - pthread_cond_signal(&resource_wait); - V(mutex); -#endif + bool cancel = false; + + if (jcr->job->MaxRunTime == 0) { + return false; + } + if ((watchdog_time - jcr->start_time) < jcr->job->MaxRunTime) { + Dmsg3(200, "Job %p (%s) with MaxRunTime %d not expired\n", + jcr, jcr->Job, jcr->job->MaxRunTime); + return false; + } + + switch (jcr->JobStatus) { + case JS_Created: + case JS_Running: + case JS_Blocked: + case JS_WaitFD: + case JS_WaitSD: + case JS_WaitStoreRes: + case JS_WaitClientRes: + case JS_WaitJobRes: + case JS_WaitPriority: + case JS_WaitMaxJobs: + case JS_WaitStartTime: + case JS_Differences: + cancel = true; + break; + case JS_Terminated: + case JS_ErrorTerminated: + case JS_Canceled: + case JS_FatalError: + cancel = false; + break; + default: + Jmsg1(jcr, M_ERROR, 0, _("Unhandled job status code %d\n"), + jcr->JobStatus); + } + + Dmsg3(200, "MaxRunTime result: %scancel JCR %p (%s)\n", + cancel ? "" : "do not ", jcr, jcr->job); + + return cancel; } + /* * Get or create a Client record for this Job */ @@ -351,27 +517,25 @@ int get_or_create_client_record(JCR *jcr) CLIENT_DBR cr; memset(&cr, 0, sizeof(cr)); - strcpy(cr.Name, jcr->client->hdr.name); + bstrncpy(cr.Name, jcr->client->hdr.name, sizeof(cr.Name)); cr.AutoPrune = jcr->client->AutoPrune; cr.FileRetention = jcr->client->FileRetention; cr.JobRetention = jcr->client->JobRetention; - if (jcr->client_name) { - free_pool_memory(jcr->client_name); + if (!jcr->client_name) { + jcr->client_name = get_pool_memory(PM_NAME); } - jcr->client_name = get_memory(strlen(jcr->client->hdr.name) + 1); - strcpy(jcr->client_name, jcr->client->hdr.name); + pm_strcpy(&jcr->client_name, jcr->client->hdr.name); if (!db_create_client_record(jcr, jcr->db, &cr)) { - Jmsg(jcr, M_FATAL, 0, _("Could not create Client record. %s"), + Jmsg(jcr, M_FATAL, 0, _("Could not create Client record. ERR=%s\n"), db_strerror(jcr->db)); return 0; } jcr->jr.ClientId = cr.ClientId; if (cr.Uname[0]) { - if (jcr->client_uname) { - free_pool_memory(jcr->client_uname); + if (!jcr->client_uname) { + jcr->client_uname = get_pool_memory(PM_NAME); } - jcr->client_uname = get_memory(strlen(cr.Uname) + 1); - strcpy(jcr->client_uname, cr.Uname); + pm_strcpy(&jcr->client_uname, cr.Uname); } Dmsg2(100, "Created Client %s record %d\n", jcr->client->hdr.name, jcr->jr.ClientId); @@ -424,7 +588,7 @@ void create_unique_job_name(JCR *jcr, char *base_name) P(mutex); /* lock creation of jobs */ now = time(NULL); while (now == last_start_time) { - sleep(1); + bmicrosleep(0, 500000); now = time(NULL); } last_start_time = now; @@ -436,7 +600,7 @@ void create_unique_job_name(JCR *jcr, char *base_name) strftime(dt, sizeof(dt), "%Y-%m-%d_%H.%M.%S", &tm); bstrncpy(name, base_name, sizeof(name)); name[sizeof(name)-22] = 0; /* truncate if too long */ - sprintf(jcr->Job, "%s.%s", name, dt); /* add date & time */ + bsnprintf(jcr->Job, sizeof(jcr->Job), "%s.%s", name, dt); /* add date & time */ /* Convert spaces into underscores */ for (p=jcr->Job; *p; p++) { if (*p == ' ') { @@ -454,32 +618,43 @@ void dird_free_jcr(JCR *jcr) { Dmsg0(200, "Start dird free_jcr\n"); + if (jcr->sd_auth_key) { + free(jcr->sd_auth_key); + jcr->sd_auth_key = NULL; + } + if (jcr->where) { + free(jcr->where); + jcr->where = NULL; + } if (jcr->file_bsock) { Dmsg0(200, "Close File bsock\n"); bnet_close(jcr->file_bsock); + jcr->file_bsock = NULL; } if (jcr->store_bsock) { Dmsg0(200, "Close Store bsock\n"); bnet_close(jcr->store_bsock); + jcr->store_bsock = NULL; } if (jcr->fname) { Dmsg0(200, "Free JCR fname\n"); free_pool_memory(jcr->fname); + jcr->fname = NULL; } if (jcr->stime) { Dmsg0(200, "Free JCR stime\n"); free_pool_memory(jcr->stime); - } - if (jcr->db) { - Dmsg0(200, "Close DB\n"); - db_close_database(jcr, jcr->db); - } - if (jcr->RestoreWhere) { - free(jcr->RestoreWhere); + jcr->stime = NULL; } if (jcr->RestoreBootstrap) { free(jcr->RestoreBootstrap); + jcr->RestoreBootstrap = NULL; + } + if (jcr->client_uname) { + free_pool_memory(jcr->client_uname); + jcr->client_uname = NULL; } + pthread_cond_destroy(&jcr->term_wait); Dmsg0(200, "End dird free_jcr\n"); } @@ -494,20 +669,33 @@ void set_jcr_defaults(JCR *jcr, JOB *job) { jcr->job = job; jcr->JobType = job->JobType; - jcr->JobLevel = job->level; + switch (jcr->JobType) { + case JT_ADMIN: + case JT_RESTORE: + jcr->JobLevel = L_NONE; + break; + default: + jcr->JobLevel = job->level; + break; + } + jcr->JobPriority = job->Priority; jcr->store = job->storage; jcr->client = job->client; - if (jcr->client_name) { - free_pool_memory(jcr->client_name); + if (!jcr->client_name) { + jcr->client_name = get_pool_memory(PM_NAME); } - jcr->client_name = get_memory(strlen(jcr->client->hdr.name) + 1); - strcpy(jcr->client_name, jcr->client->hdr.name); + pm_strcpy(&jcr->client_name, jcr->client->hdr.name); jcr->pool = job->pool; + jcr->full_pool = job->full_pool; + jcr->inc_pool = job->inc_pool; + jcr->dif_pool = job->dif_pool; jcr->catalog = job->client->catalog; jcr->fileset = job->fileset; jcr->messages = job->messages; + jcr->spool_data = job->spool_data; if (jcr->RestoreBootstrap) { free(jcr->RestoreBootstrap); + jcr->RestoreBootstrap = NULL; } /* This can be overridden by Console program */ if (job->RestoreBootstrap) { @@ -522,85 +710,12 @@ void set_jcr_defaults(JCR *jcr, JOB *job) case JT_BACKUP: jcr->JobLevel = L_INCREMENTAL; break; + case JT_RESTORE: + case JT_ADMIN: + jcr->JobLevel = L_NONE; + break; default: break; } } } - -/* - * Edit codes into Run command - * %% = % - * %c = Client's name - * %d = Director's name - * %i = JobId - * %e = Job Exit - * %j = Job - * %l = Job Level - * %n = Job name - * %t = Job type - * - * omsg = edited output message - * imsg = input string containing edit codes (%x) - * - */ -static char *edit_run_codes(JCR *jcr, char *omsg, char *imsg) -{ - char *p; - const char *str; - char add[20]; - - *omsg = 0; - Dmsg1(200, "edit_run_codes: %s\n", imsg); - for (p=imsg; *p; p++) { - if (*p == '%') { - switch (*++p) { - case '%': - str = "%"; - break; - case 'c': - str = jcr->client_name; - if (!str) { - str = ""; - } - break; - case 'd': - str = my_name; - break; - case 'e': - str = job_status_to_str(jcr->JobStatus); - break; - case 'i': - sprintf(add, "%d", jcr->JobId); - str = add; - break; - case 'j': /* Job */ - str = jcr->Job; - break; - case 'l': - str = job_level_to_str(jcr->JobLevel); - break; - case 'n': - str = jcr->job->hdr.name; - break; - case 't': - str = job_type_to_str(jcr->JobType); - break; - default: - add[0] = '%'; - add[1] = *p; - add[2] = 0; - str = add; - break; - } - } else { - add[0] = *p; - add[1] = 0; - str = add; - } - Dmsg1(200, "add_str %s\n", str); - pm_strcat(&omsg, (char *)str); - Dmsg1(200, "omsg=%s\n", omsg); - } - return omsg; -}