git.sur5r.net Git - bacula/bacula/blob - bacula/src/stored/acquire.c

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2002-2008 Free Software Foundation Europe e.V.
   5
   6    The main author of Bacula is Kern Sibbald, with contributions from
   7    many others, a complete list can be found in the file AUTHORS.
   8    This program is Free Software; you can redistribute it and/or
   9    modify it under the terms of version two of the GNU General Public
  10    License as published by the Free Software Foundation and included
  11    in the file LICENSE.
  12
  13    This program is distributed in the hope that it will be useful, but
  14    WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16    General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21    02110-1301, USA.
  22
  23    Bacula® is a registered trademark of Kern Sibbald.
  24    The licensor of Bacula is the Free Software Foundation Europe
  25    (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
  26    Switzerland, email:ftf@fsfeurope.org.
  27 */
  28 /*
  29  *  Routines to acquire and release a device for read/write
  30  *
  31  *   Kern Sibbald, August MMII
  32  *
  33  *   Version $Id$
  34  */
  35
  36 #include "bacula.h"                   /* pull in global headers */
  37 #include "stored.h"                   /* pull in Storage Deamon headers */
  38
  39 /* Forward referenced functions */
  40 static void attach_dcr_to_dev(DCR *dcr);
  41 static void set_dcr_from_vol(DCR *dcr, VOL_LIST *vol);
  42
  43
  44 /*********************************************************************
  45  * Acquire device for reading.
  46  *  The drive should have previously been reserved by calling
  47  *  reserve_device_for_read(). We read the Volume label from the block and
  48  *  leave the block pointers just after the label.
  49  *
  50  *  Returns: NULL if failed for any reason
  51  *           dcr  if successful
  52  */
  53 bool acquire_device_for_read(DCR *dcr)
  54 {
  55    DEVICE *dev = dcr->dev;
  56    JCR *jcr = dcr->jcr;
  57    bool ok = false;
  58    bool tape_previously_mounted;
  59    bool tape_initially_mounted;
  60    VOL_LIST *vol;
  61    bool try_autochanger = true;
  62    int i;
  63    int vol_label_status;
  64    int retry = 0;
  65
  66    Dmsg1(950, "jcr->dcr=%p\n", jcr->dcr);
  67    dev->dblock(BST_DOING_ACQUIRE);
  68
  69    if (dev->num_writers > 0) {
  70       Jmsg2(jcr, M_FATAL, 0, _("Acquire read: num_writers=%d not zero. Job %d canceled.\n"),
  71          dev->num_writers, jcr->JobId);
  72       goto get_out;
  73    }
  74
  75    /* Find next Volume, if any */
  76    vol = jcr->VolList;
  77    if (!vol) {
  78       char ed1[50];
  79       Jmsg(jcr, M_FATAL, 0, _("No volumes specified for reading. Job %s canceled.\n"),
  80          edit_int64(jcr->JobId, ed1));
  81       goto get_out;
  82    }
  83    jcr->CurReadVolume++;
  84    for (i=1; i<jcr->CurReadVolume; i++) {
  85       vol = vol->next;
  86    }
  87    if (!vol) {
  88       Jmsg(jcr, M_FATAL, 0, _("Logic error: no next volume to read. Numvol=%d Curvol=%d\n"),
  89          jcr->NumReadVolumes, jcr->CurReadVolume);
  90       goto get_out;                   /* should not happen */
  91    }
  92    set_dcr_from_vol(dcr, vol);
  93
  94    Dmsg2(100, "Want Vol=%s Slot=%d\n", vol->VolumeName, vol->Slot);
  95
  96    /*
  97     * If the MediaType requested for this volume is not the
  98     *  same as the current drive, we attempt to find the same
  99     *  device that was used to write the orginal volume.  If
 100     *  found, we switch to using that device.
 101     *
 102     *  N.B. A lot of routines rely on the dcr pointer not changing
 103     *    read_records.c even has multiple dcrs cached, so we take care
 104     *    here to release all important parts of the dcr and re-acquire
 105     *    them such as the block pointer (size may change), but we do
 106     *    not release the dcr.
 107     */
 108    Dmsg2(50, "MediaType dcr=%s dev=%s\n", dcr->media_type, dev->device->media_type);
 109    if (dcr->media_type[0] && strcmp(dcr->media_type, dev->device->media_type) != 0) {
 110       RCTX rctx;
 111       DIRSTORE *store;
 112       int stat;
 113
 114       Jmsg3(jcr, M_INFO, 0, _("Changing read device. Want Media Type=\"%s\" have=\"%s\"\n"
 115                               "  device=%s\n"),
 116             dcr->media_type, dev->device->media_type, dev->print_name());
 117       Dmsg3(50, "Changing read device. Want Media Type=\"%s\" have=\"%s\"\n"
 118                               "  device=%s\n",
 119             dcr->media_type, dev->device->media_type, dev->print_name());
 120
 121       dev->dunblock(DEV_UNLOCKED);
 122
 123       lock_reservations();
 124       memset(&rctx, 0, sizeof(RCTX));
 125       rctx.jcr = jcr;
 126       jcr->reserve_msgs = New(alist(10, not_owned_by_alist));
 127       rctx.any_drive = true;
 128       rctx.device_name = vol->device;
 129       store = new DIRSTORE;
 130       memset(store, 0, sizeof(DIRSTORE));
 131       store->name[0] = 0; /* No dir name */
 132       bstrncpy(store->media_type, vol->MediaType, sizeof(store->media_type));
 133       bstrncpy(store->pool_name, dcr->pool_name, sizeof(store->pool_name));
 134       bstrncpy(store->pool_type, dcr->pool_type, sizeof(store->pool_type));
 135       store->append = false;
 136       rctx.store = store;
 137       clean_device(dcr);                     /* clean up the dcr */
 138
 139       /*
 140        * Search for a new device
 141        */
 142       stat = search_res_for_device(rctx);
 143       release_reserve_messages(jcr);         /* release queued messages */
 144       unlock_reservations();
 145
 146       if (stat == 1) {
 147          dev = dcr->dev;                     /* get new device pointer */
 148          dev->dblock(BST_DOING_ACQUIRE);
 149          dcr->VolumeName[0] = 0;
 150          Jmsg(jcr, M_INFO, 0, _("Media Type change.  New read device %s chosen.\n"),
 151             dev->print_name());
 152          Dmsg1(50, "Media Type change.  New read device %s chosen.\n", dev->print_name());
 153
 154          bstrncpy(dcr->VolumeName, vol->VolumeName, sizeof(dcr->VolumeName));
 155          bstrncpy(dcr->VolCatInfo.VolCatName, vol->VolumeName, sizeof(dcr->VolCatInfo.VolCatName));
 156          bstrncpy(dcr->media_type, vol->MediaType, sizeof(dcr->media_type));
 157          dcr->VolCatInfo.Slot = vol->Slot;
 158          dcr->VolCatInfo.InChanger = vol->Slot > 0;
 159          bstrncpy(dcr->pool_name, store->pool_name, sizeof(dcr->pool_name));
 160          bstrncpy(dcr->pool_type, store->pool_type, sizeof(dcr->pool_type));
 161       } else {
 162          /* error */
 163          Jmsg1(jcr, M_FATAL, 0, _("No suitable device found to read Volume \"%s\"\n"),
 164             vol->VolumeName);
 165          Dmsg1(50, "No suitable device found to read Volume \"%s\"\n", vol->VolumeName);
 166          goto get_out;
 167       }
 168    }
 169
 170    dev->clear_unload();
 171
 172    if (dev->vol && dev->vol->is_swapping()) {
 173       dev->vol->set_slot(vol->Slot);
 174       Dmsg3(100, "swapping: slot=%d Vol=%s dev=%s\n", dev->vol->get_slot(),
 175          dev->vol->vol_name, dev->print_name());
 176    }
 177
 178    init_device_wait_timers(dcr);
 179
 180    tape_previously_mounted = dev->can_read() || dev->can_append() ||
 181                              dev->is_labeled();
 182    tape_initially_mounted = tape_previously_mounted;
 183
 184
 185    /* Volume info is always needed because of VolParts */
 186    Dmsg1(150, "dir_get_volume_info vol=%s\n", dcr->VolumeName);
 187    if (!dir_get_volume_info(dcr, GET_VOL_INFO_FOR_READ)) {
 188       Dmsg2(150, "dir_get_vol_info failed for vol=%s: %s\n",
 189          dcr->VolumeName, jcr->errmsg);
 190       Jmsg1(jcr, M_WARNING, 0, "Read acquire: %s", jcr->errmsg);
 191    }
 192    dev->set_load();                /* set to load volume */
 193
 194    for ( ;; ) {
 195       /* If not polling limit retries */
 196       if (!dev->poll && retry++ > 10) {
 197          break;
 198       }
 199       dev->clear_labeled();              /* force reread of label */
 200       if (job_canceled(jcr)) {
 201          char ed1[50];
 202          Mmsg1(dev->errmsg, _("Job %s canceled.\n"), edit_int64(jcr->JobId, ed1));
 203          Jmsg(jcr, M_INFO, 0, dev->errmsg);
 204          goto get_out;                /* error return */
 205       }
 206
 207       dcr->do_unload();
 208       dcr->do_swapping(false/*!is_writing*/);
 209       dcr->do_load(false /*!is_writing*/);
 210       set_dcr_from_vol(dcr, vol);          /* refresh dcr with desired volume info */
 211
 212       /*
 213        * This code ensures that the device is ready for
 214        * reading. If it is a file, it opens it.
 215        * If it is a tape, it checks the volume name
 216        */
 217       Dmsg1(100, "bstored: open vol=%s\n", dcr->VolumeName);
 218       if (dev->open(dcr, OPEN_READ_ONLY) < 0) {
 219          if (!dev->poll) {
 220             Jmsg3(jcr, M_WARNING, 0, _("Read open device %s Volume \"%s\" failed: ERR=%s\n"),
 221                   dev->print_name(), dcr->VolumeName, dev->bstrerror());
 222          }
 223          goto default_path;
 224       }
 225       Dmsg1(50, "opened dev %s OK\n", dev->print_name());
 226
 227       /* Read Volume Label */
 228       Dmsg0(50, "calling read-vol-label\n");
 229       vol_label_status = read_dev_volume_label(dcr);
 230       switch (vol_label_status) {
 231       case VOL_OK:
 232          Dmsg0(50, "Got correct volume.\n");
 233          ok = true;
 234          dev->VolCatInfo = dcr->VolCatInfo;     /* structure assignment */
 235          break;                    /* got it */
 236       case VOL_IO_ERROR:
 237          Dmsg0(50, "IO Error\n");
 238          /*
 239           * Send error message generated by read_dev_volume_label()
 240           *  only we really had a tape mounted. This supresses superfluous
 241           *  error messages when nothing is mounted.
 242           */
 243          if (tape_previously_mounted) {
 244             Jmsg(jcr, M_WARNING, 0, "Read acquire: %s", jcr->errmsg);
 245          }
 246          goto default_path;
 247       case VOL_NAME_ERROR:
 248          Dmsg0(50, "Vol name error.\n");
 249          if (dev->is_volume_to_unload()) {
 250             goto default_path;
 251          }
 252          dev->set_unload();              /* force unload of unwanted tape */
 253          if (!unload_autochanger(dcr, -1)) {
 254             /* at least free the device so we can re-open with correct volume */
 255             dev->close();
 256          }
 257          dev->set_load();
 258          /* Fall through */
 259       default:
 260          Jmsg1(jcr, M_WARNING, 0, "Read acquire: %s", jcr->errmsg);
 261 default_path:
 262          Dmsg0(50, "default path\n");
 263          tape_previously_mounted = true;
 264
 265          /*
 266           * If the device requires mount, close it, so the device can be ejected.
 267           */
 268          if (dev->requires_mount()) {
 269             dev->close();
 270          }
 271
 272          /* Call autochanger only once unless ask_sysop called */
 273          if (try_autochanger) {
 274             int stat;
 275             Dmsg2(200, "calling autoload Vol=%s Slot=%d\n",
 276                dcr->VolumeName, dcr->VolCatInfo.Slot);
 277             stat = autoload_device(dcr, 0, NULL);
 278             if (stat > 0) {
 279                try_autochanger = false;
 280                continue;              /* try reading volume mounted */
 281             }
 282          }
 283
 284          /* Mount a specific volume and no other */
 285          Dmsg0(200, "calling dir_ask_sysop\n");
 286          if (!dir_ask_sysop_to_mount_volume(dcr, ST_READ)) {
 287             goto get_out;             /* error return */
 288          }
 289          try_autochanger = true;      /* permit trying the autochanger again */
 290          continue;                    /* try reading again */
 291       } /* end switch */
 292       break;
 293    } /* end for loop */
 294
 295    if (!ok) {
 296       Jmsg1(jcr, M_FATAL, 0, _("Too many errors trying to mount device %s for reading.\n"),
 297             dev->print_name());
 298       goto get_out;
 299    }
 300
 301    dev->clear_append();
 302    dev->set_read();
 303    set_jcr_job_status(jcr, JS_Running);
 304    dir_send_job_status(jcr);
 305    Jmsg(jcr, M_INFO, 0, _("Ready to read from volume \"%s\" on device %s.\n"),
 306       dcr->VolumeName, dev->print_name());
 307
 308 get_out:
 309    dev->dlock();
 310    dcr->clear_reserved();
 311    /*
 312     * Normally we are blocked, but in at least one error case above
 313     *   we are not blocked because we unsuccessfully tried changing
 314     *   devices.
 315     */
 316    if (dev->is_blocked()) {
 317       dev->dunblock(DEV_LOCKED);
 318    } else {
 319       dev->dunlock();               /* dunblock() unlock the device too */
 320    }
 321    Dmsg1(950, "jcr->dcr=%p\n", jcr->dcr);
 322    return ok;
 323 }
 324
 325
 326 /*
 327  * Acquire device for writing. We permit multiple writers.
 328  *  If this is the first one, we read the label.
 329  *
 330  *  Returns: NULL if failed for any reason
 331  *           dcr if successful.
 332  *   Note, normally reserve_device_for_append() is called
 333  *   before this routine.
 334  */
 335 DCR *acquire_device_for_append(DCR *dcr)
 336 {
 337    DEVICE *dev = dcr->dev;
 338    JCR *jcr = dcr->jcr;
 339    bool ok = false;
 340    bool have_vol = false;
 341
 342    init_device_wait_timers(dcr);
 343
 344    dev->dblock(BST_DOING_ACQUIRE);
 345    Dmsg1(100, "acquire_append device is %s\n", dev->is_tape()?"tape":
 346         (dev->is_dvd()?"DVD":"disk"));
 347
 348    /*
 349     * With the reservation system, this should not happen
 350     */
 351    if (dev->can_read()) {
 352       Jmsg1(jcr, M_FATAL, 0, _("Want to append, but device %s is busy reading.\n"), dev->print_name());
 353       Dmsg1(200, "Want to append but device %s is busy reading.\n", dev->print_name());
 354       goto get_out;
 355    }
 356
 357    dev->clear_unload();
 358
 359    /*
 360     * have_vol defines whether or not mount_next_write_volume should
 361     *   ask the Director again about what Volume to use.
 362     */
 363    if (dev->can_append() && dcr->is_suitable_volume_mounted() &&
 364        strcmp(dcr->VolCatInfo.VolCatStatus, "Recycle") != 0) {
 365       Dmsg0(190, "device already in append.\n");
 366       /*
 367        * At this point, the correct tape is already mounted, so
 368        *   we do not need to do mount_next_write_volume(), unless
 369        *   we need to recycle the tape.
 370        */
 371        if (dev->num_writers == 0) {
 372           memcpy(&dev->VolCatInfo, &dcr->VolCatInfo, sizeof(dev->VolCatInfo));
 373        }
 374        have_vol = dcr->is_tape_position_ok();
 375    }
 376
 377    if (!have_vol) {
 378       Dmsg1(190, "jid=%u Do mount_next_write_vol\n", (uint32_t)jcr->JobId);
 379       if (!dcr->mount_next_write_volume()) {
 380          if (!job_canceled(jcr)) {
 381             /* Reduce "noise" -- don't print if job canceled */
 382             Jmsg(jcr, M_FATAL, 0, _("Could not ready device %s for append.\n"),
 383                dev->print_name());
 384             Dmsg1(200, "Could not ready device %s for append.\n",
 385                dev->print_name());
 386          }
 387          goto get_out;
 388       }
 389       Dmsg2(190, "Output pos=%u:%u\n", dcr->dev->file, dcr->dev->block_num);
 390    }
 391
 392    dev->num_writers++;                /* we are now a writer */
 393    if (jcr->NumWriteVolumes == 0) {
 394       jcr->NumWriteVolumes = 1;
 395    }
 396    dev->VolCatInfo.VolCatJobs++;              /* increment number of jobs on vol */
 397    dir_update_volume_info(dcr, false, false); /* send Volume info to Director */
 398    ok = true;
 399
 400 get_out:
 401    dev->dlock();
 402    dcr->clear_reserved();
 403    dev->dunblock(DEV_LOCKED);
 404    return ok ? dcr : NULL;
 405 }
 406
 407 /*
 408  * This job is done, so release the device. From a Unix standpoint,
 409  *  the device remains open.
 410  *
 411  * Note, if we are spooling, we may enter with the device locked.
 412  * However, in all cases, unlock the device when leaving.
 413  *
 414  */
 415 bool release_device(DCR *dcr)
 416 {
 417    JCR *jcr = dcr->jcr;
 418    DEVICE *dev = dcr->dev;
 419    bool ok = true;
 420    char tbuf[100];
 421
 422    /* lock only if not already locked by this thread */
 423    if (!dcr->is_dev_locked()) {
 424       dev->r_dlock();
 425    }
 426    lock_volumes();
 427    Dmsg2(100, "release_device device %s is %s\n", dev->print_name(), dev->is_tape()?"tape":"disk");
 428
 429    /* if device is reserved, job never started, so release the reserve here */
 430    dcr->clear_reserved();
 431
 432    if (dev->can_read()) {
 433       VOLUME_CAT_INFO *vol = &dev->VolCatInfo;
 434       dev->clear_read();              /* clear read bit */
 435       Dmsg2(150, "dir_update_vol_info. label=%d Vol=%s\n",
 436          dev->is_labeled(), vol->VolCatName);
 437       if (dev->is_labeled() && vol->VolCatName[0] != 0) {
 438          dir_update_volume_info(dcr, false, false); /* send Volume info to Director */
 439          remove_read_volume(jcr, dcr->VolumeName);
 440          volume_unused(dcr);
 441       }
 442    } else if (dev->num_writers > 0) {
 443       /*
 444        * Note if WEOT is set, we are at the end of the tape
 445        *   and may not be positioned correctly, so the
 446        *   job_media_record and update_vol_info have already been
 447        *   done, which means we skip them here.
 448        */
 449       dev->num_writers--;
 450       Dmsg1(100, "There are %d writers in release_device\n", dev->num_writers);
 451       if (dev->is_labeled()) {
 452          Dmsg2(200, "dir_create_jobmedia. Release vol=%s dev=%s\n",
 453                dev->VolCatInfo.VolCatName, dev->print_name());
 454          if (!dev->at_weot() && !dir_create_jobmedia_record(dcr)) {
 455             Jmsg2(jcr, M_FATAL, 0, _("Could not create JobMedia record for Volume=\"%s\" Job=%s\n"),
 456                dcr->VolCatInfo.VolCatName, jcr->Job);
 457          }
 458          /* If no more writers, and no errors, and wrote something, write an EOF */
 459          if (!dev->num_writers && dev->can_write() && dev->block_num > 0) {
 460             dev->weof(1);
 461             write_ansi_ibm_labels(dcr, ANSI_EOF_LABEL, dev->VolHdr.VolumeName);
 462          }
 463          if (!dev->at_weot()) {
 464             dev->VolCatInfo.VolCatFiles = dev->file;   /* set number of files */
 465             /* Note! do volume update before close, which zaps VolCatInfo */
 466             dir_update_volume_info(dcr, false, false); /* send Volume info to Director */
 467             Dmsg2(200, "dir_update_vol_info. Release vol=%s dev=%s\n",
 468                   dev->VolCatInfo.VolCatName, dev->print_name());
 469          }
 470          if (dev->num_writers == 0) {         /* if not being used */
 471             volume_unused(dcr);               /*  we obviously are not using the volume */
 472          }
 473       }
 474
 475    } else {
 476       /*
 477        * If we reach here, it is most likely because the job
 478        *   has failed, since the device is not in read mode and
 479        *   there are no writers. It was probably reserved.
 480        */
 481       volume_unused(dcr);
 482    }
 483    unlock_volumes();
 484    Dmsg3(100, "%d writers, %d reserve, dev=%s\n", dev->num_writers, dev->num_reserved(),
 485          dev->print_name());
 486    debug_list_volumes("acquire:release_device()");
 487
 488
 489    /* If no writers, close if file or !CAP_ALWAYS_OPEN */
 490    if (dev->num_writers == 0 && (!dev->is_tape() || !dev->has_cap(CAP_ALWAYSOPEN))) {
 491       dvd_remove_empty_part(dcr);        /* get rid of any empty spool part */
 492       dev->close();
 493    }
 494
 495    /* Fire off Alert command and include any output */
 496    if (!job_canceled(jcr) && dcr->device->alert_command) {
 497       POOLMEM *alert;
 498       int status = 1;
 499       BPIPE *bpipe;
 500       char line[MAXSTRING];
 501       alert = get_pool_memory(PM_FNAME);
 502       alert = edit_device_codes(dcr, alert, dcr->device->alert_command, "");
 503       bpipe = open_bpipe(alert, 0, "r");
 504       if (bpipe) {
 505          while (fgets(line, sizeof(line), bpipe->rfd)) {
 506             Jmsg(jcr, M_ALERT, 0, _("Alert: %s"), line);
 507          }
 508          status = close_bpipe(bpipe);
 509       } else {
 510          status = errno;
 511       }
 512       if (status != 0) {
 513          berrno be;
 514          Jmsg(jcr, M_ALERT, 0, _("3997 Bad alert command: %s: ERR=%s.\n"),
 515               alert, be.bstrerror(status));
 516       }
 517
 518       Dmsg1(400, "alert status=%d\n", status);
 519       free_pool_memory(alert);
 520    }
 521    pthread_cond_broadcast(&dev->wait_next_vol);
 522    Dmsg2(100, "JobId=%u broadcast wait_device_release at %s\n",
 523          (uint32_t)jcr->JobId, bstrftimes(tbuf, sizeof(tbuf), (utime_t)time(NULL)));
 524    pthread_cond_broadcast(&wait_device_release);
 525    dev->dunlock();
 526    if (dcr->keep_dcr) {
 527       detach_dcr_from_dev(dcr);
 528    } else {
 529       if (jcr->read_dcr == dcr) {
 530          jcr->read_dcr = NULL;
 531       }
 532       if (jcr->dcr == dcr) {
 533          jcr->dcr = NULL;
 534       }
 535       free_dcr(dcr);
 536    }
 537    Dmsg2(100, "===== Device %s released by JobId=%u\n", dev->print_name(),
 538          (uint32_t)jcr->JobId);
 539    return ok;
 540 }
 541
 542 /*
 543  * Clean up the device for reuse without freeing the memory
 544  */
 545 bool clean_device(DCR *dcr)
 546 {
 547    bool ok;
 548    dcr->keep_dcr = true;                  /* do not free the dcr */
 549    ok = release_device(dcr);
 550    dcr->keep_dcr = false;
 551    return ok;
 552 }
 553
 554 /*
 555  * Create a new Device Control Record and attach
 556  *   it to the device (if this is a real job).
 557  * Note, this has been updated so that it can be called first
 558  *   without a DEVICE, then a second or third time with a DEVICE,
 559  *   and each time, it should cleanup and point to the new device.
 560  *   This should facilitate switching devices.
 561  * Note, each dcr must point to the controlling job (jcr).  However,
 562  *   a job can have multiple dcrs, so we must not store in the jcr's
 563  *   structure as previously. The higher level routine must store
 564  *   this dcr in the right place
 565  *
 566  */
 567 DCR *new_dcr(JCR *jcr, DCR *dcr, DEVICE *dev)
 568 {
 569    if (!dcr) {
 570       dcr = (DCR *)malloc(sizeof(DCR));
 571       memset(dcr, 0, sizeof(DCR));
 572       dcr->tid = pthread_self();
 573       dcr->spool_fd = -1;
 574    }
 575    dcr->jcr = jcr;                 /* point back to jcr */
 576    /* Set device information, possibly change device */
 577    if (dev) {
 578       if (dcr->block) {
 579          free_block(dcr->block);
 580       }
 581       dcr->block = new_block(dev);
 582       if (dcr->rec) {
 583          free_record(dcr->rec);
 584       }
 585       dcr->rec = new_record();
 586       if (dcr->attached_to_dev) {
 587          detach_dcr_from_dev(dcr);
 588       }
 589       /* Use job spoolsize prior to device spoolsize */
 590       if (jcr->spool_size) {
 591          dcr->max_job_spool_size = jcr->spool_size;
 592       } else {
 593          dcr->max_job_spool_size = dev->device->max_job_spool_size;
 594       }
 595       dcr->device = dev->device;
 596       dcr->dev = dev;
 597       attach_dcr_to_dev(dcr);
 598    }
 599    return dcr;
 600 }
 601
 602 /*
 603  * Search the dcrs list for the given dcr. If it is found,
 604  *  as it should be, then remove it. Also zap the jcr pointer
 605  *  to the dcr if it is the same one.
 606  *
 607  * Note, this code will be turned on when we can write to multiple
 608  *  dcrs at the same time.
 609  */
 610 #ifdef needed
 611 static void remove_dcr_from_dcrs(DCR *dcr)
 612 {
 613    JCR *jcr = dcr->jcr;
 614    if (jcr->dcrs) {
 615       int i = 0;
 616       DCR *ldcr;
 617       int num = jcr->dcrs->size();
 618       for (i=0; i < num; i++) {
 619          ldcr = (DCR *)jcr->dcrs->get(i);
 620          if (ldcr == dcr) {
 621             jcr->dcrs->remove(i);
 622             if (jcr->dcr == dcr) {
 623                jcr->dcr = NULL;
 624             }
 625          }
 626       }
 627    }
 628 }
 629 #endif
 630
 631 static void attach_dcr_to_dev(DCR *dcr)
 632 {
 633    DEVICE *dev = dcr->dev;
 634    JCR *jcr = dcr->jcr;
 635
 636    if (jcr) Dmsg1(500, "JobId=%u enter attach_dcr_to_dev\n", (uint32_t)jcr->JobId);
 637    if (!dcr->attached_to_dev && dev->initiated && jcr && jcr->get_JobType() != JT_SYSTEM) {
 638       dev->attached_dcrs->append(dcr);  /* attach dcr to device */
 639       dcr->attached_to_dev = true;
 640       Dmsg1(500, "JobId=%u attach_dcr_to_dev\n", (uint32_t)jcr->JobId);
 641    }
 642 }
 643
 644 void detach_dcr_from_dev(DCR *dcr)
 645 {
 646    DEVICE *dev = dcr->dev;
 647    Dmsg0(500, "Enter detach_dcr_from_dev\n"); /* jcr is NULL in some cases */
 648
 649    /* Detach this dcr only if attached */
 650    if (dcr->attached_to_dev && dev) {
 651       dev->dlock();
 652       dcr->unreserve_device();
 653       dcr->dev->attached_dcrs->remove(dcr);  /* detach dcr from device */
 654       dcr->attached_to_dev = false;
 655 //    remove_dcr_from_dcrs(dcr);      /* remove dcr from jcr list */
 656       dev->dunlock();
 657    }
 658 }
 659
 660 /*
 661  * Free up all aspects of the given dcr -- i.e. dechain it,
 662  *  release allocated memory, zap pointers, ...
 663  */
 664 void free_dcr(DCR *dcr)
 665 {
 666    JCR *jcr = dcr->jcr;
 667
 668    detach_dcr_from_dev(dcr);
 669
 670    if (dcr->block) {
 671       free_block(dcr->block);
 672    }
 673    if (dcr->rec) {
 674       free_record(dcr->rec);
 675    }
 676    if (jcr && jcr->dcr == dcr) {
 677       jcr->dcr = NULL;
 678    }
 679    free(dcr);
 680 }
 681
 682 static void set_dcr_from_vol(DCR *dcr, VOL_LIST *vol)
 683 {
 684    /*
 685     * Note, if we want to be able to work from a .bsr file only
 686     *  for disaster recovery, we must "simulate" reading the catalog
 687     */
 688    bstrncpy(dcr->VolumeName, vol->VolumeName, sizeof(dcr->VolumeName));
 689    bstrncpy(dcr->VolCatInfo.VolCatName, vol->VolumeName, sizeof(dcr->VolCatInfo.VolCatName));
 690    bstrncpy(dcr->media_type, vol->MediaType, sizeof(dcr->media_type));
 691    dcr->VolCatInfo.Slot = vol->Slot;
 692    dcr->VolCatInfo.InChanger = vol->Slot > 0;
 693 }