STATICFNDEF void mu_rndwn_all_helper(shm_parms *parm_buff, char *fname, int *exit_status, int *tmp_exit_status)
{
replpool_identifier replpool_id;
boolean_t ret_status, jnlpool_sem_created;
unsigned char ipcs_buff[MAX_IPCS_ID_BUF], *ipcs_ptr;
ESTABLISH(mu_rndwn_all_helper_ch);
if (validate_db_shm_entry(parm_buff, fname, tmp_exit_status))
{
if (SS_NORMAL == *tmp_exit_status)
{ /* shm still exists */
mu_gv_cur_reg_init();
gv_cur_region->dyn.addr->fname_len = strlen(fname);
STRNCPY_STR(gv_cur_region->dyn.addr->fname, fname, gv_cur_region->dyn.addr->fname_len);
if (mu_rndwn_file(gv_cur_region, FALSE))
gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT(4) ERR_MUFILRNDWNSUC, 2, DB_LEN_STR(gv_cur_region));
else
{ /* Save semid so that it will not be removed by mu_rndwn_sem_all() */
add_to_semids_list(FILE_INFO(gv_cur_region)->semid);
*exit_status = ERR_MUNOTALLSEC;
}
mu_gv_cur_reg_free();
} else
{ /* shm has been cleaned up by "validate_db_shm_entry" so no need of any more cleanup here */
assert(ERR_SHMREMOVED == *tmp_exit_status);
*tmp_exit_status = SS_NORMAL; /* reset tmp_exit_status for below logic to treat this as normal */
}
} else if ((SS_NORMAL == *tmp_exit_status)
&& validate_replpool_shm_entry(parm_buff, (replpool_id_ptr_t)&replpool_id, tmp_exit_status))
{
if (SS_NORMAL == *tmp_exit_status)
{
assert(JNLPOOL_SEGMENT == replpool_id.pool_type || RECVPOOL_SEGMENT == replpool_id.pool_type);
ret_status = mu_rndwn_repl_instance(&replpool_id, TRUE, FALSE, &jnlpool_sem_created);
ipcs_ptr = i2asc((uchar_ptr_t)ipcs_buff, parm_buff->shmid);
*ipcs_ptr = '\0';
gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT(6) (JNLPOOL_SEGMENT == replpool_id.pool_type) ?
(ret_status ? ERR_MUJPOOLRNDWNSUC : ERR_MUJPOOLRNDWNFL) :
(ret_status ? ERR_MURPOOLRNDWNSUC : ERR_MURPOOLRNDWNFL),
4, LEN_AND_STR(ipcs_buff), LEN_AND_STR(replpool_id.instfilename));
if (!ret_status)
*exit_status = ERR_MUNOTALLSEC;
} else
{ /* shm has been cleaned up by "validate_replpool_shm_entry" so no need of any more cleanup here */
assert(ERR_SHMREMOVED == *tmp_exit_status);
*tmp_exit_status = SS_NORMAL; /* reset tmp_exit_status for below logic to treat this as normal */
}
}
REVERT;
}
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);
}
/* Takes an entry from 'ipcs -m' and checks for its validity to be a GT.M db segment.
* Returns TRUE if the shared memory segment is a valid GT.M db segment
* (based on a check on some fields in the shared memory) else FALSE.
* If the segment belongs to GT.M it returns the database file name by the second argument.
* Sets exit_stat to ERR_MUNOTALLSEC if appropriate.
*/
boolean_t validate_db_shm_entry(shm_parms *parm_buff, char *fname, int *exit_stat)
{
boolean_t remove_shmid;
file_control *fc;
int fname_len, save_errno, status, shmid;
node_local_ptr_t nl_addr;
sm_uc_ptr_t start_addr;
struct stat st_buff;
struct shmid_ds shmstat;
sgmnt_data tsd;
unix_db_info *udi;
char msgbuff[OUT_BUFF_SIZE];
if (NULL == parm_buff)
return FALSE;
/* check for the bare minimum size of the shared memory segment that we expect
* (with no fileheader related information at hand) */
if (MIN_NODE_LOCAL_SPACE + SHMPOOL_SECTION_SIZE > parm_buff->sgmnt_siz)
return FALSE;
if (IPC_PRIVATE != parm_buff->key)
return FALSE;
shmid = parm_buff->shmid;
/* we do not need to lock the shm for reading the rundown information as
* the other rundowns (if any) can also be allowed to share reading the
* same info concurrently.
*/
if (-1 == (sm_long_t)(start_addr = (sm_uc_ptr_t) do_shmat(shmid, 0, SHM_RND)))
return FALSE;
nl_addr = (node_local_ptr_t)start_addr;
memcpy(fname, nl_addr->fname, MAX_FN_LEN + 1);
fname[MAX_FN_LEN] = '\0'; /* make sure the fname is null terminated */
fname_len = STRLEN(fname);
msgbuff[0] = '\0';
if (memcmp(nl_addr->label, GDS_LABEL, GDS_LABEL_SZ - 1))
{
if (!memcmp(nl_addr->label, GDS_LABEL, GDS_LABEL_SZ - 3))
{
util_out_print("Cannot rundown shmid = !UL for database !AD as it has format !AD "
"but this mupip uses format !AD", TRUE, shmid,
fname_len, fname, GDS_LABEL_SZ - 1, nl_addr->label, GDS_LABEL_SZ - 1, GDS_LABEL);
*exit_stat = ERR_MUNOTALLSEC;
}
shmdt((void *)start_addr);
return FALSE;
}
if (-1 == shmctl(shmid, IPC_STAT, &shmstat))
{
save_errno = errno;
assert(FALSE);/* we were able to attach to this shmid before so should be able to get stats on it */
util_out_print("!AD -> Error with shmctl for shmid = !UL",
TRUE, fname_len, fname, shmid);
gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT(1) save_errno);
*exit_stat = ERR_MUNOTALLSEC;
shmdt((void *)start_addr);
return FALSE;
}
remove_shmid = FALSE;
/* Check if db filename reported in shared memory still exists. If not, clean this shared memory section
* without even invoking "mu_rndwn_file" as that expects the db file to exist. Same case if shared memory
* points back to a database whose file header does not have this shmid.
*/
if (-1 == Stat(fname, &st_buff))
{
if (ENOENT == errno)
{
SNPRINTF(msgbuff, OUT_BUFF_SIZE, "File %s does not exist", fname);
if (1 < shmstat.shm_nattch)
{
PRINT_AND_SEND_DBRNDWN_FAILURE_MSG(msgbuff, fname, shmid);
*exit_stat = ERR_MUNOTALLSEC;
shmdt((void *)start_addr);
return FALSE;
}
remove_shmid = TRUE;
} else
{ /* Stat errored out e.g. due to file permissions. Log that */
save_errno = errno;
util_out_print("Cannot rundown shmid !UL for database file !AD as stat() on the file"
" returned the following error", TRUE, shmid, fname_len, fname);
gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT(1) save_errno);
*exit_stat = ERR_MUNOTALLSEC;
shmdt((void *)start_addr);
return FALSE;
}
} else
{
mu_gv_cur_reg_init();
gv_cur_region->dyn.addr->fname_len = strlen(fname);
STRNCPY_STR(gv_cur_region->dyn.addr->fname, fname, gv_cur_region->dyn.addr->fname_len);
fc = gv_cur_region->dyn.addr->file_cntl;
fc->op = FC_OPEN;
status = dbfilop(fc);
if (SS_NORMAL != status)
{
util_out_print("!AD -> Error with dbfilop for shmid = !UL", TRUE, fname_len, fname, shmid);
gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT(5) status, 2, DB_LEN_STR(gv_cur_region), errno);
*exit_stat = ERR_MUNOTALLSEC;
shmdt((void *)start_addr);
return FALSE;
}
udi = FILE_INFO(gv_cur_region);
LSEEKREAD(udi->fd, 0, &tsd, SIZEOF(sgmnt_data), status);
if (0 != status)
{
save_errno = errno;
util_out_print("!AD -> Error with LSEEKREAD for shmid = !UL", TRUE, fname_len, fname, shmid);
gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT(1) save_errno);
*exit_stat = ERR_MUNOTALLSEC;
shmdt((void *)start_addr);
return FALSE;
}
mu_gv_cur_reg_free();
if (tsd.shmid != shmid)
{
SNPRINTF(msgbuff, OUT_BUFF_SIZE, "Shared memory ID (%d) in the DB file header does not match with the one"
" reported by \"ipcs\" command (%d)", tsd.shmid, shmid);
if (1 < shmstat.shm_nattch)
{
PRINT_AND_SEND_DBRNDWN_FAILURE_MSG(msgbuff, fname, shmid);
*exit_stat = ERR_MUNOTALLSEC;
shmdt((void *)start_addr);
return FALSE;
}
remove_shmid = TRUE;
} else if (tsd.gt_shm_ctime.ctime != shmstat.shm_ctime)
{
SNPRINTF(msgbuff, OUT_BUFF_SIZE, "Shared memory creation time in the DB file header does not match with"
" the one reported by shmctl");
if (1 < shmstat.shm_nattch)
{
PRINT_AND_SEND_DBRNDWN_FAILURE_MSG(msgbuff, fname, shmid);
*exit_stat = ERR_MUNOTALLSEC;
shmdt((void *)start_addr);
return FALSE;
}
remove_shmid = TRUE;
}
}
shmdt((void *)start_addr);
if (remove_shmid)
{
assert('\0' != msgbuff[0]);
if (0 != shm_rmid(shmid))
{
save_errno = errno;
gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT(8) ERR_DBFILERR, 2, fname_len, fname,
ERR_TEXT, 2, RTS_ERROR_TEXT("Error removing shared memory"));
util_out_print("!AD -> Error removing shared memory for shmid = !UL", TRUE, fname_len, fname, shmid);
gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT(1) save_errno);
*exit_stat = ERR_MUNOTALLSEC;
return FALSE;
}
PRINT_AND_SEND_SHMREMOVED_MSG(msgbuff, fname_len, fname, shmid);
*exit_stat = ERR_SHMREMOVED;
} else
*exit_stat = SS_NORMAL;
return TRUE;
}
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));
}
