void jnl_write_trunc_rec(sgmnt_addrs *csa, uint4 orig_total_blks, uint4 orig_free_blocks, uint4 total_blks_after_trunc)
{
struct_jrec_trunc trunc_rec;
jnl_private_control *jpc;
assert(csa->now_crit);
jpc = csa->jnl;
trunc_rec.prefix.jrec_type = JRT_TRUNC;
trunc_rec.prefix.forwptr = trunc_rec.suffix.backptr = TRUNC_RECLEN;
trunc_rec.prefix.tn = csa->ti->curr_tn;
trunc_rec.suffix.suffix_code = JNL_REC_SUFFIX_CODE;
trunc_rec.prefix.time = jgbl.gbl_jrec_time;
trunc_rec.prefix.checksum = INIT_CHECKSUM_SEED;
trunc_rec.prefix.pini_addr = (0 == jpc->pini_addr) ? JNL_HDR_LEN : jpc->pini_addr;
trunc_rec.orig_total_blks = orig_total_blks;
trunc_rec.orig_free_blocks = orig_free_blocks;
trunc_rec.total_blks_after_trunc = total_blks_after_trunc;
jnl_write(jpc, JRT_TRUNC, (jnl_record *)&trunc_rec, NULL, NULL);
}
void jnl_write_pblk(sgmnt_addrs *csa, cw_set_element *cse, blk_hdr_ptr_t buffer)
{
struct_jrec_blk pblk_record;
int tmp_jrec_size, jrec_size, zero_len;
jnl_format_buffer blk_trailer;
char local_buff[JNL_REC_START_BNDRY + JREC_SUFFIX_SIZE];
jrec_suffix *suffix;
jnl_private_control *jpc;
assert(csa->now_crit);
jpc = csa->jnl;
assert(0 != jpc->pini_addr);
pblk_record.prefix.jrec_type = JRT_PBLK;
pblk_record.prefix.pini_addr = (0 == jpc->pini_addr) ? JNL_HDR_LEN : jpc->pini_addr;
pblk_record.prefix.tn = csa->ti->curr_tn;
/* At this point jgbl.gbl_jrec_time should be set by the caller */
assert(jgbl.gbl_jrec_time);
pblk_record.prefix.time = jgbl.gbl_jrec_time;
pblk_record.prefix.checksum = cse->blk_checksum;
pblk_record.blknum = cse->blk;
/* in case we have a bad block-size, we dont want to write a PBLK larger than the GDS block size (maximum block size).
* in addition, check that checksum computed in t_end/tp_tend did take the adjusted bsiz into consideration.
*/
assert(buffer->bsiz <= csa->hdr->blk_size || dse_running);
pblk_record.bsiz = MIN(csa->hdr->blk_size, buffer->bsiz);
assert((pblk_record.bsiz == buffer->bsiz) ||
(cse->blk_checksum == jnl_get_checksum((uint4 *)buffer, NULL, pblk_record.bsiz)));
assert(pblk_record.bsiz >= SIZEOF(blk_hdr) || dse_running);
pblk_record.ondsk_blkver = cse->ondsk_blkver;
tmp_jrec_size = (int)FIXED_PBLK_RECLEN + pblk_record.bsiz + JREC_SUFFIX_SIZE;
jrec_size = ROUND_UP2(tmp_jrec_size, JNL_REC_START_BNDRY);
zero_len = jrec_size - tmp_jrec_size;
blk_trailer.buff = local_buff + (JNL_REC_START_BNDRY - zero_len);
memset(blk_trailer.buff, 0, zero_len);
blk_trailer.record_size = zero_len + JREC_SUFFIX_SIZE;
suffix = (jrec_suffix *)&local_buff[JNL_REC_START_BNDRY];
pblk_record.prefix.forwptr = suffix->backptr = jrec_size;
suffix->suffix_code = JNL_REC_SUFFIX_CODE;
assert(SIZEOF(uint4) == SIZEOF(jrec_suffix));
jnl_write(jpc, JRT_PBLK, (jnl_record *)&pblk_record, buffer, &blk_trailer);
}
void jnl_put_jrt_pfin(sgmnt_addrs *csa)
{
struct_jrec_pfin pfin_record;
jnl_private_control *jpc;
assert(csa->now_crit);
jpc = csa->jnl;
assert(0 != jpc->pini_addr);
pfin_record.prefix.jrec_type = JRT_PFIN;
pfin_record.prefix.forwptr = pfin_record.suffix.backptr = PFIN_RECLEN;
pfin_record.suffix.suffix_code = JNL_REC_SUFFIX_CODE;
pfin_record.prefix.pini_addr = (0 == jpc->pini_addr) ? JNL_HDR_LEN : jpc->pini_addr;
pfin_record.prefix.tn = csa->ti->curr_tn;
/* At this point jgbl.gbl_jrec_time should be set by the caller */
assert(jgbl.gbl_jrec_time);
pfin_record.prefix.time = jgbl.gbl_jrec_time;
pfin_record.prefix.checksum = INIT_CHECKSUM_SEED;
pfin_record.filler = 0;
pfin_record.prefix.checksum = compute_checksum(INIT_CHECKSUM_SEED, (unsigned char *)&pfin_record, SIZEOF(struct_jrec_pfin));
jnl_write(jpc, JRT_PFIN, (jnl_record *)&pfin_record, NULL, NULL, NULL);
}
void jnl_write_aimg_rec(sgmnt_addrs *csa, cw_set_element *cse)
{
struct_jrec_blk aimg_record;
int tmp_jrec_size, jrec_size, zero_len;
jnl_format_buffer blk_trailer; /* partial record after the aimg block */
char local_buff[JNL_REC_START_BNDRY + JREC_SUFFIX_SIZE];
jrec_suffix *suffix;
blk_hdr_ptr_t buffer;
jnl_private_control *jpc;
assert(csa->now_crit);
jpc = csa->jnl;
assert(0 != jpc->pini_addr);
aimg_record.prefix.jrec_type = JRT_AIMG;
aimg_record.prefix.pini_addr = (0 == jpc->pini_addr) ? JNL_HDR_LEN : jpc->pini_addr;
aimg_record.prefix.tn = csa->ti->curr_tn;
/* At this point jgbl.gbl_jrec_time should be set by the caller */
assert(jgbl.gbl_jrec_time);
aimg_record.prefix.time = jgbl.gbl_jrec_time;
aimg_record.prefix.checksum = INIT_CHECKSUM_SEED;
aimg_record.blknum = cse->blk;
/* in case we have a bad block-size, we dont want to write an AIMG larger than the GDS block size (maximum block size) */
buffer = (blk_hdr_ptr_t)cse->new_buff;
assert(buffer->bsiz <= csa->hdr->blk_size);
assert(buffer->bsiz >= sizeof(blk_hdr));
aimg_record.bsiz = MIN(csa->hdr->blk_size, buffer->bsiz);
aimg_record.ondsk_blkver = cse->ondsk_blkver;
tmp_jrec_size = FIXED_AIMG_RECLEN + aimg_record.bsiz + JREC_SUFFIX_SIZE;
jrec_size = ROUND_UP2(tmp_jrec_size, JNL_REC_START_BNDRY);
zero_len = jrec_size - tmp_jrec_size;
blk_trailer.buff = local_buff + (JNL_REC_START_BNDRY - zero_len);
memset(blk_trailer.buff, 0, zero_len);
blk_trailer.record_size = zero_len + JREC_SUFFIX_SIZE;
suffix = (jrec_suffix *)&local_buff[JNL_REC_START_BNDRY];
aimg_record.prefix.forwptr = suffix->backptr = jrec_size;
suffix->suffix_code = JNL_REC_SUFFIX_CODE;
assert(sizeof(uint4) == sizeof(jrec_suffix));
jnl_write(jpc, JRT_AIMG, (jnl_record *)&aimg_record, buffer, &blk_trailer);
}
void jnl_write_aimg_rec(sgmnt_addrs *csa, cw_set_element *cse, uint4 com_csum)
{
struct_jrec_blk aimg_record;
int tmp_jrec_size, jrec_size, zero_len;
jnl_format_buffer blk_trailer; /* partial record after the aimg block */
char local_buff[JNL_REC_START_BNDRY + JREC_SUFFIX_SIZE];
jrec_suffix *suffix;
blk_hdr_ptr_t buffer, save_buffer;
jnl_private_control *jpc;
sgmnt_data_ptr_t csd;
uint4 cursum;
# ifdef GTM_CRYPT
char *in, *out;
int in_len, gtmcrypt_errno;
gd_segment *seg;
# endif
csd = csa->hdr;
assert(csa->now_crit);
jpc = csa->jnl;
assert(0 != jpc->pini_addr);
aimg_record.prefix.jrec_type = JRT_AIMG;
aimg_record.prefix.pini_addr = (0 == jpc->pini_addr) ? JNL_HDR_LEN : jpc->pini_addr;
aimg_record.prefix.tn = csa->ti->curr_tn;
/* At this point jgbl.gbl_jrec_time should be set by the caller */
assert(jgbl.gbl_jrec_time);
aimg_record.prefix.time = jgbl.gbl_jrec_time;
aimg_record.prefix.checksum = INIT_CHECKSUM_SEED;
aimg_record.blknum = cse->blk;
/* in case we have a bad block-size, we dont want to write an AIMG larger than the GDS block size (maximum block size) */
buffer = (blk_hdr_ptr_t)cse->new_buff;
assert(buffer->bsiz <= csd->blk_size);
assert(buffer->bsiz >= SIZEOF(blk_hdr));
aimg_record.bsiz = MIN(csd->blk_size, buffer->bsiz);
aimg_record.ondsk_blkver = cse->ondsk_blkver;
tmp_jrec_size = (int)FIXED_AIMG_RECLEN + aimg_record.bsiz + JREC_SUFFIX_SIZE;
jrec_size = ROUND_UP2(tmp_jrec_size, JNL_REC_START_BNDRY);
zero_len = jrec_size - tmp_jrec_size;
blk_trailer.buff = local_buff + (JNL_REC_START_BNDRY - zero_len);
memset(blk_trailer.buff, 0, zero_len);
blk_trailer.record_size = zero_len + JREC_SUFFIX_SIZE;
suffix = (jrec_suffix *)&local_buff[JNL_REC_START_BNDRY];
aimg_record.prefix.forwptr = suffix->backptr = jrec_size;
suffix->suffix_code = JNL_REC_SUFFIX_CODE;
assert(SIZEOF(uint4) == SIZEOF(jrec_suffix));
save_buffer = buffer;
# ifdef GTM_CRYPT
in_len = aimg_record.bsiz - SIZEOF(*buffer);
if (BLK_NEEDS_ENCRYPTION3(csd->is_encrypted, buffer->levl, in_len))
{
ASSERT_ENCRYPTION_INITIALIZED;
assert(aimg_record.bsiz <= csa->hdr->blk_size);
REALLOC_CRYPTBUF_IF_NEEDED(csa->hdr->blk_size);
memcpy(pvt_crypt_buf.addr, buffer, SIZEOF(blk_hdr)); /* copy the block header */
in = (char *)(buffer + 1); /* + 1 because `buffer' is of type blk_hdr_ptr_t */
out = pvt_crypt_buf.addr + SIZEOF(blk_hdr);
GTMCRYPT_ENCRYPT(csa, csa->encr_key_handle, in, in_len, out, gtmcrypt_errno);
if (0 != gtmcrypt_errno)
{
seg = csa->region->dyn.addr;
GTMCRYPT_REPORT_ERROR(gtmcrypt_errno, rts_error, seg->fname_len, seg->fname);
}
buffer = (blk_hdr_ptr_t)pvt_crypt_buf.addr;
}
# endif
cursum = jnl_get_checksum((uint4 *)buffer, NULL, aimg_record.bsiz);
COMPUTE_AIMG_CHECKSUM(cursum, &aimg_record, com_csum, aimg_record.prefix.checksum);
jnl_write(jpc, JRT_AIMG, (jnl_record *)&aimg_record, buffer, &blk_trailer);
buffer = save_buffer;
}
