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

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