iSharkFly-Open
/
fis-gtm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
fis-gtm/sr_port/jnl_write.c

566 lines
25 KiB
C
Raw Blame History

/****************************************************************
* *
* Copyright 2003, 2012 Fidelity Information Services, Inc *
* *
* This source code contains the intellectual property *
* of its copyright holder(s), and is made available *
* under a license. If you do not know the terms of *
* the license, please stop and do not read further. *
* *
****************************************************************/
#include "mdef.h"
#include "gtm_string.h"
#include "gtm_inet.h"
#include <stddef.h> /* for offsetof() macro */
#ifdef VMS
#include <descrip.h> /* Required for gtmsource.h */
#endif
#include "gdsroot.h"
#include "gtm_facility.h"
#include "fileinfo.h"
#include "gdsbt.h"
#include "gdsblk.h"
#include "gdsfhead.h"
#include "filestruct.h"
#include "ccp.h"
#include "iosp.h"
#include "jnl.h"
#include "repl_msg.h"
#include "gtmsource.h"
#include "min_max.h"
#include "sleep_cnt.h"
#include "jnl_write.h"
#include "copy.h"
#include "jnl_get_checksum.h"
#include "memcoherency.h"
#include "is_proc_alive.h"
#include "wbox_test_init.h"
#include "gtmimagename.h"
GBLREF jnlpool_ctl_ptr_t temp_jnlpool_ctl;
GBLREF uint4 process_id;
GBLREF sm_uc_ptr_t jnldata_base;
GBLREF jnlpool_addrs jnlpool;
GBLREF jnlpool_ctl_ptr_t jnlpool_ctl;
GBLREF jnl_gbls_t jgbl;
GBLREF boolean_t is_src_server;
GBLREF boolean_t in_jnl_file_autoswitch;
#ifdef DEBUG
STATICDEF int jnl_write_recursion_depth;
#define MAX_JNL_WRITE_RECURSION_DEPTH 2
#endif
error_def(ERR_JNLWRTNOWWRTR);
error_def(ERR_JNLWRTDEFER);
#ifdef DEBUG
/* The fancy ordering of operators/operands in the JNL_SPACE_AVAILABLE calculation is to avoid overflows. */
#define JNL_SPACE_AVAILABLE(jb, lcl_dskaddr, lcl_freeaddr, lcl_size, jnl_wrt_start_mask) \
( \
assert(((jb)->dskaddr <= lcl_freeaddr) \
|| (gtm_white_box_test_case_enabled \
&& (WBTEST_JNL_FILE_LOST_DSKADDR == gtm_white_box_test_case_number))), \
/* the following assert is an || to take care of 4G value overflows or 0 underflows */ \
assert((lcl_freeaddr <= lcl_size) || ((jb)->dskaddr >= lcl_freeaddr - lcl_size) \
|| (gtm_white_box_test_case_enabled \
&& (WBTEST_JNL_FILE_LOST_DSKADDR == gtm_white_box_test_case_number))), \
(lcl_size - (lcl_freeaddr - ((lcl_dskaddr = (jb)->dskaddr) & jnl_wrt_start_mask))) \
)
#else
#define JNL_SPACE_AVAILABLE(jb, dummy, lcl_freeaddr, lcl_size, jnl_wrt_start_mask) \
(lcl_size - (lcl_freeaddr - ((jb)->dskaddr & jnl_wrt_start_mask)))
#endif
#define JNL_PUTSTR(lcl_free, lcl_buff, src, len, lcl_size) \
{ \
int size_before_wrap; \
\
size_before_wrap = lcl_size - lcl_free; \
if (len <= size_before_wrap) \
{ \
memcpy(&lcl_buff[lcl_free], src, len); \
lcl_free += len; \
if (len == size_before_wrap) \
lcl_free = 0; \
} else \
{ \
memcpy(&lcl_buff[lcl_free], src, size_before_wrap); \
lcl_free = len - size_before_wrap; \
memcpy(&lcl_buff[0], src + size_before_wrap, lcl_free); \
} \
}
/* Note: DO_JNL_WRITE_ATTEMPT_IF_NEEDED and DO_JNL_FILE_EXTEND_IF_NEEDED are macros (instead of functions) for performance
* reasons since they are invoked for the fast path (no-align-record) always and for the ALIGN record once in a while.
*/
#define DO_JNL_WRITE_ATTEMPT_IF_NEEDED(JPC, JB, LCL_DSKADDR, LCL_FREEADDR, LCL_SIZE, \
JNL_WRT_START_MASK, REC_LEN, JNL_WRT_START_MODULUS) \
{ \
GBLREF uint4 process_id; \
\
assert((!JB->blocked) || (FALSE == is_proc_alive(JB->blocked, 0)) \
VMS_ONLY(|| ((JB->blocked == process_id) && lib$ast_in_prog()))); \
JB->blocked = process_id; \
/* We should differentiate between a full and an empty journal buffer, hence the pessimism reflected \
* in the <= check below. Hence also the -1 in LCL_FREEADDR - (LCL_SIZE - REC_LEN - 1).* This means \
* that although we have space we might still be invoking jnl_write_attempt (very unlikely). \
*/ \
if (JNL_SPACE_AVAILABLE(JB, LCL_DSKADDR, LCL_FREEADDR, LCL_SIZE, JNL_WRT_START_MASK) <= REC_LEN) \
{ /* The fancy ordering of operators/operands in the calculation done below is to avoid overflows. */ \
if (SS_NORMAL != jnl_write_attempt(JPC, \
ROUND_UP2(LCL_FREEADDR - (LCL_SIZE - REC_LEN- 1), JNL_WRT_START_MODULUS))) \
{ \
assert(NOJNL == JPC->channel); /* jnl file lost */ \
DEBUG_ONLY(jnl_write_recursion_depth--); \
return; /* let the caller handle the error */ \
} \
} \
JB->blocked = 0; \
}
#define DO_JNL_FILE_EXTEND_IF_NEEDED(JREC_LEN, JB, LCL_FREEADDR, CSA, RECTYPE, BLK_PTR, JFB, REG, JPC, JNL_REC) \
{ \
int4 jrec_len_padded; \
\
GBLREF boolean_t in_jnl_file_autoswitch; \
\
/* Before writing a journal record, check if we have some padding space \
* to close the journal file in case we are on the verge of an autoswitch. \
* If we are about to autoswitch the journal file at this point, dont \
* do the padding check since the padding space has already been checked \
* in jnl_write calls before this autoswitch invocation. We can safely \
* write the input record without worrying about autoswitch limit overflow. \
*/ \
jrec_len_padded = JREC_LEN; \
if (!in_jnl_file_autoswitch) \
jrec_len_padded = JREC_LEN + JNL_FILE_TAIL_PRESERVE; \
if (JB->filesize < DISK_BLOCKS_SUM(LCL_FREEADDR, jrec_len_padded)) /* not enough room in jnl file, extend it */ \
{ /* We should never reach here if we are called from t_end/tp_tend. We check that by using the fact that \
* early_tn is different from curr_tn in the t_end/tp_tend case. The only exception is wcs_recover which \
* also sets these to be different in case of writing an INCTN record. For this case though it is okay to \
* extend/autoswitch the file. So allow that. \
*/ \
assertpro((CSA->ti->early_tn == CSA->ti->curr_tn) || (JRT_INCTN == RECTYPE)); \
assert(!IS_REPLICATED(RECTYPE)); /* all replicated jnl records should have gone through t_end/tp_tend */ \
assert(jrt_fixed_size[RECTYPE]); /* this is used later in re-computing checksums */ \
assert(NULL == BLK_PTR); /* as otherwise it is a PBLK or AIMG record which is of variable record \
* length that conflicts with the immediately above assert. \
*/ \
assert(NULL == JFB); /* as otherwise it is a logical record with formatted journal records which \
* is of variable record length (conflicts with the jrt_fixed_size assert). \
*/ \
assertpro(!in_jnl_file_autoswitch); /* avoid recursion of jnl_file_extend */ \
if (SS_NORMAL != jnl_flush(REG)) \
{ \
assert(NOJNL == JPC->channel); /* jnl file lost */ \
DEBUG_ONLY(jnl_write_recursion_depth--); \
return; /* let the caller handle the error */ \
} \
assert(LCL_FREEADDR == JB->dskaddr); \
if (EXIT_ERR == jnl_file_extend(JPC, JREC_LEN)) /* if extension fails, not much we can do */ \
{ \
DEBUG_ONLY(jnl_write_recursion_depth--); \
assert(FALSE); \
return; \
} \
if (0 == JPC->pini_addr) \
{ /* This can happen only if jnl got switched in jnl_file_extend above. \
* Write a PINI record in the new journal file and then continue writing the input record. \
* Basically we need to redo the processing in jnl_write because a lot of the local variables \
* have changed state (e.g. JB->freeaddr etc.). So we instead call jnl_write() \
* recursively and then return immediately. \
*/ \
jnl_put_jrt_pini(CSA); \
assertpro(JPC->pini_addr); /* should have been set in "jnl_put_jrt_pini" */ \
if (JRT_PINI != RECTYPE) \
{ \
JNL_REC->prefix.pini_addr = JPC->pini_addr; \
/* Checksum needs to be recomputed since prefix.pini_addr is changed in above statement */ \
JNL_REC->prefix.checksum = INIT_CHECKSUM_SEED; \
JNL_REC->prefix.checksum = compute_checksum(INIT_CHECKSUM_SEED, \
(uint4 *)JNL_REC, JNL_REC->prefix.forwptr); \
jnl_write(JPC, RECTYPE, JNL_REC, NULL, NULL); \
} \
DEBUG_ONLY(jnl_write_recursion_depth--); \
return; \
} \
} \
}
/* jpc : Journal private control
* rectype : Record type
* jnl_rec : This contains fixed part of a variable size record or the complete fixed size records.
* blk_ptr : For JRT_PBLK and JRT_AIMG this has the block image
* jfb : For SET/KILL/ZKILL/ZTWORM records entire record is formatted in this.
* For JRT_PBLK and JRT_AIMG it contains partial records
*/
void jnl_write(jnl_private_control *jpc, enum jnl_record_type rectype, jnl_record *jnl_rec, blk_hdr_ptr_t blk_ptr,
jnl_format_buffer *jfb)
{
int4 align_rec_len, rlen, rlen_with_align, dstlen, lcl_size, lcl_free, lcl_orig_free;
jnl_buffer_ptr_t jb;
sgmnt_addrs *csa;
sgmnt_data_ptr_t csd;
node_local_ptr_t cnl;
struct_jrec_align align_rec;
uint4 status;
jrec_suffix suffix;
boolean_t nowrap, is_replicated;
struct_jrec_blk *jrec_blk;
uint4 checksum, jnlpool_size, lcl_freeaddr;
sm_uc_ptr_t lcl_buff;
gd_region *reg;
char *ptr;
int jnl_wrt_start_modulus, jnl_wrt_start_mask;
uint4 jnl_fs_block_size, aligned_lcl_free, padding_size;
uint4 tmp_csum1, tmp_csum2;
# ifdef DEBUG
uint4 lcl_dskaddr, mumps_node_sz;
char *mumps_node_ptr;
# endif
assert(jnl_write_recursion_depth++ < MAX_JNL_WRITE_RECURSION_DEPTH);
reg = jpc->region;
csa = &FILE_INFO(reg)->s_addrs;
csd = csa->hdr;
is_replicated = jrt_is_replicated[rectype];
/* Ensure that no replicated journal record is written by this routine if REPL-WAS_ENABLED(csa) is TRUE */
assert((JNL_ENABLED(csa) && !REPL_WAS_ENABLED(csa)) || !is_replicated);
/* Assert that the only journal records that the source server ever writes are PINI/PFIN/EPOCH/EOF
* which it does at the very end when the database is about to be shut down
*/
assert(!is_src_server || (JRT_EOF == rectype) || (JRT_PINI == rectype) || (JRT_EPOCH == rectype) || (JRT_PFIN == rectype));
assert(csa->now_crit || (csd->clustered && csa->nl->ccp_state == CCST_CLOSED));
assert(rectype > JRT_BAD && rectype < JRT_RECTYPES && JRT_ALIGN != rectype);
jb = jpc->jnl_buff;
/* Before taking a copy of jb->freeaddr, determine if both free and freeaddr are in sync. If not fix that first. */
if (jb->free_update_pid)
{
FIX_NONZERO_FREE_UPDATE_PID(csa, jb);
}
lcl_freeaddr = jb->freeaddr;
lcl_free = jb->free;
lcl_size = jb->size;
lcl_buff = &jb->buff[jb->buff_off];
DBG_CHECK_JNL_BUFF_FREEADDR(jb);
++jb->reccnt[rectype];
assert(NULL != jnl_rec);
rlen = jnl_rec->prefix.forwptr;
/* Do high-level check on rlen */
assert(rlen <= jb->max_jrec_len);
/* Do fine-grained checks on rlen */
GTMTRIG_ONLY(assert(!IS_ZTWORM(rectype) || (MAX_ZTWORM_JREC_LEN >= rlen));) /* ZTWORMHOLE */
assert(!IS_SET_KILL_ZKILL_ZTRIG(rectype) || (JNL_MAX_SET_KILL_RECLEN(csd) >= rlen)); /* SET, KILL, ZKILL */
assert((NULL == blk_ptr) || (JNL_MAX_PBLK_RECLEN(csd) >= rlen)); /* PBLK and AIMG */
jb->bytcnt += rlen;
assert (0 == rlen % JNL_REC_START_BNDRY);
rlen_with_align = rlen + (int4)MIN_ALIGN_RECLEN;
assert(0 == rlen_with_align % JNL_REC_START_BNDRY);
assert((uint4)rlen_with_align < ((uint4)1 << jb->log2_of_alignsize));
if ((lcl_freeaddr >> jb->log2_of_alignsize) == ((lcl_freeaddr + rlen_with_align - 1) >> jb->log2_of_alignsize))
rlen_with_align = rlen;
else
{
align_rec.align_str.length = ROUND_UP2(lcl_freeaddr, ((uint4)1 << jb->log2_of_alignsize))
- lcl_freeaddr - (uint4)MIN_ALIGN_RECLEN;
align_rec_len = (int4)(MIN_ALIGN_RECLEN + align_rec.align_str.length);
assert (0 == align_rec_len % JNL_REC_START_BNDRY);
rlen_with_align = rlen + align_rec_len;
}
jnl_wrt_start_mask = JNL_WRT_START_MASK(jb);
jnl_wrt_start_modulus = JNL_WRT_START_MODULUS(jb);
cnl = csa->nl;
/* If we are currently extending the journal file and writing the closing part of journal records,
* it better be the records that we expect. This is because we will skip the padding check for these
* records. The macro JNL_FILE_TAIL_PRESERVE already takes into account padding space for these.
*/
assert(!in_jnl_file_autoswitch
|| (JRT_PINI == rectype) || (JRT_PFIN == rectype) || (JRT_EPOCH == rectype)
|| (JRT_INCTN == rectype) || (JRT_EOF == rectype));
if (rlen_with_align != rlen)
{
DO_JNL_WRITE_ATTEMPT_IF_NEEDED(jpc, jb, lcl_dskaddr, lcl_freeaddr, lcl_size,
jnl_wrt_start_mask, align_rec_len, jnl_wrt_start_modulus);
DO_JNL_FILE_EXTEND_IF_NEEDED(align_rec_len, jb, lcl_freeaddr, csa, rectype, blk_ptr, jfb, reg, jpc, jnl_rec);
align_rec.prefix.jrec_type = JRT_ALIGN;
assert(align_rec_len <= jb->max_jrec_len);
align_rec.prefix.forwptr = suffix.backptr = align_rec_len;
align_rec.prefix.time = jnl_rec->prefix.time;
align_rec.prefix.tn = jnl_rec->prefix.tn;
/* we have to write an ALIGN record here before writing the PINI record but we do not have a non-zero
* pini_addr for the ALIGN since we have not yet written the PINI. we use the pini_addr field of the
* first PINI journal record in the journal file which is nothing but JNL_FILE_FIRST_RECORD.
*/
align_rec.prefix.pini_addr = (JRT_PINI == rectype) ? JNL_FILE_FIRST_RECORD : jnl_rec->prefix.pini_addr;
align_rec.prefix.checksum = INIT_CHECKSUM_SEED;
suffix.suffix_code = JNL_REC_SUFFIX_CODE;
align_rec.prefix.checksum = compute_checksum(INIT_CHECKSUM_SEED, (uint4 *)&align_rec, SIZEOF(jrec_prefix));
ADJUST_CHECKSUM(align_rec.prefix.checksum, lcl_freeaddr, align_rec.prefix.checksum);
ADJUST_CHECKSUM(align_rec.prefix.checksum, csd->jnl_checksum, align_rec.prefix.checksum);
assert(lcl_free >= 0 && lcl_free < lcl_size);
if (lcl_size >= (lcl_free + align_rec_len))
{ /* before the string for zeroes */
memcpy(lcl_buff + lcl_free, (uchar_ptr_t)&align_rec, FIXED_ALIGN_RECLEN);
lcl_free += (int4)(FIXED_ALIGN_RECLEN + align_rec.align_str.length); /* zeroing is not necessary */
} else
{
JNL_PUTSTR(lcl_free, lcl_buff, (uchar_ptr_t)&align_rec, (int4)FIXED_ALIGN_RECLEN, lcl_size);
if (lcl_size >= (lcl_free + align_rec.align_str.length + SIZEOF(jrec_suffix)))
lcl_free += align_rec.align_str.length; /* zeroing is not necessary */
else
{
if (lcl_size >= (lcl_free + align_rec.align_str.length))
{
lcl_free += align_rec.align_str.length; /* zeroing is not necessary */
if (lcl_size == lcl_free)
lcl_free = 0;
} else
lcl_free = lcl_free + align_rec.align_str.length - lcl_size;
}
}
/* Now copy suffix */
assert(0 == (UINTPTR_T)(&lcl_buff[0] + lcl_free) % SIZEOF(jrec_suffix));
*(jrec_suffix *)(lcl_buff + lcl_free) = *(jrec_suffix *)&suffix;
lcl_free += SIZEOF(jrec_suffix);
if (lcl_size == lcl_free)
lcl_free = 0;
jpc->new_freeaddr = lcl_freeaddr + align_rec_len;
INCR_GVSTATS_COUNTER(csa, cnl, n_jrec_other, 1);
INCR_GVSTATS_COUNTER(csa, cnl, n_jbuff_bytes, align_rec_len);
assert(jgbl.gbl_jrec_time >= align_rec.prefix.time);
assert(align_rec.prefix.time >= jb->prev_jrec_time);
jb->prev_jrec_time = align_rec.prefix.time;
jpc->temp_free = lcl_free; /* set jpc->temp_free BEFORE setting free_update_pid (secshr_db_clnup relies on this) */
assert(lcl_free == jpc->new_freeaddr % lcl_size);
/* Note that freeaddr should be updated ahead of free since jnl_output_sp.c does computation of wrtsize
* based on free and asserts follow later there which use freeaddr.
*/
jb->free_update_pid = process_id;
lcl_freeaddr = jpc->new_freeaddr;
jb->freeaddr = lcl_freeaddr;
/* Write memory barrier here to enforce the fact that freeaddr *must* be seen to be updated before
free is updated. It is less important if free is stale so we do not require a 2nd barrier for that
and will let the lock release (crit lock required since clustering not currently supported) do the
2nd memory barrier for us. This barrier takes care of this process's responsibility to broadcast
cache changes. It is up to readers to also specify a read memory barrier if necessary to receive
this broadcast.
*/
SHM_WRITE_MEMORY_BARRIER;
jb->free = lcl_free;
jb->free_update_pid = 0;
DBG_CHECK_JNL_BUFF_FREEADDR(jb);
if (JRT_PINI == rectype)
{
jnl_rec->prefix.pini_addr = lcl_freeaddr;
/* Checksum needs to be recomputed since prefix.pini_addr is changed in above statement */
jnl_rec->prefix.checksum = INIT_CHECKSUM_SEED;
jnl_rec->prefix.checksum = compute_checksum(INIT_CHECKSUM_SEED,
(uint4 *)&jnl_rec->jrec_pini, SIZEOF(struct_jrec_pini));
}
}
checksum = jnl_rec->prefix.checksum;
assert(checksum);
# ifdef DEBUG
/* Ensure that the checksum computed earlier in jnl_format or jnl_write_pblk or jnl_write_aimg_rec or fixed-sized records
* matches with the block's content.
*/
if ((JRT_PBLK == rectype) || (JRT_AIMG == rectype))
{
COMPUTE_COMMON_CHECKSUM(tmp_csum2, jnl_rec->prefix);
tmp_csum1 = jnl_get_checksum((uint4 *)blk_ptr, NULL, jnl_rec->jrec_pblk.bsiz);
COMPUTE_PBLK_CHECKSUM(tmp_csum1, &jnl_rec->jrec_pblk, tmp_csum2, tmp_csum1);
assert(checksum == tmp_csum1);
} else if (IS_SET_KILL_ZKILL_ZTRIG_ZTWORM(rectype))
{
COMPUTE_COMMON_CHECKSUM(tmp_csum2, jnl_rec->prefix);
mumps_node_ptr = jfb->buff + FIXED_UPD_RECLEN;
mumps_node_sz = jfb->record_size - (FIXED_UPD_RECLEN + JREC_SUFFIX_SIZE);
tmp_csum1 = jnl_get_checksum((uint4 *)mumps_node_ptr, NULL, mumps_node_sz);
COMPUTE_LOGICAL_REC_CHECKSUM(tmp_csum1, &jnl_rec->jrec_set_kill, tmp_csum2, tmp_csum1);
assert(checksum == tmp_csum1);
}else if (jrt_fixed_size[rectype] || JRT_ALIGN == rectype)
{
jnl_rec->prefix.checksum = INIT_CHECKSUM_SEED;
switch(rectype)
{
case JRT_ALIGN:
tmp_csum1 = compute_checksum(INIT_CHECKSUM_SEED, (uint4 *)&jnl_rec->jrec_align, SIZEOF(jrec_prefix));
break;
default:
if(JRT_TRIPLE != rectype && JRT_HISTREC != rectype)
tmp_csum1 = compute_checksum(INIT_CHECKSUM_SEED, (uint4 *)&jnl_rec->jrec_set_kill,
jnl_rec->prefix.forwptr);
break;
}
assert(checksum == tmp_csum1);
jnl_rec->prefix.checksum = checksum;
}
# endif
ADJUST_CHECKSUM(checksum, lcl_freeaddr, checksum);
ADJUST_CHECKSUM(checksum, csd->jnl_checksum, checksum);
jnl_rec->prefix.checksum = checksum;
DO_JNL_WRITE_ATTEMPT_IF_NEEDED(jpc, jb, lcl_dskaddr, lcl_freeaddr, lcl_size,
jnl_wrt_start_mask, rlen, jnl_wrt_start_modulus);
DO_JNL_FILE_EXTEND_IF_NEEDED(rlen, jb, lcl_freeaddr, csa, rectype, blk_ptr, jfb, reg, jpc, jnl_rec);
lcl_orig_free = lcl_free;
nowrap = (lcl_size >= (lcl_free + rlen));
assert(jrt_fixed_size[JRT_EOF]);
if (jrt_fixed_size[rectype])
{
if (nowrap)
{
memcpy(lcl_buff + lcl_free, (uchar_ptr_t)jnl_rec, rlen);
lcl_free += rlen;
if (lcl_size == lcl_free)
lcl_free = 0;
} else
JNL_PUTSTR(lcl_free, lcl_buff, (uchar_ptr_t)jnl_rec, rlen, lcl_size);
/* As part of writing the EOF record into the journal buffer, add enough 0-padding needed to reach
* a filesystem-block-size aligned boundary. This way later jnl_qio_start can safely do aligned
* writes without having to write non-zero garbage after the EOF record. Note that this has to be
* done BEFORE updating freeaddr. Otherwise, it is possible that a jnl qio timer pops after freeaddr
* gets updated but before the 0-padding is done and flushes the eof record to disk without the 0-padding.
*/
if (JRT_EOF == rectype)
{
jnl_fs_block_size = jb->fs_block_size;
aligned_lcl_free = ROUND_UP2(lcl_free, jnl_fs_block_size);
padding_size = aligned_lcl_free - lcl_free;
assert(0 <= (int4)padding_size);
if (padding_size)
memset(lcl_buff + lcl_free, 0, padding_size);
}
/* Note: Cannot easily use ? : syntax below as INCR_GVSTATS_COUNTER macro
* is not an arithmetic expression but a sequence of statements.
*/
if (JRT_EPOCH != rectype)
INCR_GVSTATS_COUNTER(csa, cnl, n_jrec_other, 1);
/* else for EPOCH, the increment of JRE or JRI is done after "jnl_write_epoch_rec" in caller */
} else
{
if (NULL != blk_ptr) /* PBLK and AIMG */
{
assert(FIXED_BLK_RECLEN == FIXED_PBLK_RECLEN);
assert(FIXED_BLK_RECLEN == FIXED_AIMG_RECLEN);
jrec_blk = (struct_jrec_blk *)jnl_rec;
if (nowrap)
{ /* write fixed part of record before the actual gds block image */
memcpy(lcl_buff + lcl_free, (uchar_ptr_t)jnl_rec, FIXED_BLK_RECLEN);
lcl_free += (int4)FIXED_BLK_RECLEN;
/* write actual block */
memcpy(lcl_buff + lcl_free, (uchar_ptr_t)blk_ptr, jrec_blk->bsiz);
lcl_free += jrec_blk->bsiz;
/* Now write trailing characters for 8-bye alignment and then suffix */
memcpy(lcl_buff + lcl_free, (uchar_ptr_t)jfb->buff, jfb->record_size);
lcl_free += jfb->record_size;
assert(lcl_free <= lcl_size);
if (lcl_size == lcl_free)
lcl_free = 0;
} else
{ /* write fixed part of record before the actual gds block image */
JNL_PUTSTR(lcl_free, lcl_buff, (uchar_ptr_t)jnl_rec, (int4)FIXED_BLK_RECLEN, lcl_size);
/* write actual block */
JNL_PUTSTR(lcl_free, lcl_buff, (uchar_ptr_t)blk_ptr, jrec_blk->bsiz, lcl_size);
/* Now write trailing characters for 8-bye alignment and then suffix */
JNL_PUTSTR(lcl_free, lcl_buff, (uchar_ptr_t)jfb->buff, jfb->record_size, lcl_size);
}
INCR_GVSTATS_COUNTER(csa, cnl, n_jrec_pblk, 1);
} else
{ /* SET, KILL, ZKILL for TP, ZTP, non-TP */
assert(IS_TP(rectype) || IS_ZTP(rectype) || (0 == ((struct_jrec_upd *)jfb->buff)->update_num));
assert((!IS_TP(rectype) && !IS_ZTP(rectype)) || (0 != ((struct_jrec_upd *)jfb->buff)->update_num));
assert(((jrec_prefix *)jfb->buff)->forwptr == jfb->record_size);
if (nowrap)
{
memcpy(lcl_buff + lcl_free, (uchar_ptr_t)jfb->buff, rlen);
lcl_free += rlen;
if (lcl_size == lcl_free)
lcl_free = 0;
} else
JNL_PUTSTR(lcl_free, lcl_buff, (uchar_ptr_t)jfb->buff, rlen, lcl_size);
INCR_GVSTATS_COUNTER(csa, cnl, n_jrec_logical, 1);
}
}
assert((lcl_free - lcl_orig_free + lcl_size) % lcl_size == rlen);
assert(lcl_buff[lcl_orig_free] == rectype);
assert(lcl_orig_free < lcl_free || lcl_free < jb->dsk);
assert((lcl_freeaddr >= jb->dskaddr)
|| (gtm_white_box_test_case_enabled && (WBTEST_JNL_FILE_LOST_DSKADDR == gtm_white_box_test_case_number)));
jpc->new_freeaddr = lcl_freeaddr + rlen;
INCR_GVSTATS_COUNTER(csa, cnl, n_jbuff_bytes, rlen);
assert(lcl_free == jpc->new_freeaddr % lcl_size);
if (REPL_ENABLED(csa) && is_replicated)
{ /* If the database is encrypted, then at this point jfb->buff will contain encrypted
* data which we don't want to to push into the jnlpool. Instead, we make use of the
* alternate alt_buff which is guaranteed to contain the original unencrypted data.
*/
if (jrt_fixed_size[rectype])
ptr = (char *)jnl_rec;
else
{
# ifdef GTM_CRYPT
if (csd->is_encrypted && IS_SET_KILL_ZKILL_ZTRIG_ZTWORM(rectype))
ptr = jfb->alt_buff;
else
# endif
ptr = jfb->buff;
}
assert(NULL != jnlpool.jnlpool_ctl && NULL != jnlpool_ctl); /* ensure we haven't yet detached from the jnlpool */
assert((&FILE_INFO(jnlpool.jnlpool_dummy_reg)->s_addrs)->now_crit); /* ensure we have the jnl pool lock */
DEBUG_ONLY(jgbl.cu_jnl_index++;)
jnlpool_size = temp_jnlpool_ctl->jnlpool_size;
dstlen = jnlpool_size - temp_jnlpool_ctl->write;
if (rlen <= dstlen) /* dstlen >= rlen (most frequent case) */
memcpy(jnldata_base + temp_jnlpool_ctl->write, ptr, rlen);
else /* dstlen < rlen */
{
memcpy(jnldata_base + temp_jnlpool_ctl->write, ptr, dstlen);
memcpy(jnldata_base, ptr + dstlen, rlen - dstlen);
}
temp_jnlpool_ctl->write += rlen;
if (temp_jnlpool_ctl->write >= jnlpool_size)
temp_jnlpool_ctl->write -= jnlpool_size;
}
assert(jgbl.gbl_jrec_time >= jnl_rec->prefix.time);
assert(jnl_rec->prefix.time >= jb->prev_jrec_time);
jb->prev_jrec_time = jnl_rec->prefix.time;
jpc->temp_free = lcl_free; /* set jpc->temp_free BEFORE setting free_update_pid (secshr_db_clnup relies on this) */
/* Note that freeaddr should be updated ahead of free since jnl_output_sp.c does computation of wrtsize
* based on free and asserts follow later there which use freeaddr.
*/
jb->free_update_pid = process_id;
lcl_freeaddr = jpc->new_freeaddr;
jb->freeaddr = lcl_freeaddr;
/* Write memory barrier here to enforce the fact that freeaddr *must* be seen to be updated before
free is updated. It is less important if free is stale so we do not require a 2nd barrier for that
and will let the lock release (crit lock required since clustering not currently supported) do the
2nd memory barrier for us. This barrier takes care of this process's responsibility to broadcast
cache changes. It is up to readers to also specify a read memory barrier if necessary to receive
this broadcast.
*/
SHM_WRITE_MEMORY_BARRIER;
jb->free = lcl_free;
jb->free_update_pid = 0;
DBG_CHECK_JNL_BUFF_FREEADDR(jb);
VMS_ONLY(
if (((lcl_freeaddr - jb->dskaddr) > jb->min_write_size)
&& (SS_NORMAL != (status = jnl_qio_start(jpc))) && (ERR_JNLWRTNOWWRTR != status) && (ERR_JNLWRTDEFER != status))
{
jb->blocked = 0;
jnl_file_lost(jpc, status);
DEBUG_ONLY(jnl_write_recursion_depth--);
return;
}
)
DEBUG_ONLY(jnl_write_recursion_depth--);
}
Reference in New Issue View Git Blame Copy Permalink