X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=bacula%2Fsrc%2Fstored%2Fdev.h;h=108389760d69b636f6ca45b64e357eac8b44f83c;hb=a38a3fd0b18d6d8fb5aaa6b868fa5fc6a6f5fa2f;hp=688eee3c1433967394fd15ee7f7d96bc3b89faec;hpb=95f96233caf6cc7ccb04224d1631d87218246db9;p=bacula%2Fbacula diff --git a/bacula/src/stored/dev.h b/bacula/src/stored/dev.h index 688eee3c14..108389760d 100644 --- a/bacula/src/stored/dev.h +++ b/bacula/src/stored/dev.h @@ -1,16 +1,7 @@ -/* - * Definitions for using the Device functions in Bacula - * Tape and File storage access - * - * Kern Sibbald, MM - * - * Version $Id$ - * - */ /* Bacula® - The Network Backup Solution - Copyright (C) 2000-2006 Free Software Foundation Europe e.V. + Copyright (C) 2000-2007 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. @@ -34,21 +25,29 @@ (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 + * + * Kern Sibbald, MM + * + * Version $Id$ + * + */ #ifndef __DEV_H #define __DEV_H 1 -#undef DCR /* used by Bacula */ - -/* #define NEW_LOCK 1 */ +#ifdef SD_DEBUG_LOCK +#define r_dlock() _r_dlock(__FILE__, __LINE__); /* in device.c */ +#define r_dunlock() _r_dunlock(__FILE__, __LINE__); /* in device.c */ +#define dlock() _dlock(__FILE__, __LINE__); /* in device.c */ +#define dunlock() _dunlock(__FILE__, __LINE__); /* in device.c */ +#endif -#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)) +#undef DCR /* used by Bacula */ -#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) @@ -144,7 +143,7 @@ enum { #define ST_PART_SPOOLED (1<<18) /* spooling part */ #define ST_FREESPACE_OK (1<<19) /* Have valid freespace for DVD */ -/* dev_blocked states (mutually exclusive) */ +/* m_blocked states (mutually exclusive) */ enum { BST_NOT_BLOCKED = 0, /* not blocked */ BST_UNMOUNTED, /* User unmounted device */ @@ -196,29 +195,42 @@ typedef struct s_steal_lock { class DEVRES; /* Device resource defined in stored_conf.h */ class DCR; /* forward reference */ +class VOLRES; /* forward reference */ + +/* + * Used in unblock() call + */ +enum { + dev_locked = true, + dev_unlocked = false +}; + /* * 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 { +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 */ public: 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 */ +// brwlock_t xlock; /* New mutual exclusion lock */ - int fd; /* file descriptor */ int capabilities; /* capabilities mask */ int state; /* state mask */ int dev_errno; /* Our own errno */ @@ -226,6 +238,7 @@ public: int openmode; /* parameter passed to open_dev (useful to reopen the device) */ int dev_type; /* device type */ bool autoselect; /* Autoselect in autochanger */ + 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) */ @@ -263,6 +276,7 @@ public: 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 */ @@ -289,7 +303,7 @@ public: uint64_t DevReadBytes; /* Methods */ - btime_t get_timer_count(); /* return the last timer interval (ms) */ + 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; } @@ -302,7 +316,7 @@ public: 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_open() const { return m_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; } @@ -323,14 +337,14 @@ 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); }; + (m_blocked == BST_UNMOUNTED || + m_blocked == BST_WAITING_FOR_SYSOP || + m_blocked == BST_UNMOUNTED_WAITING_FOR_SYSOP); }; const char *strerror() const; const char *archive_name() const; const char *name() const; @@ -358,7 +372,7 @@ public: 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_opened() { m_fd = -1; }; void clear_mounted() { state &= ~ST_MOUNTED; }; void clear_media() { state &= ~ST_MEDIA; }; void clear_short_block() { state &= ~ST_SHORT; }; @@ -366,15 +380,28 @@ public: char *bstrerror(void) { return errmsg; }; char *print_errmsg() { return errmsg; }; +#ifdef SD_DEBUG_LOCK + void _r_dlock(const char *, int); /* in device.c */ + void _r_dunlock(const char *, int); /* in device.c */ + void _dlock(const char *, int); /* in device.c */ + void _dunlock(const char *, int); /* in device.c */ +#else + void r_dlock(); /* in device.c */ + void r_dunlock() { dunlock(); } + void dlock() { P(m_mutex); } + void dunlock() { V(m_mutex); } +#endif + + void clear_volhdr(); /* in dev.c */ void block(int why); /* in dev.c */ - void unblock(); /* in dev.c */ + void unblock(bool locked=false); /* 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 */ + 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 */ @@ -389,6 +416,7 @@ public: 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 */ @@ -396,12 +424,13 @@ public: 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; }; + void set_blocked(int block) { m_blocked = block; }; + int blocked() const { return m_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; }; + bool is_blocked() const { return m_blocked != BST_NOT_BLOCKED; }; + int fd() const { return m_fd; }; private: bool do_mount(int mount, int timeout); /* in dev.c */ @@ -411,7 +440,6 @@ private: 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; } @@ -431,6 +459,7 @@ public: 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 */ @@ -470,7 +499,6 @@ public: dlink link; char *vol_name; DEVICE *dev; - DCR *dcr; };