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

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2001-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  *  This file handles accepting Director Commands
  30  *
  31  *    Most Director commands are handled here, with the
  32  *    exception of the Job command command and subsequent
  33  *    subcommands that are handled
  34  *    in job.c.
  35  *
  36  *    N.B. in this file, in general we must use P(dev->mutex) rather
  37  *      than dev->r_lock() so that we can examine the blocked
  38  *      state rather than blocking ourselves because a Job
  39  *      thread has the device blocked. In some "safe" cases,
  40  *      we can do things to a blocked device. CAREFUL!!!!
  41  *
  42  *    File daemon commands are handled in fdcmd.c
  43  *
  44  *     Kern Sibbald, May MMI
  45  *
  46  *   Version $Id$
  47  *
  48  */
  49
  50 #include "bacula.h"
  51 #include "stored.h"
  52
  53 /* Exported variables */
  54
  55 /* Imported variables */
  56 extern BSOCK *filed_chan;
  57 extern struct s_last_job last_job;
  58 extern bool init_done;
  59
  60 /* Static variables */
  61 static char derrmsg[]     = "3900 Invalid command\n";
  62 static char OKsetdebug[]  = "3000 OK setdebug=%d\n";
  63 static char invalid_cmd[] = "3997 Invalid command for a Director with Monitor directive enabled.\n";
  64 static char OK_bootstrap[]    = "3000 OK bootstrap\n";
  65 static char ERROR_bootstrap[] = "3904 Error bootstrap\n";
  66
  67 /* Imported functions */
  68 extern void terminate_child();
  69 extern bool job_cmd(JCR *jcr);
  70 extern bool use_cmd(JCR *jcr);
  71 extern bool run_cmd(JCR *jcr);
  72 extern bool status_cmd(JCR *sjcr);
  73 extern bool qstatus_cmd(JCR *jcr);
  74 //extern bool query_cmd(JCR *jcr);
  75
  76 /* Forward referenced functions */
  77 static bool label_cmd(JCR *jcr);
  78 static bool die_cmd(JCR *jcr);
  79 static bool relabel_cmd(JCR *jcr);
  80 static bool readlabel_cmd(JCR *jcr);
  81 static bool release_cmd(JCR *jcr);
  82 static bool setdebug_cmd(JCR *jcr);
  83 static bool cancel_cmd(JCR *cjcr);
  84 static bool mount_cmd(JCR *jcr);
  85 static bool unmount_cmd(JCR *jcr);
  86 static bool bootstrap_cmd(JCR *jcr);
  87 static bool changer_cmd(JCR *sjcr);
  88 static bool do_label(JCR *jcr, int relabel);
  89 static DCR *find_device(JCR *jcr, POOL_MEM &dev_name, int drive);
  90 static void read_volume_label(JCR *jcr, DCR *dcr, DEVICE *dev, int Slot);
  91 static void label_volume_if_ok(DCR *dcr, char *oldname,
  92                                char *newname, char *poolname,
  93                                int Slot, int relabel);
  94 static bool try_autoload_device(JCR *jcr, DCR *dcr, int slot, const char *VolName);
  95 static void send_dir_busy_message(BSOCK *dir, DEVICE *dev);
  96
  97 struct s_cmds {
  98    const char *cmd;
  99    bool (*func)(JCR *jcr);
 100    bool monitoraccess;                      /* set if monitors can access this cmd */
 101 };
 102
 103 /*
 104  * The following are the recognized commands from the Director.
 105  */
 106 static struct s_cmds cmds[] = {
 107    {"JobId=",      job_cmd,         0},     /* start Job */
 108    {"autochanger", changer_cmd,     0},
 109    {"bootstrap",   bootstrap_cmd,   0},
 110    {"cancel",      cancel_cmd,      0},
 111    {".die",        die_cmd,         0},
 112    {"label",       label_cmd,       0},     /* label a tape */
 113    {"mount",       mount_cmd,       0},
 114    {"readlabel",   readlabel_cmd,   0},
 115    {"release",     release_cmd,     0},
 116    {"relabel",     relabel_cmd,     0},     /* relabel a tape */
 117    {"setdebug=",   setdebug_cmd,    0},     /* set debug level */
 118    {"status",      status_cmd,      1},
 119    {".status",     qstatus_cmd,     1},
 120    {"unmount",     unmount_cmd,     0},
 121    {"use storage=", use_cmd,        0},
 122    {"run",         run_cmd,         0},
 123 // {"query",       query_cmd,       0},
 124    {NULL,        NULL}                      /* list terminator */
 125 };
 126
 127
 128 /*
 129  * Connection request. We accept connections either from the
 130  *  Director or a Client (File daemon).
 131  *
 132  * Note, we are running as a seperate thread of the Storage daemon.
 133  *  and it is because a Director has made a connection with
 134  *  us on the "Message" channel.
 135  *
 136  * Basic tasks done here:
 137  *  - Create a JCR record
 138  *  - If it was from the FD, call handle_filed_connection()
 139  *  - Authenticate the Director
 140  *  - We wait for a command
 141  *  - We execute the command
 142  *  - We continue or exit depending on the return status
 143  */
 144 void *handle_connection_request(void *arg)
 145 {
 146    BSOCK *bs = (BSOCK *)arg;
 147    JCR *jcr;
 148    int i;
 149    bool found, quit;
 150    int bnet_stat = 0;
 151    char name[500];
 152    char tbuf[100];
 153
 154    if (bs->recv() <= 0) {
 155       Emsg0(M_ERROR, 0, _("Connection request failed.\n"));
 156       bs->close();
 157       return NULL;
 158    }
 159
 160    /*
 161     * Do a sanity check on the message received
 162     */
 163    if (bs->msglen < 25 || bs->msglen > (int)sizeof(name)) {
 164       Dmsg1(000, "<filed: %s", bs->msg);
 165       Emsg1(M_ERROR, 0, _("Invalid connection. Len=%d\n"), bs->msglen);
 166       bs->close();
 167       return NULL;
 168    }
 169    /*
 170     * See if this is a File daemon connection. If so
 171     *   call FD handler.
 172     */
 173    Dmsg1(110, "Conn: %s", bs->msg);
 174    if (debug_level == 3) {
 175       Dmsg1(000, "<filed: %s", bs->msg);
 176    }
 177    if (sscanf(bs->msg, "Hello Start Job %127s", name) == 1) {
 178       Dmsg1(110, "Got a FD connection at %s\n", bstrftimes(tbuf, sizeof(tbuf),
 179             (utime_t)time(NULL)));
 180       Dmsg1(50, "%s", bs->msg);
 181       handle_filed_connection(bs, name);
 182       return NULL;
 183    }
 184
 185    /*
 186     * This is a connection from the Director, so setup a JCR
 187     */
 188    Dmsg1(110, "Got a DIR connection at %s\n", bstrftimes(tbuf, sizeof(tbuf),
 189          (utime_t)time(NULL)));
 190    jcr = new_jcr(sizeof(JCR), stored_free_jcr); /* create Job Control Record */
 191    jcr->dir_bsock = bs;               /* save Director bsock */
 192    jcr->dir_bsock->set_jcr(jcr);
 193    jcr->dcrs = New(alist(10, not_owned_by_alist));
 194    /* Initialize FD start condition variable */
 195    int errstat = pthread_cond_init(&jcr->job_start_wait, NULL);
 196    if (errstat != 0) {
 197       berrno be;
 198       Jmsg1(jcr, M_FATAL, 0, _("Unable to init job cond variable: ERR=%s\n"), be.bstrerror(errstat));
 199       goto bail_out;
 200    }
 201
 202    Dmsg0(1000, "stored in start_job\n");
 203
 204    /*
 205     * Authenticate the Director
 206     */
 207    if (!authenticate_director(jcr)) {
 208       Jmsg(jcr, M_FATAL, 0, _("Unable to authenticate Director\n"));
 209       goto bail_out;
 210    }
 211    Dmsg0(90, "Message channel init completed.\n");
 212
 213    for (quit=false; !quit;) {
 214       /* Read command */
 215       if ((bnet_stat = bs->recv()) <= 0) {
 216          break;               /* connection terminated */
 217       }
 218       Dmsg1(199, "<dird: %s\n", bs->msg);
 219       /* Ensure that device initialization is complete */
 220       while (!init_done) {
 221          bmicrosleep(1, 0);
 222       }
 223       found = false;
 224       for (i=0; cmds[i].cmd; i++) {
 225         if (strncmp(cmds[i].cmd, bs->msg, strlen(cmds[i].cmd)) == 0) {
 226            if ((!cmds[i].monitoraccess) && (jcr->director->monitor)) {
 227               Dmsg1(100, "Command \"%s\" is invalid.\n", cmds[i].cmd);
 228               bs->fsend(invalid_cmd);
 229               bs->signal(BNET_EOD);
 230               break;
 231            }
 232            Dmsg1(200, "Do command: %s\n", cmds[i].cmd);
 233            if (!cmds[i].func(jcr)) { /* do command */
 234               quit = true; /* error, get out */
 235               Dmsg1(190, "Command %s reqeusts quit\n", cmds[i].cmd);
 236            }
 237            found = true;             /* indicate command found */
 238            break;
 239         }
 240       }
 241       if (!found) {                   /* command not found */
 242         bs->fsend(derrmsg);
 243         break;
 244       }
 245    }
 246 bail_out:
 247    generate_daemon_event(jcr, "JobEnd");
 248    dequeue_messages(jcr);             /* send any queued messages */
 249    bs->signal(BNET_TERMINATE);
 250    free_jcr(jcr);
 251    return NULL;
 252 }
 253
 254
 255 /*
 256  * Force SD to die, and hopefully dump itself.  Turned on only
 257  *  in development version.
 258  */
 259 static bool die_cmd(JCR *jcr)
 260 {
 261 #ifdef DEVELOPER
 262    JCR *djcr = NULL;
 263    int a;
 264    Pmsg0(000, "I have been requested to die ...");
 265    a = djcr->JobId;   /* ref NULL pointer */
 266 #endif
 267    return 0;
 268 }
 269
 270
 271
 272 /*
 273  * Set debug level as requested by the Director
 274  *
 275  */
 276 static bool setdebug_cmd(JCR *jcr)
 277 {
 278    BSOCK *dir = jcr->dir_bsock;
 279    int level, trace_flag;
 280
 281    Dmsg1(10, "setdebug_cmd: %s", dir->msg);
 282    if (sscanf(dir->msg, "setdebug=%d trace=%d", &level, &trace_flag) != 2 || level < 0) {
 283       dir->fsend(_("3991 Bad setdebug command: %s\n"), dir->msg);
 284       return 0;
 285    }
 286    debug_level = level;
 287    set_trace(trace_flag);
 288    return dir->fsend(OKsetdebug, level);
 289 }
 290
 291
 292 /*
 293  * Cancel a Job
 294  */
 295 static bool cancel_cmd(JCR *cjcr)
 296 {
 297    BSOCK *dir = cjcr->dir_bsock;
 298    int oldStatus;
 299    char Job[MAX_NAME_LENGTH];
 300    JCR *jcr;
 301
 302    if (sscanf(dir->msg, "cancel Job=%127s", Job) == 1) {
 303       if (!(jcr=get_jcr_by_full_name(Job))) {
 304          dir->fsend(_("3904 Job %s not found.\n"), Job);
 305       } else {
 306          oldStatus = jcr->JobStatus;
 307          set_jcr_job_status(jcr, JS_Canceled);
 308          if (!jcr->authenticated && oldStatus == JS_WaitFD) {
 309             pthread_cond_signal(&jcr->job_start_wait); /* wake waiting thread */
 310          }
 311          if (jcr->file_bsock) {
 312             bnet_sig(jcr->file_bsock, BNET_TERMINATE);
 313          } else {
 314             /* Still waiting for FD to connect, release it */
 315             pthread_cond_signal(&jcr->job_start_wait); /* wake waiting job */
 316          }
 317          /* If thread waiting on mount, wake him */
 318          if (jcr->dcr && jcr->dcr->dev && jcr->dcr->dev->waiting_for_mount()) {
 319             pthread_cond_broadcast(&jcr->dcr->dev->wait_next_vol);
 320             Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)jcr->JobId);
 321             pthread_cond_broadcast(&wait_device_release);
 322          }
 323          if (jcr->read_dcr && jcr->read_dcr->dev && jcr->read_dcr->dev->waiting_for_mount()) {
 324             pthread_cond_broadcast(&jcr->read_dcr->dev->wait_next_vol);
 325             Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)jcr->JobId);
 326             pthread_cond_broadcast(&wait_device_release);
 327          }
 328          Jmsg(jcr, M_INFO, 0, _("Job %s marked to be canceled.\n"), jcr->Job);
 329          dir->fsend(_("3000 Job %s marked to be canceled.\n"), jcr->Job);
 330          free_jcr(jcr);
 331       }
 332    } else {
 333       dir->fsend(_("3903 Error scanning cancel command.\n"));
 334    }
 335    dir->signal(BNET_EOD);
 336    return 1;
 337 }
 338
 339 /*
 340  * Label a Volume
 341  *
 342  */
 343 static bool label_cmd(JCR *jcr)
 344 {
 345    return do_label(jcr, 0);
 346 }
 347
 348 static bool relabel_cmd(JCR *jcr)
 349 {
 350    return do_label(jcr, 1);
 351 }
 352
 353 static bool do_label(JCR *jcr, int relabel)
 354 {
 355    POOLMEM *newname, *oldname, *poolname, *mtype;
 356    POOL_MEM dev_name;
 357    BSOCK *dir = jcr->dir_bsock;
 358    DCR *dcr;
 359    DEVICE *dev;
 360    bool ok = false;
 361    int slot;
 362    int drive;
 363
 364    newname = get_memory(dir->msglen+1);
 365    oldname = get_memory(dir->msglen+1);
 366    poolname = get_memory(dir->msglen+1);
 367    mtype = get_memory(dir->msglen+1);
 368    if (relabel) {
 369       if (sscanf(dir->msg, "relabel %127s OldName=%127s NewName=%127s PoolName=%127s "
 370                  "MediaType=%127s Slot=%d drive=%d",
 371                   dev_name.c_str(), oldname, newname, poolname, mtype,
 372                   &slot, &drive) == 7) {
 373          ok = true;
 374       }
 375    } else {
 376       *oldname = 0;
 377       if (sscanf(dir->msg, "label %127s VolumeName=%127s PoolName=%127s "
 378                  "MediaType=%127s Slot=%d drive=%d",
 379           dev_name.c_str(), newname, poolname, mtype, &slot, &drive) == 6) {
 380          ok = true;
 381       }
 382    }
 383    if (ok) {
 384       unbash_spaces(newname);
 385       unbash_spaces(oldname);
 386       unbash_spaces(poolname);
 387       unbash_spaces(mtype);
 388       dcr = find_device(jcr, dev_name, drive);
 389       if (dcr) {
 390          dev = dcr->dev;
 391          dev->dlock();                 /* Use P to avoid indefinite block */
 392          if (!dev->is_open() && !dev->is_busy()) {
 393             Dmsg1(400, "Can %slabel. Device is not open\n", relabel?"re":"");
 394             label_volume_if_ok(dcr, oldname, newname, poolname, slot, relabel);
 395             dev->close();
 396          /* Under certain "safe" conditions, we can steal the lock */
 397          } else if (dev->can_steal_lock()) {
 398             Dmsg0(400, "Can relabel. can_steal_lock\n");
 399             label_volume_if_ok(dcr, oldname, newname, poolname, slot, relabel);
 400          } else if (dev->is_busy() || dev->is_blocked()) {
 401             send_dir_busy_message(dir, dev);
 402          } else {                     /* device not being used */
 403             Dmsg0(400, "Can relabel. device not used\n");
 404             label_volume_if_ok(dcr, oldname, newname, poolname, slot, relabel);
 405          }
 406          dev->dunlock();
 407          free_dcr(dcr);
 408       } else {
 409          dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), dev_name.c_str());
 410       }
 411    } else {
 412       /* NB dir->msg gets clobbered in bnet_fsend, so save command */
 413       pm_strcpy(jcr->errmsg, dir->msg);
 414       dir->fsend(_("3903 Error scanning label command: %s\n"), jcr->errmsg);
 415    }
 416    free_memory(oldname);
 417    free_memory(newname);
 418    free_memory(poolname);
 419    free_memory(mtype);
 420    dir->signal(BNET_EOD);
 421    return true;
 422 }
 423
 424 /*
 425  * Read the tape label and determine if we can safely
 426  * label the tape (not a Bacula volume), then label it.
 427  *
 428  *  Enter with the mutex set
 429  */
 430 static void label_volume_if_ok(DCR *dcr, char *oldname,
 431                                char *newname, char *poolname,
 432                                int slot, int relabel)
 433 {
 434    BSOCK *dir = dcr->jcr->dir_bsock;
 435    bsteal_lock_t hold;
 436    DEVICE *dev = dcr->dev;
 437    int label_status;
 438    int mode;
 439    const char *volname = (relabel == 1) ? oldname : newname;
 440    char ed1[50];
 441
 442    steal_device_lock(dev, &hold, BST_WRITING_LABEL);
 443    Dmsg1(100, "Stole device %s lock, writing label.\n", dev->print_name());
 444
 445
 446    Dmsg0(90, "try_autoload_device - looking for volume_info\n");
 447    if (!try_autoload_device(dcr->jcr, dcr, slot, volname)) {
 448       goto bail_out;                  /* error */
 449    }
 450
 451    /* Ensure that the device is open -- autoload_device() closes it */
 452    if (dev->is_tape()) {
 453       mode = OPEN_READ_WRITE;
 454    } else {
 455       mode = CREATE_READ_WRITE;
 456    }
 457
 458    if (relabel) {
 459       dev->truncating = true;         /* let open() know we will truncate it */
 460    }
 461    /* Set old volume name for open if relabeling */
 462    bstrncpy(dcr->VolCatInfo.VolCatName, volname, sizeof(dcr->VolCatInfo.VolCatName));
 463    if (dev->open(dcr, mode) < 0) {
 464       dir->fsend(_("3910 Unable to open device %s: ERR=%s\n"),
 465          dev->print_name(), dev->bstrerror());
 466       goto bail_out;
 467    }
 468
 469    /* See what we have for a Volume */
 470    label_status = read_dev_volume_label(dcr);
 471
 472    /* Set new volume name */
 473    bstrncpy(dcr->VolCatInfo.VolCatName, newname, sizeof(dcr->VolCatInfo.VolCatName));
 474    switch(label_status) {
 475    case VOL_NAME_ERROR:
 476    case VOL_VERSION_ERROR:
 477    case VOL_LABEL_ERROR:
 478    case VOL_OK:
 479       if (!relabel) {
 480          dir->fsend(_(
 481             "3920 Cannot label Volume because it is already labeled: \"%s\"\n"),
 482              dev->VolHdr.VolumeName);
 483          break;
 484       }
 485
 486       /* Relabel request. If oldname matches, continue */
 487       if (strcmp(oldname, dev->VolHdr.VolumeName) != 0) {
 488          dir->fsend(_("3921 Wrong volume mounted.\n"));
 489          break;
 490       }
 491       if (dev->label_type != B_BACULA_LABEL) {
 492          dir->fsend(_("3922 Cannot relabel an ANSI/IBM labeled Volume.\n"));
 493          break;
 494       }
 495       /* Fall through wanted! */
 496    case VOL_IO_ERROR:
 497    case VOL_NO_LABEL:
 498       if (!write_new_volume_label_to_dev(dcr, newname, poolname,
 499            relabel, true /* write dvd now */)) {
 500          dir->fsend(_("3912 Failed to label Volume: ERR=%s\n"), dev->bstrerror());
 501          break;
 502       }
 503       bstrncpy(dcr->VolumeName, newname, sizeof(dcr->VolumeName));
 504       /* The following 3000 OK label. string is scanned in ua_label.c */
 505       dir->fsend("3000 OK label. VolBytes=%s DVD=%d Volume=\"%s\" Device=%s\n",
 506                  edit_uint64(dev->VolCatInfo.VolCatBytes, ed1),
 507                  dev->is_dvd()?1:0, newname, dev->print_name());
 508       break;
 509    case VOL_NO_MEDIA:
 510       dir->fsend(_("3914 Failed to label Volume (no media): ERR=%s\n"), dev->bstrerror());
 511       break;
 512    default:
 513       dir->fsend(_("3913 Cannot label Volume. "
 514 "Unknown status %d from read_volume_label()\n"), label_status);
 515       break;
 516    }
 517
 518 bail_out:
 519    if (!dev->is_open()) {
 520       dev->clear_volhdr();
 521    }
 522    volume_unused(dcr);                   /* no longer using volume */
 523    give_back_device_lock(dev, &hold);
 524    return;
 525 }
 526
 527
 528 /*
 529  * Read the tape label
 530  *
 531  *  Enter with the mutex set
 532  */
 533 static bool read_label(DCR *dcr)
 534 {
 535    int ok;
 536    JCR *jcr = dcr->jcr;
 537    BSOCK *dir = jcr->dir_bsock;
 538    bsteal_lock_t hold;
 539    DEVICE *dev = dcr->dev;
 540
 541    steal_device_lock(dev, &hold, BST_DOING_ACQUIRE);
 542
 543    dcr->VolumeName[0] = 0;
 544    dev->clear_labeled();              /* force read of label */
 545    switch (read_dev_volume_label(dcr)) {
 546    case VOL_OK:
 547       dir->fsend(_("3001 Mounted Volume: %s\n"), dev->VolHdr.VolumeName);
 548       ok = true;
 549       break;
 550    default:
 551       dir->fsend(_("3902 Cannot mount Volume on Storage Device %s because:\n%s"),
 552          dev->print_name(), jcr->errmsg);
 553       ok = false;
 554       break;
 555    }
 556    volume_unused(dcr);
 557    give_back_device_lock(dev, &hold);
 558    return ok;
 559 }
 560
 561 /*
 562  * Searches for device by name, and if found, creates a dcr and
 563  *  returns it.
 564  */
 565 static DCR *find_device(JCR *jcr, POOL_MEM &devname, int drive)
 566 {
 567    DEVRES *device;
 568    AUTOCHANGER *changer;
 569    bool found = false;
 570    DCR *dcr = NULL;
 571
 572    unbash_spaces(devname);
 573    foreach_res(device, R_DEVICE) {
 574       /* Find resource, and make sure we were able to open it */
 575       if (strcmp(device->hdr.name, devname.c_str()) == 0) {
 576          if (!device->dev) {
 577             device->dev = init_dev(jcr, device);
 578          }
 579          if (!device->dev) {
 580             Jmsg(jcr, M_WARNING, 0, _("\n"
 581                "     Device \"%s\" requested by DIR could not be opened or does not exist.\n"),
 582                  devname.c_str());
 583             continue;
 584          }
 585          Dmsg1(20, "Found device %s\n", device->hdr.name);
 586          found = true;
 587          break;
 588       }
 589    }
 590    if (!found) {
 591       foreach_res(changer, R_AUTOCHANGER) {
 592          /* Find resource, and make sure we were able to open it */
 593          if (strcmp(devname.c_str(), changer->hdr.name) == 0) {
 594             /* Try each device in this AutoChanger */
 595             foreach_alist(device, changer->device) {
 596                Dmsg1(100, "Try changer device %s\n", device->hdr.name);
 597                if (!device->dev) {
 598                   device->dev = init_dev(jcr, device);
 599                }
 600                if (!device->dev) {
 601                   Dmsg1(100, "Device %s could not be opened. Skipped\n", devname.c_str());
 602                   Jmsg(jcr, M_WARNING, 0, _("\n"
 603                      "     Device \"%s\" in changer \"%s\" requested by DIR could not be opened or does not exist.\n"),
 604                        device->hdr.name, devname.c_str());
 605                   continue;
 606                }
 607                if (!device->dev->autoselect) {
 608                   Dmsg1(100, "Device %s not autoselect skipped.\n", devname.c_str());
 609                   continue;              /* device is not available */
 610                }
 611                if (drive < 0 || drive == (int)device->dev->drive_index) {
 612                   Dmsg1(20, "Found changer device %s\n", device->hdr.name);
 613                   found = true;
 614                   break;
 615                }
 616                Dmsg3(100, "Device %s drive wrong: want=%d got=%d skipping\n",
 617                   devname.c_str(), drive, (int)device->dev->drive_index);
 618             }
 619             break;                    /* we found it but could not open a device */
 620          }
 621       }
 622    }
 623
 624    if (found) {
 625       Dmsg1(100, "Found device %s\n", device->hdr.name);
 626       dcr = new_dcr(jcr, NULL, device->dev);
 627       dcr->device = device;
 628    }
 629    return dcr;
 630 }
 631
 632
 633 /*
 634  * Mount command from Director
 635  */
 636 static bool mount_cmd(JCR *jcr)
 637 {
 638    POOL_MEM devname;
 639    BSOCK *dir = jcr->dir_bsock;
 640    DEVICE *dev;
 641    DCR *dcr;
 642    int drive;
 643    int slot = 0;
 644    bool ok;
 645
 646    ok = sscanf(dir->msg, "mount %127s drive=%d slot=%d", devname.c_str(),
 647                &drive, &slot) == 3;
 648    if (!ok) {
 649       ok = sscanf(dir->msg, "mount %127s drive=%d", devname.c_str(), &drive) == 2;
 650    }
 651    if (ok) {
 652       dcr = find_device(jcr, devname, drive);
 653       if (dcr) {
 654          dev = dcr->dev;
 655          dev->dlock();                 /* Use P to avoid indefinite block */
 656          Dmsg2(100, "mount cmd blocked=%d must_unload=%d\n", dev->blocked(),
 657             dev->must_unload());
 658          switch (dev->blocked()) {         /* device blocked? */
 659          case BST_WAITING_FOR_SYSOP:
 660             /* Someone is waiting, wake him */
 661             Dmsg0(100, "Waiting for mount. Attempting to wake thread\n");
 662             dev->set_blocked(BST_MOUNT);
 663             dir->fsend("3001 OK mount requested. %sDevice=%s\n",
 664                        slot>0?_("Specified slot ignored. "):"",
 665                        dev->print_name());
 666             pthread_cond_broadcast(&dev->wait_next_vol);
 667             Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)dcr->jcr->JobId);
 668             pthread_cond_broadcast(&wait_device_release);
 669             break;
 670
 671          /* In both of these two cases, we (the user) unmounted the Volume */
 672          case BST_UNMOUNTED_WAITING_FOR_SYSOP:
 673          case BST_UNMOUNTED:
 674             if (dev->is_autochanger() && slot > 0) {
 675                try_autoload_device(jcr, dcr, slot, "");
 676             }
 677             /* We freed the device, so reopen it and wake any waiting threads */
 678             if (dev->open(dcr, OPEN_READ_ONLY) < 0) {
 679                dir->fsend(_("3901 Unable to open device %s: ERR=%s\n"),
 680                   dev->print_name(), dev->bstrerror());
 681                if (dev->blocked() == BST_UNMOUNTED) {
 682                   /* We blocked the device, so unblock it */
 683                   Dmsg0(100, "Unmounted. Unblocking device\n");
 684                   unblock_device(dev);
 685                }
 686                break;
 687             }
 688             read_dev_volume_label(dcr);
 689             if (dev->blocked() == BST_UNMOUNTED) {
 690                /* We blocked the device, so unblock it */
 691                Dmsg0(100, "Unmounted. Unblocking device\n");
 692                read_label(dcr);       /* this should not be necessary */
 693                unblock_device(dev);
 694             } else {
 695                Dmsg0(100, "Unmounted waiting for mount. Attempting to wake thread\n");
 696                dev->set_blocked(BST_MOUNT);
 697             }
 698             if (dev->is_labeled()) {
 699                dir->fsend(_("3001 Device %s is mounted with Volume \"%s\"\n"),
 700                   dev->print_name(), dev->VolHdr.VolumeName);
 701             } else {
 702                dir->fsend(_("3905 Device %s open but no Bacula volume is mounted.\n"
 703                                  "If this is not a blank tape, try unmounting and remounting the Volume.\n"),
 704                           dev->print_name());
 705             }
 706             pthread_cond_broadcast(&dev->wait_next_vol);
 707             Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)dcr->jcr->JobId);
 708             pthread_cond_broadcast(&wait_device_release);
 709             break;
 710
 711          case BST_DOING_ACQUIRE:
 712             dir->fsend(_("3001 Device %s is doing acquire.\n"),
 713                        dev->print_name());
 714             break;
 715
 716          case BST_WRITING_LABEL:
 717             dir->fsend(_("3903 Device %s is being labeled.\n"),
 718                dev->print_name());
 719             break;
 720
 721          case BST_NOT_BLOCKED:
 722             if (dev->is_autochanger() && slot > 0) {
 723                try_autoload_device(jcr, dcr, slot, "");
 724             }
 725             if (dev->is_open()) {
 726                if (dev->is_labeled()) {
 727                   dir->fsend(_("3001 Device %s is mounted with Volume \"%s\"\n"),
 728                      dev->print_name(), dev->VolHdr.VolumeName);
 729                } else {
 730                   dir->fsend(_("3905 Device %s open but no Bacula volume is mounted.\n"
 731                                  "If this is not a blank tape, try unmounting and remounting the Volume.\n"),
 732                              dev->print_name());
 733                }
 734             } else if (dev->is_tape()) {
 735                if (dev->open(dcr, OPEN_READ_ONLY) < 0) {
 736                   dir->fsend(_("3901 Unable to open device %s: ERR=%s\n"),
 737                      dev->print_name(), dev->bstrerror());
 738                   break;
 739                }
 740                read_label(dcr);
 741                if (dev->is_labeled()) {
 742                   dir->fsend(_("3001 Device %s is already mounted with Volume \"%s\"\n"),
 743                      dev->print_name(), dev->VolHdr.VolumeName);
 744                } else {
 745                   dir->fsend(_("3905 Device %s open but no Bacula volume is mounted.\n"
 746                                     "If this is not a blank tape, try unmounting and remounting the Volume.\n"),
 747                              dev->print_name());
 748                }
 749             } else if (dev->is_unmountable()) {
 750                if (dev->mount(1)) {
 751                   dir->fsend(_("3002 Device %s is mounted.\n"),
 752                      dev->print_name());
 753                } else {
 754                   dir->fsend(_("3907 %s"), dev->bstrerror());
 755                }
 756             } else { /* must be file */
 757                dir->fsend(_("3906 File device %s is always mounted.\n"),
 758                   dev->print_name());
 759             }
 760             break;
 761
 762          default:
 763             dir->fsend(_("3905 Bizarre wait state %d\n"), dev->blocked());
 764             break;
 765          }
 766          dev->dunlock();
 767          free_dcr(dcr);
 768       } else {
 769          dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
 770       }
 771    } else {
 772       pm_strcpy(jcr->errmsg, dir->msg);
 773       dir->fsend(_("3909 Error scanning mount command: %s\n"), jcr->errmsg);
 774    }
 775    dir->signal(BNET_EOD);
 776    return true;
 777 }
 778
 779 /*
 780  * unmount command from Director
 781  */
 782 static bool unmount_cmd(JCR *jcr)
 783 {
 784    POOL_MEM devname;
 785    BSOCK *dir = jcr->dir_bsock;
 786    DEVICE *dev;
 787    DCR *dcr;
 788    int drive;
 789
 790    if (sscanf(dir->msg, "unmount %127s drive=%d", devname.c_str(), &drive) == 2) {
 791       dcr = find_device(jcr, devname, drive);
 792       if (dcr) {
 793          dev = dcr->dev;
 794          dev->dlock();                 /* Use P to avoid indefinite block */
 795          if (!dev->is_open()) {
 796             if (!dev->is_busy()) {
 797                unload_autochanger(dcr, -1);
 798             }
 799             if (dev->is_unmountable()) {
 800                if (dev->unmount(0)) {
 801                   dir->fsend(_("3002 Device %s unmounted.\n"),
 802                      dev->print_name());
 803                } else {
 804                   dir->fsend(_("3907 %s"), dev->bstrerror());
 805                }
 806             } else {
 807                Dmsg0(90, "Device already unmounted\n");
 808                dir->fsend(_("3901 Device %s is already unmounted.\n"),
 809                   dev->print_name());
 810             }
 811          } else if (dev->blocked() == BST_WAITING_FOR_SYSOP) {
 812             Dmsg2(90, "%d waiter dev_block=%d. doing unmount\n", dev->num_waiting,
 813                dev->blocked());
 814             if (!unload_autochanger(dcr, -1)) {
 815                /* ***FIXME**** what is this ????  */
 816                dev->close();
 817                free_volume(dev);
 818             }
 819             if (dev->is_unmountable() && !dev->unmount(0)) {
 820                dir->fsend(_("3907 %s"), dev->bstrerror());
 821             } else {
 822                dev->set_blocked(BST_UNMOUNTED_WAITING_FOR_SYSOP);
 823                dir->fsend(_("3001 Device %s unmounted.\n"),
 824                   dev->print_name());
 825             }
 826
 827          } else if (dev->blocked() == BST_DOING_ACQUIRE) {
 828             dir->fsend(_("3902 Device %s is busy in acquire.\n"),
 829                dev->print_name());
 830
 831          } else if (dev->blocked() == BST_WRITING_LABEL) {
 832             dir->fsend(_("3903 Device %s is being labeled.\n"),
 833                dev->print_name());
 834
 835          } else if (dev->is_busy()) {
 836             send_dir_busy_message(dir, dev);
 837          } else {                     /* device not being used */
 838             Dmsg0(90, "Device not in use, unmounting\n");
 839             /* On FreeBSD, I am having ASSERT() failures in block_device()
 840              * and I can only imagine that the thread id that we are
 841              * leaving in no_wait_id is being re-used. So here,
 842              * we simply do it by hand.  Gross, but a solution.
 843              */
 844             /*  block_device(dev, BST_UNMOUNTED); replace with 2 lines below */
 845             dev->set_blocked(BST_UNMOUNTED);
 846             clear_thread_id(dev->no_wait_id);
 847             if (!unload_autochanger(dcr, -1)) {
 848                dev->close();
 849                free_volume(dev);
 850             }
 851             if (dev->is_unmountable() && !dev->unmount(0)) {
 852                dir->fsend(_("3907 %s"), dev->bstrerror());
 853             } else {
 854                dir->fsend(_("3002 Device %s unmounted.\n"),
 855                   dev->print_name());
 856             }
 857          }
 858          dev->dunlock();
 859          free_dcr(dcr);
 860       } else {
 861          dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
 862       }
 863    } else {
 864       /* NB dir->msg gets clobbered in bnet_fsend, so save command */
 865       pm_strcpy(jcr->errmsg, dir->msg);
 866       dir->fsend(_("3907 Error scanning unmount command: %s\n"), jcr->errmsg);
 867    }
 868    dir->signal(BNET_EOD);
 869    return true;
 870 }
 871
 872 /*
 873  * Release command from Director. This rewinds the device and if
 874  *   configured does a offline and ensures that Bacula will
 875  *   re-read the label of the tape before continuing. This gives
 876  *   the operator the chance to change the tape anytime before the
 877  *   next job starts.
 878  */
 879 static bool release_cmd(JCR *jcr)
 880 {
 881    POOL_MEM devname;
 882    BSOCK *dir = jcr->dir_bsock;
 883    DEVICE *dev;
 884    DCR *dcr;
 885    int drive;
 886
 887    if (sscanf(dir->msg, "release %127s drive=%d", devname.c_str(), &drive) == 2) {
 888       dcr = find_device(jcr, devname, drive);
 889       if (dcr) {
 890          dev = dcr->dev;
 891          dev->dlock();                 /* Use P to avoid indefinite block */
 892          if (!dev->is_open()) {
 893             if (!dev->is_busy()) {
 894                unload_autochanger(dcr, -1);
 895             }
 896             Dmsg0(90, "Device already released\n");
 897             dir->fsend(_("3921 Device %s already released.\n"),
 898                dev->print_name());
 899
 900          } else if (dev->blocked() == BST_WAITING_FOR_SYSOP) {
 901             Dmsg2(90, "%d waiter dev_block=%d.\n", dev->num_waiting,
 902                dev->blocked());
 903             unload_autochanger(dcr, -1);
 904             dir->fsend(_("3922 Device %s waiting for sysop.\n"),
 905                dev->print_name());
 906
 907          } else if (dev->blocked() == BST_UNMOUNTED_WAITING_FOR_SYSOP) {
 908             Dmsg2(90, "%d waiter dev_block=%d. doing unmount\n", dev->num_waiting,
 909                dev->blocked());
 910             dir->fsend(_("3922 Device %s waiting for mount.\n"),
 911                dev->print_name());
 912
 913          } else if (dev->blocked() == BST_DOING_ACQUIRE) {
 914             dir->fsend(_("3923 Device %s is busy in acquire.\n"),
 915                dev->print_name());
 916
 917          } else if (dev->blocked() == BST_WRITING_LABEL) {
 918             dir->fsend(_("3914 Device %s is being labeled.\n"),
 919                dev->print_name());
 920
 921          } else if (dev->is_busy()) {
 922             send_dir_busy_message(dir, dev);
 923          } else {                     /* device not being used */
 924             Dmsg0(90, "Device not in use, releasing\n");
 925             dcr->release_volume();
 926             dir->fsend(_("3022 Device %s released.\n"),
 927                dev->print_name());
 928          }
 929          dev->dunlock();
 930          free_dcr(dcr);
 931       } else {
 932          dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
 933       }
 934    } else {
 935       /* NB dir->msg gets clobbered in bnet_fsend, so save command */
 936       pm_strcpy(jcr->errmsg, dir->msg);
 937       dir->fsend(_("3927 Error scanning release command: %s\n"), jcr->errmsg);
 938    }
 939    dir->signal(BNET_EOD);
 940    return true;
 941 }
 942
 943 static pthread_mutex_t bsr_mutex = PTHREAD_MUTEX_INITIALIZER;
 944 static uint32_t bsr_uniq = 0;
 945
 946 static bool get_bootstrap_file(JCR *jcr, BSOCK *sock)
 947 {
 948    POOLMEM *fname = get_pool_memory(PM_FNAME);
 949    FILE *bs;
 950    bool ok = false;
 951
 952    if (jcr->RestoreBootstrap) {
 953       unlink(jcr->RestoreBootstrap);
 954       free_pool_memory(jcr->RestoreBootstrap);
 955    }
 956    P(bsr_mutex);
 957    bsr_uniq++;
 958    Mmsg(fname, "%s/%s.%s.%d.bootstrap", me->working_directory, me->hdr.name,
 959       jcr->Job, bsr_uniq);
 960    V(bsr_mutex);
 961    Dmsg1(400, "bootstrap=%s\n", fname);
 962    jcr->RestoreBootstrap = fname;
 963    bs = fopen(fname, "a+b");           /* create file */
 964    if (!bs) {
 965       berrno be;
 966       Jmsg(jcr, M_FATAL, 0, _("Could not create bootstrap file %s: ERR=%s\n"),
 967          jcr->RestoreBootstrap, be.bstrerror());
 968       goto bail_out;
 969    }
 970    Dmsg0(10, "=== Bootstrap file ===\n");
 971    while (sock->recv() >= 0) {
 972        Dmsg1(10, "%s", sock->msg);
 973        fputs(sock->msg, bs);
 974    }
 975    fclose(bs);
 976    Dmsg0(10, "=== end bootstrap file ===\n");
 977    jcr->bsr = parse_bsr(jcr, jcr->RestoreBootstrap);
 978    if (!jcr->bsr) {
 979       Jmsg(jcr, M_FATAL, 0, _("Error parsing bootstrap file.\n"));
 980       goto bail_out;
 981    }
 982    if (debug_level >= 10) {
 983       dump_bsr(jcr->bsr, true);
 984    }
 985    /* If we got a bootstrap, we are reading, so create read volume list */
 986    create_restore_volume_list(jcr);
 987    ok = true;
 988
 989 bail_out:
 990    unlink(jcr->RestoreBootstrap);
 991    free_pool_memory(jcr->RestoreBootstrap);
 992    jcr->RestoreBootstrap = NULL;
 993    if (!ok) {
 994       sock->fsend(ERROR_bootstrap);
 995       return false;
 996    }
 997    return sock->fsend(OK_bootstrap);
 998 }
 999
