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 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);
}
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);
}
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"))
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 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);
}
bool mubinccpy(backup_reg_list *list)
{
static readonly mval null_str = {MV_STR, 0, 0 , 0 , 0, 0};
int backup_socket;
int4 size, size1, bsize, bm_num, hint, lmsize, save_blks, rsize, match, timeout, outsize;
uint4 status, total_blks, bplmap, gds_ratio, blks_per_buff, counter, i, lcnt, read_size;
uchar_ptr_t bm_blk_buff, ptr1, ptr1_top, ptr, ptr_top;
char_ptr_t outptr, data_ptr;
unsigned short rd_iosb[4], port;
enum db_acc_method access;
blk_hdr *bp, *bptr;
struct FAB *fcb, temp_fab, mubincfab;
struct RAB temp_rab, mubincrab;
inc_header *outbuf;
mval val;
mstr *file;
sgmnt_data_ptr_t header;
char *common, addr[SA_MAXLEN + 1];
void (*common_write)();
void (*common_close)();
muinc_blk_hdr_ptr_t sblkh_p;
trans_num blk_tn;
block_id blk_num_base, blk_num;
boolean_t is_bitmap_blk, backup_this_blk;
enum db_ver dummy_odbv;
int4 blk_bsiz;
error_def(ERR_BCKUPBUFLUSH);
error_def(ERR_COMMITWAITSTUCK);
error_def(ERR_DBCCERR);
error_def(ERR_ERRCALL);
assert(list->reg == gv_cur_region);
assert(incremental);
/* Make sure inc_header can be same size on all platforms. Some platforms pad 8 byte aligned structures
that end on a 4 byte boundary and some do not. It is critical that this structure is the same size on
all platforms as it is sent across TCP connections when doing TCP backup.
*/
assert(0 == (SIZEOF(inc_header) % 8));
/* ================= Initialization and some checks ======================== */
header = list->backup_hdr;
file = &(list->backup_file);
if (!mubtomag)
mubmaxblk = BACKUP_TEMPFILE_BUFF_SIZE;
fcb = ((vms_gds_info *)(gv_cur_region->dyn.addr->file_cntl->file_info))->fab;
if (list->tn >= header->trans_hist.curr_tn)
{
util_out_print("!/TRANSACTION number is greater than or equal to current transaction,", TRUE);
util_out_print("No blocks backed up from database !AD", TRUE, fcb->fab$b_fns, fcb->fab$l_fna);
return TRUE;
}
/* =========== open backup destination and define common_write ================= */
backup_write_errno = 0;
backup_close_errno = 0;
switch(list->backup_to)
{
case backup_to_file:
/* open the file and define the common_write function */
mubincfab = cc$rms_fab;
mubincfab.fab$b_fac = FAB$M_PUT;
mubincfab.fab$l_fop = FAB$M_CBT | FAB$M_MXV | FAB$M_TEF | FAB$M_POS & (~FAB$M_RWC) & (~FAB$M_RWO);
mubincfab.fab$l_fna = file->addr;
mubincfab.fab$b_fns = file->len;
mubincfab.fab$l_alq = cs_addrs->hdr->start_vbn +
STARTING_BLOCKS * cs_addrs->hdr->blk_size / DISK_BLOCK_SIZE;
mubincfab.fab$w_mrs = mubmaxblk;
mubincfab.fab$w_deq = EXTEND_SIZE;
switch (status = sys$create(&mubincfab))
{
case RMS$_NORMAL:
case RMS$_CREATED:
case RMS$_SUPERSEDE:
case RMS$_FILEPURGED:
break;
default:
gtm_putmsg(status, 0, mubincfab.fab$l_stv);
util_out_print("Error: Cannot create backup file !AD.",
TRUE, mubincfab.fab$b_fns, mubincfab.fab$l_fna);
return FALSE;
}
mubincrab = cc$rms_rab;
mubincrab.rab$l_fab = &mubincfab;
mubincrab.rab$l_rop = RAB$M_WBH;
if (RMS$_NORMAL != (status = sys$connect(&mubincrab)))
{
gtm_putmsg(status, 0, mubincrab.rab$l_stv);
util_out_print("Error: Cannot connect to backup file !AD.",
TRUE, mubincfab.fab$b_fns, mubincfab.fab$l_fna);
mubincfab.fab$l_fop |= FAB$M_DLT;
sys$close(&mubincfab);
return FALSE;
}
common = (char *)(&mubincrab);
common_write = file_write;
common_close = file_close;
break;
case backup_to_exec:
util_out_print("Error: Backup to pipe is yet to be implemented.", TRUE);
util_out_print("Error: Your request to backup database !AD to !AD is currently not valid.", TRUE,
fcb->fab$b_fns, fcb->fab$l_fna, file->len, file->addr);
return FALSE;
case backup_to_tcp:
iotcp_fillroutine();
/* parse it first */
switch (match = SSCANF(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 to backup through a TCP connection.",
TRUE);
return FALSE;
}
if ((0 == cli_get_int("NETTIMEOUT", &timeout)) || (0 > timeout))
timeout = DEFAULT_BKRS_TIMEOUT;
if (0 > (backup_socket = tcp_open(addr, port, timeout, FALSE)))
{
util_out_print("ERROR: Cannot open tcp connection due to the above error.", TRUE);
return FALSE;
}
common_write = tcp_write;
common_close = tcp_close;
common = (char *)(&backup_socket);
break;
default :
util_out_print("ERROR: Backup format !UL not supported.", TRUE, list->backup_to);
util_out_print("Error: Your request to backup database !AD to !AD is not valid.", TRUE,
fcb->fab$b_fns, fcb->fab$l_fna, file->len, file->addr);
return FALSE;
}
/* ============================= write inc_header =========================================== */
outptr = malloc(SIZEOF(inc_header));
outbuf = (inc_header *)outptr;
MEMCPY_LIT(&outbuf->label[0], INC_HEADER_LABEL);
stringpool.free = stringpool.base;
op_horolog(&val);
stringpool.free = stringpool.base;
op_fnzdate(&val, &mu_bin_datefmt, &null_str, &null_str, &val);
memcpy(&outbuf->date[0], val.str.addr, val.str.len);
memcpy(&outbuf->reg[0], gv_cur_region->rname, MAX_RN_LEN);
outbuf->start_tn = list->tn;
outbuf->end_tn = header->trans_hist.curr_tn;
outbuf->db_total_blks = header->trans_hist.total_blks;
outbuf->blk_size = header->blk_size;
outbuf->blks_to_upgrd = header->blks_to_upgrd;
COMMON_WRITE(common, outptr, SIZEOF(inc_header));
free(outptr);
if (mu_ctrly_occurred || mu_ctrlc_occurred)
{
error_mupip = TRUE;
COMMON_CLOSE(common);
util_out_print("WARNING: DB file !AD backup aborted.", TRUE, fcb->fab$b_fns, fcb->fab$l_fna);
return FALSE;
}
/* ============================ read/write appropriate blocks =============================== */
bsize = header->blk_size;
gds_ratio = bsize / DISK_BLOCK_SIZE;
blks_per_buff = BACKUP_READ_SIZE / bsize;
read_size = blks_per_buff * bsize;
outsize = SIZEOF(muinc_blk_hdr) + bsize;
outptr = (char_ptr_t)malloc(MAX(outsize, mubmaxblk));
sblkh_p = (muinc_blk_hdr_ptr_t)outptr;
data_ptr = (char_ptr_t)(sblkh_p + 1);
bp = (blk_hdr_ptr_t)mubbuf;
bm_blk_buff = (uchar_ptr_t)malloc(SIZEOF(blk_hdr) + (BLKS_PER_LMAP * BML_BITS_PER_BLK / BITS_PER_UCHAR));
mubincrab.rab$l_rbf = outptr;
save_blks = 0;
access = header->acc_meth;
memset(sblkh_p, 0, SIZEOF(*sblkh_p));
if (access == dba_bg)
bp = mubbuf;
else
{
ptr = cs_addrs->db_addrs[0] + (cs_addrs->hdr->start_vbn - 1) * DISK_BLOCK_SIZE;
ptr_top = cs_addrs->db_addrs[1] + 1;
}
sblkh_p->use.bkup.ondsk_blkver = GDSNOVER;
for (blk_num_base = 0; blk_num_base < header->trans_hist.total_blks; blk_num_base += blks_per_buff)
{
if (online && (0 != cs_addrs->shmpool_buffer->failed))
break;
if (header->trans_hist.total_blks - blk_num_base < blks_per_buff)
{
blks_per_buff = header->trans_hist.total_blks - blk_num_base;
read_size = blks_per_buff * bsize;
}
if (access == dba_bg)
{
if ((SS$_NORMAL != (status = sys$qiow(EFN$C_ENF, fcb->fab$l_stv, IO$_READVBLK, &rd_iosb, 0, 0, bp,
read_size, cs_addrs->hdr->start_vbn + (gds_ratio * blk_num_base),
0, 0, 0)))
|| (SS$_NORMAL != (status = rd_iosb[0])))
{
gtm_putmsg(VARLSTCNT(1) status);
util_out_print("Error reading data from database !AD.", TRUE,
fcb->fab$b_fns, fcb->fab$l_fna);
free(outptr);
free(bm_blk_buff);
error_mupip = TRUE;
COMMON_CLOSE(common);
return FALSE;
}
} else
{
assert(dba_mm == access);
bp = ptr + blk_num_base * bsize;
}
bptr = (blk_hdr *)bp;
/* The blocks we back up will be whatever version they are. There is no implicit conversion in this
part of the backup/restore. Since we aren't even looking at the blocks (and indeed some of these blocks
could potentially contain unintialized garbage data), we set the block version to GDSNOVER to signal
that the block version is unknown. The above applies to "regular" blocks but not to bitmap blocks which
we know are initialized. Because we have to read the bitmap blocks, they will be converted as necessary.
*/
for (i = 0;
i < blks_per_buff && ((blk_num_base + i) < header->trans_hist.total_blks);
i++, bptr = (blk_hdr *)((char *)bptr + bsize))
{
blk_num = blk_num_base + i;
if (mu_ctrly_occurred || mu_ctrlc_occurred)
{
free(outptr);
free(bm_blk_buff);
error_mupip = TRUE;
COMMON_CLOSE(common);
util_out_print("WARNING: DB file !AD backup aborted.", TRUE, fcb->fab$b_fns, fcb->fab$l_fna);
return FALSE;
}
/* Before we check if this block needs backing up, check if this is a new bitmap block or not. If it is,
we can fall through and back it up as normal. But if this is NOT a bitmap block, use the
existing bitmap to determine if this block has ever been allocated or not. If not, we don't want to
even look at this block. It could be uninitialized which will just make things run slower if we
go to read it and back it up.
*/
if (0 != ((BLKS_PER_LMAP - 1) & blk_num))
{ /* Not a local bitmap block */
if (!gvcst_blk_ever_allocated(bm_blk_buff + SIZEOF(blk_hdr),
((blk_num * BML_BITS_PER_BLK)
% (BLKS_PER_LMAP * BML_BITS_PER_BLK))))
continue; /* Bypass never-set blocks to avoid conversion problems */
is_bitmap_blk = FALSE;
if (SIZEOF(v15_blk_hdr) <= (blk_bsiz = ((v15_blk_hdr_ptr_t)bptr)->bsiz))
{ /* We have either a V4 block or uninitialized garbage */
if (blk_bsiz > bsize)
/* This is not a valid V4 block so ignore it */
continue;
blk_tn = ((v15_blk_hdr_ptr_t)bptr)->tn;
} else
{ /* Assume V5 block */
if ((blk_bsiz = bptr->bsiz) > bsize)
/* Not a valid V5 block either */
continue;
blk_tn = bptr->tn;
}
} else
{ /* This is a bitmap block so save it into our bitmap block buffer. It is used as the
basis of whether or not we have to process a given block or not. We process allocated and
recycled blocks leaving free (never used) blocks alone as they have no data worth saving.
But after saving it, upgrade it to the current format if necessary.
*/
is_bitmap_blk = TRUE;
memcpy(bm_blk_buff, bptr, BM_SIZE(header->bplmap));
if (SIZEOF(v15_blk_hdr) <= ((v15_blk_hdr_ptr_t)bm_blk_buff)->bsiz)
{ /* This is a V4 format block -- needs upgrading */
status = gds_blk_upgrade(bm_blk_buff, bm_blk_buff, bsize, &dummy_odbv);
if (SS_NORMAL != status)
{
free(outptr);
free(bm_blk_buff);
error_mupip = TRUE;
COMMON_CLOSE(common);
util_out_print("Error: Block 0x!XL is too large for automatic upgrade", TRUE,
sblkh_p->blkid);
return FALSE;
}
}
assert(BM_SIZE(header->bplmap) == ((blk_hdr_ptr_t)bm_blk_buff)->bsiz);
assert(LCL_MAP_LEVL == ((blk_hdr_ptr_t)bm_blk_buff)->levl);
assert(gvcst_blk_is_allocated(bm_blk_buff + SIZEOF(blk_hdr),
((blk_num * BML_BITS_PER_BLK)
% (BLKS_PER_LMAP * BML_BITS_PER_BLK))));
blk_bsiz = BM_SIZE(header->bplmap);
blk_tn = ((blk_hdr_ptr_t)bm_blk_buff)->tn;
}
/* The conditions for backing up a block or ignoring it (in order of evaluation):
1) If blk is larger than size of db at time backup was initiated, we ignore the block.
2) Always backup blocks 0, 1, and 2 as these are the only blocks that can contain data
and still have a transaction number of 0.
3) For bitmap blocks, if blks_to_upgrd != 0 and the TN is 0 and the block number >=
last_blk_at_last_bkup, then backup the block. This way we get the correct version of
the bitmap block in the restore (otherwise have no clue what version to create them in
as bitmaps are created with a TN of 0 when before image journaling is enabled).
4) If the block TN is below our TN threshold, ignore the block.
5) Else if none of the above conditions, backup the block.
*/
if (online && (header->trans_hist.curr_tn <= blk_tn))
backup_this_blk = FALSE;
else if (3 > blk_num || (is_bitmap_blk && 0 != header->blks_to_upgrd && (trans_num)0 == blk_tn
&& blk_num >= list->last_blk_at_last_bkup))
backup_this_blk = TRUE;
else if ((blk_tn < list->tn))
backup_this_blk = FALSE;
else
backup_this_blk = TRUE;
if (!backup_this_blk)
{
if (online)
cs_addrs->nl->nbb = blk_num;
continue; /* not applicable */
}
sblkh_p->blkid = blk_num;
memcpy(data_ptr, bptr, blk_bsiz);
sblkh_p->valid_data = TRUE; /* Validation marker */
COMMON_WRITE(common, outptr, outsize);
if (online)
{
if (0 != cs_addrs->shmpool_buffer->failed)
break;
cs_addrs->nl->nbb = blk_num;
}
save_blks++;
}
}
/* ============================= write saved information for online backup ========================== */
if (online && (0 == cs_addrs->shmpool_buffer->failed))
{
/* -------- make sure everyone involved finishes -------- */
cs_addrs->nl->nbb = BACKUP_NOT_IN_PROGRESS;
/* By getting crit here, we ensure that there is no process still in transaction logic that sees
(nbb != BACKUP_NOT_IN_PRORESS). After rel_crit(), any process that enters transaction logic will
see (nbb == BACKUP_NOT_IN_PRORESS) because we just set it to that value. At this point, backup
buffer is complete and there will not be any more new entries in the backup buffer until the next
backup.
*/
grab_crit(gv_cur_region);
assert(cs_data == cs_addrs->hdr);
if (dba_bg == cs_data->acc_meth)
{ /* Now that we have crit, wait for any pending phase2 updates to finish. Since phase2 updates happen
* outside of crit, we dont want them to keep writing to the backup temporary file even after the
* backup is complete and the temporary file has been deleted.
*/
if (cs_addrs->nl->wcs_phase2_commit_pidcnt && !wcs_phase2_commit_wait(cs_addrs, NULL))
{
gtm_putmsg(VARLSTCNT(7) ERR_COMMITWAITSTUCK, 5, process_id, 1,
cs_addrs->nl->wcs_phase2_commit_pidcnt, DB_LEN_STR(gv_cur_region));
rel_crit(gv_cur_region);
free(outptr);
free(bm_blk_buff);
error_mupip = TRUE;
COMMON_CLOSE(common);
return FALSE;
}
}
if (debug_mupip)
{
util_out_print("MUPIP INFO: Current Transaction # at end of backup is 0x!16@XQ", TRUE,
&cs_data->trans_hist.curr_tn);
}
rel_crit(gv_cur_region);
counter = 0;
while (0 != cs_addrs->shmpool_buffer->backup_cnt)
{
if (0 != cs_addrs->shmpool_buffer->failed)
{
util_out_print("Process !UL encountered the following error.", TRUE,
cs_addrs->shmpool_buffer->failed);
if (0 != cs_addrs->shmpool_buffer->backup_errno)
gtm_putmsg(VARLSTCNT(1) cs_addrs->shmpool_buffer->backup_errno);
free(outptr);
free(bm_blk_buff);
error_mupip = TRUE;
COMMON_CLOSE(common);
return FALSE;
}
backup_buffer_flush(gv_cur_region);
if (++counter > MAX_BACKUP_FLUSH_TRY)
{
gtm_putmsg(VARLSTCNT(1) ERR_BCKUPBUFLUSH);
free(outptr);
free(bm_blk_buff);
error_mupip = TRUE;
COMMON_CLOSE(common);
return FALSE;
}
if (counter & 0xF)
wcs_sleep(counter);
else
{ /* Force shmpool recovery to see if it can find the lost blocks */
if (!shmpool_lock_hdr(gv_cur_region))
{
gtm_putmsg(VARLSTCNT(9) ERR_DBCCERR, 2, REG_LEN_STR(gv_cur_region),
ERR_ERRCALL, 3, CALLFROM);
free(outptr);
free(bm_blk_buff);
error_mupip = TRUE;
COMMON_CLOSE(common);
assert(FALSE);
return FALSE;;
}
shmpool_abandoned_blk_chk(gv_cur_region, TRUE);
shmpool_unlock_hdr(gv_cur_region);
}
}
/* -------- Open the temporary file -------- */
temp_fab = cc$rms_fab;
temp_fab.fab$b_fac = FAB$M_GET;
temp_fab.fab$l_fna = list->backup_tempfile;
temp_fab.fab$b_fns = strlen(list->backup_tempfile);
temp_rab = cc$rms_rab;
temp_rab.rab$l_fab = &temp_fab;
for (lcnt = 1; MAX_OPEN_RETRY >= lcnt; lcnt++)
{
if (RMS$_FLK != (status = sys$open(&temp_fab, NULL, NULL)))
break;
wcs_sleep(lcnt);
}
if (RMS$_NORMAL != status)
{
gtm_putmsg(status, 0, temp_fab.fab$l_stv);
util_out_print("WARNING: DB file !AD backup aborted.", TRUE, fcb->fab$b_fns, fcb->fab$l_fna);
free(outptr);
free(bm_blk_buff);
error_mupip = TRUE;
COMMON_CLOSE(common);
return FALSE;
}
if (RMS$_NORMAL != (status = sys$connect(&temp_rab)))
{
gtm_putmsg(status, 0, temp_rab.rab$l_stv);
util_out_print("WARNING: DB file !AD backup aborted.", TRUE, fcb->fab$b_fns, fcb->fab$l_fna);
free(outptr);
free(bm_blk_buff);
error_mupip = TRUE;
COMMON_CLOSE(common);
return FALSE;
}
/* -------- read and write every record in the temporary file -------- */
while (1)
{
temp_rab.rab$w_usz = outsize;
temp_rab.rab$l_ubf = outptr;
status = sys$get(&temp_rab);
if (RMS$_NORMAL != status)
{
if (RMS$_EOF == status)
status = RMS$_NORMAL;
break;
}
assert(outsize == temp_rab.rab$w_rsz);
/* Still validly sized blk? */
assert((outsize - SIZEOF(shmpool_blk_hdr)) >= ((blk_hdr_ptr_t)(outptr + SIZEOF(shmpool_blk_hdr)))->bsiz);
COMMON_WRITE(common, outptr, temp_rab.rab$w_rsz);
}
if (RMS$_NORMAL != status)
{
gtm_putmsg(status, 0, temp_rab.rab$l_stv);
util_out_print("WARNING: DB file !AD backup aborted.", TRUE, fcb->fab$b_fns, fcb->fab$l_fna);
free(outptr);
free(bm_blk_buff);
error_mupip = TRUE;
COMMON_CLOSE(common);
return FALSE;
}
/* ---------------- Close the temporary file ----------------------- */
if (RMS$_NORMAL != (status = sys$close(&temp_fab)))
{
gtm_putmsg(status, 0, temp_fab.fab$l_stv);
util_out_print("WARNING: DB file !AD backup aborted.", TRUE, fcb->fab$b_fns, fcb->fab$l_fna);
free(outptr);
free(bm_blk_buff);
error_mupip = TRUE;
COMMON_CLOSE(common);
return FALSE;
}
}
/* ============================= write end_msg and fileheader ======================================= */
if ((!online) || (0 == cs_addrs->shmpool_buffer->failed))
{
MEMCPY_LIT(outptr, END_MSG);
/* Although the write only need be of length SIZEOF(END_MSG) - 1 for file IO, if the write is going
to TCP we have to write all these records with common length so just write the "regular" sized
buffer. The extra garbage left over from the last write will be ignored as we key only on the
this end text.
*/
COMMON_WRITE(common, outptr, outsize);
ptr1 = header;
size1 = ROUND_UP(SIZEOF(sgmnt_data), DISK_BLOCK_SIZE);
ptr1_top = ptr1 + size1;
for (;ptr1 < ptr1_top ; ptr1 += size1)
{
if ((size1 = ptr1_top - ptr1) > mubmaxblk)
size1 = (mubmaxblk / DISK_BLOCK_SIZE) * DISK_BLOCK_SIZE;
COMMON_WRITE(common, ptr1, size1);
}
MEMCPY_LIT(outptr, HDR_MSG);
COMMON_WRITE(common, outptr, SIZEOF(HDR_MSG));
ptr1 = MM_ADDR(header);
size1 = ROUND_UP(MASTER_MAP_SIZE(header), DISK_BLOCK_SIZE);
ptr1_top = ptr1 + size1;
for (;ptr1 < ptr1_top ; ptr1 += size1)
{
if ((size1 = ptr1_top - ptr1) > mubmaxblk)
size1 = (mubmaxblk / DISK_BLOCK_SIZE) * DISK_BLOCK_SIZE;
COMMON_WRITE(common, ptr1, size1);
}
MEMCPY_LIT(outptr, MAP_MSG);
COMMON_WRITE(common, outptr, SIZEOF(MAP_MSG));
}
/* ================== close backup destination, output and return ================================== */
if (online && (0 != cs_addrs->shmpool_buffer->failed))
{
util_out_print("Process !UL encountered the following error.", TRUE,
cs_addrs->shmpool_buffer->failed);
if (0 != cs_addrs->shmpool_buffer->backup_errno)
gtm_putmsg(VARLSTCNT(1) cs_addrs->shmpool_buffer->backup_errno);
free(outptr);
free(bm_blk_buff);
error_mupip = TRUE;
COMMON_CLOSE(common);
return FALSE;
}
COMMON_CLOSE(common);
free(outptr);
free(bm_blk_buff);
util_out_print("DB file !AD incrementally backed up in !AD", TRUE,
fcb->fab$b_fns, fcb->fab$l_fna, file->len, file->addr);
util_out_print("!UL blocks saved.", TRUE, save_blks);
util_out_print("Transactions from 0x!16@XQ to 0x!16@XQ are backed up.", TRUE,
&cs_addrs->shmpool_buffer->inc_backup_tn, &header->trans_hist.curr_tn);
cs_addrs->hdr->last_inc_backup = header->trans_hist.curr_tn;
if (record)
cs_addrs->hdr->last_rec_backup = header->trans_hist.curr_tn;
file_backed_up = TRUE;
return TRUE;
}
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);
}
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"))
void get_cmd_qlf(command_qualifier *qualif)
{
static readonly char upper[] = "UPPER";
static readonly char lower[] = "LOWER";
mstr *s;
int4 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;
INIT_QUALIF_STR(qualif, CQ_OBJECT, object_file);
INIT_QUALIF_STR(qualif, CQ_LIST, list_file);
INIT_QUALIF_STR(qualif, CQ_CE_PREPROCESS, ceprep_file);
if (gtm_utf8_mode)
qualif->qlf |= CQ_UTF8; /* Mark as being compiled in UTF8 mode */
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;
if (cli_negated("ALIGN_STRINGS") == TRUE)
qualif->qlf &= ~CQ_ALIGN_STRINGS;
#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;
}
}
}
# ifdef UNIX
if (CLI_PRESENT == cli_present("NAMEOFRTN"))
qualif->qlf |= CQ_NAMEOFRTN;
# endif
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;
# ifdef USHBIN_SUPPORTED
if (CLI_PRESENT == cli_present("DYNAMIC_LITERALS"))
qualif->qlf |= CQ_DYNAMIC_LITERALS;
# endif
# ifdef UNIX
if (CLI_PRESENT == cli_present("EMBED_SOURCE"))
qualif->qlf |= CQ_EMBED_SOURCE;
else if (cli_negated("EMBED_SOURCE"))
qualif->qlf &= ~CQ_EMBED_SOURCE;
# endif
}
void mupip_extend(void)
{
unsigned short r_len;
char regionname[MAX_RN_LEN];
uint4 bplmap, bit_maps, blocks, i, old_total, total, status;
int4 tblocks;
int fd;
r_len = SIZEOF(regionname);
if (cli_get_str("REG_NAME", regionname, &r_len) == FALSE)
rts_error(VARLSTCNT(1) ERR_MUNODBNAME);
if (cli_get_int("BLOCKS",&tblocks))
{
if (tblocks < 1)
{
util_out_print("!/BLOCKS too small, no extension done",TRUE);
mupip_exit(ERR_MUNOACTION);
}
blocks = tblocks;
} else
blocks = (uint4)-1;
gvinit();
for (i = 0, gv_cur_region = gd_header->regions; i < gd_header->n_regions; i++, gv_cur_region++)
{
if (memcmp(gv_cur_region->rname, regionname, r_len) == 0)
break;
}
if (i >= gd_header->n_regions)
{
gtm_putmsg(VARLSTCNT(4) ERR_NOREGION, 2, r_len, regionname);
mupip_exit(ERR_MUNOACTION);
}
if ((dba_bg != gv_cur_region->dyn.addr->acc_meth) && (dba_mm != gv_cur_region->dyn.addr->acc_meth))
{
util_out_print("Can only EXTEND BG and MM databases",TRUE);
mupip_exit(ERR_MUNOACTION);
}
if (reg_cmcheck(gv_cur_region))
{
util_out_print("!/Can't EXTEND region !AD across network",TRUE, REG_LEN_STR(gv_cur_region));
mupip_exit(ERR_MUNOACTION);
}
# if !defined(MM_FILE_EXT_OK) && defined(UNIX)
if (dba_mm == gv_cur_region->dyn.addr->acc_meth)
{
FILE_CNTL_INIT(gv_cur_region->dyn.addr);
if (!STANDALONE(gv_cur_region))
{
util_out_print("Can't get standalone access to database file !AD with MM access method, no extension done.",
TRUE, DB_LEN_STR(gv_cur_region));
mupip_exit(ERR_MUNOACTION);
}
assert((FILE_INFO(gv_cur_region))->grabbed_access_sem); /* we should have standalone access */
}
# endif
gvcst_init(gv_cur_region);
if (gv_cur_region->was_open)
{ /* This should not happen as extend works on only one region at a time, but handle for safety */
gtm_putmsg(VARLSTCNT(4) ERR_DBOPNERR, 2, DB_LEN_STR(gv_cur_region));
DB_IPCS_RESET(gv_cur_region);
mupip_exit(ERR_MUNOACTION);
}
cs_addrs = &FILE_INFO(gv_cur_region)->s_addrs;
cs_data = cs_addrs->hdr;
if ((uint4)-1 == blocks)
{
if (cs_addrs->hdr->extension_size == 0)
{
util_out_print("The extension size on file !AD is zero, no extension done.",TRUE,
DB_LEN_STR(gv_cur_region));
DB_IPCS_RESET(gv_cur_region);
mupip_exit(ERR_MUNOACTION);
}
blocks = cs_addrs->hdr->extension_size;
}
/* cannot extend for read_only database. */
if (gv_cur_region->read_only)
{
gtm_putmsg(VARLSTCNT(4) ERR_DBRDONLY, 2, DB_LEN_STR(gv_cur_region));
DB_IPCS_RESET(gv_cur_region);
mupip_exit(ERR_MUNOACTION);
}
switch(gv_cur_region->dyn.addr->acc_meth)
{
case dba_bg:
case dba_mm:
grab_crit(gv_cur_region);
GRAB_UNFROZEN_CRIT(gv_cur_region, cs_addrs, cs_data);
old_total = cs_addrs->ti->total_blks;
if ((uint4)NO_FREE_SPACE == (status = gdsfilext(blocks, old_total)))
{
rel_crit(gv_cur_region);
util_out_print("The extension failed on file !AD; check disk space and permissions.", TRUE,
DB_LEN_STR(gv_cur_region));
DB_IPCS_RESET(gv_cur_region);
mupip_exit(ERR_MUNOACTION);
} else
assert(SS_NORMAL == status);
total = cs_addrs->ti->total_blks;
bplmap = cs_addrs->hdr->bplmap;
bit_maps = DIVIDE_ROUND_UP(total, bplmap) - DIVIDE_ROUND_UP(old_total, bplmap);
rel_crit(gv_cur_region);
break;
default:
GTMASSERT;
}
util_out_print("Extension successful, file !AD extended by !UL blocks. Total blocks = !UL.",TRUE,
DB_LEN_STR(gv_cur_region), total - old_total - bit_maps, total - DIVIDE_ROUND_UP(total, bplmap));
DB_IPCS_RESET(gv_cur_region); /* final cleanup (for successful case) before exit */
mupip_exit(SS_NORMAL);
}
