X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=bacula%2Fsrc%2Fstored%2Fdev.h;h=0ff099dc4c30870c6cdbaa130c29078439d692ff;hb=8fe276359efe90c40a83f85ff8476d17f10da740;hp=50e03257336e5faa672de5a6a7b7af938864cd38;hpb=ff8f6a055709010d9d698b2f98e52e3a7148389c;p=bacula%2Fbacula diff --git a/bacula/src/stored/dev.h b/bacula/src/stored/dev.h index 50e0325733..0ff099dc4c 100644 --- a/bacula/src/stored/dev.h +++ b/bacula/src/stored/dev.h @@ -2,36 +2,48 @@ * Definitions for using the Device functions in Bacula * Tape and File storage access * + * Kern Sibbald, MM + * * Version $Id$ * */ /* - Copyright (C) 2000-2004 Kern Sibbald and John Walker + Bacula® - The Network Backup Solution + + Copyright (C) 2000-2006 Free Software Foundation Europe e.V. - This program is free software; you can redistribute it and/or - modify it under the terms of the GNU General Public License as - published by the Free Software Foundation; either version 2 of - the License, or (at your option) any later version. + 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 plus additions + that are listed 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 + 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., 59 Temple Place - Suite 330, Boston, - MA 02111-1307, USA. + 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. +*/ #ifndef __DEV_H #define __DEV_H 1 +#undef DCR /* used by Bacula */ + /* #define NEW_LOCK 1 */ -#define new_lock_device(dev) _new_lock_device(__FILE__, __LINE__, (dev)) +#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)) @@ -42,12 +54,31 @@ #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() */ -#define READ_WRITE 0 -#define READ_ONLY 1 -#define OPEN_READ_WRITE 0 -#define OPEN_READ_ONLY 1 -#define OPEN_WRITE_ONLY 2 +enum { + 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_PROG_DEV +}; /* Generic status bits returned from status_dev() */ #define BMT_TAPE (1<<0) /* is tape device */ @@ -62,9 +93,6 @@ #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 */ @@ -85,34 +113,47 @@ #define CAP_FASTFSF (1<<16) /* Fast forward space file */ #define CAP_TWOEOF (1<<17) /* Write two eofs for EOM */ #define CAP_CLOSEONPOLL (1<<18) /* Close device on polling */ +#define CAP_POSITIONBLOCKS (1<<19) /* Use block positioning */ +#define CAP_MTIOCGET (1<<20) /* Basic support for fileno and blkno */ +#define CAP_REQMOUNT (1<<21) /* Require mount to read files back (typically: DVD) */ +#define CAP_CHECKLABELS (1<<22) /* Check for ANSI/IBM labels */ /* Test state */ #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_PROG (1<<4) /* is a program device */ -#define ST_LABEL (1<<5) /* label found */ -#define ST_MALLOC (1<<6) /* dev packet malloc'ed in init_dev() */ -#define ST_APPEND (1<<7) /* ready for Bacula append */ -#define ST_READ (1<<8) /* ready for Bacula read */ -#define ST_EOT (1<<9) /* at end of tape */ -#define ST_WEOT (1<<10) /* Got EOT on write */ -#define ST_EOF (1<<11) /* Read EOF i.e. zero bytes */ -#define ST_NEXTVOL (1<<12) /* Start writing on next volume */ -#define ST_SHORT (1<<13) /* Short block read */ +#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 */ +#define ST_READ (1<<9) /* ready for Bacula read */ +#define ST_EOT (1<<10) /* at end of tape */ +#define ST_WEOT (1<<11) /* Got EOT on write */ +#define ST_EOF (1<<12) /* Read EOF i.e. zero bytes */ +#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_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) */ -#define BST_NOT_BLOCKED 0 /* not blocked */ -#define BST_UNMOUNTED 1 /* User unmounted device */ -#define BST_WAITING_FOR_SYSOP 2 /* Waiting for operator to mount tape */ -#define BST_DOING_ACQUIRE 3 /* Opening/validating/moving tape */ -#define BST_WRITING_LABEL 4 /* Labeling a tape */ -#define BST_UNMOUNTED_WAITING_FOR_SYSOP 5 /* Closed by user during mount request */ -#define BST_MOUNT 6 /* Mount request */ +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, /* User unmounted during wait for op */ + BST_MOUNT /* Mount request */ +}; /* Volume Catalog Information structure definition */ struct VOLUME_CAT_INFO { @@ -121,40 +162,50 @@ struct VOLUME_CAT_INFO { uint32_t VolCatFiles; /* Number of files */ uint32_t VolCatBlocks; /* Number of blocks */ uint64_t VolCatBytes; /* Number of bytes written */ + uint32_t VolCatParts; /* Number of parts written */ uint32_t VolCatMounts; /* Number of mounts this volume */ uint32_t VolCatErrors; /* Number of errors this volume */ uint32_t VolCatWrites; /* Number of writes this volume */ uint32_t VolCatReads; /* Number of reads this volume */ uint64_t VolCatRBytes; /* Number of bytes read */ uint32_t VolCatRecycles; /* Number of recycles this volume */ - int32_t Slot; /* Slot in changer */ - bool InChanger; /* Set if vol in current magazine */ + uint32_t EndFile; /* Last file number */ + uint32_t EndBlock; /* Last block number */ + int32_t LabelType; /* Bacula/ANSI/IBM */ + 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 */ + int64_t VolMediaId; /* MediaId */ + utime_t VolFirstWritten; /* Time of first 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 */ + 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 */ +class DEVRES; /* Device resource defined in stored_conf.h */ -/* Device structure definition */ -struct DEVICE { +class DCR; /* forward reference */ +/* + * Device structure definition. There is one of these for + * each physical device. Everything here is "global" to + * that device and effects all jobs using the device. + */ +class DEVICE { public: - DEVICE *next; /* pointer to next open device */ - DEVICE *prev; /* pointer to prev open device */ - JCR *attached_jcrs; /* attached JCR list */ + dlist *attached_dcrs; /* attached DCR list */ pthread_mutex_t 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 */ @@ -162,13 +213,24 @@ public: int dev_prev_blocked; /* previous blocked state */ int num_waiting; /* number of threads waiting */ int num_writers; /* number of writing threads */ - int use_count; /* usage count on this device */ + int reserved_device; /* number of device reservations */ + + /* New access control in process of being implemented */ + brwlock_t lock; /* New mutual exclusion lock */ + int fd; /* file descriptor */ int capabilities; /* capabilities mask */ int state; /* state mask */ int dev_errno; /* Our own errno */ int mode; /* read/write modes */ - char *dev_name; /* device name */ + int openmode; /* parameter passed to open_dev (useful to reopen the device) */ + int dev_type; /* device type */ + bool autoselect; /* Autoselect in autochanger */ + 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 */ uint32_t block_num; /* current block number base 0 */ uint32_t file; /* current file number base 0 */ @@ -181,16 +243,33 @@ public: uint64_t max_volume_size; /* max bytes to put on one volume */ uint64_t max_file_size; /* max file size to put in one file on volume */ uint64_t volume_capacity; /* advisory capacity */ + uint64_t max_spool_size; /* maximum spool file size */ + uint64_t spool_size; /* current spool size for this device */ uint32_t max_rewind_wait; /* max secs to allow for rewind */ uint32_t max_open_wait; /* max secs to allow for open */ uint32_t max_open_vols; /* max simultaneous open volumes */ + + uint64_t max_part_size; /* max part size */ + uint64_t part_size; /* current part size */ + 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_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 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 */ btimer_t *tid; /* timer id */ VOLUME_CAT_INFO VolCatInfo; /* Volume Catalog Information */ VOLUME_LABEL VolHdr; /* Actual volume label */ - + char pool_name[MAX_NAME_LENGTH]; /* pool name */ + char pool_type[MAX_NAME_LENGTH]; /* pool type */ + /* Device wait times ***FIXME*** look at durations */ char BadVolName[MAX_NAME_LENGTH]; /* Last wrong Volume mounted */ bool poll; /* set to poll Volume */ @@ -200,6 +279,186 @@ public: int wait_sec; int rem_wait_sec; int num_wait; + + /* Methods */ + 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_prog() const { return dev_type == B_PROG_DEV; } + int is_open() const { return fd >= 0; } + int is_offline() const { return state & ST_OFFLINE; } + int is_labeled() const { return state & ST_LABEL; } + int is_mounted() const { return state & ST_MOUNTED; } + 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 || reserved_device; } + 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 + * and the job is canceled). + */ + 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 waiting_for_mount() const { return + (dev_blocked == BST_UNMOUNTED || + dev_blocked == BST_WAITING_FOR_SYSOP || + dev_blocked == BST_UNMOUNTED_WAITING_FOR_SYSOP); }; + const char *strerror() const; + const char *archive_name() const; + const char *name() const; + const char *print_name() const; /* Name for display purposes */ + 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; }; + 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_mounted(int val) { if (val) state |= ST_MOUNTED; \ + else state &= ~ST_MOUNTED; }; + 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 clear_opened() { 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; }; + char *bstrerror(void) { return errmsg; }; + char *print_errmsg() { return errmsg; }; + + void block(int why); /* in dev.c */ + void unblock(); /* 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 */ + 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 */ + 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 */ + bool update_freespace(); /* in dvd.c */ + + void set_blocked(int block) { dev_blocked = block; }; + int get_blocked() const { return dev_blocked; }; + uint32_t get_file() const { return file; }; + uint32_t get_block() const { return block_num; }; + const char *print_blocked() const; /* in dev.c */ + bool is_blocked() const { return dev_blocked != BST_NOT_BLOCKED; }; + +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; } + +/* + * Device Context (or Control) Record. + * There is one of these records for each Job that is using + * the device. Items in this record are "local" to the Job and + * do not affect other Jobs. Note, a job can have multiple + * DCRs open, each pointing to a different device. + */ +class DCR { +public: + dlink dev_link; /* link to attach to dev */ + JCR *jcr; /* pointer to JCR */ + DEVICE *dev; /* pointer to device */ + DEVRES *device; /* pointer to device resource */ + DEV_BLOCK *block; /* pointer to block */ + DEV_RECORD *rec; /* pointer to record */ + int spool_fd; /* fd if spooling */ + bool spool_data; /* set to spool data */ + bool spooling; /* set when actually spooling */ + bool despooling; /* set when despooling */ + bool despool_wait; /* waiting for despooling */ + bool dev_locked; /* set if dev already locked */ + 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 any_volume; /* Any OK for dir_find_next... */ + bool attached_to_dev; /* set when attached to dev */ + uint32_t VolFirstIndex; /* First file index this Volume */ + uint32_t VolLastIndex; /* Last file index this Volume */ + uint32_t FileIndex; /* Current File Index */ + uint32_t EndFile; /* End file written */ + uint32_t StartFile; /* Start write file */ + uint32_t StartBlock; /* Start write block */ + uint32_t EndBlock; /* Ending block written */ + 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 */ + char pool_name[MAX_NAME_LENGTH]; /* pool name */ + char pool_type[MAX_NAME_LENGTH]; /* pool type */ + char media_type[MAX_NAME_LENGTH]; /* media type */ + char dev_name[MAX_NAME_LENGTH]; /* dev name */ + int Copy; /* identical copy number */ + int Stripe; /* RAIT stripe */ + VOLUME_CAT_INFO VolCatInfo; /* Catalog info for desired volume */ +}; + +/* + * Volume reservation class -- see reserve.c + */ +class VOLRES { +public: + dlink link; + char *vol_name; + DEVICE *dev; + DCR *dcr; };