X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=bacula%2Fsrc%2Fstored%2Fdev.h;h=fbfa735b687ba7294f50a8dbe0a1fc76fe719600;hb=a9ee2b24de8abaf0355f5fe2fbf9cb0a5204f76b;hp=2988caf884fe8657131ab00a534d115fcbc69f22;hpb=011cb2c216b6de9f656fed85a24ac9d9537c04bf;p=bacula%2Fbacula diff --git a/bacula/src/stored/dev.h b/bacula/src/stored/dev.h index 2988caf884..fbfa735b68 100644 --- a/bacula/src/stored/dev.h +++ b/bacula/src/stored/dev.h @@ -1,3 +1,30 @@ +/* + Bacula® - The Network Backup Solution + + Copyright (C) 2000-2008 Free Software Foundation Europe e.V. + + The main author of Bacula is Kern Sibbald, with contributions from + many others, a complete list can be found in the file AUTHORS. + This program is Free Software; you can redistribute it and/or + modify it under the terms of version two of the GNU General Public + License as published by the Free Software Foundation and included + in the file LICENSE. + + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + 02110-1301, USA. + + Bacula® is a registered trademark of John Walker. + The licensor of Bacula is the Free Software Foundation Europe + (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich, + Switzerland, email:ftf@fsfeurope.org. +*/ /* * Definitions for using the Device functions in Bacula * Tape and File storage access @@ -7,19 +34,36 @@ * Version $Id$ * */ -/* - Copyright (C) 2000-2005 Kern Sibbald - - This program is free software; you can redistribute it and/or - modify it under the terms of the GNU General Public License - version 2 as ammended with additional clauses defined in the - file LICENSE in the main source directory. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - the file LICENSE for additional details. +/* + * Some details of how volume and device reservations work + * + * class VOLRES: + * set_in_use() volume being used on current drive + * clear_in_use() no longer being used. Can be re-used or moved. + * set_swapping() set volume being moved to another drive + * is_swapping() volume is being moved to another drive + * clear_swapping() volume normal + * + * class DEVICE: + * set_load() set to load volume + * needs_load() volume must be loaded (i.e. set_load done) + * clear_load() load done. + * set_unload() set to unload volume + * needs_unload() volume must be unloaded + * clear_unload() volume unloaded + * + * reservations are temporary until the drive is acquired + * inc_reserved() increments num of reservations + * dec_reserved() decrements num of reservations + * num_reserved() number of reservations + * + * class DCR: + * set_reserved() sets local reserve flag and calls dev->inc_reserved() + * clear_reserved() clears local reserve flag and calls dev->dec_reserved() + * is_reserved() returns local reserved flag + * unreserve_device() much more complete unreservation + * */ @@ -28,26 +72,32 @@ #undef DCR /* used by Bacula */ -/* #define NEW_LOCK 1 */ - -#define new_lock_device(dev) _new_lock_device(__FILE__, __LINE__, (dev)) -#define new_lock_device_state(dev,state) _new_lock_device(__FILE__, __LINE__, (dev), (state)) -#define new_unlock_device(dev) _new_unlock_device(__FILE__, __LINE__, (dev)) - -#define lock_device(d) _lock_device(__FILE__, __LINE__, (d)) -#define unlock_device(d) _unlock_device(__FILE__, __LINE__, (d)) -#define block_device(d, s) _block_device(__FILE__, __LINE__, (d), s) -#define unblock_device(d) _unblock_device(__FILE__, __LINE__, (d)) -#define steal_device_lock(d, p, s) _steal_device_lock(__FILE__, __LINE__, (d), (p), s) -#define give_back_device_lock(d, p) _give_back_device_lock(__FILE__, __LINE__, (d), (p)) +/* Return values from wait_for_sysop() */ +enum { + W_ERROR = 1, + W_TIMEOUT, + W_POLL, + W_MOUNT, + W_WAKE +}; /* Arguments to open_dev() */ enum { - OPEN_READ_WRITE = 0, + CREATE_READ_WRITE = 1, + OPEN_READ_WRITE, OPEN_READ_ONLY, OPEN_WRITE_ONLY }; +/* Device types */ +enum { + B_FILE_DEV = 1, + B_TAPE_DEV, + B_DVD_DEV, + B_FIFO_DEV, + B_VTL_DEV +}; + /* Generic status bits returned from status_dev() */ #define BMT_TAPE (1<<0) /* is tape device */ #define BMT_EOF (1<<1) /* just read EOF */ @@ -61,9 +111,6 @@ enum { #define BMT_IM_REP_EN (1<<9) /* immediate report enabled */ -/* Test capabilities */ -#define dev_cap(dev, cap) ((dev)->capabilities & (cap)) - /* Bits for device capabilities */ #define CAP_EOF (1<<0) /* has MTWEOF */ #define CAP_BSR (1<<1) /* has MTBSR */ @@ -93,12 +140,13 @@ enum { #define dev_state(dev, st_state) ((dev)->state & (st_state)) /* Device state bits */ -#define ST_OPENED (1<<0) /* set when device opened */ -#define ST_TAPE (1<<1) /* is a tape device */ -#define ST_FILE (1<<2) /* is a file device */ -#define ST_FIFO (1<<3) /* is a fifo device */ -#define ST_DVD (1<<4) /* is a DVD device */ -#define ST_PROG (1<<5) /* is a program device */ +#define ST_XXXXXX (1<<0) /* was ST_OPENED */ +#define ST_XXXXX (1<<1) /* was ST_TAPE */ +#define ST_XXXX (1<<2) /* was ST_FILE */ +#define ST_XXX (1<<3) /* was ST_FIFO */ +#define ST_XX (1<<4) /* was ST_DVD */ +#define ST_X (1<<5) /* was ST_PROG */ + #define ST_LABEL (1<<6) /* label found */ #define ST_MALLOC (1<<7) /* dev packet malloc'ed in init_dev() */ #define ST_APPEND (1<<8) /* ready for Bacula append */ @@ -109,18 +157,11 @@ enum { #define ST_NEXTVOL (1<<13) /* Start writing on next volume */ #define ST_SHORT (1<<14) /* Short block read */ #define ST_MOUNTED (1<<15) /* the device is mounted to the mount point */ -#define ST_OFFLINE (1<<16) /* set offline by operator */ +#define ST_MEDIA (1<<16) /* Media found in mounted device */ +#define ST_OFFLINE (1<<17) /* set offline by operator */ +#define ST_PART_SPOOLED (1<<18) /* spooling part */ +#define ST_FREESPACE_OK (1<<19) /* Have valid freespace for DVD */ -/* dev_blocked states (mutually exclusive) */ -enum { - BST_NOT_BLOCKED = 0, /* not blocked */ - BST_UNMOUNTED, /* User unmounted device */ - BST_WAITING_FOR_SYSOP, /* Waiting for operator to mount tape */ - BST_DOING_ACQUIRE, /* Opening/validating/moving tape */ - BST_WRITING_LABEL, /* Labeling a tape */ - BST_UNMOUNTED_WAITING_FOR_SYSOP, /* Closed by user during mount request */ - BST_MOUNT /* Mount request */ -}; /* Volume Catalog Information structure definition */ struct VOLUME_CAT_INFO { @@ -139,28 +180,25 @@ struct VOLUME_CAT_INFO { uint32_t EndFile; /* Last file number */ uint32_t EndBlock; /* Last block number */ int32_t LabelType; /* Bacula/ANSI/IBM */ - int32_t Slot; /* Slot in changer */ - bool InChanger; /* Set if vol in current magazine */ + int32_t Slot; /* >0=Slot loaded, 0=nothing, -1=unknown */ uint32_t VolCatMaxJobs; /* Maximum Jobs to write to volume */ uint32_t VolCatMaxFiles; /* Maximum files to write to volume */ uint64_t VolCatMaxBytes; /* Max bytes to write to volume */ uint64_t VolCatCapacityBytes; /* capacity estimate */ - uint64_t VolReadTime; /* time spent reading */ - uint64_t VolWriteTime; /* time spent writing this Volume */ + btime_t VolReadTime; /* time spent reading */ + btime_t VolWriteTime; /* time spent writing this Volume */ + int64_t VolMediaId; /* MediaId */ + utime_t VolFirstWritten; /* Time of first write */ + utime_t VolLastWritten; /* Time of last write */ + bool InChanger; /* Set if vol in current magazine */ char VolCatStatus[20]; /* Volume status */ char VolCatName[MAX_NAME_LENGTH]; /* Desired volume to mount */ }; -typedef struct s_steal_lock { - pthread_t no_wait_id; /* id of no wait thread */ - int dev_blocked; /* state */ - int dev_prev_blocked; /* previous blocked state */ -} bsteal_lock_t; - -struct DEVRES; /* Device resource defined in stored_conf.h */ -int weof_dev(DEVICE *dev, int num); -bool rewind_dev(DEVICE *dev); +class DEVRES; /* Device resource defined in stored_conf.h */ +class DCR; /* forward reference */ +class VOLRES; /* forward reference */ /* * Device structure definition. There is one of these for @@ -168,34 +206,37 @@ bool rewind_dev(DEVICE *dev); * that device and effects all jobs using the device. */ class DEVICE { +private: + int m_fd; /* file descriptor */ + int m_blocked; /* set if we must wait (i.e. change tape) */ + int m_count; /* Mutex use count -- DEBUG only */ + pthread_t m_pid; /* Thread that locked -- DEBUG only */ + bool m_unload; /* set when Volume must be unloaded */ + bool m_load; /* set when Volume must be loaded */ + int m_num_reserved; /* counter of device reservations */ + int32_t m_slot; /* slot loaded in drive or -1 if none */ + public: + DEVICE * volatile swap_dev; /* Swap vol from this device */ dlist *attached_dcrs; /* attached DCR list */ - pthread_mutex_t mutex; /* access control */ + pthread_mutex_t m_mutex; /* access control */ pthread_mutex_t spool_mutex; /* mutex for updating spool_size */ pthread_cond_t wait; /* thread wait variable */ pthread_cond_t wait_next_vol; /* wait for tape to be mounted */ pthread_t no_wait_id; /* this thread must not wait */ - int dev_blocked; /* set if we must wait (i.e. change tape) */ int dev_prev_blocked; /* previous blocked state */ int num_waiting; /* number of threads waiting */ int num_writers; /* number of writing threads */ - int reserved_device; /* number of device reservations */ - - /* New access control in process of being implemented */ - brwlock_t lock; /* New mutual exclusion lock */ - - int use_count; /* usage count on this device 0 or 1 */ - int fd; /* file descriptor */ int capabilities; /* capabilities mask */ int state; /* state mask */ int dev_errno; /* Our own errno */ int mode; /* read/write modes */ int openmode; /* parameter passed to open_dev (useful to reopen the device) */ + int dev_type; /* device type */ bool autoselect; /* Autoselect in autochanger */ - bool open_nowait; /* If set, don t wait on open */ + bool initiated; /* set when init_dev() called */ int label_type; /* Bacula/ANSI/IBM label types */ uint32_t drive_index; /* Autochanger drive index (base 0) */ - int32_t Slot; /* Slot currently in drive (base 1) */ POOLMEM *dev_name; /* Physical device name */ POOLMEM *prt_name; /* Name used for display purposes */ char *errmsg; /* nicely edited error message */ @@ -218,17 +259,19 @@ public: uint64_t max_part_size; /* max part size */ uint64_t part_size; /* current part size */ - uint32_t part; /* current part number */ + uint32_t part; /* current part number (starts at 0) */ uint64_t part_start; /* current part start address (relative to the whole volume) */ - uint32_t num_parts; /* number of parts (total) */ + uint32_t num_dvd_parts; /* number of parts WRITTEN on the DVD */ + /* state ST_FREESPACE_OK is set if free_space is valid */ uint64_t free_space; /* current free space on medium (without the current part) */ - int free_space_errno; /* indicates: - * - free_space_errno == 0: ignore free_space. - * - free_space_errno < 0: an error occured. - * - free_space_errno > 0: free_space is valid. */ + int free_space_errno; /* indicates errno getting freespace */ + bool truncating; /* if set, we are currently truncating the DVD */ + bool blank_dvd; /* if set, we have a blank DVD in the drive */ + utime_t vol_poll_interval; /* interval between polling Vol mount */ DEVRES *device; /* pointer to Device Resource */ + VOLRES *vol; /* Pointer to Volume reservation item */ btimer_t *tid; /* timer id */ VOLUME_CAT_INFO VolCatInfo; /* Volume Catalog Information */ @@ -246,19 +289,43 @@ public: int rem_wait_sec; int num_wait; + btime_t last_timer; /* used by read/write/seek to get stats (usec) */ + btime_t last_tick; /* contains last read/write time (usec) */ + + btime_t DevReadTime; + btime_t DevWriteTime; + uint64_t DevWriteBytes; + uint64_t DevReadBytes; + /* Methods */ - int is_tape() const { return state & ST_TAPE; } - int is_file() const { return state & ST_FILE; } - int is_fifo() const { return state & ST_FIFO; } - int is_dvd() const { return state & ST_DVD; } - int is_open() const { return state & ST_OPENED; } + btime_t get_timer_count(); /* return the last timer interval (ms) */ + + int has_cap(int cap) const { return capabilities & cap; } + void clear_cap(int cap) { capabilities &= ~cap; } + void set_cap(int cap) { capabilities |= cap; } + int is_autochanger() const { return capabilities & CAP_AUTOCHANGER; } + int requires_mount() const { return capabilities & CAP_REQMOUNT; } + int is_removable() const { return capabilities & CAP_REM; } + int is_tape() const { return dev_type == B_TAPE_DEV; } + int is_file() const { return dev_type == B_FILE_DEV; } + int is_fifo() const { return dev_type == B_FIFO_DEV; } + int is_dvd() const { return dev_type == B_DVD_DEV; } + int is_vtl() const { return dev_type == B_VTL_DEV; } + int is_open() const { return m_fd >= 0; } int is_offline() const { return state & ST_OFFLINE; } int is_labeled() const { return state & ST_LABEL; } - int is_busy() const { return state & ST_READ || num_writers || reserved_device; } + int is_mounted() const { return state & ST_MOUNTED; } + int is_unmountable() const { return (is_dvd() || (is_file() && is_removable())); } + int num_reserved() const { return m_num_reserved; }; + int is_part_spooled() const { return state & ST_PART_SPOOLED; } + int have_media() const { return state & ST_MEDIA; } + int is_short_block() const { return state & ST_SHORT; } + int is_busy() const { return (state & ST_READ) || num_writers || num_reserved(); } int at_eof() const { return state & ST_EOF; } int at_eot() const { return state & ST_EOT; } int at_weot() const { return state & ST_WEOT; } int can_append() const { return state & ST_APPEND; } + int is_freespace_ok() const { return state & ST_FREESPACE_OK; } /* * can_write() is meant for checking at the end of a job to see * if we still have a tape (perhaps not if at end of tape @@ -267,39 +334,126 @@ public: int can_write() const { return is_open() && can_append() && is_labeled() && !at_weot(); } int can_read() const { return state & ST_READ; } - bool can_steal_lock() const { return dev_blocked && - (dev_blocked == BST_UNMOUNTED || - dev_blocked == BST_WAITING_FOR_SYSOP || - dev_blocked == BST_UNMOUNTED_WAITING_FOR_SYSOP); }; + bool can_steal_lock() const { return m_blocked && + (m_blocked == BST_UNMOUNTED || + m_blocked == BST_WAITING_FOR_SYSOP || + m_blocked == BST_UNMOUNTED_WAITING_FOR_SYSOP); }; bool waiting_for_mount() const { return - (dev_blocked == BST_UNMOUNTED || - dev_blocked == BST_WAITING_FOR_SYSOP || - dev_blocked == BST_UNMOUNTED_WAITING_FOR_SYSOP); }; - bool weof() { return !weof_dev(this, 1); }; - bool fsr(int num); /* in dev.c */ - bool rewind() { return rewind_dev(this); }; + (m_blocked == BST_UNMOUNTED || + m_blocked == BST_WAITING_FOR_SYSOP || + m_blocked == BST_UNMOUNTED_WAITING_FOR_SYSOP); }; + bool must_unload() const { return m_unload; }; + bool must_load() const { return m_load; }; const char *strerror() const; const char *archive_name() const; const char *name() const; const char *print_name() const; /* Name for display purposes */ - void set_eof(); /* in dev.c */ - void set_eot(); /* in dev.c */ + void set_ateof(); /* in dev.c */ + void set_ateot(); /* in dev.c */ + void set_eot() { state |= ST_EOT; }; + void set_eof() { state |= ST_EOF; }; void set_append() { state |= ST_APPEND; }; void set_labeled() { state |= ST_LABEL; }; - void set_read() { state |= ST_READ; }; + inline void set_read() { state |= ST_READ; }; void set_offline() { state |= ST_OFFLINE; }; + void set_mounted() { state |= ST_MOUNTED; }; + void set_media() { state |= ST_MEDIA; }; + void set_short_block() { state |= ST_SHORT; }; + void set_freespace_ok() { state |= ST_FREESPACE_OK; } + void set_part_spooled(int val) { if (val) state |= ST_PART_SPOOLED; \ + else state &= ~ST_PART_SPOOLED; + }; + void set_unload() { m_unload = true; }; + void set_load() { m_load = true; }; + void inc_reserved() { m_num_reserved++; } + void set_mounted(int val) { if (val) state |= ST_MOUNTED; \ + else state &= ~ST_MOUNTED; }; + void dec_reserved() { m_num_reserved--; ASSERT(m_num_reserved>=0); }; void clear_append() { state &= ~ST_APPEND; }; void clear_read() { state &= ~ST_READ; }; void clear_labeled() { state &= ~ST_LABEL; }; void clear_offline() { state &= ~ST_OFFLINE; }; void clear_eot() { state &= ~ST_EOT; }; void clear_eof() { state &= ~ST_EOF; }; - void block(int why); /* in dev.c */ - void unblock(); /* in dev.c */ - void close(); /* in dev.c */ + void clear_opened() { m_fd = -1; }; + void clear_mounted() { state &= ~ST_MOUNTED; }; + void clear_media() { state &= ~ST_MEDIA; }; + void clear_short_block() { state &= ~ST_SHORT; }; + void clear_freespace_ok() { state &= ~ST_FREESPACE_OK; }; + void clear_unload() { m_unload = false; }; + void clear_load() { m_load = false; }; + char *bstrerror(void) { return errmsg; }; + char *print_errmsg() { return errmsg; }; + int32_t get_slot() const { return m_slot; }; + + + void clear_volhdr(); /* in dev.c */ + void close(); /* in dev.c */ + void close_part(DCR *dcr); /* in dev.c */ + bool truncate(DCR *dcr); /* in dev.c */ + int open(DCR *dcr, int mode); /* in dev.c */ + void term(void); /* in dev.c */ + ssize_t read(void *buf, size_t len); /* in dev.c */ + ssize_t write(const void *buf, size_t len); /* in dev.c */ + bool rewind(DCR *dcr); /* in dev.c */ + bool mount(int timeout); /* in dev.c */ + bool unmount(int timeout); /* in dev.c */ + void edit_mount_codes(POOL_MEM &omsg, const char *imsg); /* in dev.c */ + bool offline_or_rewind(); /* in dev.c */ + bool offline(); /* in dev.c */ + bool bsf(int count); /* in dev.c */ + bool eod(DCR *dcr); /* in dev.c */ + bool fsr(int num); /* in dev.c */ + bool fsf(int num); /* in dev.c */ + bool bsr(int num); /* in dev.c */ + bool weof(int num); /* in dev.c */ + void lock_door(); /* in dev.c */ + void unlock_door(); /* in dev.c */ + int32_t get_os_tape_file(); /* in dev.c */ + bool scan_dir_for_volume(DCR *dcr); /* in scan.c */ + bool reposition(DCR *dcr, uint32_t rfile, uint32_t rblock); /* in dev.c */ + void clrerror(int func); /* in dev.c */ + boffset_t lseek(DCR *dcr, boffset_t offset, int whence); /* in dev.c */ + bool update_pos(DCR *dcr); /* in dev.c */ + void set_slot(int32_t slot); /* in dev.c */ + void clear_slot(); /* in dev.c */ + + + bool update_freespace(); /* in dvd.c */ + + uint32_t get_file() const { return file; }; + uint32_t get_block_num() const { return block_num; }; + int fd() const { return m_fd; }; + + /* + * Locking and blocking calls + */ +#ifdef SD_DEBUG_LOCK + void _r_dlock(const char *, int); /* in lock.c */ + void _r_dunlock(const char *, int); /* in lock.c */ + void _dlock(const char *, int); /* in lock.c */ + void _dunlock(const char *, int); /* in lock.c */ +#else + void r_dlock(); /* in lock.c */ + void r_dunlock() { dunlock(); } + void dlock() { P(m_mutex); } + void dunlock() { V(m_mutex); } +#endif + void dblock(int why); /* in lock.c */ + void dunblock(bool locked=false); /* in lock.c */ + void set_blocked(int block) { m_blocked = block; }; + int blocked() const { return m_blocked; }; + bool is_blocked() const { return m_blocked != BST_NOT_BLOCKED; }; + const char *print_blocked() const; /* in dev.c */ + +private: + bool do_mount(int mount, int timeout); /* in dev.c */ + void set_mode(int omode); /* in dev.c */ + void open_tape_device(DCR *dcr, int omode); /* in dev.c */ + void open_file_device(DCR *dcr, int omode); /* in dev.c */ + void open_dvd_device(DCR *dcr, int omode); /* in dev.c */ }; -/* Note, these return int not bool! */ inline const char *DEVICE::strerror() const { return errmsg; } inline const char *DEVICE::archive_name() const { return dev_name; } inline const char *DEVICE::print_name() const { return prt_name; } @@ -312,21 +466,31 @@ inline const char *DEVICE::print_name() const { return prt_name; } * DCRs open, each pointing to a different device. */ class DCR { +private: + bool m_dev_locked; /* set if dev already locked */ + bool m_reserved; /* set if reserved device */ + bool m_found_in_use; /* set if a volume found in use */ + public: dlink dev_link; /* link to attach to dev */ JCR *jcr; /* pointer to JCR */ - DEVICE *dev; /* pointer to device */ + DEVICE * volatile dev; /* pointer to device */ DEVRES *device; /* pointer to device resource */ DEV_BLOCK *block; /* pointer to block */ DEV_RECORD *rec; /* pointer to record */ + pthread_t tid; /* Thread running this dcr */ int spool_fd; /* fd if spooling */ bool spool_data; /* set to spool data */ bool spooling; /* set when actually spooling */ - bool dev_locked; /* set if dev already locked */ + bool despooling; /* set when despooling */ + bool despool_wait; /* waiting for despooling */ bool NewVol; /* set if new Volume mounted */ bool WroteVol; /* set if Volume written */ bool NewFile; /* set when EOF written */ - bool reserved_device; /* set if reserve done */ + bool reserved_volume; /* set if we reserved a volume */ + bool any_volume; /* Any OK for dir_find_next... */ + bool attached_to_dev; /* set when attached to dev */ + bool keep_dcr; /* do not free dcr in release_dcr */ uint32_t VolFirstIndex; /* First file index this Volume */ uint32_t VolLastIndex; /* Last file index this Volume */ uint32_t FileIndex; /* Current File Index */ @@ -334,6 +498,7 @@ public: uint32_t StartFile; /* Start write file */ uint32_t StartBlock; /* Start write block */ uint32_t EndBlock; /* Ending block written */ + int64_t VolMediaId; /* MediaId */ int64_t job_spool_size; /* Current job spool size */ int64_t max_job_spool_size; /* Max job spool size */ char VolumeName[MAX_NAME_LENGTH]; /* Volume name */ @@ -344,16 +509,59 @@ public: int Copy; /* identical copy number */ int Stripe; /* RAIT stripe */ VOLUME_CAT_INFO VolCatInfo; /* Catalog info for desired volume */ + + /* Methods */ + bool found_in_use() const { return m_found_in_use; }; + void set_found_in_use() { m_found_in_use = true; }; + void clear_found_in_use() { m_found_in_use = false; }; + bool is_reserved() const { return m_reserved; }; + bool is_dev_locked() { return m_dev_locked; } + void dlock() { dev->dlock(); m_dev_locked = true; } + void dunlock() { m_dev_locked = false; dev->dunlock(); } + void dblock(int why) { dev->dblock(why); } + + + /* Methods in reserve.c */ + void clear_reserved(); + void set_reserved(); + void unreserve_device(); + bool can_i_use_volume(); + + /* Methods in mount.c */ + bool mount_next_write_volume(); + bool mount_next_read_volume(); + void mark_volume_in_error(); + void mark_volume_not_inchanger(); + int try_autolabel(bool opened); + bool is_suitable_volume_mounted(); + bool is_eod_valid(); + int check_volume_label(bool &ask, bool &autochanger); + void release_volume(); + void do_swapping(bool is_writing); + bool is_tape_position_ok(); }; /* * Volume reservation class -- see reserve.c */ class VOLRES { + bool m_swapping; /* set when swapping to another drive */ + bool m_in_use; /* set when volume reserved or in use */ + int32_t m_slot; /* slot of swapping volume */ public: dlink link; - char *vol_name; - DEVICE *dev; + char *vol_name; /* Volume name */ + DEVICE *dev; /* Pointer to device to which we are attached */ + + bool is_swapping() const { return m_swapping; }; + void set_swapping() { m_swapping = true; }; + void clear_swapping() { m_swapping = false; }; + bool is_in_use() const { return m_in_use; }; + void set_in_use() { m_in_use = true; }; + void clear_in_use() { m_in_use = false; }; + void set_slot(int32_t slot) { m_slot = slot; }; + void clear_slot() { m_slot = -1; }; + int32_t get_slot() const { return m_slot; }; };