1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
/****************************************************************
* *
* Copyright 2001, 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 <sys/types.h>
#include "gtm_unistd.h"
#include <signal.h>
#include <errno.h>
#ifdef DEBUG
#include "gtm_stdio.h"
#endif
#include "gdsroot.h"
#include "gtm_facility.h"
#include "fileinfo.h"
#include "gdsbt.h"
#include "gdsfhead.h"
#include "filestruct.h"
#include "gdsblk.h"
#include "iosp.h"
#include "gtmio.h"
#include "gds_blk_downgrade.h"
#include "gdsbml.h"
#include "jnl.h"
#include "anticipatory_freeze.h"
GBLREF sm_uc_ptr_t reformat_buffer;
GBLREF int reformat_buffer_len;
GBLREF volatile int reformat_buffer_in_use; /* used only in DEBUG mode */
GBLREF int fast_lock_count;
GBLREF boolean_t dse_running;
int dsk_write(gd_region *reg, block_id blk, cache_rec_ptr_t cr)
{
unix_db_info *udi;
int4 size, save_errno;
sgmnt_addrs *csa;
sgmnt_data_ptr_t csd;
sm_uc_ptr_t buff;
DEBUG_ONLY(
blk_hdr_ptr_t blk_hdr;
)
udi = (unix_db_info *)(reg->dyn.addr->file_cntl->file_info);
csa = &udi->s_addrs;
csd = csa->hdr;
assert(NULL != csd);
assert(cr);
assert(cr->buffaddr);
buff = GDS_ANY_REL2ABS(csa, cr->buffaddr);
DEBUG_ONLY(
/* Check GDS block that is about to be written. Dont do this for DSE as it may intentionally create bad blocks */
if (!dse_running)
{
blk_hdr = (blk_hdr_ptr_t)buff;
assert((unsigned)GDSVLAST > (unsigned)blk_hdr->bver);
assert((LCL_MAP_LEVL == blk_hdr->levl) || ((unsigned)MAX_BT_DEPTH > (unsigned)blk_hdr->levl));
assert((unsigned)csd->blk_size >= (unsigned)blk_hdr->bsiz);
assert(csd->trans_hist.curr_tn >= blk_hdr->tn);
}
)
assert(((blk_hdr_ptr_t)buff)->bver); /* GDSV4 (0) version uses this field as a block length so should always be > 0 */
assert(0 == fast_lock_count); /* ensure the static reformat buffer is not being used currently */
++fast_lock_count; /* Prevents interrupt from using reformat buffer while we have it */
/* reformat_buffer_in_use should always be incremented only AFTER incrementing fast_lock_count
* as it is the latter that prevents interrupts from using the reformat buffer. Similarly
* the decrement of fast_lock_count should be done AFTER decrementing reformat_buffer_in_use.
*/
assert(0 == reformat_buffer_in_use);
DEBUG_ONLY(reformat_buffer_in_use++;)
if (IS_GDS_BLK_DOWNGRADE_NEEDED(cr->ondsk_blkver))
{ /* Need to downgrade/reformat this block back to the previous format */
DEBUG_DYNGRD_ONLY(PRINTF("DSK_WRITE: Block %d being dynamically downgraded on write\n", blk));
if (csd->blk_size > reformat_buffer_len)
{ /* Buffer not big enough (or does not exist) .. get a new one releasing old if it exists */
if (reformat_buffer)
free(reformat_buffer); /* Different blksized databases in use .. keep only largest one */
reformat_buffer = malloc(csd->blk_size);
reformat_buffer_len = csd->blk_size;
}
gds_blk_downgrade((v15_blk_hdr_ptr_t)reformat_buffer, (blk_hdr_ptr_t)buff);
buff = reformat_buffer;
size = ((v15_blk_hdr_ptr_t)buff)->bsiz;
assert(size <= csd->blk_size - SIZEOF(blk_hdr) + SIZEOF(v15_blk_hdr));
size = (size + 1) & ~1;
assert(SIZEOF(v15_blk_hdr) <= size);
} else DEBUG_ONLY(if (GDSV6 == cr->ondsk_blkver))
{
size = (((blk_hdr_ptr_t)buff)->bsiz + 1) & ~1;
assert(SIZEOF(blk_hdr) <= size);
}
DEBUG_ONLY(else GTMASSERT);
if (csa->do_fullblockwrites)
/* round size up to next full logical filesys block. */
size = (int)ROUND_UP(size, csa->fullblockwrite_len);
assert(size <= csd->blk_size);
assert(FALSE == reg->read_only);
assert(dba_bg == reg->dyn.addr->acc_meth);
assert(!csa->acc_meth.bg.cache_state->cache_array || buff != (sm_uc_ptr_t)csd);
assert(!csa->acc_meth.bg.cache_state->cache_array
|| (buff >= (sm_uc_ptr_t)csa->acc_meth.bg.cache_state->cache_array
+ (SIZEOF(cache_rec) * (csd->bt_buckets + csd->n_bts))));
assert(buff < (sm_uc_ptr_t)csd || buff == reformat_buffer);
/* assumes hdr follows immediately after the buffer pool in shared memory */
assert(size <= csd->blk_size);
if (udi->raw)
size = ROUND_UP(size, DISK_BLOCK_SIZE); /* raw I/O must be a multiple of DISK_BLOCK_SIZE */
DB_LSEEKWRITE(csa, udi->fn, udi->fd,
(DISK_BLOCK_SIZE * (csd->start_vbn - 1) + (off_t)blk * csd->blk_size),
buff, size, save_errno);
DEBUG_ONLY(reformat_buffer_in_use--;)
assert(0 == reformat_buffer_in_use);
--fast_lock_count;
assert(0 == fast_lock_count);
if (0 != save_errno) /* If it didn't work for whatever reason.. */
return -1;
return SS_NORMAL;
}
|