1000 static bool bootstrap_cmd(JCR *jcr)
1001 {
1002    return get_bootstrap_file(jcr, jcr->dir_bsock);
1003 }
1004
1005 /*
1006  * Autochanger command from Director
1007  */
1008 static bool changer_cmd(JCR *jcr)
1009 {
1010    POOL_MEM devname;
1011    BSOCK *dir = jcr->dir_bsock;
1012    DEVICE *dev;
1013    DCR *dcr;
1014    const char *cmd = NULL;
1015    bool ok = false;
1016    /*
1017     * A safe_cmd may call autochanger script but does not load/unload
1018     *    slots so it can be done at the same time that the drive is open.
1019     */
1020    bool safe_cmd = false;
1021
1022    if (sscanf(dir->msg, "autochanger list %127s", devname.c_str()) == 1) {
1023       cmd = "list";
1024       safe_cmd = ok = true;
1025    } else if (sscanf(dir->msg, "autochanger slots %127s", devname.c_str()) == 1) {
1026       cmd = "slots";
1027       safe_cmd = ok = true;
1028    } else if (sscanf(dir->msg, "autochanger drives %127s", devname.c_str()) == 1) {
1029       cmd = "drives";
1030       safe_cmd = ok = true;
1031    }
1032    if (ok) {
1033       dcr = find_device(jcr, devname, -1);
1034       if (dcr) {
1035          dev = dcr->dev;
1036          dev->dlock();                 /* Use P to avoid indefinite block */
1037          if (!dev->device->changer_res) {
1038             dir->fsend(_("3995 Device %s is not an autochanger.\n"),
1039                dev->print_name());
1040          /* Under certain "safe" conditions, we can steal the lock */
1041          } else if (safe_cmd || !dev->is_open() || dev->can_steal_lock()) {
1042             autochanger_cmd(dcr, dir, cmd);
1043          } else if (dev->is_busy() || dev->is_blocked()) {
1044             send_dir_busy_message(dir, dev);
1045          } else {                     /* device not being used */
1046             autochanger_cmd(dcr, dir, cmd);
1047          }
1048          dev->dunlock();
1049          free_dcr(dcr);
1050       } else {
1051          dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
1052       }
1053    } else {  /* error on scanf */
1054       pm_strcpy(jcr->errmsg, dir->msg);
1055       dir->fsend(_("3908 Error scanning autocharger drives/list/slots command: %s\n"),
1056          jcr->errmsg);
1057    }
1058    dir->signal(BNET_EOD);
1059    return true;
1060 }
1061
1062 /*
1063  * Read and return the Volume label
1064  */
1065 static bool readlabel_cmd(JCR *jcr)
1066 {
1067    POOL_MEM devname;
1068    BSOCK *dir = jcr->dir_bsock;
1069    DEVICE *dev;
1070    DCR *dcr;
1071    int Slot;
1072    int drive;
1073
1074    if (sscanf(dir->msg, "readlabel %127s Slot=%d drive=%d", devname.c_str(),
1075        &Slot, &drive) == 3) {
1076       dcr = find_device(jcr, devname, drive);
1077       if (dcr) {
1078          dev = dcr->dev;
1079          dev->dlock();                 /* Use P to avoid indefinite block */
1080          if (!dev->is_open()) {
1081             read_volume_label(jcr, dcr, dev, Slot);
1082             dev->close();
1083          /* Under certain "safe" conditions, we can steal the lock */
1084          } else if (dev->can_steal_lock()) {
1085             read_volume_label(jcr, dcr, dev, Slot);
1086          } else if (dev->is_busy() || dev->is_blocked()) {
1087             send_dir_busy_message(dir, dev);
1088          } else {                     /* device not being used */
1089             read_volume_label(jcr, dcr, dev, Slot);
1090          }
1091          dev->dunlock();
1092          free_dcr(dcr);
1093       } else {
1094          dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
1095       }
1096    } else {
1097       pm_strcpy(jcr->errmsg, dir->msg);
1098       dir->fsend(_("3909 Error scanning readlabel command: %s\n"), jcr->errmsg);
1099    }
1100    dir->signal(BNET_EOD);
1101    return true;
1102 }
1103
1104
1105 /*
1106  * Read the tape label
1107  *
1108  *  Enter with the mutex set
1109  */
1110 static void read_volume_label(JCR *jcr, DCR *dcr, DEVICE *dev, int Slot)
1111 {
1112    BSOCK *dir = jcr->dir_bsock;
1113    bsteal_lock_t hold;
1114
1115    dcr->dev = dev;
1116    steal_device_lock(dev, &hold, BST_WRITING_LABEL);
1117
1118    if (!try_autoload_device(jcr, dcr, Slot, "")) {
1119       goto bail_out;                  /* error */
1120    }
1121
1122    dev->clear_labeled();              /* force read of label */
1123    switch (read_dev_volume_label(dcr)) {
1124    case VOL_OK:
1125       /* DO NOT add quotes around the Volume name. It is scanned in the DIR */
1126       dir->fsend(_("3001 Volume=%s Slot=%d\n"), dev->VolHdr.VolumeName, Slot);
1127       Dmsg1(100, "Volume: %s\n", dev->VolHdr.VolumeName);
1128       break;
1129    default:
1130       dir->fsend(_("3902 Cannot mount Volume on Storage Device %s because:\n%s"),
1131                  dev->print_name(), jcr->errmsg);
1132       break;
1133    }
1134
1135 bail_out:
1136    give_back_device_lock(dev, &hold);
1137    return;
1138 }
1139
1140 static bool try_autoload_device(JCR *jcr, DCR *dcr, int slot, const char *VolName)
1141 {
1142    BSOCK *dir = jcr->dir_bsock;
1143
1144    bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
1145    dcr->VolCatInfo.Slot = slot;
1146    dcr->VolCatInfo.InChanger = slot > 0;
1147    if (autoload_device(dcr, 0, dir) < 0) {    /* autoload if possible */
1148       return false;
1149    }
1150    return true;
1151 }
1152
1153 static void send_dir_busy_message(BSOCK *dir, DEVICE *dev)
1154 {
1155    if (dev->is_blocked()) {
1156       switch (dev->blocked()) {
1157       case BST_UNMOUNTED:
1158          dir->fsend(_("3931 Device %s is BLOCKED. user unmounted.\n"),
1159             dev->print_name());
1160          break;
1161       case BST_UNMOUNTED_WAITING_FOR_SYSOP:
1162          dir->fsend(_("3932 Device %s is BLOCKED. user unmounted during wait for media/mount.\n"),
1163              dev->print_name());
1164          break;
1165       case BST_WAITING_FOR_SYSOP:
1166          dir->fsend(_("3933 Device %s is BLOCKED waiting for media.\n"),
1167             dev->print_name());
1168          break;
1169       case BST_DOING_ACQUIRE:
1170          dir->fsend(_("3934 Device %s is being initialized.\n"),
1171             dev->print_name());
1172          break;
1173       case BST_WRITING_LABEL:
1174          dir->fsend(_("3935 Device %s is blocked labeling a Volume.\n"),
1175             dev->print_name());
1176          break;
1177       default:
1178          dir->fsend(_("3935 Device %s is blocked for unknown reason.\n"),
1179             dev->print_name());
1180          break;
1181       }
1182    } else if (dev->can_read()) {
1183        dir->fsend(_("3936 Device %s is busy reading.\n"),
1184                    dev->print_name());;
1185    } else {
1186        dir->fsend(_("3937 Device %s is busy with %d writer(s).\n"),
1187           dev->print_name(), dev->num_writers);
1188    }
1189 }