void mu_signal_process(char *command, int signal) { boolean_t pid_present, name_present; int4 pid, length, status, item, outv; char prc_nam[20]; unsigned short name_len; $DESCRIPTOR(d_prc_nam,""); memset(prc_nam, 0, SIZEOF(prc_nam)); pid_present = name_present = FALSE; if (cli_present("id") == CLI_PRESENT) { if(!cli_get_hex("id", &pid)) return; pid_present = TRUE; } if (cli_present("name") == CLI_PRESENT) { name_len = 20; if (!cli_get_str("name", prc_nam, &name_len)) return; if (prc_nam[name_len-1] == '"') name_len--; if (prc_nam[0] == '"') { d_prc_nam.dsc$a_pointer = &prc_nam[1]; name_len--; } else d_prc_nam.dsc$a_pointer = &prc_nam; d_prc_nam.dsc$w_length = name_len; name_present = TRUE; } if (!name_present) { if (SS$_NORMAL == send_signal(pid, signal)) SENDMSG_OUTPUT("", pid); return; } item = JPI$_PID; status = lib$getjpi(&item, 0, &d_prc_nam, &outv, 0, 0); if (SS$_NORMAL != status) { rts_error(VARLSTCNT(1) status); return; } if (!pid_present) { if (SS$_NORMAL == send_signal(outv, signal)) SENDMSG_OUTPUT(&prc_nam, outv); return; } if (outv != pid) { util_out_print("ID !XL and NAME !AD are not the same process", FLUSH, pid, LEN_AND_STR(&prc_nam)); return; } if (SS$_NORMAL == send_signal(pid, signal)) SENDMSG_OUTPUT(&prc_nam, pid); return; }
/* This function will process I/O if -OUTPUT suboption is present. This will create the file and duplicate it as stderr. So anything written to stderr will be written to this file. */ bool open_fileio(int *save_stderr) { char ofnamebuf[1024]; mstr ofname; int status=FALSE, fd; unsigned short len; char *errmsg; #ifdef __MVS__ int realfiletag, fstatus; struct stat info; /* Need the ERR_BADTAG and ERR_TEXT error_defs for the TAG_POLICY macro warning */ error_def(ERR_TEXT); error_def(ERR_BADTAG); #endif *save_stderr = SYS_STDERR; ofname.addr=ofnamebuf; ofname.len=SIZEOF(ofnamebuf); if (cli_present("OUTPUT") == CLI_PRESENT) { len = ofname.len; if (cli_get_str("OUTPUT", ofname.addr, &len)) { int dup2_res; ZOS_ONLY(STAT_FILE(ofname.addr, &info, fstatus);)
void mupip_rctldump(void) { # ifdef AUTORELINK_SUPPORTED unsigned short max_len; mstr dir; char objdir[GTM_PATH_MAX]; open_relinkctl_sgm *linkctl; DCL_THREADGBL_ACCESS; SETUP_THREADGBL_ACCESS; if (TREF(parms_cnt)) { assert(1 == TREF(parms_cnt)); max_len = SIZEOF(objdir); if (!cli_get_str("DIRECTORY", objdir, &max_len)) rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_MUPCLIERR); dir.addr = objdir; dir.len = max_len; linkctl = relinkctl_attach(&dir); assert(linkctl == TREF(open_relinkctl_list)); assert((NULL == linkctl) || (NULL == linkctl->next)); } else zro_init(); util_out_print("", RESET); /* Reset output buffer */ zshow_rctldump(NULL); /* callee knows caller is mupip_rctldump type based on the NULL parameter */ # endif /* AUTORELINK_SUPPORTED */ }
void murgetlst(void) { char *c1, *c2, buff[MAX_LINE]; unsigned short len; inc_list_struct *ptr; error_def(ERR_MUNODBNAME); len = SIZEOF(buff); if (!cli_get_str(name,buff,&len)) mupip_exit(ERR_MUNODBNAME); ptr = &in_files; for (c1 = c2 = buff; ; ) { for ( ; *c2 && (*c2 != ',') ; c2++) ; ptr->next = (inc_list_struct*)malloc(SIZEOF(inc_list_struct)); ptr = ptr->next; ptr->next = 0; ptr->input_file.len = INTCAST(c2 - c1); ptr->input_file.addr = (char *)malloc(c2 - c1 + 1); memcpy(ptr->input_file.addr, c1, c2 - c1); *(char*)(ptr->input_file.addr + (c2 - c1)) = '\0'; if (!*c2) break; else c1 = ++c2; } return; }
int dse_data(char *dst, int *len) { unsigned short cli_len; char buf[MAX_LINE],*src,*bot,*top; cli_len = sizeof(buf); if (!cli_get_str("DATA",buf,&cli_len)) return FALSE; bot = dst; top = &buf[cli_len - 1]; src = &buf[0]; #ifdef VMS if (buf[0] == '"') src = &buf[1]; #endif for (; src <= top ;src++) { #ifdef VMS if (src == top && *src == '"') break; #endif if (*src == '\\') { src++; if (*src == '\\') { *dst++ = '\\'; continue; } if (*src >= '0' && *src <= '9') *dst = *src - '0'; else if (*src >= 'a' && *src <= 'f') *dst = *src - 'a' + 10; else if (*src >= 'A' && *src <= 'F') *dst = *src - 'A' +10; else continue; src++; if (*src >= '0' && *src <= '9') *dst = (*dst << 4) + *src - '0'; else if (*src >= 'a' && *src <= 'f') *dst = (*dst << 4) + *src - 'a' + 10; else if (*src >= 'A' && *src <= 'F') *dst = (*dst << 4) + *src - 'A' +10; dst++; } else *dst++ = *src; } *len = dst - bot; return TRUE; }
/* Description: * Edits or displays the contents of a replication instance file. * Parameters: None * Return Value: None */ void repl_inst_edit(void) { unsigned short inst_fn_len; char inst_fn[MAX_FN_LEN + 1], buff_unaligned[REPL_INST_HDR_SIZE + GTMSRC_LCL_SIZE + 8]; char *buff; repl_inst_hdr_ptr_t repl_instance; gtmsrc_lcl_ptr_t gtmsrclcl_ptr; uint4 offset, size; gtm_uint64_t value; boolean_t value_present; error_def(ERR_MUPCLIERR); in_repl_inst_edit = TRUE; inst_fn_len = MAX_FN_LEN; if (!cli_get_str("INSTFILE", inst_fn, &inst_fn_len) || (0 == inst_fn_len)) rts_error(VARLSTCNT(1) ERR_MUPCLIERR); inst_fn[inst_fn_len] = '\0'; buff = &buff_unaligned[0]; buff = (char *)ROUND_UP2((INTPTR_T)buff, 8); if (CLI_PRESENT == cli_present("SHOW")) { print_offset = (CLI_PRESENT == cli_present("DETAIL")); repl_inst_read(inst_fn, (off_t)0, (sm_uc_ptr_t)buff, REPL_INST_HDR_SIZE + GTMSRC_LCL_SIZE); util_out_print("GTM-I-MUREPLSHOW, SHOW output for replication instance file !AD", TRUE, inst_fn_len, inst_fn); repl_instance = (repl_inst_hdr_ptr_t)&buff[0]; section_offset = 0; repl_inst_dump_filehdr(repl_instance); section_offset = REPL_INST_HDR_SIZE; repl_inst_dump_gtmsrclcl((gtmsrc_lcl_ptr_t)&buff[REPL_INST_HDR_SIZE]); section_offset = REPL_INST_TRIPLE_OFFSET; repl_inst_dump_triplehist(inst_fn, repl_instance->num_triples); } if (CLI_PRESENT == cli_present("CHANGE")) { mupcli_get_offset_size_value(&offset, &size, &value, &value_present); assert(size <= REPL_INST_HDR_SIZE + GTMSRC_LCL_SIZE); repl_inst_read(inst_fn, (off_t)offset, (sm_uc_ptr_t)buff, size); mupcli_edit_offset_size_value((sm_uc_ptr_t)buff, offset, size, value, value_present); repl_inst_write(inst_fn, (off_t)offset, (sm_uc_ptr_t)buff, size); } in_repl_inst_edit = FALSE; }
void mupip_crypt(void) { # ifdef GTM_CRYPT unsigned short fname_len; char fname[GTM_PATH_MAX]; int4 len, off; error_def(ERR_MUPCLIERR); fname_len = SIZEOF(fname); if (!cli_get_str("FILE", fname, &fname_len)) mupip_exit(ERR_MUPCLIERR); if (!cli_get_int("OFFSET", &off)) mupip_exit(ERR_MUPCLIERR); if (!cli_get_int("LENGTH", &len)) mupip_exit(ERR_MUPCLIERR); if (CLI_PRESENT == cli_present("DECRYPT")) mupip_exit(mu_decrypt(fname, off, len)); else mupip_exit(ERR_MUPCLIERR); # endif }
void mu_signal_process(char *command, int signal) { unsigned short slen; int len, toprocess_id, save_errno; char buff[256]; error_def(ERR_MUPCLIERR); error_def(ERR_MUPIPSIG); slen = sizeof(buff); if (!cli_get_str("ID", buff, &slen)) mupip_exit(ERR_MUPCLIERR); len = slen; toprocess_id = asc2i((uchar_ptr_t)buff, len); if (toprocess_id < 0) { util_out_print("Error converting !AD to a number", FLUSH, len, buff); mupip_exit(ERR_MUPCLIERR); } else { if (-1 == kill(toprocess_id, signal)) { save_errno = errno; util_out_print("Error issuing !AD to process !UL: !AZ", FLUSH, LEN_AND_STR(command), toprocess_id, STRERROR(errno)); } else { util_out_print("!AD issued to process !UL", FLUSH, LEN_AND_STR(command), toprocess_id); if (!MEMCMP_LIT(command, STOP_STR)) { send_msg(VARLSTCNT(9) ERR_MUPIPSIG, 7, LEN_AND_STR(command), signal, process_id, process_id, toprocess_id, toprocess_id); } } } return; }
bool open_source_file (void) { mstr fstr; int status, n; parse_blk pblk; char *p, buff[MAX_FBUFF + 1]; time_t clock; struct stat statbuf; mval val; mval pars; unsigned short clen; memset(&pblk, 0, SIZEOF(pblk)); pblk.buffer = buff; pblk.buff_size = MAX_FBUFF; pblk.fop = F_SYNTAXO; fstr.addr = (char *)source_file_name; fstr.len = source_name_len; status = parse_file(&fstr, &pblk); if (!(status & 1)) rts_error_csa(CSA_ARG(NULL) VARLSTCNT(5) ERR_FILEPARSE, 2, fstr.len, fstr.addr, status); pars.mvtype = MV_STR; pars.str.len = SIZEOF(open_params_list); pars.str.addr = (char *)open_params_list; val.mvtype = MV_STR; val.str.len = source_name_len; val.str.addr = (char *)source_file_name; op_open(&val, &pars, 0, 0); dev_in_use = io_curr_device; /* save list file info in use if it is opened */ op_use(&val, &pars); compile_src_dev = io_curr_device; if (tt_so_do_once) { clock = time(0); p = "MDEFAULT"; n = STR_LIT_LEN("MDEFAULT"); } else { STAT_FILE((char *)source_file_name, &statbuf, status); assert(status == 0); clock = statbuf.st_mtime; p = pblk.l_name; n = pblk.b_name; if (n > MAX_MIDENT_LEN) n = MAX_MIDENT_LEN; } /* routine_name is the internal name of the routine (with '%' translated to '_') which can be * different from module_name if the NAMEOFRTN parm is used (by trigger compilation code). * module_name is the external file name of the module (file.m, file.o). * int_module_name is the external symbol that gets exposed (in the GTM context) and is normally * the same as module_name except when NAMEOFRTN is specified in which case it takes on the * untranslated value of routine_name. */ memcpy(module_name.addr, p, n); module_name.len = n; if (!(cmd_qlf.qlf & CQ_NAMEOFRTN)) { memcpy(routine_name.addr, p, n); routine_name.len = n; } else { /* Routine name specified */ clen = MAX_MIDENT_LEN; cli_get_str("NAMEOFRTN", routine_name.addr, &clen); routine_name.len = MIN(clen, MAX_MIDENT_LEN); cmd_qlf.qlf &= ~CQ_NAMEOFRTN; /* Can only be used for first module in list */ } memcpy(int_module_name.addr, routine_name.addr, routine_name.len); int_module_name.len = routine_name.len; if ('_' == *routine_name.addr) routine_name.addr[0] = '%'; GTM_CTIME(p, &clock); memcpy(rev_time_buf, p + 4, REV_TIME_BUFF_LEN); io_curr_device = dev_in_use; /* set it back to make open_list_file save the device */ return TRUE; }
int gtmsource_get_opt(void) { char *connect_parm_token_str, *connect_parm; char *connect_parms_str, tmp_connect_parms_str[GTMSOURCE_CONN_PARMS_LEN + 1]; char secondary_sys[MAX_SECONDARY_LEN], *c, inst_name[MAX_FN_LEN + 1]; char statslog_val[SIZEOF("OFF")]; /* "ON" or "OFF" */ char update_val[SIZEOF("DISABLE")]; /* "ENABLE" or "DISABLE" */ char freeze_val[SIZEOF("OFF")]; /* "ON" or "OFF" */ char freeze_comment[SIZEOF(gtmsource_options.freeze_comment)]; int tries, index = 0, timeout_status, connect_parms_index, status, renegotiate_interval; struct hostent *sec_hostentry; unsigned short log_file_len, filter_cmd_len; unsigned short secondary_len, inst_name_len, statslog_val_len, update_val_len, connect_parms_str_len; unsigned short freeze_val_len, freeze_comment_len, tlsid_len; int errcode; int port_len; char *ip_end; mstr log_nam, trans_name; boolean_t secondary, dotted_notation, log, log_interval_specified, connect_parms_badval, plaintext_fallback; memset((char *)>msource_options, 0, SIZEOF(gtmsource_options)); gtmsource_options.start = (CLI_PRESENT == cli_present("START")); gtmsource_options.shut_down = (CLI_PRESENT == cli_present("SHUTDOWN")); gtmsource_options.activate = (CLI_PRESENT == cli_present("ACTIVATE")); gtmsource_options.deactivate = (CLI_PRESENT == cli_present("DEACTIVATE")); gtmsource_options.checkhealth = (CLI_PRESENT == cli_present("CHECKHEALTH")); gtmsource_options.statslog = (CLI_PRESENT == cli_present("STATSLOG")); gtmsource_options.showbacklog = (CLI_PRESENT == cli_present("SHOWBACKLOG")); gtmsource_options.changelog = (CLI_PRESENT == cli_present("CHANGELOG")); gtmsource_options.stopsourcefilter = (CLI_PRESENT == cli_present("STOPSOURCEFILTER")); gtmsource_options.needrestart = (CLI_PRESENT == cli_present("NEEDRESTART")); gtmsource_options.losttncomplete = (CLI_PRESENT == cli_present("LOSTTNCOMPLETE")); gtmsource_options.jnlpool = (CLI_PRESENT == cli_present("JNLPOOL")); secondary = (CLI_PRESENT == cli_present("SECONDARY")); gtmsource_options.rootprimary = ROOTPRIMARY_UNSPECIFIED; /* to indicate unspecified state */ if ((CLI_PRESENT == cli_present("ROOTPRIMARY")) || (CLI_PRESENT == cli_present("UPDOK"))) gtmsource_options.rootprimary = ROOTPRIMARY_SPECIFIED; else if ((CLI_PRESENT == cli_present("PROPAGATEPRIMARY")) || (CLI_PRESENT == cli_present("UPDNOTOK"))) gtmsource_options.rootprimary = PROPAGATEPRIMARY_SPECIFIED; else { /* Neither ROOTPRIMARY (or UPDOK) nor PROPAGATEPRIMARY (or UPDNOTOK) specified. Assume default values. * Assume ROOTPRIMARY for -START -SECONDARY (active source server start) and -ACTIVATE commands. * Assume PROPAGATEPRIMARY for -START -PASSIVE (passive source server start) and -DEACTIVATE commands. */ if ((gtmsource_options.start && secondary) || gtmsource_options.activate) gtmsource_options.rootprimary = ROOTPRIMARY_SPECIFIED; if ((gtmsource_options.start && !secondary) || gtmsource_options.deactivate) gtmsource_options.rootprimary = PROPAGATEPRIMARY_SPECIFIED; } gtmsource_options.instsecondary = (CLI_PRESENT == cli_present("INSTSECONDARY")); if (gtmsource_options.instsecondary) { /* -INSTSECONDARY is specified in the command line. */ inst_name_len = SIZEOF(inst_name);; if (!cli_get_str("INSTSECONDARY", &inst_name[0], &inst_name_len)) { util_out_print("Error parsing INSTSECONDARY qualifier", TRUE); return(-1); } } else { /* Check if environment variable "gtm_repl_instsecondary" is defined. * Do that only if any of the following qualifiers is present as these are the only ones that honour it. * Mandatory : START, ACTIVATE, DEACTIVATE, STOPSOURCEFILTER, CHANGELOG, STATSLOG, NEEDRESTART, * Optional : CHECKHEALTH, SHOWBACKLOG or SHUTDOWN */ if (gtmsource_options.start || gtmsource_options.activate || gtmsource_options.deactivate || gtmsource_options.stopsourcefilter || gtmsource_options.changelog || gtmsource_options.statslog || gtmsource_options.needrestart || gtmsource_options.checkhealth || gtmsource_options.showbacklog || gtmsource_options.shut_down) { log_nam.addr = GTM_REPL_INSTSECONDARY; log_nam.len = SIZEOF(GTM_REPL_INSTSECONDARY) - 1; trans_name.addr = &inst_name[0]; if (SS_NORMAL == (status = TRANS_LOG_NAME(&log_nam, &trans_name, inst_name, SIZEOF(inst_name), do_sendmsg_on_log2long))) { gtmsource_options.instsecondary = TRUE; inst_name_len = trans_name.len; } else if (!gtmsource_options.checkhealth && !gtmsource_options.showbacklog && !gtmsource_options.shut_down) { if (SS_LOG2LONG == status) gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT(5) ERR_LOGTOOLONG, 3, log_nam.len, log_nam.addr, SIZEOF(inst_name) - 1); gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_REPLINSTSECUNDF); return (-1); } } } if (gtmsource_options.instsecondary) { /* Secondary instance name specified either through -INSTSECONDARY or "gtm_repl_instsecondary" */ inst_name[inst_name_len] = '\0'; if ((MAX_INSTNAME_LEN <= inst_name_len) || (0 == inst_name_len)) { gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT(4) ERR_REPLINSTSECLEN, 2, inst_name_len, inst_name); return (-1); } assert((inst_name_len + 1) <= MAX_INSTNAME_LEN); memcpy(gtmsource_options.secondary_instname, inst_name, inst_name_len + 1); /* copy terminating '\0' as well */ } if (gtmsource_options.start || gtmsource_options.activate) { if (secondary) { secondary_len = MAX_SECONDARY_LEN; if (!cli_get_str("SECONDARY", secondary_sys, &secondary_len)) { util_out_print("Error parsing SECONDARY qualifier", TRUE); return(-1); } /* Parse secondary_sys into secondary_host * and secondary_port */ c = secondary_sys; dotted_notation = TRUE; if ('[' == *c) { ip_end = strchr(++c, ']'); if (NULL == ip_end || 0 == (index = ip_end - c)) { util_out_print("Invalid IP address !AD", TRUE, LEN_AND_STR(secondary_sys)); return(-1); } memcpy(gtmsource_options.secondary_host, c, index); gtmsource_options.secondary_host[index] = '\0'; c = ip_end + 1; } else { while(*c && (':' != *c)) gtmsource_options.secondary_host[index++] = *c++; gtmsource_options.secondary_host[index] = '\0'; } if (':' != *c) { util_out_print("Secondary port number should be specified", TRUE); return(-1); } port_len = strlen(++c); errno = 0; if (((0 == (gtmsource_options.secondary_port = ATOI(c))) && (0 != errno)) || (0 >= gtmsource_options.secondary_port)) { util_out_print("Error parsing secondary port number !AD", TRUE, LEN_AND_STR(c)); return(-1); } } if (CLI_PRESENT == cli_present("CONNECTPARAMS")) { connect_parms_str_len = GTMSOURCE_CONN_PARMS_LEN + 1; if (!cli_get_str("CONNECTPARAMS", tmp_connect_parms_str, &connect_parms_str_len)) { util_out_print("Error parsing CONNECTPARAMS qualifier", TRUE); return(-1); } #ifdef VMS /* strip the quotes around the string. (DCL doesn't do it) */ assert('"' == tmp_connect_parms_str[0]); assert('"' == tmp_connect_parms_str[connect_parms_str_len - 1]); connect_parms_str = &tmp_connect_parms_str[1]; tmp_connect_parms_str[connect_parms_str_len - 1] = '\0'; #else connect_parms_str = &tmp_connect_parms_str[0]; #endif for (connect_parms_index = GTMSOURCE_CONN_HARD_TRIES_COUNT, connect_parms_badval = FALSE, connect_parm_token_str = connect_parms_str; !connect_parms_badval && connect_parms_index < GTMSOURCE_CONN_PARMS_COUNT && (connect_parm = strtok(connect_parm_token_str, GTMSOURCE_CONN_PARMS_DELIM)) != NULL; connect_parms_index++, connect_parm_token_str = NULL) { errno = 0; if ((0 == (gtmsource_options.connect_parms[connect_parms_index] = ATOI(connect_parm)) && 0 != errno) || 0 >= gtmsource_options.connect_parms[connect_parms_index]) connect_parms_badval = TRUE; } if (connect_parms_badval) { util_out_print("Error parsing or invalid value parameter in CONNECTPARAMS", TRUE); return(-1); } if (GTMSOURCE_CONN_PARMS_COUNT != connect_parms_index) { util_out_print( "All CONNECTPARAMS - HARD TRIES, HARD TRIES PERIOD, " "SOFT TRIES PERIOD, " "ALERT TIME, HEARTBEAT INTERVAL, " "MAX HEARBEAT WAIT should be specified", TRUE); return(-1); } } else { gtmsource_options.connect_parms[GTMSOURCE_CONN_HARD_TRIES_COUNT] = REPL_CONN_HARD_TRIES_COUNT; gtmsource_options.connect_parms[GTMSOURCE_CONN_HARD_TRIES_PERIOD] = REPL_CONN_HARD_TRIES_PERIOD; gtmsource_options.connect_parms[GTMSOURCE_CONN_SOFT_TRIES_PERIOD] = REPL_CONN_SOFT_TRIES_PERIOD; gtmsource_options.connect_parms[GTMSOURCE_CONN_ALERT_PERIOD] = REPL_CONN_ALERT_ALERT_PERIOD; gtmsource_options.connect_parms[GTMSOURCE_CONN_HEARTBEAT_PERIOD] = REPL_CONN_HEARTBEAT_PERIOD; gtmsource_options.connect_parms[GTMSOURCE_CONN_HEARTBEAT_MAX_WAIT] = REPL_CONN_HEARTBEAT_MAX_WAIT; } if (gtmsource_options.connect_parms[GTMSOURCE_CONN_ALERT_PERIOD]< gtmsource_options.connect_parms[GTMSOURCE_CONN_SOFT_TRIES_PERIOD]) gtmsource_options.connect_parms[GTMSOURCE_CONN_ALERT_PERIOD] = gtmsource_options.connect_parms[GTMSOURCE_CONN_SOFT_TRIES_PERIOD]; if (gtmsource_options.connect_parms[GTMSOURCE_CONN_HEARTBEAT_MAX_WAIT] < gtmsource_options.connect_parms[GTMSOURCE_CONN_HEARTBEAT_PERIOD]) gtmsource_options.connect_parms[GTMSOURCE_CONN_HEARTBEAT_MAX_WAIT] = gtmsource_options.connect_parms[GTMSOURCE_CONN_HEARTBEAT_PERIOD]; } if (gtmsource_options.start || gtmsource_options.statslog || gtmsource_options.changelog || gtmsource_options.activate) { log = (cli_present("LOG") == CLI_PRESENT); log_interval_specified = (CLI_PRESENT == cli_present("LOG_INTERVAL")); if (log) { log_file_len = MAX_FN_LEN + 1; if (!cli_get_str("LOG", gtmsource_options.log_file, &log_file_len)) { util_out_print("Error parsing LOG qualifier", TRUE); return(-1); } } else gtmsource_options.log_file[0] = '\0'; gtmsource_options.src_log_interval = 0; if (log_interval_specified) { if (!cli_get_num("LOG_INTERVAL", (int4 *)>msource_options.src_log_interval)) { util_out_print("Error parsing LOG_INTERVAL qualifier", TRUE); return (-1); } } if (gtmsource_options.start && 0 == gtmsource_options.src_log_interval) gtmsource_options.src_log_interval = LOGTRNUM_INTERVAL; /* For changelog/activate, interval == 0 implies don't change log interval already established */ /* We ignore interval specification for statslog, Vinaya 2005/02/07 */ } if (gtmsource_options.start) { assert(secondary || CLI_PRESENT == cli_present("PASSIVE")); gtmsource_options.mode = ((secondary) ? GTMSOURCE_MODE_ACTIVE : GTMSOURCE_MODE_PASSIVE); if (CLI_PRESENT == cli_present("BUFFSIZE")) { if (!cli_get_int("BUFFSIZE", >msource_options.buffsize)) { util_out_print("Error parsing BUFFSIZE qualifier", TRUE); return(-1); } if (MIN_JNLPOOL_SIZE > gtmsource_options.buffsize) gtmsource_options.buffsize = MIN_JNLPOOL_SIZE; } else gtmsource_options.buffsize = DEFAULT_JNLPOOL_SIZE; /* Round up buffsize to the nearest (~JNL_WRT_END_MASK + 1) multiple */ gtmsource_options.buffsize = ((gtmsource_options.buffsize + ~JNL_WRT_END_MASK) & JNL_WRT_END_MASK); if (CLI_PRESENT == cli_present("FILTER")) { filter_cmd_len = MAX_FILTER_CMD_LEN; if (!cli_get_str("FILTER", gtmsource_options.filter_cmd, &filter_cmd_len)) { util_out_print("Error parsing FILTER qualifier", TRUE); return(-1); } } else gtmsource_options.filter_cmd[0] = '\0'; /* Check if compression level is specified */ if (CLI_PRESENT == cli_present("CMPLVL")) { if (!cli_get_int("CMPLVL", >msource_options.cmplvl)) { util_out_print("Error parsing CMPLVL qualifier", TRUE); return(-1); } if (GTM_CMPLVL_OUT_OF_RANGE(gtmsource_options.cmplvl)) gtmsource_options.cmplvl = ZLIB_CMPLVL_MIN; /* no compression in this case */ /* CMPLVL qualifier should override any value specified in the environment variable gtm_zlib_cmp_level */ gtm_zlib_cmp_level = gtmsource_options.cmplvl; } else gtmsource_options.cmplvl = ZLIB_CMPLVL_MIN; /* no compression in this case */ /* Check if SSL/TLS secure communication is requested. */ # ifdef GTM_TLS if (CLI_PRESENT == cli_present("TLSID")) { tlsid_len = MAX_TLSID_LEN; if (!cli_get_str("TLSID", repl_tls.id, &tlsid_len)) { util_out_print("Error parsing TLSID qualifier", TRUE); return -1; } assert(0 < tlsid_len); if (CLI_PRESENT == cli_present("RENEGOTIATE_INTERVAL")) { if (!cli_get_int("RENEGOTIATE_INTERVAL", &renegotiate_interval)) { util_out_print("Error parsing RENEGOTIATE_INTERVAL qualifier", TRUE); return -1; } if (0 > renegotiate_interval) { util_out_print("Negative values are not allowed for RENEGOTIATE_INTERVAL qualifier", TRUE); return -1; } else if ((0 < renegotiate_interval) && (renegotiate_interval < MIN_RENEGOTIATE_TIMEOUT)) renegotiate_interval = MIN_RENEGOTIATE_TIMEOUT; renegotiate_interval = renegotiate_interval * 60; /* Convert to seconds. */ } else renegotiate_interval = DEFAULT_RENEGOTIATE_TIMEOUT * 60; /* Convert to seconds. */ /* Convert renegotiate_interval to heartbeat units (# of 8 second intervals). */ renegotiate_interval = DIVIDE_ROUND_UP(renegotiate_interval, HEARTBEAT_INTERVAL_IN_SECS); gtmsource_options.renegotiate_interval = renegotiate_interval; /* Check if plaintext-fallback mode is specified. Default option is NOPLAINTEXTFALLBACK. */ if (CLI_PRESENT == (plaintext_fallback = cli_present("PLAINTEXTFALLBACK"))) repl_tls.plaintext_fallback = (plaintext_fallback != CLI_NEGATED); else repl_tls.plaintext_fallback = FALSE; } # endif } if (gtmsource_options.shut_down) { if ((timeout_status = cli_present("TIMEOUT")) == CLI_PRESENT) { if (!cli_get_int("TIMEOUT", >msource_options.shutdown_time)) { util_out_print("Error parsing TIMEOUT qualifier", TRUE); return(-1); } if (DEFAULT_SHUTDOWN_TIMEOUT < gtmsource_options.shutdown_time || 0 > gtmsource_options.shutdown_time) { gtmsource_options.shutdown_time = DEFAULT_SHUTDOWN_TIMEOUT; util_out_print("shutdown TIMEOUT changed to !UL", TRUE, gtmsource_options.shutdown_time); } } else if (CLI_NEGATED == timeout_status) gtmsource_options.shutdown_time = -1; else /* TIMEOUT not specified */ gtmsource_options.shutdown_time = DEFAULT_SHUTDOWN_TIMEOUT; } if (gtmsource_options.statslog) { statslog_val_len = 4; /* max(strlen("ON"), strlen("OFF")) + 1 */ if (!cli_get_str("STATSLOG", statslog_val, &statslog_val_len)) { util_out_print("Error parsing STATSLOG qualifier", TRUE); return(-1); } UNIX_ONLY(cli_strupper(statslog_val);) if (0 == STRCMP(statslog_val, "ON"))
void jobchild_init(void) { unsigned int status; job_params_type jparms; /* Transfer data */ unsigned char *transfer_addr; rhdtyp *base_addr; unsigned short i, arg_len; char run_file_name[FILE_NAME_SIZE + 2], *c; gcall_args job_arglist; mval job_args[MAX_ACTUALS]; error_def (ERR_RUNPARAMERR); static char interactive_mode_buf[] = "INTERACTIVE"; static char other_mode_buf[] = "OTHER"; error_def(ERR_TEXT); ESTABLISH(job_init_ch); /* * Check if environment variable ppid - job parent pid * exists. If it does not, we are a regular gtm process, * else, we are a child process of a job command. */ if ((c = GETENV(CHILD_FLAG_ENV)) && strlen(c)) { /* * We are a Jobbed process. * Get Job parameters and set up environment * to run the Job command */ /* Clear the environment variable so that subsequent child * mumps processes can start normal initialization. */ if (PUTENV(CLEAR_CHILD_FLAG_ENV)) { util_out_print("Unable to clear gtmj0 process !UL exiting.", TRUE, process_id); rts_error(VARLSTCNT(1) errno); } /* read parameters into parameter structure */ ojchildparms(&jparms, &job_arglist, job_args); /* Execute the command to be run before executing the actual M routine */ if (jparms.startup.len) SYSTEM(jparms.startup.addr); /* Set up job's input, output and error files. Redirect them, if necessary. */ /* It is needed since the middle process would not have always done this(under jobpid == TRUE cases) */ if (!(status = ojchildioset(&jparms))) rts_error(VARLSTCNT(4) ERR_TEXT, 2, LEN_AND_LIT("Failed to set STDIN/OUT/ERR for the job")); job_addr(&jparms.routine, &jparms.label, jparms.offset, (char **)&base_addr, (char **)&transfer_addr); /* Set process priority */ if (jparms.baspri) nice((int) jparms.baspri); /* Set up $ZMODE to "OTHER" */ dollar_zmode.mvtype = MV_STR; dollar_zmode.str.addr = &other_mode_buf[0]; dollar_zmode.str.len = sizeof(other_mode_buf) -1; } else { /* If we are not a child, setup a dummy mumps routine */ if (MUMPS_RUN == invocation_mode) { mstr routine, label; int offset; arg_len = FILE_NAME_SIZE; if (!cli_get_str("INFILE", run_file_name, &arg_len)) rts_error(VARLSTCNT(1) ERR_RUNPARAMERR); lref_parse((uchar_ptr_t)run_file_name, &routine, &label, &offset); job_addr(&routine, &label, offset, (char **)&base_addr, (char **)&transfer_addr); } else if (MUMPS_CALLIN & invocation_mode) /* call-in mode */ { base_addr = make_cimode(); transfer_addr = PTEXT_ADR(base_addr); } else /* direct mode */ { base_addr = make_dmode(); transfer_addr = PTEXT_ADR(base_addr); } job_arglist.callargs = 0; /* Set up $ZMODE to "INTERACTIVE" */ dollar_zmode.mvtype = MV_STR; dollar_zmode.str.addr = &interactive_mode_buf[0]; dollar_zmode.str.len = sizeof(interactive_mode_buf) -1; } gtm_init_env(base_addr, transfer_addr); if (MUMPS_CALLIN & invocation_mode) { SET_CI_ENV(ci_ret_code_exit); } if (job_arglist.callargs) { callg((int(*)())push_parm, &job_arglist); frame_pointer->type |= SFT_EXTFUN; } REVERT; }
void mupip_upgrade(void) { bool rbno; unsigned char *upgrd_buff[2], upgrd_label[GDS_LABEL_SZ]="UPGRADE0304"; char fn[256]; char answer[4]; unsigned short fn_len; int4 fd, save_errno, old_hdr_size, new_hdr_size, status, bufsize, dsize, datasize[2]; int4 old_hdr_size_vbn, new_hdr_size_vbn; int fstat_res; off_t last_full_grp_startoff, old_file_len, old_file_len2, read_off, write_off, old_start_vbn_off; block_id last_full_grp_startblk; v3_sgmnt_data old_head_data, *old_head; sgmnt_data new_head_data, *new_head; struct stat stat_buf; error_def(ERR_MUNODBNAME); error_def(ERR_MUNOUPGRD); error_def(ERR_DBOPNERR); error_def(ERR_DBRDONLY); error_def(ERR_DBFILOPERR); error_def(ERR_DBPREMATEOF); ESTABLISH(mupip_upgrade_ch); fn_len = sizeof(fn); if (!cli_get_str("FILE", fn, &fn_len)) rts_error(VARLSTCNT(1) ERR_MUNODBNAME); if (!(mupip_upgrade_standalone(fn, &upgrade_standalone_sems))) rts_error(VARLSTCNT(1) ERR_MUNOUPGRD); if (-1 == (fd = OPEN(fn, O_RDWR))) { save_errno = errno; if (-1 != (fd = OPEN(fn, O_RDONLY))) { util_out_print("Cannot update read-only database.", FLUSH); rts_error(VARLSTCNT(5) ERR_DBRDONLY, 2, fn_len, fn, errno); } rts_error(VARLSTCNT(5) ERR_DBRDONLY, 2, fn_len, fn, save_errno); } /* Confirm before proceed */ if (!mu_upgrd_confirmed(TRUE)) { util_out_print("Upgrade canceled by user", FLUSH); rts_error(VARLSTCNT(1) ERR_MUNOUPGRD); } util_out_print("Do not interrupt to avoid damage in database!!", FLUSH); util_out_print("Mupip upgrade started ...!/", FLUSH); mu_upgrd_sig_init(); /* get file status */ FSTAT_FILE(fd, &stat_buf, fstat_res); if (-1 == fstat_res) rts_error(VARLSTCNT(5) ERR_DBOPNERR, 2, fn_len, fn, errno); old_file_len = stat_buf.st_size; /* Prepare v3.x file header buffer */ old_hdr_size = sizeof(*old_head); old_head = &old_head_data; /* Prepare v4.x file header buffer */ new_hdr_size = sizeof(*new_head); new_head = &new_head_data; memset(new_head, 0, new_hdr_size); old_hdr_size_vbn = DIVIDE_ROUND_UP(old_hdr_size, DISK_BLOCK_SIZE); new_hdr_size_vbn = DIVIDE_ROUND_UP(new_hdr_size, DISK_BLOCK_SIZE); /* READ header from V3.x file */ LSEEKREAD(fd, 0, old_head, old_hdr_size, status); if (0 != status) if (-1 == status) rts_error(VARLSTCNT(4) ERR_DBPREMATEOF, 2, fn_len, fn); else rts_error(VARLSTCNT(5) ERR_DBFILOPERR, 2, fn_len, fn, status); /* Check version */ if (memcmp(&old_head->label[0], GDS_LABEL, GDS_LABEL_SZ - 1)) { if (memcmp(&old_head->label[0], GDS_LABEL, GDS_LABEL_SZ - 3)) { /* it is not a GTM database */ close(fd); util_out_print("File !AD is not a GT.M database.!/", FLUSH, fn_len, fn); rts_error(VARLSTCNT(1) ERR_MUNOUPGRD); }else { /* it is GTM database */ /* is it not v3.x database? */ if (memcmp(&old_head->label[GDS_LABEL_SZ - 3],GDS_V30,2) !=0 && memcmp(&old_head->label[GDS_LABEL_SZ - 3],GDS_ALT_V30,2) != 0) { close(fd); util_out_print("File !AD has an unrecognized database version!/", FLUSH, fn_len, fn); rts_error(VARLSTCNT(1) ERR_MUNOUPGRD); } } } else { /* Note: We assume that if the V4.x header and current GT.M file header * has same field names, they are at same offset */ /* READ the header from file again as V4.x header */ LSEEKREAD(fd, 0, new_head, new_hdr_size, status); if (0 != status) if (-1 != status) rts_error(VARLSTCNT(5) ERR_DBFILOPERR, 2, fn_len, fn, status); else rts_error(VARLSTCNT(4) ERR_DBPREMATEOF, 2, fn_len, fn); if (QWNE(new_head->reg_seqno, seq_num_zero) || QWNE(new_head->resync_seqno, seq_num_zero) || (new_head->resync_tn != 0) || new_head->repl_state != repl_closed) { util_out_print("!AD might already have been upgraded", FLUSH, fn_len, fn); util_out_print("Do you wish to continue with the upgrade? [y/n] ", FLUSH); SCANF("%s", answer); if (answer[0] != 'y' && answer[0] != 'Y') { close(fd); util_out_print("Upgrade canceled by user", FLUSH); rts_error(VARLSTCNT(1) ERR_MUNOUPGRD); } } init_replication(new_head); new_head->max_update_array_size = new_head->max_non_bm_update_array_size = ROUND_UP2(MAX_NON_BITMAP_UPDATE_ARRAY_SIZE(new_head), UPDATE_ARRAY_ALIGN_SIZE); new_head->max_update_array_size += ROUND_UP2(MAX_BITMAP_UPDATE_ARRAY_SIZE, UPDATE_ARRAY_ALIGN_SIZE); new_head->mutex_spin_parms.mutex_hard_spin_count = MUTEX_HARD_SPIN_COUNT; new_head->mutex_spin_parms.mutex_sleep_spin_count = MUTEX_SLEEP_SPIN_COUNT; new_head->mutex_spin_parms.mutex_spin_sleep_mask = MUTEX_SPIN_SLEEP_MASK; new_head->semid = INVALID_SEMID; new_head->shmid = INVALID_SHMID; if (JNL_ALLOWED(new_head)) { /* Following 3 are new fields starting from V43001. * Initialize them appropriately. */ new_head->epoch_interval = DEFAULT_EPOCH_INTERVAL; new_head->alignsize = DISK_BLOCK_SIZE * JNL_DEF_ALIGNSIZE; if (!new_head->jnl_alq) new_head->jnl_alq = JNL_ALLOC_DEF; /* note new_head->jnl_deq is carried over without any change even if it is zero since a zero * jnl file extension size is supported starting V43001 */ new_head->autoswitchlimit = ALIGNED_ROUND_DOWN(JNL_ALLOC_MAX, new_head->jnl_alq, new_head->jnl_deq); /* following field is assumed as non-zero by set_jnl_info starting V43001A */ if (JNL_ALLOWED(new_head) && !new_head->jnl_buffer_size) new_head->jnl_buffer_size = JNL_BUFFER_DEF; } else { new_head->epoch_interval = 0; new_head->alignsize = 0; new_head->autoswitchlimit = 0; } new_head->yield_lmt = DEFAULT_YIELD_LIMIT; /* writing header */ LSEEKWRITE(fd, 0, new_head, new_hdr_size, status); if (0 != status) rts_error(VARLSTCNT(5) ERR_DBFILOPERR, 2, fn_len, fn, status); close(fd); util_out_print("File !AD successfully upgraded.!/", FLUSH, fn_len, fn); if (0 != sem_rmid(upgrade_standalone_sems)) { util_out_print("Error with sem_rmid : %d [0x%x]", TRUE, upgrade_standalone_sems, upgrade_standalone_sems); rts_error(VARLSTCNT(1) ERR_MUNOUPGRD); } mupip_exit(SS_NORMAL); } util_out_print("Old header size: !SL", FLUSH, old_hdr_size); util_out_print("New header size: !SL", FLUSH, new_hdr_size); if (old_head->createinprogress) { close(fd); util_out_print("Database creation in progress on file !AD.!/", FLUSH, fn_len, fn); rts_error(VARLSTCNT(1) ERR_MUNOUPGRD); } if (old_head->file_corrupt) { close(fd); util_out_print("Database !AD is corrupted.!/", FLUSH, fn_len, fn); rts_error(VARLSTCNT(1) ERR_MUNOUPGRD); } if ((((off_t)old_head->start_vbn - 1) * DISK_BLOCK_SIZE + (off_t)old_head->trans_hist.total_blks * old_head->blk_size + (off_t)DISK_BLOCK_SIZE != old_file_len) && (((off_t)old_head->start_vbn - 1) * DISK_BLOCK_SIZE + (off_t)old_head->trans_hist.total_blks * old_head->blk_size + (off_t)old_head->blk_size != old_file_len)) { util_out_print("Incorrect start_vbn !SL or, block size !SL or, total blocks !SL", FLUSH, old_head->start_vbn, old_head->blk_size, old_head->trans_hist.total_blks); rts_error(VARLSTCNT(1) ERR_MUNOUPGRD); } if (ROUND_DOWN(old_head->blk_size, DISK_BLOCK_SIZE) != old_head->blk_size) { util_out_print("Database block size !SL is not divisible by DISK_BLOCK_SIZE", FLUSH, old_head->blk_size); rts_error(VARLSTCNT(1) ERR_MUNOUPGRD); } mu_upgrd_header(old_head, new_head); /* Update header from v3.x to v4.x */ new_head->start_vbn = new_hdr_size_vbn + 1; new_head->free_space = 0; new_head->wc_blocked_t_end_hist.evnt_cnt = old_head->wc_blocked_t_end_hist2.evnt_cnt; new_head->wc_blocked_t_end_hist.evnt_tn = old_head->wc_blocked_t_end_hist2.evnt_tn; init_replication(new_head); /* A simple way of doing mupip upgrade is to move all the data after file header towards the eof to make space and write down the header. This does not need any computation or, change in data/index blocks. This is a slow process because it has mainly I/O, though no manipulation of database structures. or index blocks. This is okay for small database. A time efficient way is to physically move second group of BLKS_PER_LMAP number of blocks towards the eof and move first group of BLKS_PER_LMAP number of blocks in place of 2nd group. Finally adjust all indices to point to the blocks correctly. Also adjust master bit map. (note: we cannot move first group from the beginning). Detail algorithm as follows: --------------------------- // Allocate two buffers each to hold one group of data. Read v3.x header and upgrade to v4.x if file is big enough read group 1 in buff[0] read_off = offset of starting block of 2nd group. read group 2 in buff[1] write buff[0] at offset read_off last_full_grp_startblk = points to the block where 2nd group of 512 blocks of old file will be written back. //Instead of searching for a free group we will write at the last full group //Say, we have 3000 blocks. last_full_grp_startblk = 2048 // (not 2560, because it is not full) //All data from that point upto eof will be read and saved in buffer read all remaining data from the point last_full_grp_startblk upto eof in buff[0] write buff[1] at the point of last_full_grp_startblk Now write buff[0] at the end of last write //Graphical Example: Each letter corresponds to a group of 512 blocks where first block // is local bit map. Last group U may be a group of less than 512 blocks. // Extend towards right -------------------------------------------------------> // old permutation: [v3 head] A B C D E F G H I J K L M N O P Q R S T U // new permutation: [v4 head ] A C D E F G H I J K L M N O P Q R S T B U Finally traverse the tree and adjust block pointers Adjust master map write new v4.x header at bof else bufsize = size of data for a group rbno = 0 // read buffer no. This switches between 0 and 1 read_off = 0 write_off = 0 upgrd_buff[rbno] = new header data_size[rbno] = new header size rbno = INVERT(rbno); do while not eof data_size[rbno] = MIN(bufsize, remaining_data_size) Read data of size data_size[rbno] in upgrd_buff[rbno] and adjust read_off rbno = INVERT(rbno); Write upgrd_buff[rbno] of datasize[rbno] at write_off and increase write_off Enddo rbno = INVERT(rbno) Write upgrd_buff[rbno] of datasize[rbno] at write_off endif */ bufsize = old_head->blk_size * BLKS_PER_LMAP; upgrd_buff[0] = (unsigned char*) malloc(bufsize); upgrd_buff[1] = (unsigned char*) malloc(bufsize); read_off = old_start_vbn_off = (off_t)(old_head->start_vbn - 1) * DISK_BLOCK_SIZE; /* start vbn offset in bytes */ last_full_grp_startblk = ROUND_DOWN(new_head->trans_hist.total_blks, BLKS_PER_LMAP); /* in block_id */ last_full_grp_startoff = old_start_vbn_off + (off_t)last_full_grp_startblk * new_head->blk_size; /* offset in bytes */ /* this calculation is used because some 3.2x database has GDS blk_size bytes at the end instead of DISK_BLOCK_SIZE bytes. */ old_file_len2 = old_head->start_vbn * DISK_BLOCK_SIZE + (off_t)old_head->blk_size * old_head->trans_hist.total_blks; /* Change Label to a temporary dummy value, so that other GTM process does not come while doing upgrade and corrupts database */ LSEEKWRITE(fd, 0, upgrd_label, GDS_LABEL_SZ - 1, status); if (0 != status) rts_error(VARLSTCNT(5) ERR_DBFILOPERR, 2, fn_len, fn, status); if (old_head->trans_hist.total_blks > BLKS_PER_LMAP * 2) { /* recalculate start_vbn and free space, because there will be a gap after header */ new_head->start_vbn = old_head->start_vbn + bufsize / DISK_BLOCK_SIZE; new_head->free_space = bufsize - (new_hdr_size_vbn - old_hdr_size_vbn) * DISK_BLOCK_SIZE; util_out_print("New starting VBN is: !SL !/", FLUSH, new_head->start_vbn); /* read 1st group of blocks */ LSEEKREAD(fd, read_off, upgrd_buff[0], bufsize, status); if (0 != status) if (-1 == status) rts_error(VARLSTCNT(4) ERR_DBPREMATEOF, 2, fn_len, fn); else rts_error(VARLSTCNT(5) ERR_DBFILOPERR, 2, fn_len, fn, status); read_off = read_off + bufsize; /* read 2nd group of blocks */ LSEEKREAD(fd, read_off, upgrd_buff[1], bufsize, status); if (0 != status) if (-1 == status) rts_error(VARLSTCNT(4) ERR_DBPREMATEOF, 2, fn_len, fn); else rts_error(VARLSTCNT(5) ERR_DBFILOPERR, 2, fn_len, fn, status); /* write 1st group of blocks in place of 2nd group */ write_off = old_start_vbn_off + bufsize; LSEEKWRITE(fd, write_off, upgrd_buff[0], bufsize, status); if (0 != status) rts_error(VARLSTCNT(5) ERR_DBFILOPERR, 2, fn_len, fn, status); /* read last group (# of blks <= BLKS_PER_LMAP) */ dsize = old_file_len2 - last_full_grp_startoff; assert (dsize <= bufsize); LSEEKREAD(fd, last_full_grp_startoff, upgrd_buff[0], dsize, status); if (0 != status) if (-1 == status) rts_error(VARLSTCNT(4) ERR_DBPREMATEOF, 2, fn_len, fn); else rts_error(VARLSTCNT(5) ERR_DBFILOPERR, 2, fn_len, fn, status); /* write 2nd group of blocks */ LSEEKWRITE(fd, last_full_grp_startoff, upgrd_buff[1], bufsize, status); if (0 != status) rts_error(VARLSTCNT(5) ERR_DBFILOPERR, 2, fn_len, fn, status); /* write last group read from old file */ LSEEKWRITE(fd, last_full_grp_startoff + bufsize, upgrd_buff[0], dsize, status); if (0 != status) rts_error(VARLSTCNT(5) ERR_DBFILOPERR, 2, fn_len, fn, status); util_out_print("Please wait while index is being adjusted...!/", FLUSH); mu_upgrd_adjust_blkptr(1L, TRUE, new_head, fd, fn, fn_len); mu_upgrd_adjust_mm(new_head->master_map, DIVIDE_ROUND_UP(new_head->trans_hist.total_blks+1,BLKS_PER_LMAP)); /* writing header */ LSEEKWRITE(fd, 0, new_head, new_hdr_size, status); if (0 != status) rts_error(VARLSTCNT(5) ERR_DBFILOPERR, 2, fn_len, fn, status); } else /* very small database */ { rbno = 0; write_off = 0; datasize[rbno] = new_hdr_size; memcpy(upgrd_buff[0], new_head, new_hdr_size); rbno = INVERT(rbno); while(read_off < old_file_len2) { datasize[rbno] = MIN (old_file_len2 - read_off, bufsize); LSEEKREAD(fd, read_off, upgrd_buff[rbno], datasize[rbno], status); if (0 != status) if (-1 == status) rts_error(VARLSTCNT(4) ERR_DBPREMATEOF, 2, fn_len, fn); else rts_error(VARLSTCNT(5) ERR_DBFILOPERR, 2, fn_len, fn, status); read_off += datasize[rbno]; rbno = INVERT(rbno); LSEEKWRITE(fd, write_off, upgrd_buff[rbno], datasize[rbno], status); if (0 != status) rts_error(VARLSTCNT(5) ERR_DBFILOPERR, 2, fn_len, fn, status); write_off+= datasize[rbno]; } rbno = INVERT(rbno); LSEEKWRITE(fd, write_off, upgrd_buff[rbno], datasize[rbno], status); if (0 != status) rts_error(VARLSTCNT(5) ERR_DBFILOPERR, 2, fn_len, fn, status); } /* end if small database */ free(upgrd_buff[0]); free(upgrd_buff[1]); close(fd); util_out_print("File !AD successfully upgraded.!/", FLUSH, fn_len, fn); REVERT; if (0 != sem_rmid(upgrade_standalone_sems)) { util_out_print("Error with sem_rmid : %d [0x%x]", TRUE, upgrade_standalone_sems, upgrade_standalone_sems); rts_error(VARLSTCNT(1) ERR_MUNOUPGRD); } mupip_exit(SS_NORMAL); }
void mupip_restore(void) { static readonly char label[] = GDS_LABEL; char db_name[MAX_FN_LEN + 1], *inbuf, *p; inc_list_struct *ptr; inc_header *inhead; sgmnt_data *old_data; short iosb[4]; unsigned short n_len; int4 status, vbn, rsize, temp, save_errno; uint4 rest_blks, totblks; trans_num curr_tn; uint4 ii; block_id blk_num; bool extend; uint4 cli_status; BFILE *in; int i, db_fd; uint4 old_blk_size, old_tot_blks, bplmap; short old_start_vbn; off_t new_eof; char buff[DISK_BLOCK_SIZE]; char msg_buffer[1024], *newmap, *newmap_bptr; mstr msg_string; char addr[SA_MAXLEN+1]; unsigned char tcp[5]; backup_type type; unsigned short port; int4 timeout, cut, match; char debug_info[256]; void (*common_read)(); char *errptr; pid_t waitpid_res; error_def(ERR_MUPRESTERR); error_def(ERR_MUPCLIERR); error_def(ERR_IOEOF); extend = TRUE; if (CLI_NEGATED == (cli_status = cli_present("EXTEND"))) extend = FALSE; mu_outofband_setup(); mu_gv_cur_reg_init(); n_len = sizeof(db_name); if (cli_get_str("DATABASE", db_name, &n_len) == FALSE) mupip_exit(ERR_MUPCLIERR); strcpy((char *)gv_cur_region->dyn.addr->fname, db_name); gv_cur_region->dyn.addr->fname_len = n_len; if (!mu_rndwn_file(gv_cur_region, TRUE)) { util_out_print("Error securing stand alone access to output file !AD. Aborting restore.", TRUE, n_len, db_name); mupip_exit(ERR_MUPRESTERR); } OPENFILE(db_name, O_RDWR, db_fd); if (-1 == db_fd) { save_errno = errno; util_out_print("Error accessing output file !AD. Aborting restore.", TRUE, n_len, db_name); errptr = (char *)STRERROR(save_errno); util_out_print("open : !AZ", TRUE, errptr); mupip_exit(save_errno); } murgetlst(); inbuf = (char*)malloc(INC_BACKUP_CHUNK_SIZE); old_data = (sgmnt_data*)malloc(sizeof(sgmnt_data)); LSEEKREAD(db_fd, 0, old_data, sizeof(sgmnt_data), save_errno); if (0 != save_errno) { util_out_print("Error accessing output file !AD. Aborting restore.", TRUE, n_len, db_name); if (-1 != save_errno) { errptr = (char *)STRERROR(save_errno); util_out_print("read : !AZ", TRUE, errptr); db_ipcs_reset(gv_cur_region, TRUE); mu_gv_cur_reg_free(); mupip_exit(save_errno); } else { db_ipcs_reset(gv_cur_region, TRUE); mu_gv_cur_reg_free(); mupip_exit(ERR_IOEOF); } } if (memcmp(&old_data->label[0], &label[0], GDS_LABEL_SZ)) { util_out_print("Output file !AD has an unrecognizable format", TRUE, n_len, db_name); free(old_data); free(inbuf); db_ipcs_reset(gv_cur_region, TRUE); mu_gv_cur_reg_free(); mupip_exit(ERR_MUPRESTERR); } curr_tn = old_data->trans_hist.curr_tn; old_blk_size = old_data->blk_size; old_tot_blks = old_data->trans_hist.total_blks; old_start_vbn = old_data->start_vbn; bplmap = old_data->bplmap; free(old_data); msg_string.addr = msg_buffer; msg_string.len = sizeof(msg_buffer); inhead = (inc_header *)malloc(sizeof(inc_header) + 8); inhead = (inc_header *)((((int4)inhead) + 7) & -8); rest_blks = 0; for (ptr = in_files.next; ptr; ptr = ptr->next) { /* --- determine source type --- */ type = backup_to_file; if (0 == ptr->input_file.len) continue; else if ('|' == *(ptr->input_file.addr + ptr->input_file.len - 1)) { type = backup_to_exec; ptr->input_file.len--; *(ptr->input_file.addr + ptr->input_file.len) = '\0'; } else if (ptr->input_file.len > 5) { lower_to_upper(tcp, (uchar_ptr_t)ptr->input_file.addr, 5); if (0 == memcmp(tcp, "TCP:/", 5)) { type = backup_to_tcp; cut = 5; while ('/' == *(ptr->input_file.addr + cut)) cut++; ptr->input_file.len -= cut; p = ptr->input_file.addr; while (p < ptr->input_file.addr + ptr->input_file.len) { *p = *(p + cut); p++; } *p = '\0'; } } /* --- open the input stream --- */ restore_read_errno = 0; switch(type) { case backup_to_file: common_read = iob_read; if ((in = iob_open_rd(ptr->input_file.addr, DISK_BLOCK_SIZE, BLOCKING_FACTOR)) == NULL) { save_errno = errno; util_out_print("Error accessing input file !AD. Aborting restore.", TRUE, ptr->input_file.len, ptr->input_file.addr); errptr = (char *)STRERROR(save_errno); util_out_print("open : !AZ", TRUE, errptr); db_ipcs_reset(gv_cur_region, TRUE); mu_gv_cur_reg_free(); mupip_exit(save_errno); } ESTABLISH(iob_io_error); break; case backup_to_exec: pipe_child = 0; common_read = exec_read; in = (BFILE *)malloc(sizeof(BFILE)); if (0 > (in->fd = gtm_pipe(ptr->input_file.addr, input_from_comm))) { util_out_print("Error creating input pipe from !AD.", TRUE, ptr->input_file.len, ptr->input_file.addr); db_ipcs_reset(gv_cur_region, TRUE); mu_gv_cur_reg_free(); mupip_exit(ERR_MUPRESTERR); } #ifdef DEBUG_ONLINE PRINTF("file descriptor for the openned pipe is %d.\n", in->fd); PRINTF("the command passed to gtm_pipe is %s.\n", ptr->input_file.addr); #endif break; case backup_to_tcp: common_read = tcp_read; /* parse the input */ switch (match = SSCANF(ptr->input_file.addr, "%[^:]:%hu", addr, &port)) { case 1 : port = DEFAULT_BKRS_PORT; case 2 : break; default : util_out_print("Error : A hostname has to be specified.", TRUE); db_ipcs_reset(gv_cur_region, TRUE); mu_gv_cur_reg_free(); mupip_exit(ERR_MUPRESTERR); } if ((0 == cli_get_int("NETTIMEOUT", &timeout)) || (0 > timeout)) timeout = DEFAULT_BKRS_TIMEOUT; in = (BFILE *)malloc(sizeof(BFILE)); iotcp_fillroutine(); if (0 > (in->fd = tcp_open(addr, port, timeout, TRUE))) { util_out_print("Error establishing TCP connection to !AD.", TRUE, ptr->input_file.len, ptr->input_file.addr); db_ipcs_reset(gv_cur_region, TRUE); mu_gv_cur_reg_free(); mupip_exit(ERR_MUPRESTERR); } break; default: util_out_print("Aborting restore!/", TRUE); util_out_print("Unrecognized input format !AD", TRUE, ptr->input_file.len, ptr->input_file.addr); db_ipcs_reset(gv_cur_region, TRUE); mu_gv_cur_reg_free(); mupip_exit(ERR_MUPRESTERR); } COMMON_READ(in, inhead, sizeof(inc_header)); if (memcmp(&inhead->label[0], INC_HEADER_LABEL, INC_HDR_LABEL_SZ)) { util_out_print("Input file !AD has an unrecognizable format", TRUE, ptr->input_file.len, ptr->input_file.addr); free(inbuf); db_ipcs_reset(gv_cur_region, TRUE); mu_gv_cur_reg_free(); mupip_exit(ERR_MUPRESTERR); } if (curr_tn != inhead->start_tn) { util_out_print("Transaction in input file !AD does not align with database TN.!/DB: !XL!_Input file: !XL", TRUE, ptr->input_file.len, ptr->input_file.addr, curr_tn, inhead->start_tn); free(inbuf); db_ipcs_reset(gv_cur_region, TRUE); mu_gv_cur_reg_free(); mupip_exit(ERR_MUPRESTERR); } if (old_blk_size != inhead->blk_size) { util_out_print("Incompatable block size. Output file !AD has block size !XL,", TRUE, n_len, db_name); util_out_print("while input file !AD is from a database with block size !XL,", TRUE, ptr->input_file.len, ptr->input_file.addr, inhead->blk_size); free(inbuf); db_ipcs_reset(gv_cur_region, TRUE); mu_gv_cur_reg_free(); mupip_exit(ERR_MUPRESTERR); } if (old_tot_blks != inhead->db_total_blks) { if (old_tot_blks > inhead->db_total_blks || !extend) { totblks = old_tot_blks - DIVIDE_ROUND_UP(old_tot_blks, DISK_BLOCK_SIZE); util_out_print("Incompatable database sizes. Output file !AD has!/ !UL (!XL hex) total blocks,", TRUE, n_len, db_name, totblks, totblks); totblks = inhead->db_total_blks - DIVIDE_ROUND_UP(inhead->db_total_blks, DISK_BLOCK_SIZE); util_out_print("while input file !AD is from a database with!/ !UL (!XL hex) total blocks", TRUE, ptr->input_file.len, ptr->input_file.addr, totblks, totblks); free(inbuf); db_ipcs_reset(gv_cur_region, TRUE); mu_gv_cur_reg_free(); mupip_exit(ERR_MUPRESTERR); } else { /* this part of the code is similar to gdsfilext except that you don't need to do * most of the work that gdsfilext does. However, for situations where the database * extended since the last backup (the beginning of this incremental backup), and * there are new bitmaps that are never touched later on by GT.M, these bitmaps * will have tn == 0, which prevents the backup process to pick up these blocks, * so, we need to initialize these bitmaps here */ new_eof = ((off_t)(old_start_vbn - 1) * DISK_BLOCK_SIZE) + ((off_t)inhead->db_total_blks * old_blk_size); memset(buff, 0, DISK_BLOCK_SIZE); LSEEKWRITE(db_fd, new_eof, buff, DISK_BLOCK_SIZE, status); if (0 != status) { util_out_print("Aborting restore!/", TRUE); util_out_print("lseek or write error : Unable to extend output file !AD!/", TRUE, n_len, db_name); util_out_print(" from !UL (!XL hex) total blocks to !UL (!XL hex) total blocks.!/", TRUE, old_tot_blks, old_tot_blks, inhead->db_total_blks, inhead->db_total_blks); util_out_print(" Current input file is !AD with !UL (!XL hex) total blocks!/", TRUE, ptr->input_file.len, ptr->input_file.addr, inhead->db_total_blks, inhead->db_total_blks); gtm_putmsg(VARLSTCNT(1) status); free(inbuf); db_ipcs_reset(gv_cur_region, TRUE); mu_gv_cur_reg_free(); mupip_exit(ERR_MUPRESTERR); } /* --- initialize all new bitmaps, just in case they are not touched later --- */ if (DIVIDE_ROUND_DOWN(inhead->db_total_blks, bplmap) > DIVIDE_ROUND_DOWN(old_tot_blks, bplmap)) { /* -- similar logic exist in bml_newmap.c, which need to pick up any new updates here -- */ newmap = (char *)malloc(old_blk_size); ((blk_hdr *)newmap)->bsiz = BM_SIZE(bplmap); ((blk_hdr *)newmap)->levl = LCL_MAP_LEVL; ((blk_hdr *)newmap)->tn = curr_tn; newmap_bptr = newmap + sizeof(blk_hdr); *newmap_bptr++ = THREE_BLKS_FREE; memset(newmap_bptr, FOUR_BLKS_FREE, BM_SIZE(bplmap) - sizeof(blk_hdr) - 1); for (ii = ROUND_UP(old_tot_blks, bplmap); ii <= inhead->db_total_blks; ii += bplmap) { new_eof = (off_t)(old_start_vbn - 1) * DISK_BLOCK_SIZE + (off_t)ii * old_blk_size; LSEEKWRITE(db_fd, new_eof, newmap, old_blk_size, status); if (0 != status) { util_out_print("Aborting restore!/", TRUE); util_out_print("Bitmap 0x!XL initialization error!", TRUE, ii); gtm_putmsg(VARLSTCNT(1) status); free(inbuf); free(newmap); db_ipcs_reset(gv_cur_region, TRUE); mu_gv_cur_reg_free(); mupip_exit(ERR_MUPRESTERR); } } free(newmap); } old_tot_blks = inhead->db_total_blks; } } COMMON_READ(in, &rsize, sizeof(int4)); for ( ; ;) { /* rsize is the size of the record, including the size, but, since the size has already been read in, this will read in the current record and the size for the next record */ /* ensure we have a reasonable record size, at least */ if (rsize - sizeof(int4) - sizeof(block_id) > old_blk_size) { util_out_print("Invalid information in restore file !AD. Aborting restore.", TRUE, ptr->input_file.len, ptr->input_file.addr); iob_close(in); db_ipcs_reset(gv_cur_region, TRUE); mu_gv_cur_reg_free(); mupip_exit(ERR_MUPRESTERR); } COMMON_READ(in, inbuf, rsize); if (!memcmp(inbuf, &end_msg[0], sizeof end_msg - 1)) break; rest_blks++; blk_num = *(block_id*)inbuf; vbn = old_start_vbn - 1 + (old_blk_size / DISK_BLOCK_SIZE * blk_num); LSEEKWRITE(db_fd, (off_t)vbn * DISK_BLOCK_SIZE, inbuf + sizeof(block_id), rsize - sizeof(block_id) - sizeof(int4), save_errno); if (0 != save_errno) { util_out_print("Error accessing output file !AD. Aborting restore.", TRUE, n_len, db_name); errptr = (char *)STRERROR(save_errno); util_out_print("write : !AZ", TRUE, errptr); db_ipcs_reset(gv_cur_region, TRUE); mu_gv_cur_reg_free(); mupip_exit(save_errno); } GET_LONG(temp, (inbuf + rsize - sizeof(int4))); rsize = temp; } GET_LONG(temp, (inbuf + rsize - sizeof(int4))); rsize = temp; vbn = 0; for (i = 0; ; i++) /* Restore file header */ { COMMON_READ(in, inbuf, rsize); if (!memcmp(inbuf, &hdr_msg[0], sizeof hdr_msg - 1)) break; LSEEKWRITE(db_fd, vbn, inbuf, rsize - sizeof(int4), save_errno); if (0 != save_errno) { util_out_print("Error accessing output file !AD. Aborting restore.", TRUE, n_len, db_name); errptr = (char *)STRERROR(save_errno); util_out_print("write : !AZ", TRUE, errptr); db_ipcs_reset(gv_cur_region, TRUE); mu_gv_cur_reg_free(); mupip_exit(save_errno); } vbn += rsize - sizeof(int4); GET_LONG(temp, (inbuf + rsize - sizeof(int4))); rsize = temp; } curr_tn = inhead->end_tn; switch (type) { case backup_to_file: REVERT; iob_close(in); break; case backup_to_exec: close(in->fd); if ((pipe_child > 0) && (FALSE != is_proc_alive(pipe_child, 0))) WAITPID(pipe_child, (int *)&status, 0, waitpid_res); break; case backup_to_tcp: break; } } util_out_print("!/RESTORE COMPLETED", TRUE); util_out_print("!UL blocks restored", TRUE, rest_blks); free(inbuf); db_ipcs_reset(gv_cur_region, FALSE); mu_gv_cur_reg_free(); mupip_exit(SS_NORMAL); }
void mupip_trigger(void) { char trigger_file_name[MAX_FN_LEN + 1], select_list[MAX_LINE], select_file_name[MAX_FN_LEN + 1]; unsigned short trigger_file_len = MAX_FN_LEN + 1, select_list_len = MAX_LINE; unsigned short sf_name_len; int local_errno; struct stat statbuf; boolean_t noprompt, trigger_error; gd_region *reg, *reg_top; sgmnt_addrs *csa; # ifdef DEBUG DCL_THREADGBL_ACCESS; SETUP_THREADGBL_ACCESS; # endif if (CLI_PRESENT == cli_present("TRIGGERFILE")) { noprompt = (CLI_PRESENT == cli_present("NOPROMPT")); if (!cli_get_str("TRIGGERFILE", trigger_file_name, &trigger_file_len)) { util_out_print("Error parsing TRIGGERFILE name", TRUE); mupip_exit(ERR_MUPCLIERR); } assert('\0' == trigger_file_name[trigger_file_len]); /* should have been made sure by caller */ if (0 == trigger_file_len) { util_out_print("Missing input file name", TRUE); mupip_exit(ERR_MUPCLIERR); } gvinit(); mu_trig_trgfile(trigger_file_name, (uint4)trigger_file_len, noprompt); } if (CLI_PRESENT == cli_present("SELECT")) { if (FALSE == cli_get_str("SELECT", select_list, &select_list_len)) mupip_exit(ERR_MUPCLIERR); sf_name_len = MAX_FN_LEN; if (FALSE == cli_get_str("FILE", select_file_name, &sf_name_len)) mupip_exit(ERR_MUPCLIERR); if (0 == sf_name_len) select_file_name[0] = '\0'; else if (-1 == Stat((char *)select_file_name, &statbuf)) { if (ENOENT != errno) { local_errno = errno; perror("Error opening output file"); mupip_exit(local_errno); } } else { util_out_print("Error opening output file: !AD -- File exists", TRUE, sf_name_len, select_file_name); mupip_exit(ERR_MUNOACTION); } trigger_error = trigger_select_tpwrap(select_list, (uint4)select_list_len, select_file_name, (uint4)sf_name_len); if (trigger_error) mupip_exit(ERR_MUNOACTION); } if (CLI_PRESENT == cli_present("UPGRADE")) { /* Invoke MUPIP TRIGGER -UPGRADE */ gvinit(); DEBUG_ONLY(TREF(in_trigger_upgrade) = TRUE;) for (reg = gd_header->regions, reg_top = reg + gd_header->n_regions; reg < reg_top; reg++)
void mupip_cvtgbl(void) { unsigned short fn_len, len; char fn[256]; unsigned char buff[7]; uint4 begin, end; int i, format; uint4 cli_status; gtm_int64_t begin_i8, end_i8; DCL_THREADGBL_ACCESS; SETUP_THREADGBL_ACCESS; /* If an online rollback occurs when we are loading up the database with new globals and takes us back to a prior logical * state, then we should not continue with the load. The reason being that the application might rely on certain globals to * be present before loading others and that property could be voilated if online rollback takes the database back to a * completely different logical state. Set the variable issue_DBROLLEDBACK_anyways that forces the restart logic to issue * an rts_error the first time it detects an online rollback (that takes the database to a prior logical state). */ TREF(issue_DBROLLEDBACK_anyways) = TRUE; is_replicator = TRUE; skip_dbtriggers = TRUE; fn_len = SIZEOF(fn); if (cli_present("STDIN")) { /* User wants to load from standard input */ assert(SIZEOF(fn) > sys_input.len); memcpy(fn, sys_input.addr, sys_input.len); fn_len = sys_input.len; assert(-1 != fcntl(fileno(stdin), F_GETFD)); /* Check if both file name and -STDIN specified. */ if (cli_get_str("FILE", fn, &fn_len)) mupip_exit(ERR_MUPCLIERR); } else if (!cli_get_str("FILE", fn, &fn_len)) /* User wants to read from a file. */ mupip_exit(ERR_MUPCLIERR); /* Neither -STDIN nor file name specified. */ if (mupip_error_occurred) exit(-1); file_input_init(fn, fn_len); mu_outofband_setup(); if ((cli_status = cli_present("BEGIN")) == CLI_PRESENT) { if (!cli_get_int64("BEGIN", &begin_i8)) mupip_exit(ERR_MUPCLIERR); if (1 > begin_i8) mupip_exit(ERR_LOADBGSZ); else if (MAXUINT4 < begin_i8) mupip_exit(ERR_LOADBGSZ2); begin = (uint4) begin_i8; } else { begin = 1; begin_i8 = 1; } if ((cli_status = cli_present("END")) == CLI_PRESENT) { if (!cli_get_int64("END", &end_i8)) mupip_exit(ERR_MUPCLIERR); if (1 > end_i8) mupip_exit(ERR_LOADEDSZ); else if (MAXUINT4 < end_i8) mupip_exit(ERR_LOADEDSZ2); if (end_i8 < begin_i8) mupip_exit(ERR_LOADEDBG); end = (uint4) end_i8; } else end = MAXUINT4; if ((cli_status = cli_present("FILL_FACTOR")) == CLI_PRESENT) { assert(SIZEOF(gv_fillfactor) == SIZEOF(int4)); if (!cli_get_int("FILL_FACTOR", (int4 *)&gv_fillfactor)) gv_fillfactor = MAX_FILLFACTOR; if (gv_fillfactor < MIN_FILLFACTOR) gv_fillfactor = MIN_FILLFACTOR; else if (gv_fillfactor > MAX_FILLFACTOR) gv_fillfactor = MAX_FILLFACTOR; } else gv_fillfactor = MAX_FILLFACTOR; if (cli_present("FORMAT") == CLI_PRESENT) { len = SIZEOF("FORMAT"); if (!cli_get_str("FORMAT", (char *)buff, &len)) go_load(begin, end); else { lower_to_upper(buff, buff, len); if (!memcmp(buff, "ZWR", len)) go_load(begin, end); else if (!memcmp(buff, "BINARY", len)) bin_load(begin, end); else if (!memcmp(buff, "GO", len)) go_load(begin, end); else if (!memcmp(buff, "GOQ", len)) goq_load(); else { util_out_print("Illegal format for load",TRUE); mupip_exit(ERR_MUPCLIERR); } } } else go_load(begin, end); if (mupip_error_occurred) { util_out_print("Error occurred during loading",TRUE); exit(-1); } else mupip_exit(SS_NORMAL); }
void get_cmd_qlf(command_qualifier *qualif) { static readonly char upper[] = "UPPER"; static readonly char lower[] = "LOWER"; mstr *s; int temp_int; unsigned short len; unsigned char inbuf[255]; qualif->qlf = glb_cmd_qlf.qlf; qualif->object_file.mvtype = qualif->list_file.mvtype = qualif->ceprep_file.mvtype = 0; if (cli_present("OBJECT") == CLI_PRESENT) { qualif->qlf |= CQ_OBJECT; qualif->object_file.mvtype = MV_STR; s = &qualif->object_file.str; len = s->len; if (cli_get_str("OBJECT", s->addr, &len) == FALSE) { s->len = 0; if (glb_cmd_qlf.object_file.mvtype == MV_STR && glb_cmd_qlf.object_file.str.len > 0) { s->len = glb_cmd_qlf.object_file.str.len; memcpy(s->addr, glb_cmd_qlf.object_file.str.addr, s->len); } } else s->len = len; } else if (cli_negated("OBJECT") == TRUE) qualif->qlf &= ~CQ_OBJECT; if (cli_present("CROSS_REFERENCE") == CLI_PRESENT) qualif->qlf |= CQ_CROSS_REFERENCE; else if (cli_negated("CROSS_REFERENCE") == TRUE) qualif->qlf &= ~CQ_CROSS_REFERENCE; if (cli_negated("IGNORE") == TRUE) qualif->qlf &= ~CQ_IGNORE; else qualif->qlf |= CQ_IGNORE; if (cli_present("DEBUG") == CLI_PRESENT) qualif->qlf |= CQ_DEBUG; else if (cli_negated("DEBUG") == TRUE) qualif->qlf &= ~CQ_DEBUG; if (cli_negated("LINE_ENTRY") == TRUE) qualif->qlf &= ~CQ_LINE_ENTRY; if (cli_negated("INLINE_LITERALS") == TRUE) qualif->qlf &= ~CQ_INLINE_LITERALS; #ifdef DEBUG if (cli_present("MACHINE_CODE") == CLI_PRESENT) qualif->qlf |= CQ_MACHINE_CODE; else if (cli_negated("MACHINE_CODE") == TRUE) qualif->qlf &= ~CQ_MACHINE_CODE; #else qualif->qlf &= ~CQ_MACHINE_CODE; #endif if (cli_negated("WARNINGS") == TRUE) qualif->qlf &= ~CQ_WARNINGS; else qualif->qlf |= CQ_WARNINGS; if (cli_negated("LIST") == TRUE) qualif->qlf &= (~CQ_LIST & ~CQ_MACHINE_CODE); else if (cli_present("LIST") == CLI_PRESENT) { qualif->qlf |= CQ_LIST; qualif->list_file.mvtype = MV_STR; s = &qualif->list_file.str; len = s->len; if (cli_get_str("LIST", s->addr, &len) == FALSE) { s->len = 0; if (glb_cmd_qlf.list_file.mvtype == MV_STR && glb_cmd_qlf.list_file.str.len > 0) { s->len = glb_cmd_qlf.list_file.str.len; memcpy(s->addr, glb_cmd_qlf.list_file.str.addr, s->len); } } else s->len = len; } else if (!(qualif->qlf & CQ_LIST)) { qualif->qlf &= ~CQ_MACHINE_CODE; } if (cli_get_int("LENGTH",&temp_int) == FALSE) temp_int = 66; lst_param.lines_per_page = temp_int; if (cli_get_int("SPACE",&temp_int) == FALSE || temp_int <= 0 || temp_int >= lst_param.lines_per_page) temp_int = 1; lst_param.space = temp_int; if (cli_present("LABELS") == CLI_PRESENT) { len = sizeof(inbuf); if (cli_get_str("LABELS", (char *)&inbuf[0], &len)) { if (len == sizeof(upper) - 1) { if (!memcmp(upper, &inbuf[0], len)) qualif->qlf &= ~CQ_LOWER_LABELS; else if (!memcmp(lower, &inbuf[0], len)) qualif->qlf |= CQ_LOWER_LABELS; } } } if (cli_present("CE_PREPROCESS") == CLI_PRESENT) { qualif->qlf |= CQ_CE_PREPROCESS; qualif->ceprep_file.mvtype = MV_STR; s = &qualif->ceprep_file.str; len = s->len; if (cli_get_str("CE_PREPROCESS", s->addr, &len) == FALSE) { s->len = 0; if (glb_cmd_qlf.ceprep_file.mvtype == MV_STR && glb_cmd_qlf.ceprep_file.str.len > 0) { s->len = glb_cmd_qlf.ceprep_file.str.len; memcpy(s->addr, glb_cmd_qlf.ceprep_file.str.addr, s->len); } } else s->len = len; } else if (cli_negated("CE_PREPROCESS") == TRUE) qualif->qlf &= ~CQ_CE_PREPROCESS; }
/* * This function reads command line parameters and forms a configuration for mupip size invocation. * It later executes mupip size on each global based on the configuration * * MUPIP SIZE interface is described in GTM-7292 */ void mupip_size(void) { boolean_t restrict_reg = FALSE; char buff[MAX_LINE], cli_buff[MAX_LINE]; char *p_end; /* used for strtol validation */ glist exclude_gl_head, gl_head, *gl_ptr; int4 reg_max_rec, reg_max_key, reg_max_blk; mupip_size_cfg_t mupip_size_cfg = { impsample, 1000, 1, 0 }; /* configuration default values */ uint4 status = EXIT_NRM; unsigned short BUFF_LEN = SIZEOF(buff), n_len; DCL_THREADGBL_ACCESS; SETUP_THREADGBL_ACCESS; mu_outofband_setup(); error_mupip = FALSE; memset(mu_int_adj, 0, ARRAYSIZE(mu_int_adj)); memset(mu_int_adj_prev, 0, ARRAYSIZE(mu_int_adj_prev)); /* Region qualifier */ grlist = NULL; if (CLI_PRESENT == cli_present("REGION")) { restrict_reg = TRUE; gvinit(); /* init gd_header (needed to call mu_getlst) */ mu_getlst("REGION", SIZEOF(tp_region)); } mupip_size_check_error(); /* SELECT qualifier */ memset(cli_buff, 0, SIZEOF(cli_buff)); n_len = SIZEOF(cli_buff); if (CLI_PRESENT != cli_present("SELECT")) { n_len = 1; cli_buff[0] = '*'; } else if (FALSE == cli_get_str("SELECT", cli_buff, &n_len)) { n_len = 1; cli_buff[0] = '*'; } /* gv_select will select globals for this clause*/ gv_select(cli_buff, n_len, FALSE, "SELECT", &gl_head, ®_max_rec, ®_max_key, ®_max_blk, restrict_reg); if (!gl_head.next) { error_mupip = TRUE; gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_NOSELECT); } mupip_size_check_error(); if (CLI_PRESENT == cli_present("ADJACENCY")) { assert(SIZEOF(muint_adj) == SIZEOF(int4)); if (0 == cli_get_int("ADJACENCY", (int4 *)&muint_adj)) { error_mupip = TRUE; gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_MUPCLIERR); } } else muint_adj = DEFAULT_ADJACENCY; /* HEURISTIC qualifier */ if (cli_present("HEURISTIC.SCAN") == CLI_PRESENT) { mupip_size_cfg.heuristic = scan; if (cli_present("HEURISTIC.LEVEL")) { boolean_t valid = TRUE; if (cli_get_str("HEURISTIC.LEVEL", buff, &BUFF_LEN)) { mupip_size_cfg.level = strtol(buff, &p_end, 10); valid = (*p_end == '\0'); } else valid = FALSE; if (!valid || mupip_size_cfg.level <= -MAX_BT_DEPTH || MAX_BT_DEPTH <= mupip_size_cfg.level) { error_mupip = TRUE; gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT(4) ERR_MUSIZEINVARG, 2, LEN_AND_LIT("HEURISTIC.LEVEL")); } } /* else level is already initialized with default value */ } else if (cli_present("HEURISTIC.ARSAMPLE") == CLI_PRESENT || cli_present("HEURISTIC.IMPSAMPLE") == CLI_PRESENT) { if (cli_present("HEURISTIC.ARSAMPLE") == CLI_PRESENT) mupip_size_cfg.heuristic = arsample; else if (cli_present("HEURISTIC.IMPSAMPLE") == CLI_PRESENT) mupip_size_cfg.heuristic = impsample; if (cli_present("HEURISTIC.SAMPLES")) { boolean_t valid = cli_get_int("HEURISTIC.SAMPLES", &(mupip_size_cfg.samples)); if (!valid || mupip_size_cfg.samples <= 0){ error_mupip = TRUE; gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT(4) ERR_MUSIZEINVARG, 2, LEN_AND_LIT("HEURISTIC.SAMPLES")); } } /* else samples is already initialized with default value */ /* undocumented SEED parameter used for testing sampling method */ if (cli_present("HEURISTIC.SEED")) { boolean_t valid = cli_get_int("HEURISTIC.SEED", &(mupip_size_cfg.seed)); if (!valid){ error_mupip = TRUE; gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT(4) ERR_MUSIZEINVARG, 2, LEN_AND_LIT("HEURISTIC.SEED")); } } /* else seed will be based on the time */ } mupip_size_check_error(); /* run mupip size on each global */ for (gl_ptr = gl_head.next; gl_ptr; gl_ptr = gl_ptr->next) { util_out_print("!/Global: !AD (region !AD)", FLUSH, GNAME(gl_ptr).len, GNAME(gl_ptr).addr, REG_LEN_STR(gl_ptr->reg)); switch (mupip_size_cfg.heuristic) { case scan: status |= mu_size_scan(gl_ptr, mupip_size_cfg.level); break; case arsample: status |= mu_size_arsample(gl_ptr, mupip_size_cfg.samples, mupip_size_cfg.seed); break; case impsample: status |= mu_size_impsample(gl_ptr, mupip_size_cfg.samples, mupip_size_cfg.seed); break; default: assertpro(FALSE && mupip_size_cfg.heuristic); break; } if (mu_ctrlc_occurred || mu_ctrly_occurred) mupip_exit(ERR_MUNOFINISH); } mupip_exit(status == EXIT_NRM ? SS_NORMAL : ERR_MUNOFINISH); }
void dse_save(void) { block_id blk; unsigned i, j, util_len; unsigned short buff_len; bool was_block, was_crit; char buff[100], *ptr, util_buff[MAX_UTIL_LEN]; sm_uc_ptr_t bp; int4 dummy_int, nocrit_present; cache_rec_ptr_t dummy_cr; error_def(ERR_DSEBLKRDFAIL); memset(util_buff, 0, MAX_UTIL_LEN); if (was_block = (cli_present("BLOCK") == CLI_PRESENT)) { if (!cli_get_hex("BLOCK", &blk)) return; if (blk < 0 || blk >= cs_addrs->ti->total_blks) { util_out_print("Error: invalid block number.", TRUE); return; } patch_curr_blk = blk; } else blk = patch_curr_blk; if (cli_present("LIST") == CLI_PRESENT) { if (was_block) { util_len = sizeof("!/Saved versions of block "); memcpy(util_buff, "!/Saved versions of block ", util_len); util_len += i2hex_nofill(blk, (uchar_ptr_t)&util_buff[util_len-1], 8); util_buff[util_len-1] = 0; util_out_print(util_buff, TRUE); for (i = j = 0; i < patch_save_count; i++) if (patch_save_set[i].blk == blk) { j++; if (*patch_save_set[i].comment) util_out_print("Version !UL Region !AD Comment: !AD!/", TRUE, patch_save_set[i].ver, REG_LEN_STR(patch_save_set[i].region), LEN_AND_STR(patch_save_set[i].comment)); else util_out_print("Version !UL Region !AD!/", TRUE, patch_save_set[i].ver, REG_LEN_STR(patch_save_set[i].region)); } if (!j) util_out_print("None.!/", TRUE); return; } util_out_print("!/Save history:!/", TRUE); for (i = j = 0; i < patch_save_count; i++) { util_len = sizeof("Block "); memcpy(util_buff, "Block ", util_len); util_len += i2hex_nofill(patch_save_set[i].blk, (uchar_ptr_t)&util_buff[util_len-1], 8); util_buff[util_len-1] = 0; util_out_print(util_buff, TRUE); j++; if (*patch_save_set[i].comment) { util_out_print("Version !UL Region !AD Comment: !AD!/", TRUE, patch_save_set[i].ver, REG_LEN_STR(patch_save_set[i].region), LEN_AND_STR(patch_save_set[i].comment)); } else { util_out_print("Version !UL Region !AD!/", TRUE, patch_save_set[i].ver, REG_LEN_STR(patch_save_set[i].region)); } } if (!j) util_out_print(" None.!/", TRUE); return; } j = 1; for (i = 0; i < patch_save_count; i++) if (patch_save_set[i].blk == blk && patch_save_set[i].region == gv_cur_region && patch_save_set[i].ver >= j) j = patch_save_set[i].ver + 1; util_len = sizeof("!/Saving version !UL of block "); memcpy(util_buff, "!/Saving version !UL of block ", util_len); util_len += i2hex_nofill(blk, (uchar_ptr_t)&util_buff[util_len-1], 8); util_buff[util_len-1] = 0; util_out_print(util_buff, TRUE, j); patch_save_set[patch_save_count].ver = j; patch_save_set[patch_save_count].blk = blk; patch_save_set[patch_save_count].region = gv_cur_region; patch_save_set[patch_save_count].bp = (char *)malloc(cs_addrs->hdr->blk_size); if (blk >= cs_addrs->ti->total_blks) rts_error(VARLSTCNT(1) ERR_DSEBLKRDFAIL); was_crit = cs_addrs->now_crit; nocrit_present = (CLI_NEGATED == cli_present("CRIT")); if (!was_crit) { if (nocrit_present) cs_addrs->now_crit = TRUE; else grab_crit(gv_cur_region); } if (!(bp = t_qread(blk, &dummy_int, &dummy_cr))) rts_error(VARLSTCNT(1) ERR_DSEBLKRDFAIL); memcpy(patch_save_set[patch_save_count].bp, bp, cs_addrs->hdr->blk_size); if (!was_crit) { if (nocrit_present) cs_addrs->now_crit = FALSE; else rel_crit(gv_cur_region); } buff_len = sizeof(buff); if ((cli_present("COMMENT") == CLI_PRESENT) && cli_get_str("COMMENT", buff, &buff_len)) { ptr = &buff[buff_len]; *ptr = 0; j = ptr - &buff[0] + 1; patch_save_set[patch_save_count].comment = (char *)malloc(j); memcpy(patch_save_set[patch_save_count].comment, &buff[0], j); } else patch_save_set[patch_save_count].comment = ""; patch_save_count++; return; }
int cli_parse_two_numbers(char *qual_name, const char delimiter, uint4 *first_num, uint4 *second_num) { /* Parse two unsigned base 10 numbers separated by the given delimiter. Eg. -LOG_INTERVAL=10,20 (on VMS, -LOG_INTERVAL="10,20"). * Both Unix and VMS accept the qualifier as a string. NOTE: On VMS, such qualifiers are quoted strings. * Both numbers are optional (eg. -LOG_INTERVAL=10, or -LOG_INTERVAL=",20", or -LOG_INTERVAL=,). * Return values: * CLI_2NUM_FIRST_SPECIFIED (binary 10), first number specified, second not * CLI_2NUM_SECOND_SPECIFIED (binary 01), first number not specified, second is * CLI_2NUM_BOTH_SPECIFIED (binary 11) (CLI_2NUM_FIRST_SPECIFIED | CLI_2NUM_SECOND_SPECIFIED), both specified * 0 (binary 00), error in parsing either number */ char *first_num_str, *second_num_str, *two_num_str_top, *num_endptr; char two_num_qual_str[128]; unsigned short two_num_qual_len; uint4 num; int retval = 0; two_num_qual_len = sizeof(two_num_qual_str); if (!cli_get_str(qual_name, two_num_qual_str, &two_num_qual_len)) { util_out_print("Error parsing !AZ qualifier", TRUE, qual_name); return 0; } #ifdef VMS /* DCL does not strip quotes included in the command line. However, the DEFAULT value (see mupip_cmd.cld) is stripped * of quotes. */ if ('"' == two_num_qual_str[0]) { assert('"' == two_num_qual_str[two_num_qual_len - 1]); /* end quote should exist */ first_num_str = &two_num_qual_str[1]; /* Skip begin quote */ two_num_qual_str[two_num_qual_len - 1] = '\0'; /* Zap end quote */ two_num_qual_len -= 2; /* Quotes gone */ } else #endif first_num_str = two_num_qual_str; for (second_num_str = first_num_str, two_num_str_top = first_num_str + two_num_qual_len; second_num_str < two_num_str_top && delimiter != *second_num_str; second_num_str++) ; if (delimiter == *second_num_str) *second_num_str++ = '\0'; if (*first_num_str != '\0') /* VMS issues EINVAL if strtoul is passed null string */ { errno = 0; num = (uint4)STRTOUL(first_num_str, &num_endptr, 10); if ((0 == num && (0 != errno || (num_endptr == first_num_str && *first_num_str != '\0'))) || (0 != errno && GTM64_ONLY(UINT_MAX == num) NON_GTM64_ONLY(ULONG_MAX == num))) { util_out_print("Error parsing or invalid parameter for !AZ", TRUE, qual_name); return 0; } *first_num = num; retval |= CLI_2NUM_FIRST_SPECIFIED; } /* else, first number not specified */ if (second_num_str < two_num_str_top && *second_num_str != '\0') { errno = 0; num = (uint4)STRTOUL(second_num_str, &num_endptr, 10); if ((0 == num && (0 != errno || (num_endptr == second_num_str && *second_num_str != '\0'))) || (0 != errno && GTM64_ONLY(UINT_MAX == num) NON_GTM64_ONLY(ULONG_MAX == num))) { util_out_print("Error parsing or invalid parameter for LOG_INTERVAL", TRUE); return 0; } *second_num = num; retval |= CLI_2NUM_SECOND_SPECIFIED; } /* else, second number not specified */ return retval; }
void mupip_cvtgbl(void) { char fn[MAX_FN_LEN + 1], *line1_ptr, *line3_ptr; gtm_int64_t begin_i8, end_i8; int dos, i, file_format, line1_len, line3_len, utf8; uint4 begin, cli_status, end, max_rec_size; unsigned char buff[MAX_ONERROR_VALUE_LEN]; unsigned short fn_len, len; DCL_THREADGBL_ACCESS; SETUP_THREADGBL_ACCESS; assert(MAX_ONERROR_VALUE_LEN > MAX_FORMAT_VALUE_LEN); /* so the buff[] definition above is good for FORMAT and ONERROR */ /* If an online rollback occurs when we are loading up the database with new globals and takes us back to a prior logical * state, then we should not continue with the load. The reason being that the application might rely on certain globals to * be present before loading others and that property could be violated if online rollback takes the database back to a * completely different logical state. Set the variable issue_DBROLLEDBACK_anyways that forces the restart logic to issue * an rts_error the first time it detects an online rollback (that takes the database to a prior logical state). */ TREF(issue_DBROLLEDBACK_anyways) = TRUE; is_replicator = TRUE; skip_dbtriggers = TRUE; fn_len = SIZEOF(fn); if (cli_present("STDIN")) { /* User wants to load from standard input */ assert(SIZEOF(fn) > sys_input.len); memcpy(fn, sys_input.addr, sys_input.len); fn_len = sys_input.len; assert(-1 != fcntl(fileno(stdin), F_GETFD)); /* Check if both file name and -STDIN specified. */ if (cli_get_str("FILE", fn, &fn_len)) mupip_exit(ERR_MUPCLIERR); } else if (!cli_get_str("FILE", fn, &fn_len)) /* User wants to read from a file. */ mupip_exit(ERR_MUPCLIERR); /* Neither -STDIN nor file name specified. */ file_input_init(fn, fn_len, IOP_EOL); if (mupip_error_occurred) EXIT(-1); mu_outofband_setup(); if ((cli_status = cli_present("BEGIN")) == CLI_PRESENT) { if (!cli_get_int64("BEGIN", &begin_i8)) mupip_exit(ERR_MUPCLIERR); if (1 > begin_i8) mupip_exit(ERR_LOADBGSZ); else if (MAXUINT4 < begin_i8) mupip_exit(ERR_LOADBGSZ2); begin = (uint4) begin_i8; } else { begin = 1; begin_i8 = 1; } if ((cli_status = cli_present("END")) == CLI_PRESENT) { if (!cli_get_int64("END", &end_i8)) mupip_exit(ERR_MUPCLIERR); if (1 > end_i8) mupip_exit(ERR_LOADEDSZ); else if (MAXUINT4 < end_i8) mupip_exit(ERR_LOADEDSZ2); if (end_i8 < begin_i8) mupip_exit(ERR_LOADEDBG); end = (uint4) end_i8; } else end = MAXUINT4; if ((cli_status = cli_present("FILL_FACTOR")) == CLI_PRESENT) { assert(SIZEOF(gv_fillfactor) == SIZEOF(int4)); if (!cli_get_int("FILL_FACTOR", (int4 *)&gv_fillfactor)) gv_fillfactor = MAX_FILLFACTOR; if (gv_fillfactor < MIN_FILLFACTOR) gv_fillfactor = MIN_FILLFACTOR; else if (gv_fillfactor > MAX_FILLFACTOR) gv_fillfactor = MAX_FILLFACTOR; } else gv_fillfactor = MAX_FILLFACTOR; if (cli_present("ONERROR") == CLI_PRESENT) { len = SIZEOF(buff); if (!cli_get_str("ONERROR", (char *)buff, &len)) { assert(FALSE); onerror = ONERROR_PROCEED; } else { lower_to_upper(buff, buff, len); if (!memcmp(buff, "STOP", len)) onerror = ONERROR_STOP; else if (!memcmp(buff, "PROCEED", len)) onerror = ONERROR_PROCEED; else if (!memcmp(buff, "INTERACTIVE", len)) { if (isatty(0)) /*if stdin is a terminal*/ onerror = ONERROR_INTERACTIVE; else onerror = ONERROR_STOP; } else { util_out_print("Illegal ONERROR parameter for load",TRUE); mupip_exit(ERR_MUPCLIERR); } } } else onerror = ONERROR_PROCEED; /* Default: Proceed on error */ file_format = get_load_format(&line1_ptr, &line3_ptr, &line1_len, &line3_len, &max_rec_size, &utf8, &dos); /* from header */ if (MU_FMT_GOQ == file_format) mupip_exit(ERR_LDBINFMT); if (BADZCHSET == utf8) mupip_exit(ERR_MUNOFINISH); if (cli_present("FORMAT") == CLI_PRESENT) { /* If the command speficies a format see if it matches the label */ len = SIZEOF(buff); if (!cli_get_str("FORMAT", (char *)buff, &len)) go_load(begin, end, (unsigned char *)line1_ptr, line3_ptr, line3_len, max_rec_size, file_format, utf8, dos); else { lower_to_upper(buff, buff, len); if (!memcmp(buff, "ZWR", len)) { /* If the label did not determine a format let them specify ZWR and they can sort out the result */ if ((MU_FMT_ZWR == file_format) || (MU_FMT_UNRECOG == file_format)) go_load(begin, end, (unsigned char *)line1_ptr, line3_ptr, line3_len, max_rec_size, MU_FMT_ZWR, utf8, dos); else mupip_exit(ERR_LDBINFMT); } else if (!memcmp(buff, "BINARY", len)) { if (MU_FMT_BINARY == file_format) bin_load(begin, end, line1_ptr, line1_len); else mupip_exit(ERR_LDBINFMT); } else if (!memcmp(buff, "GO", len)) { /* If the label did not determine a format let them specify GO and they can sort out the result */ if ((MU_FMT_GO == file_format) || (MU_FMT_UNRECOG == file_format)) go_load(begin, end, (unsigned char *)line1_ptr, line3_ptr, line3_len, max_rec_size, MU_FMT_GO, utf8, dos); else mupip_exit(ERR_LDBINFMT); } else if (!memcmp(buff, "GOQ", len)) { /* get_load_format doesn't recognize GOQ labels' */ if (MU_FMT_UNRECOG == file_format) goq_load(); else mupip_exit(ERR_LDBINFMT); } else { util_out_print("Illegal file format for load",TRUE); mupip_exit(ERR_MUPCLIERR); } } } else { if (MU_FMT_BINARY == file_format) bin_load(begin, end, line1_ptr, line1_len); else if ((MU_FMT_ZWR == file_format) || (MU_FMT_GO == file_format)) go_load(begin, end, (unsigned char *)line1_ptr, line3_ptr, line3_len, max_rec_size, file_format, utf8, dos); else { assert(MU_FMT_UNRECOG == file_format); mupip_exit(ERR_LDBINFMT); } } mupip_exit(mupip_error_occurred ? ERR_MUNOFINISH : SS_NORMAL); }
void dse_f_reg(void) { char rn[MAX_RN_LEN]; unsigned short rnlen; int i; bool found; gd_region *ptr; gd_addr *temp_gdaddr; gd_binding *map; temp_gdaddr = gd_header; gd_header = original_header; rnlen = SIZEOF(rn); if (!cli_get_str("REGION",rn,&rnlen)) { gd_header = temp_gdaddr; return; } if (rn[0] == '*' && rnlen == 1) { util_out_print("List of global directory:!_!AD!/",TRUE,dollar_zgbldir.str.len,dollar_zgbldir.str.addr); for (i=0, ptr = gd_header->regions; i < gd_header->n_regions ;i++, ptr++) { util_out_print("!/File !_!AD",TRUE, ptr->dyn.addr->fname_len,&ptr->dyn.addr->fname[0]); util_out_print("Region!_!AD",TRUE, REG_LEN_STR(ptr)); } gd_header = temp_gdaddr; return; } assert(rn[0]); found = FALSE; for (i=0, ptr = gd_header->regions; i < gd_header->n_regions ;i++, ptr++) { if (found = !memcmp(&ptr->rname[0],&rn[0],MAX_RN_LEN)) break; } if (!found) { util_out_print("Error: region not found.",TRUE); gd_header = temp_gdaddr; return; } if (ptr == gv_cur_region) { util_out_print("Error: already in region: !AD",TRUE,REG_LEN_STR(gv_cur_region)); gd_header = temp_gdaddr; return; } if (ptr->dyn.addr->acc_meth == dba_cm) { util_out_print("Error: Cannot edit an GT.CM database file.",TRUE); gd_header = temp_gdaddr; return; } if (ptr->dyn.addr->acc_meth == dba_usr) { util_out_print("Error: Cannot edit a non-GDS format database file.",TRUE); gd_header = temp_gdaddr; return; } if (!ptr->open) { util_out_print("Error: that region was not opened because it is not bound to any namespace.",TRUE); gd_header = temp_gdaddr; return; } if (TRUE == cs_addrs->now_crit) { util_out_print("Warning: now leaving region in critical section: !AD",TRUE, gv_cur_region->rname_len, gv_cur_region->rname); } gv_cur_region = ptr; gv_target = NULL; /* to prevent out-of-sync situations between gv_target and cs_addrs */ gv_currkey->base[0] = '\0'; /* prevent fast-path from op_gvname from being taken as region has been switched * and gv_target has been reset to NULL. */ gv_currkey->end = 0; /* clear end so it is in sync with base[0] */ switch (gv_cur_region->dyn.addr->acc_meth) { case dba_mm: case dba_bg: cs_addrs = &FILE_INFO(gv_cur_region)->s_addrs; cs_data = cs_addrs->hdr; break; default: GTMASSERT; } if (cs_addrs && cs_addrs->critical) crash_count = cs_addrs->critical->crashcnt; util_out_print("!/File !_!AD",TRUE, DB_LEN_STR(gv_cur_region)); util_out_print("Region!_!AD!/",TRUE, REG_LEN_STR(gv_cur_region)); patch_curr_blk = get_dir_root(); gv_init_reg(gv_cur_region); GET_SAVED_GDADDR(gd_header, temp_gdaddr, map, gv_cur_region); return; }
/* NOTE: WHY BOTH old_data and dummy_data? */ cce_show_file() { char fn[256]; struct FAB ccpfab; struct XABFHC xab; sgmnt_data *old_data, *dummy_data; sgmnt_addrs *cs; short iosb[4]; unsigned short fn_len; short unsigned timlen; struct dsc$descriptor_s time_desc; int4 status, size, cluster; unsigned char *c; unsigned char outbuf[80]; int outbufidx; $DESCRIPTOR(output_qualifier, "OUTPUT"); error_def(ERR_CCERDERR); error_def(ERR_CCEBADFN); error_def(ERR_DBOPNERR); error_def(ERR_DBNOTGDS); error_def(ERR_BADDBVER); error_def(ERR_CCEBGONLY); fn_len = SIZEOF(fn); if (!cli_get_str("FILE",fn,&fn_len)) { lib$signal(ERR_CCEBADFN); return; } ccpfab = cc$rms_fab; ccpfab.fab$l_fna = fn; ccpfab.fab$b_fns = fn_len; ccpfab.fab$b_fac = FAB$M_BIO | FAB$M_GET; ccpfab.fab$b_shr = FAB$M_SHRPUT | FAB$M_SHRGET | FAB$M_UPI; ccpfab.fab$l_fop = FAB$M_UFO; xab = cc$rms_xabfhc; ccpfab.fab$l_xab = &xab; status = sys$open(&ccpfab); if (status != RMS$_NORMAL) { lib$signal(ERR_DBOPNERR, 2, ccpfab.fab$b_fns, ccpfab.fab$l_fna, status); return; } dummy_data = malloc(512); status = sys$qiow(EFN$C_ENF, ccpfab.fab$l_stv, IO$_READVBLK, iosb, 0, 0, dummy_data, 512, 1, 0, 0, 0); if (status & 1) status = iosb[0]; if ((status & 1) == 0) { lib$signal(ERR_CCERDERR, 2, ccpfab.fab$b_fns, ccpfab.fab$l_fna, status); sys$dassgn(ccpfab.fab$l_stv); return; } if (memcmp(&dummy_data->label[0], GDS_LABEL, 12)) { if (memcmp(&dummy_data->label[0], GDS_LABEL, 9)) lib$signal (ERR_DBNOTGDS, 2, ccpfab.fab$b_fns, ccpfab.fab$l_fna); else lib$signal (ERR_BADDBVER, 2, ccpfab.fab$b_fns, ccpfab.fab$l_fna); status = sys$dassgn(ccpfab.fab$l_stv); assert(status & 1); return; } if (dummy_data->acc_meth != dba_bg) { lib$signal(ERR_CCEBGONLY); status = sys$dassgn(ccpfab.fab$l_stv); assert(status & 1); return; } size = (((SIZEOF(sgmnt_data)) + 511)/512) * 512; old_data = malloc(size); status = sys$qiow(EFN$C_ENF, ccpfab.fab$l_stv, IO$_READVBLK, iosb, 0, 0, old_data, size, 1, 0, 0, 0); if (status & 1) status = iosb[0]; if ((status & 1) == 0) { lib$signal(ERR_CCERDERR, 2, ccpfab.fab$b_fns, ccpfab.fab$l_fna, status); status = sys$dassgn(ccpfab.fab$l_stv); assert(status & 1); return; } outbufidx = 0; util_out_open(&output_qualifier); PUTLIT("Database file "); PUTSTR(fn, fn_len); PUTLIT(" is "); if (!old_data->clustered) { PUTLIT(" NOT "); } PUTLIT(" a cluster database"); util_out_write(outbuf, outbufidx); time_desc.dsc$b_dtype = DSC$K_DTYPE_T; time_desc.dsc$b_class = DSC$K_CLASS_S; time_desc.dsc$a_pointer = &outbuf[20]; time_desc.dsc$w_length = 40; PUTTIM("STALE_INTERVAL", old_data->staleness); PUTTIM("RESPONSE_INTERVAL",old_data->ccp_response_interval); PUTTIM("QUANTUM_INTERVAL", old_data->ccp_quantum_interval); PUTTIM("TICK_INTERVAL", old_data->ccp_tick_interval); util_out_close(); status = sys$dassgn(ccpfab.fab$l_stv); assert(status & 1); free(dummy_data); free(old_data); return; }
void dse_open (void) { unsigned short cli_len; int4 save_errno; mval val; mval pars; int cnt; static readonly unsigned char open_params_list[2] = { (unsigned char)iop_newversion, (unsigned char)iop_eol }; if (cli_present("FILE") == CLI_PRESENT) { if (CLOSED_FMT != dse_dmp_format) { util_out_print("Error: output file already open.",TRUE); util_out_print("Current output file: !AD", TRUE, strlen(patch_ofile), &patch_ofile[0]); return; } cli_len = sizeof(patch_ofile); if (!cli_get_str("FILE", patch_ofile, &cli_len)) return; if (0 == cli_len) { util_out_print("Error: must specify a file name.",TRUE); return; } patch_ofile[cli_len] = 0; patch_len = cli_len; pars.mvtype = MV_STR; pars.str.len = sizeof(open_params_list); pars.str.addr = (char *)open_params_list; val.mvtype = MV_STR; val.str.len = patch_len; val.str.addr = (char *)patch_ofile; (*op_open_ptr)(&val, &pars, 0, NULL); op_use(&val, &pars); if (CLI_PRESENT == cli_present("OCHSET")) { if (cli_get_str("OCHSET", ch_set_name, &cli_len)) { if (0 == cli_len) { util_out_print("Error: must specify a charactor set name.",TRUE); return; } ch_set_name[cli_len] = 0; ch_set_len = cli_len; if ( (iconv_t)0 != dse_over_cvtcd ) { ICONV_CLOSE_CD(dse_over_cvtcd); } ICONV_OPEN_CD(dse_over_cvtcd, INSIDE_CH_SET, ch_set_name); } } else if ( (iconv_t) 0 == dse_over_cvtcd ) ICONV_OPEN_CD(dse_over_cvtcd, INSIDE_CH_SET, OUTSIDE_CH_SET); dse_dmp_format = OPEN_FMT; } else { if (CLOSED_FMT != dse_dmp_format) util_out_print("Current output file: !AD", TRUE, strlen(patch_ofile), &patch_ofile[0]); else util_out_print("No current output file.",TRUE); } return; }
int gtmsource_get_opt(void) { boolean_t secondary, dotted_notation; int tries, index = 0; unsigned short secondary_len; char secondary_sys[MAX_SECONDARY_LEN], *c; struct hostent *sec_hostentry; boolean_t log, log_interval_specified; unsigned short log_file_len; boolean_t buffsize_status; boolean_t filter; unsigned short filter_cmd_len; int timeout_status; unsigned short statslog_val_len; char statslog_val[4]; /* "ON" or "OFF" */ unsigned short update_val_len; char update_val[SIZEOF("DISABLE")]; /* "ENABLE" or "DISABLE" */ unsigned short connect_parms_str_len; char *connect_parms_str, tmp_connect_parms_str[GTMSOURCE_CONN_PARMS_LEN + 1]; char *connect_parm_token_str, *connect_parm; int connect_parms_index; boolean_t connect_parms_badval; memset((char *)>msource_options, 0, SIZEOF(gtmsource_options)); gtmsource_options.start = (cli_present("START") == CLI_PRESENT); gtmsource_options.shut_down = (cli_present("SHUTDOWN") == CLI_PRESENT); gtmsource_options.activate = (cli_present("ACTIVATE") == CLI_PRESENT); gtmsource_options.deactivate = (cli_present("DEACTIVATE") == CLI_PRESENT); gtmsource_options.checkhealth = (cli_present("CHECKHEALTH") == CLI_PRESENT); gtmsource_options.statslog = (cli_present("STATSLOG") == CLI_PRESENT); gtmsource_options.showbacklog = (cli_present("SHOWBACKLOG") == CLI_PRESENT); gtmsource_options.changelog = (cli_present("CHANGELOG") == CLI_PRESENT); gtmsource_options.stopsourcefilter = (cli_present("STOPSOURCEFILTER") == CLI_PRESENT); gtmsource_options.update = (cli_present("UPDATE") == CLI_PRESENT); if (gtmsource_options.start || gtmsource_options.activate) { if (secondary = (CLI_PRESENT == cli_present("SECONDARY"))) { secondary_len = MAX_SECONDARY_LEN; if (!cli_get_str("SECONDARY", secondary_sys, &secondary_len)) { util_out_print("Error parsing SECONDARY qualifier", TRUE); return(-1); } /* Parse secondary_sys into secondary_host * and secondary_port */ c = secondary_sys; dotted_notation = TRUE; while(*c && *c != ':') { if ('.' != *c && !ISDIGIT(*c)) dotted_notation = FALSE; gtmsource_options.secondary_host[index++] = *c++; } gtmsource_options.secondary_host[index] = '\0'; if (':' != *c) { util_out_print("Secondary port number should be specified", TRUE); return(-1); } errno = 0; if (((0 == (gtmsource_options.secondary_port = ATOI(++c))) && (0 != errno)) || (0 >= gtmsource_options.secondary_port)) { util_out_print("Error parsing secondary port number !AD", TRUE, LEN_AND_STR(c)); return(-1); } /* Validate the specified secondary host name */ if (dotted_notation) { if ((in_addr_t)-1 == (gtmsource_options.sec_inet_addr = INET_ADDR(gtmsource_options.secondary_host))) { util_out_print("Invalid IP address !AD", TRUE, LEN_AND_STR(gtmsource_options.secondary_host)); return(-1); } } else { for (tries = 0; tries < MAX_GETHOST_TRIES && !(sec_hostentry = GETHOSTBYNAME(gtmsource_options.secondary_host)) && h_errno == TRY_AGAIN; tries++); if (NULL == sec_hostentry) { util_out_print("Could not find IP address for !AD", TRUE, LEN_AND_STR(gtmsource_options.secondary_host)); return(-1); } gtmsource_options.sec_inet_addr = ((struct in_addr *)sec_hostentry->h_addr_list[0])->s_addr; } } if (CLI_PRESENT == cli_present("CONNECTPARAMS")) { connect_parms_str_len = GTMSOURCE_CONN_PARMS_LEN + 1; if (!cli_get_str("CONNECTPARAMS", tmp_connect_parms_str, &connect_parms_str_len)) { util_out_print("Error parsing CONNECTPARAMS qualifier", TRUE); return(-1); } #ifdef VMS /* strip the quotes around the string. (DCL doesn't do it) */ assert('"' == tmp_connect_parms_str[0]); assert('"' == tmp_connect_parms_str[connect_parms_str_len - 1]); connect_parms_str = &tmp_connect_parms_str[1]; tmp_connect_parms_str[connect_parms_str_len - 1] = '\0'; #else connect_parms_str = &tmp_connect_parms_str[0]; #endif for (connect_parms_index = GTMSOURCE_CONN_HARD_TRIES_COUNT, connect_parms_badval = FALSE, connect_parm_token_str = connect_parms_str; !connect_parms_badval && connect_parms_index < GTMSOURCE_CONN_PARMS_COUNT && (connect_parm = strtok(connect_parm_token_str, GTMSOURCE_CONN_PARMS_DELIM)) != NULL; connect_parms_index++, connect_parm_token_str = NULL) { errno = 0; if ((0 == (gtmsource_options.connect_parms[connect_parms_index] = ATOI(connect_parm)) && 0 != errno) || 0 >= gtmsource_options.connect_parms[connect_parms_index]) connect_parms_badval = TRUE; } if (connect_parms_badval) { util_out_print("Error parsing or invalid value parameter in CONNECTPARAMS", TRUE); return(-1); } if (GTMSOURCE_CONN_PARMS_COUNT != connect_parms_index) { util_out_print( "All CONNECTPARAMS - HARD TRIES, HARD TRIES PERIOD, " "SOFT TRIES PERIOD, " "ALERT TIME, HEARTBEAT INTERVAL, " "MAX HEARBEAT WAIT should be specified", TRUE); return(-1); } } else { gtmsource_options.connect_parms[GTMSOURCE_CONN_HARD_TRIES_COUNT] = REPL_CONN_HARD_TRIES_COUNT; gtmsource_options.connect_parms[GTMSOURCE_CONN_HARD_TRIES_PERIOD] = REPL_CONN_HARD_TRIES_PERIOD; gtmsource_options.connect_parms[GTMSOURCE_CONN_SOFT_TRIES_PERIOD] = REPL_CONN_SOFT_TRIES_PERIOD; gtmsource_options.connect_parms[GTMSOURCE_CONN_ALERT_PERIOD] = REPL_CONN_ALERT_ALERT_PERIOD; gtmsource_options.connect_parms[GTMSOURCE_CONN_HEARTBEAT_PERIOD] = REPL_CONN_HEARTBEAT_PERIOD; gtmsource_options.connect_parms[GTMSOURCE_CONN_HEARTBEAT_MAX_WAIT] = REPL_CONN_HEARTBEAT_MAX_WAIT; } if (gtmsource_options.connect_parms[GTMSOURCE_CONN_ALERT_PERIOD]< gtmsource_options.connect_parms[GTMSOURCE_CONN_SOFT_TRIES_PERIOD]) gtmsource_options.connect_parms[GTMSOURCE_CONN_ALERT_PERIOD] = gtmsource_options.connect_parms[GTMSOURCE_CONN_SOFT_TRIES_PERIOD]; if (gtmsource_options.connect_parms[GTMSOURCE_CONN_HEARTBEAT_MAX_WAIT] < gtmsource_options.connect_parms[GTMSOURCE_CONN_HEARTBEAT_PERIOD]) gtmsource_options.connect_parms[GTMSOURCE_CONN_HEARTBEAT_MAX_WAIT] = gtmsource_options.connect_parms[GTMSOURCE_CONN_HEARTBEAT_PERIOD]; } if (gtmsource_options.start || gtmsource_options.statslog || gtmsource_options.changelog || gtmsource_options.activate || gtmsource_options.deactivate) { log = (cli_present("LOG") == CLI_PRESENT); log_interval_specified = (CLI_PRESENT == cli_present("LOG_INTERVAL")); if (log) { log_file_len = MAX_FN_LEN + 1; if (!cli_get_str("LOG", gtmsource_options.log_file, &log_file_len)) { util_out_print("Error parsing LOG qualifier", TRUE); return(-1); } } else gtmsource_options.log_file[0] = '\0'; gtmsource_options.src_log_interval = 0; if (log_interval_specified) { if (!cli_get_num("LOG_INTERVAL", (int4 *)>msource_options.src_log_interval)) { util_out_print("Error parsing LOG_INTERVAL qualifier", TRUE); return (-1); } } if (gtmsource_options.start && 0 == gtmsource_options.src_log_interval) gtmsource_options.src_log_interval = LOGTRNUM_INTERVAL; /* For changelog/activate/deactivate, interval == 0 implies don't change log interval already established */ /* We ignore interval specification for statslog, Vinaya 2005/02/07 */ } if (gtmsource_options.start) { assert(secondary || CLI_PRESENT == cli_present("PASSIVE")); gtmsource_options.mode = ((secondary) ? GTMSOURCE_MODE_ACTIVE : GTMSOURCE_MODE_PASSIVE); if (buffsize_status = (CLI_PRESENT == cli_present("BUFFSIZE"))) { if (!cli_get_int("BUFFSIZE", >msource_options.buffsize)) { util_out_print("Error parsing BUFFSIZE qualifier", TRUE); return(-1); } if (MIN_JNLPOOL_SIZE > gtmsource_options.buffsize) gtmsource_options.buffsize = MIN_JNLPOOL_SIZE; } else gtmsource_options.buffsize = DEFAULT_JNLPOOL_SIZE; /* Round up buffsize to the nearest (~JNL_WRT_END_MASK + 1) multiple */ gtmsource_options.buffsize = ((gtmsource_options.buffsize + ~JNL_WRT_END_MASK) & JNL_WRT_END_MASK); if (filter = (CLI_PRESENT == cli_present("FILTER"))) { filter_cmd_len = MAX_FILTER_CMD_LEN; if (!cli_get_str("FILTER", gtmsource_options.filter_cmd, &filter_cmd_len)) { util_out_print("Error parsing FILTER qualifier", TRUE); return(-1); } } else gtmsource_options.filter_cmd[0] = '\0'; } if (gtmsource_options.shut_down) { if ((timeout_status = cli_present("TIMEOUT")) == CLI_PRESENT) { if (!cli_get_int("TIMEOUT", >msource_options.shutdown_time)) { util_out_print("Error parsing TIMEOUT qualifier", TRUE); return(-1); } if (DEFAULT_SHUTDOWN_TIMEOUT < gtmsource_options.shutdown_time || 0 > gtmsource_options.shutdown_time) { gtmsource_options.shutdown_time = DEFAULT_SHUTDOWN_TIMEOUT; util_out_print("shutdown TIMEOUT changed to !UL", TRUE, gtmsource_options.shutdown_time); } } else if (CLI_NEGATED == timeout_status) gtmsource_options.shutdown_time = -1; else /* TIMEOUT not specified */ gtmsource_options.shutdown_time = DEFAULT_SHUTDOWN_TIMEOUT; } if (gtmsource_options.statslog) { statslog_val_len = 4; /* max(strlen("ON"), strlen("OFF")) + 1 */ if (!cli_get_str("STATSLOG", statslog_val, &statslog_val_len)) { util_out_print("Error parsing STATSLOG qualifier", TRUE); return(-1); } UNIX_ONLY(cli_strupper(statslog_val);) if (0 == strcmp(statslog_val, "ON"))
int4 mupip_set_file(int db_fn_len, char *db_fn) { bool got_standalone; boolean_t bypass_partial_recov, need_standalone = FALSE; char acc_spec[MAX_ACC_METH_LEN], ver_spec[MAX_DB_VER_LEN], exit_stat, *fn; unsigned short acc_spec_len = MAX_ACC_METH_LEN, ver_spec_len = MAX_DB_VER_LEN; int fd, fn_len; int4 status; int4 status1; int glbl_buff_status, defer_status, rsrvd_bytes_status, extn_count_status, lock_space_status, disk_wait_status; int4 new_disk_wait, new_cache_size, new_extn_count, new_lock_space, reserved_bytes, defer_time; sgmnt_data_ptr_t csd; tp_region *rptr, single; enum db_acc_method access, access_new; enum db_ver desired_dbver; gd_region *temp_cur_region; char *errptr, *command = "MUPIP SET VERSION"; int save_errno; error_def(ERR_DBPREMATEOF); error_def(ERR_DBRDERR); error_def(ERR_DBRDONLY); error_def(ERR_INVACCMETHOD); error_def(ERR_MUNOACTION); error_def(ERR_RBWRNNOTCHG); error_def(ERR_WCERRNOTCHG); error_def(ERR_WCWRNNOTCHG); error_def(ERR_MMNODYNDWNGRD); exit_stat = EXIT_NRM; defer_status = cli_present("DEFER_TIME"); if (defer_status) need_standalone = TRUE; bypass_partial_recov = cli_present("PARTIAL_RECOV_BYPASS") == CLI_PRESENT; if (bypass_partial_recov) need_standalone = TRUE; if (disk_wait_status = cli_present("WAIT_DISK")) { if (cli_get_int("WAIT_DISK", &new_disk_wait)) { if (new_disk_wait < 0) { util_out_print("!UL negative, minimum WAIT_DISK allowed is 0.", TRUE, new_disk_wait); return (int4)ERR_WCWRNNOTCHG; } need_standalone = TRUE; } else { util_out_print("Error getting WAIT_DISK qualifier value", TRUE); return (int4)ERR_WCWRNNOTCHG; } } if (glbl_buff_status = cli_present("GLOBAL_BUFFERS")) { if (cli_get_int("GLOBAL_BUFFERS", &new_cache_size)) { if (new_cache_size > WC_MAX_BUFFS) { util_out_print("!UL too large, maximum write cache buffers allowed is !UL", TRUE, new_cache_size, WC_MAX_BUFFS); return (int4)ERR_WCWRNNOTCHG; } if (new_cache_size < WC_MIN_BUFFS) { util_out_print("!UL too small, minimum cache buffers allowed is !UL", TRUE, new_cache_size, WC_MIN_BUFFS); return (int4)ERR_WCWRNNOTCHG; } } else { util_out_print("Error getting GLOBAL BUFFER qualifier value", TRUE); return (int4)ERR_WCWRNNOTCHG; } need_standalone = TRUE; } /* EXTENSION_COUNT does not require standalone access and hence need_standalone will not be set to TRUE for this. */ if (extn_count_status = cli_present("EXTENSION_COUNT")) { if (cli_get_int("EXTENSION_COUNT", &new_extn_count)) { if (new_extn_count > MAX_EXTN_COUNT) { util_out_print("!UL too large, maximum extension count allowed is !UL", TRUE, new_extn_count, MAX_EXTN_COUNT); return (int4)ERR_WCWRNNOTCHG; } if (new_extn_count < MIN_EXTN_COUNT) { util_out_print("!UL too small, minimum extension count allowed is !UL", TRUE, new_extn_count, MIN_EXTN_COUNT); return (int4)ERR_WCWRNNOTCHG; } } else { util_out_print("Error getting EXTENSION COUNT qualifier value", TRUE); return (int4)ERR_WCWRNNOTCHG; } } if (lock_space_status = cli_present("LOCK_SPACE")) { if (cli_get_int("LOCK_SPACE", &new_lock_space)) { if (new_lock_space > MAX_LOCK_SPACE) { util_out_print("!UL too large, maximum lock space allowed is !UL", TRUE, new_lock_space, MAX_LOCK_SPACE); return (int4)ERR_WCWRNNOTCHG; } else if (new_lock_space < MIN_LOCK_SPACE) { util_out_print("!UL too small, minimum lock space allowed is !UL", TRUE, new_lock_space, MIN_LOCK_SPACE); return (int4)ERR_WCWRNNOTCHG; } } else { util_out_print("Error getting LOCK_SPACE qualifier value", TRUE); return (int4)ERR_WCWRNNOTCHG; } need_standalone = TRUE; } if (rsrvd_bytes_status = cli_present("RESERVED_BYTES")) { if (!cli_get_int("RESERVED_BYTES", &reserved_bytes)) { util_out_print("Error getting RESERVED BYTES qualifier value", TRUE); return (int4)ERR_RBWRNNOTCHG; } need_standalone = TRUE; } if (cli_present("ACCESS_METHOD")) { cli_get_str("ACCESS_METHOD", acc_spec, &acc_spec_len); cli_strupper(acc_spec); if (0 == memcmp(acc_spec, "MM", acc_spec_len)) access = dba_mm; else if (0 == memcmp(acc_spec, "BG", acc_spec_len)) access = dba_bg; else mupip_exit(ERR_INVACCMETHOD); need_standalone = TRUE; } else access = n_dba; /* really want to keep current method, which has not yet been read */ if (cli_present("VERSION")) { assert(!need_standalone); cli_get_str("VERSION", ver_spec, &ver_spec_len); cli_strupper(ver_spec); if (0 == memcmp(ver_spec, "V4", ver_spec_len)) desired_dbver = GDSV4; else if (0 == memcmp(ver_spec, "V5", ver_spec_len)) desired_dbver = GDSV5; else GTMASSERT; /* CLI should prevent us ever getting here */ } else desired_dbver = GDSVLAST; /* really want to keep version, which has not yet been read */ if (region) rptr = grlist; else { rptr = &single; memset(&single, 0, sizeof(single)); } csd = (sgmnt_data *)malloc(ROUND_UP(sizeof(sgmnt_data), DISK_BLOCK_SIZE)); in_backup = FALSE; /* Only want yes/no from mupfndfil, not an address */ for (; rptr != NULL; rptr = rptr->fPtr) { if (region) { if (dba_usr == rptr->reg->dyn.addr->acc_meth) { util_out_print("!/Region !AD is not a GDS access type", TRUE, REG_LEN_STR(rptr->reg)); exit_stat |= EXIT_WRN; continue; } if (!mupfndfil(rptr->reg, NULL)) continue; fn = (char *)rptr->reg->dyn.addr->fname; fn_len = rptr->reg->dyn.addr->fname_len; } else { fn = db_fn; fn_len = db_fn_len; } mu_gv_cur_reg_init(); strcpy((char *)gv_cur_region->dyn.addr->fname, fn); gv_cur_region->dyn.addr->fname_len = fn_len; if (!need_standalone) { gvcst_init(gv_cur_region); change_reg(); /* sets cs_addrs and cs_data */ if (gv_cur_region->read_only) { gtm_putmsg(VARLSTCNT(4) ERR_DBRDONLY, 2, DB_LEN_STR(gv_cur_region)); exit_stat |= EXIT_ERR; gds_rundown(); mu_gv_cur_reg_free(); continue; } grab_crit(gv_cur_region); status = EXIT_NRM; access_new = (n_dba == access ? cs_data->acc_meth : access); /* recalculate; n_dba is a proxy for no change */ change_fhead_timer("FLUSH_TIME", cs_data->flush_time, (dba_bg == access_new ? TIM_FLU_MOD_BG : TIM_FLU_MOD_MM), FALSE); if (GDSVLAST != desired_dbver) { if ((dba_mm != access_new) || (GDSV4 != desired_dbver)) status1 = desired_db_format_set(gv_cur_region, desired_dbver, command); else { status1 = ERR_MMNODYNDWNGRD; gtm_putmsg(VARLSTCNT(4) status1, 2, REG_LEN_STR(gv_cur_region)); } if (SS_NORMAL != status1) { /* "desired_db_format_set" would have printed appropriate error messages */ if (ERR_MUNOACTION != status1) { /* real error occurred while setting the db format. skip to next region */ status = EXIT_ERR; } } } if (EXIT_NRM == status) { if (extn_count_status) cs_data->extension_size = (uint4)new_extn_count; wcs_flu(WCSFLU_FLUSH_HDR); if (extn_count_status) util_out_print("Database file !AD now has extension count !UL", TRUE, fn_len, fn, cs_data->extension_size); if (GDSVLAST != desired_dbver) util_out_print("Database file !AD now has desired DB format !AD", TRUE, fn_len, fn, LEN_AND_STR(gtm_dbversion_table[cs_data->desired_db_format])); } else exit_stat |= status; rel_crit(gv_cur_region); gds_rundown(); } else { /* Following part needs standalone access */ assert(GDSVLAST == desired_dbver); got_standalone = mu_rndwn_file(gv_cur_region, TRUE); if (FALSE == got_standalone) return (int4)ERR_WCERRNOTCHG; /* we should open it (for changing) after mu_rndwn_file, since mu_rndwn_file changes the file header too */ if (-1 == (fd = OPEN(fn, O_RDWR))) { save_errno = errno; errptr = (char *)STRERROR(save_errno); util_out_print("open : !AZ", TRUE, errptr); exit_stat |= EXIT_ERR; db_ipcs_reset(gv_cur_region, FALSE); mu_gv_cur_reg_free(); continue; } LSEEKREAD(fd, 0, csd, sizeof(sgmnt_data), status); if (0 != status) { save_errno = errno; PERROR("Error reading header of file"); errptr = (char *)STRERROR(save_errno); util_out_print("read : !AZ", TRUE, errptr); util_out_print("Error reading header of file", TRUE); util_out_print("Database file !AD not changed: ", TRUE, fn_len, fn); if (-1 != status) rts_error(VARLSTCNT(4) ERR_DBRDERR, 2, fn_len, fn); else rts_error(VARLSTCNT(4) ERR_DBPREMATEOF, 2, fn_len, fn); } if (rsrvd_bytes_status) { if (reserved_bytes > MAX_RESERVE_B(csd)) { util_out_print("!UL too large, maximum reserved bytes allowed is !UL for database file !AD", TRUE, reserved_bytes, MAX_RESERVE_B(csd), fn_len, fn); close(fd); db_ipcs_reset(gv_cur_region, FALSE); return (int4)ERR_RBWRNNOTCHG; } csd->reserved_bytes = reserved_bytes; } access_new = (n_dba == access ? csd->acc_meth : access); /* recalculate; n_dba is a proxy for no change */ change_fhead_timer("FLUSH_TIME", csd->flush_time, (dba_bg == access_new ? TIM_FLU_MOD_BG : TIM_FLU_MOD_MM), FALSE); if ((n_dba != access) && (csd->acc_meth != access)) /* n_dba is a proxy for no change */ { if (dba_mm == access) csd->defer_time = 1; /* defer defaults to 1 */ csd->acc_meth = access; if (0 == csd->n_bts) { csd->n_bts = WC_DEF_BUFFS; csd->bt_buckets = getprime(csd->n_bts); } } if (glbl_buff_status) { csd->n_bts = BT_FACTOR(new_cache_size); csd->bt_buckets = getprime(csd->n_bts); csd->n_wrt_per_flu = 7; csd->flush_trigger = FLUSH_FACTOR(csd->n_bts); } if (disk_wait_status) csd->wait_disk_space = new_disk_wait; if (extn_count_status) csd->extension_size = (uint4)new_extn_count; if (lock_space_status) csd->lock_space_size = (uint4)new_lock_space * OS_PAGELET_SIZE; if (bypass_partial_recov) { csd->file_corrupt = FALSE; util_out_print("Database file !AD now has partial recovery flag set to !UL(FALSE) ", TRUE, fn_len, fn, csd->file_corrupt); } if (dba_mm == access_new) { if (CLI_NEGATED == defer_status) csd->defer_time = 0; else if (CLI_PRESENT == defer_status) { if (!cli_get_num("DEFER_TIME", &defer_time)) { util_out_print("Error getting DEFER_TIME qualifier value", TRUE); db_ipcs_reset(gv_cur_region, FALSE); return (int4)ERR_RBWRNNOTCHG; } if (-1 > defer_time) { util_out_print("DEFER_TIME cannot take negative values less than -1", TRUE); util_out_print("Database file !AD not changed", TRUE, fn_len, fn); exit_stat |= EXIT_WRN; db_ipcs_reset(gv_cur_region, FALSE); mu_gv_cur_reg_free(); continue; } csd->defer_time = defer_time; } if (csd->blks_to_upgrd) { util_out_print("MM access method cannot be set if there are blocks to upgrade", TRUE); util_out_print("Database file !AD not changed", TRUE, fn_len, fn); exit_stat |= EXIT_WRN; db_ipcs_reset(gv_cur_region, FALSE); mu_gv_cur_reg_free(); continue; } if (GDSVCURR != csd->desired_db_format) { util_out_print("MM access method cannot be set in DB compatibility mode", TRUE); util_out_print("Database file !AD not changed", TRUE, fn_len, fn); exit_stat |= EXIT_WRN; db_ipcs_reset(gv_cur_region, FALSE); mu_gv_cur_reg_free(); continue; } if (JNL_ENABLED(csd) && csd->jnl_before_image) { util_out_print("MM access method cannot be set with BEFORE image journaling", TRUE); util_out_print("Database file !AD not changed", TRUE, fn_len, fn); exit_stat |= EXIT_WRN; db_ipcs_reset(gv_cur_region, FALSE); mu_gv_cur_reg_free(); continue; } csd->jnl_before_image = FALSE; } else { if (defer_status) { util_out_print("DEFER cannot be specified with BG access method.", TRUE); util_out_print("Database file !AD not changed", TRUE, fn_len, fn); exit_stat |= EXIT_WRN; db_ipcs_reset(gv_cur_region, FALSE); mu_gv_cur_reg_free(); continue; } } LSEEKWRITE(fd, 0, csd, sizeof(sgmnt_data), status); if (0 != status) { save_errno = errno; errptr = (char *)STRERROR(save_errno); util_out_print("write : !AZ", TRUE, errptr); util_out_print("Error writing header of file", TRUE); util_out_print("Database file !AD not changed: ", TRUE, fn_len, fn); rts_error(VARLSTCNT(4) ERR_DBRDERR, 2, fn_len, fn); } close(fd); /* --------------------- report results ------------------------- */ if (glbl_buff_status) util_out_print("Database file !AD now has !UL global buffers", TRUE, fn_len, fn, csd->n_bts); if (defer_status && (dba_mm == csd->acc_meth)) util_out_print("Database file !AD now has defer_time set to !SL", TRUE, fn_len, fn, csd->defer_time); if (rsrvd_bytes_status) util_out_print("Database file !AD now has !UL reserved bytes", TRUE, fn_len, fn, csd->reserved_bytes); if (extn_count_status) util_out_print("Database file !AD now has extension count !UL", TRUE, fn_len, fn, csd->extension_size); if (lock_space_status) util_out_print("Database file !AD now has lock space !UL pages", TRUE, fn_len, fn, csd->lock_space_size/OS_PAGELET_SIZE); if (disk_wait_status) util_out_print("Database file !AD now has wait disk set to !UL seconds", TRUE, fn_len, fn, csd->wait_disk_space); db_ipcs_reset(gv_cur_region, FALSE); } /* end of else part if (!need_standalone) */ mu_gv_cur_reg_free(); } free(csd); assert(!(exit_stat & EXIT_INF)); return (exit_stat & EXIT_ERR ? (int4)ERR_WCERRNOTCHG : (exit_stat & EXIT_WRN ? (int4)ERR_WCWRNNOTCHG : SS_NORMAL)); }
void cce_cluster(void ) { enum db_ver database; char fn[256]; struct FAB ccpfab; struct XABFHC xab; sgmnt_data *old_data, *dummy_data; short iosb[4]; unsigned short fn_len; int4 status, size, cluster, space_needed; error_def(ERR_CCERDERR); error_def(ERR_CCEWRTERR); error_def(ERR_CCEDBCL); error_def(ERR_CCEDBNTCL); error_def(ERR_CCEBADFN); error_def(ERR_DBOPNERR); error_def(ERR_DBNOTGDS); error_def(ERR_BADDBVER); error_def(ERR_CCEBGONLY); $DESCRIPTOR(cluster_qualifier, "CLUSTER"); fn_len = SIZEOF(fn); if (!cli_get_str("FILE",fn,&fn_len)) { lib$signal(ERR_CCEBADFN); return; } ccpfab = cc$rms_fab; ccpfab.fab$l_fna = fn; ccpfab.fab$b_fns = fn_len; ccpfab.fab$b_fac = FAB$M_BIO | FAB$M_GET | FAB$M_PUT; ccpfab.fab$l_fop = FAB$M_UFO; xab = cc$rms_xabfhc; ccpfab.fab$l_xab = &xab; status = sys$open(&ccpfab); if (status != RMS$_NORMAL) { lib$signal(ERR_DBOPNERR, 2, ccpfab.fab$b_fns, ccpfab.fab$l_fna, status); return; } dummy_data = malloc(ROUND_UP(SIZEOF(sgmnt_data), OS_PAGELET_SIZE)); status = sys$qiow(EFN$C_ENF, ccpfab.fab$l_stv, IO$_READVBLK, iosb, 0, 0, dummy_data, ROUND_UP(SIZEOF(sgmnt_data), OS_PAGELET_SIZE), 1,0,0,0); if (status & 1) status = iosb[0]; if ((status & 1) == 0) { lib$signal(ERR_CCERDERR, 2, ccpfab.fab$b_fns, ccpfab.fab$l_fna, status); sys$dassgn(ccpfab.fab$l_stv); free(dummy_data); return; } /* Commented out as this is unused code and we are removing the old version database references (SE - 4/2005 V5.0) if (memcmp(&dummy_data->label[0], GDS_LABEL, GDS_LABEL_SZ)) { if (memcmp(&dummy_data->label[0], GDS_LABEL, GDS_LABEL_SZ - 3)) { lib$signal (ERR_DBNOTGDS, 2, ccpfab.fab$b_fns, ccpfab.fab$l_fna); status = sys$dassgn(ccpfab.fab$l_stv); assert(status & 1); free(dummy_data); return; }else { if (!memcmp(&dummy_data->label[GDS_LABEL_SZ - 3],GDS_V23,2)) database = v23; else if (!memcmp(&dummy_data->label[GDS_LABEL_SZ - 3],GDS_V24,2)) database = v24; else if (!memcmp(&dummy_data->label[GDS_LABEL_SZ - 3],GDS_V25,2)) database = v25; else if (!memcmp(&dummy_data->label[GDS_LABEL_SZ - 3],GDS_V254,2)) database = v254; else lib$signal (ERR_BADDBVER, 2, ccpfab.fab$b_fns, ccpfab.fab$l_fna); } } else database = v255; */ if (dummy_data->acc_meth != dba_bg) { lib$signal(ERR_CCEBGONLY); status = sys$dassgn(ccpfab.fab$l_stv); assert(status & 1); free(dummy_data); return; } size = (LOCK_BLOCK(dummy_data) * DISK_BLOCK_SIZE) + LOCK_SPACE_SIZE(dummy_data); old_data = malloc(size); memcpy(old_data, dummy_data, SIZEOF(sgmnt_data)); cluster = cli$present(&cluster_qualifier); if (cluster == CLI$_NEGATED) old_data->clustered = FALSE; else if (cluster == CLI$_PRESENT) { old_data->clustered = TRUE; old_data->trans_hist.lock_sequence = 0; } change_fhead_timer("STALE_INTERVAL", old_data->staleness, -50000000, TRUE); change_fhead_timer("RESPONSE_INTERVAL",old_data->ccp_response_interval, -600000000, TRUE); change_fhead_timer("QUANTUM_INTERVAL", old_data->ccp_quantum_interval, -10000000, FALSE); change_fhead_timer("TICK_INTERVAL", old_data->ccp_tick_interval, -1000000, FALSE); if (old_data->unbacked_cache) { space_needed = (old_data->n_bts + getprime(old_data->n_bts) + 1) * SIZEOF(bt_rec); if (space_needed > old_data->free_space) { old_data->n_bts = old_data->free_space/(2*SIZEOF(bt_rec)); for (;;) { space_needed = (old_data->n_bts + getprime(old_data->n_bts) + 1) * SIZEOF(bt_rec); if (space_needed <= old_data->free_space) { old_data->bt_buckets = getprime(old_data->n_bts); break; } old_data->n_bts--; } util_out_open(0); util_out_print("Only have space for !UL cache records in clustered file !AD, adjusting file",TRUE, old_data->n_bts, fn_len, fn); } old_data->free_space -= space_needed; old_data->unbacked_cache = FALSE; } status = dbcx_ref(old_data, ccpfab.fab$l_stv); if ((status & 1) == 0) lib$signal(ERR_CCEWRTERR, 2, ccpfab.fab$b_fns, ccpfab.fab$l_fna, status); if (cluster != CLI$_ABSENT) lib$signal ((old_data->clustered) ? ERR_CCEDBCL : ERR_CCEDBNTCL, 2, ccpfab.fab$b_fns, ccpfab.fab$l_fna); status = sys$dassgn(ccpfab.fab$l_stv); assert(status & 1); free(dummy_data); free(old_data); return; }
int gtmrecv_get_opt(void) { boolean_t autorollback, cmplvl_status, filter, log, log_interval_specified, plaintext_fallback; char statslog_val[4]; /* "ON" or "OFF" */ gtm_int64_t buffsize; int status; uint4 n_readers, n_helpers; unsigned short filter_cmd_len, instfilename_len, instname_len, log_file_len, statslog_val_len, tlsid_len; gtmrecv_options.start = (CLI_PRESENT == cli_present("START")); gtmrecv_options.shut_down = (CLI_PRESENT == cli_present("SHUTDOWN")); gtmrecv_options.checkhealth = (CLI_PRESENT == cli_present("CHECKHEALTH")); gtmrecv_options.statslog = (CLI_PRESENT == cli_present("STATSLOG")); gtmrecv_options.showbacklog = (CLI_PRESENT == cli_present("SHOWBACKLOG")); gtmrecv_options.changelog = (CLI_PRESENT == cli_present("CHANGELOG")); gtmrecv_options.updateonly = (CLI_PRESENT == cli_present("UPDATEONLY")); gtmrecv_options.updateresync = (CLI_PRESENT == cli_present("UPDATERESYNC")); gtmrecv_options.reuse_specified = (CLI_PRESENT == cli_present("REUSE")); gtmrecv_options.resume_specified = (CLI_PRESENT == cli_present("RESUME")); gtmrecv_options.initialize_specified = (CLI_PRESENT == cli_present("INITIALIZE")); if (gtmrecv_options.updateresync) { instfilename_len = SIZEOF(gtmrecv_options.updresync_instfilename) - 1; /* keep 1 byte for trailing NULL */ /* Treat -UPDATERESYNC (with no value) as if -UPDATERESYNC="" was specified */ if (!cli_get_str("UPDATERESYNC", gtmrecv_options.updresync_instfilename, &instfilename_len)) { instfilename_len = 0; if (gtmrecv_options.reuse_specified) { util_out_print("Error: REUSE qualifier not allowed if UPDATERESYNC qualifier has no value", TRUE); return (-1); } } else if (gtmrecv_options.reuse_specified) { instname_len = SIZEOF(gtmrecv_options.reuse_instname) - 1; /* keep 1 byte for trailing NULL */ if (!cli_get_str("REUSE", gtmrecv_options.reuse_instname, &instname_len)) { util_out_print("Error parsing REUSE qualifier", TRUE); return (-1); } else { assert(SIZEOF(gtmrecv_options.reuse_instname) > instname_len); gtmrecv_options.reuse_instname[instname_len] = '\0'; } } assert(SIZEOF(gtmrecv_options.updresync_instfilename) > instfilename_len); gtmrecv_options.updresync_instfilename[instfilename_len] = '\0'; if (gtmrecv_options.resume_specified) { if (!cli_get_int("RESUME", >mrecv_options.resume_strm_num)) { util_out_print("Error parsing RESUME qualifier", TRUE); return (-1); } if ((0 >= gtmrecv_options.resume_strm_num) || (MAX_SUPPL_STRMS <= gtmrecv_options.resume_strm_num)) { util_out_print("RESUME qualifier should specify a stream number between 1 and 15 (both inclusive)", TRUE); return (-1); } } } gtmrecv_options.noresync = (CLI_PRESENT == cli_present("NORESYNC")); gtmrecv_options.helpers = (CLI_PRESENT == cli_present("HELPERS")); gtmrecv_options.listen_port = 0; /* invalid port; indicates listenport not specified */ if (gtmrecv_options.start && CLI_PRESENT == cli_present("LISTENPORT")) { if (!cli_get_int("LISTENPORT", >mrecv_options.listen_port)) { util_out_print("Error parsing LISTENPORT qualifier", TRUE); return (-1); } if (CLI_PRESENT == cli_present("BUFFSIZE")) { /* use a big conversion so we have a signed number for comparison */ if (!cli_get_int64("BUFFSIZE", &buffsize)) { util_out_print("Error parsing BUFFSIZE qualifier", TRUE); return(-1); } if (MIN_RECVPOOL_SIZE > buffsize) gtmrecv_options.buffsize = MIN_RECVPOOL_SIZE; else if ((gtm_int64_t)MAX_RECVPOOL_SIZE < buffsize) gtmrecv_options.buffsize = (uint4)MAX_RECVPOOL_SIZE; else gtmrecv_options.buffsize = (uint4)buffsize; } else gtmrecv_options.buffsize = DEFAULT_RECVPOOL_SIZE; /* Check if -autorollback is specified (default is -noautorollback) */ autorollback = cli_present("AUTOROLLBACK"); gtmrecv_options.autorollback = autorollback ? (CLI_NEGATED != autorollback) : FALSE; if (gtmrecv_options.autorollback) gtmrecv_options.autorollback_verbose = cli_present("AUTOROLLBACK.VERBOSE"); /* Check if compression level is specified */ if (cmplvl_status = (CLI_PRESENT == cli_present("CMPLVL"))) { if (!cli_get_int("CMPLVL", >mrecv_options.cmplvl)) { util_out_print("Error parsing CMPLVL qualifier", TRUE); return(-1); } if (GTM_CMPLVL_OUT_OF_RANGE(gtmrecv_options.cmplvl)) gtmrecv_options.cmplvl = ZLIB_CMPLVL_MIN; /* no compression in this case */ /* CMPLVL qualifier should override any value specified in the environment variable gtm_zlib_cmp_level */ gtm_zlib_cmp_level = gtmrecv_options.cmplvl; } else gtmrecv_options.cmplvl = ZLIB_CMPLVL_MIN; /* no compression in this case */ if (filter = (CLI_PRESENT == cli_present("FILTER"))) { filter_cmd_len = MAX_FILTER_CMD_LEN; if (!cli_get_str("FILTER", gtmrecv_options.filter_cmd, &filter_cmd_len)) { util_out_print("Error parsing FILTER qualifier", TRUE); return (-1); } } else gtmrecv_options.filter_cmd[0] = '\0'; gtmrecv_options.stopsourcefilter = (CLI_PRESENT == cli_present("STOPSOURCEFILTER")); /* Check if SSL/TLS secure communication is requested. */ # ifdef GTM_TLS if (CLI_PRESENT == cli_present("TLSID")) { tlsid_len = MAX_TLSID_LEN; if (!cli_get_str("TLSID", repl_tls.id, &tlsid_len)) { util_out_print("Error parsing TLSID qualifier", TRUE); return -1; } assert(0 < tlsid_len); /* Check if plaintext-fallback mode is specified. Default option is NOPLAINTEXTFALLBACK. */ if (CLI_PRESENT == (plaintext_fallback = cli_present("PLAINTEXTFALLBACK"))) repl_tls.plaintext_fallback = (plaintext_fallback != CLI_NEGATED); else repl_tls.plaintext_fallback = FALSE; } # endif } if ((gtmrecv_options.start && 0 != gtmrecv_options.listen_port) || gtmrecv_options.statslog || gtmrecv_options.changelog) { log = (CLI_PRESENT == cli_present("LOG")); log_interval_specified = (CLI_PRESENT == cli_present("LOG_INTERVAL")); if (log) { log_file_len = MAX_FN_LEN + 1; if (!cli_get_str("LOG", gtmrecv_options.log_file, &log_file_len)) { util_out_print("Error parsing LOG qualifier", TRUE); return (-1); } } else gtmrecv_options.log_file[0] = '\0'; gtmrecv_options.rcvr_log_interval = gtmrecv_options.upd_log_interval = 0; if (log_interval_specified && 0 == cli_parse_two_numbers("LOG_INTERVAL", GTMRECV_LOGINTERVAL_DELIM, >mrecv_options.rcvr_log_interval, >mrecv_options.upd_log_interval)) return (-1); if (gtmrecv_options.start) { if (0 == gtmrecv_options.rcvr_log_interval) gtmrecv_options.rcvr_log_interval = LOGTRNUM_INTERVAL; if (0 == gtmrecv_options.upd_log_interval) gtmrecv_options.upd_log_interval = LOGTRNUM_INTERVAL; } /* For changelog, interval == 0 implies don't change log interval already established */ /* We ignore interval specification for statslog, Vinaya 2005/02/07 */ } if (gtmrecv_options.shut_down) { if (CLI_PRESENT == (status = cli_present("TIMEOUT"))) { if (!cli_get_int("TIMEOUT", >mrecv_options.shutdown_time)) { util_out_print("Error parsing TIMEOUT qualifier", TRUE); return (-1); } if (DEFAULT_SHUTDOWN_TIMEOUT < gtmrecv_options.shutdown_time || 0 > gtmrecv_options.shutdown_time) { gtmrecv_options.shutdown_time = DEFAULT_SHUTDOWN_TIMEOUT; util_out_print("shutdown TIMEOUT changed to !UL", TRUE, gtmrecv_options.shutdown_time); } } else if (CLI_NEGATED == status) gtmrecv_options.shutdown_time = -1; else /* TIMEOUT not specified */ gtmrecv_options.shutdown_time = DEFAULT_SHUTDOWN_TIMEOUT; } if (gtmrecv_options.statslog) { statslog_val_len = 4; /* max(strlen("ON"), strlen("OFF")) + 1 */ if (!cli_get_str("STATSLOG", statslog_val, &statslog_val_len)) { util_out_print("Error parsing STATSLOG qualifier", TRUE); return (-1); } cli_strupper(statslog_val); if (0 == STRCMP(statslog_val, "ON")) gtmrecv_options.statslog = TRUE; else if (0 == STRCMP(statslog_val, "OFF")) gtmrecv_options.statslog = FALSE; else { util_out_print("Invalid value for STATSLOG qualifier, should be either ON or OFF", TRUE); return (-1); } } gtmrecv_options.n_readers = gtmrecv_options.n_writers = 0; if (gtmrecv_options.helpers && gtmrecv_options.start) { /* parse the helpers qualifier to find out how many readers and writes have to be started */ if (0 == (status = cli_parse_two_numbers("HELPERS", UPD_HELPERS_DELIM, &n_helpers, &n_readers))) return (-1); if (!(status & CLI_2NUM_FIRST_SPECIFIED)) n_helpers = DEFAULT_UPD_HELPERS; if (MIN_UPD_HELPERS > n_helpers || MAX_UPD_HELPERS < n_helpers) { util_out_print("Invalid number of helpers; must be in the range [!UL,!UL]", TRUE, MIN_UPD_HELPERS, MAX_UPD_HELPERS); return (-1); } if (!(status & CLI_2NUM_SECOND_SPECIFIED)) n_readers = (int)(n_helpers * ((float)DEFAULT_UPD_HELP_READERS)/DEFAULT_UPD_HELPERS); /* may round down */ if (n_readers > n_helpers) { n_readers = n_helpers; util_out_print("Number of readers exceeds number of helpers, reducing number of readers to number of " "helpers", TRUE); } gtmrecv_options.n_readers = n_readers; gtmrecv_options.n_writers = n_helpers - n_readers; } return (0); }
void mu_getlst(char *name, int4 size) { char *c1, *c2, *c3, *c4, rbuff[MAX_FN_LEN + 1], fbuff[MAX_FN_LEN + 1]; unsigned short rlen, flen, i; gd_region *reg; tp_region *list; boolean_t matched; error_def(ERR_MUNODBNAME); error_def(ERR_MUBCKNODIR); error_def(ERR_MUNOACTION); error_def(ERR_TEXT); mu_star_specified = FALSE; assert(size > 0); rlen = sizeof(rbuff); flen = sizeof(fbuff); if (!cli_get_str(name, rbuff, &rlen)) mupip_exit(ERR_MUNODBNAME); if (in_backup && ((!cli_get_str("SAVE_DIR", fbuff, &flen)) || (0 == flen))) mupip_exit(ERR_MUBCKNODIR); is_directory = FALSE; for (c1 = c2 = rbuff, c3 = c4 = fbuff;;) { for (; *c2 && (*c2 != ','); c2++) /* locate a reg spec */ ; if (c2 - c1 > MAX_RN_LEN) { error_mupip = TRUE; util_out_print("!UL exceeds maximum REGION name length of !UL characters.", TRUE, c2 - c1, MAX_RN_LEN); } else { /* handle the reg spec here */ if ('*' == *c1 && (1 == c2 - c1)) mu_star_specified = TRUE; matched = FALSE; for (i = 0, reg = gd_header->regions; i < gd_header->n_regions; i++, reg++) { if (TRUE == str_match((char *)reg->rname, reg->rname_len, c1, c2 - c1)) { matched = TRUE; if (NULL == (list = insert_region(reg, &(grlist), NULL, size))) { error_mupip = TRUE; rts_error(VARLSTCNT(4) ERR_TEXT, 2, RTS_ERROR_STRING("Region not found")); continue; } if ((FALSE == in_backup) || (0 != ((backup_reg_list *)list)->backup_file.len)) continue; if (TRUE == is_directory) { assert(NULL != grlist->fPtr); mubexpfilnam(directory.addr, directory.len, (backup_reg_list *)list); } else { for (; *c4 && (*c4 != ','); c4++) /* locate a file spec */ ; if (FALSE == mubgetfil((backup_reg_list *)list, c3, c4 - c3)) break; if (*c4) c3 = ++c4; else if (FALSE == is_directory) break; } } } if (!matched) { util_out_print("REGION !AD not found", TRUE, c2 - c1, c1); mupip_exit(ERR_MUNOACTION); } } if (!*c2) break; else c1 = ++c2; } return; }
void op_zcompile(mval *v, boolean_t mExtReqd) { unsigned status; command_qualifier save_qlf; unsigned short len; char source_file_string[FILE_NAME_SIZE + 1], obj_file[FILE_NAME_SIZE + 1], list_file[FILE_NAME_SIZE + 1], ceprep_file[FILE_NAME_SIZE + 1]; # ifdef UNIX CLI_ENTRY *save_cmd_ary; # endif size_t mcallocated, alloc; mcalloc_hdr *lastmca, *nextmca; DCL_THREADGBL_ACCESS; SETUP_THREADGBL_ACCESS; MV_FORCE_STR(v); if (!v->str.len) return; save_qlf = glb_cmd_qlf; glb_cmd_qlf.object_file.str.addr = obj_file; glb_cmd_qlf.object_file.str.len = FILE_NAME_SIZE; glb_cmd_qlf.list_file.str.addr = list_file; glb_cmd_qlf.list_file.str.len = FILE_NAME_SIZE; glb_cmd_qlf.ceprep_file.str.addr = ceprep_file; glb_cmd_qlf.ceprep_file.str.len = FILE_NAME_SIZE; zl_cmd_qlf(&v->str, &glb_cmd_qlf); cmd_qlf = glb_cmd_qlf; assert(run_time); assert(rts_stringpool.base == stringpool.base); rts_stringpool = stringpool; if (!indr_stringpool.base) { stp_init (STP_INITSIZE); indr_stringpool = stringpool; } else stringpool = indr_stringpool; run_time = FALSE; TREF(compile_time) = TRUE; TREF(transform) = FALSE; TREF(dollar_zcstatus) = SS_NORMAL; len = FILE_NAME_SIZE; # ifdef UNIX /* The caller of this function could be GT.M, DSE, MUPIP, GTCM GNP server, GTCM OMI server etc. Most of them have their * own command parsing tables and some dont even have one. Nevertheless, we need to parse the string as if it was a * MUMPS compilation command. So we switch temporarily to the MUMPS parsing table "mumps_cmd_ary". Note that the only * rts_errors possible between save and restore of the cmd_ary are in compile_source_file and those are internally * handled by source_ch which will transfer control back to us (right after the the call to compile_source_file below) * and hence proper restoring of cmd_ary is guaranteed even in case of errors. */ save_cmd_ary = cmd_ary; cmd_ary = mumps_cmd_ary; # endif mcfree(); /* If last compile errored out, may have left things uninitialized for us */ /* Find out how much space we have in mcalloc blocks */ for (mcallocated = 0, nextmca = mcavailptr; nextmca; nextmca = nextmca->link) mcallocated += nextmca->size; if (0 == mcallocated) mcallocated = MC_DSBLKSIZE - MCALLOC_HDR_SZ; /* Min size is one default block size */ for (status = cli_get_str("INFILE",source_file_string, &len); status; status = cli_get_str("INFILE",source_file_string, &len)) { compile_source_file(len, source_file_string, mExtReqd); len = FILE_NAME_SIZE; } /* Determine if need to remove any added added mc blocks. Min value of mcallocated will ensure * we leave at least one block alone. */ for (alloc = 0, nextmca = mcavailptr; nextmca && (alloc < mcallocated); alloc += nextmca->size, lastmca = nextmca, nextmca = nextmca->link); if (nextmca) { /* Start freeing at the nextmca node since these are added blocks */ lastmca->link = NULL; /* Sever link to further blocks here */ /* Release any remaining blocks if any */ for (lastmca = nextmca; lastmca; lastmca = nextmca) { nextmca = lastmca->link; free(lastmca); } } # ifdef UNIX cmd_ary = save_cmd_ary; /* restore cmd_ary */ # endif assert((FALSE == run_time) && (TRUE == TREF(compile_time))); run_time = TRUE; TREF(compile_time) = FALSE; TREF(transform) = TRUE; indr_stringpool = stringpool; stringpool = rts_stringpool; indr_stringpool.free = indr_stringpool.base; glb_cmd_qlf = save_qlf; }
void mu_extract(void) { int stat_res, truncate_res; int reg_max_rec, reg_max_key, reg_max_blk, reg_std_null_coll; int iter, format, local_errno, int_nlen; boolean_t freeze = FALSE, logqualifier, success; char format_buffer[FORMAT_STR_MAX_SIZE], ch_set_name[MAX_CHSET_NAME], cli_buff[MAX_LINE], label_buff[LABEL_STR_MAX_SIZE], gbl_name_buff[MAX_MIDENT_LEN + 2]; /* 2 for null and '^' */ glist gl_head, *gl_ptr; gd_region *reg, *region_top; mu_extr_stats global_total, grand_total; uint4 item_code, devbufsiz, maxfield; unsigned short label_len, n_len, ch_set_len, buflen; unsigned char *outbuf, *outptr, *chptr, *leadptr; struct stat statbuf; mval val, curr_gbl_name, op_val, op_pars; mstr chset_mstr; gtm_chset_t saved_out_set; static unsigned char ochset_set = FALSE; static readonly unsigned char open_params_list[] = { (unsigned char)iop_noreadonly, (unsigned char)iop_nowrap, (unsigned char)iop_stream, (unsigned char)iop_eol }; static readonly unsigned char no_param = (unsigned char)iop_eol; coll_hdr extr_collhdr; error_def(ERR_NOSELECT); error_def(ERR_GTMASSERT); error_def(ERR_EXTRACTCTRLY); error_def(ERR_EXTRACTFILERR); error_def(ERR_MUPCLIERR); error_def(ERR_MUNOACTION); error_def(ERR_MUNOFINISH); error_def(ERR_RECORDSTAT); error_def(ERR_NULLCOLLDIFF); /* Initialize all local character arrays to zero before using */ memset(cli_buff, 0, sizeof(cli_buff)); memset(outfilename, 0, sizeof(outfilename)); memset(label_buff, 0, sizeof(label_buff)); memset(format_buffer, 0, sizeof(format_buffer)); active_device = io_curr_device.out; mu_outofband_setup(); if (CLI_PRESENT == cli_present("OCHSET")) { ch_set_len = sizeof(ch_set_name); if (cli_get_str("OCHSET", ch_set_name, &ch_set_len)) { if (0 == ch_set_len) mupip_exit(ERR_MUNOACTION); /* need to change to OPCHSET error when added */ ch_set_name[ch_set_len] = '\0'; #ifdef KEEP_zOS_EBCDIC if ( (iconv_t)0 != active_device->output_conv_cd) ICONV_CLOSE_CD(active_device->output_conv_cd); if (DEFAULT_CODE_SET != active_device->out_code_set) ICONV_OPEN_CD(active_device->output_conv_cd, INSIDE_CH_SET, ch_set_name); #else chset_mstr.addr = ch_set_name; chset_mstr.len = ch_set_len; SET_ENCODING(active_device->ochset, &chset_mstr); get_chset_desc(&chset_names[active_device->ochset]); #endif ochset_set = TRUE; } } logqualifier = (CLI_NEGATED != cli_present("LOG")); if (CLI_PRESENT == cli_present("FREEZE")) freeze = TRUE; n_len = sizeof(format_buffer); if (FALSE == cli_get_str("FORMAT", format_buffer, &n_len)) { n_len = sizeof("ZWR") - 1; memcpy(format_buffer, "ZWR", n_len); } int_nlen = n_len; lower_to_upper((uchar_ptr_t)format_buffer, (uchar_ptr_t)format_buffer, int_nlen); if (0 == memcmp(format_buffer, "ZWR", n_len)) format = MU_FMT_ZWR; else if (0 == memcmp(format_buffer, "GO", n_len)) { if (gtm_utf8_mode) { util_out_print("Extract error: GO format is not supported in UTF-8 mode. Use ZWR format.", TRUE); mupip_exit(ERR_MUPCLIERR); } format = MU_FMT_GO; } else if (0 == memcmp(format_buffer, "BINARY", n_len)) format = MU_FMT_BINARY; else { util_out_print("Extract error: bad format type", TRUE); mupip_exit(ERR_MUPCLIERR); } n_len = sizeof(cli_buff); if (FALSE == cli_get_str((char *)select_text, cli_buff, &n_len)) { n_len = 1; cli_buff[0] = '*'; } /* gv_select will select globals */ gv_select(cli_buff, n_len, freeze, (char *)select_text, &gl_head, ®_max_rec, ®_max_key, ®_max_blk); if (!gl_head.next) { rts_error(VARLSTCNT(1) ERR_NOSELECT); mupip_exit(ERR_NOSELECT); } /* For binary format, check whether all regions have same null collation order */ if (MU_FMT_BINARY == format) { for (reg = gd_header->regions, region_top = gd_header->regions + gd_header->n_regions, reg_std_null_coll = -1; reg < region_top ; reg++) { if (reg->open) { if (reg_std_null_coll != reg->std_null_coll) { if (reg_std_null_coll == -1) reg_std_null_coll = reg->std_null_coll; else { rts_error(VARLSTCNT(1) ERR_NULLCOLLDIFF); mupip_exit(ERR_NULLCOLLDIFF); } } } } assert(-1 != reg_std_null_coll); } grand_total.recknt = grand_total.reclen = grand_total.keylen = grand_total.datalen = 0; global_total.recknt = global_total.reclen = global_total.keylen = global_total.datalen = 0; n_len = sizeof(outfilename); if (FALSE == cli_get_str("FILE", outfilename, &n_len)) { rts_error(VARLSTCNT(1) ERR_MUPCLIERR); mupip_exit(ERR_MUPCLIERR); } if (-1 == Stat((char *)outfilename, &statbuf)) { if (ENOENT != errno) { local_errno = errno; perror("Error opening output file"); mupip_exit(local_errno); } } else { util_out_print("Error opening output file: !AD -- File exists", TRUE, n_len, outfilename); mupip_exit(ERR_MUNOACTION); } op_pars.mvtype = MV_STR; op_pars.str.len = sizeof(open_params_list); op_pars.str.addr = (char *)open_params_list; op_val.mvtype = MV_STR; op_val.str.len = filename_len = n_len; op_val.str.addr = (char *)outfilename; (*op_open_ptr)(&op_val, &op_pars, 0, 0); ESTABLISH(mu_extract_handler); op_use(&op_val, &op_pars); if (MU_FMT_BINARY == format) { /* binary header label format: * fixed length text, fixed length date & time, * fixed length max blk size, fixed length max rec size, fixed length max key size, fixed length std_null_coll * 32-byte padded user-supplied string */ outbuf = (unsigned char *)malloc(sizeof(BIN_HEADER_LABEL) + sizeof(BIN_HEADER_DATEFMT) - 1 + 4 * BIN_HEADER_NUMSZ + BIN_HEADER_LABELSZ); outptr = outbuf; MEMCPY_LIT(outptr, BIN_HEADER_LABEL); outptr += STR_LIT_LEN(BIN_HEADER_LABEL); stringpool.free = stringpool.base; op_horolog(&val); stringpool.free = stringpool.base; op_fnzdate(&val, (mval *)&mu_bin_datefmt, &null_str, &null_str, &val); memcpy(outptr, val.str.addr, val.str.len); outptr += val.str.len; WRITE_NUMERIC(reg_max_blk); WRITE_NUMERIC(reg_max_rec); WRITE_NUMERIC(reg_max_key); WRITE_NUMERIC(reg_std_null_coll); if (gtm_utf8_mode) { MEMCPY_LIT(outptr, UTF8_NAME); label_len = STR_LIT_LEN(UTF8_NAME); outptr[label_len++] = ' '; } else label_len = 0; buflen = sizeof(label_buff); if (FALSE == cli_get_str("LABEL", label_buff, &buflen)) { MEMCPY_LIT(&outptr[label_len], EXTR_DEFAULT_LABEL); buflen = STR_LIT_LEN(EXTR_DEFAULT_LABEL); } else memcpy(&outptr[label_len], label_buff, buflen); label_len += buflen; if (label_len > BIN_HEADER_LABELSZ) { /* Label size exceeds the space, so truncate the label and back off to the valid beginning (i.e. to the leading byte) of the last character that can entirely fit in the space */ label_len = BIN_HEADER_LABELSZ; chptr = &outptr[BIN_HEADER_LABELSZ]; UTF8_LEADING_BYTE(chptr, outptr, leadptr); assert(chptr - leadptr < 4); if (leadptr < chptr) label_len -= (chptr - leadptr); } outptr += label_len; for (iter = label_len; iter < BIN_HEADER_LABELSZ; iter++) *outptr++ = ' '; label_len = outptr - outbuf; if (!ochset_set) { #ifdef KEEP_zOS_EBCDIC /* extract ascii header for binary by default */ /* Do we need to restore it somewhere? */ saved_out_set = (io_curr_device.out)->out_code_set; (io_curr_device.out)->out_code_set = DEFAULT_CODE_SET; #else saved_out_set = (io_curr_device.out)->ochset; (io_curr_device.out)->ochset = CHSET_M; #endif } op_val.str.addr = (char *)(&label_len); op_val.str.len = sizeof(label_len); op_write(&op_val); op_val.str.addr = (char *)outbuf; op_val.str.len = label_len; op_write(&op_val); } else { assert((MU_FMT_GO == format) || (MU_FMT_ZWR == format)); label_len = sizeof(label_buff); if (FALSE == cli_get_str("LABEL", label_buff, &label_len)) { MEMCPY_LIT(label_buff, EXTR_DEFAULT_LABEL); label_len = STR_LIT_LEN(EXTR_DEFAULT_LABEL); } if (gtm_utf8_mode) { label_buff[label_len++] = ' '; MEMCPY_LIT(&label_buff[label_len], UTF8_NAME); label_len += STR_LIT_LEN(UTF8_NAME); } label_buff[label_len++] = '\n'; op_val.mvtype = MV_STR; op_val.str.len = label_len; op_val.str.addr = label_buff; op_write(&op_val); stringpool.free = stringpool.base; op_horolog(&val); stringpool.free = stringpool.base; op_fnzdate(&val, &datefmt, &null_str, &null_str, &val); op_val = val; op_val.mvtype = MV_STR; op_write(&op_val); if (MU_FMT_ZWR == format) { op_val.str.addr = " ZWR"; op_val.str.len = sizeof(" ZWR") - 1; op_write(&op_val); } op_wteol(1); } REVERT; ESTABLISH(mu_extract_handler1); success = TRUE; for (gl_ptr = gl_head.next; gl_ptr; gl_ptr = gl_ptr->next) { if (mu_ctrly_occurred) break; if (mu_ctrlc_occurred) { gbl_name_buff[0]='^'; memcpy(&gbl_name_buff[1], gl_ptr->name.str.addr, gl_ptr->name.str.len); gtm_putmsg(VARLSTCNT(8) ERR_RECORDSTAT, 6, gl_ptr->name.str.len + 1, gbl_name_buff, global_total.recknt, global_total.keylen, global_total.datalen, global_total.reclen); mu_ctrlc_occurred = FALSE; } gv_bind_name(gd_header, &gl_ptr->name.str); if (MU_FMT_BINARY == format) { label_len = sizeof(extr_collhdr); op_val.mvtype = MV_STR; op_val.str.addr = (char *)(&label_len); op_val.str.len = sizeof(label_len); op_write(&op_val); extr_collhdr.act = gv_target->act; extr_collhdr.nct = gv_target->nct; extr_collhdr.ver = gv_target->ver; op_val.str.addr = (char *)(&extr_collhdr); op_val.str.len = sizeof(extr_collhdr); op_write(&op_val); } /* Note: Do not change the order of the expression below. * Otherwise if success is FALSE, mu_extr_gblout() will not be called at all. * We want mu_extr_gblout() to be called irrespective of the value of success */ success = mu_extr_gblout(&gl_ptr->name, &global_total, format) && success; if (logqualifier) { gbl_name_buff[0]='^'; memcpy(&gbl_name_buff[1], gl_ptr->name.str.addr, gl_ptr->name.str.len); gtm_putmsg(VARLSTCNT(8) ERR_RECORDSTAT, 6, gl_ptr->name.str.len + 1, gbl_name_buff, global_total.recknt, global_total.keylen, global_total.datalen, global_total.reclen); mu_ctrlc_occurred = FALSE; } grand_total.recknt += global_total.recknt; if (grand_total.reclen < global_total.reclen) grand_total.reclen = global_total.reclen; if (grand_total.keylen < global_total.keylen) grand_total.keylen = global_total.keylen; if (grand_total.datalen < global_total.datalen) grand_total.datalen = global_total.datalen; } op_val.mvtype = op_pars.mvtype = MV_STR; op_val.str.addr = (char *)outfilename;; op_val.str.len = filename_len; op_pars.str.len = sizeof(no_param); op_pars.str.addr = (char *)&no_param; op_close(&op_val, &op_pars); REVERT; if (mu_ctrly_occurred) { gtm_putmsg(VARLSTCNT(1) ERR_EXTRACTCTRLY); mupip_exit(ERR_MUNOFINISH); } gtm_putmsg(VARLSTCNT(8) ERR_RECORDSTAT, 6, LEN_AND_LIT(gt_lit), grand_total.recknt, grand_total.keylen, grand_total.datalen, grand_total.reclen); if (MU_FMT_BINARY == format) { /* truncate the last newline charactor flushed by op_close */ STAT_FILE((char *)outfilename, &statbuf, stat_res); if (-1 == stat_res) rts_error(VARLSTCNT(1) errno); TRUNCATE_FILE((const char *)outfilename, statbuf.st_size - 1, truncate_res); if (-1 == truncate_res) rts_error(VARLSTCNT(1) errno); } mupip_exit(success ? SS_NORMAL : ERR_MUNOFINISH); }