gtm_uint64_t gds_file_size(file_control *fc)
{
unix_db_info *udi;
int fstat_res;
struct stat stat_buf;
udi = (unix_db_info *)fc->file_info;
FSTAT_FILE(udi->fd, &stat_buf, fstat_res);
if (-1 == fstat_res)
rts_error(VARLSTCNT(5) ERR_DBFILOPERR, 2, LEN_AND_STR(udi->fn), errno);
assert(0 == stat_buf.st_size % DISK_BLOCK_SIZE);
return (gtm_uint64_t)(stat_buf.st_size / DISK_BLOCK_SIZE);
}
int4 disk_block_available(int fd, GTM_BAVAIL_TYPE *ret, boolean_t fill_unix_holes)
{
struct stat fstat_buf;
struct statvfs fstatvfs_buf;
int status;
FSTATVFS_FILE(fd, &fstatvfs_buf, status);
if (-1 == status)
return errno;
*ret = (GTM_BAVAIL_TYPE)((fstatvfs_buf.f_frsize / DISK_BLOCK_SIZE) * fstatvfs_buf.f_bavail);
if (fill_unix_holes)
{
FSTAT_FILE(fd, &fstat_buf, status);
if (-1 == status)
return errno;
*ret -= (GTM_BAVAIL_TYPE)(DEV_BSIZE / DISK_BLOCK_SIZE
* (DIVIDE_ROUND_UP(fstat_buf.st_size, DEV_BSIZE) - fstat_buf.st_blocks));
}
return 0;
}
boolean_t mur_fopen_sp(jnl_ctl_list *jctl)
{
struct stat stat_buf;
int status, perms;
error_def(ERR_JNLFILEOPNERR);
error_def(ERR_SYSCALL);
perms = O_RDONLY;
jctl->read_only = TRUE;
/* Both for recover and rollback open in read/write mode. We do not need to write in journal file
* for mupip journal extract/show/verify or recover -forward. So open it as read-only
*/
if (mur_options.update && !mur_options.forward)
{
perms = O_RDWR;
jctl->read_only = FALSE;
}
jctl->channel = OPEN((char *)jctl->jnl_fn, perms);
if (-1 != jctl->channel)
{
FSTAT_FILE(jctl->channel, &stat_buf, status);
if (-1 != status)
{
jctl->os_filesize = (off_jnl_t)stat_buf.st_size;
return TRUE;
}
jctl->status = errno;
CLOSEFILE(jctl->channel, status);
} else
jctl->status = errno;
if (ENOENT == jctl->status) /* File Not Found is a common error, so no need for SYSCALL */
gtm_putmsg(VARLSTCNT(5) ERR_JNLFILEOPNERR, 2, jctl->jnl_fn_len, jctl->jnl_fn, jctl->status);
else
gtm_putmsg(VARLSTCNT(12) ERR_JNLFILEOPNERR, 2, jctl->jnl_fn_len, jctl->jnl_fn, ERR_SYSCALL, 5,
LEN_AND_STR((-1 == jctl->channel) ? "open" : "fstat"), CALLFROM, jctl->status);
jctl->channel = NOJNL;
return FALSE;
}
/* Given a journal file name, this function opens that file explicitly without going through "jnl_ensure_open" */
int repl_open_jnl_file_by_name(repl_ctl_element *tmp_ctl, int jnl_fn_len, char *jnl_fn, int *fd_ptr, void *stat_buf_ptr)
{
int tmp_fd;
int status;
#ifdef UNIX
struct stat stat_buf;
#elif defined(VMS)
struct FAB fab;
struct NAM stat_buf;
#else
#error Unsupported platform
#endif
tmp_ctl->jnl_fn_len = jnl_fn_len;
memcpy(tmp_ctl->jnl_fn, jnl_fn, jnl_fn_len);
tmp_ctl->jnl_fn[jnl_fn_len] = '\0';
status = SS_NORMAL;
/* Open Journal File */
# ifdef UNIX
OPENFILE(tmp_ctl->jnl_fn, O_RDONLY, tmp_fd);
if (0 > tmp_fd)
{
status = errno;
assert(FALSE);
}
if (SS_NORMAL == status)
{
FSTAT_FILE(tmp_fd, &stat_buf, status);
if (0 > status)
{
status = errno;
assert(FALSE);
}
# ifdef __MVS
else if (-1 == gtm_zos_tag_to_policy(tmp_fd, TAG_BINARY))
{
status = errno;
assert(FALSE);
}
# endif
}
*((struct stat *)stat_buf_ptr) = stat_buf;
# elif defined(VMS)
fab = cc$rms_fab;
fab.fab$l_fna = tmp_ctl->jnl_fn;
fab.fab$b_fns = tmp_ctl->jnl_fn_len;
fab.fab$l_fop = FAB$M_UFO;
fab.fab$b_fac = FAB$M_GET | FAB$M_PUT | FAB$M_BIO;
fab.fab$b_shr = FAB$M_SHRPUT | FAB$M_SHRGET | FAB$M_UPI;
stat_buf = cc$rms_nam;
fab.fab$l_nam = &stat_buf;
fab.fab$l_dna = JNL_EXT_DEF;
fab.fab$b_dns = SIZEOF(JNL_EXT_DEF) - 1;
status = sys$open(&fab);
if (RMS$_NORMAL == status)
{
status = SS_NORMAL;
tmp_fd = fab.fab$l_stv;
}
assert(SS_NORMAL == status);
*((struct NAM *)stat_buf_ptr) = stat_buf;
# endif
REPL_DPRINT2("CTL INIT : Direct open of file %s\n", tmp_ctl->jnl_fn);
*fd_ptr = tmp_fd;
return status;
}
void iorm_close(io_desc *iod, mval *pp)
{
d_rm_struct *rm_ptr;
unsigned char c;
char *path, *path2;
int fclose_res;
int stat_res;
int fstat_res;
struct stat statbuf, fstatbuf;
int p_offset;
assert (iod->type == rm);
if (iod->state != dev_open)
return;
rm_ptr = (d_rm_struct *)iod->dev_sp;
iorm_use(iod,pp);
if (iod->dollar.x && rm_ptr->lastop == RM_WRITE && !iod->dollar.za)
iorm_flush(iod);
p_offset = 0;
while (*(pp->str.addr + p_offset) != iop_eol)
{
switch (c = *(pp->str.addr + p_offset++))
{
case iop_delete:
path = iod->trans_name->dollar_io;
FSTAT_FILE(rm_ptr->fildes, &fstatbuf, fstat_res);
if (-1 == fstat_res)
rts_error(VARLSTCNT(1) errno);
STAT_FILE(path, &statbuf, stat_res);
if (-1 == stat_res)
rts_error(VARLSTCNT(1) errno);
if (fstatbuf.st_ino == statbuf.st_ino)
if (UNLINK(path) == -1)
rts_error(VARLSTCNT(1) errno);
break;
case iop_rename:
path = iod->trans_name->dollar_io;
path2 = (char*)(pp->str.addr + p_offset + 1);
FSTAT_FILE(rm_ptr->fildes, &fstatbuf, fstat_res);
if (-1 == fstat_res)
rts_error(VARLSTCNT(1) errno);
STAT_FILE(path, &statbuf, stat_res);
if (-1 == stat_res)
rts_error(VARLSTCNT(1) errno);
if (fstatbuf.st_ino == statbuf.st_ino)
{ if (LINK(path, path2) == -1)
rts_error(VARLSTCNT(1) errno);
if (UNLINK(path) == -1)
rts_error(VARLSTCNT(1) errno);
}
break;
default:
break;
}
p_offset += ( io_params_size[c]==IOP_VAR_SIZE ?
(unsigned char)(*(pp->str.addr + p_offset) + 1) : io_params_size[c] );
}
if (iod->pair.in != iod)
assert (iod->pair.out == iod);
if (iod->pair.out != iod)
assert (iod->pair.in == iod);
iod->state = dev_closed;
iod->dollar.zeof = FALSE;
iod->dollar.x = 0;
iod->dollar.y = 0;
rm_ptr->lastop = RM_NOOP;
/* Do the close first. If the fclose() is done first and we are being called from io_rundown just prior to the execv
in a newly JOBbed off process, the fclose() does an implied fflush() which is known to do an lseek() which resets
the file pointers of any open (flat) files in the parent due to an archane interaction between child and parent
processes prior to an execv() call. The fclose (for stream files) will fail but it will clean up structures orphaned
by the close().
*/
close(rm_ptr->fildes);
if (rm_ptr->filstr != NULL)
FCLOSE(rm_ptr->filstr, fclose_res);
#ifdef __MVS__
if (rm_ptr->fifo)
{
if (rm_ptr != (iod->pair.out)->dev_sp || rm_ptr != (iod->pair.in)->dev_sp)
{
if (rm_ptr != (iod->pair.out)->dev_sp)
{
rm_ptr = (iod->pair.out)->dev_sp;
iod = iod->pair.out;
}
else
{
rm_ptr = (iod->pair.in)->dev_sp;
iod = iod->pair.in;
}
assert(NULL != rm_ptr);
if(dev_closed != iod->state)
{
iod->state = dev_closed;
iod->dollar.zeof = FALSE;
iod->dollar.x = 0;
iod->dollar.y = 0;
rm_ptr->lastop = RM_NOOP;
assert(rm_ptr->fildes>=0);
close(rm_ptr->fildes);
if (rm_ptr->filstr != NULL)
fclose(rm_ptr->filstr);
}
}
}
#endif
return;
}
void db_init(gd_region *reg, sgmnt_data_ptr_t tsd)
{
static boolean_t mutex_init_done = FALSE;
boolean_t is_bg, read_only;
char machine_name[MAX_MCNAMELEN];
file_control *fc;
int gethostname_res, stat_res, mm_prot;
int4 status, semval, dblksize, fbwsize;
sm_long_t status_l;
sgmnt_addrs *csa;
sgmnt_data_ptr_t csd;
struct sembuf sop[3];
struct stat stat_buf;
union semun semarg;
struct semid_ds semstat;
struct shmid_ds shmstat;
struct statvfs dbvfs;
uint4 sopcnt;
unix_db_info *udi;
#ifdef periodic_timer_removed
void periodic_flush_check();
#endif
error_def(ERR_CLSTCONFLICT);
error_def(ERR_CRITSEMFAIL);
error_def(ERR_DBNAMEMISMATCH);
error_def(ERR_DBIDMISMATCH);
error_def(ERR_NLMISMATCHCALC);
error_def(ERR_REQRUNDOWN);
error_def(ERR_SYSCALL);
assert(tsd->acc_meth == dba_bg || tsd->acc_meth == dba_mm);
is_bg = (dba_bg == tsd->acc_meth);
read_only = reg->read_only;
new_dbinit_ipc = FALSE; /* we did not create a new ipc resource */
udi = FILE_INFO(reg);
memset(machine_name, 0, sizeof(machine_name));
if (GETHOSTNAME(machine_name, MAX_MCNAMELEN, gethostname_res))
rts_error(VARLSTCNT(5) ERR_TEXT, 2, LEN_AND_LIT("Unable to get the hostname"), errno);
assert(strlen(machine_name) < MAX_MCNAMELEN);
csa = &udi->s_addrs;
csa->db_addrs[0] = csa->db_addrs[1] = csa->lock_addrs[0] = NULL; /* to help in dbinit_ch and gds_rundown */
reg->opening = TRUE;
/*
* Create ftok semaphore for this region.
* We do not want to make ftok counter semaphore to be 2 for on mupip journal recover process.
*/
if (!ftok_sem_get(reg, !mupip_jnl_recover, GTM_ID, FALSE))
rts_error(VARLSTCNT(4) ERR_DBFILERR, 2, DB_LEN_STR(reg));
/*
* At this point we have ftok_semid sempahore based on ftok key.
* Any ftok conflicted region will block at this point.
* Say, a.dat and b.dat both has same ftok and we have process A to access a.dat and
* process B to access b.dat. In this case only one can continue to do db_init()
*/
fc = reg->dyn.addr->file_cntl;
fc->file_type = reg->dyn.addr->acc_meth;
fc->op = FC_READ;
fc->op_buff = (sm_uc_ptr_t)tsd;
fc->op_len = sizeof(*tsd);
fc->op_pos = 1;
dbfilop(fc); /* Read file header */
udi->shmid = tsd->shmid;
udi->semid = tsd->semid;
udi->sem_ctime = tsd->sem_ctime.ctime;
udi->shm_ctime = tsd->shm_ctime.ctime;
dbsecspc(reg, tsd); /* Find db segment size */
if (!mupip_jnl_recover)
{
if (INVALID_SEMID == udi->semid)
{
if (0 != udi->sem_ctime || INVALID_SHMID != udi->shmid || 0 != udi->shm_ctime)
/* We must have somthing wrong in protocol or, code, if this happens */
GTMASSERT;
/*
* Create new semaphore using IPC_PRIVATE. System guarantees a unique id.
*/
if (-1 == (udi->semid = semget(IPC_PRIVATE, FTOK_SEM_PER_ID, RWDALL | IPC_CREAT)))
{
udi->semid = INVALID_SEMID;
rts_error(VARLSTCNT(9) ERR_DBFILERR, 2, DB_LEN_STR(reg),
ERR_TEXT, 2, LEN_AND_LIT("Error with database control semget"), errno);
}
udi->shmid = INVALID_SHMID; /* reset shmid so dbinit_ch does not get confused in case we go there */
new_dbinit_ipc = TRUE;
tsd->semid = udi->semid;
semarg.val = GTM_ID;
/*
* Following will set semaphore number 2 (=FTOK_SEM_PER_ID - 1) value as GTM_ID.
* In case we have orphaned semaphore for some reason, mupip rundown will be
* able to identify GTM semaphores from the value and can remove.
*/
if (-1 == semctl(udi->semid, FTOK_SEM_PER_ID - 1, SETVAL, semarg))
rts_error(VARLSTCNT(9) ERR_DBFILERR, 2, DB_LEN_STR(reg),
ERR_TEXT, 2, LEN_AND_LIT("Error with database control semctl SETVAL"), errno);
/*
* Warning: We must read the sem_ctime using IPC_STAT after SETVAL, which changes it.
* We must NOT do any more SETVAL after this. Our design is to use
* sem_ctime as creation time of semaphore.
*/
semarg.buf = &semstat;
if (-1 == semctl(udi->semid, FTOK_SEM_PER_ID - 1, IPC_STAT, semarg))
rts_error(VARLSTCNT(9) ERR_DBFILERR, 2, DB_LEN_STR(reg),
ERR_TEXT, 2, LEN_AND_LIT("Error with database control semctl IPC_STAT"), errno);
tsd->sem_ctime.ctime = udi->sem_ctime = semarg.buf->sem_ctime;
} else
{
if (INVALID_SHMID == udi->shmid)
/* if mu_rndwn_file gets standalone access of this region and
* somehow mupip process crashes, we can have semid != -1 but shmid == -1
*/
rts_error(VARLSTCNT(10) ERR_REQRUNDOWN, 4, DB_LEN_STR(reg), LEN_AND_STR(tsd->machine_name),
ERR_TEXT, 2, LEN_AND_LIT("semid is valid but shmid is invalid"));
semarg.buf = &semstat;
if (-1 == semctl(udi->semid, 0, IPC_STAT, semarg))
/* file header has valid semid but semaphore does not exists */
rts_error(VARLSTCNT(6) ERR_REQRUNDOWN, 4, DB_LEN_STR(reg), LEN_AND_STR(tsd->machine_name));
else if (semarg.buf->sem_ctime != tsd->sem_ctime.ctime)
rts_error(VARLSTCNT(10) ERR_REQRUNDOWN, 4, DB_LEN_STR(reg), LEN_AND_STR(tsd->machine_name),
ERR_TEXT, 2, LEN_AND_LIT("sem_ctime does not match"));
if (-1 == shmctl(udi->shmid, IPC_STAT, &shmstat))
rts_error(VARLSTCNT(9) ERR_DBFILERR, 2, DB_LEN_STR(reg),
ERR_TEXT, 2, LEN_AND_LIT("Error with database control shmctl"), errno);
else if (shmstat.shm_ctime != tsd->shm_ctime.ctime)
rts_error(VARLSTCNT(10) ERR_REQRUNDOWN, 4, DB_LEN_STR(reg), LEN_AND_STR(tsd->machine_name),
ERR_TEXT, 2, LEN_AND_LIT("shm_ctime does not match"));
}
/* We already have ftok semaphore of this region, so just plainly do semaphore operation */
/* This is the database access control semaphore for any region */
sop[0].sem_num = 0; sop[0].sem_op = 0; /* Wait for 0 */
sop[1].sem_num = 0; sop[1].sem_op = 1; /* Lock */
sopcnt = 2;
if (!read_only)
{
sop[2].sem_num = 1; sop[2].sem_op = 1; /* increment r/w access counter */
sopcnt = 3;
}
sop[0].sem_flg = sop[1].sem_flg = sop[2].sem_flg = SEM_UNDO | IPC_NOWAIT;
SEMOP(udi->semid, sop, sopcnt, status);
if (-1 == status)
{
errno_save = errno;
gtm_putmsg(VARLSTCNT(4) ERR_CRITSEMFAIL, 2, DB_LEN_STR(reg));
rts_error(VARLSTCNT(8) ERR_SYSCALL, 5, RTS_ERROR_LITERAL("semop()"), CALLFROM, errno_save);
}
} else /* for mupip_jnl_recover we were already in mu_rndwn_file and got "semid" semaphore */
{
if (INVALID_SEMID == udi->semid || 0 == udi->sem_ctime)
/* make sure mu_rndwn_file() has reset created semaphore for standalone access */
GTMASSERT;
if (INVALID_SHMID != udi->shmid || 0 != udi->shm_ctime)
/* make sure mu_rndwn_file() has reset shared memory */
GTMASSERT;
udi->shmid = INVALID_SHMID; /* reset shmid so dbinit_ch does not get confused in case we go there */
new_dbinit_ipc = TRUE;
}
sem_incremented = TRUE;
if (new_dbinit_ipc)
{
/* Create new shared memory using IPC_PRIVATE. System guarantees a unique id */
#ifdef __MVS__
if (-1 == (status_l = udi->shmid = shmget(IPC_PRIVATE, ROUND_UP(reg->sec_size, MEGA_BOUND),
__IPC_MEGA | IPC_CREAT | RWDALL)))
#else
if (-1 == (status_l = udi->shmid = shmget(IPC_PRIVATE, reg->sec_size, RWDALL | IPC_CREAT)))
#endif
{
udi->shmid = status_l = INVALID_SHMID;
rts_error(VARLSTCNT(9) ERR_DBFILERR, 2, DB_LEN_STR(reg),
ERR_TEXT, 2, LEN_AND_LIT("Error with database shmget"), errno);
}
tsd->shmid = udi->shmid;
if (-1 == shmctl(udi->shmid, IPC_STAT, &shmstat))
rts_error(VARLSTCNT(9) ERR_DBFILERR, 2, DB_LEN_STR(reg),
ERR_TEXT, 2, LEN_AND_LIT("Error with database control shmctl"), errno);
tsd->shm_ctime.ctime = udi->shm_ctime = shmstat.shm_ctime;
}
#ifdef DEBUG_DB64
status_l = (sm_long_t)(csa->db_addrs[0] = (sm_uc_ptr_t)do_shmat(udi->shmid, next_smseg, SHM_RND));
next_smseg = (sm_uc_ptr_t)ROUND_UP((sm_long_t)(next_smseg + reg->sec_size), SHMAT_ADDR_INCS);
#else
status_l = (sm_long_t)(csa->db_addrs[0] = (sm_uc_ptr_t)do_shmat(udi->shmid, 0, SHM_RND));
#endif
if (-1 == status_l)
{
rts_error(VARLSTCNT(9) ERR_DBFILERR, 2, DB_LEN_STR(reg),
ERR_TEXT, 2, LEN_AND_LIT("Error attaching to database shared memory"), errno);
}
csa->nl = (node_local_ptr_t)csa->db_addrs[0];
csa->critical = (mutex_struct_ptr_t)(csa->db_addrs[0] + NODE_LOCAL_SIZE);
assert(((int)csa->critical & 0xf) == 0); /* critical should be 16-byte aligned */
#ifdef CACHELINE_SIZE
assert(0 == ((int)csa->critical & (CACHELINE_SIZE - 1)));
#endif
/* Note: Here we check jnl_sate from database file and its value cannot change without standalone access.
* The jnl_buff buffer should be initialized irrespective of read/write process */
JNL_INIT(csa, reg, tsd);
csa->backup_buffer = (backup_buff_ptr_t)(csa->db_addrs[0] + NODE_LOCAL_SPACE + JNL_SHARE_SIZE(tsd));
csa->lock_addrs[0] = (sm_uc_ptr_t)csa->backup_buffer + BACKUP_BUFFER_SIZE + 1;
csa->lock_addrs[1] = csa->lock_addrs[0] + LOCK_SPACE_SIZE(tsd) - 1;
csa->total_blks = tsd->trans_hist.total_blks; /* For test to see if file has extended */
if (new_dbinit_ipc)
{
memset(csa->nl, 0, sizeof(*csa->nl)); /* We allocated shared storage -- we have to init it */
if (JNL_ALLOWED(csa))
{ /* initialize jb->cycle to a value different from initial value of jpc->cycle (0). although this is not
* necessary right now, in the future, the plan is to change jnl_ensure_open() to only do a cycle mismatch
* check in order to determine whether to call jnl_file_open() or not. this is in preparation for that.
*/
csa->jnl->jnl_buff->cycle = 1;
}
}
if (is_bg)
csd = csa->hdr = (sgmnt_data_ptr_t)(csa->lock_addrs[1] + 1 + CACHE_CONTROL_SIZE(tsd));
else
{
csa->acc_meth.mm.mmblk_state = (mmblk_que_heads_ptr_t)(csa->lock_addrs[1] + 1);
FSTAT_FILE(udi->fd, &stat_buf, stat_res);
if (-1 == stat_res)
rts_error(VARLSTCNT(5) ERR_DBFILERR, 2, DB_LEN_STR(reg), errno);
mm_prot = read_only ? PROT_READ : (PROT_READ | PROT_WRITE);
#ifdef DEBUG_DB64
if (-1 == (sm_long_t)(csa->db_addrs[0] = (sm_uc_ptr_t)mmap((caddr_t)get_mmseg((size_t)stat_buf.st_size),
(size_t)stat_buf.st_size,
mm_prot,
GTM_MM_FLAGS, udi->fd, (off_t)0)))
rts_error(VARLSTCNT(5) ERR_DBFILERR, 2, DB_LEN_STR(reg), errno);
put_mmseg((caddr_t)(csa->db_addrs[0]), (size_t)stat_buf.st_size);
#else
if (-1 == (sm_long_t)(csa->db_addrs[0] = (sm_uc_ptr_t)mmap((caddr_t)NULL,
(size_t)stat_buf.st_size,
mm_prot,
GTM_MM_FLAGS, udi->fd, (off_t)0)))
rts_error(VARLSTCNT(5) ERR_DBFILERR, 2, DB_LEN_STR(reg), errno);
#endif
csa->db_addrs[1] = csa->db_addrs[0] + stat_buf.st_size - 1;
csd = csa->hdr = (sgmnt_data_ptr_t)csa->db_addrs[0];
}
if (!csa->nl->glob_sec_init)
{
assert(new_dbinit_ipc);
if (is_bg)
*csd = *tsd;
if (csd->machine_name[0]) /* crash occured */
{
if (0 != memcmp(csd->machine_name, machine_name, MAX_MCNAMELEN)) /* crashed on some other node */
rts_error(VARLSTCNT(6) ERR_CLSTCONFLICT, 4, DB_LEN_STR(reg), LEN_AND_STR(csd->machine_name));
else
rts_error(VARLSTCNT(6) ERR_REQRUNDOWN, 4, DB_LEN_STR(reg), LEN_AND_STR(csd->machine_name));
}
if (is_bg)
{
bt_malloc(csa);
csa->nl->cache_off = -CACHE_CONTROL_SIZE(tsd);
db_csh_ini(csa);
}
db_csh_ref(csa);
strcpy(csa->nl->machine_name, machine_name); /* machine name */
assert(MAX_REL_NAME > gtm_release_name_len);
memcpy(csa->nl->now_running, gtm_release_name, gtm_release_name_len + 1); /* GT.M release name */
memcpy(csa->nl->label, GDS_LABEL, GDS_LABEL_SZ - 1); /* GDS label */
memcpy(csa->nl->fname, reg->dyn.addr->fname, reg->dyn.addr->fname_len); /* database filename */
csa->nl->creation_date_time = csd->creation.date_time;
csa->nl->highest_lbm_blk_changed = -1;
csa->nl->wcs_timers = -1;
csa->nl->nbb = BACKUP_NOT_IN_PROGRESS;
csa->nl->unique_id.uid = FILE_INFO(reg)->fileid; /* save what file we initialized this storage for */
/* save pointers in csa to access shared memory */
csa->nl->critical = (sm_off_t)((sm_uc_ptr_t)csa->critical - (sm_uc_ptr_t)csa->nl);
if (JNL_ALLOWED(csa))
csa->nl->jnl_buff = (sm_off_t)((sm_uc_ptr_t)csa->jnl->jnl_buff - (sm_uc_ptr_t)csa->nl);
csa->nl->backup_buffer = (sm_off_t)((sm_uc_ptr_t)csa->backup_buffer - (sm_uc_ptr_t)csa->nl);
csa->nl->hdr = (sm_off_t)((sm_uc_ptr_t)csd - (sm_uc_ptr_t)csa->nl);
csa->nl->lock_addrs = (sm_off_t)((sm_uc_ptr_t)csa->lock_addrs[0] - (sm_uc_ptr_t)csa->nl);
if (!read_only || is_bg)
{
csd->trans_hist.early_tn = csd->trans_hist.curr_tn;
csd->max_update_array_size = csd->max_non_bm_update_array_size
= ROUND_UP2(MAX_NON_BITMAP_UPDATE_ARRAY_SIZE(csd), UPDATE_ARRAY_ALIGN_SIZE);
csd->max_update_array_size += ROUND_UP2(MAX_BITMAP_UPDATE_ARRAY_SIZE, UPDATE_ARRAY_ALIGN_SIZE);
/* add current db_csh counters into the cumulative counters and reset the current counters */
#define TAB_DB_CSH_ACCT_REC(COUNTER, DUMMY1, DUMMY2) \
csd->COUNTER.cumul_count += csd->COUNTER.curr_count; \
csd->COUNTER.curr_count = 0;
#include "tab_db_csh_acct_rec.h"
#undef TAB_DB_CSH_ACCT_REC
}
if (!read_only)
{
if (is_bg)
{
assert(memcmp(csd, GDS_LABEL, GDS_LABEL_SZ - 1) == 0);
LSEEKWRITE(udi->fd, (off_t)0, (sm_uc_ptr_t)csd, sizeof(sgmnt_data), errno_save);
if (0 != errno_save)
{
rts_error(VARLSTCNT(9) ERR_DBFILERR, 2, DB_LEN_STR(reg),
ERR_TEXT, 2, LEN_AND_LIT("Error with database write"), errno_save);
}
}
}
reg->dyn.addr->ext_blk_count = csd->extension_size;
mlk_shr_init(csa->lock_addrs[0], csd->lock_space_size, csa, (FALSE == read_only));
DEBUG_ONLY(locknl = csa->nl;) /* for DEBUG_ONLY LOCK_HIST macro */
bool same_device_check (mstr tname, char *buf)
{
int fstat_res, gsn_stat;
struct stat outbuf1, outbuf2;
GTM_SOCKLEN_TYPE socknamelen1;
GTM_SOCKLEN_TYPE socknamelen2;
GTM_SOCKLEN_TYPE psocknamelen1;
GTM_SOCKLEN_TYPE psocknamelen2;
struct sockaddr_storage sockname1;
struct sockaddr_storage sockname2;
struct sockaddr_storage psockname1;
struct sockaddr_storage psockname2;
char port_buffer1[NI_MAXSERV];
char port_buffer2[NI_MAXSERV];
char pport_buffer1[NI_MAXSERV];
char pport_buffer2[NI_MAXSERV];
char host_buffer1[NI_MAXHOST];
char host_buffer2[NI_MAXHOST];
char phost_buffer1[NI_MAXHOST];
char phost_buffer2[NI_MAXHOST];
int errcode, tmplen, save_errno;
const char *errptr;
FSTAT_FILE(0, &outbuf1, fstat_res);
if (-1 == fstat_res)
{
save_errno = errno;
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(8) ERR_SYSCALL, 5, RTS_ERROR_LITERAL("fstat"), CALLFROM, save_errno);
}
FSTAT_FILE(1, &outbuf2, fstat_res);
if (-1 == fstat_res)
{
save_errno = errno;
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(8) ERR_SYSCALL, 5, RTS_ERROR_LITERAL("fstat"), CALLFROM, save_errno);
}
if ((S_IFMT & outbuf1.st_mode) != (S_IFMT & outbuf2.st_mode))
return FALSE;
if (S_ISSOCK(outbuf1.st_mode))
{
/* if here then both 0,1 are sockets */
socknamelen1 = SIZEOF(sockname1);
if (-1 == (gsn_stat = getsockname(0, (struct sockaddr *)&sockname1, (GTM_SOCKLEN_TYPE *)&socknamelen1)))
{
save_errno = errno;
if (IS_SOCKNAME_UNIXERROR(save_errno))
{
/* problem with getsockname for AF_UNIX socket so just assign family for the switch below */
(((sockaddr_ptr)&sockname1)->sa_family) = AF_UNIX;
} else
{
/* process error */
errptr = (char *)STRERROR(save_errno);
tmplen = STRLEN(errptr);
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(5) ERR_GETSOCKNAMERR, 3, save_errno, tmplen, errptr);
}
}
socknamelen2 = SIZEOF(sockname2);
if (-1 == (gsn_stat = getsockname(1, (struct sockaddr *)&sockname2, (GTM_SOCKLEN_TYPE *)&socknamelen2)))
{
save_errno = errno;
if (IS_SOCKNAME_UNIXERROR(save_errno))
{
/* problem with getsockname for AF_UNIX socket so just assign family for the switch below */
(((sockaddr_ptr)&sockname2)->sa_family) = AF_UNIX;
} else
{
/* process error */
errptr = (char *)STRERROR(save_errno);
tmplen = STRLEN(errptr);
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(5) ERR_GETSOCKNAMERR, 3, save_errno, tmplen, errptr);
}
}
/* if both sockets not the same family then not the same device */
if ((((sockaddr_ptr)&sockname1)->sa_family) != (((sockaddr_ptr)&sockname2)->sa_family))
return FALSE;
switch(((sockaddr_ptr)&sockname1)->sa_family)
{
case AF_INET:
case AF_INET6:
GETNAMEINFO((struct sockaddr *)&sockname1, socknamelen1, host_buffer1, NI_MAXHOST,
port_buffer1, NI_MAXSERV, NI_NUMERICHOST|NI_NUMERICSERV, errcode);
if (0 != errcode)
{
RTS_ERROR_ADDRINFO(NULL, ERR_GETNAMEINFO, errcode);
return FALSE;
}
GETNAMEINFO((struct sockaddr *)&sockname2, socknamelen2, host_buffer2, NI_MAXHOST,
port_buffer2, NI_MAXSERV, NI_NUMERICHOST|NI_NUMERICSERV, errcode);
if (0 != errcode)
{
RTS_ERROR_ADDRINFO(NULL, ERR_GETNAMEINFO, errcode);
return FALSE;
}
/* hosts and ports must be the same */
if (STRCMP(host_buffer1, host_buffer2) || STRCMP(port_buffer1, port_buffer2))
return FALSE;
psocknamelen1 = SIZEOF(psockname1);
if (-1 == (gsn_stat = getpeername(0, (struct sockaddr *)&psockname1,
(GTM_SOCKLEN_TYPE *)&psocknamelen1)))
{
save_errno = errno;
errptr = (char *)STRERROR(save_errno);
tmplen = STRLEN(errptr);
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(5) ERR_GETSOCKNAMERR, 3, save_errno, tmplen, errptr);
}
psocknamelen2 = SIZEOF(psockname2);
if (-1 == (gsn_stat = getpeername(1, (struct sockaddr *)&psockname2,
(GTM_SOCKLEN_TYPE *)&psocknamelen2)))
{
save_errno = errno;
errptr = (char *)STRERROR(save_errno);
tmplen = STRLEN(errptr);
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(5) ERR_GETSOCKNAMERR, 3, save_errno, tmplen, errptr);
}
GETNAMEINFO((struct sockaddr *)&psockname1, psocknamelen1, phost_buffer1, NI_MAXHOST,
pport_buffer1, NI_MAXSERV, NI_NUMERICHOST|NI_NUMERICSERV, errcode);
if (0 != errcode)
{
RTS_ERROR_ADDRINFO(NULL, ERR_GETNAMEINFO, errcode);
return FALSE;
}
GETNAMEINFO((struct sockaddr *)&psockname2, psocknamelen2, phost_buffer2, NI_MAXHOST,
pport_buffer2, NI_MAXSERV, NI_NUMERICHOST|NI_NUMERICSERV, errcode);
if (0 != errcode)
{
RTS_ERROR_ADDRINFO(NULL, ERR_GETNAMEINFO, errcode);
return FALSE;
}
/* hosts and ports for the peer sockets must also be the same */
if (STRCMP(phost_buffer1, phost_buffer2) || STRCMP(pport_buffer1, pport_buffer2))
return FALSE;
break;
case AF_UNIX:
default:
/* if inodes are different or st_dev different then not the same device */
if ((outbuf1.st_ino != outbuf2.st_ino) || (outbuf1.st_dev != outbuf2.st_dev))
return FALSE;
break;
}
return TRUE;
} else if (S_ISCHR(outbuf1.st_mode))
{
/* if here then both 0,1 are character devices */
/* if inodes are different or st_dev different then not the same device */
if ((outbuf1.st_ino != outbuf2.st_ino) || (outbuf1.st_dev != outbuf2.st_dev))
return FALSE;
else
return TRUE;
} else
{
/* unexpected type so assert */
assert(FALSE);
return FALSE;
}
}
static bool mu_open_try(io_log_name *naml, io_log_name *tl, mval *pp, mval *mspace)
{
int4 status;
int4 size;
mstr tn; /* translated name */
mstr chset_mstr;
int oflag;
unsigned char ch;
int file_des;
struct stat outbuf;
char *buf, namebuf[LOGNAME_LEN + 1];
d_mt_struct *mt_ptr;
int umask_orig, umask_creat;
int char_or_block_special;
int fstat_res;
int save_errno;
int p_offset;
boolean_t ichset_specified, ochset_specified;
error_def(ERR_SYSCALL);
mt_ptr = NULL;
char_or_block_special = FALSE;
file_des = -2;
oflag = 0;
tn.len = tl->len;
if (tn.len > LOGNAME_LEN)
tn.len = LOGNAME_LEN;
tn.addr = tl->dollar_io;
memcpy(namebuf, tn.addr, tn.len);
namebuf[tn.len] = '\0';
buf = namebuf;
if (0 == naml->iod)
{
if (0 == tl->iod)
{
tl->iod = (io_desc *)malloc(sizeof(io_desc));
memset((char*)tl->iod, 0, sizeof(io_desc));
tl->iod->pair.in = tl->iod;
tl->iod->pair.out = tl->iod;
tl->iod->trans_name = tl;
tl->iod->type = n_io_dev_types;
p_offset = 0;
while(iop_eol != *(pp->str.addr + p_offset))
{
ch = *(pp->str.addr + p_offset++);
if (iop_sequential == ch)
tl->iod->type = rm;
if (IOP_VAR_SIZE == io_params_size[ch])
p_offset += *(pp->str.addr + p_offset) + 1;
else
p_offset += io_params_size[ch];
}
}
if ((n_io_dev_types == tl->iod->type) && mspace && mspace->str.len)
tl->iod->type = us;
if (n_io_dev_types == tl->iod->type)
{
if (0 == memvcmp(tn.addr, tn.len, sys_input.addr, sys_input.len))
{
file_des = 0;
FSTAT_FILE(file_des, &outbuf, fstat_res);
if (-1 == fstat_res)
{
save_errno = errno;
rts_error(VARLSTCNT(8) ERR_SYSCALL, 5,
RTS_ERROR_LITERAL("fstat()"),
CALLFROM, save_errno);
}
} else
{
if (0 == memvcmp(tn.addr, tn.len, sys_output.addr, sys_output.len))
{
file_des = 1;
FSTAT_FILE(file_des, &outbuf, fstat_res);
if (-1 == fstat_res)
{
save_errno = errno;
rts_error(VARLSTCNT(8) ERR_SYSCALL, 5,
RTS_ERROR_LITERAL("fstat()"),
CALLFROM, save_errno);
}
} else if (0 == memvcmp(tn.addr, tn.len, "/dev/null", 9))
tl->iod->type = nl;
else if ((-1 == Stat(buf, &outbuf)) && (n_io_dev_types == tl->iod->type))
{
if (ENOENT == errno)
tl->iod->type = rm;
else
{
save_errno = errno;
rts_error(VARLSTCNT(8) ERR_SYSCALL, 5,
RTS_ERROR_LITERAL("fstat()"),
CALLFROM, save_errno);
}
}
}
}
if (n_io_dev_types == tl->iod->type)
{
switch(outbuf.st_mode & S_IFMT)
{
case S_IFCHR:
case S_IFBLK:
char_or_block_special = TRUE;
break;
case S_IFIFO:
tl->iod->type = ff;
break;
case S_IFREG:
case S_IFDIR:
tl->iod->type = rm;
break;
case S_IFSOCK:
case 0:
tl->iod->type = ff;
break;
default:
break;
}
}
naml->iod = tl->iod;
}
active_device = naml->iod;
if ((-2 == file_des) && (dev_open != naml->iod->state) && (us != naml->iod->type) && (tcp != naml->iod->type))
{
oflag |= (O_RDWR | O_CREAT | O_NOCTTY);
size = 0;
p_offset = 0;
ichset_specified = ochset_specified = FALSE;
while(iop_eol != *(pp->str.addr + p_offset))
{
assert((params) *(pp->str.addr + p_offset) < (params)n_iops);
switch ((ch = *(pp->str.addr + p_offset++)))
{
case iop_allocation:
if (rm == naml->iod->type)
{
GET_LONG(size, pp->str.addr + p_offset);
size *= 512;
}
break;
case iop_append:
if (rm == naml->iod->type)
oflag |= O_APPEND;
break;
case iop_contiguous:
break;
case iop_newversion:
if ((dev_open != naml->iod->state) && (rm == naml->iod->type))
oflag |= O_TRUNC;
break;
case iop_readonly:
oflag &= ~(O_RDWR | O_CREAT | O_WRONLY);
oflag |= O_RDONLY;
break;
case iop_writeonly:
oflag &= ~(O_RDWR | O_RDONLY);
oflag |= O_WRONLY | O_CREAT;
break;
case iop_ipchset:
#ifdef KEEP_zOS_EBCDIC
if ( (iconv_t)0 != naml->iod->input_conv_cd )
{
ICONV_CLOSE_CD(naml->iod->input_conv_cd);
}
SET_CODE_SET(naml->iod->in_code_set,
(char *)(pp->str.addr + p_offset + 1));
if (DEFAULT_CODE_SET != naml->iod->in_code_set)
ICONV_OPEN_CD(naml->iod->input_conv_cd,
(char *)(pp->str.addr + p_offset + 1), INSIDE_CH_SET);
break;
#endif
if (gtm_utf8_mode)
{
chset_mstr.addr = (char *)(pp->str.addr + p_offset + 1);
chset_mstr.len = *(pp->str.addr + p_offset);
SET_ENCODING(naml->iod->ichset, &chset_mstr);
ichset_specified = TRUE;
}
break;
case iop_opchset:
#ifdef KEEP_zOS_EBCDIC
if ( (iconv_t)0 != naml->iod->output_conv_cd)
{
ICONV_CLOSE_CD(naml->iod->output_conv_cd);
}
SET_CODE_SET(naml->iod->out_code_set,
(char *)(pp->str.addr + p_offset + 1));
if (DEFAULT_CODE_SET != naml->iod->out_code_set)
ICONV_OPEN_CD(naml->iod->output_conv_cd, INSIDE_CH_SET,
(char *)(pp->str.addr + p_offset + 1));
break;
#endif
if (gtm_utf8_mode)
{
chset_mstr.addr = (char *)(pp->str.addr + p_offset + 1);
chset_mstr.len = *(pp->str.addr + p_offset);
SET_ENCODING(naml->iod->ochset, &chset_mstr);
ochset_specified = TRUE;
}
break;
case iop_m:
case iop_utf8:
case iop_utf16:
case iop_utf16be:
case iop_utf16le:
if (gtm_utf8_mode)
{
naml->iod->ichset = naml->iod->ochset =
(iop_m == ch) ? CHSET_M :
(iop_utf8 == ch) ? CHSET_UTF8 :
(iop_utf16 == ch) ? CHSET_UTF16 :
(iop_utf16be == ch) ? CHSET_UTF16BE : CHSET_UTF16LE;
ichset_specified = ochset_specified = TRUE;
}
break;
default:
break;
}
if (IOP_VAR_SIZE == io_params_size[ch])
p_offset += *(pp->str.addr + p_offset) + 1;
else
p_offset += io_params_size[ch];
}
if (!ichset_specified)
naml->iod->ichset = (gtm_utf8_mode) ? CHSET_UTF8 : CHSET_M;
if (!ochset_specified)
naml->iod->ochset = (gtm_utf8_mode) ? CHSET_UTF8 : CHSET_M;
if (CHSET_M != naml->iod->ichset && CHSET_UTF16 != naml->iod->ichset)
get_chset_desc(&chset_names[naml->iod->ichset]);
if (CHSET_M != naml->iod->ochset && CHSET_UTF16 != naml->iod->ochset)
get_chset_desc(&chset_names[naml->iod->ochset]);
/* RW permissions for owner and others as determined by umask. */
umask_orig = umask(000); /* determine umask (destructive) */
(void)umask(umask_orig); /* reset umask */
umask_creat = 0666 & ~umask_orig;
/*
* the check for EINTR below is valid and should not be converte d to an EINTR
* wrapper macro, due to the other errno values being checked.
*/
while ((-1 == (file_des = OPEN4(buf, oflag, umask_creat, size))))
{
if ( EINTR == errno
|| ETXTBSY == errno
|| ENFILE == errno
|| EBUSY == errno
|| ((mb == naml->iod->type) && (ENXIO == errno)))
continue;
else
break;
}
if (-1 == file_des)
return FALSE;
}
assert (tcp != naml->iod->type);
#ifdef KEEP_zOS_EBCDIC
SET_CODE_SET(naml->iod->in_code_set, OUTSIDE_CH_SET);
if (DEFAULT_CODE_SET != naml->iod->in_code_set)
ICONV_OPEN_CD(naml->iod->input_conv_cd, OUTSIDE_CH_SET, INSIDE_CH_SET);
SET_CODE_SET(naml->iod->out_code_set, OUTSIDE_CH_SET);
if (DEFAULT_CODE_SET != naml->iod->out_code_set)
ICONV_OPEN_CD(naml->iod->output_conv_cd, INSIDE_CH_SET, OUTSIDE_CH_SET);
#endif
/* smw 99/12/18 not possible to be -1 here */
if (-1 == file_des)
{
rts_error(VARLSTCNT(8) ERR_SYSCALL, 5,
RTS_ERROR_LITERAL("open()"),
CALLFROM, save_errno);
}
if (n_io_dev_types == naml->iod->type)
{
if (isatty(file_des))
naml->iod->type = tt;
else if (char_or_block_special && file_des > 2)
/* assume mag tape */
naml->iod->type = mt;
else
naml->iod->type = rm;
}
assert(naml->iod->type < n_io_dev_types);
naml->iod->disp_ptr = &io_dev_dispatch_mupip[naml->iod->type];
active_device = naml->iod;
if (dev_never_opened == naml->iod->state)
{
naml->iod->wrap = DEFAULT_IOD_WRAP;
naml->iod->width = DEFAULT_IOD_WIDTH;
naml->iod->length = DEFAULT_IOD_LENGTH;
naml->iod->write_filter = 0; /* MUPIP should not use FILTER */
}
if (dev_open != naml->iod->state)
{
naml->iod->dollar.x = 0;
naml->iod->dollar.y = 0;
naml->iod->dollar.za = 0;
naml->iod->dollar.zb[0] = 0;
}
status = (naml->iod->disp_ptr->open)(naml, pp, file_des, mspace, NO_M_TIMEOUT);
if (TRUE == status)
naml->iod->state = dev_open;
else if (dev_open == naml->iod->state)
naml->iod->state = dev_closed;
if (1 == file_des)
naml->iod->dollar.zeof = TRUE;
active_device = 0;
if (run_time)
return (status);
return TRUE;
}
/*
* This is a plain way to read file header.
* User needs to take care of concurrency issue etc.
* Parameters :
* fn : full name of a database file.
* header: Pointer to database file header structure (may not be in shared memory)
* len: size of header (may be just SGMNT_HDR_LEN or SIZEOF_FILE_HDR_MAX)
*/
boolean_t file_head_read(char *fn, sgmnt_data_ptr_t header, int4 len)
{
int save_errno, fd, header_size;
struct stat stat_buf;
error_def(ERR_DBFILOPERR);
error_def(ERR_DBNOTGDS);
header_size = sizeof(sgmnt_data);
OPENFILE(fn, O_RDONLY, fd);
if (-1 == fd)
{
save_errno = errno;
gtm_putmsg(VARLSTCNT(5) ERR_DBFILOPERR, 2, LEN_AND_STR(fn), save_errno);
return FALSE;
}
FSTAT_FILE(fd, &stat_buf, save_errno);
if (-1 == save_errno)
{
save_errno = errno;
gtm_putmsg(VARLSTCNT(5) ERR_DBFILOPERR, 2, LEN_AND_STR(fn), save_errno);
CLOSEFILE(fd, save_errno);
return FALSE;
}
if (!S_ISREG(stat_buf.st_mode) || stat_buf.st_size < header_size)
{
gtm_putmsg(VARLSTCNT(4) ERR_DBNOTGDS, 2, LEN_AND_STR(fn));
CLOSEFILE(fd, save_errno);
return FALSE;
}
LSEEKREAD(fd, 0, header, header_size, save_errno);
if (0 != save_errno)
{
gtm_putmsg(VARLSTCNT(5) ERR_DBFILOPERR, 2, LEN_AND_STR(fn), save_errno);
CLOSEFILE(fd, save_errno);
return FALSE;
}
if (memcmp(header->label, GDS_LABEL, GDS_LABEL_SZ - 1))
{
gtm_putmsg(VARLSTCNT(4) ERR_DBNOTGDS, 2, LEN_AND_STR(fn));
CLOSEFILE(fd, save_errno);
return FALSE;
}
CHECK_DB_ENDIAN(header, strlen(fn), fn);
assert(MASTER_MAP_SIZE_MAX >= MASTER_MAP_SIZE(header));
assert(SGMNT_HDR_LEN == len || SIZEOF_FILE_HDR(header) <= len);
if (SIZEOF_FILE_HDR(header) <= len)
{
LSEEKREAD(fd, ROUND_UP(SGMNT_HDR_LEN + 1, DISK_BLOCK_SIZE), MM_ADDR(header), MASTER_MAP_SIZE(header), save_errno);
if (0 != save_errno)
{
gtm_putmsg(VARLSTCNT(5) ERR_DBFILOPERR, 2, LEN_AND_STR(fn), save_errno);
CLOSEFILE(fd, save_errno);
return FALSE;
}
}
CLOSEFILE(fd, save_errno);
if (0 != save_errno)
{
gtm_putmsg(VARLSTCNT(5) ERR_DBFILOPERR, 2, LEN_AND_STR(fn), save_errno);
return FALSE;
}
return TRUE;
}
void iorm_write_utf(mstr *v)
{
int4 inchars, char_count; /* in characters */
int4 inlen, outbytes, mblen; /* in bytes */
int4 availwidth, usedwidth, mbwidth; /* in display columns */
int status, padsize,fstat_res,save_errno;
wint_t utf_code;
io_desc *iod;
d_rm_struct *rm_ptr;
unsigned char *inptr, *top, *nextmb, *outptr, *nextoutptr, *outstart, temppad, temppadarray[2];
char *out_ptr;
boolean_t utf8_active = TRUE; /* needed by GTM_IO_WCWIDTH macro */
boolean_t stream, wrap;
struct stat statbuf;
boolean_t ch_set;
iod = io_curr_device.out;
ESTABLISH_GTMIO_CH(&io_curr_device, ch_set);
rm_ptr = (d_rm_struct *)iod->dev_sp;
assert(NULL != rm_ptr);
inptr = (unsigned char *)v->addr;
inlen = v->len;
top = inptr + inlen;
if (!rm_ptr->fixed && 0 == iod->dollar.x)
rm_ptr->out_bytes = 0; /* user reset $X */
inchars = UTF8_LEN_STRICT(v->addr, v->len); /* validate and get good char count */
if (0 >= inchars)
{
REVERT_GTMIO_CH(&io_curr_device, ch_set);
return;
}
usedwidth = 0;
stream = rm_ptr->stream;
wrap = iod->wrap;
if (stream && !wrap)
{ /* For STREAM and NOWRAP, allow the entire record to be written without any record truncations/terminations */
availwidth = inlen; /* calculate worst case requirement of width (in chars) to write out input bytes */
rm_ptr->out_bytes = 0;
} else
availwidth = iod->width - iod->dollar.x;
outbytes = 0;
if (CHSET_UTF8 != iod->ochset)
{
outstart = nextoutptr = outptr = &rm_ptr->outbuf[rm_ptr->out_bytes];
if (!rm_ptr->done_1st_write)
{ /* get the file size */
FSTAT_FILE(rm_ptr->fildes, &statbuf, fstat_res);
if (-1 == fstat_res)
{
save_errno = errno;
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(8) ERR_SYSCALL, 5, RTS_ERROR_LITERAL("fstat"),
CALLFROM, save_errno);
}
if (CHSET_UTF16 == iod->ochset)
{ /* Write BOM but do not count it towards the bytes in the current record */
/* write BOM if file is empty */
if (0 == statbuf.st_size)
{
memcpy(outptr, UTF16BE_BOM, UTF16BE_BOM_LEN);
outbytes = UTF16BE_BOM_LEN;
if (rm_ptr->output_encrypted)
{
REALLOC_CRYPTBUF_IF_NEEDED(outbytes);
WRITE_ENCRYPTED_DATA(rm_ptr, iod->trans_name, outstart, outbytes,
pvt_crypt_buf.addr);
out_ptr = pvt_crypt_buf.addr;
} else
out_ptr = (char *)outstart;
DOWRITERC_RM(rm_ptr, out_ptr, outbytes, status);
ISSUE_NOPRINCIO_IF_NEEDED_RM(status, ==, iod);
rm_ptr->write_occurred = TRUE;
outptr = outstart;
rm_ptr->out_bytes = outbytes = 0;
/* save UTF16BE_BOM_LEN in bom_num_bytes until bom is checked, but don't
indicate that bom has been checked - which still needs to be done for reading
the exception is if the file was opened WRITEONLY */
rm_ptr->bom_num_bytes = UTF16BE_BOM_LEN;
if (rm_ptr->write_only)
rm_ptr->bom_checked = TRUE;
}
iod->ochset = CHSET_UTF16BE;
get_chset_desc(&chset_names[iod->ochset]);
}
void mupip_upgrade(void)
{
bool rbno;
unsigned char *upgrd_buff[2], upgrd_label[GDS_LABEL_SZ]="UPGRADE0304";
char fn[256];
char answer[4];
unsigned short fn_len;
int4 fd, save_errno, old_hdr_size, new_hdr_size, status, bufsize, dsize, datasize[2];
int4 old_hdr_size_vbn, new_hdr_size_vbn;
int fstat_res;
off_t last_full_grp_startoff, old_file_len, old_file_len2, read_off, write_off, old_start_vbn_off;
block_id last_full_grp_startblk;
v3_sgmnt_data old_head_data, *old_head;
sgmnt_data new_head_data, *new_head;
struct stat stat_buf;
error_def(ERR_MUNODBNAME);
error_def(ERR_MUNOUPGRD);
error_def(ERR_DBOPNERR);
error_def(ERR_DBRDONLY);
error_def(ERR_DBFILOPERR);
error_def(ERR_DBPREMATEOF);
ESTABLISH(mupip_upgrade_ch);
fn_len = sizeof(fn);
if (!cli_get_str("FILE", fn, &fn_len))
rts_error(VARLSTCNT(1) ERR_MUNODBNAME);
if (!(mupip_upgrade_standalone(fn, &upgrade_standalone_sems)))
rts_error(VARLSTCNT(1) ERR_MUNOUPGRD);
if (-1 == (fd = OPEN(fn, O_RDWR)))
{
save_errno = errno;
if (-1 != (fd = OPEN(fn, O_RDONLY)))
{
util_out_print("Cannot update read-only database.", FLUSH);
rts_error(VARLSTCNT(5) ERR_DBRDONLY, 2, fn_len, fn, errno);
}
rts_error(VARLSTCNT(5) ERR_DBRDONLY, 2, fn_len, fn, save_errno);
}
/* Confirm before proceed */
if (!mu_upgrd_confirmed(TRUE))
{
util_out_print("Upgrade canceled by user", FLUSH);
rts_error(VARLSTCNT(1) ERR_MUNOUPGRD);
}
util_out_print("Do not interrupt to avoid damage in database!!", FLUSH);
util_out_print("Mupip upgrade started ...!/", FLUSH);
mu_upgrd_sig_init();
/* get file status */
FSTAT_FILE(fd, &stat_buf, fstat_res);
if (-1 == fstat_res)
rts_error(VARLSTCNT(5) ERR_DBOPNERR, 2, fn_len, fn, errno);
old_file_len = stat_buf.st_size;
/* Prepare v3.x file header buffer */
old_hdr_size = sizeof(*old_head);
old_head = &old_head_data;
/* Prepare v4.x file header buffer */
new_hdr_size = sizeof(*new_head);
new_head = &new_head_data;
memset(new_head, 0, new_hdr_size);
old_hdr_size_vbn = DIVIDE_ROUND_UP(old_hdr_size, DISK_BLOCK_SIZE);
new_hdr_size_vbn = DIVIDE_ROUND_UP(new_hdr_size, DISK_BLOCK_SIZE);
/* READ header from V3.x file */
LSEEKREAD(fd, 0, old_head, old_hdr_size, status);
if (0 != status)
if (-1 == status)
rts_error(VARLSTCNT(4) ERR_DBPREMATEOF, 2, fn_len, fn);
else
rts_error(VARLSTCNT(5) ERR_DBFILOPERR, 2, fn_len, fn, status);
/* Check version */
if (memcmp(&old_head->label[0], GDS_LABEL, GDS_LABEL_SZ - 1))
{
if (memcmp(&old_head->label[0], GDS_LABEL, GDS_LABEL_SZ - 3))
{ /* it is not a GTM database */
close(fd);
util_out_print("File !AD is not a GT.M database.!/", FLUSH, fn_len, fn);
rts_error(VARLSTCNT(1) ERR_MUNOUPGRD);
}else
{ /* it is GTM database */
/* is it not v3.x database? */
if (memcmp(&old_head->label[GDS_LABEL_SZ - 3],GDS_V30,2) !=0 &&
memcmp(&old_head->label[GDS_LABEL_SZ - 3],GDS_ALT_V30,2) != 0)
{
close(fd);
util_out_print("File !AD has an unrecognized database version!/", FLUSH, fn_len, fn);
rts_error(VARLSTCNT(1) ERR_MUNOUPGRD);
}
}
}
else
{ /* Note: We assume that if the V4.x header and current GT.M file header
* has same field names, they are at same offset */
/* READ the header from file again as V4.x header */
LSEEKREAD(fd, 0, new_head, new_hdr_size, status);
if (0 != status)
if (-1 != status)
rts_error(VARLSTCNT(5) ERR_DBFILOPERR, 2, fn_len, fn, status);
else
rts_error(VARLSTCNT(4) ERR_DBPREMATEOF, 2, fn_len, fn);
if (QWNE(new_head->reg_seqno, seq_num_zero) ||
QWNE(new_head->resync_seqno, seq_num_zero) ||
(new_head->resync_tn != 0) ||
new_head->repl_state != repl_closed)
{
util_out_print("!AD might already have been upgraded", FLUSH, fn_len, fn);
util_out_print("Do you wish to continue with the upgrade? [y/n] ", FLUSH);
SCANF("%s", answer);
if (answer[0] != 'y' && answer[0] != 'Y')
{
close(fd);
util_out_print("Upgrade canceled by user", FLUSH);
rts_error(VARLSTCNT(1) ERR_MUNOUPGRD);
}
}
init_replication(new_head);
new_head->max_update_array_size = new_head->max_non_bm_update_array_size
= ROUND_UP2(MAX_NON_BITMAP_UPDATE_ARRAY_SIZE(new_head), UPDATE_ARRAY_ALIGN_SIZE);
new_head->max_update_array_size += ROUND_UP2(MAX_BITMAP_UPDATE_ARRAY_SIZE, UPDATE_ARRAY_ALIGN_SIZE);
new_head->mutex_spin_parms.mutex_hard_spin_count = MUTEX_HARD_SPIN_COUNT;
new_head->mutex_spin_parms.mutex_sleep_spin_count = MUTEX_SLEEP_SPIN_COUNT;
new_head->mutex_spin_parms.mutex_spin_sleep_mask = MUTEX_SPIN_SLEEP_MASK;
new_head->semid = INVALID_SEMID;
new_head->shmid = INVALID_SHMID;
if (JNL_ALLOWED(new_head))
{ /* Following 3 are new fields starting from V43001.
* Initialize them appropriately.
*/
new_head->epoch_interval = DEFAULT_EPOCH_INTERVAL;
new_head->alignsize = DISK_BLOCK_SIZE * JNL_DEF_ALIGNSIZE;
if (!new_head->jnl_alq)
new_head->jnl_alq = JNL_ALLOC_DEF;
/* note new_head->jnl_deq is carried over without any change even if it is zero since a zero
* jnl file extension size is supported starting V43001
*/
new_head->autoswitchlimit = ALIGNED_ROUND_DOWN(JNL_ALLOC_MAX, new_head->jnl_alq, new_head->jnl_deq);
/* following field is assumed as non-zero by set_jnl_info starting V43001A */
if (JNL_ALLOWED(new_head) && !new_head->jnl_buffer_size)
new_head->jnl_buffer_size = JNL_BUFFER_DEF;
} else
{
new_head->epoch_interval = 0;
new_head->alignsize = 0;
new_head->autoswitchlimit = 0;
}
new_head->yield_lmt = DEFAULT_YIELD_LIMIT;
/* writing header */
LSEEKWRITE(fd, 0, new_head, new_hdr_size, status);
if (0 != status)
rts_error(VARLSTCNT(5) ERR_DBFILOPERR, 2, fn_len, fn, status);
close(fd);
util_out_print("File !AD successfully upgraded.!/", FLUSH, fn_len, fn);
if (0 != sem_rmid(upgrade_standalone_sems))
{
util_out_print("Error with sem_rmid : %d [0x%x]", TRUE, upgrade_standalone_sems, upgrade_standalone_sems);
rts_error(VARLSTCNT(1) ERR_MUNOUPGRD);
}
mupip_exit(SS_NORMAL);
}
util_out_print("Old header size: !SL", FLUSH, old_hdr_size);
util_out_print("New header size: !SL", FLUSH, new_hdr_size);
if (old_head->createinprogress)
{
close(fd);
util_out_print("Database creation in progress on file !AD.!/", FLUSH, fn_len, fn);
rts_error(VARLSTCNT(1) ERR_MUNOUPGRD);
}
if (old_head->file_corrupt)
{
close(fd);
util_out_print("Database !AD is corrupted.!/", FLUSH, fn_len, fn);
rts_error(VARLSTCNT(1) ERR_MUNOUPGRD);
}
if ((((off_t)old_head->start_vbn - 1) * DISK_BLOCK_SIZE +
(off_t)old_head->trans_hist.total_blks * old_head->blk_size + (off_t)DISK_BLOCK_SIZE != old_file_len) &&
(((off_t)old_head->start_vbn - 1) * DISK_BLOCK_SIZE +
(off_t)old_head->trans_hist.total_blks * old_head->blk_size + (off_t)old_head->blk_size != old_file_len))
{
util_out_print("Incorrect start_vbn !SL or, block size !SL or, total blocks !SL",
FLUSH, old_head->start_vbn, old_head->blk_size, old_head->trans_hist.total_blks);
rts_error(VARLSTCNT(1) ERR_MUNOUPGRD);
}
if (ROUND_DOWN(old_head->blk_size, DISK_BLOCK_SIZE) != old_head->blk_size)
{
util_out_print("Database block size !SL is not divisible by DISK_BLOCK_SIZE", FLUSH, old_head->blk_size);
rts_error(VARLSTCNT(1) ERR_MUNOUPGRD);
}
mu_upgrd_header(old_head, new_head); /* Update header from v3.x to v4.x */
new_head->start_vbn = new_hdr_size_vbn + 1;
new_head->free_space = 0;
new_head->wc_blocked_t_end_hist.evnt_cnt = old_head->wc_blocked_t_end_hist2.evnt_cnt;
new_head->wc_blocked_t_end_hist.evnt_tn = old_head->wc_blocked_t_end_hist2.evnt_tn;
init_replication(new_head);
/*
A simple way of doing mupip upgrade is to move all the data after file header
towards the eof to make space and write down the header. This does not need any
computation or, change in data/index blocks. This is a slow process because it
has mainly I/O, though no manipulation of database structures. or index blocks.
This is okay for small database.
A time efficient way is to physically move second group of BLKS_PER_LMAP number of
blocks towards the eof and move first group of BLKS_PER_LMAP number of blocks in
place of 2nd group. Finally adjust all indices to point to the blocks correctly.
Also adjust master bit map.
(note: we cannot move first group from the beginning).
Detail algorithm as follows:
---------------------------
// Allocate two buffers each to hold one group of data.
Read v3.x header and upgrade to v4.x
if file is big enough
read group 1 in buff[0]
read_off = offset of starting block of 2nd group.
read group 2 in buff[1]
write buff[0] at offset read_off
last_full_grp_startblk = points to the block where 2nd group of 512 blocks
of old file will be written back.
//Instead of searching for a free group we will write at the last full group
//Say, we have 3000 blocks. last_full_grp_startblk = 2048
// (not 2560, because it is not full)
//All data from that point upto eof will be read and saved in buffer
read all remaining data from the point last_full_grp_startblk upto eof in buff[0]
write buff[1] at the point of last_full_grp_startblk
Now write buff[0] at the end of last write
//Graphical Example: Each letter corresponds to a group of 512 blocks where first block
// is local bit map. Last group U may be a group of less than 512 blocks.
// Extend towards right ------------------------------------------------------->
// old permutation: [v3 head] A B C D E F G H I J K L M N O P Q R S T U
// new permutation: [v4 head ] A C D E F G H I J K L M N O P Q R S T B U
Finally traverse the tree and adjust block pointers
Adjust master map
write new v4.x header at bof
else
bufsize = size of data for a group
rbno = 0 // read buffer no. This switches between 0 and 1
read_off = 0
write_off = 0
upgrd_buff[rbno] = new header
data_size[rbno] = new header size
rbno = INVERT(rbno);
do while not eof
data_size[rbno] = MIN(bufsize, remaining_data_size)
Read data of size data_size[rbno] in upgrd_buff[rbno] and adjust read_off
rbno = INVERT(rbno);
Write upgrd_buff[rbno] of datasize[rbno] at write_off and increase write_off
Enddo
rbno = INVERT(rbno)
Write upgrd_buff[rbno] of datasize[rbno] at write_off
endif
*/
bufsize = old_head->blk_size * BLKS_PER_LMAP;
upgrd_buff[0] = (unsigned char*) malloc(bufsize);
upgrd_buff[1] = (unsigned char*) malloc(bufsize);
read_off = old_start_vbn_off = (off_t)(old_head->start_vbn - 1) * DISK_BLOCK_SIZE; /* start vbn offset in bytes */
last_full_grp_startblk = ROUND_DOWN(new_head->trans_hist.total_blks, BLKS_PER_LMAP); /* in block_id */
last_full_grp_startoff = old_start_vbn_off + (off_t)last_full_grp_startblk * new_head->blk_size; /* offset in bytes */
/* this calculation is used because some 3.2x database has GDS blk_size bytes at the end
instead of DISK_BLOCK_SIZE bytes. */
old_file_len2 = old_head->start_vbn * DISK_BLOCK_SIZE + (off_t)old_head->blk_size * old_head->trans_hist.total_blks;
/* Change Label to a temporary dummy value, so that other GTM process does not come
while doing upgrade and corrupts database */
LSEEKWRITE(fd, 0, upgrd_label, GDS_LABEL_SZ - 1, status);
if (0 != status)
rts_error(VARLSTCNT(5) ERR_DBFILOPERR, 2, fn_len, fn, status);
if (old_head->trans_hist.total_blks > BLKS_PER_LMAP * 2)
{
/* recalculate start_vbn and free space, because there will be a gap after header */
new_head->start_vbn = old_head->start_vbn + bufsize / DISK_BLOCK_SIZE;
new_head->free_space = bufsize - (new_hdr_size_vbn - old_hdr_size_vbn) * DISK_BLOCK_SIZE;
util_out_print("New starting VBN is: !SL !/", FLUSH, new_head->start_vbn);
/* read 1st group of blocks */
LSEEKREAD(fd, read_off, upgrd_buff[0], bufsize, status);
if (0 != status)
if (-1 == status)
rts_error(VARLSTCNT(4) ERR_DBPREMATEOF, 2, fn_len, fn);
else
rts_error(VARLSTCNT(5) ERR_DBFILOPERR, 2, fn_len, fn, status);
read_off = read_off + bufsize;
/* read 2nd group of blocks */
LSEEKREAD(fd, read_off, upgrd_buff[1], bufsize, status);
if (0 != status)
if (-1 == status)
rts_error(VARLSTCNT(4) ERR_DBPREMATEOF, 2, fn_len, fn);
else
rts_error(VARLSTCNT(5) ERR_DBFILOPERR, 2, fn_len, fn, status);
/* write 1st group of blocks in place of 2nd group */
write_off = old_start_vbn_off + bufsize;
LSEEKWRITE(fd, write_off, upgrd_buff[0], bufsize, status);
if (0 != status)
rts_error(VARLSTCNT(5) ERR_DBFILOPERR, 2, fn_len, fn, status);
/* read last group (# of blks <= BLKS_PER_LMAP) */
dsize = old_file_len2 - last_full_grp_startoff;
assert (dsize <= bufsize);
LSEEKREAD(fd, last_full_grp_startoff, upgrd_buff[0], dsize, status);
if (0 != status)
if (-1 == status)
rts_error(VARLSTCNT(4) ERR_DBPREMATEOF, 2, fn_len, fn);
else
rts_error(VARLSTCNT(5) ERR_DBFILOPERR, 2, fn_len, fn, status);
/* write 2nd group of blocks */
LSEEKWRITE(fd, last_full_grp_startoff, upgrd_buff[1], bufsize, status);
if (0 != status)
rts_error(VARLSTCNT(5) ERR_DBFILOPERR, 2, fn_len, fn, status);
/* write last group read from old file */
LSEEKWRITE(fd, last_full_grp_startoff + bufsize, upgrd_buff[0], dsize, status);
if (0 != status)
rts_error(VARLSTCNT(5) ERR_DBFILOPERR, 2, fn_len, fn, status);
util_out_print("Please wait while index is being adjusted...!/", FLUSH);
mu_upgrd_adjust_blkptr(1L, TRUE, new_head, fd, fn, fn_len);
mu_upgrd_adjust_mm(new_head->master_map, DIVIDE_ROUND_UP(new_head->trans_hist.total_blks+1,BLKS_PER_LMAP));
/* writing header */
LSEEKWRITE(fd, 0, new_head, new_hdr_size, status);
if (0 != status)
rts_error(VARLSTCNT(5) ERR_DBFILOPERR, 2, fn_len, fn, status);
}
else /* very small database */
{
rbno = 0;
write_off = 0;
datasize[rbno] = new_hdr_size;
memcpy(upgrd_buff[0], new_head, new_hdr_size);
rbno = INVERT(rbno);
while(read_off < old_file_len2)
{
datasize[rbno] = MIN (old_file_len2 - read_off, bufsize);
LSEEKREAD(fd, read_off, upgrd_buff[rbno], datasize[rbno], status);
if (0 != status)
if (-1 == status)
rts_error(VARLSTCNT(4) ERR_DBPREMATEOF, 2, fn_len, fn);
else
rts_error(VARLSTCNT(5) ERR_DBFILOPERR, 2, fn_len, fn, status);
read_off += datasize[rbno];
rbno = INVERT(rbno);
LSEEKWRITE(fd, write_off, upgrd_buff[rbno], datasize[rbno], status);
if (0 != status)
rts_error(VARLSTCNT(5) ERR_DBFILOPERR, 2, fn_len, fn, status);
write_off+= datasize[rbno];
}
rbno = INVERT(rbno);
LSEEKWRITE(fd, write_off, upgrd_buff[rbno], datasize[rbno], status);
if (0 != status)
rts_error(VARLSTCNT(5) ERR_DBFILOPERR, 2, fn_len, fn, status);
} /* end if small database */
free(upgrd_buff[0]);
free(upgrd_buff[1]);
close(fd);
util_out_print("File !AD successfully upgraded.!/", FLUSH, fn_len, fn);
REVERT;
if (0 != sem_rmid(upgrade_standalone_sems))
{
util_out_print("Error with sem_rmid : %d [0x%x]", TRUE, upgrade_standalone_sems, upgrade_standalone_sems);
rts_error(VARLSTCNT(1) ERR_MUNOUPGRD);
}
mupip_exit(SS_NORMAL);
}