From: Kern Sibbald Date: Thu, 10 Jun 2004 17:33:23 +0000 (+0000) Subject: Attr spooling stats + storage override for restore X-Git-Tag: Release-1.34.4~11 X-Git-Url: https://git.sur5r.net/?a=commitdiff_plain;h=fc90347edd552c51270513557780277740dba028;p=bacula%2Fbacula Attr spooling stats + storage override for restore git-svn-id: https://bacula.svn.sourceforge.net/svnroot/bacula/trunk@1408 91ce42f0-d328-0410-95d8-f526ca767f89 --- diff --git a/bacula/kernstodo b/bacula/kernstodo index 0852b32866..b67fe87926 100644 --- a/bacula/kernstodo +++ b/bacula/kernstodo @@ -4,10 +4,11 @@ 1.34.4 Items to do: - Implement SIGHUP in Dir - Implement fast tree insert (doubly linked list?) -- Implement "label slots=1,2... pool=yyy barcodes" - Do tape alerts -- see tapealert.txt - When restore started from console, report jobid. - Feedback while the tree is being built. +- Add reporting in attr despooling. +- Win32 inc problem when new directory added. - On Win95 The error I when I installed 1.34.2 clients: The BACULA-FD file is @@ -1088,3 +1089,6 @@ Block Position: 0 ... - Add regression of btape "fill" +==== Done in 1.34.4 +- Implement "label slots=1,2... pool=yyy barcodes" + diff --git a/bacula/src/cats/sql.c b/bacula/src/cats/sql.c index e5328c0042..9ef630a3c1 100644 --- a/bacula/src/cats/sql.c +++ b/bacula/src/cats/sql.c @@ -157,12 +157,12 @@ UpdateDB(char *file, int line, JCR *jcr, B_DB *mdb, char *cmd) return 0; } mdb->num_rows = sql_affected_rows(mdb); - if (mdb->num_rows != 1) { + if (mdb->num_rows < 1) { char ed1[30]; m_msg(file, line, &mdb->errmsg, _("Update problem: affected_rows=%s\n"), edit_uint64(mdb->num_rows, ed1)); if (verbose) { -// j_msg(file, line, jcr, M_INFO, 0, "%s\n", cmd); + j_msg(file, line, jcr, M_INFO, 0, "%s\n", cmd); } return 0; } diff --git a/bacula/src/dird/ua_restore.c b/bacula/src/dird/ua_restore.c index ab674e03b3..e332c29f8c 100644 --- a/bacula/src/dird/ua_restore.c +++ b/bacula/src/dird/ua_restore.c @@ -1086,14 +1086,33 @@ static void get_storage_from_mediatype(UAContext *ua, NAME_LIST *name_list, REST LockRes(); foreach_res(store, R_STORAGE) { if (strcmp(name_list->name[0], store->media_type) == 0) { - rx->store = store; - UnlockRes(); - return; + if (acl_access_ok(ua, Storage_ACL, store->hdr.name)) { + rx->store = store; + } + break; } } UnlockRes(); - /* Try asking user */ + if (rx->store) { + /* Check if an explicit storage resource is given */ + store = NULL; + int i = find_arg_with_value(ua, "storage"); + if (i > 0) { + store = (STORE *)GetResWithName(R_STORAGE, ua->argv[i]); + if (store && !acl_access_ok(ua, Storage_ACL, store->hdr.name)) { + store = NULL; + } + } + if (store && (store != rx->store)) { + bsendmsg(ua, _("Warning default storage overridden by %s on command line.\n"), + store->hdr.name); + rx->store = store; + } + return; + } + + /* Take command line arg, or ask user if none */ rx->store = get_storage_resource(ua, false /* don't use default */); if (!rx->store) { diff --git a/bacula/src/lib/bnet.c b/bacula/src/lib/bnet.c index 94c7285894..a1816eff7c 100644 --- a/bacula/src/lib/bnet.c +++ b/bacula/src/lib/bnet.c @@ -281,13 +281,16 @@ bnet_suppress_error_messages(BSOCK *bsock, bool flag) /* * Transmit spooled data now to a BSOCK */ -int bnet_despool_to_bsock(BSOCK *bsock) +int bnet_despool_to_bsock(BSOCK *bsock, void update_attr_spool_size(ssize_t size), ssize_t tsize) { int32_t pktsiz; size_t nbytes; + ssize_t last = 0, size = 0; + int count = 0; rewind(bsock->spool_fd); while (fread((char *)&pktsiz, 1, sizeof(int32_t), bsock->spool_fd) == sizeof(int32_t)) { + size += sizeof(int32_t); bsock->msglen = ntohl(pktsiz); if (bsock->msglen > 0) { if (bsock->msglen > (int32_t)sizeof_pool_memory(bsock->msg)) { @@ -297,11 +300,18 @@ int bnet_despool_to_bsock(BSOCK *bsock) if (nbytes != (size_t)bsock->msglen) { Dmsg2(400, "nbytes=%d msglen=%d\n", nbytes, bsock->msglen); Qmsg1(bsock->jcr, M_FATAL, 0, _("fread attr spool error. ERR=%s\n"), strerror(errno)); + update_attr_spool_size(tsize-last); return 0; } + size += nbytes; + if ((++count & 0x3F) == 0) { + update_attr_spool_size(size-last); + last = size; + } } bnet_send(bsock); } + update_attr_spool_size(tsize-last); if (ferror(bsock->spool_fd)) { Qmsg1(bsock->jcr, M_FATAL, 0, _("fread attr spool error. ERR=%s\n"), strerror(errno)); return 0; diff --git a/bacula/src/lib/protos.h b/bacula/src/lib/protos.h index 564807db65..3fa47ecede 100644 --- a/bacula/src/lib/protos.h +++ b/bacula/src/lib/protos.h @@ -81,7 +81,7 @@ char * bnet_strerror (BSOCK *bsock); char * bnet_sig_to_ascii (BSOCK *bsock); int bnet_wait_data (BSOCK *bsock, int sec); int bnet_wait_data_intr (BSOCK *bsock, int sec); -int bnet_despool_to_bsock (BSOCK *bsock); +int bnet_despool_to_bsock (BSOCK *bsock, void update(ssize_t size), ssize_t size); int is_bnet_stop (BSOCK *bsock); int is_bnet_error (BSOCK *bsock); void bnet_suppress_error_messages(BSOCK *bsock, bool flag); diff --git a/bacula/src/stored/protos.h b/bacula/src/stored/protos.h index a81ccb3cd2..ca4e5e9abd 100644 --- a/bacula/src/stored/protos.h +++ b/bacula/src/stored/protos.h @@ -28,171 +28,171 @@ uint32_t new_VolSessionId(); /* From acquire.c */ -DCR *acquire_device_for_append(JCR *jcr); -DCR *acquire_device_for_read(JCR *jcr); -int release_device(JCR *jcr); -DCR *new_dcr(JCR *jcr, DEVICE *dev); -void free_dcr(DCR *dcr); +DCR *acquire_device_for_append(JCR *jcr); +DCR *acquire_device_for_read(JCR *jcr); +int release_device(JCR *jcr); +DCR *new_dcr(JCR *jcr, DEVICE *dev); +void free_dcr(DCR *dcr); /* From askdir.c */ enum get_vol_info_rw { GET_VOL_INFO_FOR_WRITE, GET_VOL_INFO_FOR_READ }; -int dir_get_volume_info(JCR *jcr, enum get_vol_info_rw); -int dir_find_next_appendable_volume(JCR *jcr); -int dir_update_volume_info(JCR *jcr, DEVICE *dev, int label); -int dir_ask_sysop_to_create_appendable_volume(JCR *jcr, DEVICE *dev); -int dir_ask_sysop_to_mount_volume(JCR *jcr, DEVICE *dev); -int dir_update_file_attributes(JCR *jcr, DEV_RECORD *rec); -int dir_send_job_status(JCR *jcr); -int dir_create_jobmedia_record(JCR *jcr); +int dir_get_volume_info(JCR *jcr, enum get_vol_info_rw); +int dir_find_next_appendable_volume(JCR *jcr); +int dir_update_volume_info(JCR *jcr, DEVICE *dev, int label); +int dir_ask_sysop_to_create_appendable_volume(JCR *jcr, DEVICE *dev); +int dir_ask_sysop_to_mount_volume(JCR *jcr, DEVICE *dev); +int dir_update_file_attributes(JCR *jcr, DEV_RECORD *rec); +int dir_send_job_status(JCR *jcr); +int dir_create_jobmedia_record(JCR *jcr); /* authenticate.c */ -int authenticate_director(JCR *jcr); -int authenticate_filed(JCR *jcr); +int authenticate_director(JCR *jcr); +int authenticate_filed(JCR *jcr); /* From block.c */ -void dump_block(DEV_BLOCK *b, char *msg); +void dump_block(DEV_BLOCK *b, char *msg); DEV_BLOCK *new_block(DEVICE *dev); DEV_BLOCK *dup_block(DEV_BLOCK *eblock); -void init_block_write(DEV_BLOCK *block); -void empty_block(DEV_BLOCK *block); -void free_block(DEV_BLOCK *block); -int write_block_to_device(DCR *dcr, DEV_BLOCK *block); -int write_block_to_dev(DCR *dcr, DEV_BLOCK *block); -void print_block_read_errors(JCR *jcr, DEV_BLOCK *block); -void ser_block_header(DEV_BLOCK *block); +void init_block_write(DEV_BLOCK *block); +void empty_block(DEV_BLOCK *block); +void free_block(DEV_BLOCK *block); +int write_block_to_device(DCR *dcr, DEV_BLOCK *block); +int write_block_to_dev(DCR *dcr, DEV_BLOCK *block); +void print_block_read_errors(JCR *jcr, DEV_BLOCK *block); +void ser_block_header(DEV_BLOCK *block); #define CHECK_BLOCK_NUMBERS true #define NO_BLOCK_NUMBER_CHECK false -int read_block_from_device(JCR *jcr, DEVICE *dev, DEV_BLOCK *block, bool check_block_numbers); -int read_block_from_dev(JCR *jcr, DEVICE *dev, DEV_BLOCK *block, bool check_block_numbers); +int read_block_from_device(JCR *jcr, DEVICE *dev, DEV_BLOCK *block, bool check_block_numbers); +int read_block_from_dev(JCR *jcr, DEVICE *dev, DEV_BLOCK *block, bool check_block_numbers); /* From butil.c -- utilities for SD tool programs */ -void print_ls_output(char *fname, char *link, int type, struct stat *statp); +void print_ls_output(char *fname, char *link, int type, struct stat *statp); JCR *setup_jcr(char *name, char *device, BSR *bsr, char *VolumeName); DEVICE *setup_to_access_device(JCR *jcr, int read_access); -void display_tape_error_status(JCR *jcr, DEVICE *dev); +void display_tape_error_status(JCR *jcr, DEVICE *dev); DEVRES *find_device_res(char *device_name, int read_access); /* From dev.c */ -DEVICE *init_dev(DEVICE *dev, DEVRES *device); -int open_dev(DEVICE *dev, char *VolName, int mode); -void close_dev(DEVICE *dev); -void force_close_dev(DEVICE *dev); -int truncate_dev(DEVICE *dev); -void term_dev(DEVICE *dev); -char * strerror_dev(DEVICE *dev); -void clrerror_dev(DEVICE *dev, int func); -int update_pos_dev(DEVICE *dev); -int rewind_dev(DEVICE *dev); -int load_dev(DEVICE *dev); -int offline_dev(DEVICE *dev); -int flush_dev(DEVICE *dev); -int weof_dev(DEVICE *dev, int num); -int write_block(DEVICE *dev); -int write_dev(DEVICE *dev, char *buf, size_t len); -int read_dev(DEVICE *dev, char *buf, size_t len); +DEVICE *init_dev(DEVICE *dev, DEVRES *device); +int open_dev(DEVICE *dev, char *VolName, int mode); +void close_dev(DEVICE *dev); +void force_close_dev(DEVICE *dev); +int truncate_dev(DEVICE *dev); +void term_dev(DEVICE *dev); +char * strerror_dev(DEVICE *dev); +void clrerror_dev(DEVICE *dev, int func); +int update_pos_dev(DEVICE *dev); +int rewind_dev(DEVICE *dev); +int load_dev(DEVICE *dev); +int offline_dev(DEVICE *dev); +int flush_dev(DEVICE *dev); +int weof_dev(DEVICE *dev, int num); +int write_block(DEVICE *dev); +int write_dev(DEVICE *dev, char *buf, size_t len); +int read_dev(DEVICE *dev, char *buf, size_t len); uint32_t status_dev(DEVICE *dev); -int eod_dev(DEVICE *dev); -int fsf_dev(DEVICE *dev, int num); -int fsr_dev(DEVICE *dev, int num); -int bsf_dev(DEVICE *dev, int num); -int bsr_dev(DEVICE *dev, int num); -void attach_jcr_to_device(DEVICE *dev, JCR *jcr); -void detach_jcr_from_device(DEVICE *dev, JCR *jcr); -JCR *next_attached_jcr(DEVICE *dev, JCR *jcr); -int dev_can_write(DEVICE *dev); -int offline_or_rewind_dev(DEVICE *dev); -int reposition_dev(DEVICE *dev, uint32_t file, uint32_t block); -void init_dev_wait_timers(DEVICE *dev); -bool double_dev_wait_time(DEVICE *dev); +int eod_dev(DEVICE *dev); +int fsf_dev(DEVICE *dev, int num); +int fsr_dev(DEVICE *dev, int num); +int bsf_dev(DEVICE *dev, int num); +int bsr_dev(DEVICE *dev, int num); +void attach_jcr_to_device(DEVICE *dev, JCR *jcr); +void detach_jcr_from_device(DEVICE *dev, JCR *jcr); +JCR *next_attached_jcr(DEVICE *dev, JCR *jcr); +int dev_can_write(DEVICE *dev); +int offline_or_rewind_dev(DEVICE *dev); +int reposition_dev(DEVICE *dev, uint32_t file, uint32_t block); +void init_dev_wait_timers(DEVICE *dev); +bool double_dev_wait_time(DEVICE *dev); /* Get info about device */ -char * dev_name(DEVICE *dev); -char * dev_vol_name(DEVICE *dev); +char * dev_name(DEVICE *dev); +char * dev_vol_name(DEVICE *dev); uint32_t dev_block(DEVICE *dev); uint32_t dev_file(DEVICE *dev); -int dev_is_tape(DEVICE *dev); +int dev_is_tape(DEVICE *dev); /* From device.c */ -int open_device(JCR *jcr, DEVICE *dev); -int first_open_device(DEVICE *dev); -int fixup_device_block_write_error(JCR *jcr, DEVICE *dev, DEV_BLOCK *block); -void _lock_device(char *file, int line, DEVICE *dev); -void _unlock_device(char *file, int line, DEVICE *dev); -void _block_device(char *file, int line, DEVICE *dev, int state); -void _unblock_device(char *file, int line, DEVICE *dev); -void _steal_device_lock(char *file, int line, DEVICE *dev, bsteal_lock_t *hold, int state); -void _give_back_device_lock(char *file, int line, DEVICE *dev, bsteal_lock_t *hold); -void set_new_volume_parameters(JCR *jcr, DEVICE *dev); -void set_new_file_parameters(JCR *jcr, DEVICE *dev); -int device_is_unmounted(DEVICE *dev); +int open_device(JCR *jcr, DEVICE *dev); +int first_open_device(DEVICE *dev); +int fixup_device_block_write_error(JCR *jcr, DEVICE *dev, DEV_BLOCK *block); +void _lock_device(char *file, int line, DEVICE *dev); +void _unlock_device(char *file, int line, DEVICE *dev); +void _block_device(char *file, int line, DEVICE *dev, int state); +void _unblock_device(char *file, int line, DEVICE *dev); +void _steal_device_lock(char *file, int line, DEVICE *dev, bsteal_lock_t *hold, int state); +void _give_back_device_lock(char *file, int line, DEVICE *dev, bsteal_lock_t *hold); +void set_new_volume_parameters(JCR *jcr, DEVICE *dev); +void set_new_file_parameters(JCR *jcr, DEVICE *dev); +int device_is_unmounted(DEVICE *dev); /* From dircmd.c */ -void *connection_request(void *arg); +void *connection_request(void *arg); /* From fd_cmds.c */ -void run_job(JCR *jcr); +void run_job(JCR *jcr); /* From job.c */ -void stored_free_jcr(JCR *jcr); -void connection_from_filed(void *arg); -void handle_filed_connection(BSOCK *fd, char *job_name); +void stored_free_jcr(JCR *jcr); +void connection_from_filed(void *arg); +void handle_filed_connection(BSOCK *fd, char *job_name); /* From label.c */ -int read_dev_volume_label(JCR *jcr, DEVICE *dev, DEV_BLOCK *block); -void create_session_label(JCR *jcr, DEV_RECORD *rec, int label); -void create_volume_label(DEVICE *dev, char *VolName, char *PoolName); -int write_volume_label_to_dev(JCR *jcr, DEVRES *device, char *VolName, char *PoolName); -int write_session_label(JCR *jcr, DEV_BLOCK *block, int label); -int write_volume_label_to_block(JCR *jcr, DEVICE *dev, DEV_BLOCK *block); -void dump_volume_label(DEVICE *dev); -void dump_label_record(DEVICE *dev, DEV_RECORD *rec, int verbose); -int unser_volume_label(DEVICE *dev, DEV_RECORD *rec); -int unser_session_label(SESSION_LABEL *label, DEV_RECORD *rec); +int read_dev_volume_label(JCR *jcr, DEVICE *dev, DEV_BLOCK *block); +void create_session_label(JCR *jcr, DEV_RECORD *rec, int label); +void create_volume_label(DEVICE *dev, char *VolName, char *PoolName); +int write_volume_label_to_dev(JCR *jcr, DEVRES *device, char *VolName, char *PoolName); +int write_session_label(JCR *jcr, DEV_BLOCK *block, int label); +int write_volume_label_to_block(JCR *jcr, DEVICE *dev, DEV_BLOCK *block); +void dump_volume_label(DEVICE *dev); +void dump_label_record(DEVICE *dev, DEV_RECORD *rec, int verbose); +int unser_volume_label(DEVICE *dev, DEV_RECORD *rec); +int unser_session_label(SESSION_LABEL *label, DEV_RECORD *rec); /* From match_bsr.c */ -int match_bsr(BSR *bsr, DEV_RECORD *rec, VOLUME_LABEL *volrec, - SESSION_LABEL *sesrec); -int match_bsr_block(BSR *bsr, DEV_BLOCK *block); -void position_bsr_block(BSR *bsr, DEV_BLOCK *block); -BSR *find_next_bsr(BSR *root_bsr, DEVICE *dev); -bool match_set_eof(BSR *bsr, DEV_RECORD *rec); +int match_bsr(BSR *bsr, DEV_RECORD *rec, VOLUME_LABEL *volrec, + SESSION_LABEL *sesrec); +int match_bsr_block(BSR *bsr, DEV_BLOCK *block); +void position_bsr_block(BSR *bsr, DEV_BLOCK *block); +BSR *find_next_bsr(BSR *root_bsr, DEVICE *dev); +bool match_set_eof(BSR *bsr, DEV_RECORD *rec); /* From mount.c */ -int mount_next_write_volume(JCR *jcr, DEVICE *dev, DEV_BLOCK *block, int release); -int mount_next_read_volume(JCR *jcr, DEVICE *dev, DEV_BLOCK *block); -void release_volume(JCR *jcr, DEVICE *dev); -void mark_volume_in_error(JCR *jcr, DEVICE *dev); +int mount_next_write_volume(JCR *jcr, DEVICE *dev, DEV_BLOCK *block, int release); +int mount_next_read_volume(JCR *jcr, DEVICE *dev, DEV_BLOCK *block); +void release_volume(JCR *jcr, DEVICE *dev); +void mark_volume_in_error(JCR *jcr, DEVICE *dev); /* From autochanger.c */ -int autoload_device(JCR *jcr, DEVICE *dev, int writing, BSOCK *dir); -int autochanger_list(JCR *jcr, DEVICE *dev, BSOCK *dir); -void invalidate_slot_in_catalog(JCR *jcr, DEVICE *dev); +int autoload_device(JCR *jcr, DEVICE *dev, int writing, BSOCK *dir); +int autochanger_list(JCR *jcr, DEVICE *dev, BSOCK *dir); +void invalidate_slot_in_catalog(JCR *jcr, DEVICE *dev); /* From parse_bsr.c */ -BSR *parse_bsr(JCR *jcr, char *lf); -void dump_bsr(BSR *bsr, bool recurse); -void free_bsr(BSR *bsr); +BSR *parse_bsr(JCR *jcr, char *lf); +void dump_bsr(BSR *bsr, bool recurse); +void free_bsr(BSR *bsr); VOL_LIST *new_vol(); -int add_vol(JCR *jcr, VOL_LIST *vol); -void free_vol_list(JCR *jcr); -void create_vol_list(JCR *jcr); +int add_vol(JCR *jcr, VOL_LIST *vol); +void free_vol_list(JCR *jcr); +void create_vol_list(JCR *jcr); /* From record.c */ -char *FI_to_ascii(int fi); -char *stream_to_ascii(int stream, int fi); -int write_record_to_block(DEV_BLOCK *block, DEV_RECORD *rec); -int can_write_record_to_block(DEV_BLOCK *block, DEV_RECORD *rec); -int read_record_from_block(DEV_BLOCK *block, DEV_RECORD *rec); +char *FI_to_ascii(int fi); +char *stream_to_ascii(int stream, int fi); +int write_record_to_block(DEV_BLOCK *block, DEV_RECORD *rec); +int can_write_record_to_block(DEV_BLOCK *block, DEV_RECORD *rec); +int read_record_from_block(DEV_BLOCK *block, DEV_RECORD *rec); DEV_RECORD *new_record(); -void free_record(DEV_RECORD *rec); +void free_record(DEV_RECORD *rec); /* From read_record.c */ int read_records(JCR *jcr, DEVICE *dev, @@ -200,15 +200,12 @@ int read_records(JCR *jcr, DEVICE *dev, int mount_cb(JCR *jcr, DEVICE *dev, DEV_BLOCK *block)); /* From spool.c */ -bool begin_data_spool (JCR *jcr); -bool discard_data_spool (JCR *jcr); -bool commit_data_spool (JCR *jcr); -bool are_attributes_spooled (JCR *jcr); -bool begin_attribute_spool (JCR *jcr); -bool discard_attribute_spool (JCR *jcr); -bool commit_attribute_spool (JCR *jcr); -bool write_block_to_spool_file (DCR *dcr, DEV_BLOCK *block); -bool open_spool_file (JCR *jcr, BSOCK *bs); -bool close_spool_file (JCR *jcr, BSOCK *bs); -void list_spool_stats (BSOCK *bs); - +bool begin_data_spool (JCR *jcr); +bool discard_data_spool (JCR *jcr); +bool commit_data_spool (JCR *jcr); +bool are_attributes_spooled (JCR *jcr); +bool begin_attribute_spool (JCR *jcr); +bool discard_attribute_spool (JCR *jcr); +bool commit_attribute_spool (JCR *jcr); +bool write_block_to_spool_file (DCR *dcr, DEV_BLOCK *block); +void list_spool_stats (BSOCK *bs); diff --git a/bacula/src/stored/spool.c b/bacula/src/stored/spool.c index ad1e4c0b05..80f16f808d 100644 --- a/bacula/src/stored/spool.c +++ b/bacula/src/stored/spool.c @@ -34,6 +34,8 @@ static bool open_data_spool_file(JCR *jcr); static bool close_data_spool_file(JCR *jcr); static bool despool_data(DCR *dcr); static int read_block_from_spool_file(DCR *dcr, DEV_BLOCK *block); +static bool open_attr_spool_file(JCR *jcr, BSOCK *bs); +static bool close_attr_spool_file(JCR *jcr, BSOCK *bs); struct spool_stats_t { uint32_t data_jobs; /* current jobs spooling data */ @@ -43,7 +45,7 @@ struct spool_stats_t { uint64_t max_data_size; /* max data size */ uint64_t max_attr_size; uint64_t data_size; /* current data size (all jobs running) */ - uint64_t attr_size; + int64_t attr_size; }; static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; @@ -67,15 +69,16 @@ void list_spool_stats(BSOCK *bs) { char ed1[30], ed2[30]; if (spool_stats.data_jobs || spool_stats.max_data_size) { - bnet_fsend(bs, "Data spooling: %d active jobs, %s bytes; %d total jobs, %s max bytes/job.\n", + bnet_fsend(bs, "Data spooling: %u active jobs, %s bytes; %u total jobs, %s max bytes/job.\n", spool_stats.data_jobs, edit_uint64_with_commas(spool_stats.data_size, ed1), spool_stats.total_data_jobs, edit_uint64_with_commas(spool_stats.max_data_size, ed2)); } if (spool_stats.attr_jobs || spool_stats.max_attr_size) { - bnet_fsend(bs, "Attr spooling: %d active jobs; %d total jobs, %s max bytes/job.\n", - spool_stats.attr_jobs, spool_stats.total_attr_jobs, - edit_uint64_with_commas(spool_stats.max_attr_size, ed1)); + bnet_fsend(bs, "Attr spooling: %u active jobs, %s bytes; %u total jobs, %s max bytes.\n", + spool_stats.attr_jobs, edit_uint64_with_commas(spool_stats.attr_size, ed1), + spool_stats.total_attr_jobs, + edit_uint64_with_commas(spool_stats.max_attr_size, ed2)); } } @@ -432,7 +435,7 @@ bool are_attributes_spooled(JCR *jcr) bool begin_attribute_spool(JCR *jcr) { if (!jcr->no_attributes && jcr->spool_attributes) { - return open_spool_file(jcr, jcr->dir_bsock); + return open_attr_spool_file(jcr, jcr->dir_bsock); } return true; } @@ -440,16 +443,44 @@ bool begin_attribute_spool(JCR *jcr) bool discard_attribute_spool(JCR *jcr) { if (are_attributes_spooled(jcr)) { - return close_spool_file(jcr, jcr->dir_bsock); + return close_attr_spool_file(jcr, jcr->dir_bsock); } return true; } +static void update_attr_spool_size(ssize_t size) +{ + P(mutex); + if (size > 0) { + if ((spool_stats.attr_size - size) > 0) { + spool_stats.attr_size -= size; + } else { + spool_stats.attr_size = 0; + } + } + V(mutex); +} + bool commit_attribute_spool(JCR *jcr) { + ssize_t size; + char ec1[30]; + if (are_attributes_spooled(jcr)) { - bnet_despool_to_bsock(jcr->dir_bsock); - return close_spool_file(jcr, jcr->dir_bsock); + fseek(jcr->dir_bsock->spool_fd, 0, SEEK_END); + size = ftell(jcr->dir_bsock->spool_fd); + P(mutex); + if (size > 0) { + if (spool_stats.attr_size + size > spool_stats.max_attr_size) { + spool_stats.max_attr_size = spool_stats.attr_size + size; + } + } + spool_stats.attr_size += size; + V(mutex); + Jmsg(jcr, M_INFO, 0, _("Sending spooled attrs to DIR. Despooling %s bytes ...\n"), + edit_uint64_with_commas(size, ec1)); + bnet_despool_to_bsock(jcr->dir_bsock, update_attr_spool_size, size); + return close_attr_spool_file(jcr, jcr->dir_bsock); } return true; } @@ -460,45 +491,42 @@ static void make_unique_spool_filename(JCR *jcr, POOLMEM **name, int fd) jcr->Job, fd); } -bool open_spool_file(JCR *jcr, BSOCK *bs) + +bool open_attr_spool_file(JCR *jcr, BSOCK *bs) { - POOLMEM *name = get_pool_memory(PM_MESSAGE); - - make_unique_spool_filename(jcr, &name, bs->fd); - bs->spool_fd = fopen(mp_chr(name), "w+"); - if (!bs->spool_fd) { - Jmsg(jcr, M_ERROR, 0, _("fopen attr spool file %s failed: ERR=%s\n"), name, strerror(errno)); - free_pool_memory(name); - return false; - } - P(mutex); - spool_stats.attr_jobs++; - V(mutex); - free_pool_memory(name); - return true; + POOLMEM *name = get_pool_memory(PM_MESSAGE); + + make_unique_spool_filename(jcr, &name, bs->fd); + bs->spool_fd = fopen(mp_chr(name), "w+"); + if (!bs->spool_fd) { + Jmsg(jcr, M_ERROR, 0, _("fopen attr spool file %s failed: ERR=%s\n"), name, strerror(errno)); + free_pool_memory(name); + return false; + } + P(mutex); + spool_stats.attr_jobs++; + V(mutex); + free_pool_memory(name); + return true; } -bool close_spool_file(JCR *jcr, BSOCK *bs) +bool close_attr_spool_file(JCR *jcr, BSOCK *bs) { - POOLMEM *name = get_pool_memory(PM_MESSAGE); - ssize_t size; - - fseek(bs->spool_fd, 0, SEEK_END); - size = ftell(bs->spool_fd); - P(mutex); - if (size > 0) { - if (spool_stats.attr_size + size > spool_stats.max_attr_size) { - spool_stats.max_attr_size = spool_stats.attr_size + size; - } - } - spool_stats.attr_jobs--; - spool_stats.total_attr_jobs++; - V(mutex); - make_unique_spool_filename(jcr, &name, bs->fd); - fclose(bs->spool_fd); - unlink(mp_chr(name)); - free_pool_memory(name); - bs->spool_fd = NULL; - bs->spool = false; - return true; + POOLMEM *name; + + if (!bs->spool_fd) { + return true; + } + name = get_pool_memory(PM_MESSAGE); + P(mutex); + spool_stats.attr_jobs--; + spool_stats.total_attr_jobs++; + V(mutex); + make_unique_spool_filename(jcr, &name, bs->fd); + fclose(bs->spool_fd); + unlink(mp_chr(name)); + free_pool_memory(name); + bs->spool_fd = NULL; + bs->spool = false; + return true; }