X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=bacula%2Fsrc%2Fstored%2Fjob.c;h=431071c582e0dc321414fabbad707ea26f9c5f97;hb=706490171cd2e5458defa3e4abfeca745d19d1f3;hp=0e76449a552c2ec6918b986daf167421acfd1ee0;hpb=28a45733fdb9131af7db083f5e40a44e173c679d;p=bacula%2Fbacula diff --git a/bacula/src/stored/job.c b/bacula/src/stored/job.c index 0e76449a55..431071c582 100644 --- a/bacula/src/stored/job.c +++ b/bacula/src/stored/job.c @@ -1,55 +1,67 @@ /* - * Job control and execution for Storage Daemon - * - * Version $Id$ - * - */ -/* - Copyright (C) 2000-2003 Kern Sibbald and John Walker + Bacula® - The Network Backup Solution - 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. + Copyright (C) 2000-2008 Free Software Foundation Europe e.V. - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of + 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 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 FileSetMD5=%127s " - "SpoolData=%d"; -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[] = "3914 Device \"%s\" not in SD Device resources.\n"; -static char BAD_use[] = "3913 Bad use command: %s\n"; -static char BAD_job[] = "3915 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 @@ -61,50 +73,52 @@ static char BAD_job[] = "3915 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, *fileset_md5; + POOL_MEM job_name, client_name, job, fileset_name, fileset_md5; int JobType, level, spool_attributes, no_attributes, spool_data; - struct timeval tv; - struct timezone tz; - struct timespec timeout; + int write_part_after_job, PreferMountedVols; + int stat; JCR *ojcr; /* * Get JobId and permissions from Director */ - - Dmsg1(100, "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); - fileset_md5 = get_memory(dir->msglen); - if (sscanf(dir->msg, jobcmd, &JobId, job, job_name, client_name, - &JobType, &level, fileset_name, &no_attributes, - &spool_attributes, fileset_md5, &spool_data) != 11) { - pm_strcpy(&jcr->errmsg, dir->msg); - bnet_fsend(dir, BAD_job, jcr->errmsg); - Emsg1(M_FATAL, 0, _("Bad Job Command from Director: %s\n"), jcr->errmsg); - free_memory(job); - free_memory(job_name); - free_memory(client_name); - free_memory(fileset_name); - free_memory(fileset_md5); - set_jcr_job_status(jcr, 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); + 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); + Dmsg2(100, "Found ojcr=0x%x Job %s\n", (unsigned)(long)ojcr, job.c_str()); free_jcr(ojcr); } jcr->JobId = JobId; @@ -113,102 +127,124 @@ int job_cmd(JCR *jcr) bstrncpy(jcr->Job, job, sizeof(jcr->Job)); unbash_spaces(job_name); jcr->job_name = get_pool_memory(PM_NAME); - pm_strcpy(&jcr->job_name, job_name); + pm_strcpy(jcr->job_name, job_name); unbash_spaces(client_name); jcr->client_name = get_pool_memory(PM_NAME); - pm_strcpy(&jcr->client_name, client_name); + pm_strcpy(jcr->client_name, client_name); unbash_spaces(fileset_name); jcr->fileset_name = get_pool_memory(PM_NAME); - pm_strcpy(&jcr->fileset_name, fileset_name); - jcr->JobType = JobType; - jcr->JobLevel = level; + 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; 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); - free_memory(job); - free_memory(job_name); - free_memory(client_name); - free_memory(fileset_name); - free_memory(fileset_md5); + 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 */ - make_session_key(auth_key, NULL, 1); - 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)); + 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)) { - set_jcr_job_status(jcr, JS_ErrorTerminated); - memset(jcr->sd_auth_key, 0, strlen(jcr->sd_auth_key)); - return 0; + if (!jcr->need_fd) { + do_mac(jcr); + return false; } - set_jcr_job_status(jcr, 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(100, "%s waiting on FD to contact SD\n", jcr->Job); /* * 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(jcr->mutex); - for ( ;!job_canceled(jcr); ) { - errstat = pthread_cond_timedwait(&jcr->job_start_wait, &jcr->mutex, &timeout); - if (errstat == 0 || errstat == ETIMEDOUT) { - break; + 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_canceled(jcr)) { Dmsg1(100, "Running job %s\n", jcr->Job); - run_job(jcr); /* Run the job */ + run_job(jcr); /* Run the job */ } - return 0; + return false; } /* - * After receiving a connection (in job.c) if it is + * After receiving a connection (in dircmd.c) if it is * from the File daemon, this routine is called. - */ + */ void handle_filed_connection(BSOCK *fd, char *job_name) { JCR *jcr; - bmicrosleep(0, 50000); /* wait 50 millisecs */ +/* + * 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); - Dmsg1(100, "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 = jcr; + jcr->file_bsock->set_jcr(jcr); Dmsg1(110, "Found Job %s\n", job_name); if (jcr->authenticated) { - Pmsg2(000, "Hey!!!! JobId %u 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,123 +252,103 @@ 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) { 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) { - Jmsg0(jcr, 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(); - if (verbose) { - unbash_spaces(dir->msg); - pm_strcpy(&jcr->errmsg, dir->msg); - Jmsg(jcr, M_INFO, 0, _("Failed command: %s\n"), jcr->errmsg); + 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; + } } - Jmsg(jcr, M_FATAL, 0, _("\n" - " Device \"%s\" requested by Dir not found in SD Device resources.\n"), - dev_name); - bnet_fsend(dir, NO_device, dev_name); + /* 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 { unbash_spaces(dir->msg); - pm_strcpy(&jcr->errmsg, dir->msg); - if (verbose) { - Jmsg(jcr, M_INFO, 0, _("Failed command: %s\n"), jcr->errmsg); - } - Jmsg(jcr, M_FATAL, 0, _("Bad Use Device command: %s\n"), jcr->errmsg); - bnet_fsend(dir, BAD_use, jcr->errmsg); + 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); + jcr->file_bsock->close(); jcr->file_bsock = NULL; } - 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); - } if (jcr->job_name) { free_pool_memory(jcr->job_name); } @@ -355,13 +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; }