STATICFNDEF void gvtr_set_hasht_gblsubs(mval *subs_mval, mval *set_mval) { uint4 curend; boolean_t was_null = FALSE, is_null = FALSE; DCL_THREADGBL_ACCESS; SETUP_THREADGBL_ACCESS; curend = gv_currkey->end; /* note down gv_currkey->end before changing it so we can restore it before function returns */ assert(KEY_DELIMITER == gv_currkey->base[curend]); assert(gv_target->gd_csa == cs_addrs); COPY_SUBS_TO_GVCURRKEY(subs_mval, gv_cur_region, gv_currkey, was_null, is_null); /* updates gv_currkey */ MV_FORCE_STR(set_mval); gvcst_put(set_mval); gv_currkey->end = curend; /* reset gv_currkey->end to what it was at function entry */ gv_currkey->base[curend] = KEY_DELIMITER; /* restore terminator for entire key so key is well-formed */ return; }
int rc_prc_setf(rc_q_hdr *qhdr) { rc_set *req, *rsp; short data_off, str_remain, *ptr; char *cp1; int i; mval v; ESTABLISH_RET(rc_dbms_ch, RC_SUCCESS); if ((qhdr->a.erc.value = rc_fnd_file(&qhdr->r.xdsid)) != RC_SUCCESS) { REVERT; #ifdef DEBUG gtcm_cpktdmp(qhdr,qhdr->a.len.value,"rc_fnd_file failed."); #endif return -1; } rsp = req = (rc_set *)qhdr; v.mvtype = MV_STR; for (cp1 = req->key.key; *cp1; cp1++) ; v.str.len = cp1 - req->key.key; v.str.addr = req->key.key; if (v.str.len > 8) /* GT.M does not support global variables > 8 chars */ { qhdr->a.erc.value = RC_KEYTOOLONG; REVERT; #ifdef DEBUG gtcm_cpktdmp(qhdr,qhdr->a.len.value,"RC_KEYTOOLONG."); #endif return -1; } gv_bind_name(gd_header, &v.str); memcpy(gv_currkey->base, req->key.key, req->key.len.value); gv_currkey->end = req->key.len.value; gv_currkey->base[gv_currkey->end] = 0; for (i = gv_currkey->end - 2; i > 0; i--) if (!gv_currkey->base[i - 1]) break; gv_currkey->prev = i; ptr = (short*)(req->key.key + req->key.len.value); GET_SHORT(v.str.len, ptr); ptr++; GET_SHORT(data_off ,ptr); ptr++; GET_SHORT(str_remain ,ptr); ptr++; if (gv_currkey->end + 1 + v.str.len + sizeof(rec_hdr) > gv_cur_region->max_rec_size) { qhdr->a.erc.value = RC_KEYTOOLONG; #ifdef DEBUG gtcm_cpktdmp(qhdr,qhdr->a.len.value,"RC_KEYTOOLONG."); #endif } else /* the total record will fit into a block */ { if (rc_set_fragment = data_off) /* just send fragment */ { v.str.len = v.str.len - data_off - str_remain; v.str.addr = (char*)ptr; } else /* first fragment, put whole record, with zero filler */ { v.str.addr = (char*)malloc(v.str.len); memset(v.str.addr, 0, v.str.len); memcpy(v.str.addr + data_off, ptr, v.str.len - data_off - str_remain); } v.mvtype = MV_STR; gvcst_put(&v); if (rc_set_fragment) rc_set_fragment = 0; else free(v.str.addr); } REVERT; return ((qhdr->a.erc.value == RC_SUCCESS) ? 0 : -1); }
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; }