2 Bacula® - The Network Backup Solution
4 Copyright (C) 2000-2012 Free Software Foundation Europe e.V.
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 three of the GNU Affero General Public
10 License as published by the Free Software Foundation and included
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.
18 You should have received a copy of the GNU Affero 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
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.
29 * Drive reservation functions for Storage Daemon
33 * Split from job.c and acquire.c June 2005
40 const int dbglvl = 150;
42 static brwlock_t reservation_lock;
44 /* Forward referenced functions */
45 static int can_reserve_drive(DCR *dcr, RCTX &rctx);
46 static int reserve_device(RCTX &rctx);
47 static bool reserve_device_for_read(DCR *dcr);
48 static bool reserve_device_for_append(DCR *dcr, RCTX &rctx);
49 static bool use_device_cmd(JCR *jcr);
50 static void queue_reserve_message(JCR *jcr);
51 static void pop_reserve_messages(JCR *jcr);
52 //void switch_device(DCR *dcr, DEVICE *dev);
54 /* Requests from the Director daemon */
55 static char use_storage[] = "use storage=%127s media_type=%127s "
56 "pool_name=%127s pool_type=%127s append=%d copy=%d stripe=%d\n";
57 static char use_device[] = "use device=%127s\n";
59 /* Responses sent to Director daemon */
60 static char OK_device[] = "3000 OK use device device=%s\n";
61 static char NO_device[] = "3924 Device \"%s\" not in SD Device"
62 " resources or no matching Media Type.\n";
63 static char BAD_use[] = "3913 Bad use command: %s\n";
65 bool use_cmd(JCR *jcr)
68 * Get the device, media, and pool information
70 if (!use_device_cmd(jcr)) {
71 jcr->setJobStatus(JS_ErrorTerminated);
72 memset(jcr->sd_auth_key, 0, strlen(jcr->sd_auth_key));
79 * This allows a given thread to recursively call lock_reservations.
80 * It must, of course, call unlock_... the same number of times.
82 void init_reservations_lock()
85 if ((errstat=rwl_init(&reservation_lock)) != 0) {
87 Emsg1(M_ABORT, 0, _("Unable to initialize reservation lock. ERR=%s\n"),
88 be.bstrerror(errstat));
94 void term_reservations_lock()
96 rwl_destroy(&reservation_lock);
100 int reservations_lock_count = 0;
102 /* This applies to a drive and to Volumes */
103 void _lock_reservations(const char *file, int line)
106 reservations_lock_count++;
107 if ((errstat=rwl_writelock_p(&reservation_lock, file, line)) != 0) {
109 Emsg2(M_ABORT, 0, "rwl_writelock failure. stat=%d: ERR=%s\n",
110 errstat, be.bstrerror(errstat));
114 void _unlock_reservations()
117 reservations_lock_count--;
118 if ((errstat=rwl_writeunlock(&reservation_lock)) != 0) {
120 Emsg2(M_ABORT, 0, "rwl_writeunlock failure. stat=%d: ERR=%s\n",
121 errstat, be.bstrerror(errstat));
125 void DCR::set_reserved()
128 Dmsg2(dbglvl, "Inc reserve=%d dev=%s\n", dev->num_reserved(), dev->print_name());
132 void DCR::clear_reserved()
137 Dmsg2(dbglvl, "Dec reserve=%d dev=%s\n", dev->num_reserved(), dev->print_name());
142 * Remove any reservation from a drive and tell the system
143 * that the volume is unused at least by us.
145 void DCR::unreserve_device()
151 reserved_volume = false;
152 /* If we set read mode in reserving, remove it */
153 if (dev->can_read()) {
156 if (dev->num_writers < 0) {
157 Jmsg1(jcr, M_ERROR, 0, _("Hey! num_writers=%d!!!!\n"), dev->num_writers);
158 dev->num_writers = 0;
160 if (dev->num_reserved() == 0 && dev->num_writers == 0) {
161 generate_plugin_event(jcr, bsdEventDeviceClose, this);
170 * We get the following type of information:
172 * use storage=xxx media_type=yyy pool_name=xxx pool_type=yyy append=1 copy=0 strip=0
176 * use storage=xxx media_type=yyy pool_name=xxx pool_type=yyy append=0 copy=0 strip=0
180 static bool use_device_cmd(JCR *jcr)
182 POOL_MEM store_name, dev_name, media_type, pool_name, pool_type;
183 BSOCK *dir = jcr->dir_bsock;
186 int32_t Copy, Stripe;
191 memset(&rctx, 0, sizeof(RCTX));
194 * If there are multiple devices, the director sends us
195 * use_device for each device that it wants to use.
197 dirstore = New(alist(10, not_owned_by_alist));
198 jcr->reserve_msgs = New(alist(10, not_owned_by_alist));
200 Dmsg1(dbglvl, "<dird: %s", dir->msg);
201 ok = sscanf(dir->msg, use_storage, store_name.c_str(),
202 media_type.c_str(), pool_name.c_str(),
203 pool_type.c_str(), &append, &Copy, &Stripe) == 7;
208 jcr->write_store = dirstore;
210 jcr->read_store = dirstore;
212 rctx.append = append;
213 unbash_spaces(store_name);
214 unbash_spaces(media_type);
215 unbash_spaces(pool_name);
216 unbash_spaces(pool_type);
217 store = new DIRSTORE;
218 dirstore->append(store);
219 memset(store, 0, sizeof(DIRSTORE));
220 store->device = New(alist(10));
221 bstrncpy(store->name, store_name, sizeof(store->name));
222 bstrncpy(store->media_type, media_type, sizeof(store->media_type));
223 bstrncpy(store->pool_name, pool_name, sizeof(store->pool_name));
224 bstrncpy(store->pool_type, pool_type, sizeof(store->pool_type));
225 store->append = append;
227 /* Now get all devices */
228 while (dir->recv() >= 0) {
229 Dmsg1(dbglvl, "<dird device: %s", dir->msg);
230 ok = sscanf(dir->msg, use_device, dev_name.c_str()) == 1;
234 unbash_spaces(dev_name);
235 store->device->append(bstrdup(dev_name.c_str()));
237 } while (ok && dir->recv() >= 0);
240 /* Developer debug code */
242 if (debug_level >= dbglvl) {
243 foreach_alist(store, dirstore) {
244 Dmsg5(dbglvl, "Storage=%s media_type=%s pool=%s pool_type=%s append=%d\n",
245 store->name, store->media_type, store->pool_name,
246 store->pool_type, store->append);
247 foreach_alist(device_name, store->device) {
248 Dmsg1(dbglvl, " Device=%s\n", device_name);
254 init_jcr_device_wait_timers(jcr);
255 jcr->dcr = new_dcr(jcr, NULL, NULL); /* get a dcr */
257 BSOCK *dir = jcr->dir_bsock;
258 dir->fsend(_("3939 Could not get dcr\n"));
259 Dmsg1(dbglvl, ">dird: %s", dir->msg);
263 * At this point, we have a list of all the Director's Storage
264 * resources indicated for this Job, which include Pool, PoolType,
265 * storage name, and Media type.
266 * Then for each of the Storage resources, we have a list of
267 * device names that were given.
269 * Wiffle through them and find one that can do the backup.
272 int wait_for_device_retries = 0;
275 rctx.notify_dir = true;
277 /* Put new dcr in proper location */
279 rctx.jcr->dcr = jcr->dcr;
281 rctx.jcr->read_dcr = jcr->dcr;
284 for ( ; !fail && !job_canceled(jcr); ) {
285 pop_reserve_messages(jcr);
286 rctx.suitable_device = false;
287 rctx.have_volume = false;
288 rctx.VolumeName[0] = 0;
289 rctx.any_drive = false;
290 if (!jcr->PreferMountedVols) {
292 * Here we try to find a drive that is not used.
293 * This will maximize the use of available drives.
296 rctx.num_writers = 20000000; /* start with impossible number */
297 rctx.low_use_drive = NULL;
298 rctx.PreferMountedVols = false;
299 rctx.exact_match = false;
300 rctx.autochanger_only = true;
301 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
304 /* Look through all drives possibly for low_use drive */
305 if (rctx.low_use_drive) {
306 rctx.try_low_use_drive = true;
307 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
310 rctx.try_low_use_drive = false;
312 rctx.autochanger_only = false;
313 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
318 * Now we look for a drive that may or may not be in
321 /* Look for an exact Volume match all drives */
322 rctx.PreferMountedVols = true;
323 rctx.exact_match = true;
324 rctx.autochanger_only = false;
325 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
328 /* Look for any mounted drive */
329 rctx.exact_match = false;
330 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
334 rctx.any_drive = true;
335 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
338 /* Keep reservations locked *except* during wait_for_device() */
339 unlock_reservations();
341 * The idea of looping on repeat a few times it to ensure
342 * that if there is some subtle timing problem between two
343 * jobs, we will simply try again, and most likely succeed.
344 * This can happen if one job reserves a drive or finishes using
345 * a drive at the same time a second job wants it.
347 if (repeat++ > 1) { /* try algorithm 3 times */
348 bmicrosleep(30, 0); /* wait a bit */
349 Dmsg0(dbglvl, "repeat reserve algorithm\n");
350 } else if (!rctx.suitable_device || !wait_for_device(jcr, wait_for_device_retries)) {
351 Dmsg0(dbglvl, "Fail. !suitable_device || !wait_for_device\n");
355 dir->signal(BNET_HEARTBEAT); /* Inform Dir that we are alive */
357 unlock_reservations();
360 * If we get here, there are no suitable devices available, which
361 * means nothing configured. If a device is suitable but busy
362 * with another Volume, we will not come here.
364 unbash_spaces(dir->msg);
365 pm_strcpy(jcr->errmsg, dir->msg);
366 Jmsg(jcr, M_FATAL, 0, _("Device reservation failed for JobId=%d: %s\n"),
367 jcr->JobId, jcr->errmsg);
368 dir->fsend(NO_device, dev_name.c_str());
370 Dmsg1(dbglvl, ">dird: %s", dir->msg);
373 unbash_spaces(dir->msg);
374 pm_strcpy(jcr->errmsg, dir->msg);
375 Jmsg(jcr, M_FATAL, 0, _("Failed command: %s\n"), jcr->errmsg);
376 dir->fsend(BAD_use, jcr->errmsg);
377 Dmsg1(dbglvl, ">dird: %s", dir->msg);
380 release_reserve_messages(jcr);
386 * Walk through the autochanger resources and check if
387 * the volume is in one of them.
389 * Returns: true if volume is in device
392 static bool is_vol_in_autochanger(RCTX &rctx, VOLRES *vol)
394 AUTOCHANGER *changer = vol->dev->device->changer_res;
396 /* Find resource, and make sure we were able to open it */
397 if (strcmp(rctx.device_name, changer->hdr.name) == 0) {
398 Dmsg1(dbglvl, "Found changer device %s\n", vol->dev->device->hdr.name);
401 Dmsg1(dbglvl, "Incorrect changer device %s\n", changer->hdr.name);
406 * Search for a device suitable for this job.
407 * Note, this routine sets sets rctx.suitable_device if any
408 * device exists within the SD. The device may not be actually
410 * It also returns if it finds a useable device.
412 bool find_suitable_device_for_job(JCR *jcr, RCTX &rctx)
421 dirstore = jcr->write_store;
423 dirstore = jcr->read_store;
425 Dmsg5(dbglvl, "Start find_suit_dev PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
426 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
427 rctx.autochanger_only, rctx.any_drive);
430 * If the appropriate conditions of this if are met, namely that
431 * we are appending and the user wants mounted drive (or we
432 * force try a mounted drive because they are all busy), we
433 * start by looking at all the Volumes in the volume list.
435 if (!is_vol_list_empty() && rctx.append && rctx.PreferMountedVols) {
436 dlist *temp_vol_list;
438 temp_vol_list = dup_vol_list(jcr);
440 /* Look through reserved volumes for one we can use */
441 Dmsg0(dbglvl, "look for vol in vol list\n");
442 foreach_dlist(vol, temp_vol_list) {
444 Dmsg1(dbglvl, "vol=%s no dev\n", vol->vol_name);
447 /* Check with Director if this Volume is OK */
448 bstrncpy(dcr->VolumeName, vol->vol_name, sizeof(dcr->VolumeName));
449 if (!dir_get_volume_info(dcr, GET_VOL_INFO_FOR_WRITE)) {
453 Dmsg1(dbglvl, "vol=%s OK for this job\n", vol->vol_name);
454 foreach_alist(store, dirstore) {
457 foreach_alist(device_name, store->device) {
458 /* Found a device, try to use it */
459 rctx.device_name = device_name;
460 rctx.device = vol->dev->device;
462 if (vol->dev->is_autochanger()) {
463 Dmsg1(dbglvl, "vol=%s is in changer\n", vol->vol_name);
464 if (!is_vol_in_autochanger(rctx, vol) || !vol->dev->autoselect) {
467 } else if (strcmp(device_name, vol->dev->device->hdr.name) != 0) {
468 Dmsg2(dbglvl, "device=%s not suitable want %s\n",
469 vol->dev->device->hdr.name, device_name);
473 bstrncpy(rctx.VolumeName, vol->vol_name, sizeof(rctx.VolumeName));
474 rctx.have_volume = true;
475 /* Try reserving this device and volume */
476 Dmsg2(dbglvl, "try vol=%s on device=%s\n", rctx.VolumeName, device_name);
477 stat = reserve_device(rctx);
478 if (stat == 1) { /* found available device */
479 Dmsg1(dbglvl, "Suitable device found=%s\n", device_name);
482 } else if (stat == 0) { /* device busy */
483 Dmsg1(dbglvl, "Suitable device=%s, busy: not use\n", device_name);
485 /* otherwise error */
486 Dmsg0(dbglvl, "No suitable device found.\n");
488 rctx.have_volume = false;
489 rctx.VolumeName[0] = 0;
498 } /* end for loop over reserved volumes */
500 Dmsg0(dbglvl, "lock volumes\n");
501 free_temp_vol_list(temp_vol_list);
504 Dmsg1(dbglvl, "OK dev found. Vol=%s from in-use vols list\n", rctx.VolumeName);
509 * No reserved volume we can use, so now search for an available device.
511 * For each storage device that the user specified, we
512 * search and see if there is a resource for that device.
514 foreach_alist(store, dirstore) {
516 foreach_alist(device_name, store->device) {
518 rctx.device_name = device_name;
519 stat = search_res_for_device(rctx);
520 if (stat == 1) { /* found available device */
521 Dmsg1(dbglvl, "available device found=%s\n", device_name);
524 } else if (stat == 0) { /* device busy */
525 Dmsg1(dbglvl, "No usable device=%s, busy: not use\n", device_name);
527 /* otherwise error */
528 Dmsg0(dbglvl, "No usable device found.\n");
536 Dmsg1(dbglvl, "OK dev found. Vol=%s\n", rctx.VolumeName);
538 Dmsg0(dbglvl, "Leave find_suit_dev: no dev found.\n");
544 * Search for a particular storage device with particular storage
545 * characteristics (MediaType).
547 int search_res_for_device(RCTX &rctx)
549 AUTOCHANGER *changer;
552 Dmsg1(dbglvl, "search res for %s\n", rctx.device_name);
553 /* Look through Autochangers first */
554 foreach_res(changer, R_AUTOCHANGER) {
555 Dmsg1(dbglvl, "Try match changer res=%s\n", changer->hdr.name);
556 /* Find resource, and make sure we were able to open it */
557 if (strcmp(rctx.device_name, changer->hdr.name) == 0) {
558 /* Try each device in this AutoChanger */
559 foreach_alist(rctx.device, changer->device) {
560 Dmsg1(dbglvl, "Try changer device %s\n", rctx.device->hdr.name);
561 if (!rctx.device->autoselect) {
562 Dmsg1(100, "Device %s not autoselect skipped.\n",
563 rctx.device->hdr.name);
564 continue; /* device is not available */
566 stat = reserve_device(rctx);
567 if (stat != 1) { /* try another device */
571 if (rctx.store->append == SD_APPEND) {
572 Dmsg2(dbglvl, "Device %s reserved=%d for append.\n",
573 rctx.device->hdr.name, rctx.jcr->dcr->dev->num_reserved());
575 Dmsg2(dbglvl, "Device %s reserved=%d for read.\n",
576 rctx.device->hdr.name, rctx.jcr->read_dcr->dev->num_reserved());
583 /* Now if requested look through regular devices */
584 if (!rctx.autochanger_only) {
585 foreach_res(rctx.device, R_DEVICE) {
586 Dmsg1(dbglvl, "Try match res=%s\n", rctx.device->hdr.name);
587 /* Find resource, and make sure we were able to open it */
588 if (strcmp(rctx.device_name, rctx.device->hdr.name) == 0) {
589 stat = reserve_device(rctx);
590 if (stat != 1) { /* try another device */
594 if (rctx.store->append == SD_APPEND) {
595 Dmsg2(dbglvl, "Device %s reserved=%d for append.\n",
596 rctx.device->hdr.name, rctx.jcr->dcr->dev->num_reserved());
598 Dmsg2(dbglvl, "Device %s reserved=%d for read.\n",
599 rctx.device->hdr.name, rctx.jcr->read_dcr->dev->num_reserved());
605 return -1; /* nothing found */
609 * Try to reserve a specific device.
611 * Returns: 1 -- OK, have DCR
615 static int reserve_device(RCTX &rctx)
619 const int name_len = MAX_NAME_LENGTH;
621 /* Make sure MediaType is OK */
622 Dmsg2(dbglvl, "chk MediaType device=%s request=%s\n",
623 rctx.device->media_type, rctx.store->media_type);
624 if (strcmp(rctx.device->media_type, rctx.store->media_type) != 0) {
628 /* Make sure device exists -- i.e. we can stat() it */
629 if (!rctx.device->dev) {
630 rctx.device->dev = init_dev(rctx.jcr, rctx.device);
632 if (!rctx.device->dev) {
633 if (rctx.device->changer_res) {
634 Jmsg(rctx.jcr, M_WARNING, 0, _("\n"
635 " Device \"%s\" in changer \"%s\" requested by DIR could not be opened or does not exist.\n"),
636 rctx.device->hdr.name, rctx.device_name);
638 Jmsg(rctx.jcr, M_WARNING, 0, _("\n"
639 " Device \"%s\" requested by DIR could not be opened or does not exist.\n"),
642 return -1; /* no use waiting */
645 rctx.suitable_device = true;
646 Dmsg1(dbglvl, "try reserve %s\n", rctx.device->hdr.name);
647 if (rctx.store->append) {
648 dcr = new_dcr(rctx.jcr, rctx.jcr->dcr, rctx.device->dev);
650 dcr = new_dcr(rctx.jcr, rctx.jcr->read_dcr, rctx.device->dev);
653 BSOCK *dir = rctx.jcr->dir_bsock;
654 dir->fsend(_("3926 Could not get dcr for device: %s\n"), rctx.device_name);
655 Dmsg1(dbglvl, ">dird: %s", dir->msg);
658 bstrncpy(dcr->pool_name, rctx.store->pool_name, name_len);
659 bstrncpy(dcr->pool_type, rctx.store->pool_type, name_len);
660 bstrncpy(dcr->media_type, rctx.store->media_type, name_len);
661 bstrncpy(dcr->dev_name, rctx.device_name, name_len);
662 if (rctx.store->append == SD_APPEND) {
663 Dmsg2(dbglvl, "call reserve for append: have_vol=%d vol=%s\n", rctx.have_volume, rctx.VolumeName);
664 ok = reserve_device_for_append(dcr, rctx);
670 Dmsg5(dbglvl, "Reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n",
671 dcr->dev->num_reserved(),
672 dcr->dev_name, dcr->media_type, dcr->pool_name, ok);
673 Dmsg3(dbglvl, "Vol=%s num_writers=%d, have_vol=%d\n",
674 rctx.VolumeName, dcr->dev->num_writers, rctx.have_volume);
675 if (rctx.have_volume) {
676 Dmsg0(dbglvl, "Call reserve_volume for append.\n");
677 if (reserve_volume(dcr, rctx.VolumeName)) {
678 Dmsg1(dbglvl, "Reserved vol=%s\n", rctx.VolumeName);
680 Dmsg1(dbglvl, "Could not reserve vol=%s\n", rctx.VolumeName);
684 dcr->any_volume = true;
685 Dmsg0(dbglvl, "no vol, call find_next_appendable_vol.\n");
686 if (dir_find_next_appendable_volume(dcr)) {
687 bstrncpy(rctx.VolumeName, dcr->VolumeName, sizeof(rctx.VolumeName));
688 rctx.have_volume = true;
689 Dmsg1(dbglvl, "looking for Volume=%s\n", rctx.VolumeName);
691 Dmsg0(dbglvl, "No next volume found\n");
692 rctx.have_volume = false;
693 rctx.VolumeName[0] = 0;
695 * If there is at least one volume that is valid and in use,
696 * but we get here, check if we are running with prefers
697 * non-mounted drives. In that case, we have selected a
698 * non-used drive and our one and only volume is mounted
699 * elsewhere, so we bail out and retry using that drive.
701 if (dcr->found_in_use() && !rctx.PreferMountedVols) {
702 rctx.PreferMountedVols = true;
703 if (dcr->VolumeName[0]) {
704 dcr->unreserve_device();
709 * Note. Under some circumstances, the Director can hand us
710 * a Volume name that is not the same as the one on the current
711 * drive, and in that case, the call above to find the next
712 * volume will fail because in attempting to reserve the Volume
713 * the code will realize that we already have a tape mounted,
714 * and it will fail. This *should* only happen if there are
715 * writers, thus the following test. In that case, we simply
716 * bail out, and continue waiting, rather than plunging on
717 * and hoping that the operator can resolve the problem.
719 if (dcr->dev->num_writers != 0) {
720 if (dcr->VolumeName[0]) {
721 dcr->unreserve_device();
728 ok = reserve_device_for_read(dcr);
730 rctx.jcr->read_dcr = dcr;
731 Dmsg5(dbglvl, "Read reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n",
732 dcr->dev->num_reserved(),
733 dcr->dev_name, dcr->media_type, dcr->pool_name, ok);
740 if (rctx.notify_dir) {
742 BSOCK *dir = rctx.jcr->dir_bsock;
743 pm_strcpy(dev_name, rctx.device->hdr.name);
744 bash_spaces(dev_name);
745 ok = dir->fsend(OK_device, dev_name.c_str()); /* Return real device name */
746 Dmsg1(dbglvl, ">dird: %s", dir->msg);
753 rctx.have_volume = false;
754 rctx.VolumeName[0] = 0;
755 Dmsg0(dbglvl, "Not OK.\n");
760 * We "reserve" the drive by setting the ST_READ bit. No one else
761 * should touch the drive until that is cleared.
762 * This allows the DIR to "reserve" the device before actually
765 static bool reserve_device_for_read(DCR *dcr)
767 DEVICE *dev = dcr->dev;
772 if (job_canceled(jcr)) {
778 if (dev->is_device_unmounted()) {
779 Dmsg1(dbglvl, "Device %s is BLOCKED due to user unmount.\n", dev->print_name());
780 Mmsg(jcr->errmsg, _("3601 JobId=%u device %s is BLOCKED due to user unmount.\n"),
781 jcr->JobId, dev->print_name());
782 queue_reserve_message(jcr);
786 if (dev->is_busy()) {
787 Dmsg4(dbglvl, "Device %s is busy ST_READ=%d num_writers=%d reserved=%d.\n",
789 dev->state & ST_READ?1:0, dev->num_writers, dev->num_reserved());
790 Mmsg(jcr->errmsg, _("3602 JobId=%u device %s is busy (already reading/writing).\n"),
791 jcr->JobId, dev->print_name());
792 queue_reserve_message(jcr);
796 /* Note: on failure this returns jcr->errmsg properly edited */
797 if (generate_plugin_event(jcr, bsdEventDeviceTryOpen, dcr) != bRC_OK) {
798 queue_reserve_message(jcr);
813 * We reserve the device for appending by incrementing
814 * num_reserved(). We do virtually all the same work that
815 * is done in acquire_device_for_append(), but we do
816 * not attempt to mount the device. This routine allows
817 * the DIR to reserve multiple devices before *really*
818 * starting the job. It also permits the SD to refuse
819 * certain devices (not up, ...).
821 * Note, in reserving a device, if the device is for the
822 * same pool and the same pool type, then it is acceptable.
823 * The Media Type has already been checked. If we are
824 * the first tor reserve the device, we put the pool
825 * name and pool type in the device record.
827 static bool reserve_device_for_append(DCR *dcr, RCTX &rctx)
830 DEVICE *dev = dcr->dev;
834 if (job_canceled(jcr)) {
840 /* If device is being read, we cannot write it */
841 if (dev->can_read()) {
842 Mmsg(jcr->errmsg, _("3603 JobId=%u device %s is busy reading.\n"),
843 jcr->JobId, dev->print_name());
844 Dmsg1(dbglvl, "Failed: %s", jcr->errmsg);
845 queue_reserve_message(jcr);
849 /* If device is unmounted, we are out of luck */
850 if (dev->is_device_unmounted()) {
851 Mmsg(jcr->errmsg, _("3604 JobId=%u device %s is BLOCKED due to user unmount.\n"),
852 jcr->JobId, dev->print_name());
853 Dmsg1(dbglvl, "Failed: %s", jcr->errmsg);
854 queue_reserve_message(jcr);
858 Dmsg1(dbglvl, "reserve_append device is %s\n", dev->print_name());
860 /* Now do detailed tests ... */
861 if (can_reserve_drive(dcr, rctx) != 1) {
862 Dmsg0(dbglvl, "can_reserve_drive!=1\n");
866 /* Note: on failure this returns jcr->errmsg properly edited */
867 if (generate_plugin_event(jcr, bsdEventDeviceTryOpen, dcr) != bRC_OK) {
868 queue_reserve_message(jcr);
879 static int is_pool_ok(DCR *dcr)
881 DEVICE *dev = dcr->dev;
884 /* Now check if we want the same Pool and pool type */
885 if (strcmp(dev->pool_name, dcr->pool_name) == 0 &&
886 strcmp(dev->pool_type, dcr->pool_type) == 0) {
887 /* OK, compatible device */
888 Dmsg1(dbglvl, "OK dev: %s num_writers=0, reserved, pool matches\n", dev->print_name());
891 /* Drive Pool not suitable for us */
893 "3608 JobId=%u wants Pool=\"%s\" but have Pool=\"%s\" nreserve=%d on drive %s.\n"),
894 (uint32_t)jcr->JobId, dcr->pool_name, dev->pool_name,
895 dev->num_reserved(), dev->print_name());
896 Dmsg1(dbglvl, "Failed: %s", jcr->errmsg);
897 queue_reserve_message(jcr);
902 static bool is_max_jobs_ok(DCR *dcr)
904 DEVICE *dev = dcr->dev;
907 Dmsg5(dbglvl, "MaxJobs=%d Jobs=%d reserves=%d Status=%s Vol=%s\n",
908 dcr->VolCatInfo.VolCatMaxJobs,
909 dcr->VolCatInfo.VolCatJobs, dev->num_reserved(),
910 dcr->VolCatInfo.VolCatStatus,
912 /* Limit max concurrent jobs on this drive */
913 if (dev->max_concurrent_jobs > 0 && dev->max_concurrent_jobs <=
914 (uint32_t)(dev->num_writers + dev->num_reserved())) {
915 /* Max Concurrent Jobs depassed or already reserved */
916 Mmsg(jcr->errmsg, _("3609 JobId=%u Max concurrent jobs exceeded on drive %s.\n"),
917 (uint32_t)jcr->JobId, dev->print_name());
918 Dmsg1(dbglvl, "Failed: %s", jcr->errmsg);
919 queue_reserve_message(jcr);
922 if (strcmp(dcr->VolCatInfo.VolCatStatus, "Recycle") == 0) {
925 if (dcr->VolCatInfo.VolCatMaxJobs > 0 && dcr->VolCatInfo.VolCatMaxJobs <=
926 (dcr->VolCatInfo.VolCatJobs + dev->num_reserved())) {
927 /* Max Job Vols depassed or already reserved */
928 Mmsg(jcr->errmsg, _("3610 JobId=%u Volume max jobs exceeded on drive %s.\n"),
929 (uint32_t)jcr->JobId, dev->print_name());
930 Dmsg1(dbglvl, "reserve dev failed: %s", jcr->errmsg);
931 queue_reserve_message(jcr);
932 return false; /* wait */
938 * Returns: 1 if drive can be reserved
939 * 0 if we should wait
940 * -1 on error or impossibility
942 static int can_reserve_drive(DCR *dcr, RCTX &rctx)
944 DEVICE *dev = dcr->dev;
947 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
948 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
949 rctx.autochanger_only, rctx.any_drive);
951 /* Check for max jobs on this Volume */
952 if (!is_max_jobs_ok(dcr)) {
956 /* setting any_drive overrides PreferMountedVols flag */
957 if (!rctx.any_drive) {
959 * When PreferMountedVols is set, we keep track of the
960 * drive in use that has the least number of writers, then if
961 * no unmounted drive is found, we try that drive. This
962 * helps spread the load to the least used drives.
964 if (rctx.try_low_use_drive && dev == rctx.low_use_drive) {
965 Dmsg2(dbglvl, "OK dev=%s == low_drive=%s.\n",
966 dev->print_name(), rctx.low_use_drive->print_name());
969 /* If he wants a free drive, but this one is busy, no go */
970 if (!rctx.PreferMountedVols && dev->is_busy()) {
971 /* Save least used drive */
972 if ((dev->num_writers + dev->num_reserved()) < rctx.num_writers) {
973 rctx.num_writers = dev->num_writers + dev->num_reserved();
974 rctx.low_use_drive = dev;
975 Dmsg2(dbglvl, "set low use drive=%s num_writers=%d\n",
976 dev->print_name(), rctx.num_writers);
978 Dmsg1(dbglvl, "not low use num_writers=%d\n", dev->num_writers+dev->num_reserved());
980 Mmsg(jcr->errmsg, _("3605 JobId=%u wants free drive but device %s is busy.\n"),
981 jcr->JobId, dev->print_name());
982 Dmsg1(dbglvl, "Failed: %s", jcr->errmsg);
983 queue_reserve_message(jcr);
987 /* Check for prefer mounted volumes */
988 if (rctx.PreferMountedVols && !dev->vol && dev->is_tape()) {
989 Mmsg(jcr->errmsg, _("3606 JobId=%u prefers mounted drives, but drive %s has no Volume.\n"),
990 jcr->JobId, dev->print_name());
991 Dmsg1(dbglvl, "Failed: %s", jcr->errmsg);
992 queue_reserve_message(jcr);
993 return 0; /* No volume mounted */
996 /* Check for exact Volume name match */
997 /* ***FIXME*** for Disk, we can accept any volume that goes with this
1000 if (rctx.exact_match && rctx.have_volume) {
1002 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
1003 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
1004 rctx.autochanger_only, rctx.any_drive);
1005 Dmsg4(dbglvl, "have_vol=%d have=%s resvol=%s want=%s\n",
1006 rctx.have_volume, dev->VolHdr.VolumeName,
1007 dev->vol?dev->vol->vol_name:"*none*", rctx.VolumeName);
1008 ok = strcmp(dev->VolHdr.VolumeName, rctx.VolumeName) == 0 ||
1009 (dev->vol && strcmp(dev->vol->vol_name, rctx.VolumeName) == 0);
1011 Mmsg(jcr->errmsg, _("3607 JobId=%u wants Vol=\"%s\" drive has Vol=\"%s\" on drive %s.\n"),
1012 jcr->JobId, rctx.VolumeName, dev->VolHdr.VolumeName,
1014 queue_reserve_message(jcr);
1015 Dmsg3(dbglvl, "not OK: dev have=%s resvol=%s want=%s\n",
1016 dev->VolHdr.VolumeName, dev->vol?dev->vol->vol_name:"*none*", rctx.VolumeName);
1019 if (!dcr->can_i_use_volume()) {
1020 return 0; /* fail if volume on another drive */
1025 /* Check for unused autochanger drive */
1026 if (rctx.autochanger_only && !dev->is_busy() &&
1027 dev->VolHdr.VolumeName[0] == 0) {
1028 /* Device is available but not yet reserved, reserve it for us */
1029 Dmsg1(dbglvl, "OK Res Unused autochanger %s.\n", dev->print_name());
1030 bstrncpy(dev->pool_name, dcr->pool_name, sizeof(dev->pool_name));
1031 bstrncpy(dev->pool_type, dcr->pool_type, sizeof(dev->pool_type));
1032 return 1; /* reserve drive */
1036 * Handle the case that there are no writers
1038 if (dev->num_writers == 0) {
1039 /* Now check if there are any reservations on the drive */
1040 if (dev->num_reserved()) {
1041 return is_pool_ok(dcr);
1042 } else if (dev->can_append()) {
1043 if (is_pool_ok(dcr)) {
1046 /* Changing pool, unload old tape if any in drive */
1047 Dmsg0(dbglvl, "OK dev: num_writers=0, not reserved, pool change, unload changer\n");
1048 /* ***FIXME*** use set_unload() */
1049 unload_autochanger(dcr, -1);
1052 /* Device is available but not yet reserved, reserve it for us */
1053 Dmsg1(dbglvl, "OK Dev avail reserved %s\n", dev->print_name());
1054 bstrncpy(dev->pool_name, dcr->pool_name, sizeof(dev->pool_name));
1055 bstrncpy(dev->pool_type, dcr->pool_type, sizeof(dev->pool_type));
1056 return 1; /* reserve drive */
1060 * Check if the device is in append mode with writers (i.e.
1061 * available if pool is the same).
1063 if (dev->can_append() || dev->num_writers > 0) {
1064 return is_pool_ok(dcr);
1066 Pmsg1(000, _("Logic error!!!! JobId=%u Should not get here.\n"), (int)jcr->JobId);
1067 Mmsg(jcr->errmsg, _("3910 JobId=%u Logic error!!!! drive %s Should not get here.\n"),
1068 jcr->JobId, dev->print_name());
1069 queue_reserve_message(jcr);
1070 Jmsg0(jcr, M_FATAL, 0, _("Logic error!!!! Should not get here.\n"));
1071 return -1; /* error, should not get here */
1073 Mmsg(jcr->errmsg, _("3911 JobId=%u failed reserve drive %s.\n"),
1074 jcr->JobId, dev->print_name());
1075 queue_reserve_message(jcr);
1076 Dmsg1(dbglvl, "Failed: No reserve %s\n", dev->print_name());
1084 * Queue a reservation error or failure message for this jcr
1086 static void queue_reserve_message(JCR *jcr)
1094 msgs = jcr->reserve_msgs;
1099 * Look for duplicate message. If found, do
1102 for (i=msgs->size()-1; i >= 0; i--) {
1103 msg = (char *)msgs->get(i);
1107 /* Comparison based on 4 digit message number */
1108 if (strncmp(msg, jcr->errmsg, 4) == 0) {
1112 /* Message unique, so insert it */
1113 jcr->reserve_msgs->push(bstrdup(jcr->errmsg));
1120 * Send any reservation messages queued for this jcr
1122 void send_drive_reserve_messages(JCR *jcr, void sendit(const char *msg, int len, void *sarg), void *arg)
1129 msgs = jcr->reserve_msgs;
1130 if (!msgs || msgs->size() == 0) {
1133 for (i=msgs->size()-1; i >= 0; i--) {
1134 msg = (char *)msgs->get(i);
1136 sendit(" ", 3, arg);
1137 sendit(msg, strlen(msg), arg);
1148 * Pop and release any reservations messages
1150 static void pop_reserve_messages(JCR *jcr)
1156 msgs = jcr->reserve_msgs;
1160 while ((msg = (char *)msgs->pop())) {
1168 * Also called from acquire.c
1170 void release_reserve_messages(JCR *jcr)
1172 pop_reserve_messages(jcr);
1174 if (!jcr->reserve_msgs) {
1177 delete jcr->reserve_msgs;
1178 jcr->reserve_msgs = NULL;