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