dmpr_arg_reader_.pl1 10/10/89 1422.4rew 10/10/89 1359.2 66024 /****^ *********************************************************** * * * Copyright, (C) BULL HN Information Systems Inc., 1989 * * * * Copyright, (C) Honeywell Information Systems Inc., 1982 * * * * Copyright (c) 1972 by Massachusetts Institute of * * Technology and Honeywell Information Systems, Inc. * * * *********************************************************** */ /****^ HISTORY COMMENTS: 1) change(85-12-04,GWMay), approve(), audit(), install(): old history comments - Written: In antiquity, probably by Dave Vinograd. Modified: April 1983 by GA Texada for -trace -no_trace. Modified: May 1983 by GA Texada to add -preattach. Modified: August 1983 by GA Texada to redefine -detach & -no_detach. 2) change(85-12-04,GWMay), approve(85-12-04,MCR7310), audit(85-12-05,Dupuis), install(85-12-16,MR12.0-1001): Modified wakeup interval to allow a maximum of 1440 minutes. It previously allowed 480 minutes. 3) change(89-08-31,GWMay), approve(89-10-03,MCR8135), audit(89-10-04,Beattie), install(89-10-10,MR12.3-1089): Disabled the -incr_skip_count argument. Used the value dmpr_data_.incr_skip_count as a switch for a new control argument set. Added -purge_volume_log, -pvl, -no_purge_volume_log, -npvl arguments. END HISTORY COMMENTS */ /* format: style1,ind2,^inddcls,ifthenstmt,dclind2,declareind2,ifthendo,ifthen*/ dmpr_arg_reader_: proc (a_alp, a_code); /* This routine reads and handles the arguments * for the volume dumper. * * Usage: dcl dmpr_arg_reader_ entry ( pointer, fixed bin (35)); * * call dmpr_arg_reader_ (a_alp, a_code); * * where * * * 1) a_alp is a pointer to the argument list (Input). * * 2) a_code is a standard status code (Output). * */ dcl (ac, al) fixed bin; dcl pre_attach_vol fixed bin; dcl (a_code, code) fixed bin (35); dcl (a_alp, alp, ap) ptr; dcl arg char (al) based (ap); dcl myname char (16) int static init ("dmpr_arg_reader_") options (constant); dcl error_table_$bad_arg ext fixed bin (35); dcl error_table_$noarg ext fixed bin (35); dcl error_table_$badopt ext fixed bin (35); dcl get_wdir_ entry returns (char (168)); dcl suffixed_name_$make entry (char (*), char (*), char (*) aligned, fixed bin (35)); dcl dmpr_report_$error_output entry options (variable); dcl convert_date_to_binary_ entry (char (*), fixed bin (71), fixed bin (35)); dcl cu_$arg_ptr_rel entry (fixed bin, ptr, fixed bin, fixed bin (35), ptr); dcl cv_dec_check_ entry (char (*), fixed bin (35)) returns (fixed bin); dcl hbound builtin; a_code = 0; /* set up and copy args */ alp = a_alp; /* arg list pointer */ do ac = 1 by 1; /* scan the arg list */ call cu_$arg_ptr_rel (ac, ap, al, code, alp); if code ^= 0 then if code = error_table_$noarg then return; else go to err; /* error if code other than noargs */ if arg = "-control" then do; call suffixed_name_$make (get_arg (), "dump", dmpr_data_.control_name, code); if code ^= 0 then goto bad_arg; end; else if arg = "-operator" then dmpr_data_.operator = get_arg (); else if arg = "-output_volume_desc" then /* this must be attach description */ dmpr_data_.att_desc = get_arg (); else if arg = "-wakeup" then do; /* this must be wakeup interval in minutes */ dmpr_data_.wakeup_interval = cv_dec_check_ (get_arg (), code); if code ^= 0 then do; bad_intr: call dmpr_report_$error_output (0, myname, "Invalid interval ^a specified", arg); goto bad_arg; end; if dmpr_data_.wakeup_interval < 1 | dmpr_data_.wakeup_interval > 1440 then goto bad_intr; dmpr_data_.wakeup_interval = dmpr_data_.wakeup_interval * 60000000; /* interval converted to microseconds */ end; else if arg = "-restart" then /* restart at pvname given */ dmpr_data_.restart_pvname = get_arg (); else if arg = "-mod_after" then do; call convert_date_to_binary_ (get_arg (), dmpr_data_.mod_after_time, code); if code ^= 0 then do; call dmpr_report_$error_output (0, myname, "Invalid time ^a specified", arg); goto bad_arg; end; end; else if arg = "-incr_skip_count" then do; call dmpr_report_$error_output (error_table_$bad_arg, myname, " The -incr_skip_count function has been replaced by -purge_volume_log.", arg); goto bad_arg; end; else if arg = "-purge_volume_log" | arg = "-pvl" then dmpr_data_.incr_skip_count = 0; /* use the old value as a switch */ else if arg = "-no_purge_volume_log" | arg = "-npvl" then dmpr_data_.incr_skip_count = -1; /* use the old value as a switch */ else if arg = "-pre_attach" | arg = "-preattach" then do; pre_attach_vol = cv_dec_check_ (get_arg (), code); if code ^= 0 then do; bad_mv: call dmpr_report_$error_output (0, myname, "Invalid preattach vol number ^a specified", arg); goto bad_arg; end; if pre_attach_vol > hbound (dmpr_data_.pre_attach_volname, 1) then goto bad_mv; dmpr_data_.pre_attach_vol = pre_attach_vol; end; else if arg = "-working_dir" | arg = "-wd" then dmpr_data_.sys_dir = get_wdir_ (); else if arg = "-accounting" then dmpr_data_.accounting = "1"b; else if arg = "-auto" then dmpr_data_.auto_vol = "1"b;/* enable auto volume selection */ else if arg = "-error_on" then dmpr_data_.err_online = "1"b; /* output errors online */ else if arg = "-names" then dmpr_data_.names = "1"b; /* collect all names */ else if arg = "-detach" then do; /* only valid for incrementals */ if dmpr_data_.dump_type ^= incr then goto bad_arg; dmpr_data_.detach = "1"b; end; else if arg = "-no_detach" then do; /* only for incr's */ if dmpr_data_.dump_type ^= incr then goto bad_arg; dmpr_data_.detach = ""b; /* don't detach */ end; else if arg = "-no_object" then dmpr_data_.no_object = "1"b; /* don't activate object */ else if arg = "-cumulative" then dmpr_data_.reset = "1"b; /* reset bit map. */ else if arg = "-manual_free" then dmpr_data_.manual_free = "1"b; else if arg = "-no_update" then dmpr_data_.no_update = "1"b; /* don't modify vtoce */ else if arg = "-trace" then dmpr_data_.trace = "1"b; else if arg = "-no_trace" then dmpr_data_.trace = "0"b; else do; code = error_table_$badopt; goto err; end; end; bad_arg: code = error_table_$bad_arg; err: call dmpr_report_$error_output (code, myname, "^a", arg); a_code = code; /* return an error code */ return; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ get_arg: proc returns (char (*)); ac = ac + 1; call cu_$arg_ptr_rel (ac, ap, al, code, alp); if code ^= 0 then goto err; return (arg); end get_arg; %include dmpr_data_; %include backup_static_variables; %include backup_volume_header; end dmpr_arg_reader_;  dmpr_finish_.pl1 10/10/89 1422.4r w 10/10/89 1359.7 84150 /****^ *********************************************************** * * * Copyright, (C) Honeywell Bull Inc., 1989 * * * * Copyright, (C) Honeywell Information Systems Inc., 1982 * * * * Copyright (c) 1972 by Massachusetts Institute of * * Technology and Honeywell Information Systems, Inc. * * * *********************************************************** */ /****^ HISTORY COMMENTS: 1) change(86-08-12,GWMay), approve(86-08-12,MCR7445), audit(86-11-20,GDixon), install(86-11-21,MR12.0-1223): changed to set bit count on the segment .contents_names. 2) change(89-01-06,GWMay), approve(89-01-06,MCR8039), audit(89-01-09,Farley), install(89-01-17,MR12.3-1002): Changed to call msf_mgr_$adjust to correctly set the size of the .contents_names segments. END HISTORY COMMENTS */ /* format: style1,ind2,^inddcls,ifthenstmt,dclind2,declareind2,ifthendo,ifthen*/ dmpr_finish_: proc (code); /* This routine provides a centralized cleanup function for the volume dumper. It closes the account segment, unlocks any logs that may have been left locked, detachs a switches that may have been left attached, releases any temp segs, clears any pending alarms by deleting the event channel, and resets the ring 0 dumper and its data. This routine is used to clean up both in the normal case and after a dumper abort when the state of the world is not well understood. */ /* Modified: 8/82 by GA Texada to fix phx13662, phx13708 */ /* Modified: 3/83 by E. N. Kittlitz for 256K segments. */ /* Modified: 8/01/83 by GA Texada to call manage_volume_pool_$check_reserved to free any reserved volumes not in valid use. */ dcl code fixed bin (35); dcl i fixed bin; dcl attach_name char (32); dcl bit_count fixed bin (24); dcl ignore fixed bin (35); dcl tp (4) ptr; dcl msf_manager_$adjust entry (ptr, fixed bin, fixed bin (24), bit (3), fixed bin (35)); dcl msf_manager_$close entry (ptr); dcl manage_volume_pool_$check_reserved entry (ptr, entry, fixed bin (35)); dcl manage_volume_pool$free entry (ptr, entry options (variable), char (*) aligned, fixed bin (35)); dcl ioa_$rsnnl entry options (variable); dcl hcs_$fs_get_path_name entry (ptr, char (*), fixed bin, char (*), fixed bin (35)); dcl adjust_bit_count_ entry (char (*), char (*), bit (1), fixed bin, fixed bin (35)); dcl hcs_$delentry_seg entry (ptr, fixed bin (35)); dcl hcs_$terminate_seg entry (ptr, fixed bin, fixed bin (35)); dcl release_temp_segments_ entry (char (*), (*) ptr, fixed bin (35)); dcl dmpr_report_$error_output entry options (variable); dcl dmpr_report_$online_output entry options (variable); dcl dmpr_log_$close_volume_log entry (fixed bin (35)); dcl set_lock_$unlock entry (bit (36) aligned, fixed bin (35)); dcl ipc_$delete_ev_chn entry (fixed bin (71), fixed bin (35)); dcl hc_backup_$dmpr_unlock_pv entry (bit (36) aligned, fixed bin, fixed bin (35)); dcl hc_backup_$revert_dmpr entry (fixed bin); dcl hcs_$set_256K_switch entry (bit (2) aligned, bit (2) aligned, fixed bin (35)); dcl iox_$close entry (ptr, fixed bin (35)); dcl iox_$find_iocb entry (char (*), ptr, fixed bin (35)); dcl iox_$detach_iocb entry (ptr, fixed bin (35)); dcl set_bc_n_truncate bit (3) int static init ("110"b) options (constant); dcl null builtin; %page; code = 0; if dmprp = null then return; if ^dmpr_data_.data_init then return; /* reject calls if dmpr_data_ not inited */ if dmpr_data_.bvlp ^= null then do; bvlp = dmpr_data_.bvlp; call unlock_volume_log; call setbc_term (dmpr_data_.bvlp); end; if dmpr_data_.fcbp ^= null then do; if dmpr_data_.contents_namesp ^= null then do; contents_namesp = dmpr_data_.contents_namesp; bit_count = backup_volume_contents_names.offset * BITS_PER_WORD; call msf_manager_$adjust (dmpr_data_.fcbp, dmpr_data_.component, bit_count, set_bc_n_truncate, ignore); call msf_manager_$close (dmpr_data_.fcbp); end; end; if dmpr_data_.pvlp ^= null then do; pvlp = dmpr_data_.pvlp; call unlock_pvolog; call setbc_term (dmpr_data_.pvlp); end; if dmpr_data_.contentsp ^= null then call setbc_term (dmpr_data_.contentsp); if dmpr_data_.control_iocbp ^= null () then call detach ("dump_control", dmpr_data_.control_iocbp); /* detach control seg */ if dmpr_data_.account_iocbp ^= null () then call detach ("account_file", dmpr_data_.account_iocbp); /* and account file */ if dmpr_data_.detach then do; if dmpr_data_.outputvol_iocbp ^= null then call dmpr_report_$online_output (0, myname, "Finished volume ^a: ^d ^d ^d ^d", dmpr_data_.volname, dmpr_data_.dump_volume_dir_rec, dmpr_data_.dump_volume_dir_num, dmpr_data_.dump_volume_seg_rec, dmpr_data_.dump_volume_seg_num); dmpr_data_.not_reported = "0"b; if dmpr_data_.pre_attach_vol = 0 then call detach ("dump_volume", dmpr_data_.outputvol_iocbp); /* and output volume */ else do; do i = dmpr_data_.vol_idx + 1 to dmpr_data_.pre_attach_vol while (dmpr_data_.pre_attach_pvlp (i) ^= null ()); if dmpr_data_.auto_vol then call manage_volume_pool$free (dmpr_data_.vpp, dmpr_report_$error_output, dmpr_data_.pre_attach_volname (i), ignore); call hcs_$delentry_seg (dmpr_data_.pre_attach_pvlp (i), ignore); end; do i = 1 to dmpr_data_.pre_attach_vol while (dmpr_data_.pre_attach_iocbp (i) ^= null ()); call ioa_$rsnnl ("^a.^d", attach_name, ignore, "dump_volume", i); call detach (attach_name, dmpr_data_.pre_attach_iocbp (i)); end; dmpr_data_.pre_attach_vol = 0; end; end; if dmpr_data_.vpp ^= null () then /* free ANY old reserved volumes */ call manage_volume_pool_$check_reserved (dmpr_data_.vpp, dmpr_report_$error_output, (0)); /* don't care about code here */ if dmpr_data_.error_iocbp ^= null () then call detach ("error_file", dmpr_data_.error_iocbp); /* and error file */ if dmpr_data_.dump_type = incr & dmpr_data_.incr_ev_chn ^= 0 then do; /* incremental case */ call ipc_$delete_ev_chn (dmpr_data_.incr_ev_chn, code); dmpr_data_.incr_ev_chn = 0; end; call hc_backup_$dmpr_unlock_pv (dmpr_data_.pvid, dmpr_data_.dump_type, ignore); call hc_backup_$revert_dmpr (dmpr_data_.dump_type); tp (1) = dmpr_data_.dirp; tp (2) = dmpr_data_.inputp; tp (3) = dmpr_data_.recordp; tp (4) = dmpr_data_.infop; call release_temp_segments_ ("dumper", tp, code); call hcs_$set_256K_switch (dmpr_data_.old_256K_switch, (""b), (0)); dmpr_data_.dump_in_progress = "0"b; /* finished */ call set_lock_$unlock (dmpr_data_.lock, ignore); dmprp = null; /* vanish the control seg */ return; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ detach: proc (iocb_name, iocbp); /* This proc detachs the switch specified . It ignores all errors */ dcl iocb_name char (*); dcl tiocbp ptr; dcl iocbp ptr; call iox_$find_iocb (iocb_name, tiocbp, ignore); call iox_$close (tiocbp, ignore); call iox_$detach_iocb (tiocbp, ignore); iocbp = null (); return; end detach; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ %page; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ unlock_volume_log: proc; /* This proc unlocks the backup_volume_log, which may be locked. It also closes the volume log. */ call set_lock_$unlock (backup_volume_log.lock, ignore); call dmpr_log_$close_volume_log (code); return; end unlock_volume_log; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ unlock_pvolog: proc; /* This proc unlocks the output volume log */ call set_lock_$unlock (pvolog.lock, ignore); return; end unlock_pvolog; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ setbc_term: proc (p); /* This proc terminates the specified segment and sets the ptr to it to null */ dcl p ptr; dcl dn char (168); dcl en char (32); dcl ldn fixed bin; call hcs_$fs_get_path_name (p, dn, ldn, en, ignore); call adjust_bit_count_ (dn, en, "0"b, (0), ignore); call hcs_$terminate_seg (p, 0, ignore); p = null; end setbc_term; %page; %include dmpr_data_; %page; %include backup_static_variables; %page; %include backup_volume_log; %page; %include backup_pvol_info; %page; %include fs_vol_label; %page; %include backup_volume_header; %page; %include backup_volume_contents; %page; %include pvolog; %page; %include system_constants; %page; %include terminate_file; end dmpr_finish_;  dmpr_info_.pl1 10/22/84 0946.0rew 10/22/84 0902.2 17118 /* *********************************************************** * * * Copyright, (C) Honeywell Information Systems Inc., 1982 * * * * Copyright (c) 1972 by Massachusetts Institute of * * Technology and Honeywell Information Systems, Inc. * * * *********************************************************** */ dmpr_info_: proc (code); /* This routine initializes the info segment that is written as the first object on each output volume. The info segment describes the dump pass and defines what system it came from by means of the rpv uid, which will be different from site to site. This infomation is used by the volume reloader. */ dcl code fixed bin (35); dcl lvname char (32) aligned; dcl clock_ entry returns (fixed bin (71)); dcl mdc_$pvname_info entry (char (*) aligned, bit (36) aligned, char (*) aligned, bit (36) aligned, fixed bin, fixed bin (35)); %include backup_info; %include dmpr_data_; %include backup_volume_header; infop = dmpr_data_.infop; backup_info.pattern1 = pattern1; backup_info.pattern2 = pattern2; backup_info.pattern3 = pattern3; backup_info.rec1_type = info_type; backup_info.rec1_len = 4 * size (backup_info); backup_info.rec2_type = null_type; backup_info.rec2_len = 0; call mdc_$pvname_info ("rpv", backup_info.rpv_pvid, lvname, backup_info.rpv_lvid, backup_info.rpv_disk_type, code); if code ^= 0 then return; dmpr_data_.rpv_pvid = backup_info.rpv_pvid; /* because the label really doesn't have it */ backup_info.version = backup_info_version_2; backup_info.control_file = dmpr_data_.control_name; backup_info.operator = dmpr_data_.operator; backup_info.dump_type = dmpr_data_.dump_type; return; end dmpr_info_;  dmpr_log_.pl1 10/18/89 1038.4rew 10/18/89 1034.4 345537 /****^ *********************************************************** * * * Copyright, (C) BULL HN Information Systems Inc., 1989 * * * * Copyright, (C) Honeywell Bull Inc., 1989 * * * * Copyright, (C) Honeywell Information Systems Inc., 1982 * * * * Copyright (c) 1972 by Massachusetts Institute of * * Technology and Honeywell Information Systems, Inc. * * * *********************************************************** */ /****^ HISTORY COMMENTS: 1) change(86-07-10,GWMay), approve(86-07-10,MCR7445), audit(86-11-20,GDixon), install(86-12-09,MR12.0-1238): modified the code which allocates the storage for the entrynames in a directory to check the number of names. If the names are <0 or greater than the calculated limit, the program will report the directory as having a problem. Before this fix the dumper would try to allocate very large amounts of storage and blow up. Changed to use actual file storage for contents names vs allocated storage and then assignment. Changed to use pathname_ and expand_pathname_$add_suffix instead of an internal routine. Changed to check for available space in the .contents_names segment instead of using an out_of_bounds condition. Changed error messages to be more descriptive and fit within 80 chars. 2) change(86-12-01,GWMay), approve(86-12-01,PBF7445), audit(86-12-01,GDixon), install(86-12-09,MR12.0-1238): moved call to msf_manager_$adjust after the call to msf_manager_$get_ptr. removed calls to terminate_file_ which msf_manager_$adjust was intended to replace. 3) change(89-01-06,GWMay), approve(89-01-06,MCR8039), audit(89-01-09,Farley), install(89-01-17,MR12.3-1002): Changed to call msf_mgr_$adjust to correctly set the size of the .contents_names segments. 4) change(89-08-31,GWMay), approve(89-10-03,MCR8135), audit(89-10-04,Beattie), install(89-10-12,MR12.3-1092): Added support for version 3 backup_volume_log.incl.pl1 structures. Initialized new structure values backup_volume_log.Nsaved_(cons incr)_sets. 5) change(89-10-18,GWMay), approve(89-10-18,PBF1089), audit(89-10-18,Beattie), install(89-10-18,MR12.3-1094): Fix bug where the values of the new variables were not copied to the new log. END HISTORY COMMENTS */ /* format: style1,ind2,^inddcls,ifthenstmt,dclind2,declareind2,ifthendo,ifthen*/ dmpr_log_: proc; /* This routine provides all the record keeping functions that the volume dumper subsystem requires. It creates in use, and the prev output log. In addition this routine creates and updates the contents segment one of which exists for each dump volume and the account segment, one of which exists for each dump volume. The volume log contains a record of all dump volumes that contain information taken from that physical volume, the times during which the dump volume was written, and some statistics about what was written. The output volume log contains a record of each physical volume written on this dump volume and a count of how many times it was done. The prev volume log contains a record of the last/previous dump volumes that have been written. The contents segment contains a uid of every object that was written on a dump volume. The volume log is used by the volume reloader and retriever to determine which dump volumes should be read to recover the data. The output log is used by the dumper to protect dump volumes from destruction while they still have useful information on them. The contents segment is used by the volume retriever to save time by searching the online contents segment rather then having to search the dump volume. */ /* Modified: 11/16/81 by GA Texada to not lock the volume log in open_volume_log if the previous volume log wasn't closed before returning. Modified: 11/24/81 by GAT to not make a "names" seg unless -names was specified. Modified: 04/05/83 by GA Texada to add a trace capability. Modified: 04/84 by GA Texada for version 2 volume logs. */ dcl Lall_entry_names fixed bin (21); dcl Pall_entry_names ptr; dcl all_entry_names char (Lall_entry_names) based (Pall_entry_names); dcl accountp ptr; dcl bit_count fixed bin (24); dcl code fixed bin (35); dcl counted_number_of_entries fixed bin; dcl counted_number_of_entry_names fixed bin; dcl dname char (168); dcl ename char (32); dcl found bit (1); dcl i fixed bin; dcl pname char (168); dcl stored_number_of_entry_names fixed bin; dcl uid_path (0:16) bit (36); dcl account_dir char (168) static init (">system_control_1>volume_backup_accounts") options (constant); dcl dump_idx fixed bin int static init (-1); dcl lock_wait_time fixed bin static init (60) options (constant); dcl max_entry_names fixed bin internal static; dcl max_dir_entries fixed bin internal static; dcl myname char (32) static init ("dmpr_log_") options (constant); dcl set_bc_n_truncate bit (3) int static init ("110"b) options (constant); dcl truncate_only bit (3) int static init ("010"b) options (constant); dcl out_of_bounds condition; dcl (addr, bin, clock, divide, fixed, hbound, lbound, length, null, ptr, unspec, rel, rtrim, size, substr) builtin; dcl 1 add_key aligned, 2 flags, ( 3 input_key bit (1), 3 input_desc bit (1), 3 mbz bit (34)) unal, 2 desc, ( 3 type fixed bin (2), 3 records fixed bin (9), 3 mbz1 bit (23)) unal, 2 key_len fixed bin, 2 key char (68); dcl error_table_$action_not_performed ext fixed bin (35); dcl error_table_$bad_dir fixed bin (35) ext static; dcl error_table_$bad_index fixed bin (35) ext static; dcl error_table_$bad_segment fixed bin (35) ext; dcl error_table_$bad_volid ext fixed bin (35); dcl error_table_$invalid_lock_reset ext fixed bin (35); dcl error_table_$namedup fixed bin (35) external; dcl error_table_$noentry ext fixed bin (35); dcl sys_info$default_dir_max_length fixed bin (17) ext static; dcl adjust_bit_count_ entry (char (*), char (*), bit (1), fixed bin, fixed bin (35)); dcl dmpr_report_$online_output entry options (variable); dcl dmpr_report_$error_output entry options (variable); dcl expand_pathname_ entry (char (*), char (*), char (*), fixed bin (35)); dcl expand_pathname_$add_suffix entry (char (*), char (*), char (*), char (*), fixed bin (35)); dcl hcs_$chname entry (char (*), char (*), char (*), char (*), fixed bin (35)); dcl hcs_$fs_get_path_name entry (ptr, char (*), fixed bin, char (*), fixed bin (35)); dcl hcs_$make_seg entry (char (*), char (*), char (*), fixed bin (5), ptr, fixed bin (35)); dcl hcs_$truncate_seg entry (ptr, fixed bin, fixed bin (35)); dcl ioa_$rsnnl entry options (variable); dcl iox_$attach_ioname entry (char (*), ptr, char (*), fixed bin (35)); dcl iox_$close entry (ptr, fixed bin (35)); dcl iox_$control entry (ptr, char (*), ptr, fixed bin (35)); dcl iox_$detach_iocb entry (ptr, fixed bin (35)); dcl iox_$open entry (ptr, fixed bin, bit (36), fixed bin (35)); dcl msf_manager_$adjust entry (ptr, fixed bin, fixed bin (24), bit (3), fixed bin (35)); dcl msf_manager_$close entry (ptr); dcl msf_manager_$get_ptr entry (ptr, fixed bin, bit (1), ptr, fixed bin, fixed bin (35)); dcl msf_manager_$open entry (char (*), char (*), ptr, fixed bin (35)); dcl pathname_ entry (char (*), char (*)) returns (char (168)); dcl set_lock_$lock entry (bit (36) aligned, fixed bin, fixed bin (35)); dcl set_lock_$unlock entry (bit (36) aligned, fixed bin (35)); %page; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ create_pvolog: entry (a_volname, code); dcl a_volname char (*); /* This entry creates the output log , and if successful initializes it */ code = 0; dmpr_data_.pvlp = null; dname = ""; ename = ""; pname = ""; pname = rtrim (dmpr_data_.sys_dir) || ">pvolog"; pname = pathname_ (pname, a_volname); call expand_pathname_$add_suffix (pname, "pvolog", dname, ename, code); if code ^= 0 then goto log_err; pname = pathname_ (dname, ename); call hcs_$make_seg (dname, ename, "", 01010b, pvlp, code); if code ^= 0 then do; log_err: call dmpr_report_$error_output (code, myname, "Error creating: ^/^a^/reason", pname); code = error_table_$bad_volid; return; end; pvolog.version = pvolog_version_1; pvolog.dump_type = dmpr_data_.dump_type; pvolog.volid = dmpr_data_.volid; pvolog.mount_time = clock; dmpr_data_.pvlp = pvlp; return; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ %page; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ update_pvolog: entry (code); /* This entry adds a physical volume name to an output log, if not there already, and increases the usage count associated with that physical volume name by one */ code = 0; pvlp = dmpr_data_.pvlp; call lock_pvolog; if code ^= 0 then return; found = "0"b; do i = 1 to pvolog.next while (^found); pvlep = addr (pvolog.array (i)); if pvle.pvname = dmpr_data_.pvname then do; found = "1"b; pvle.invocation_count = pvle.invocation_count + 1; end; end; if ^found then do; pvolog.next = pvolog.next + 1; pvolog.in_use = pvolog.in_use + 1; pvlep = addr (pvolog.array (pvolog.next)); pvle.invocation_count = 1; pvle.pvname = dmpr_data_.pvname; end; call unlock_pvolog; return; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ %page; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ log_object: entry (code); /* This entry adds the uid of the object to the contents segment and the uid pathname of the object to the account segment. */ code = 0; if dmpr_data_.contentsp = null then do; code = error_table_$noentry; return; end; contentsp = dmpr_data_.contentsp; recordp = dmpr_data_.recordp; backup_volume_contents.next = backup_volume_contents.next + 1; backup_volume_contents.uid (backup_volume_contents.next) = backup_volume_record.uid; backup_volume_contents.tape_loc (backup_volume_contents.next) = 0; backup_volume_contents.pad1 (backup_volume_contents.next) = "0"b; backup_volume_contents.offset (backup_volume_contents.next) = 0; backup_volume_contents.component (backup_volume_contents.next) = 0; if dmpr_data_.names & backup_volume_record.dirsw then do; dp = dmpr_data_.dirp; if able_to_count_entry_names () then if entry_names_are_ok () then if entry_names_fit_in_contents_seg (Pall_entry_names) then call put_entry_names_in_contents_seg (); end; if dmpr_data_.accounting then call update_accounting_info (); if dmpr_data_.trace then call dmpr_report_$online_output (0, myname, "Dumping ^12.3b: ^a.", backup_volume_record.uid, convert_puid_ ()); return; %page; /* ************************************************************************* */ able_to_count_entry_names: proc () returns (bit (1) aligned); /* ************************************************************************* */ on out_of_bounds begin; call dmpr_report_$error_output (error_table_$bad_index, myname, "Due to an out_of_bounds condition, the names of the entries in the following directory cannot be logged or added to the contents names segment. directory uid: ^o primary name: ^a pvname: ^a vtocx: ^o reason", dir.uid, backup_volume_record.primary_name, dmpr_data_.pvname, backup_volume_record.vtocx); goto exit_count; end; Lall_entry_names = 0; counted_number_of_entry_names = 0; counted_number_of_entries = 0; stored_number_of_entry_names = 0; do ep = ptr (dp, dir.entryfrp) repeat ptr (ep, entry.efrp) while (rel (ep) ^= "0"b & counted_number_of_entries <= max_dir_entries); stored_number_of_entry_names = stored_number_of_entry_names + entry.nnames; counted_number_of_entries = counted_number_of_entries + 1; do np = ptr (ep, entry.name_frp) repeat ptr (ep, np -> names.fp) while (rel (np) ^= "0"b & counted_number_of_entry_names <= max_entry_names); counted_number_of_entry_names = counted_number_of_entry_names + 1; Lall_entry_names = Lall_entry_names + length (rtrim (np -> names.name)) + length (">"); end; end; Lall_entry_names = Lall_entry_names + length (">"); return ("1"b); exit_count: return ("0"b); end able_to_count_entry_names; %page; /* ************************************************************************* */ entry_names_are_ok: proc () returns (bit (1) aligned); /* ************************************************************************* */ dcl Serror bit (1) aligned; Serror = "1"b; if stored_number_of_entry_names ^= counted_number_of_entry_names then do; call dmpr_report_$error_output (error_table_$bad_dir, myname, "The actual number of entry names in the directory does not match the number of entry names stored in the directory entries. counted: ^d stored: ^d directory uid: ^o primary name: ^a pvname: ^a vtocx: ^o reason", counted_number_of_entry_names, stored_number_of_entry_names, dir.uid, backup_volume_record.primary_name, dmpr_data_.pvname, backup_volume_record.vtocx); Serror = "0"b; end; if stored_number_of_entry_names < 0 | stored_number_of_entry_names > max_entry_names then do; call dmpr_report_$error_output (error_table_$bad_dir, myname, "The total number of names referenced by directory entries is negative or exceeds the maximum number of names a directory will hold. value: ^d directory uid: ^o primary name: ^a pvname: ^a vtocx: ^o reason", stored_number_of_entry_names, dir.uid, backup_volume_record.primary_name, dmpr_data_.pvname, backup_volume_record.vtocx); Serror = "0"b; end; return (Serror); end entry_names_are_ok; %page; /* ************************************************************************* */ entry_names_fit_in_contents_seg: proc (Pentry_name_storage) returns (bit (1) aligned); /* ************************************************************************* */ dcl Pentry_name_storage ptr, return_bit bit (1) aligned; dcl next_word_offset fixed bin (19); dcl sys_info$max_seg_size fixed bin (35) ext static; Pentry_name_storage = null; return_bit = "0"b; next_word_offset = 0; contents_namesp = dmpr_data_.contents_namesp; next_word_offset = backup_volume_contents_names.offset + divide (Lall_entry_names + (CHARS_PER_WORD - 1), CHARS_PER_WORD, 18, 0); if next_word_offset > sys_info$max_seg_size then do; bit_count = backup_volume_contents_names.offset * BITS_PER_WORD; call msf_manager_$adjust (dmpr_data_.fcbp, dmpr_data_.component, bit_count, set_bc_n_truncate, code); if code ^= 0 then do; dmpr_data_.names = "0"b; call dmpr_report_$online_output (code, dmpr_data_.myname, "Unable to truncate component in multisegment file: ^a>contents>^a.contents, Attempting to truncate and set bit count for component ^d. Names collection turned OFF.^/reason", dmpr_data_.sys_dir, dmpr_data_.volname, dmpr_data_.component); return ("0"b); end; dmpr_data_.component = dmpr_data_.component + 1; call msf_manager_$get_ptr (dmpr_data_.fcbp, dmpr_data_.component, "1"b, contents_namesp, 0, code); if code ^= 0 then do; dmpr_data_.names = "0"b; call dmpr_report_$online_output (code, dmpr_data_.myname, "Unable to get next component in multisegment file: ^a>contents>^a.contents, Attempting to get component ^d. Names collection turned OFF.^/reason", dmpr_data_.sys_dir, dmpr_data_.volname, dmpr_data_.component); return ("0"b); end; else do; dmpr_data_.contents_namesp = contents_namesp; backup_volume_contents_names.version = backup_volume_contents_version_3; backup_volume_contents_names.offset = bin (rel (addr (backup_volume_contents_names.begin))); backup_volume_contents_names.pad (*) = "0"b; next_word_offset = backup_volume_contents_names.offset + divide (Lall_entry_names + (CHARS_PER_WORD - 1), CHARS_PER_WORD, 18, 0); end; end; Pentry_name_storage = ptr (contents_namesp, backup_volume_contents_names.offset); backup_volume_contents.offset (backup_volume_contents.next) = backup_volume_contents_names.offset; backup_volume_contents.component (backup_volume_contents.next) = dmpr_data_.component; backup_volume_contents_names.offset = next_word_offset; return ("1"b); end entry_names_fit_in_contents_seg; %page; /* ************************************************************************* */ put_entry_names_in_contents_seg: proc (); /* ************************************************************************* */ dcl Lcurrent_name fixed bin, current_position fixed bin; Lcurrent_name = 0; all_entry_names = ""; current_position = 1; do ep = ptr (dp, dir.entryfrp) repeat ptr (ep, entry.efrp) while (rel (ep) ^= "0"b); do np = ptr (ep, entry.name_frp) repeat ptr (ep, np -> names.fp) while (rel (np) ^= "0"b); Lcurrent_name = length (rtrim (np -> names.name)); substr (all_entry_names, current_position, Lcurrent_name) = substr (np -> names.name, 1, Lcurrent_name); current_position = current_position + Lcurrent_name; Lcurrent_name = length (">"); substr (all_entry_names, current_position, Lcurrent_name) = ">"; current_position = current_position + Lcurrent_name; end; end; Lcurrent_name = length (">"); substr (all_entry_names, current_position, Lcurrent_name) = ">"; return; end put_entry_names_in_contents_seg; %page; /* ************************************************************************* */ update_accounting_info: proc (); /* ************************************************************************* */ do i = lbound (backup_volume_record.uid_path, 1) to hbound (backup_volume_record.uid_path, 1) while (backup_volume_record.uid_path (i) ^= "0"b); uid_path (i) = backup_volume_record.uid_path (i); end; i = i + 1; uid_path (i) = backup_volume_record.uid; add_key.input_key = "1"b; add_key.input_desc = "1"b; add_key.key_len = i * 4; unspec (add_key.key) = unspec (uid_path); add_key.records = fixed (backup_volume_record.records, 9); add_key.type = dmpr_data_.dump_type; call iox_$control (dmpr_data_.account_iocbp, "add_key", addr (add_key), code); if code ^= 0 then call dmpr_report_$error_output (code, myname, "Error adding key to account file:^/^a>^a.account^/reason", account_dir, dmpr_data_.volname); return; end update_accounting_info; /* end dmpr_log_$log_object */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ %page; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ close_account_file: entry (code); /* This entry closes down an account file */ if dmpr_data_.account_iocbp = null then return; call iox_$close (dmpr_data_.account_iocbp, code); if code ^= 0 then do; call dmpr_report_$error_output (code, myname, "Unable to close account file:^/^a>^a^/reason", account_dir, dmpr_data_.volname); return; end; call iox_$detach_iocb (dmpr_data_.account_iocbp, code); if code ^= 0 then call dmpr_report_$error_output (code, myname, "Unable to detach account file:^/^a>^a^/reason", account_dir, dmpr_data_.volname); dmpr_data_.account_iocbp = null; return; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ init_account_file: entry (code); /* This entry creates the account segment in a specified directory and if successful initializes it and sets a pointer to in static. */ code = 0; dname = ""; ename = ""; pname = ""; pname = pathname_ (account_dir, (dmpr_data_.volname)); call expand_pathname_$add_suffix (pname, "account", dname, ename, code); if code ^= 0 then goto acct_err; pname = pathname_ (dname, ename); retry_acc: call hcs_$make_seg (dname, ename, "", 01010b, accountp, code); if code ^= 0 then do; if code = error_table_$namedup then do; call rename_account_file (dname, ename, ename, 1, code); if code = 0 then goto retry_acc; end; acct_err: call dmpr_report_$error_output (code, myname, "Error creating:^/^a^/reason", pname); return; end; call iox_$attach_ioname ("account_file", dmpr_data_.account_iocbp, "vfile_ " || rtrim (pname) || " -dup_ok", code); if code ^= 0 then do; call dmpr_report_$error_output (code, myname, "Error attaching account file:^/^a^/reason", pname); return; end; call iox_$open (dmpr_data_.account_iocbp, Direct_update, "0"b, code); if code ^= 0 then do; call dmpr_report_$error_output (code, myname, "Error opening account file:^/^a^/reason", pname); return; end; return; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ %page; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ open_volume_log: entry (code); /* This entry creates a volume log entry. It also takes care to close off any old entries which this entries superceeds. This must be done as the volume retriever will not use an entry that is not closed. If it were to do so the first entry it would use would be the volume presently mounted. This, of course restricts the volume dumper such that now two dumper processes should dump the same physical volume in the same mode of operation */ code = 0; if dump_idx ^= -1 then return; /* two updates without a close */ bvlp = dmpr_data_.bvlp; call lock_volume_log; /* protect against two updates */ if code ^= 0 then return; do i = backup_volume_log.next to 1 by -1; bvlep = addr (backup_volume_log.array (i)); if bvle.close_time = 0 & bvle.dump_type = dmpr_data_.dump_type then do; bvle.close_time = clock; if dmpr_data_.restart_pvname ^= "" then dmpr_data_.cycle_uid = bvle.cycle_uid; end; end; backup_volume_log.next = backup_volume_log.next + 1; backup_volume_log.rpv_pvid = dmpr_data_.rpv_pvid; dump_idx = backup_volume_log.next; bvlep = addr (backup_volume_log.array (dump_idx)); bvle.dump_type = dmpr_data_.dump_type; /* update new record */ bvle.volid = dmpr_data_.volid; bvle.volname = dmpr_data_.volname; bvle.open_time = clock; bvle.cycle_uid = dmpr_data_.cycle_uid; bvle.close_time = 0; bvle.io_module = dmpr_data_.io_module; bvle.dir_num, bvle.dir_rec = -1; bvle.seg_num, bvle.seg_rec = -1; dmpr_data_.vol_log_dir_num = 0; dmpr_data_.vol_log_dir_rec = 0; dmpr_data_.vol_log_seg_num = 0; dmpr_data_.vol_log_seg_rec = 0; open_ret: call unlock_volume_log; return; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ %page; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ close_volume_log: entry (code); /* This entry closes a volume log entry. The internal static variable dump_indx is used in attemp to remenber what entry was in use, but it must be checked as a purge of the volume log can shift entries. If things have moved a linear search is made for the previous entry. In either case the entry is closed. */ code = 0; if dump_idx = -1 then return; /* its closed already */ bvlp = dmpr_data_.bvlp; call lock_volume_log; if code ^= 0 then return; bvlep = addr (backup_volume_log.array (dump_idx)); if (bvle.volname = dmpr_data_.volname & bvle.dump_type = dmpr_data_.dump_type & bvle.cycle_uid = dmpr_data_.cycle_uid & bvle.close_time = 0) then ; else do; do dump_idx = 1 to backup_volume_log.next; /* it may have moved */ bvlep = addr (backup_volume_log.array (dump_idx)); if (bvle.volname = dmpr_data_.volname & bvle.dump_type = dmpr_data_.dump_type & bvle.cycle_uid = dmpr_data_.cycle_uid & bvle.close_time = 0) then goto close_log_entry; end; code = error_table_$action_not_performed; call dmpr_report_$error_output (code, myname, "Unable to close:^/^a.volog^/reason", dmpr_data_.pvname); goto reset_log_data; end; close_log_entry: bvle.close_time = clock; bvle.dir_num = dmpr_data_.vol_log_dir_num; bvle.dir_rec = dmpr_data_.vol_log_dir_rec; bvle.seg_num = dmpr_data_.vol_log_seg_num; bvle.seg_rec = dmpr_data_.vol_log_seg_rec; reset_log_data: dmpr_data_.vol_log_dir_num = 0; dmpr_data_.vol_log_dir_rec = 0; dmpr_data_.vol_log_seg_num = 0; dmpr_data_.vol_log_seg_rec = 0; call set_bc (bvlp); call unlock_volume_log; dump_idx = -1; return; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ %page; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ init_contents_seg: entry (code); /* This entry create a contents segment and, if successful, initializes it. Note that since contents are written out they must contain a logical record header. */ code = 0; dname = ""; ename = ""; pname = ""; pname = rtrim (dmpr_data_.sys_dir) || ">contents"; pname = pathname_ (pname, (dmpr_data_.volname)); call expand_pathname_$add_suffix (pname, "contents", dname, ename, code); if code ^= 0 then goto cont_err; pname = pathname_ (dname, ename); call hcs_$make_seg (dname, ename, "", 01010b, contentsp, code); if contentsp ^= null then do; call hcs_$truncate_seg (contentsp, 0, code); if code ^= 0 then do; call dmpr_report_$error_output (code, myname, "Unable to truncate:^/^a^/reason", pname); code = 0; return; end; end; else do; cont_err: call dmpr_report_$error_output (code, myname, "Error creating:^/^a^/reason", pname); return; end; call init_header (contentsp, contents_type); dmpr_data_.contentsp = contentsp; backup_volume_contents.version = backup_volume_contents_version_3; backup_volume_contents.volname = dmpr_data_.volname; backup_volume_contents.volid = dmpr_data_.volid; backup_volume_contents.next = 0; backup_volume_contents.pad (*) = "0"b; if dmpr_data_.names then do; if dmpr_data_.contents_namesp ^= null then do; bit_count = backup_volume_contents_names.offset * BITS_PER_WORD; call msf_manager_$adjust (dmpr_data_.fcbp, dmpr_data_.component, bit_count, set_bc_n_truncate, code); call msf_manager_$close (dmpr_data_.fcbp); end; dmpr_data_.fcbp = null; dmpr_data_.contents_namesp = null; pname = rtrim (dmpr_data_.sys_dir) || ">contents>" || rtrim (dmpr_data_.volname) || ".contents_names"; call expand_pathname_ (pname, dname, ename, code); if code ^= 0 then do; name_err: dmpr_data_.names = "0"b; call dmpr_report_$error_output (code, myname, "Error creating:^/^a^/- names collection aborted.^/reason", pname); return; end; dmpr_data_.component = 0; call msf_manager_$open (dname, ename, dmpr_data_.fcbp, code); if code ^= 0 & code ^= error_table_$noentry then do; call dmpr_report_$error_output (code, myname, "Unable to open:^/^a^/- names collection aborted.^/reason", pname); dmpr_data_.names = "0"b; code = 0; return; end; call msf_manager_$get_ptr (dmpr_data_.fcbp, dmpr_data_.component, "1"b, contents_namesp, 0, code); if code ^= 0 then go to name_err; call msf_manager_$adjust (dmpr_data_.fcbp, dmpr_data_.component, 0, truncate_only, code); dmpr_data_.contents_namesp = contents_namesp; backup_volume_contents_names.version = backup_volume_contents_version_3; backup_volume_contents_names.offset = bin (rel (addr (backup_volume_contents_names.begin))); backup_volume_contents_names.pad (*) = "0"b; max_entry_names = divide (sys_info$default_dir_max_length - size (dir) - size (entry), size (names), 17); max_dir_entries = divide (sys_info$default_dir_max_length - size (dir), size (entry), 17); end; return; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ %page; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ init_volume_log: entry (code); /* This entry locates the volume log. If one does not exist it is created and initialized. Note that since volume logs are written out they must have a logical record header. */ code = 0; dmpr_data_.bvlp = null; dname = ""; ename = ""; pname = ""; pname = pathname_ ((dmpr_data_.sys_dir), (dmpr_data_.pvname)); call expand_pathname_$add_suffix (pname, "volog", dname, ename, code); if code ^= 0 then goto vol_err; pname = pathname_ (dname, ename); call hcs_$make_seg (dname, ename, "", 01010b, bvlp, code); if code = 0 then do; call dmpr_report_$online_output (0, myname, "new volume log created:^/^a", pname); backup_volume_log.pvname = dmpr_data_.pvname; backup_volume_log.pvid = dmpr_data_.pvid; backup_volume_log.reload_groups = 2; /* default value */ backup_volume_log.version = backup_volume_log_version_3; backup_volume_log.disk_type = dmpr_data_.disk_type; backup_volume_log.rpv_pvid = dmpr_data_.rpv_pvid; backup_volume_log.Nsaved_cons_sets = -1; backup_volume_log.Nsaved_incr_sets = -1; end; else if bvlp ^= null then do; code = 0; if (backup_volume_log.pvname = dmpr_data_.pvname & backup_volume_log.pvid = dmpr_data_.pvid) then do; if backup_volume_log.version = backup_volume_log_version_1 | backup_volume_log.version = backup_volume_log_version_2 | backup_volume_log.version = backup_volume_log_version_3 then do; backup_volume_log.version = backup_volume_log_version_3; backup_volume_log.disk_type = dmpr_data_.disk_type; backup_volume_log.rpv_pvid = dmpr_data_.rpv_pvid; end; else goto invalid_volog; end; else do; invalid_volog: code = error_table_$bad_segment; call dmpr_report_$error_output (code, myname, "Invalid ^a.volog^/reason", dmpr_data_.pvname); return; end; end; else do; vol_err: call dmpr_report_$error_output (code, myname, "Error getting ptr to:^/^a^/reason", pname); return; end; if backup_volume_log.pattern1 ^= pattern1 | backup_volume_log.pattern2 ^= pattern2 | backup_volume_log.pattern3 ^= pattern3 then call init_header (bvlp, volume_log_type); dmpr_data_.bvlp = bvlp; return; %page; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* The following six internal proc lock and unlock the various logs. They are all very similar except that they deal with different logs. They all assume that the local pointer has been set from its static value. */ lock_pvolog: proc; call set_lock_$lock (pvolog.lock, lock_wait_time, code); if code ^= 0 then do; if code = error_table_$invalid_lock_reset then code = 0; else call dmpr_report_$error_output (code, myname, "Unable to lock ^a.pvolog^/reason", dmpr_data_.volname); end; return; end lock_pvolog; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ unlock_pvolog: proc; call set_lock_$unlock (pvolog.lock, code); if code ^= 0 then call dmpr_report_$error_output (code, myname, "Error unlocking ^a.pvolog^/reason", dmpr_data_.volname); return; end unlock_pvolog; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ lock_volume_log: proc; call set_lock_$lock (backup_volume_log.lock, lock_wait_time, code); if code ^= 0 then do; if code = error_table_$invalid_lock_reset then code = 0; else call dmpr_report_$error_output (code, myname, "Unable to lock ^a.volog^/reason", dmpr_data_.pvname); end; return; end lock_volume_log; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ unlock_volume_log: proc; call set_lock_$unlock (backup_volume_log.lock, code); if code ^= 0 then call dmpr_report_$error_output (code, myname, "Error unlocking ^a.volog^/reason", dmpr_data_.pvname); return; end unlock_volume_log; %page; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ init_header: proc (tp, type); /* This proc initializes the logical volume header that is a part of all objects, except segments and directories, which it preceeds, which are written out. */ dcl tp ptr; dcl type fixed bin; tp -> backup_volume_log.pattern1 = pattern1; tp -> backup_volume_log.pattern2 = pattern2; tp -> backup_volume_log.pattern3 = pattern3; tp -> backup_volume_log.rec1_type = type; tp -> backup_volume_log.rec2_len = 0; tp -> backup_volume_log.rec2_type = null_type; return; end init_header; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ set_bc: proc (p); dcl p ptr; dcl dn char (168); dcl en char (32); dcl ldn fixed bin; call hcs_$fs_get_path_name (p, dn, ldn, en, code); if code ^= 0 then do; call dmpr_report_$error_output (code, myname, "Unable to convert ptr to pathname for bit count setting^/reason"); code = 0; return; end; call adjust_bit_count_ (dn, en, "0"b, (0), code); if code ^= 0 then call dmpr_report_$error_output (code, myname, "Unable to set bit count of ^a>^a^/reason", dn, en); code = 0; end set_bc; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ rename_account_file: proc (dn, prefix, en, a_suffix, ec); /* This proc recursively renames account segs with a numeric suffix utile a namedup is not encountered. This preserves the account segs in reverse numeric order for later processing. */ dcl dn char (*); dcl prefix char (*); dcl en char (*); dcl new_en char (32); dcl suffix fixed bin; dcl a_suffix fixed bin; dcl ec fixed bin (35); suffix = a_suffix; call ioa_$rsnnl ("^a.^d", new_en, (0), prefix, suffix); retry_rn: call hcs_$chname (dn, en, en, new_en, ec); if ec = error_table_$namedup then do; call rename_account_file (dn, prefix, new_en, suffix + 1, ec); if ec = 0 then goto retry_rn; end; end rename_account_file; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ %page; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* This proc is used to convert a unique id pathname to an ascii pathname */ convert_puid_: proc returns (char (168)); dcl (dn, ret_dn) char (168); dcl en char (32); dcl ec fixed bin (35); dcl seg_fault_error condition; dcl error_table_$root ext fixed bin (35); dcl hc_backup_$decode_uidpath entry options (variable); on seg_fault_error goto ret_unk; call hc_backup_$decode_uidpath (backup_volume_record.uid_path, dn, en, ec); if ec = error_table_$root then ; else if ec ^= 0 then ret_unk: return ("UNKNOWN_PATH>" || rtrim (backup_volume_record.primary_name, " ")); call ioa_$rsnnl ("^a^[>^]^[^a>^;^s^]^a", ret_dn, (0), dn, dn ^= ">", en ^= "", en, backup_volume_record.primary_name); return (ret_dn); end convert_puid_; %page; %include backup_static_variables; %page; %include backup_volume_contents; %page; %include backup_volume_header; %page; %include backup_volume_record; %page; %include backup_volume_log; %page; %include backup_pvol_info; %page; %include dir_header; %page; %include dir_name; %page; %include dir_entry; %page; %include dmpr_data_; %page; %include fs_vol_label; %page; %include iox_modes; %page; %include pvolog; %page; %include system_constants; %page; %include vtoce; end dmpr_log_;  dmpr_output_.pl1 10/10/89 1422.4r w 10/10/89 1359.8 338508 /****^ *********************************************************** * * * Copyright, (C) Honeywell Bull Inc., 1988 * * * * Copyright, (C) Honeywell Information Systems Inc., 1982 * * * * Copyright (c) 1972 by Massachusetts Institute of * * Technology and Honeywell Information Systems, Inc. * * * *********************************************************** */ /****^ HISTORY COMMENTS: 1) change(88-10-05,GWMay), approve(88-10-05,MCR8005), audit(88-10-12,Farley), install(88-10-17,MR12.2-1173): Changed to output a unique string to delimit each set of system data dumped. END HISTORY COMMENTS */ /* format: style1,ind2,^inddcls,ifthenstmt,dclind2,declareind2,ifthendo,ifthen*/ dmpr_output_: proc; /* This routine writes the objects that are being dumped through the specified switch. It controls error recovery and volume attachment for the switch. Any object written is preceeded by logical header which identifies its type and length and provides a unique pattern in case resynchronization is necessary. */ /* 1) Modified: 12/17/81 by GA Texada to add a query in the attach proc to enable a clean exit. */ /* and to fix phxXXXXX */ /* 2) Modified: 7/15/82 by GA Texada to fix hardcore 372 (phx01702). */ /* 3) Modified: 11/12/82 by GA Texada to implement phx14088, */ /* implements preattach_(vols ioname) */ /* 4) Modified: 1/26/83 to set dmpr_data_.cur_vol_open */ /* 5) Modified: August 1983 by GA Texada to add new_pass_attach and end_pass_detach. */ /* 6) Modified: April 1985 by SGH (UNCA) to fix preattach cleanup -- phx17367, to complete fix for phx8938, and to synchronize output after non-null objects */ dcl dirname char (168); dcl ename char (32); dcl ldn fixed bin; dcl current_length fixed bin; dcl attach_name char (32); dcl answer char (3) var; dcl error_count fixed bin; dcl prev_contentsp ptr; dcl retry bit (1); dcl new_tape bit (1); dcl att_desc char (256); dcl write_volume_log bit (1); dcl code fixed bin (35); dcl ignore fixed bin (35); dcl datap ptr; dcl (prex, sprex) fixed bin; dcl pagex fixed bin; dcl pagep ptr; dcl page_of_chars char (CHARS_PER_PAGE) based (pagep) aligned; dcl page_by_page bit (1); dcl start_numeric fixed bin; dcl char_num char (32); dcl num fixed bin; dcl myname char (32) int static init ("dmpr_output_") options (constant); dcl max_error_count fixed bin int static options (constant) init (64); dcl zero_char char (1) int static init ("") options (constant); dcl ascii_type (3) char (4) int static init ("incr", "cons", "comp") options (constant); dcl retry_explanation char (143) init ( "The attachment of the dump volume has failed. A ""yes"" answer will attempt to reattach the same volume. A ""no"" answer will terminate the dump.") int static options (constant); dcl delete_explanation char (148) init ( "The open of the dump volume has failed. A ""yes"" answer will delete the volume from the volume pool. A ""no"" answer will leave the volume in the pool.") int static options (constant); dcl continue_explanation char (141) init ( "The open of the dump volume has failed. A ""yes"" answer will continue the dump with a different volume. A ""no"" answer will terminate the dump.") int static options (constant); dcl 1 volid aligned, 2 char char (2) unaligned, 2 num fixed bin unaligned; dcl 1 local_status_branch like status_branch aligned; dcl command_query_ entry options (variable); dcl continue_to_signal_ entry (fixed bin (35)); dcl suffixed_name_$make entry (char (*), char (*), char (*), fixed bin (35)); dcl manage_volume_pool_$reserve entry (ptr, entry options (variable), char (*), char (*), char (*), fixed bin (35)); dcl manage_volume_pool_$allocate entry (ptr, entry options (variable), char (*), char (*), char (*), fixed bin (35)); dcl manage_volume_pool_$free entry (ptr, entry options (variable), char (*), fixed bin (35)); dcl manage_volume_pool_$delete entry (ptr, entry options (variable), char (*), fixed bin (35)); dcl manage_volume_pool_$set_volid entry (ptr, entry options (variable), char (*), bit (36), fixed bin (35)); dcl cv_dec_check_ entry (char (*), fixed bin (35)) returns (fixed bin); dcl iox_$attach_ioname entry (char (*), ptr, char (*), fixed bin (35)); dcl iox_$control entry (ptr, char (*), ptr, fixed bin (35)); dcl iox_$modes entry (ptr, char (*), char (*), fixed bin (35)); dcl iox_$open entry (ptr, fixed bin, bit (36), fixed bin (35)); dcl iox_$put_chars entry (ptr, ptr, fixed bin, fixed bin (35)); dcl iox_$close entry (ptr, fixed bin (35)); dcl iox_$detach_iocb entry (ptr, fixed bin (35)); dcl dmpr_output_$preattach_vols entry (fixed bin, fixed bin, fixed bin (35)); dcl dmpr_output_$preattach_ioname entry (fixed bin, fixed bin, fixed bin (35)); dcl dmpr_report_$error_output entry options (variable); dcl dmpr_log_$init_account_file entry (fixed bin (35)); dcl dmpr_log_$close_account_file entry (fixed bin (35)); dcl dmpr_log_$open_volume_log entry (fixed bin (35)); dcl dmpr_log_$close_volume_log entry (fixed bin (35)); dcl dmpr_log_$init_contents_seg entry (fixed bin (35)); dcl dmpr_log_$update_pvolog entry (fixed bin (35)); dcl dmpr_log_$create_pvolog entry (char (*), fixed bin (35)); dcl hcs_$delentry_seg entry (ptr, fixed bin (35)); dcl hcs_$initiate entry (char (*), char (*), char (*), fixed bin, fixed bin, ptr, fixed bin (35)); dcl hcs_$terminate_seg entry (ptr, fixed bin, fixed bin (35)); dcl hcs_$fs_get_path_name entry (ptr, char (*), fixed bin, char (*), fixed bin (35)); dcl adjust_bit_count_ entry (char (*), char (*), bit (1), fixed bin, fixed bin (35)); dcl hcs_$status_long entry (char (*), char (*), fixed bin, ptr, ptr, fixed bin (35)); dcl dmpr_report_$online_output entry options (variable); dcl ioa_$rsnnl entry options (variable); dcl unique_bits_ entry () returns (bit (70)); dcl tape_check bit (72); dcl seg_fault_error condition; dcl page_read_error condition; dcl page_fault_error condition; dcl error_table_$segfault ext fixed bin (35); dcl error_table_$bad_volid ext fixed bin (35); dcl error_table_$action_not_performed ext fixed bin (35); dcl error_table_$device_end ext fixed bin (35); dcl error_table_$end_of_info ext fixed bin (35); dcl error_table_$fatal_error ext fixed bin (35); dcl error_table_$undefined_order_request ext fixed bin (35); dcl error_table_$no_operation ext fixed bin (35); dcl (addr, substr, null, size, fixed, ptr, search, unspec, length, rtrim, clock) builtin; dcl (before, bit, divide) builtin; init: entry (code); /* This entry initializes the output routine. It sets up the logical record header and attaches the number of output volumes requested */ dcl local_pre_attach_vol fixed bin; /* for use in preattaching volumes */ code = 0; write_volume_log = ""b; query_info.version = query_info_version_5; query_info.yes_or_no_sw = "1"b; recordp = dmpr_data_.recordp; backup_volume_record.version = backup_volume_record_version_2; backup_volume_record.pattern1 = pattern1; backup_volume_record.pattern2 = pattern2; backup_volume_record.pattern3 = pattern3; if dmpr_data_.pre_attach_vol > 0 then do; local_pre_attach_vol = dmpr_data_.pre_attach_vol; dmpr_data_.pre_attach_vol = 0; call dmpr_output_$preattach_vols (local_pre_attach_vol, 1, code); if code ^= 0 then return; call dmpr_report_$online_output (0, dmpr_data_.myname, "Please get the following volumes: ^v(^a ^)", local_pre_attach_vol, dmpr_data_.pre_attach_volname (*)); dmpr_data_.pvlp = null; dmpr_data_.volid = "0"b; dmpr_data_.volname = ""; call dmpr_output_$preattach_ioname (local_pre_attach_vol, 1, code); if code ^= 0 then return; dmpr_data_.pre_attach_vol = local_pre_attach_vol; end; call attach; return; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ new_pass_attach: entry (code); write_volume_log = ""b; call attach (); /* takes care of errors himself */ return; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ end_pass_detach: entry (code); write_volume_log = ""b; call detach (); return; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ output_object: entry (datap, code); /* This entry writes the vtoce and the object , if one exists, on the attached switch. If the object has pages of zeros it is written out in a compacted form. The output strategy is to write the object untill the write succedes. Thus if an object spans a dump volume , it will be rewritten, in its entirity on the new dump volume */ code = 0; write_volume_log = ""b; query_info.version = query_info_version_5; query_info.yes_or_no_sw = "1"b; recordp = dmpr_data_.recordp; bvlp = dmpr_data_.bvlp; page_by_page = "0"b; backup_volume_record.rec1_type = vtoce_type; backup_volume_record.rec1_len = CHARS_PER_WORD * size (backup_volume_record); if datap ^= null then do; if backup_volume_record.dirsw then backup_volume_record.rec2_type = dir_type; else backup_volume_record.rec2_type = seg_type; if fixed (backup_volume_record.csl, 9) ^= fixed (backup_volume_record.records, 9) then do; page_by_page = "1"b; backup_volume_record.rec2_len = CHARS_PER_PAGE * fixed (backup_volume_record.records, 9); end; else if fixed (backup_volume_record.csl, 9) = 0 then backup_volume_record.rec2_len = 0; else backup_volume_record.rec2_len = CHARS_PER_PAGE * (fixed (backup_volume_record.records, 9) - 1) + CHARS_PER_WORD * last_page_length (); end; else do; backup_volume_record.rec2_type = null_type; backup_volume_record.rec2_len = 0; end; start_io: retry = "1"b; do while (retry); /* write the VTOCE for this seg/dir */ call iox_$put_chars (dmpr_data_.outputvol_iocbp, recordp, backup_volume_record.rec1_len, code); call check_output_error; end; on seg_fault_error, page_fault_error begin; if tape_check ^= ""b then do; call iox_$put_chars (dmpr_data_.outputvol_iocbp, addr (tape_check), size (tape_check) * CHARS_PER_WORD, code); call check_output_error; end; call continue_to_signal_ (code); end; tape_check = ""b; /* write the data from this seg/dir */ if backup_volume_record.rec2_len ^= 0 then do; tape_check = dmpr_data_.volid || substr (unique_bits_ (), 35); call iox_$put_chars (dmpr_data_.outputvol_iocbp, addr (tape_check), size (tape_check) * CHARS_PER_WORD, code); call check_output_error; if new_tape then goto start_io; if ^page_by_page then do; retry = "1"b; do while (retry); call iox_$put_chars (dmpr_data_.outputvol_iocbp, datap, backup_volume_record.rec2_len, code); call check_output_error; if new_tape then goto start_io; end; end; else call page_by_page_write; call iox_$put_chars (dmpr_data_.outputvol_iocbp, addr (tape_check), size (tape_check) * CHARS_PER_WORD, code); call check_output_error; if new_tape then goto start_io; tape_check = ""b; /* back to "" so it doesn't get written below */ call iox_$control (dmpr_data_.outputvol_iocbp, "error_count", addr (error_count), code); /* force output synchronization */ if ^(code = error_table_$undefined_order_request | code = error_table_$no_operation) then do; if code = 0 then if error_count > max_error_count then code = error_table_$fatal_error; /* too many errors, abandon tape */ call check_output_error; if new_tape then goto start_io; end; end; non_local_return: if tape_check ^= ""b then do; call iox_$put_chars (dmpr_data_.outputvol_iocbp, addr (tape_check), size (tape_check) * CHARS_PER_WORD, code); call check_output_error; end; return; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ preattach_vols: entry (nvols_to_get, begin_indx, mcode); dcl (nvols_to_get, begin_indx) fixed bin, mcode fixed bin (35), safe_pvlp ptr, /* use to save the current values */ safe_volname char (32), /* crucial variables from dmpr_data_ */ safe_volid bit (36); /* when doing this routine */ safe_volname = dmpr_data_.volname; safe_volid = dmpr_data_.volid; safe_pvlp = dmpr_data_.pvlp; write_volume_log = ""b; do prex = begin_indx to (dmpr_data_.pre_attach_vol + nvols_to_get); call get_volname (mcode); if mcode ^= 0 then goto restore_safe; dmpr_data_.pre_attach_volname (prex) = dmpr_data_.volname; dmpr_data_.pre_attach_volid (prex) = dmpr_data_.volid; dmpr_data_.pre_attach_pvlp (prex) = dmpr_data_.pvlp; end; restore_safe: dmpr_data_.volname = safe_volname; /* restore all these */ dmpr_data_.volid = safe_volid; dmpr_data_.pvlp = safe_pvlp; return; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ preattach_ioname: entry (nvols_to_name, begin_indx, picode); dcl nvols_to_name fixed bin, picode fixed bin (35); write_volume_log = ""b; do prex = begin_indx to (dmpr_data_.pre_attach_vol + nvols_to_name); call ioa_$rsnnl ("^a.^d", attach_name, (0), "dump_volume", prex); if dmpr_data_.att_desc ^= "" then call ioa_$rsnnl (dmpr_data_.att_desc, att_desc, (0), dmpr_data_.pre_attach_volname (prex)); else call ioa_$rsnnl ("tape_mult_ ^a -write -system", att_desc, (0), dmpr_data_.pre_attach_volname (prex)); dmpr_data_.io_module = before (att_desc, " "); call iox_$attach_ioname (attach_name, dmpr_data_.pre_attach_iocbp (prex), att_desc, picode); if picode ^= 0 then do; call dmpr_report_$error_output (picode, myname, "Unable to attach ^a via desc ^a", attach_name, att_desc); if (prex - begin_indx >= 1) then do; /* if I got at least one attached, fake 'em out */ picode = 0; /* so we don't quit */ sprex = prex - begin_indx; /* this is how many we have */ end; else sprex = 0; do prex = prex to (dmpr_data_.pre_attach_vol + nvols_to_name); /* get rid of the pvolog segments for these */ call hcs_$delentry_seg (dmpr_data_.pre_attach_pvlp (prex), ignore); dmpr_data_.pre_attach_pvlp (prex) = null (); if dmpr_data_.auto_vol then /* and free the volumes in the pool */ call manage_volume_pool_$free (dmpr_data_.vpp, dmpr_report_$error_output, (dmpr_data_.pre_attach_volname (prex)), ignore); dmpr_data_.pre_attach_volname (prex) = ""; /* and clean up these... */ dmpr_data_.pre_attach_volid (prex) = "0"b; end; nvols_to_name = sprex; /* now, tell him how many we really did */ end; end; return; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ write_volume_log: entry (code); /* This entry writes a volume log on the attached switch. */ code = 0; query_info.version = query_info_version_5; write_volume_log = "1"b; recordp = dmpr_data_.recordp; bvlp = dmpr_data_.bvlp; call get_seg_current_length (bvlp); if code ^= 0 then do; call dmpr_report_$error_output (code, myname, "Unable to find length of volume log ^a.volog", dmpr_data_.pvname); return; end; backup_volume_log.rec1_len = current_length * CHARS_PER_PAGE; backup_volume_record.rec2_type = null_type; backup_volume_record.rec2_len = 0; backup_volume_log.time_dumped = substr (bit (fixed (clock, 52), 52), 1, 36); /* vologs have the header builtin so we don't write one. */ /* Just write it as one big header */ retry = "1"b; do while (retry); call iox_$put_chars (dmpr_data_.outputvol_iocbp, bvlp, backup_volume_log.rec1_len, code); call check_output_error; end; return; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ get_volname: proc (ec); dcl volid bit (36); dcl volname char (32); dcl ec fixed bin (35); /* This proc reads a dump volume name and converts it to a volume id. Volume names are restricted to two or less acsii characters preceeding a numeric value(eg ic12345 is ok but inc12345 is not). It also creates an output log for the dump volume in which all the physical volumes that are dumped on this dump volume will be recorded. If the output log can not be created then it is assumed that the volume is alreay in use and another volume name is requested. */ request: volname = "*"; if dmpr_data_.auto_vol then do; get_vol: call manage_volume_pool_$reserve (dmpr_data_.vpp, dmpr_report_$error_output, volname, ascii_type (dmpr_data_.dump_type), volname, ec); if ec ^= 0 then do; if volname ^= "*" & ec = error_table_$action_not_performed then do; call dmpr_report_$online_output (0, myname, "Pool volume ^a already allocated", volname); return; /* let attach get us a new one */ end; if ec = error_table_$action_not_performed then ec = 0; call dmpr_report_$online_output (ec, myname, "Unable to get next dump volume name from dump volume pool"); reread1: call get_volname_from_user (volname); goto get_vol; /* add to volume pool */ end; call set_volid (volname, volid, ec); if ec ^= 0 then do; call dmpr_report_$online_output (ec, myname, "Invalid volume id ^a", volname); bad_volid: call manage_volume_pool_$free (dmpr_data_.vpp, dmpr_report_$error_output, volname, ignore); call manage_volume_pool_$delete (dmpr_data_.vpp, dmpr_report_$error_output, volname, ignore); goto request; end; call manage_volume_pool_$set_volid (dmpr_data_.vpp, dmpr_report_$error_output, volname, volid, ec); if ec ^= 0 then do; call dmpr_report_$error_output (ec, dmpr_data_.myname, "Unable to set volid for ^a", volname); goto bad_volid; end; end; else do; reread2: call get_volname_from_user (volname); call set_volid (volname, volid, ec); if ec ^= 0 then do; call dmpr_report_$online_output (ec, myname, "Invalid volume id ^a specified.", volname); goto reread2; end; end; call dmpr_log_$create_pvolog (volname, ec); if ec ^= 0 then do; call dmpr_report_$online_output (0, myname, "Dump volume ^a still contains pertinent information", volname); goto request; end; dmpr_data_.volid = volid; dmpr_data_.volname = volname; return; end get_volname; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ attach: proc; /* This proc attaches an output volume through the specified attach description and opens it. It then create a contents segment and an account sgment for this volume. It then attempts to determine the previous dump volume of this type and write its contents segment on the just attached dump volume. Finally it updates the prev output log to reflect this dump volume is now the previous dump volume. A return code of a -1 will indicate that the dump should be aborted by Operator request. */ dmpr_data_.cur_vol_open = "0"b; retry_attach: if dmpr_data_.pre_attach_vol > 0 then do; dmpr_data_.vol_idx = dmpr_data_.vol_idx + 1; if dmpr_data_.vol_idx > dmpr_data_.pre_attach_vol then do; dmpr_data_.pre_attach_vol, dmpr_data_.vol_idx = 0; goto non_pre_attach; /* turn it off */ end; dmpr_data_.volname = dmpr_data_.pre_attach_volname (dmpr_data_.vol_idx); dmpr_data_.volid = dmpr_data_.pre_attach_volid (dmpr_data_.vol_idx); dmpr_data_.outputvol_iocbp = dmpr_data_.pre_attach_iocbp (dmpr_data_.vol_idx); dmpr_data_.pvlp = dmpr_data_.pre_attach_pvlp (dmpr_data_.vol_idx); end; else do; non_pre_attach: call get_volname (code); if code ^= 0 then return; if dmpr_data_.att_desc ^= "" then call ioa_$rsnnl (dmpr_data_.att_desc, att_desc, (0), dmpr_data_.volname); else call ioa_$rsnnl ("tape_mult_ ^a -write -system", att_desc, (0), dmpr_data_.volname); dmpr_data_.io_module = before (att_desc, " "); reattach: call iox_$attach_ioname ("dump_volume", dmpr_data_.outputvol_iocbp, att_desc, code); if code ^= 0 then do; call dmpr_report_$error_output (code, myname, "Unable to attach dump volume ^a.", dmpr_data_.volname); query_info.explanation_ptr = addr (retry_explanation); query_info.explanation_len = length (retry_explanation); call command_query_ (addr (query_info), answer, myname, "^/Do you wish to re-try the attachment?"); query_info.explanation_ptr = null (); /* because its used elsewhere */ query_info.explanation_len = 0; /* and we dont want to confuse anyone */ if answer = "yes" then goto reattach; else do; call hcs_$delentry_seg (dmpr_data_.pvlp, ignore); call hcs_$terminate_seg (dmpr_data_.pvlp, 0, ignore); dmpr_data_.pvlp = null (); if dmpr_data_.auto_vol then call manage_volume_pool_$free (dmpr_data_.vpp, dmpr_report_$error_output, (dmpr_data_.volname), ignore); code = -1; /* flag for dumper */ return; end; end; end; if dmpr_data_.auto_vol then do; call manage_volume_pool_$allocate (dmpr_data_.vpp, dmpr_report_$error_output, (dmpr_data_.volname), ascii_type (dmpr_data_.dump_type), (dmpr_data_.volname), code); if code ^= 0 then do; call dmpr_report_$error_output (code, myname, "Unable to mark ^a allocated in volume pool", dmpr_data_.volname); call hcs_$delentry_seg (dmpr_data_.pvlp, ignore); call hcs_$terminate_seg (dmpr_data_.pvlp, 0, ignore); dmpr_data_.pvlp = null (); call iox_$detach_iocb (dmpr_data_.outputvol_iocbp, (0)); goto retry_attach; end; end; call iox_$open (dmpr_data_.outputvol_iocbp, Stream_output, "0"b, code); if code ^= 0 then do; call dmpr_report_$error_output (code, myname, "Error on opening dump volume ^a", dmpr_data_.volname); call iox_$detach_iocb (dmpr_data_.outputvol_iocbp, ignore); call hcs_$delentry_seg (dmpr_data_.pvlp, ignore); call hcs_$terminate_seg (dmpr_data_.pvlp, 0, ignore); dmpr_data_.pvlp = null (); if dmpr_data_.auto_vol then do; call manage_volume_pool_$free (dmpr_data_.vpp, dmpr_report_$error_output, (dmpr_data_.volname), ignore); if dmpr_data_.pre_attach_vol > 0 then goto retry_attach; /* presumably, there isn't anyone to answer our questions so,*/ query_info.explanation_ptr = addr (delete_explanation); query_info.explanation_len = length (delete_explanation); call command_query_ (addr (query_info), answer, myname, "^/^a^/^a", "The open operation has failed.", "Do you wish to delete the volume from the pool? "); if answer = "yes" then call manage_volume_pool_$delete (dmpr_data_.vpp, dmpr_report_$error_output, (dmpr_data_.volname), ignore); query_info.explanation_ptr = addr (continue_explanation); query_info.explanation_len = length (continue_explanation); call command_query_ (addr (query_info), answer, myname, "^/Do you wish to continue the dump?"); query_info.explanation_ptr = null (); query_info.explanation_len = 0; if answer = "yes" then ; else do; code = -1; /* Operator aborted the dump */ return; end; end; goto retry_attach; end; call iox_$modes (dmpr_data_.outputvol_iocbp, "async", (""), (0)); /* run asynchronously */ dmpr_data_.cur_vol_open = "1"b; /* ok, good open */ call dmpr_log_$init_contents_seg (code); if code ^= 0 then do; call dmpr_report_$error_output (code, myname, "Contents seg init failure"); return; end; if dmpr_data_.accounting then do; call dmpr_log_$init_account_file (code); if code ^= 0 then do; call dmpr_report_$error_output (code, myname, "Account file init failure"); return; end; end; infop = dmpr_data_.infop; backup_info.rec2_type = null_type; backup_info.rec2_len = 0; backup_info.dump_volname = dmpr_data_.volname; backup_info.dump_volid = dmpr_data_.volid; backup_info.time_dumped = substr (bit (fixed (clock, 52), 52), 1, 36); retry = "1"b; do while (retry); call iox_$put_chars (dmpr_data_.outputvol_iocbp, infop, backup_info.rec1_len, code); call check_output_error; end; if dmpr_data_.prev_volname = "" then do; call dmpr_report_$error_output (0, dmpr_data_.myname, "Previous dump volume not known. Contents segment not written to new dump volume"); goto update_prev; end; call suffixed_name_$make ((dmpr_data_.prev_volname), "contents", ename, code); if code ^= 0 then goto prev_err; call hcs_$initiate (rtrim (dmpr_data_.sys_dir) || ">contents", ename, "", 0, 1, prev_contentsp, code); if prev_contentsp = null then do; prev_err: call dmpr_report_$error_output (code, myname, "Unable to locate contents seg ^a", ename); goto update_prev; end; call get_seg_current_length (prev_contentsp); if code ^= 0 then do; call dmpr_report_$error_output (code, myname, "Unable to determine length of previous contents file"); goto update_prev; end; prev_contentsp -> backup_volume_contents.rec1_len = CHARS_PER_PAGE * current_length; prev_contentsp -> backup_volume_contents.rec2_type = null_type; prev_contentsp -> backup_volume_contents.rec2_len = 0; prev_contentsp -> backup_volume_contents.time_dumped = substr (bit (fixed (clock, 52), 52), 1, 36); retry = "1"b; do while (retry); call iox_$put_chars (dmpr_data_.outputvol_iocbp, prev_contentsp, prev_contentsp -> backup_volume_contents.rec1_len, code); call check_output_error; end; update_prev: dmpr_data_.prev_volname = dmpr_data_.volname; if dmpr_data_.bvlp ^= null then do; if ^write_volume_log then call dmpr_log_$open_volume_log (code); if code ^= 0 then call dmpr_report_$error_output (code, myname, "Unable to open ^a.volog", dmpr_data_.pvname); end; dmpr_data_.not_reported = "1"b; dmpr_data_.dump_volume_seg_num = 0; dmpr_data_.dump_volume_seg_rec = 0; dmpr_data_.dump_volume_dir_num = 0; dmpr_data_.dump_volume_dir_rec = 0; end attach; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ detach: proc; /* This proc closes out the use of a dump volume. It does this by closing the account segment and terminating the account and contents segment. It then closes and detachs the dump volume. */ if dmpr_data_.accounting then do; call dmpr_log_$close_account_file (code); if code ^= 0 then call dmpr_report_$error_output (code, myname, "Unable to close account seg"); end; call setbc_term (dmpr_data_.contentsp); call setbc_term (dmpr_data_.pvlp); call iox_$close (dmpr_data_.outputvol_iocbp, code); if code ^= 0 then call dmpr_report_$error_output (code, myname, "Unable to close dump volume ^a", dmpr_data_.volname); call iox_$detach_iocb (dmpr_data_.outputvol_iocbp, code); if code ^= 0 then call dmpr_report_$error_output (code, myname, "Unable to detach dump volume ^a", dmpr_data_.volname); ; dmpr_data_.outputvol_iocbp = null; /* be sure */ call dmpr_report_$online_output (0, myname, "Finished ^a: ^d ^d ^d ^d", dmpr_data_.volname, dmpr_data_.dump_volume_dir_rec, dmpr_data_.dump_volume_dir_num, dmpr_data_.dump_volume_seg_rec, dmpr_data_.dump_volume_seg_num); dmpr_data_.not_reported = "0"b; if ^write_volume_log then call dmpr_log_$close_volume_log (code); if code ^= 0 then call dmpr_report_$error_output (code, myname, "Unable to close ^a.volog", dmpr_data_.volname); dmpr_data_.dump_volume_seg_num = 0; dmpr_data_.dump_volume_seg_rec = 0; dmpr_data_.dump_volume_dir_num = 0; dmpr_data_.dump_volume_dir_rec = 0; end detach; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ check_output_error: proc; /* This proc checks the error code retrurned from a write operation. If no error then it returns to its caller. If the dump volume is used up(end of reel/no more room) it closes the volume log, resets the counters associated with the dump volume and detachs the dump volume. It then atttaches a new dump volume, opens the same volume log, but for a new dump volume, and requests the caller to retry the write operation. For any other kind of error it is reported but the action is the same */ new_tape, retry = "0"b; if code = 0 then return; continue_error_check: /* if segfault err return to caller - data pointer is no good */ if code = error_table_$segfault then goto non_local_return; if ^(code = error_table_$device_end | code = error_table_$end_of_info) then do; if code = error_table_$fatal_error then /* Special case too many recoverable errors for *proper* message*/ call dmpr_report_$error_output (0, myname, "The threshold for recoverable write errors (^d) has been reached. Output to volume ^a will be terminated to minimize possible problems in later attempts to read it.", max_error_count, dmpr_data_.volname); else call dmpr_report_$error_output (code, myname, "Error on output volume ^a", dmpr_data_.volname); end; call detach; call attach; if code ^= 0 then goto non_local_return; if ^write_volume_log then call dmpr_log_$update_pvolog (code); if code ^= 0 then do; call dmpr_report_$error_output (code, myname, "Unable to update ^a.pvolog", dmpr_data_.volname); goto non_local_return; end; new_tape = "1"b; retry = "1"b; return; end check_output_error; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ get_seg_current_length: proc (segp); /* This proc calculates the length of the segment specified by segptr and returns the value in a global variable */ dcl segp ptr; call hcs_$fs_get_path_name (segp, dirname, ldn, ename, code); if code ^= 0 then do; call dmpr_report_$error_output (code, myname, "Unable to convert ptr to path-name"); return; end; call hcs_$status_long (dirname, ename, 1, addr (local_status_branch), null, code); if code ^= 0 then do; call dmpr_report_$error_output (code, myname, "Unable to get current length of ^a>^a", dirname, ename); return; end; current_length = local_status_branch.current_length; end get_seg_current_length; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ page_by_page_write: proc; /* This proc is use to write out a data object which has whole pages of zeros intermixed with non-zero pages. This is done to reduce the output load. To do this the file map contained in the vtoce is scanned and only non-null pages are written. If we switch to a new volume then we start from the beginning again. */ do pagex = 0 to fixed (backup_volume_record.csl, 9) - 1; if ^substr (backup_volume_record.fm (pagex), 1, 1) then do; pagep = ptr (datap, pagex * WORDS_PER_PAGE); retry = "1"b; do while (retry); call iox_$put_chars (dmpr_data_.outputvol_iocbp, pagep, fixed (CHARS_PER_PAGE, 21), code); call check_output_error; if new_tape then goto start_io; end; end; end; return; end page_by_page_write; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ set_volid: proc (a_volname, a_volid, code); dcl a_volname char (*); dcl a_volid bit (36); dcl code fixed bin (35); /* This proc constructs a volume id from a volume name. This is a interim measure until all dump volume are registered and have a unique id. This construction restricts the volume name to two or less non numeric characters followed by any numeric value lest then 262144. */ /* when rcp_ interface is defined call rcp_$volname_info (volname, dmpr_data_.volid, code); if code ^= 0 then call dmpr_report_$error_output (code, myname, "Unable to set volid"); but until then fudge it */ start_numeric = search (a_volname, "0123456789"); if start_numeric > 3 | start_numeric = 0 then do; bad_volid: code = error_table_$bad_volid; return; end; else do; if start_numeric > 1 then volid.char = substr (a_volname, 1, start_numeric - 1); else volid.char = ""; char_num = substr (a_volname, start_numeric, length (a_volname) - start_numeric); num = cv_dec_check_ (char_num, code); if code ^= 0 then goto bad_volid; volid.num = num; end; a_volid = unspec (volid); return; end set_volid; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ get_volname_from_user: proc (a_volname); dcl a_volname char (*); dcl avolname char (32) var; /* query_info is already set up */ query_info.yes_or_no_sw = "0"b; /* except for this */ rq: call command_query_ (addr (query_info), avolname, myname, "Type output volume name:"); if avolname ^= "" then do; a_volname = avolname; query_info.yes_or_no_sw = "1"b; /* back to my "normal" state */ end; else goto rq; end get_volname_from_user; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ last_page_length: proc returns (fixed bin); /* This proc back scans the last page of an object for the first non-zero character and returns the length of the non-zero page in words. The condition handler is established in case we share the segment with an other user who deletes/resets the ACL. */ on seg_fault_error, page_read_error begin; code = error_table_$segfault; goto non_local_return; end; pagep = ptr (datap, (fixed (backup_volume_record.csl, 9) - 1) * WORDS_PER_PAGE); return (divide (length (rtrim (page_of_chars, zero_char)) + 3, CHARS_PER_WORD, 17, 0)); end last_page_length; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ setbc_term: proc (p); /* This proc terminates the specified segment and sets the ptr to it to null */ dcl p ptr; dcl dn char (168); dcl en char (32); dcl ldn fixed bin; call hcs_$fs_get_path_name (p, dn, ldn, en, ignore); call adjust_bit_count_ (dn, en, "0"b, (0), ignore); call hcs_$terminate_seg (p, 0, ignore); p = null; end setbc_term; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ %include dmpr_data_; %include backup_info; %include backup_volume_contents; %include backup_volume_header; %include backup_volume_record; %include vtoce; %include backup_volume_log; %include backup_pvol_info; %include fs_vol_label; %include iox_modes; %include status_structures; %include query_info; %include system_constants; end dmpr_output_;  dmpr_report_.pl1 10/22/84 0946.0r w 10/22/84 0911.5 39798 /* *********************************************************** * * * Copyright, (C) Honeywell Information Systems Inc., 1982 * * * * Copyright (c) 1972 by Massachusetts Institute of * * Technology and Honeywell Information Systems, Inc. * * * *********************************************************** */ dmpr_report_: proc; /* This routine is used by the volume dumper to report and log error and status messages. It is modled after the system routine com_err_. When called for the first time in a volume dumper invocation, it creates, in the working directory, an error file, in which it logs all error and status messages. If requested it also writes error message on the stream error_output. */ dcl code fixed bin (35); dcl a_code fixed bin (35); dcl tstring char (24); dcl uname char (32); dcl caller char (*); dcl message char (*); dcl argp ptr; dcl error_iocbp ptr; dcl ret_string char (256); dcl len fixed bin; dcl error_output bit (1); dcl short char (8) ; dcl long char (100) ; dcl iox_$error_output ptr ext; dcl type_char (3) char (4) int static init ("incr", "cons", "comp") options (constant); dcl myname char (32) static int init ("dmpr_report_") options (constant); dcl date_time_ entry (fixed bin (71), char (*)); dcl cu_$arg_list_ptr entry (ptr); dcl ioa_$general_rs entry (ptr, fixed bin, fixed bin, char (*), fixed bin, bit (1) aligned, bit (1) aligned); dcl ioa_$rsnnl entry options (variable); dcl iox_$attach_ioname entry (char (*), ptr, char (*), fixed bin (35)); dcl iox_$open entry (ptr, fixed bin, bit (36), fixed bin (35)); dcl convert_status_code_ entry (fixed bin (35), char (*), char (*)); dcl ioa_$ioa_switch entry options (variable); dcl dmpr_report_$online_output entry options (variable); dcl null builtin; dcl clock builtin; %include dmpr_data_; %include backup_volume_header; return; /* never should be call here */ error_output: entry (a_code, caller, message); /* If an error file is not attached then fabricate a name with a data/time stamp, attach and open it. If successsful then report via online mechanism. */ if dmprp = null then do; error_output = "0"b; goto common; end; if dmpr_data_.disable_error_report then return; error_output = "1"b; if dmpr_data_.error_iocbp = null then do; call date_time_ (clock (), tstring); uname = "dmpr_err." || type_char (dmpr_data_.dump_type) || "." || substr (tstring, 1, 8)||"."|| substr (tstring, 11, 4); call iox_$attach_ioname ("error_file", error_iocbp, "vfile_ " || uname, code); if code ^= 0 then do; call dmpr_report_$online_output (code, myname, "Unable to attach error file"); return; end; call iox_$open (error_iocbp, 2, ""b, code); if code ^= 0 then do; call dmpr_report_$online_output (code, myname, "Error opening error file"); return; end; dmpr_data_.error_iocbp = error_iocbp; call dmpr_report_$online_output (0, myname, "Error file ^a created", uname); end; common: /* If given a non-zero code convert to a message */ short, long = ""; if a_code ^= 0 then call convert_status_code_ (a_code, short, long); /* pick up arg list ptr */ call cu_$arg_list_ptr (argp); /* convert args to message */ call ioa_$general_rs (argp, 3, 4, ret_string, len, "0"b, "0"b); call date_time_ (clock (), tstring); if error_output then /* write to file if specified */ call write_message (dmpr_data_.error_iocbp, "1"b); /* Write online if requested, if args not initialized yet, or if correct entry */ if dmprp = null then call write_message (iox_$error_output, "0"b); else if (error_output & dmpr_data_.err_online) | ^error_output | ^dmpr_data_.arg_init then call write_message (iox_$error_output, "0"b); return; online_output: entry (a_code, caller, message); error_output = "0"b; goto common; write_message: proc (P_iocbp, P_include_time); dcl (P_iocbp pointer, P_include_time bit (1) aligned) parameter; call ioa_$ioa_switch (P_iocbp, "^[^a^2x^;^s^]^a:^x^a^[:^x^a^;^s^]", P_include_time, substr (tstring, 11, 4), caller, substr (ret_string, 1, len), (a_code ^= 0), long); end write_message; end dmpr_report_;  dmpr_unlock_pv.pl1 11/15/82 1911.3rew 11/15/82 1529.5 21483 /* *********************************************************** * * * Copyright, (C) Honeywell Information Systems Inc., 1982 * * * * Copyright (c) 1972 by Massachusetts Institute of * * Technology and Honeywell Information Systems, Inc. * * * *********************************************************** */ dmpr_unlock_pv: proc; dcl pvname char (32); dcl pvid bit (36); dcl lvname char (32); dcl lvid bit (36); dcl argp ptr; dcl argl fixed bin; dcl device_type fixed bin; dcl dtype fixed bin; dcl arg char (argl) based (argp); dcl code fixed bin (35); dcl narg fixed bin; dcl myname char (32) int static init ("dmpr_unlock_pv") options (constant); dcl linkage_error condition; dcl error_table_$badopt fixed bin (35) ext; dcl cu_$arg_count entry (fixed bin); dcl cu_$arg_ptr entry (fixed bin, ptr, fixed bin, fixed bin (35)); dcl com_err_ entry options (variable); dcl ioa_ entry options (variable); dcl mdc_$pvname_info entry (char (*), bit (36), char (*), bit (36), fixed bin, fixed bin (35)); dcl hc_backup_$dmpr_unlock_pv entry (bit (36), fixed bin, fixed bin (35)); %include backup_static_variables; code = 0; call cu_$arg_count (narg); if narg ^= 2 then do; call com_err_ (0, myname, "Usage: dmpr_unlock_pv pvname dump_type"); return; end; call cu_$arg_ptr (1, argp, argl, code); if code ^= 0 then goto err;; pvname = arg; call mdc_$pvname_info (pvname, pvid, lvname, lvid, device_type, code); if code ^= 0 then do; call com_err_ (code, myname, "^a", pvname); return; end; call cu_$arg_ptr (2, argp, argl, code); if code ^= 0 then goto err; if arg = "-incr" | arg = "-incremental" then dtype = incr; else if arg = "-cons" | arg = "-consolidated" then dtype = cons; else if arg = "-comp" | arg = "-complete" then dtype = comp; else do; call com_err_ (error_table_$badopt, myname, "^a", arg); return; end; on linkage_error begin; call ioa_ ("Incorrect access to privilidged gate hc_backup_"); goto finish; end; call hc_backup_$dmpr_unlock_pv (pvid, dtype, code); if code ^= 0 then goto err; finish: return; err: call com_err_ (code, myname); goto finish; end dmpr_unlock_pv;  dump_volume_.pl1 10/10/89 1422.4r w 10/10/89 1359.7 173898 /****^ *********************************************************** * * * Copyright, (C) Honeywell Bull Inc., 1988 * * * * Copyright, (C) Honeywell Information Systems Inc., 1982 * * * * Copyright (c) 1972 by Massachusetts Institute of * * Technology and Honeywell Information Systems, Inc. * * * *********************************************************** */ /* format: style1,ind2,^inddcls,ifthenstmt,dclind2,declareind2,ifthendo,ifthen*/ dump_volume_: proc (code); /* This routine dumps a single physical volume in the dump mode specified. It also updates the appropriate volume log, a per physical volume log of all the output volumes that contain relevent information about that physical volume.In addition it maintains statistics about what is dumped from each physical volume. The incremental and consolidated volume dumping is driven by a ring 0 bit map of which vtoces to dump. The complete volume dump is driven by either a constructed bit map or a vtoce by vtoce scan, depending on which will use less resources. The volume log is written out befor and after the physical volume is dumped, so that the most recent copy is on an output volume should the online copy be lost. */ /* Modified: 10/22/81 by GA Texada to change page_read_error to page_fault_error. Modified: 11/16/81 by GAT to close and write the current volume log if aborting a dump. Modified: 12/17/81 by GAT to recognize when an attachment of a volume fails and abort the dump. Modified: 11/10/82 by GAT (PBF for MR10.1) to actually indicate that the dump should be aborted ny Operator request. Modified: 11/17/82 by GAT to query when a pv is found locked under 'special' circumstances. Modified: August 1983 by GA Texada to call dmpr_output_$new_pass_attach if necessary. */ /****^ HISTORY COMMENTS: 1) change(86-03-04,Fawcett), approve(86-04-10,MCR7383), audit(86-06-03,GWMay), install(86-07-18,MR12.0-1098): Support for subvolume devices real 512_word_io. 2) change(88-04-13,GWMay), approve(88-04-13,MCR7855), audit(88-04-14,Farley), install(88-04-19,MR12.2-1039): Changed to diagnose vtoce connection failures and continue dumping. 3) change(88-05-27,GWMay), approve(88-05-27,MCR7883), audit(88-06-14,Beattie), install(88-07-19,MR12.2-1061): Added init for first pass flag in dmpr_data. END HISTORY COMMENTS */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ code = 0; /* set return values */ loop_cnt = 0; /* init */ /* First we will set the number of vtoce in a page dependent on device_type */ if dmpr_data_.version <= dmpr_data_version_2 then n_vtoce_per_page = 5; /* old style can not be for a sub volume device */ else n_vtoce_per_page = vtoc_per_rec (dmpr_data_.disk_type); recordp = dmpr_data_.recordp; dmpr_data_.num_null_vtoce, dmpr_data_.num_vtoce_only, dmpr_data_.physical_volume_dir_num, dmpr_data_.physical_volume_dir_rec, dmpr_data_.physical_volume_seg_num, dmpr_data_.physical_volume_seg_rec = 0; /* reset counters */ /* get ptr to volume log */ call dmpr_log_$init_volume_log (code); if code ^= 0 then do; call dmpr_report_$error_output (code, myname, "Volume log init failure of ^a.volog ", dmpr_data_.pvname); return; end; bvlp = dmpr_data_.bvlp; /* Interlock physical volume against dumper operating in same mode, ie: two incremental dumpers. Setup cleanup handler in case we abort. Also pickup newest copy of label record of physical volume and some other descriptive info about the state of the pack. The label record will be use by the volume reloader to check if the initialized pack it is given can handle the information to be reloaded. */ on cleanup call unlock_pv; try_again: call hc_backup_$dmpr_lock_pv (dmpr_data_.pvid, dmpr_data_.dump_type, addr (backup_volume_log.info), code); if code ^= 0 then do; if dmpr_data_.restart_pvname = dmpr_data_.pvname then do; /* only do this IF we are restarting */ call command_query_$yes_no (ansb, 0, myname, "The physical volume ^a was found locked. This could have been caused by a previous system interruption. A ""yes"" answer will attempt to forcibly unlock it. A ""no"" answer will not.", "Volume ^a is locked, do you wish to unlock it?", dmpr_data_.pvname); if ansb then do; call unlock_pv (); if ec = 0 then goto try_again; end; end; bust_anyway: call dmpr_report_$error_output (code, myname, "Unable to lock disk volume ^a", dmpr_data_.pvname); return; end; /* pickup local copies */ n_vtoce = backup_volume_log.n_vtoce; n_free_vtoce = backup_volume_log.n_free_vtoce; /* For each dump volume we maintain a log of which physical volume are on it. This allows us to control the use of volumes and to not overwrite a volume which has useful infomation on it. This call updates that log. */ /* If we need to, get an output volume. */ if dmpr_data_.detach & dmpr_data_.outputvol_iocbp = null () then do; call dmpr_output_$new_pass_attach (code); if code ^= 0 then do; call unlock_pv; return; end; end; /* write physical volume log to dump volume */ call dmpr_output_$write_volume_log (code); if code ^= 0 then do; call dmpr_report_$error_output (code, myname, "Unable to write ^a.volog", dmpr_data_.pvname); call unlock_pv; return; end; /* Add dump volume to physical volume log */ call dmpr_log_$open_volume_log (code); if code ^= 0 then do; call dmpr_report_$error_output (code, myname, "Unable to open ^a.volog", dmpr_data_.pvname); call unlock_pv; return; end; call dmpr_log_$update_pvolog (code); if code ^= 0 then do; call dmpr_report_$error_output (code, myname, "Unable to update ^a.pvolog", dmpr_data_.volname); call unlock_pv; return; end; /* If this is a complete dump, then there are two ways to do it, either by reading each vtoce or by building a bit map of all in-use vtoces. The difference comes because to build the map we can read 5 vtoce in each page at one time by suitable use of an abs seg. Thus we compute which is the better method(uses the least resources) and do the right thing. If we build the bit map, in our ring, we operate in "request" mode. */ request = "0"b; if (dmpr_data_.dump_type = comp) & (n_free_vtoce * vtoce_read_time > n_vtoce * divide (page_read_time, n_vtoce_per_page, 17, 0)) then do; request = "1"b; vbmp = addr (vtoc_bit_map); unspec (vtoc_bit_map) = "0"b; n_windows = divide (n_vtoce, max_pages_per_segment * n_vtoce_per_page, 17, 0) + 1; on page_fault_error begin; code = error_table_$device_parity; call dmpr_report_$error_output (0, myname, "Page read error building volume bit map for disk ^a", dmpr_data_.pvname); goto map_err; end; do i = 0 to n_windows - 1; call hc_backup_$dmpr_build_vtoc_map (vbmp, i, code); if code ^= 0 then do; map_err: call dmpr_report_$error_output (code, myname, "Unable to construct bit map for disk ^a", dmpr_data_.pvname); call unlock_pv; return; end; end; revert page_fault_error; end; /* Initialize the input structure to the ring 0 volume dumper */ inputp = dmpr_data_.inputp; dmpr_input.request_vtocx = -1; dmpr_input.request = request; dmpr_input.pvid = dmpr_data_.pvid; /* changes each invocation */ dmpr_input.start_time = clock (); /* This is the main dump loop. We repeatedly call the ring 0 dumper to provide us with a pointer to the next object to be dumped until there are no more. Segments and directories are handled differently in that a directory must be consistent when dumped and thus are copied, while locked, into a temporyary segment. Segments, on the other hand are accessed through a ring 0 abs seg, we thus must be able to handle a seg fault error. Should one occur we call the ring 0 dumper and ask for a pointer to the segment again. We will repeat this up to 10 times and then give up. The final case is that of a vtoce which does not have an associated object. We dump this "null" vtoce as a place holder so that the volume reloader will not recover an earlier object with the same vtocx index. */ backup_volume_record.vtocx = -1; /* set to beginning */ dmpr_input.Sfirst_pass_for_pv = "1"b; do while (loop_cnt <= n_vtoce); /* put a limit on it */ seg_fault_retry_cnt = 0; in_use_retry_cnt = 0; vtocx_retry_cnt = 0; dmpr_input.retry = "0"b; if request then dmpr_input.request_vtocx = get_next_vtocx_ (); dmpr_input.prev_vtocx = backup_volume_record.vtocx; dmpr_input.volid = dmpr_data_.volid; on page_fault_error begin; call dmpr_report_$error_output (error_table_$device_parity, myname, "Skipping vtoce ^o on disk ^a", backup_volume_record.vtocx, dmpr_data_.pvname); goto end_loop; end; /* get pointer to object */ retry: call hc_backup_$get_dmpr_data_object (dmpr_data_.inputp, recordp, code); if code ^= 0 then do; if code = error_table_$dmpr_in_use then do; /* object in use by other dumper so sleep */ in_use_retry_cnt = in_use_retry_cnt + 1; if in_use_retry_cnt > 10 then do; call dmpr_report_$error_output (0, myname, "Skipping vtoce ^o on disk ^a because in-use too long", backup_volume_record.vtocx, dmpr_data_.pvname); goto end_loop; end; call timer_manager_$sleep (5, "11"b); goto retry; end; /* if request could not be done */ else if (request & code = error_table_$action_not_performed) then do; code = 0; goto end_loop; end; else if code = error_table_$end_of_info then do; code = 0; /* completed sucessfully */ goto exit; end; else if code = error_table_$invalid_vtoce then do; backup_volume_record.uid = "0"b; end; else if code = error_table_$vtoce_connection_fail then do; /* Directory damage is reported and this vtoce is not dumped until a system maintainer repairs the damage. */ call dmpr_report_$error_output (0, myname, "Skipping vtoce ^o on disk volume ^a because it has the same UID as another vtoce. See the syserr log for more detailed information.", backup_volume_record.vtocx, dmpr_data_.pvname); go to end_loop; end; else do; /* error condition */ if vtocx_retry_cnt < 10 then do; call dmpr_report_$error_output (code, myname, " vtoce after ^o on disk ^a, retrying dump.", dmpr_input.prev_vtocx, dmpr_data_.pvname); vtocx_retry_cnt = vtocx_retry_cnt + 1; goto retry; end; else do; call dmpr_report_$error_output (code, myname, "Volume dump of ^a aborted.", dmpr_data_.pvname); goto exit; /* got to clean up what I have already dumped. */ end; end; end; /* type of object determines pointer */ if (backup_volume_record.uid = "0"b | dmpr_input.no_object) then datap = null (); else if backup_volume_record.dirsw then datap = dmpr_data_.dirp; else datap = dmpr_data_.segp; /* write out vtoce and possibly object */ call dmpr_output_$output_object (datap, code); if code ^= 0 then do; /* if -1, the attach/open failed, so abort */ if code = -1 then do; /* which actually says that the operatore requested abort*/ call dmpr_report_$error_output (0, myname, "Dump aborted by operator request."); call unlock_pv; return; end; /* retry dump up to 10 times */ if code = error_table_$segfault then do; dmpr_input.retry = "1"b; seg_fault_retry_cnt = seg_fault_retry_cnt + 1; if seg_fault_retry_cnt > 10 then do; call dmpr_report_$error_output (code, myname, "Retry of vtocx ^o on disk ^a failed", backup_volume_record.vtocx, dmpr_data_.pvname); dmpr_input.retry = "0"b; seg_fault_retry_cnt = 0; goto end_loop; end; dmpr_data_.retrys = dmpr_data_.retrys + 1; goto retry; end; call dmpr_report_$error_output (code, myname, "Unable to write object"); end; /* Update counters */ if backup_volume_record.uid = "0"b | dmpr_input.no_object then do; if backup_volume_record.uid = "0"b then dmpr_data_.num_null_vtoce = dmpr_data_.num_null_vtoce + 1; else dmpr_data_.num_vtoce_only = dmpr_data_.num_vtoce_only + 1; end; /* Record the uid of the object dumped in the contents seg. This will save the retriever having to mount and serach an output volume, rather it can search the online contents segment. In addition record in the accounting data base the uid pathname of the object dumped. Dumping uses system resources and users should be billed for this service. Finally update some counters about what is being dumped. */ else do; call dmpr_log_$log_object (code); if code ^= 0 then call dmpr_report_$error_output (code, myname, "Error logging object"); if backup_volume_record.dirsw then do; dmpr_data_.physical_volume_dir_num = dmpr_data_.physical_volume_dir_num + 1; dmpr_data_.physical_volume_dir_rec = dmpr_data_.physical_volume_dir_rec + fixed (backup_volume_record.records, 9); dmpr_data_.vol_log_dir_num = dmpr_data_.vol_log_dir_num + 1; dmpr_data_.vol_log_dir_rec = dmpr_data_.vol_log_dir_rec + fixed (backup_volume_record.records, 9); dmpr_data_.dump_volume_dir_num = dmpr_data_.dump_volume_dir_num + 1; dmpr_data_.dump_volume_dir_rec = dmpr_data_.dump_volume_dir_rec + fixed (backup_volume_record.records, 9); end; else do; dmpr_data_.physical_volume_seg_num = dmpr_data_.physical_volume_seg_num + 1; dmpr_data_.physical_volume_seg_rec = dmpr_data_.physical_volume_seg_rec + fixed (backup_volume_record.records, 9); dmpr_data_.vol_log_seg_num = dmpr_data_.vol_log_seg_num + 1; dmpr_data_.vol_log_seg_rec = dmpr_data_.vol_log_seg_rec + fixed (backup_volume_record.records, 9); dmpr_data_.dump_volume_seg_num = dmpr_data_.dump_volume_seg_num + 1; dmpr_data_.dump_volume_seg_rec = dmpr_data_.dump_volume_seg_rec + fixed (backup_volume_record.records, 9); end; end; end_loop: /* keep track of how many times in loop */ loop_cnt = loop_cnt + 1; end; exit: revert page_fault_error; /* error exit - can't dump more then the number of vtoce on the physical volume */ if loop_cnt > n_vtoce then call dmpr_report_$error_output (0, myname, "Bit map error - please salvage disk ^a", dmpr_data_.pvname); /* Unlock physical volume, close volume log and write updated copy to dump volume */ call unlock_pv; call dmpr_log_$close_volume_log (code); if code ^= 0 then call dmpr_report_$error_output (code, myname, "Unable to close ^a.volog", dmpr_data_.pvname); call dmpr_output_$write_volume_log (code); if code ^= 0 then call dmpr_report_$error_output (code, myname, "Unable to write ^a.volog", dmpr_data_.pvname); return; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ %page; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ get_next_vtocx_: proc returns (fixed bin); /* This proc finds the next vtoce to dump from the complete volume dump bit map, described above, and retruns the vtocx index of it. */ do idx = dmpr_input.request_vtocx + 1 to n_vtoce - 1 while (vtoc_bit_map (idx) = "0"b); end; vtoc_bit_map (idx) = "0"b; return (idx); end get_next_vtocx_; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ unlock_pv: proc; if dmprp = null then return; call hc_backup_$dmpr_unlock_pv (dmpr_data_.pvid, dmpr_data_.dump_type, ec); if ec ^= 0 then call dmpr_report_$error_output (ec, myname, "Unable to unlock disk ^a", dmpr_data_.pvname); end unlock_pv; %page; dcl ansb bit (1); dcl loop_cnt fixed bin; dcl seg_fault_retry_cnt fixed bin; dcl vtocx_retry_cnt fixed bin; dcl in_use_retry_cnt fixed bin; dcl code fixed bin (35); dcl ec fixed bin (35); dcl idx fixed bin; dcl n_vtoce fixed bin; dcl n_free_vtoce fixed bin; dcl datap ptr; dcl i fixed bin; dcl vbmp ptr; dcl request bit (1); dcl vtoc_bit_map (0:36720 - 1) bit (1) unaligned; dcl n_windows fixed bin; dcl n_vtoce_per_page fixed bin; dcl myname char (32) int static init ("dump_volume_") options (constant); dcl vtoce_read_time fixed bin int static init (25) options (constant); dcl page_read_time fixed bin int static init (40) options (constant); dcl max_pages_per_segment fixed bin int static init (255) options (constant); dcl error_table_$invalid_vtoce ext fixed bin (35); dcl error_table_$dmpr_in_use ext fixed bin (35); dcl error_table_$device_parity ext fixed bin (35); dcl error_table_$action_not_performed ext fixed bin (35); dcl error_table_$segfault ext fixed bin (35); dcl error_table_$end_of_info ext fixed bin (35); dcl error_table_$vtoce_connection_fail fixed bin (35) ext static; dcl command_query_$yes_no entry () options (variable); dcl timer_manager_$sleep entry (fixed bin (71), bit (2)); dcl dmpr_report_$error_output entry options (variable); dcl dmpr_output_$new_pass_attach entry (fixed bin (35)); dcl dmpr_output_$write_volume_log entry (fixed bin (35)); dcl dmpr_output_$output_object entry (ptr, fixed bin (35)); dcl dmpr_log_$update_pvolog entry (fixed bin (35)); dcl dmpr_log_$log_object entry (fixed bin (35)); dcl dmpr_log_$init_volume_log entry (fixed bin (35)); dcl dmpr_log_$open_volume_log entry (fixed bin (35)); dcl dmpr_log_$close_volume_log entry (fixed bin (35)); dcl hc_backup_$dmpr_lock_pv entry (bit (36) aligned, fixed bin, ptr, fixed bin (35)); dcl hc_backup_$dmpr_unlock_pv entry (bit (36) aligned, fixed bin, fixed bin (35)); dcl hc_backup_$dmpr_build_vtoc_map entry (ptr, fixed bin, fixed bin (35)); dcl hc_backup_$get_dmpr_data_object entry (ptr, ptr, fixed bin (35)); dcl cleanup condition; dcl page_fault_error condition; dcl addr builtin; dcl clock builtin; dcl divide builtin; dcl fixed builtin; dcl null builtin; dcl unspec builtin; %page; %include dmpr_data_; %page; %include backup_volume_header; %include dmpr_input; %page; %include backup_volume_record; %include backup_static_variables; %page; %include vtoce; %page; %include backup_volume_log; %include backup_pvol_info; %page; %include fs_vol_label; %page; %include fs_dev_types; end dump_volume_;  dumper.pl1 07/20/88 1308.4r w 07/19/88 1535.6 340416 /* *********************************************************** * * * Copyright, (C) Honeywell Information Systems Inc., 1982 * * * * Copyright (c) 1972 by Massachusetts Institute of * * Technology and Honeywell Information Systems, Inc. * * * *********************************************************** */ /****^ HISTORY COMMENTS: 1) change(81-12-16,Texada), approve(), audit(), install(): fix phx12050 and phx12187 2) change(82-08-01,Texada), approve(), audit(), install(): for phx12187, phx13713, phx13662 3) change(82-11-12,Texada), approve(), audit(), install(): to implement phx13262 4) change(82-11-16,Texada), approve(), audit(), install(): to implement phx14088, allow preattachment of dump volumes to an existing incremental dump. 5) change(83-01-26,Texada), approve(), audit(), install(): to support version 2 dmpr_data_ and fix a problem when volumes were attached but not opened then crash. 6) change(83-03-01,Kittlitz), approve(), audit(), install(): for 256K segments. 7) change(83-04-05,Texada), approve(), audit(), install(): add trace entries. 8) change(83-08-18,Texada), approve(), audit(), install(): redefine -detach/-no_detach. 9) change(84-02-01,Texada), approve(), audit(), install(): support version 3 dmpr_data_. 10) change(84-03-05,Texada), approve(), audit(), install(): add set_volume_wakeup_interval. 11) change(85-11-05,GWMay), approve(85-12-02,MCR7310), audit(85-12-05,Dupuis), install(85-12-16,MR12.0-1001): modified the routine set_volume_wakeup_interval to allow a wakeup interval up to 1440 minutes, this was raised from 480. To accomodate the size of the interval when converted to microseconds, the variable my_interval was increased in size. END HISTORY COMMENTS */ /* format: style1,ind2,^inddcls,ifthenstmt,dclind2,declareind2,ifthendo,ifthen*/ dumper: proc; /* This proc provides the command interface for the volume dumper subsystem. It initializes the static data base and other external data bases, attaches to, opens and parses the dump control file converting the control file into an ordered array of physical volume names and ids. It then successivly dumps this array , volume by volume. */ dcl Area area based (areap); dcl tp (4) ptr; dcl dump_control_name char (32); dcl was_asleep bit (1); /* if incr dump, is saved value of dmpr_data_.dmpr_asleep, else is "0"b*/ dcl (YES, dmpr_data_already_locked, new_control_seg, trace) bit (1); dcl mname char (21); dcl (cycle_uid, ignored_lvid) bit (36); dcl answer char (3) var; dcl (ac, argl, narg, nelemt, idx, num_pv, first_pvx, nvols, tnpv) fixed bin; dcl control_seg_name char (32); dcl (areap, argp) ptr; dcl line char (120) aligned; dcl tlvname char (32) aligned; dcl lvname (100) char (32); dcl pvname (100) char (32); dcl time_string char (24); dcl pvid (100) bit (36); dcl device_type (100) fixed bin; dcl (old_time, time_pass_started) fixed bin (71); /* Time this pass started. */ dcl (code, ignore) fixed bin (35); /* Error code. */ dcl 1 query_info aligned, 2 version fixed bin init (2), 2 yes bit (1) init ("1"b), 2 name bit (1) init ("0"b), 2 code fixed bin (35) init (0), 2 pad fixed bin; dcl 1 pva (100) aligned, 2 pvname char (32), 2 device_type fixed bin, 2 pvid bit (36); dcl type_char (3) char (4) int static init ("incr", "cons", "comp") options (constant); dcl force_write_bits bit (36) init ((36)"0"b) int static options (constant); /* write pages in parallel */ dcl lock_wait_time fixed bin static init (60) options (constant); dcl arg char (argl) based (argp); dcl iox_$user_io ptr external; dcl error_table_$action_not_performed fixed bin (35) ext static; dcl error_table_$end_of_info ext fixed bin (35); dcl error_table_$invalid_lock_reset ext fixed bin (35); dcl error_table_$inconsistent fixed bin (35) ext static; dcl error_table_$bad_arg ext fixed bin (35); dcl error_table_$bad_conversion fixed bin (35) ext static; dcl error_table_$wrong_no_of_args fixed bin (35) ext static; dcl command_query_$yes_no entry () options (variable); dcl cv_dec_check_ entry (char (*), fixed bin (35)) returns (fixed bin (35)); dcl get_system_free_area_ entry () returns (ptr); dcl suffixed_name_$make entry (char (*), char (*), char (*), fixed bin (35)); dcl hcs_$force_write entry (ptr, bit (36), fixed bin (35)); dcl hcs_$set_256K_switch entry (bit (2) aligned, bit (2) aligned, fixed bin (35)); dcl hcs_$status_minf entry (char (*), char (*), fixed bin, fixed bin, fixed bin, fixed bin (35)); dcl manage_volume_pool_$set_pool_path entry (entry options (variable), char (*), ptr, fixed bin (35)); dcl com_err_ entry options (variable); dcl command_query_ entry options (variable); dcl set_lock_$lock entry (bit (36) aligned, fixed bin, fixed bin (35)); dcl ipc_$mask_ev_calls entry (fixed bin (35)); dcl ipc_$unmask_ev_calls entry (fixed bin (35)); dcl ioa_$rsnnl entry options (variable); dcl cu_$arg_count entry (fixed bin); dcl cu_$arg_ptr entry (fixed bin, ptr, fixed bin, fixed bin (35)); dcl hcs_$make_seg entry (char (*), char (*), char (*), fixed bin (5), ptr, fixed bin (35)); dcl get_wdir_ entry returns (char (168) aligned); dcl mdc_$check_mounted entry (char (*) aligned, fixed bin (35)); dcl add_epilogue_handler_ entry (entry, fixed bin (35)); dcl iox_$control entry (ptr, char (*), ptr, fixed bin (35)); dcl purge_volume_log_ entry (char (*) aligned, char (*) aligned, fixed bin, bit (1), fixed bin (35)); dcl hc_backup_$init_dmpr entry (ptr, ptr, fixed bin (35)); dcl dmpr_output_$init entry (fixed bin (35)); dcl dmpr_output_$end_pass_detach entry (fixed bin (35)); dcl dmpr_output_$preattach_vols entry (fixed bin, fixed bin, fixed bin (35)); dcl dmpr_output_$preattach_ioname entry (fixed bin, fixed bin, fixed bin (35)); dcl get_temp_segments_ entry (char (*), (*) ptr, fixed bin (35)); dcl dump_volume_ entry (fixed bin (35)); dcl dmpr_info_ entry (fixed bin (35)); dcl dmpr_arg_reader_ entry (ptr, fixed bin (35)); dcl dmpr_finish_ entry (fixed bin (35)); dcl timer_manager_$alarm_wakeup entry (fixed bin (71), bit (2), fixed bin (71)); dcl timer_manager_$get_schedule entry (ptr, ptr, fixed bin (35)); dcl timer_manager_$reset_alarm_wakeup entry (fixed bin (71)); dcl mdc_$lvname_info entry (char (*) aligned, ptr, fixed bin, fixed bin (35)); dcl mdc_$pvname_info entry (char (*), bit (36), char (*), bit (36), fixed bin, fixed bin (35)); dcl date_time_ entry (fixed bin (71), char (*)); dcl cu_$arg_list_ptr entry (ptr); /* Arg list location */ dcl iox_$attach_ioname entry (char (*), ptr, char (*), fixed bin (35)); dcl iox_$position entry (ptr, fixed bin, fixed bin, fixed bin (35)); dcl iox_$open entry (ptr, fixed bin, bit (36), fixed bin (35)); dcl iox_$get_line entry (ptr, ptr, fixed bin, fixed bin, fixed bin (35)); dcl ipc_$create_ev_chn entry (fixed bin (71), fixed bin (35)); dcl ipc_$decl_ev_call_chn entry (fixed bin (71), entry, ptr, fixed bin, fixed bin (35)); dcl (dmpr_report_$error_output, dmpr_report_$online_output) entry options (variable); dcl (cleanup, finish) condition; dcl (after, before, bit, rtrim, addr, clock, fixed, hbound, length, null, substr, verify) builtin; incremental_volume_dump: entry; call init (incr, "incremental_volume_dumper"); go to start; /* Go get arguments. */ consolidated_volume_dump: entry; call init (cons, "consolidated_volume_dump"); go to start; /* Go get arguments. */ complete_volume_dump: entry; /* Entry to do complete volume dump */ call init (comp, "complete_volume_dump"); start: dmpr_data_.old_256K_switch = ""b; call add_epilogue_handler_ (end_volume_dump, code); if code ^= 0 then call dmpr_report_$error_output (code, dmpr_data_.myname, "Unable to set epilogue handler"); on cleanup call dmpr_finish_ (ignore); on finish call dmpr_finish_ (ignore); call cu_$arg_list_ptr (argp); /* get arg list ptr */ call dmpr_arg_reader_ (argp, code); /* Get any other arguments */ if code ^= 0 then goto finale; call hcs_$set_256K_switch ("11"b, dmpr_data_.old_256K_switch, code); if code ^= 0 then do; call dmpr_report_$error_output (code, dmpr_data_.myname, "Could not enable 256KW segments."); goto finale; end; dmpr_data_.arg_init = "1"b; if (dmpr_data_.dump_type = incr) & (dmpr_data_.detach) & (dmpr_data_.pre_attach_vol ^= 0) then do; call dmpr_report_$error_output (error_table_$inconsistent, dmpr_data_.myname, "The -detach and -preattach control arguments are mutually exclusive"); goto finale; end; if dmpr_data_.control_name = "" | dmpr_data_.operator = "" then do; code = error_table_$bad_arg; /* Must have dump control file and operator */ call dmpr_report_$error_output (code, dmpr_data_.myname, "Missing control file or operator name"); goto finale; end; if dmpr_data_.auto_vol then do; call manage_volume_pool_$set_pool_path (dmpr_report_$error_output, rtrim (dmpr_data_.sys_dir) || ">Volume_Dumper", dmpr_data_.vpp, code); /* set the pool path to the standard one */ if code ^= 0 then do; call dmpr_report_$online_output (code, dmpr_data_.myname, "Unable to locate volume pool"); goto finale; end; end; /* setup temp segs */ call get_temp_segments_ ("dumper", tp, code); if code ^= 0 then do; call dmpr_report_$error_output (code, dmpr_data_.myname, "Temp seg init failure"); goto finale; end; /* initialize static ptrs */ dmpr_data_.dirp = tp (1); dmpr_data_.inputp = tp (2); dmpr_data_.recordp = tp (3); dmpr_data_.infop = tp (4); /* initialize info seg - per dump info */ call dmpr_info_ (code); if code ^= 0 then do; call dmpr_report_$error_output (code, dmpr_data_.myname, "Error initing info seg "); goto finale; end; /* attach and open control file */ call iox_$attach_ioname ("dump_control", dmpr_data_.control_iocbp, "vfile_ " || dmpr_data_.control_name, code); if code ^= 0 then do; call dmpr_report_$error_output (code, dmpr_data_.myname, "Unable to attach to ^a", dmpr_data_.control_name); goto finale; end; call iox_$open (dmpr_data_.control_iocbp, 1, "0"b, code); if code ^= 0 then do; /* Was an error encountered? */ call dmpr_report_$error_output (code, dmpr_data_.myname, "Open error on ^a", dmpr_data_.control_name); goto finale; /* Quit. */ end; if dmpr_data_.dump_type = incr then do; /* Is this an incremental volume dump? */ call ipc_$create_ev_chn (dmpr_data_.incr_ev_chn, code); /* Create an event channel. */ if code ^= 0 then do; call dmpr_report_$error_output (code, dmpr_data_.myname, "Error creating event channel"); goto finale; end; /* Make channel into call channel. */ call ipc_$decl_ev_call_chn (dmpr_data_.incr_ev_chn, restart_volume_dump, null, 1, code); if code ^= 0 then do; /* OK? */ call dmpr_report_$error_output (code, dmpr_data_.myname, "Error make event call channel"); goto finale; /* Give up. */ end; end; /* initialize ring 0 part of dumper */ call hc_backup_$init_dmpr (dmpr_data_.dirp, dmpr_data_.segp, code); if code ^= 0 then do; call dmpr_report_$error_output (code, dmpr_data_.myname, "Ring 0 dmpr init failure"); goto finale; end; call dmpr_output_$init (code); if code ^= 0 then do; if code ^= -1 then /* this code says that an attach/open failed */ call dmpr_report_$error_output (code, dmpr_data_.myname, "Output volume init failure"); goto finale; end; /* init input structure to ring 0 */ inputp = dmpr_data_.inputp; dmpr_input.version = dmpr_input_version_1; dmpr_input.type = dmpr_data_.dump_type; dmpr_input.reset = dmpr_data_.reset; dmpr_input.no_update = dmpr_data_.no_update; dmpr_input.no_object = dmpr_data_.no_object; dmpr_input.mod_after_time = dmpr_data_.mod_after_time; dmpr_data_.dump_in_progress = "1"b; /* Set flag to prevent recursion. */ go to over; /* Start dump pass. */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ wakeup_volume_dump: entry; /* Enter here on operator wakeup. */ if dmprp = null then do; no_dump: call com_err_ (0, "wakeup_volume_dump", "No dump to wakeup"); return; end; dmpr_data_.myname = "wakeup_volume_dump"; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ restart_volume_dump: entry; /* Enter here on alarm wakeup */ if dmprp = null then do; call com_err_ (0, "restart_volume_dump", "no dump to restart"); return; end; if dmpr_data_.dump_in_progress then do; /* Is a dump pass being done now? */ call dmpr_report_$online_output (0, dmpr_data_.myname, "Dump pass presently in progress; this call ignored."); return; end; call timer_manager_$reset_alarm_wakeup (dmpr_data_.incr_ev_chn); dmpr_data_.dump_in_progress = "1"b; /* Set flag. */ dmpr_data_.dmpr_asleep = "0"b; new_control_seg = "0"b; dmpr_data_already_locked = "0"b; call dmpr_report_$online_output (0, dmpr_data_.myname, "Dumper waking up at ^a", time_now_ ()); over: time_pass_started = clock; /* position to front of control file */ call iox_$position (dmpr_data_.control_iocbp, -1, 0, code); if code ^= 0 then do; /* OK? */ call dmpr_report_$error_output (code, dmpr_data_.myname, "Error positioning on ^a", dmpr_data_.control_name); goto finale; /* Give up. */ end; /* initialize local variables */ num_pv = 0; lvname (*) = ""; pvname (*) = ""; pvid (*) = "0"b; device_type (*) = 0; /* This loop converts each line of the control file into a set(possibly one) of physical volume names and ids and stores the entire result in a local array of 100 entries. This is a limit on the number of online physical volumes that can be dumped by any one volume dumper. */ read_line: line = ""; call iox_$get_line (dmpr_data_.control_iocbp, addr (line), length (line), nelemt, code); if code ^= 0 then do; if code = error_table_$end_of_info then goto begin_vol_dump; else do; call dmpr_report_$error_output (code, dmpr_data_.myname, "error reading ^a", dmpr_data_.control_name); goto finale; /* Give up. */ end; end; line = substr (line, 1, nelemt - 1); /* strip off new line at end */ if before (line, ",") = "lv" then do; tlvname = after (line, ","); call mdc_$lvname_info (tlvname, addr (pva), tnpv, code); if code ^= 0 then do; call dmpr_report_$error_output (code, dmpr_data_.myname, "Unable to convert ^a to physical volumes", tlvname); goto read_line; end; do idx = 1 to tnpv; lvname (num_pv + idx) = tlvname; pvname (num_pv + idx) = pva (idx).pvname; pvid (num_pv + idx) = pva (idx).pvid; device_type (num_pv + idx) = pva (idx).device_type; end; num_pv = num_pv + tnpv; end; else if before (line, ",") = "pv" then do; num_pv = num_pv + 1; pvname (num_pv) = after (line, ","); call mdc_$pvname_info (pvname (num_pv), pvid (num_pv), lvname (num_pv), ignored_lvid, device_type (num_pv), code); if code ^= 0 then do; call dmpr_report_$error_output (code, dmpr_data_.myname, "Unable to convert ^a to pvid", pvname (num_pv)); num_pv = num_pv - 1; goto read_line; end; end; else call dmpr_report_$error_output (0, dmpr_data_.myname, "Unrecognized line ^a", line); goto read_line; /* This loop dumps each volid specified in the just constructed array. If we are in restart mode, then we skip over all volumes until a match is found and start from there. If not we start with the first volume in the list. In either case we process(dumped) each volume in turn reporting when we start and when we end and what we did. */ begin_vol_dump: inputp = dmpr_data_.inputp; first_pvx = 1; if dmpr_data_.restart_pvname = "" /* no restart specified */ & ^new_control_seg & ^was_asleep & (dmpr_data_already_locked | (dmpr_data_.pvname ^= pvname (num_pv))) then do; if dmpr_data_already_locked then do; dmpr_data_.restart_pvname = dmpr_data_.pvname; call dmpr_report_$online_output (0, dmpr_data_.myname, "Restarting with physical volume ^a.", dmpr_data_.restart_pvname); end; else if dmpr_data_.dump_type ^= incr then do; /* it must be cons or comp */ call command_query_ (addr (query_info), answer, dmpr_data_.myname, "^/^a", "Previous dump cycle may not have completed. Do you want to restart ? "); if answer = "yes" then dmpr_data_.restart_pvname = dmpr_data_.pvname; end; end; if dmpr_data_.restart_pvname ^= "" then do; if dmpr_data_.dump_type = incr then dmpr_data_.cycle_uid = substr (bit (clock, 72), 20, 36); do idx = 1 to num_pv while (pvname (idx) ^= dmpr_data_.restart_pvname); end; if idx > num_pv then do; call dmpr_report_$error_output (0, dmpr_data_.myname, "No match of restart pvname ^a in control seg", dmpr_data_.restart_pvname); goto finale; end; first_pvx = idx; end; else dmpr_data_.cycle_uid = substr (bit (clock, 72), 20, 36); do idx = first_pvx to num_pv; dmpr_data_.pvid = pvid (idx); dmpr_data_.lvname = lvname (idx); dmpr_data_.pvname = pvname (idx); call mdc_$check_mounted (dmpr_data_.lvname, code); if code ^= 0 then do; call dmpr_report_$online_output (code, dmpr_data_.myname, "Skipping logical volume ^a", dmpr_data_.lvname); do while (lvname (idx) = dmpr_data_.lvname); idx = idx + 1; end; idx = idx - 1; end; else do; dmpr_data_.disk_type = device_type (idx); /* set for the volume log */ call hcs_$force_write (dmprp, force_write_bits, ignore); /* save changed dmpr_data_ */ if (dmpr_data_.dump_type = cons) | (dmpr_data_.dump_type = comp) then call dmpr_report_$online_output (0, dmpr_data_.myname, "Begin dump of physical volume ^a", dmpr_data_.pvname); call dump_volume_ (code); if code = 0 then do; call dmpr_report_$online_output (0, dmpr_data_.myname, "Processed ^a: ^d ^d ^d ^d ^d", dmpr_data_.pvname, dmpr_data_.physical_volume_dir_rec, dmpr_data_.physical_volume_dir_num, dmpr_data_.physical_volume_seg_rec, dmpr_data_.physical_volume_seg_num, dmpr_data_.num_null_vtoce); if dmpr_input.no_object then call dmpr_report_$online_output (0, dmpr_data_.myname, "Dumped ^d non null vtoces and ^d null vtoces", dmpr_data_.num_vtoce_only, dmpr_data_.num_null_vtoce); /* If this is a complete dump or the purge flag is on, then purge the volume log. This will release those dump volumes that have been superseeded by this dump */ if (dmpr_data_.dump_type = cons & dmpr_data_.incr_skip_count ^= -1) | dmpr_data_.dump_type = comp then do; call purge_volume_log_ (dmpr_data_.sys_dir, dmpr_data_.pvname, dmpr_data_.incr_skip_count, dmpr_data_.manual_free & dmpr_data_.auto_vol, code); if code ^= 0 then call dmpr_report_$error_output (code, dmpr_data_.myname, "Unable to purge volume log ^a", dmpr_data_.pvname); end; end; else if code = -1 then goto finale; /* Operator abort */ else do; call dmpr_report_$error_output (code, dmpr_data_.myname, "Error dumping volume ^a", dmpr_data_.pvname); end; end; end; dmpr_data_.restart_pvname = ""; /* only do it once */ call dmpr_report_$online_output (0, dmpr_data_.myname, "Dump finished at ^a", time_now_ ()); /* If an incremental dump then setup alarm clock for wakeup */ if dmpr_data_.dump_type = incr then do; call iox_$control (dmpr_data_.outputvol_iocbp, "error_count", addr (ignore), ignore); if dmpr_data_.detach then call dmpr_output_$end_pass_detach (ignore); /* detach if we are supposed too. */ call timer_manager_$alarm_wakeup (time_pass_started + dmpr_data_.wakeup_interval, "00"b, dmpr_data_.incr_ev_chn); call dmpr_report_$online_output (0, dmpr_data_.myname, "Dumper going to sleep"); call iox_$control (iox_$user_io, "start", null, code); if code ^= 0 then /* OK? */ call dmpr_report_$error_output (code, dmpr_data_.myname, "iox_$control on user_i/o"); dmpr_data_.dump_in_progress = ""b; /* Indicate dump no longer active. */ dmpr_data_.dmpr_asleep = "1"b; dmpr_data_.myname = "incremental_volume_dumper"; /* could have been invoked as wakeup_volume_dumper*/ call hcs_$force_write (dmprp, force_write_bits, ignore); /* TRY and get it written now */ return; /* all done for this pass */ end; goto finale; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ end_volume_dump: entry; /* Finish up dumping. */ if dmprp = null then do; /* tell him there is no dump */ call com_err_ (0, "end_volume_dump", "No dump to end."); return; end; dmpr_data_.myname = "end_volume_dump"; dmpr_data_.dump_in_progress = "1"b; /* let dmpr_finish_ turn it off */ dmpr_data_.disable_error_report = "1"b; dmpr_data_.detach = "1"b; /* detach output volume when finished */ finale: call dmpr_finish_ (ignore); finale_nocleanup: return; /* terminate processing */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ preattach_dump_volumes: entry; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* */ /* Allow a running incremental dump to add volumes (just like the -preattach control */ /* argument), without having to do an end_volume_dump and starting over. */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ dcl announce_vols (nvols) char (32) based (addr (dmpr_data_.pre_attach_volname (dmpr_data_.pre_attach_vol + 1))); call ipc_$mask_ev_calls (code); /* mask so we can do our work */ if code ^= 0 then do; call com_err_ (code, "preattach_dump_volumes", "Unable to mask event calls, no preattachment performed."); return; end; if dmprp = null then do; /* no funny stuff... */ call com_err_ (0, "preattach_dump_volumes", "No dump in progress, use the ""-preattach"" control argument to the incremental_volume_dump command."); goto UNMASK_EV; end; if dmpr_data_.dump_type ^= incr then do; call com_err_ (0, "preattach_dump_volumes", "This command is only valid for incremental volume dumps."); goto UNMASK_EV; end; call cu_$arg_count (narg); if narg ^= 1 then do; call com_err_ (error_table_$wrong_no_of_args, "preattach_dump_volumes", "Usage is: preattach_dump_volumes no_of_volumes"); goto UNMASK_EV; end; if dmpr_data_.detach then do; /* ok, let's ask him if we should turn off this */ call command_query_$yes_no (YES, 0, "preattach_dump_volumes", "In the invocation of the incremental_volume_dump command, -detach was specified. This is used to detach volumes after each pass of the dumper. A ""yes"" answer will turn this feature ""off"". A ""no"" answer will abort the preattachment of these volumes.", "Do you wish to turn off the effect of the -detach control argument (type ""?"" for an explaination)."); if YES then dmpr_data_.detach = ""b; else goto UNMASK_EV; end; call cu_$arg_ptr (1, argp, argl, code); if verify (arg, "0123456789") = 0 then do; /* only numbers fellas */ nvols = fixed (arg, 17, 0); /* now, be sure we don't have too many */ if nvols = 0 then do; call com_err_ (0, "preattach_dump_volumes", "The number of volumes must be greater than zero."); goto UNMASK_EV; end; if ((dmpr_data_.pre_attach_vol + nvols) > hbound (dmpr_data_.pre_attach_volname, 1) | (hbound (dmpr_data_.pre_attach_volname, 1) - (nvols + dmpr_data_.pre_attach_vol) < 0)) then do; call com_err_ (error_table_$action_not_performed, "preattach_dump_volumes", "Too many volumes to preattach. Space available for ^d more.", (hbound (dmpr_data_.pre_attach_volname, 1) - dmpr_data_.pre_attach_vol)); goto UNMASK_EV; end; end; else do; call com_err_ (error_table_$bad_conversion, "preattach_dump_volumes", "^a", arg); goto UNMASK_EV; end; on cleanup begin; code = 0; do while (code = 0); call ipc_$unmask_ev_calls (code); end; end; call dmpr_output_$preattach_vols (nvols, (dmpr_data_.pre_attach_vol + nvols) - (nvols - 1), code); /* get the volume names from the user or the pool */ if code ^= 0 then goto UNMASK_EV; call dmpr_report_$online_output (0, "preattach_dump_volumes", "Please get the following volume^[s^]: ^v(^a ^)", /* announce which volumes to get */ (nvols > 1), nvols, announce_vols (*)); call dmpr_output_$preattach_ioname (nvols, (dmpr_data_.pre_attach_vol + nvols) - (nvols - 1), code); /* do the attach */ if code = 0 then dmpr_data_.pre_attach_vol = dmpr_data_.pre_attach_vol + nvols; UNMASK_EV: code = 0; do while (code = 0); call ipc_$unmask_ev_calls (code); end; return; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ set_volume_wakeup_interval: entry; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* */ /* This entry allows the changing of the wakeup interval for a running incremental dump. */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ dcl i fixed bin (35), my_interval fixed bin (71); call ipc_$mask_ev_calls (code); if code ^= 0 then do; call com_err_ (code, "set_volume_wakeup_interval", "Unable to mask event calls, interval not changed."); return; end; areap, schedule_ptr = null (); areap = get_system_free_area_ (); on cleanup begin; if schedule_ptr ^= null () then free schedule in (Area); code = 0; do while (code = 0); call ipc_$unmask_ev_calls (code); end; end; if dmprp = null then do; call com_err_ (0, "set_volume_wakeup_interval", "No dump in progress."); goto UNMASK_EV; end; if dmpr_data_.dump_type ^= incr then do; call com_err_ (0, "set_volume_wakeup_interval", "This command is valid only for incremental volume dumps."); goto UNMASK_EV; end; call cu_$arg_count (narg); if narg ^= 1 then do; call com_err_ (error_table_$wrong_no_of_args, "set_volume_wakeup_interval", "Usage is: set_volume_wakeup_interval no_of_minutes"); goto UNMASK_EV; end; call cu_$arg_ptr (1, argp, argl, code); if code ^= 0 then do; call com_err_ (code, "set_volume_wakeup_interval"); goto UNMASK_EV; end; my_interval = cv_dec_check_ (arg, code); if code ^= 0 then do; badint: call com_err_ (0, "set_volume_wakeup_interval", "The interval must be in minutes (1 to 1440)."); goto UNMASK_EV; end; if (my_interval < 1) | (my_interval > 1440) then goto badint; /* make sure it's in the range */ my_interval = my_interval * 60000000; /* make it microseconds */ call timer_manager_$get_schedule (areap, schedule_ptr, code); if code ^= 0 then do; call com_err_ (code, "set_volume_wakeup_interval", "Getting the event schedule."); goto UNMASK_EV; end; do i = 1 to schedule.n_timers; /* now, find the right event channel */ if schedule.timer (i).channel = dmpr_data_.incr_ev_chn then do; /* here it is */ old_time = (schedule.timer (i).time - dmpr_data_.wakeup_interval); /* this was the *base* time for the wakeup */ call timer_manager_$reset_alarm_wakeup (dmpr_data_.incr_ev_chn); /* reset the *old* one */ dmpr_data_.wakeup_interval = my_interval; /* set the new one */ call timer_manager_$alarm_wakeup (old_time + dmpr_data_.wakeup_interval, "00"b, dmpr_data_.incr_ev_chn); /* and set the new wakeup */ call hcs_$force_write (dmprp, force_write_bits, ignore); /* and get it written */ free schedule in (Area); /* be clean */ goto UNMASK_EV; /* let 'er rip */ end; end; call com_err_ (0, "set_volume_wakeup_interval", "Unable to find the interval timer, no action performed."); free schedule in (Area); goto UNMASK_EV; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ volume_dump_trace_on: entry; trace = "1"b; /* turn on tracing... */ mname = "volume_dump_trace_on"; goto trace_join; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ volume_dump_trace_off: entry (); mname = "volume_dump_trace_off"; trace = "0"b; trace_join: if dmprp = null () then /* no dump to trace yet... */ call com_err_ (0, mname, "No dump in progress."); else do; call cu_$arg_count (narg); if narg > 0 then call com_err_ (error_table_$wrong_no_of_args, mname, "This command accepts no arguments."); else if dmpr_data_.trace = trace then call com_err_ (error_table_$action_not_performed, mname, "Tracing is already in the state requested, ^[on^;^off^]", trace); else dmpr_data_.trace = trace; end; return; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ init: proc (type, myname); dcl type fixed bin; dcl myname char (*); dcl (volname, pvname, prev_volname) char (32); dcl (dir_rec, dir_num, seg_num, seg_rec) fixed bin; /* This proc initializes the dumper's external static data base */ call cu_$arg_count (narg); if narg < 2 then do; call dmpr_report_$error_output (error_table_$bad_arg, myname, "Required control args not specified"); goto finale; end; if dmprp ^= null () then do; call com_err_ (0, myname, "Recursive invocations of the dumper are not allowed.^[^/Use end_volume_dump first.^]", type = incr); goto finale_nocleanup; end; do ac = 1 to narg; call cu_$arg_ptr (ac, argp, argl, code); if arg = "-control" then do; call cu_$arg_ptr (ac + 1, argp, argl, code); if code ^= 0 then do; call dmpr_report_$error_output (code, myname, "No control segment specified after -control."); goto finale; end; call suffixed_name_$make (arg, "dump", dump_control_name, code); if code ^= 0 then do; call dmpr_report_$online_output (code, myname, "Unable to create dump control seg name from ^a", arg); goto finale; end; call hcs_$status_minf (get_wdir_ (), dump_control_name, 0, (0), (0), code); if code ^= 0 then do; call dmpr_report_$online_output (code, myname, "Unable to locate ^a>^a", get_wdir_ (), dump_control_name); goto finale; end; call ioa_$rsnnl ("^a.^a.^a", control_seg_name, (0), arg, type_char (type), "control"); call hcs_$make_seg (get_wdir_ (), control_seg_name, "", 01010b, dmprp, code); if code = 0 then do; /* new control seg */ new_control: call dmpr_report_$online_output (0, myname, "^/Creating new control seg ^a>^a", get_wdir_ (), control_seg_name); new_control_seg = "1"b; dmpr_data_.version = dmpr_data_version_2; prev_volname, volname, pvname = ""; cycle_uid = substr (bit (clock, 72), 20, 36); dir_rec, dir_num, seg_rec, seg_num = 0; call lock_dmpr_data; end; else if dmprp ^= null then do; /* already existed */ new_control_seg = "0"b; if dmpr_data_.version ^= dmpr_data_version_3 then do; if dmpr_data_.version = dmpr_data_version_2 then do; dmpr_data_.version = dmpr_data_version_3; dmpr_data_.disk_type = 0; /* totally invisible */ end; else do; call dmpr_report_$online_output (0, myname, "Invalid control seg found"); goto new_control; end; end; call lock_dmpr_data; if (dmpr_data_.not_reported & dmpr_data_.cur_vol_open) then /* do only if the volume was opened. */ call dmpr_report_$online_output (0, myname, "Finished volume ^a: ^d ^d ^d ^d", dmpr_data_.volname, dmpr_data_.dump_volume_dir_rec, dmpr_data_.dump_volume_dir_num, dmpr_data_.dump_volume_seg_rec, dmpr_data_.dump_volume_seg_num); cycle_uid = dmpr_data_.cycle_uid; if dmpr_data_.cur_vol_open then do; /* if it was opened successfully */ volname = dmpr_data_.volname; prev_volname = dmpr_data_.volname; end; else do; /* nope, use the previous one */ volname = dmpr_data_.prev_volname; prev_volname = dmpr_data_.prev_volname; end; pvname = dmpr_data_.pvname; dir_rec = dmpr_data_.physical_volume_dir_rec; dir_num = dmpr_data_.physical_volume_dir_num; seg_rec = dmpr_data_.physical_volume_seg_rec; seg_num = dmpr_data_.physical_volume_seg_num; end; else do; /* couldn't create it, so punt */ call dmpr_report_$online_output (code, myname, "Unable to initialize control seg"); goto finale; end; end; end; if dmprp = null then do; call dmpr_report_$online_output (0, myname, "Control seg initialization failed - control seg not specified."); goto finale; end; dmpr_data_.ptrs = null; if type = incr then was_asleep = dmpr_data_.dmpr_asleep; else was_asleep = "0"b; /* save or set for restart processing */ dmpr_data_.bits = "0"b; dmpr_data_.fixed_bin = 0; dmpr_data_.disk_type = 0; dmpr_data_.chars = ""; if type = incr then dmpr_data_.detach = "0"b; /* default for incrs */ else dmpr_data_.detach = "1"b; dmpr_data_.cycle_uid = cycle_uid; dmpr_data_.wakeup_interval = 3600000000; /* Default, one hour (in micro seconds) */ dmpr_data_.data_init = "1"b; dmpr_data_.incr_skip_count = -1; dmpr_data_.pre_attach_vol = 0; dmpr_data_.dump_type = type; dmpr_data_.sys_dir = ">daemon_dir_dir>volume_backup"; dmpr_data_.myname = myname; dmpr_data_.pvname = pvname; dmpr_data_.volname = volname; dmpr_data_.prev_volname = prev_volname; dmpr_data_.physical_volume_dir_rec = dir_rec; dmpr_data_.physical_volume_dir_num = dir_num; dmpr_data_.physical_volume_seg_rec = seg_rec; dmpr_data_.physical_volume_seg_num = seg_num; code = 0; end init; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ time_now_: proc returns (char (6)); /* This proc returns a time string suitable for printing of the present time */ call date_time_ (clock, time_string); return (substr (time_string, 11, 6)); end time_now_; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ lock_dmpr_data: proc; call set_lock_$lock (dmpr_data_.lock, lock_wait_time, code); if code ^= 0 then do; if code = error_table_$invalid_lock_reset then do; code = 0; dmpr_data_already_locked = "1"b; end; else do; if dmpr_data_.dump_in_progress then do; call dmpr_report_$online_output (0, dmpr_data_.myname, "Dump pass presently in progress; this call ignored"); goto finale_nocleanup; end; else if dmpr_data_.dmpr_asleep then do; call dmpr_report_$online_output (0, dmpr_data_.myname, "Dumper asleep. Use wakeup_volume_dump"); goto finale_nocleanup; end; else do; call dmpr_report_$online_output (code, dmpr_data_.myname, "Dumper invoked recursively. Use end_volume_dump"); goto finale_nocleanup; end; end; end; else dmpr_data_already_locked = "0"b; end lock_dmpr_data; %include dmpr_data_; %include dmpr_input; %include backup_static_variables; %include backup_volume_header; %include timer_manager_schedule; end dumper; bull_copyright_notice.txt 08/30/05 1008.4r 08/30/05 1007.3 00020025 ----------------------------------------------------------- Historical Background This edition of the Multics software materials and documentation is provided and donated to Massachusetts Institute of Technology by Group Bull including Bull HN Information Systems Inc. as a contribution to computer science knowledge. This donation is made also to give evidence of the common contributions of Massachusetts Institute of Technology, Bell Laboratories, General Electric, Honeywell Information Systems Inc., Honeywell Bull Inc., Groupe Bull and Bull HN Information Systems Inc. to the development of this operating system. Multics development was initiated by Massachusetts Institute of Technology Project MAC (1963-1970), renamed the MIT Laboratory for Computer Science and Artificial Intelligence in the mid 1970s, under the leadership of Professor Fernando Jose Corbato.Users consider that Multics provided the best software architecture for managing computer hardware properly and for executing programs. Many subsequent operating systems incorporated Multics principles. Multics was distributed in 1975 to 2000 by Group Bull in Europe , and in the U.S. by Bull HN Information Systems Inc., as successor in interest by change in name only to Honeywell Bull Inc. and Honeywell Information Systems Inc. . ----------------------------------------------------------- Permission to use, copy, modify, and distribute these programs and their documentation for any purpose and without fee is hereby granted,provided that the below copyright notice and historical background appear in all copies and that both the copyright notice and historical background and this permission notice appear in supporting documentation, and that the names of MIT, HIS, Bull or Bull HN not be used in advertising or publicity pertaining to distribution of the programs without specific prior written permission. Copyright 1972 by Massachusetts Institute of Technology and Honeywell Information Systems Inc. Copyright 2006 by Bull HN Information Systems Inc. Copyright 2006 by Bull SAS All Rights Reserved