X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=bacula%2Fsrc%2Fstored%2Fjob.c;h=431071c582e0dc321414fabbad707ea26f9c5f97;hb=706490171cd2e5458defa3e4abfeca745d19d1f3;hp=f32535f0d9d2c27ef213f07ed5d3553d1f3d7970;hpb=f52955c3e03b6fef083df5b77ce25a75213e2539;p=bacula%2Fbacula diff --git a/bacula/src/stored/job.c b/bacula/src/stored/job.c index f32535f0d9..431071c582 100644 --- a/bacula/src/stored/job.c +++ b/bacula/src/stored/job.c @@ -1,54 +1,67 @@ /* - * Job control and execution for Storage Daemon - * - * Version $Id$ - * - */ -/* - Copyright (C) 2000, 2001, 2002 Kern Sibbald and John Walker + Bacula® - The Network Backup Solution + + Copyright (C) 2000-2008 Free Software Foundation Europe e.V. - This program is free software; you can redistribute it and/or - modify it under the terms of the GNU General Public License as - published by the Free Software Foundation; either version 2 of - the License, or (at your option) any later version. + 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 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 + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. - You should have received a copy of the GNU General Public - License along with this program; if not, write to the Free - Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, - MA 02111-1307, USA. + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + 02110-1301, USA. + 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. +*/ +/* + * Job control and execution for Storage Daemon + * + * Kern Sibbald, MM + * + * Version $Id$ + * */ #include "bacula.h" #include "stored.h" +static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; + /* Imported variables */ extern uint32_t VolSessionTime; /* Imported functions */ extern uint32_t newVolSessionId(); - -/* Forward referenced functions */ -static int use_device_cmd(JCR *jcr); +extern bool do_mac(JCR *jcr); /* Requests from the Director daemon */ -static char jobcmd[] = "JobId=%d job=%127s job_name=%127s client_name=%127s \ -type=%d level=%d FileSet=%127s NoAttr=%d SpoolAttr=%d\n"; -static char use_device[] = "use device=%s media_type=%s pool_name=%s pool_type=%s\n"; +static char jobcmd[] = "JobId=%d job=%127s job_name=%127s client_name=%127s " + "type=%d level=%d FileSet=%127s NoAttr=%d SpoolAttr=%d FileSetMD5=%127s " + "SpoolData=%d WritePartAfterJob=%d PreferMountedVols=%d SpoolSize=%s\n"; +static char oldjobcmd[] = "JobId=%d job=%127s job_name=%127s client_name=%127s " + "type=%d level=%d FileSet=%127s NoAttr=%d SpoolAttr=%d FileSetMD5=%127s " + "SpoolData=%d WritePartAfterJob=%d PreferMountedVols=%d\n"; -/* Responses sent to Director daemon */ -static char OKjob[] = "3000 OK Job SDid=%u SDtime=%u Authorization=%s\n"; -static char OK_device[] = "3000 OK use device\n"; -static char NO_device[] = "3904 Device %s not available\n"; -static char BAD_use[] = "3903 Bad use command: %s\n"; -static char BAD_job[] = "3905 Bad Job command: %s\n"; +/* Responses sent to Director daemon */ +static char OKjob[] = "3000 OK Job SDid=%u SDtime=%u Authorization=%s\n"; +static char BAD_job[] = "3915 Bad Job command. stat=%d CMD: %s\n"; +//static char OK_query[] = "3001 OK query\n"; +//static char NO_query[] = "3918 Query failed\n"; +//static char BAD_query[] = "3917 Bad query command: %s\n"; /* * Director requests us to start a job @@ -60,155 +73,178 @@ static char BAD_job[] = "3905 Bad Job command: %s\n"; * - Return when the connection is terminated or * there is an error. */ -int job_cmd(JCR *jcr) +bool job_cmd(JCR *jcr) { - int JobId, errstat; + int JobId; char auth_key[100]; + char spool_size[30]; + char seed[100]; BSOCK *dir = jcr->dir_bsock; - POOLMEM *job_name, *client_name, *job, *fileset_name; - int JobType, level, spool_attributes, no_attributes; - struct timeval tv; - struct timezone tz; - struct timespec timeout; + POOL_MEM job_name, client_name, job, fileset_name, fileset_md5; + int JobType, level, spool_attributes, no_attributes, spool_data; + int write_part_after_job, PreferMountedVols; + int stat; + JCR *ojcr; /* * Get JobId and permissions from Director */ - - Dmsg1(130, "Job_cmd: %s\n", dir->msg); - job = get_memory(dir->msglen); - job_name = get_memory(dir->msglen); - client_name = get_memory(dir->msglen); - fileset_name = get_memory(dir->msglen); - if (sscanf(dir->msg, jobcmd, &JobId, job, job_name, client_name, - &JobType, &level, fileset_name, &no_attributes, - &spool_attributes) != 9) { - bnet_fsend(dir, BAD_job, dir->msg); - Emsg1(M_FATAL, 0, _("Bad Job Command from Director: %s\n"), dir->msg); - free_memory(job); - free_memory(job_name); - free_memory(client_name); - free_memory(fileset_name); - jcr->JobStatus = JS_ErrorTerminated; - return 0; + Dmsg1(100, "msg); + bstrncpy(spool_size, "0", sizeof(spool_size)); + stat = sscanf(dir->msg, jobcmd, &JobId, job.c_str(), job_name.c_str(), + client_name.c_str(), + &JobType, &level, fileset_name.c_str(), &no_attributes, + &spool_attributes, fileset_md5.c_str(), &spool_data, + &write_part_after_job, &PreferMountedVols, spool_size); + if (stat != 14) { + /* Try old version */ + stat = sscanf(dir->msg, oldjobcmd, &JobId, job.c_str(), job_name.c_str(), + client_name.c_str(), + &JobType, &level, fileset_name.c_str(), &no_attributes, + &spool_attributes, fileset_md5.c_str(), &spool_data, + &write_part_after_job, &PreferMountedVols); + if (stat != 13) { + pm_strcpy(jcr->errmsg, dir->msg); + dir->fsend(BAD_job, stat, jcr->errmsg); + Dmsg1(100, ">dird: %s", dir->msg); + set_jcr_job_status(jcr, JS_ErrorTerminated); + return false; + } + } + /* + * Since this job could be rescheduled, we + * check to see if we have it already. If so + * free the old jcr and use the new one. + */ + ojcr = get_jcr_by_full_name(job.c_str()); + if (ojcr && !ojcr->authenticated) { + Dmsg2(100, "Found ojcr=0x%x Job %s\n", (unsigned)(long)ojcr, job.c_str()); + free_jcr(ojcr); } jcr->JobId = JobId; jcr->VolSessionId = newVolSessionId(); jcr->VolSessionTime = VolSessionTime; - strcpy(jcr->Job, job); + bstrncpy(jcr->Job, job, sizeof(jcr->Job)); unbash_spaces(job_name); - jcr->job_name = get_memory(strlen(job_name) + 1); - strcpy(jcr->job_name, job_name); + jcr->job_name = get_pool_memory(PM_NAME); + pm_strcpy(jcr->job_name, job_name); unbash_spaces(client_name); - jcr->client_name = get_memory(strlen(client_name) + 1); - strcpy(jcr->client_name, client_name); + jcr->client_name = get_pool_memory(PM_NAME); + pm_strcpy(jcr->client_name, client_name); unbash_spaces(fileset_name); - jcr->fileset_name = get_memory(strlen(fileset_name) + 1); - strcpy(jcr->fileset_name, fileset_name); - jcr->JobType = JobType; - jcr->JobLevel = level; + jcr->fileset_name = get_pool_memory(PM_NAME); + pm_strcpy(jcr->fileset_name, fileset_name); + jcr->set_JobType(JobType); + jcr->set_JobLevel(level); jcr->no_attributes = no_attributes; jcr->spool_attributes = spool_attributes; - free_memory(job); - free_memory(job_name); - free_memory(client_name); - free_memory(fileset_name); - - /* Initialize FD start condition variable */ - if ((errstat = pthread_cond_init(&jcr->job_start_wait, NULL)) != 0) { - Emsg1(M_FATAL, 0, _("Unable to init job cond variable: ERR=%s\n"), strerror(errstat)); - jcr->JobStatus = JS_ErrorTerminated; - return 0; - } - jcr->authenticated = FALSE; + jcr->spool_data = spool_data; + jcr->spool_size = str_to_int64(spool_size); + jcr->write_part_after_job = write_part_after_job; + jcr->fileset_md5 = get_pool_memory(PM_NAME); + pm_strcpy(jcr->fileset_md5, fileset_md5); + jcr->PreferMountedVols = PreferMountedVols; + + jcr->authenticated = false; + jcr->need_fd = true; /* * Pass back an authorization key for the File daemon */ - gettimeofday(&tv, &tz); - srandom(tv.tv_usec + tv.tv_sec); - sprintf(auth_key, "%ld", (long)random()); - bnet_fsend(dir, OKjob, jcr->VolSessionId, jcr->VolSessionTime, auth_key); - Dmsg1(110, ">dird: %s", dir->msg); + bsnprintf(seed, sizeof(seed), "%p%d", jcr, JobId); + make_session_key(auth_key, seed, 1); + dir->fsend(OKjob, jcr->VolSessionId, jcr->VolSessionTime, auth_key); + Dmsg2(100, ">dird jid=%u: %s", (uint32_t)jcr->JobId, dir->msg); jcr->sd_auth_key = bstrdup(auth_key); + memset(auth_key, 0, sizeof(auth_key)); + generate_daemon_event(jcr, "JobStart"); + return true; +} - /* - * Wait for the device, media, and pool information +bool run_cmd(JCR *jcr) +{ + struct timeval tv; + struct timezone tz; + struct timespec timeout; + int errstat = 0; + + Dsm_check(1); + Dmsg1(200, "Run_cmd: %s\n", jcr->dir_bsock->msg); + + /* If we do not need the FD, we are doing a migrate, copy, or virtual + * backup. */ - if (!use_device_cmd(jcr)) { - jcr->JobStatus = JS_ErrorTerminated; - return 0; + if (!jcr->need_fd) { + do_mac(jcr); + return false; } - jcr->JobStatus = JS_WaitFD; /* wait for FD to connect */ + set_jcr_job_status(jcr, JS_WaitFD); /* wait for FD to connect */ dir_send_job_status(jcr); gettimeofday(&tv, &tz); - timeout.tv_nsec = tv.tv_usec * 1000; - timeout.tv_sec = tv.tv_sec + 30 * 60; /* wait 30 minutes */ + timeout.tv_nsec = tv.tv_usec * 1000; + timeout.tv_sec = tv.tv_sec + me->client_wait; + Dmsg3(050, "%s waiting %d sec for FD to contact SD key=%s\n", + jcr->Job, (int)(timeout.tv_sec-time(NULL)), jcr->sd_auth_key); - Dmsg1(200, "%s waiting on job_start_wait\n", jcr->Job); - P(jcr->mutex); - for ( ;!job_cancelled(jcr); ) { - errstat = pthread_cond_timedwait(&jcr->job_start_wait, &jcr->mutex, &timeout); - if (errstat == 0 || errstat == ETIMEDOUT) { - break; + /* + * Wait for the File daemon to contact us to start the Job, + * when he does, we will be released, unless the 30 minutes + * expires. + */ + P(mutex); + while ( !jcr->authenticated && !job_canceled(jcr) ) { + errstat = pthread_cond_timedwait(&jcr->job_start_wait, &mutex, &timeout); + if (errstat == ETIMEDOUT || errstat == EINVAL || errstat == EPERM) { + break; } } - V(jcr->mutex); + Dmsg3(100, "Auth=%d canceled=%d errstat=%d\n", jcr->authenticated, + job_canceled(jcr), errstat); + V(mutex); + + memset(jcr->sd_auth_key, 0, strlen(jcr->sd_auth_key)); - if (jcr->authenticated && !job_cancelled(jcr)) { - run_job(jcr); /* Run the job */ + if (jcr->authenticated && !job_canceled(jcr)) { + Dmsg1(100, "Running job %s\n", jcr->Job); + run_job(jcr); /* Run the job */ } - return 0; + return false; } /* - * This entry point is only called if we have a separate - * Storage Daemon Data port. Otherwise, the connection - * is made to the main port, and if it is a File daemon - * calling, handl_filed_connection() is called directly. + * After receiving a connection (in dircmd.c) if it is + * from the File daemon, this routine is called. */ -void connection_from_filed(void *arg) -{ - BSOCK *fd = (BSOCK *)arg; - char job_name[MAX_NAME_LENGTH]; - - Dmsg0(110, "enter connection_from_filed\n"); - if (bnet_recv(fd) <= 0) { - Emsg0(M_FATAL, 0, _("Unable to authenticate Client.\n")); - return; - } - Dmsg1(100, "got: %s\n", fd->msg); - - if (sscanf(fd->msg, "Hello Start Job %127s\n", job_name) != 1) { - Emsg1(M_FATAL, 0, _("Authentication failure: %s\n"), fd->msg); - return; - } - handle_filed_connection(fd, job_name); - return; -} - void handle_filed_connection(BSOCK *fd, char *job_name) { JCR *jcr; +/* + * With the following bmicrosleep on, running the + * SD under the debugger fails. + */ +// bmicrosleep(0, 50000); /* wait 50 millisecs */ if (!(jcr=get_jcr_by_full_name(job_name))) { - Jmsg1(NULL, M_FATAL, 0, _("Job name not found: %s\n"), job_name); + Jmsg1(NULL, M_FATAL, 0, _("FD connect failed: Job name not found: %s\n"), job_name); + Dmsg1(3, "**** Job \"%s\" not found.\n", job_name); return; } jcr->file_bsock = fd; - jcr->file_bsock->jcr = (void *)jcr; + jcr->file_bsock->set_jcr(jcr); Dmsg1(110, "Found Job %s\n", job_name); if (jcr->authenticated) { - Pmsg2(000, "Hey!!!! JobId %d Job %s already authenticated.\n", - jcr->JobId, jcr->Job); + Jmsg2(jcr, M_FATAL, 0, _("Hey!!!! JobId %u Job %s already authenticated.\n"), + (uint32_t)jcr->JobId, jcr->Job); + free_jcr(jcr); + return; } - + /* * Authenticate the File daemon */ @@ -216,110 +252,102 @@ void handle_filed_connection(BSOCK *fd, char *job_name) Dmsg1(100, "Authentication failed Job %s\n", jcr->Job); Jmsg(jcr, M_FATAL, 0, _("Unable to authenticate File daemon\n")); } else { - jcr->authenticated = TRUE; - Dmsg1(110, "OK Authentication Job %s\n", jcr->Job); + jcr->authenticated = true; + Dmsg2(110, "OK Authentication jid=%u Job %s\n", (uint32_t)jcr->JobId, jcr->Job); } - P(jcr->mutex); if (!jcr->authenticated) { - jcr->JobStatus = JS_ErrorTerminated; + set_jcr_job_status(jcr, JS_ErrorTerminated); } pthread_cond_signal(&jcr->job_start_wait); /* wake waiting job */ - V(jcr->mutex); free_jcr(jcr); return; } -/* - * Use Device command from Director - * He tells is what Device Name to use, the Media Type, - * the Pool Name, and the Pool Type. +#ifdef needed +/* + * Query Device command from Director + * Sends Storage Daemon's information on the device to the + * caller (presumably the Director). + * This command always returns "true" so that the line is + * not closed on an error. * - * Ensure that the device exists and is opened, then store - * the media and pool info in the JCR. */ -static int use_device_cmd(JCR *jcr) +bool query_cmd(JCR *jcr) { - POOLMEM *dev_name, *media_type, *pool_name, *pool_type; + POOL_MEM dev_name, VolumeName, MediaType, ChangerName; BSOCK *dir = jcr->dir_bsock; DEVRES *device; + AUTOCHANGER *changer; + bool ok; - if (bnet_recv(dir) <= 0) { - Emsg0(M_FATAL, 0, "No Device from Director\n"); - return 0; - } - - Dmsg1(120, "Use device: %s", dir->msg); - dev_name = get_memory(dir->msglen); - media_type = get_memory(dir->msglen); - pool_name = get_memory(dir->msglen); - pool_type = get_memory(dir->msglen); - if (sscanf(dir->msg, use_device, dev_name, media_type, pool_name, pool_type) == 4) { + Dmsg1(100, "Query_cmd: %s", dir->msg); + ok = sscanf(dir->msg, query_device, dev_name.c_str()) == 1; + Dmsg1(100, "msg); + if (ok) { unbash_spaces(dev_name); - unbash_spaces(media_type); - unbash_spaces(pool_name); - unbash_spaces(pool_type); - device = NULL; - LockRes(); - while ((device=(DEVRES *)GetNextRes(R_DEVICE, (RES *)device))) { - /* Find resource, and make sure we were able to open it */ - if (strcmp(device->hdr.name, dev_name) == 0 && device->dev) { - Dmsg1(120, "Found device %s\n", device->hdr.name); - jcr->pool_name = get_memory(strlen(pool_name) + 1); - strcpy(jcr->pool_name, pool_name); - jcr->pool_type = get_memory(strlen(pool_type) + 1); - strcpy(jcr->pool_type, pool_type); - jcr->media_type = get_memory(strlen(media_type) + 1); - strcpy(jcr->media_type, media_type); - jcr->dev_name = get_memory(strlen(dev_name) + 1); - strcpy(jcr->dev_name, dev_name); - jcr->device = device; - Dmsg4(120, use_device, dev_name, media_type, pool_name, pool_type); - free_memory(dev_name); - free_memory(media_type); - free_memory(pool_name); - free_memory(pool_type); - UnlockRes(); - return bnet_fsend(dir, OK_device); - } + foreach_res(device, R_DEVICE) { + /* Find resource, and make sure we were able to open it */ + if (strcmp(dev_name.c_str(), device->hdr.name) == 0) { + if (!device->dev) { + device->dev = init_dev(jcr, device); + } + if (!device->dev) { + break; + } + ok = dir_update_device(jcr, device->dev); + if (ok) { + ok = dir->fsend(OK_query); + } else { + dir->fsend(NO_query); + } + return ok; + } } - UnlockRes(); - Jmsg(jcr, M_FATAL, 0, _("Requested device %s not found. Cannot continue.\n"), - dev_name); - bnet_fsend(dir, NO_device, dev_name); + foreach_res(changer, R_AUTOCHANGER) { + /* Find resource, and make sure we were able to open it */ + if (strcmp(dev_name.c_str(), changer->hdr.name) == 0) { + if (!changer->device || changer->device->size() == 0) { + continue; /* no devices */ + } + ok = dir_update_changer(jcr, changer); + if (ok) { + ok = dir->fsend(OK_query); + } else { + dir->fsend(NO_query); + } + return ok; + } + } + /* If we get here, the device/autochanger was not found */ + unbash_spaces(dir->msg); + pm_strcpy(jcr->errmsg, dir->msg); + dir->fsend(NO_device, dev_name.c_str()); + Dmsg1(100, ">dird: %s\n", dir->msg); } else { - Jmsg(jcr, M_FATAL, 0, _("storemsg); - bnet_fsend(dir, BAD_use, dir->msg); + unbash_spaces(dir->msg); + pm_strcpy(jcr->errmsg, dir->msg); + dir->fsend(BAD_query, jcr->errmsg); + Dmsg1(100, ">dird: %s\n", dir->msg); } - free_memory(dev_name); - free_memory(media_type); - free_memory(pool_name); - free_memory(pool_type); - return 0; /* ERROR return */ + return true; } -/* +#endif + + +/* * Destroy the Job Control Record and associated * resources (sockets). */ -void stored_free_jcr(JCR *jcr) +void stored_free_jcr(JCR *jcr) { + Dmsg1(900, "stored_free_jcr JobId=%u\n", jcr->JobId); if (jcr->file_bsock) { - bnet_close(jcr->file_bsock); - } - if (jcr->pool_name) { - free_memory(jcr->pool_name); - } - if (jcr->pool_type) { - free_memory(jcr->pool_type); - } - if (jcr->media_type) { - free_memory(jcr->media_type); - } - if (jcr->dev_name) { - free_memory(jcr->dev_name); + jcr->file_bsock->close(); + jcr->file_bsock = NULL; } if (jcr->job_name) { free_pool_memory(jcr->job_name); @@ -331,6 +359,9 @@ void stored_free_jcr(JCR *jcr) if (jcr->fileset_name) { free_memory(jcr->fileset_name); } + if (jcr->fileset_md5) { + free_memory(jcr->fileset_md5); + } if (jcr->bsr) { free_bsr(jcr->bsr); jcr->bsr = NULL; @@ -340,9 +371,50 @@ void stored_free_jcr(JCR *jcr) free_pool_memory(jcr->RestoreBootstrap); jcr->RestoreBootstrap = NULL; } - if (jcr->next_dev && jcr->prev_dev) { + if (jcr->next_dev || jcr->prev_dev) { Emsg0(M_FATAL, 0, _("In free_jcr(), but still attached to device!!!!\n")); } - + pthread_cond_destroy(&jcr->job_start_wait); + if (jcr->dcrs) { + delete jcr->dcrs; + } + jcr->dcrs = NULL; + + /* Avoid a double free */ + if (jcr->dcr == jcr->read_dcr) { + jcr->read_dcr = NULL; + } + if (jcr->dcr) { + free_dcr(jcr->dcr); + jcr->dcr = NULL; + } + if (jcr->read_dcr) { + free_dcr(jcr->read_dcr); + jcr->read_dcr = NULL; + } + + if (jcr->read_store) { + DIRSTORE *store; + foreach_alist(store, jcr->read_store) { + delete store->device; + delete store; + } + delete jcr->read_store; + jcr->read_store = NULL; + } + if (jcr->write_store) { + DIRSTORE *store; + foreach_alist(store, jcr->write_store) { + delete store->device; + delete store; + } + delete jcr->write_store; + jcr->write_store = NULL; + } + Dsm_check(1); + + if (jcr->JobId != 0) + write_state_file(me->working_directory, "bacula-sd", get_first_port_host_order(me->sdaddrs)); + return; }