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