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);
}
/*
* This will rundown a replication instance journal (and receiver) pool.
* Input Parameter:
* replpool_id of the instance. Instance file name must be null terminated in replpool_id.
* Returns :
* TRUE, if successful.
* FALSE, otherwise.
*/
boolean_t mu_rndwn_repl_instance(replpool_identifier *replpool_id, boolean_t immediate, boolean_t rndwn_both_pools,
boolean_t *jnlpool_sem_created)
{
boolean_t jnlpool_stat = SS_NORMAL, recvpool_stat = SS_NORMAL, decr_cnt, sem_created = FALSE, ipc_rmvd;
char *instfilename;
unsigned char ipcs_buff[MAX_IPCS_ID_BUF], *ipcs_ptr;
gd_region *r_save;
repl_inst_hdr repl_instance;
static gd_region *reg = NULL;
struct semid_ds semstat;
struct shmid_ds shmstat;
unix_db_info *udi;
int save_errno, sem_id, shm_id, status;
sgmnt_addrs *repl_csa;
boolean_t was_crit;
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
if (NULL == reg)
{
r_save = gv_cur_region;
mu_gv_cur_reg_init();
reg = gv_cur_region;
gv_cur_region = r_save;
}
*jnlpool_sem_created = FALSE;
/* Assert that the layout of replpool_identifier is identical for all versions going forward as the function
* "validate_replpool_shm_entry" (used by the argumentless mupip rundown aka "mupip rundown") relies on this.
* This assert is placed here (instead of there) because the automated tests exercise this logic much more
* than the argumentless code. If any of these asserts fail, "validate_replpool_shm_entry" needs to change
* to handle the old and new layouts.
*
* Structure ----> replpool_identifier <---- size 312 [0x0138]
*
* offset = 0000 [0x0000] size = 0012 [0x000c] ----> replpool_identifier.label
* offset = 0012 [0x000c] size = 0001 [0x0001] ----> replpool_identifier.pool_type
* offset = 0013 [0x000d] size = 0036 [0x0024] ----> replpool_identifier.now_running
* offset = 0052 [0x0034] size = 0004 [0x0004] ----> replpool_identifier.repl_pool_key_filler
* offset = 0056 [0x0038] size = 0256 [0x0100] ----> replpool_identifier.instfilename
*/
assert(0 == OFFSETOF(replpool_identifier, label[0]));
assert(12 == SIZEOF(((replpool_identifier *)NULL)->label));
assert(12 == OFFSETOF(replpool_identifier, pool_type));
assert(1 == SIZEOF(((replpool_identifier *)NULL)->pool_type));
assert(13 == OFFSETOF(replpool_identifier, now_running[0]));
assert(36 == SIZEOF(((replpool_identifier *)NULL)->now_running));
assert(56 == OFFSETOF(replpool_identifier, instfilename[0]));
assert(256 == SIZEOF(((replpool_identifier *)NULL)->instfilename));
/* End asserts */
jnlpool.jnlpool_dummy_reg = reg;
recvpool.recvpool_dummy_reg = reg;
instfilename = replpool_id->instfilename;
reg->dyn.addr->fname_len = strlen(instfilename);
assert(0 == instfilename[reg->dyn.addr->fname_len]);
memcpy((char *)reg->dyn.addr->fname, instfilename, reg->dyn.addr->fname_len + 1);
udi = FILE_INFO(reg);
udi->fn = (char *)reg->dyn.addr->fname;
/* Lock replication instance using ftok semaphore so that no other replication process can startup until we are done with
* rundown
*/
if (!ftok_sem_get(reg, TRUE, REPLPOOL_ID, immediate))
return FALSE;
ESTABLISH_RET(mu_rndwn_repl_instance_ch, FALSE);
repl_inst_read(instfilename, (off_t)0, (sm_uc_ptr_t)&repl_instance, SIZEOF(repl_inst_hdr));
assert(rndwn_both_pools || JNLPOOL_SEGMENT == replpool_id->pool_type || RECVPOOL_SEGMENT == replpool_id->pool_type);
if (rndwn_both_pools || (JNLPOOL_SEGMENT == replpool_id->pool_type))
{ /* --------------------------
* First rundown Journal pool
* --------------------------
*/
shm_id = repl_instance.jnlpool_shmid;
if (SS_NORMAL == (jnlpool_stat = mu_replpool_grab_sem(&repl_instance, JNLPOOL_SEGMENT, &sem_created, immediate)))
{
/* Got JNL_POOL_ACCESS_SEM and incremented SRC_SRV_COUNT_SEM */
assert(holds_sem[SOURCE][JNL_POOL_ACCESS_SEM]);
assert(holds_sem[SOURCE][SRC_SERV_COUNT_SEM]);
sem_id = repl_instance.jnlpool_semid;
if ((INVALID_SHMID == shm_id) || (-1 == shmctl(shm_id, IPC_STAT, &shmstat))
|| (shmstat.shm_ctime != repl_instance.jnlpool_shmid_ctime))
{
repl_instance.jnlpool_shmid = shm_id = INVALID_SHMID;
repl_instance.jnlpool_shmid_ctime = 0;
}
assert((INVALID_SHMID != shm_id) || ((NULL == jnlpool.jnlpool_ctl) && (NULL == jnlpool_ctl)));
ipc_rmvd = TRUE;
if (INVALID_SHMID != shm_id)
{
replpool_id->pool_type = JNLPOOL_SEGMENT;
jnlpool_stat = mu_rndwn_replpool(replpool_id, &repl_instance, shm_id, &ipc_rmvd);
ipcs_ptr = i2asc((uchar_ptr_t)ipcs_buff, shm_id);
*ipcs_ptr = '\0';
if (rndwn_both_pools && ((SS_NORMAL != jnlpool_stat) || ipc_rmvd))
gtm_putmsg(VARLSTCNT(6) (jnlpool_stat ? ERR_MUJPOOLRNDWNFL : ERR_MUJPOOLRNDWNSUC),
4, LEN_AND_STR(ipcs_buff), LEN_AND_STR(instfilename));
}
assert(ipc_rmvd || (NULL != jnlpool_ctl));
assert((NULL == jnlpool.jnlpool_ctl) || (SS_NORMAL == jnlpool_stat) || jgbl.onlnrlbk);
assert((INVALID_SHMID != repl_instance.jnlpool_shmid) || (0 == repl_instance.jnlpool_shmid_ctime));
assert((INVALID_SHMID == repl_instance.jnlpool_shmid) || (0 != repl_instance.jnlpool_shmid_ctime));
assert(INVALID_SEMID != sem_id);
if (!mur_options.rollback)
{ /* Invoked by MUPIP RUNDOWN in which case the semaphores needs to be removed. But, remove the
* semaphore ONLY if we created it here OR the journal pool was successfully removed.
*/
if (NULL == jnlpool_ctl)
{
if (((sem_created || (SS_NORMAL == jnlpool_stat))
&& (SS_NORMAL == mu_replpool_release_sem(&repl_instance, JNLPOOL_SEGMENT, TRUE))))
{ /* Now that semaphores are removed, reset fields in file header */
if (!sem_created)
{ /* If sem_id was created by mu_replpool_grab_sem then do NOT report the
* MURPOOLRNDWNSUC message as it indicates that the semaphore was orphaned
* and we removed it when in fact there was no orphaned semaphore and we
* created it as part of mu_replpool_grab_sem to get standalone access to
* rundown the receiver pool (which may or may not exist)
*/
ipcs_ptr = i2asc((uchar_ptr_t)ipcs_buff, sem_id);
*ipcs_ptr = '\0';
gtm_putmsg(VARLSTCNT(9) ERR_MUJPOOLRNDWNSUC, 4, LEN_AND_STR(ipcs_buff),
LEN_AND_STR(instfilename), ERR_SEMREMOVED, 1, sem_id);
}
repl_inst_jnlpool_reset();
}
} else
{ /* Anticipatory Freeze scheme is turned ON. So, release just the JNL_POOL_ACCESS_SEM. The
* semaphore will be released/removed in the caller (mupip_rundown)
*/
assert(ANTICIPATORY_FREEZE_AVAILABLE);
assertpro(SS_NORMAL == (status = rel_sem(SOURCE, JNL_POOL_ACCESS_SEM)));
assert(!holds_sem[SOURCE][JNL_POOL_ACCESS_SEM]);
/* Since we are not resetting the semaphore IDs in the file header, we need to write out
* the semaphore IDs in the instance file (if we created them).
*/
if (sem_created)
repl_inst_write(instfilename, (off_t)0, (sm_uc_ptr_t)&repl_instance,
SIZEOF(repl_inst_hdr));
}
/* If semaphore is not created and the journal pool rundown failed (due to attached processes),
* rundown process continues to holds the journal pool access control semaphore. This way, we hold
* the semaphore on behalf of the source server (now no longer alive) to prevent mu_rndwn_sem_all
* (invoked later) from cleaning up this orphaned semaphore (which causes REPLREQROLLBACK if the
* source server is restarted). But, since the semaphore is not released (until the rundown process
* dies), holds_sem[SOURCE][JNL_POOL_ACCESS_SEM] continues to remain TRUE. This causes asserts in
* ftok_sem_get if mu_rndwn_repl_instance is invoked for a different journal/receive pool. To
* workaround it, set holds_sem[SOURCE][JNL_POOL_ACCESS_SEM] to FALSE. This is an interim solution
* until we record such semaphores in an ignore-list (or some such) and change mu_rndwn_sem_all to
* skip the ones that are present in the ignore list.
*/
holds_sem[SOURCE][JNL_POOL_ACCESS_SEM] = FALSE;
}
} else if (rndwn_both_pools && (INVALID_SHMID != shm_id))
{
ipcs_ptr = i2asc((uchar_ptr_t)ipcs_buff, shm_id);
*ipcs_ptr = '\0';
if (rndwn_both_pools)
gtm_putmsg(VARLSTCNT(6) ERR_MUJPOOLRNDWNFL, 4, LEN_AND_STR(ipcs_buff),
LEN_AND_STR(instfilename));
}
*jnlpool_sem_created = sem_created;
}
if (((SS_NORMAL == jnlpool_stat) || !jgbl.mur_rollback) &&
(rndwn_both_pools || (RECVPOOL_SEGMENT == replpool_id->pool_type)))
{ /* --------------------------
* Now rundown Receivpool
* --------------------------
* Note: RECVPOOL is rundown ONLY if the JNLPOOL rundown was successful. This way, we don't end up
* creating new semaphores for the RECVPOOL if ROLLBACK is not going to start anyways because of the failed
* JNLPOOL rundown. The only exception is MUPIP RUNDOWN command in which case we try running down the
* RECVPOOL even if the JNLPOOL rundown failed.
*/
shm_id = repl_instance.recvpool_shmid;
if (SS_NORMAL == (recvpool_stat = mu_replpool_grab_sem(&repl_instance, RECVPOOL_SEGMENT, &sem_created, immediate)))
{
sem_id = repl_instance.recvpool_semid;
if ((INVALID_SHMID == shm_id) || (-1 == shmctl(shm_id, IPC_STAT, &shmstat))
|| (shmstat.shm_ctime != repl_instance.recvpool_shmid_ctime))
{
repl_instance.recvpool_shmid = shm_id = INVALID_SHMID;
repl_instance.recvpool_shmid_ctime = 0;
}
ipc_rmvd = TRUE;
if (INVALID_SHMID != shm_id)
{
replpool_id->pool_type = RECVPOOL_SEGMENT;
recvpool_stat = mu_rndwn_replpool(replpool_id, &repl_instance, shm_id, &ipc_rmvd);
ipcs_ptr = i2asc((uchar_ptr_t)ipcs_buff, shm_id);
*ipcs_ptr = '\0';
if (rndwn_both_pools && ((SS_NORMAL != recvpool_stat) || ipc_rmvd))
gtm_putmsg(VARLSTCNT(6) (recvpool_stat ? ERR_MURPOOLRNDWNFL : ERR_MURPOOLRNDWNSUC),
4, LEN_AND_STR(ipcs_buff), LEN_AND_STR(instfilename));
}
assert((TRUE == ipc_rmvd) || (SS_NORMAL != recvpool_stat) || jgbl.onlnrlbk);
assert((INVALID_SHMID != repl_instance.recvpool_shmid) || (0 == repl_instance.recvpool_shmid_ctime));
assert((INVALID_SHMID == repl_instance.recvpool_shmid) || (0 != repl_instance.recvpool_shmid_ctime));
assert(INVALID_SEMID != sem_id);
if (!mur_options.rollback)
{ /* Invoked by MUPIP RUNDOWN in which case the semaphores needs to be removed. But, remove the
* semaphore ONLY if we created it here OR the receive pool was successfully removed.
*/
if ((sem_created || (SS_NORMAL == recvpool_stat))
&& (SS_NORMAL == mu_replpool_release_sem(&repl_instance, RECVPOOL_SEGMENT, TRUE)))
{ /* Now that semaphores are removed, reset fields in file header */
if (!sem_created)
{ /* if sem_id was "created" by mu_replpool_grab_sem then do NOT report the
* MURPOOLRNDWNSUC message as it indicates that the semaphore was orphaned and we
* removed it when in fact there was no orphaned semaphore and we "created" it as
* part of mu_replpool_grab_sem to get standalone access to rundown the receiver
* pool (which may or may not exist)
*/
ipcs_ptr = i2asc((uchar_ptr_t)ipcs_buff, sem_id);
*ipcs_ptr = '\0';
gtm_putmsg(VARLSTCNT(9) ERR_MURPOOLRNDWNSUC, 4, LEN_AND_STR(ipcs_buff),
LEN_AND_STR(instfilename), ERR_SEMREMOVED, 1, sem_id);
}
if (NULL != jnlpool_ctl)
{ /* Journal pool is not yet removed. So, grab lock before resetting semid/shmid
* fields in the file header as the function expects the caller to hold crit
* if the journal pool is available
*/
repl_csa = &FILE_INFO(jnlpool.jnlpool_dummy_reg)->s_addrs;
assert(!repl_csa->now_crit);
assert(!repl_csa->hold_onto_crit);
was_crit = repl_csa->now_crit;
/* Since we do grab_lock, below, we need to do a per-process initialization. Also,
* start heartbeat so that grab_lock can issue MUTEXLCKALERT and get C-stacks if
* waiting for crit
*/
START_HEARTBEAT_IF_NEEDED;
mutex_per_process_init();
if (!was_crit)
grab_lock(jnlpool.jnlpool_dummy_reg, TRUE, GRAB_LOCK_ONLY);
}
repl_inst_recvpool_reset();
if ((NULL != jnlpool_ctl) && !was_crit)
rel_lock(jnlpool.jnlpool_dummy_reg);
}
/* If semaphore is not created and the receive pool rundown failed (due to attached processes),
* rundown process continues to holds the receive pool access control semaphore. This way, we hold
* the semaphore on behalf of the receiver server (now no longer alive) to prevent mu_rndwn_sem_all
* (invoked later) from cleaning up this orphaned semaphore (which causes REPLREQROLLBACK if the
* receiver is restarted). But, since the semaphore is not released (until the rundown process
* dies), holds_sem[RECV][RECV_POOL_ACCESS_SEM] continues to remain TRUE. This causes asserts in
* ftok_sem_get if mu_rndwn_repl_instance is invoked for a different journal/receive pool. To
* workaround it, set holds_sem[SOURCE][RECV_POOL_ACCESS_SEM] to FALSE. This is an interim solution
* until we record such semaphores in an ignore-list (or some such) and change mu_rndwn_sem_all to
* skip the ones that are present in the ignore list.
*/
assert((sem_created || (SS_NORMAL == recvpool_stat)) || holds_sem[RECV][RECV_POOL_ACCESS_SEM]);
DEBUG_ONLY(set_sem_set_recvr(sem_id));
}
} else if (rndwn_both_pools && (INVALID_SHMID != shm_id))
{
ipcs_ptr = i2asc((uchar_ptr_t)ipcs_buff, shm_id);
*ipcs_ptr = '\0';
if (rndwn_both_pools)
gtm_putmsg(VARLSTCNT(6) ERR_MURPOOLRNDWNFL, 4, LEN_AND_STR(ipcs_buff),
LEN_AND_STR(instfilename));
}
}
assert(jgbl.onlnrlbk || ANTICIPATORY_FREEZE_AVAILABLE || (NULL == jnlpool.repl_inst_filehdr));
if (mur_options.rollback && (SS_NORMAL == jnlpool_stat) && (SS_NORMAL == recvpool_stat))
{
assert(jgbl.onlnrlbk || ANTICIPATORY_FREEZE_AVAILABLE || ((INVALID_SHMID == repl_instance.jnlpool_shmid)
&& (INVALID_SHMID == repl_instance.recvpool_shmid)));
/* Initialize jnlpool.repl_inst_filehdr as it is used later by gtmrecv_fetchresync() */
decr_cnt = FALSE;
if (NULL == jnlpool.repl_inst_filehdr)
{ /* Possible if there is NO journal pool in the first place. In this case, malloc the structure here and
* copy the file header from repl_instance structure.
*/
jnlpool.repl_inst_filehdr = (repl_inst_hdr_ptr_t)malloc(SIZEOF(repl_inst_hdr));
memcpy(jnlpool.repl_inst_filehdr, &repl_instance, SIZEOF(repl_inst_hdr));
} else
{
assert(repl_instance.jnlpool_semid == jnlpool.repl_inst_filehdr->jnlpool_semid);
assert(repl_instance.jnlpool_semid_ctime == jnlpool.repl_inst_filehdr->jnlpool_semid_ctime);
assert(repl_instance.jnlpool_shmid == jnlpool.repl_inst_filehdr->jnlpool_shmid);
assert(repl_instance.jnlpool_shmid_ctime == jnlpool.repl_inst_filehdr->jnlpool_shmid_ctime);
/* If the ONLINE ROLLBACK command is run on the primary when the source server is up and running,
* jnlpool.repl_inst_filehdr->recvpool_semid will be INVALID because there is NO receiver server
* running. However, ROLLBACK creates semaphores for both journal pool and receive pool and writes
* it to the instance file header. Copy this information to the file header copy in the jnlpool
* as well
*/
jnlpool.repl_inst_filehdr->recvpool_semid = repl_instance.recvpool_semid;
jnlpool.repl_inst_filehdr->recvpool_semid_ctime = repl_instance.recvpool_semid_ctime;
}
/* Flush changes to the replication instance file header to disk */
repl_inst_write(instfilename, (off_t)0, (sm_uc_ptr_t)&repl_instance, SIZEOF(repl_inst_hdr));
} else /* for MUPIP RUNDOWN, semid fields in the file header are reset and is written in mu_replpool_release_sem() above */
decr_cnt = (NULL == jnlpool_ctl); /* for anticipatory freeze, mupip_rundown releases the semaphore */
REVERT;
/* Release replication instance ftok semaphore lock */
if (!ftok_sem_release(reg, decr_cnt, immediate)) /* Do not decrement the counter if ROLLBACK */
return FALSE;
return ((SS_NORMAL == jnlpool_stat) && (SS_NORMAL == recvpool_stat));
}
/*
* This will rundown a replication instance journal (and receiver) pool.
* Input Parameter:
* replpool_id of the instance. Instance file name must be null terminated in replpool_id.
* Returns :
* TRUE, if successful.
* FALSE, otherwise.
*/
boolean_t mu_rndwn_repl_instance(replpool_identifier *replpool_id, boolean_t immediate, boolean_t rndwn_both_pools)
{
boolean_t jnlpool_stat = TRUE, recvpool_stat = TRUE;
char *instfilename, shmid_buff[TMP_BUF_LEN];
gd_region *r_save;
repl_inst_hdr repl_instance;
static gd_region *reg = NULL;
struct semid_ds semstat;
struct shmid_ds shmstat;
union semun semarg;
uchar_ptr_t ret_ptr;
unix_db_info *udi;
int save_errno;
error_def(ERR_MUJPOOLRNDWNSUC);
error_def(ERR_MURPOOLRNDWNSUC);
error_def(ERR_MUJPOOLRNDWNFL);
error_def(ERR_MURPOOLRNDWNFL);
error_def(ERR_SEMREMOVED);
error_def(ERR_REPLACCSEM);
error_def(ERR_SYSCALL);
if (NULL == reg)
{
r_save = gv_cur_region;
mu_gv_cur_reg_init();
reg = gv_cur_region;
gv_cur_region = r_save;
}
jnlpool.jnlpool_dummy_reg = reg;
recvpool.recvpool_dummy_reg = reg;
instfilename = replpool_id->instfilename;
reg->dyn.addr->fname_len = strlen(instfilename);
assert(0 == instfilename[reg->dyn.addr->fname_len]);
memcpy((char *)reg->dyn.addr->fname, instfilename, reg->dyn.addr->fname_len + 1);
udi = FILE_INFO(reg);
udi->fn = (char *)reg->dyn.addr->fname;
/* Lock replication instance using ftok semaphore */
if (!ftok_sem_get(reg, TRUE, REPLPOOL_ID, immediate))
return FALSE;
repl_inst_read(instfilename, (off_t)0, (sm_uc_ptr_t)&repl_instance, SIZEOF(repl_inst_hdr));
semarg.buf = &semstat;
assert(rndwn_both_pools || JNLPOOL_SEGMENT == replpool_id->pool_type || RECVPOOL_SEGMENT == replpool_id->pool_type);
if (rndwn_both_pools || (JNLPOOL_SEGMENT == replpool_id->pool_type))
{ /* --------------------------
* First rundown Journal pool
* --------------------------
*/
if (INVALID_SEMID != repl_instance.jnlpool_semid)
if ((-1 == semctl(repl_instance.jnlpool_semid, 0, IPC_STAT, semarg)) ||
(semarg.buf->sem_ctime != repl_instance.jnlpool_semid_ctime))
repl_instance.jnlpool_semid = INVALID_SEMID;
if (INVALID_SHMID != repl_instance.jnlpool_shmid)
if ((-1 == shmctl(repl_instance.jnlpool_shmid, IPC_STAT, &shmstat)) ||
(shmstat.shm_ctime != repl_instance.jnlpool_shmid_ctime))
repl_instance.jnlpool_shmid = INVALID_SHMID;
if (INVALID_SHMID != repl_instance.jnlpool_shmid)
{
replpool_id->pool_type = JNLPOOL_SEGMENT;
jnlpool_stat = mu_rndwn_replpool(replpool_id, repl_instance.jnlpool_semid, repl_instance.jnlpool_shmid);
ret_ptr = i2asc((uchar_ptr_t)shmid_buff, repl_instance.jnlpool_shmid);
*ret_ptr = '\0';
if (rndwn_both_pools)
gtm_putmsg(VARLSTCNT(6) (jnlpool_stat ? ERR_MUJPOOLRNDWNSUC : ERR_MUJPOOLRNDWNFL),
4, LEN_AND_STR(shmid_buff), LEN_AND_STR(replpool_id->instfilename));
} else if (INVALID_SEMID != repl_instance.jnlpool_semid)
{
if (0 == sem_rmid(repl_instance.jnlpool_semid))
{ /* note that shmid_buff used here is actually a buffer to hold semid (not shmid) */
ret_ptr = i2asc((uchar_ptr_t)shmid_buff, repl_instance.jnlpool_semid);
*ret_ptr = '\0';
gtm_putmsg(VARLSTCNT(9) ERR_MUJPOOLRNDWNSUC, 4, LEN_AND_STR(shmid_buff),
LEN_AND_STR(replpool_id->instfilename), ERR_SEMREMOVED, 1, repl_instance.jnlpool_semid);
} else
{
save_errno = errno;
gtm_putmsg(VARLSTCNT(13) ERR_REPLACCSEM, 3, repl_instance.jnlpool_semid,
RTS_ERROR_STRING(instfilename), ERR_SYSCALL, 5, RTS_ERROR_LITERAL("jnlpool sem_rmid()"),
CALLFROM, save_errno);
}
/* Note that jnlpool_stat is not set to FALSE in case sem_rmid() fails above. This is because the
* journal pool is anyway not present and it is safer to reset the sem/shmids in the instance file.
* The only thing this might cause is a stranded semaphore but that is considered better than getting
* errors due to not resetting instance file.
*/
}
if (jnlpool_stat) /* Reset instance file for jnlpool info */
repl_inst_jnlpool_reset();
}
if (rndwn_both_pools || (RECVPOOL_SEGMENT == replpool_id->pool_type))
{ /* --------------------------
* Now rundown Receivpool
* --------------------------
*/
if (INVALID_SEMID != repl_instance.recvpool_semid)
if ((-1 == semctl(repl_instance.recvpool_semid, 0, IPC_STAT, semarg)) ||
(semarg.buf->sem_ctime != repl_instance.recvpool_semid_ctime))
repl_instance.recvpool_semid = INVALID_SEMID;
if (INVALID_SHMID != repl_instance.recvpool_shmid)
if ((-1 == shmctl(repl_instance.recvpool_shmid, IPC_STAT, &shmstat)) ||
(shmstat.shm_ctime != repl_instance.recvpool_shmid_ctime))
repl_instance.recvpool_shmid = INVALID_SHMID;
if (INVALID_SHMID != repl_instance.recvpool_shmid)
{
replpool_id->pool_type = RECVPOOL_SEGMENT;
recvpool_stat = mu_rndwn_replpool(replpool_id, repl_instance.recvpool_semid, repl_instance.recvpool_shmid);
ret_ptr = i2asc((uchar_ptr_t)shmid_buff, repl_instance.recvpool_shmid);
*ret_ptr = '\0';
if (rndwn_both_pools)
gtm_putmsg(VARLSTCNT(6) (recvpool_stat ? ERR_MURPOOLRNDWNSUC : ERR_MURPOOLRNDWNFL),
4, LEN_AND_STR(shmid_buff), LEN_AND_STR(replpool_id->instfilename));
} else if (INVALID_SEMID != repl_instance.recvpool_semid)
{
if (0 == sem_rmid(repl_instance.recvpool_semid))
{ /* note that shmid_buff used here is actually a buffer to hold semid (not shmid) */
ret_ptr = i2asc((uchar_ptr_t)shmid_buff, repl_instance.recvpool_semid);
*ret_ptr = '\0';
gtm_putmsg(VARLSTCNT(9) ERR_MURPOOLRNDWNSUC, 4, LEN_AND_STR(shmid_buff),
LEN_AND_STR(replpool_id->instfilename), ERR_SEMREMOVED, 1, repl_instance.recvpool_semid);
} else
{
save_errno = errno;
gtm_putmsg(VARLSTCNT(13) ERR_REPLACCSEM, 3, repl_instance.recvpool_semid,
RTS_ERROR_STRING(instfilename), ERR_SYSCALL, 5, RTS_ERROR_LITERAL("recvpool sem_rmid()"),
CALLFROM, save_errno);
}
/* Note that recvpool_stat is not set to FALSE in case sem_rmid() fails above. This is because the
* journal pool is anyway not present and it is safer to reset the sem/shmids in the instance file.
* The only thing this might cause is a stranded semaphore but that is considered better than getting
* errors due to not resetting instance file.
*/
}
if (recvpool_stat) /* Reset instance file for recvpool info */
repl_inst_recvpool_reset();
}
/* Release replication instance ftok semaphore lock */
if (!ftok_sem_release(reg, TRUE, immediate))
return FALSE;
return (jnlpool_stat && recvpool_stat);
}
/* 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;
}
/*
* Description:
* Grab ftok semaphore on replication instance file
* Grab all replication semaphores for the instance (both jnlpool and recvpool)
* Release ftok semaphore
* Parameters:
* Return Value: TRUE, if succsessful
* FALSE, if fails.
*/
boolean_t mu_replpool_grab_sem(boolean_t immediate)
{
char instfilename[MAX_FN_LEN + 1];
gd_region *r_save;
static gd_region *replreg;
int status, save_errno;
union semun semarg;
struct semid_ds semstat;
repl_inst_hdr repl_instance;
unix_db_info *udi;
unsigned int full_len;
error_def(ERR_RECVPOOLSETUP);
error_def(ERR_JNLPOOLSETUP);
error_def(ERR_REPLFTOKSEM);
error_def(ERR_TEXT);
if (NULL == replreg)
{
r_save = gv_cur_region;
mu_gv_cur_reg_init();
replreg = gv_cur_region;
gv_cur_region = r_save;
}
jnlpool.jnlpool_dummy_reg = replreg;
recvpool.recvpool_dummy_reg = replreg;
if (!repl_inst_get_name(instfilename, &full_len, MAX_FN_LEN + 1, issue_rts_error))
GTMASSERT; /* rts_error should have been issued by repl_inst_get_name */
assert(full_len);
memcpy((char *)replreg->dyn.addr->fname, instfilename, full_len);
replreg->dyn.addr->fname_len = full_len;
udi = FILE_INFO(replreg);
udi->fn = (char *)replreg->dyn.addr->fname;
if (!ftok_sem_get(replreg, TRUE, REPLPOOL_ID, immediate))
rts_error(VARLSTCNT(4) ERR_REPLFTOKSEM, 2, full_len, instfilename);
repl_inst_read(instfilename, (off_t)0, (sm_uc_ptr_t)&repl_instance, SIZEOF(repl_inst_hdr));
/*
* --------------------------
* First semaphores of jnlpool
* --------------------------
*/
if (-1 == (udi->semid = init_sem_set_source(IPC_PRIVATE, NUM_SRC_SEMS, RWDALL | IPC_CREAT)))
{
ftok_sem_release(replreg, TRUE, TRUE);
rts_error(VARLSTCNT(7) ERR_JNLPOOLSETUP, 0, ERR_TEXT, 2,
RTS_ERROR_LITERAL("Error creating journal pool"), REPL_SEM_ERRNO);
}
semarg.val = GTM_ID;
if (-1 == semctl(udi->semid, SOURCE_ID_SEM, SETVAL, semarg))
{
save_errno = errno;
remove_sem_set(SOURCE); /* Remove what we created */
ftok_sem_release(replreg, TRUE, TRUE);
rts_error(VARLSTCNT(7) ERR_JNLPOOLSETUP, 0, ERR_TEXT, 2,
RTS_ERROR_LITERAL("Error with jnlpool semctl"), save_errno);
}
semarg.buf = &semstat;
if (-1 == semctl(udi->semid, 0, IPC_STAT, semarg))
{
save_errno = errno;
remove_sem_set(SOURCE); /* Remove what we created */
ftok_sem_release(replreg, TRUE, TRUE);
rts_error(VARLSTCNT(7) ERR_JNLPOOLSETUP, 0, ERR_TEXT, 2,
RTS_ERROR_LITERAL("Error with jnlpool semctl"), save_errno);
}
udi->gt_sem_ctime = semarg.buf->sem_ctime;
status = grab_sem_all_source();
if (0 != status)
{
remove_sem_set(SOURCE); /* Remove what we created */
ftok_sem_release(replreg, TRUE, TRUE);
rts_error(VARLSTCNT(1) ERR_JNLPOOLSETUP);
}
repl_instance.jnlpool_semid = udi->semid;
repl_instance.jnlpool_semid_ctime = udi->gt_sem_ctime;
/*
* --------------------------
* Now semaphores of recvpool
* --------------------------
*/
assert(NUM_SRC_SEMS == NUM_RECV_SEMS);
if (-1 == (udi->semid = init_sem_set_recvr(IPC_PRIVATE, NUM_RECV_SEMS, RWDALL | IPC_CREAT)))
{
remove_sem_set(SOURCE);
ftok_sem_release(replreg, TRUE, TRUE);
rts_error(VARLSTCNT(7) ERR_RECVPOOLSETUP, 0,
ERR_TEXT, 2,
RTS_ERROR_LITERAL("Error creating recv pool"), REPL_SEM_ERRNO);
}
semarg.val = GTM_ID;
if (-1 == semctl(udi->semid, RECV_ID_SEM, SETVAL, semarg))
{
save_errno = errno;
remove_sem_set(SOURCE);
remove_sem_set(RECV);
ftok_sem_release(replreg, TRUE, TRUE);
rts_error(VARLSTCNT(7) ERR_RECVPOOLSETUP, 0, ERR_TEXT, 2,
RTS_ERROR_LITERAL("Error with recvpool semctl"), save_errno);
}
semarg.buf = &semstat;
if (-1 == semctl(udi->semid, 0, IPC_STAT, semarg)) /* For creation time */
{
save_errno = errno;
remove_sem_set(SOURCE);
remove_sem_set(RECV);
ftok_sem_release(replreg, TRUE, TRUE);
rts_error(VARLSTCNT(7) ERR_RECVPOOLSETUP, 0, ERR_TEXT, 2,
RTS_ERROR_LITERAL("Error with recvpool semctl"), save_errno);
}
udi->gt_sem_ctime = semarg.buf->sem_ctime;
status = grab_sem_all_receive();
if (0 != status)
{
remove_sem_set(SOURCE);
remove_sem_set(RECV);
ftok_sem_release(replreg, TRUE, TRUE);
rts_error(VARLSTCNT(1) ERR_RECVPOOLSETUP);
}
repl_instance.recvpool_semid = udi->semid;
repl_instance.recvpool_semid_ctime = udi->gt_sem_ctime;
/* Initialize jnlpool.repl_inst_filehdr as it is used later by gtmrecv_fetchresync() */
assert(NULL == jnlpool.repl_inst_filehdr);
jnlpool.repl_inst_filehdr = (repl_inst_hdr_ptr_t)malloc(SIZEOF(repl_inst_hdr));
memcpy(jnlpool.repl_inst_filehdr, &repl_instance, SIZEOF(repl_inst_hdr));
/* Flush changes to the replication instance file header to disk */
repl_inst_write(instfilename, (off_t)0, (sm_uc_ptr_t)&repl_instance, SIZEOF(repl_inst_hdr));
/* Now release jnlpool/recvpool ftok semaphore */
if (!ftok_sem_release(replreg, FALSE, immediate))
{
remove_sem_set(SOURCE);
remove_sem_set(RECV);
rts_error(VARLSTCNT(4) ERR_REPLFTOKSEM, 2, full_len, instfilename);
}
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));
}
cm_region_head *gtcmd_ini_reg(connection_struct *cnx)
{
cm_region_head *ptr,*last;
struct stat stat_buf;
unsigned char *fname, buff[256];
unsigned short len;
uint4 status, retlen;
unsigned char node[MAX_HOST_NAME_LEN];
sgmnt_addrs *csa;
error_def (ERR_DBOPNERR);
ptr = 0;
fname = cnx->clb_ptr->mbf;
fname++;
GET_USHORT(len, fname); /* len = *((unsigned short *)fname); */
fname += sizeof(unsigned short);
buff[len] = 0;
memcpy(buff, fname, len);
STAT_FILE((char *)buff, &stat_buf, status);
if (-1 == status)
rts_error(VARLSTCNT(5) ERR_DBOPNERR, 2, len, fname, errno);
last = reglist;
for (ptr = reglist ; ptr ; ptr = ptr->next)
{
if (is_gdid_stat_identical(&FILE_INFO(ptr->reg)->fileid, &stat_buf))
break;
last = ptr;
}
if (!ptr)
{
/* open region */
ptr = (cm_region_head*)malloc(sizeof(*ptr));
ptr->next = NULL;
ptr->last = NULL;
ptr->head.fl = ptr->head.bl = 0;
SET_LATCH_GLOBAL(&ptr->head.latch, LOCK_AVAILABLE);
if (!last)
reglist = ptr;
else
{
last->next = ptr;
ptr->last = last;
}
mu_gv_cur_reg_init();
ptr->reg = gv_cur_region;
ptr->refcnt = 0;
ptr->wakeup = 0;
ptr->reg->open = FALSE;
csa = &FILE_INFO(ptr->reg)->s_addrs;
csa->now_crit = FALSE;
csa->nl = (node_local_ptr_t)malloc(sizeof(node_local));
assert(MAX_FN_LEN > len);
memcpy(ptr->reg->dyn.addr->fname, fname, len);
ptr->reg->dyn.addr->fname_len = len;
set_gdid_from_stat(&FILE_INFO(ptr->reg)->fileid, &stat_buf);
ptr->reg_hash = (htab_desc *)malloc(sizeof(htab_desc));
if (-1 != gethostname((char *)node, sizeof(node)))
{
retlen = strlen((char *)node);
retlen = MIN(retlen, MAX_RN_LEN - 1);
memcpy(ptr->reg->rname, node, retlen);
} else
retlen = 0;
ptr->reg->rname[retlen] = ':';
ptr->reg->rname_len = retlen + 1;
gtcmd_cst_init(ptr);
} else if (!ptr->reg->open)
{
gv_cur_region = ptr->reg;
ptr->wakeup = 0; /* Because going to reinit ctl->wakeups when open region */
gtcmd_cst_init(ptr);
} else
gv_cur_region = ptr->reg;
return ptr;
}
