bool gtcmtr_query(void)
{
unsigned char *ptr, *gv_key_top_ptr, regnum;
unsigned short top, old_top;
unsigned short key_len, tmp_len, tot_val_len;
cm_region_list *reg_ref;
mval val;
boolean_t found, was_null;
uint4 msg_len;
ptr = curr_entry->clb_ptr->mbf;
assert(CMMS_Q_QUERY == *ptr);
ptr++;
GET_USHORT(tmp_len, ptr);
ptr += SIZEOF(short);
regnum = *ptr++;
reg_ref = gtcm_find_region(curr_entry, regnum);
tmp_len--; /* subtract size of regnum */
assert(0 == offsetof(gv_key, top));
GET_USHORT(old_top, ptr); /* old_top = ((gv_key *)ptr)->top; */
CM_GET_GVCURRKEY(ptr, tmp_len);
assert(1 == gv_currkey->base[gv_currkey->end - 2]);
assert(0 != gv_currkey->prev || KEY_DELIMITER == gv_currkey->base[gv_currkey->end - 3]);
gtcm_bind_name(reg_ref->reghead, FALSE); /* gtcm_bind_name sets gv_target; do not use gv_target before gtcm_bind_name */
if (gv_target->nct || gv_target->collseq)
{ /* undo client appended 01 00 00 before user provided collation routine gets control */
if (0 == gv_currkey->prev ||
1 != gv_currkey->base[gv_currkey->prev] || 0 != gv_currkey->base[gv_currkey->prev + 1])
{ /* name level $Q, or last subscript of incoming key not null */
DEBUG_ONLY(was_null = FALSE;)
gv_currkey->end -= 2;
gv_currkey->base[gv_currkey->end] = KEY_DELIMITER;
} else
bool gtcmtr_data(void)
{
cm_region_list *reg_ref;
unsigned char *ptr,regnum;
unsigned short top,len;
mval v;
int x;
ptr = curr_entry->clb_ptr->mbf;
assert(*ptr == CMMS_Q_DATA);
ptr++;
GET_USHORT(len, ptr);
ptr += sizeof(unsigned short);
regnum = *ptr++;
reg_ref = gtcm_find_region(curr_entry, regnum);
len--; /* subtract size of regnum */
CM_GET_GVCURRKEY(ptr, len);
gtcm_bind_name(reg_ref->reghead, TRUE);
x = 0;
if (gv_target->root)
x = gvcst_data();
v = *fndata_table[x / 10][x & 1];
ptr = curr_entry->clb_ptr->mbf;
*ptr++ = CMMS_R_DATA;
len = sizeof(unsigned char);
PUT_USHORT(ptr, len);
ptr += sizeof(unsigned short);
*ptr++ = MV_FORCE_INTD(&v);
curr_entry->clb_ptr->cbl = ptr - curr_entry->clb_ptr->mbf;
return TRUE;
}
char gtcmtr_lke_showrep(struct CLB *lnk, show_request *sreq)
{
gd_region *cur_region;
sgmnt_addrs *cs_adr;
mlk_ctldata *lke_ctl;
ssize_t ls_len;
mstr dnode;
show_reply srep;
uint4 status;
boolean_t was_crit;
cur_region = gv_cur_region = gtcm_find_region(curr_entry, sreq->rnum)->reghead->reg;
if (dba_bg == cur_region->dyn.addr->acc_meth || dba_mm == cur_region->dyn.addr->acc_meth)
{
cs_adr = &FILE_INFO(cur_region)->s_addrs;
ls_len = cs_adr->lock_addrs[1] - cs_adr->lock_addrs[0];
lke_ctl = (mlk_ctldata *)malloc(ls_len);
/* Prevent any modification of the lock space while we make a local copy of it */
if (cs_adr->critical != NULL)
crash_count = cs_adr->critical->crashcnt;
was_crit = cs_adr->now_crit;
if (!was_crit)
grab_crit(cur_region);
longcpy((uchar_ptr_t)lke_ctl, cs_adr->lock_addrs[0], ls_len);
if (!was_crit)
rel_crit(cur_region);
util_cm_print(lnk, 0, NULL, RESET);
dnode.len = sreq->nodelength;
dnode.addr = sreq->node;
if (lke_ctl->blkroot != 0)
(void)lke_showtree(lnk, (mlk_shrblk_ptr_t)R2A(lke_ctl->blkroot), sreq->all, sreq->wait, sreq->pid, dnode,
FALSE, NULL);
free(lke_ctl);
}
srep.code = CMMS_U_LKESHOW;
lnk->cbl = SIZEOF(srep.code);
lnk->ast = NULL;
#ifndef vinu_marker
assert(0 == offsetof(show_reply, code));
lnk->mbf = (unsigned char *)&srep; /* no need since lnk->mbf can be re-used. vinu 06/27/01 */
status = cmi_write(lnk);
if (CMI_ERROR(status))
{ /* This routine is a server routine; not sure why it does error processing similar to a client. vinu 06/27/01 */
((link_info *)(lnk->usr))->neterr = TRUE;
gvcmz_error(CMMS_U_LKESHOW, status);
} else
lnk->mbf = (unsigned char *)sreq; /* don't restore if lnk->mbf isn't modified. vinu 06/27/01 */
#else
/* server calls to cmi_* should do error processing as a callback. vinu 06/27/01 */
*lnk->mbf = srep.code;
cmi_write(lnk);
#endif
return CM_READ;
}
bool gtcmtr_kill(void)
{
cm_region_list *reg_ref;
unsigned char *ptr, regnum;
unsigned short len;
static readonly gds_file_id file;
error_def(ERR_DBPRIVERR);
ptr = curr_entry->clb_ptr->mbf;
assert(*ptr == CMMS_Q_KILL);
ptr++;
GET_SHORT(len, ptr);
ptr += sizeof(unsigned short);
regnum = *ptr++;
reg_ref = gtcm_find_region(curr_entry,regnum);
len--; /* subtract size of regnum */
CM_GET_GVCURRKEY(ptr, len);
gtcm_bind_name(reg_ref->reghead, TRUE);
if (gv_cur_region->read_only)
rts_error(VARLSTCNT(4) ERR_DBPRIVERR, 2, DB_LEN_STR(gv_cur_region));
if (JNL_ALLOWED(cs_addrs))
{ /* we need to copy client's specific prc_vec into the global variable in order that the gvcst* routines
* do the right job. actually we need to do this only if JNL_ENABLED(cs_addrs), but since it is not
* easy to re-execute the following two assignments in case gvcst_kill()'s call to t_end() encounters a
* cdb_sc_jnlstatemod retry code, we choose the easier approach of executing the following segment
* if JNL_ALLOWED(cs_addrs) is TRUE instead of checking for JNL_ENABLED(cs_addrs) to be TRUE.
* this approach has the overhead that we will be doing the following assignments even though JNL_ENABLED
* might not be TRUE but since the following two are just pointer copies, it is not considered a big overhead.
* this approach ensures that the jnl_put_jrt_pini() gets the appropriate prc_vec for writing into the
* journal record in case JNL_ENABLED turns out to be TRUE in t_end() time.
* note that the value of JNL_ALLOWED(cs_addrs) cannot be changed on the fly without obtaining standalone access
* and hence the correctness of prc_vec whenever it turns out necessary is guaranteed.
*/
originator_prc_vec = curr_entry->pvec;
cs_addrs->jnl->pini_addr = reg_ref->pini_addr;
}
if (gv_target->root)
gvcst_kill(TRUE);
if (JNL_ALLOWED(cs_addrs))
reg_ref->pini_addr = cs_addrs->jnl->pini_addr; /* In case journal switch occurred */
ptr = curr_entry->clb_ptr->mbf;
*ptr++ = CMMS_R_KILL;
curr_entry->clb_ptr->cbl = S_HDRSIZE;
return TRUE;
}
char gtcmtr_lke_clearrep(struct CLB *lnk, clear_request *creq)
{
gd_region *cur_region;
sgmnt_addrs *cs_adr;
mlk_ctldata_ptr_t lke_ctl;
mstr dnode;
show_reply srep;
uint4 status;
cur_region = gv_cur_region = gtcm_find_region(curr_entry, creq->rnum)->reghead->reg;
if (dba_bg == cur_region->dyn.addr->acc_meth || dba_mm == cur_region->dyn.addr->acc_meth)
{
cs_adr = &FILE_INFO(cur_region)->s_addrs;
lke_ctl = (mlk_ctldata_ptr_t)cs_adr->lock_addrs[0];
util_cm_print(lnk, 0, NULL, RESET);
dnode.len = creq->nodelength;
dnode.addr = creq->node;
if (cs_adr->critical != NULL)
crash_count = cs_adr->critical->crashcnt;
grab_crit(cur_region);
if (lke_ctl->blkroot != 0)
lke_cleartree(cur_region, lnk, lke_ctl, (mlk_shrblk_ptr_t)R2A(lke_ctl->blkroot), creq->all,
creq->interactive, creq->pid, dnode);
rel_crit(cur_region);
}
srep.code = CMMS_U_LKEDELETE;
lnk->cbl = sizeof(srep.code);
lnk->ast = NULL;
#ifndef vinu_marker
assert(0 == offsetof(show_reply, code));
lnk->mbf = (unsigned char *)&srep; /* no need since lnk->mbf can be re-used. vinu 06/27/01 */
status = cmi_write(lnk);
if (CMI_ERROR(status))
{ /* This routine is a server routine; not sure why it does error processing similar to a client. vinu 06/27/01 */
((link_info *)(lnk->usr))->neterr = TRUE;
gvcmz_error(CMMS_U_LKEDELETE, status);
} else
lnk->mbf = (unsigned char *)creq; /* don't restore if lnk->mbf isn't modified. vinu 06/27/01 */
#else
/* server calls to cmi_* should do error processing as a callback. vinu 06/27/01 */
*lnk->mbf = srep.code;
cmi_write(lnk);
#endif
return CM_READ;
}
bool gtcmtr_increment(void)
{
cm_region_list *reg_ref;
mval incr_delta, post_incr;
unsigned char buff[MAX_ZWR_KEY_SZ], *end;
unsigned char *ptr, regnum;
short n;
unsigned short top, len, temp_short;
static readonly gds_file_id file;
error_def(ERR_KEY2BIG);
error_def(ERR_GVIS);
error_def(ERR_DBPRIVERR);
ptr = curr_entry->clb_ptr->mbf;
assert(*ptr == CMMS_Q_INCREMENT);
ptr++;
GET_USHORT(len, ptr);
ptr += SIZEOF(unsigned short);
regnum = *ptr++;
reg_ref = gtcm_find_region(curr_entry,regnum);
len--; /* subtract size of regnum */
CM_GET_GVCURRKEY(ptr, len);
gtcm_bind_name(reg_ref->reghead, TRUE);
if (gv_cur_region->read_only)
rts_error(VARLSTCNT(4) ERR_DBPRIVERR, 2, DB_LEN_STR(gv_cur_region));
if (JNL_ALLOWED(cs_addrs))
{ /* we need to copy client's specific prc_vec into the global variable in order that the gvcst* routines
* do the right job. actually we need to do this only if JNL_ENABLED(cs_addrs), but since it is not
* easy to re-execute the following two assignments in case gvcst_incr's call to t_end encounters a
* cdb_sc_jnlstatemod retry code, we choose the easier approach of executing the following segment
* if JNL_ALLOWED(cs_addrs) is TRUE instead of checking for JNL_ENABLED(cs_addrs) to be TRUE.
* this approach has the overhead that we will be doing the following assignments even though JNL_ENABLED
* might not be TRUE but since the following two are just pointer copies, it is not considered a big overhead.
* this approach ensures that the jnl_put_jrt_pini gets the appropriate prc_vec for writing into the
* journal record in case JNL_ENABLED turns out to be TRUE in t_end time.
* note that the value of JNL_ALLOWED(cs_addrs) cannot be changed on the fly without obtaining standalone access
* and hence the correctness of prc_vec (whenever it turns out necessary) is guaranteed.
*/
originator_prc_vec = curr_entry->pvec;
cs_addrs->jnl->pini_addr = reg_ref->pini_addr;
}
GET_USHORT(len, ptr);
ptr += SIZEOF(unsigned short);
incr_delta.mvtype = MV_STR;
incr_delta.str.len = len;
incr_delta.str.addr = (char *)ptr;
if ((n = gv_currkey->end + 1) > gv_cur_region->max_key_size)
{
if ((end = format_targ_key(&buff[0], MAX_ZWR_KEY_SZ, gv_currkey, TRUE)) == 0)
end = &buff[MAX_ZWR_KEY_SZ - 1];
rts_error(VARLSTCNT(11) ERR_KEY2BIG, 4, n, (int4)gv_cur_region->max_key_size,
REG_LEN_STR(gv_cur_region), 0, ERR_GVIS, 2, end - buff, buff);
}
MV_FORCE_NUMD(&incr_delta);
gvcst_incr(&incr_delta, &post_incr);
if (JNL_ALLOWED(cs_addrs))
reg_ref->pini_addr = cs_addrs->jnl->pini_addr; /* In case journal switch occurred */
ptr = curr_entry->clb_ptr->mbf;
if (MV_DEFINED(&post_incr))
{
temp_short = (unsigned short)post_incr.str.len;
assert((int4)temp_short == post_incr.str.len); /* ushort <- int4 assignment lossy? */
if (curr_entry->clb_ptr->mbl < 1 + /* msg header */
SIZEOF(temp_short) + /* size of length of $INCR return value */
temp_short) /* length of $INCR return value */
{ /* resize buffer */
cmi_realloc_mbf(curr_entry->clb_ptr, 1 + SIZEOF(temp_short) + temp_short);
ptr = curr_entry->clb_ptr->mbf;
}
*ptr++ = CMMS_R_INCREMENT;
PUT_USHORT(ptr, temp_short);
ptr += SIZEOF(unsigned short);
memcpy(ptr, post_incr.str.addr, temp_short);
ptr += temp_short;
} else
bool gtcmtr_bufflush(void)
{
cm_region_list *reg_ref;
mval v;
short n;
unsigned short num_trans, data_len;
unsigned char buff[MAX_ZWR_KEY_SZ], *end;
unsigned char *ptr, regnum, len, cc, prv;
static readonly gds_file_id file;
error_def(ERR_KEY2BIG);
error_def(ERR_REC2BIG);
error_def(ERR_GVIS);
ptr = curr_entry->clb_ptr->mbf;
assert(*ptr == CMMS_B_BUFFLUSH);
ptr++;
v.mvtype = MV_STR;
GET_USHORT(num_trans, ptr);
ptr += sizeof (short);
for (; num_trans-- > 0;)
{
regnum = *ptr++;
reg_ref = gtcm_find_region(curr_entry, regnum);
len = *ptr++;
cc = *ptr++;
prv = *ptr++;
assert (len + cc - 1 < gv_currkey->top);
memcpy(&gv_currkey->base[cc], ptr, len);
ptr += len;
gv_currkey->end = len + cc - 1;
gv_currkey->prev = prv;
assert(prv < gv_currkey->end);
if ((n = gv_currkey->end + 1) > gv_cur_region->max_key_size)
{
if ((end = format_targ_key(&buff[0], MAX_ZWR_KEY_SZ, gv_currkey, TRUE)) == 0)
end = &buff[MAX_ZWR_KEY_SZ - 1];
rts_error(VARLSTCNT(11) ERR_KEY2BIG, 4, n, (int4)gv_cur_region->max_key_size,
REG_LEN_STR(gv_cur_region), 0, ERR_GVIS, 2, end - buff, buff);
}
gtcm_bind_name(reg_ref->reghead, TRUE);
if (JNL_ENABLED(cs_addrs->hdr))
{
cs_addrs->jnl->pini_addr = reg_ref->pini_addr;
originator_prc_vec = curr_entry->pvec;
}
GET_USHORT(data_len, ptr);
ptr += sizeof(short);
v.str.len = data_len;
v.str.addr = (char *)ptr;
if (n + v.str.len + sizeof(rec_hdr) > gv_cur_region->max_rec_size)
{
if ((end = format_targ_key(&buff[0], MAX_ZWR_KEY_SZ, gv_currkey, TRUE)) == 0)
end = &buff[MAX_ZWR_KEY_SZ - 1];
rts_error(VARLSTCNT(11) ERR_REC2BIG, 4, n + v.str.len + sizeof(rec_hdr), (int4)gv_cur_region->max_rec_size,
REG_LEN_STR(gv_cur_region), 0, ERR_GVIS, 2, end - buff, buff);
}
gvcst_put(&v);
if (JNL_ENABLED(cs_addrs->hdr))
reg_ref->pini_addr = cs_addrs->jnl->pini_addr; /* In case journal switch occurred */
ptr += data_len;
}
ptr = curr_entry->clb_ptr->mbf;
*ptr++ = CMMS_C_BUFFLUSH;
curr_entry->clb_ptr->cbl = S_HDRSIZE;
return TRUE;
}
bool gtcmtr_put(void)
{
cm_region_list *reg_ref;
mval v;
unsigned char buff[MAX_ZWR_KEY_SZ], *end;
unsigned char *ptr, regnum;
short n;
unsigned short top, len;
static readonly gds_file_id file;
error_def(ERR_KEY2BIG);
error_def(ERR_REC2BIG);
error_def(ERR_GVIS);
error_def(ERR_DBPRIVERR);
ptr = curr_entry->clb_ptr->mbf;
assert(*ptr == CMMS_Q_PUT);
ptr++;
GET_USHORT(len, ptr);
ptr += SIZEOF(unsigned short);
regnum = *ptr++;
reg_ref = gtcm_find_region(curr_entry,regnum);
len--; /* subtract size of regnum */
CM_GET_GVCURRKEY(ptr, len);
gtcm_bind_name(reg_ref->reghead, TRUE);
if (gv_cur_region->read_only)
rts_error(VARLSTCNT(4) ERR_DBPRIVERR, 2, DB_LEN_STR(gv_cur_region));
if (JNL_ALLOWED(cs_addrs))
{ /* we need to copy client's specific prc_vec into the global variable in order that the gvcst* routines
* do the right job. actually we need to do this only if JNL_ENABLED(cs_addrs), but since it is not
* easy to re-execute the following two assignments in case gvcst_put()'s call to t_end() encounters a
* cdb_sc_jnlstatemod retry code, we choose the easier approach of executing the following segment
* if JNL_ALLOWED(cs_addrs) is TRUE instead of checking for JNL_ENABLED(cs_addrs) to be TRUE.
* this approach has the overhead that we will be doing the following assignments even though JNL_ENABLED
* might not be TRUE but since the following two are just pointer copies, it is not considered a big overhead.
* this approach ensures that the jnl_put_jrt_pini() gets the appropriate prc_vec for writing into the
* journal record in case JNL_ENABLED turns out to be TRUE in t_end() time.
* note that the value of JNL_ALLOWED(cs_addrs) cannot be changed on the fly without obtaining standalone access
* and hence the correctness of prc_vec (whenever it turns out necessary) is guaranteed.
*/
originator_prc_vec = curr_entry->pvec;
cs_addrs->jnl->pini_addr = reg_ref->pini_addr;
}
GET_USHORT(len, ptr);
ptr += SIZEOF(unsigned short);
v.mvtype = MV_STR;
v.str.len = len;
v.str.addr = (char *)ptr;
if ((n = gv_currkey->end + 1) > gv_cur_region->max_key_size)
{
if ((end = format_targ_key(&buff[0], MAX_ZWR_KEY_SZ, gv_currkey, TRUE)) == 0)
end = &buff[MAX_ZWR_KEY_SZ - 1];
rts_error(VARLSTCNT(11) ERR_KEY2BIG, 4, n, (int4)gv_cur_region->max_key_size,
REG_LEN_STR(gv_cur_region), 0, ERR_GVIS, 2, end - buff, buff);
}
if (n + v.str.len + SIZEOF(rec_hdr) > gv_cur_region->max_rec_size)
{
if ((end = format_targ_key(&buff[0], MAX_ZWR_KEY_SZ, gv_currkey, TRUE)) == 0)
end = &buff[MAX_ZWR_KEY_SZ - 1];
rts_error(VARLSTCNT(10) ERR_REC2BIG, 4, n + v.str.len + SIZEOF(rec_hdr),
(int4)gv_cur_region->max_rec_size, REG_LEN_STR(gv_cur_region),
ERR_GVIS, 2, end - buff, buff);
}
gvcst_put(&v);
if (JNL_ALLOWED(cs_addrs))
reg_ref->pini_addr = cs_addrs->jnl->pini_addr; /* In case journal switch occurred */
ptr = curr_entry->clb_ptr->mbf;
*ptr++ = CMMS_R_PUT;
curr_entry->clb_ptr->cbl = S_HDRSIZE;
return TRUE;
}
