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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
|
/****************************************************************
* *
* Copyright 2009, 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_fcntl.h"
#include "gtm_stat.h"
#include "gtm_unistd.h"
#include <sys/mman.h>
#include <sys/shm.h>
#include "gtm_permissions.h"
#include "gtm_string.h"
#include "gtm_stdio.h"
#include "gtm_stdlib.h"
#include "gtm_tempnam.h"
#include "gtm_time.h"
#include "gdsroot.h"
#include "gdskill.h"
#include "gtm_facility.h"
#include "fileinfo.h"
#include "gdsbt.h"
#include "gdsblk.h"
#include "gdsfhead.h"
#include "filestruct.h"
#include "iosp.h"
#include "error.h"
#include "cli.h"
#include "eintr_wrappers.h"
#include "gtmio.h"
#include "gtm_file_stat.h"
#include "gtmimagename.h"
#include "interlock.h"
#include "wcs_phase2_commit_wait.h"
#include "util.h"
#include "ipcrmid.h"
#include "shmpool.h"
#include "db_snapshot.h"
#include "ss_lock_facility.h"
GBLREF sgmnt_addrs *cs_addrs;
GBLREF sgmnt_data *cs_data;
GBLREF gd_region *gv_cur_region;
GBLREF uint4 process_id;
GBLREF enum gtmImageTypes image_type;
error_def(ERR_COMMITWAITSTUCK);
error_def(ERR_SYSCALL);
error_def(ERR_SSFILCLNUPFAIL);
error_def(ERR_SSSHMCLNUPFAIL);
#define CLEANUP_SHADOW_FILE(preserve_snapshot, shadow_file) \
{ \
int status; \
struct stat stat_buf; \
int save_errno; \
\
if (!preserve_snapshot && (-1 != stat(shadow_file, &stat_buf))) \
{ \
status = UNLINK(shadow_file); \
if (0 != status) \
{ \
save_errno = errno; \
if (IS_MUMPS_IMAGE) \
send_msg(VARLSTCNT(5) ERR_SSFILCLNUPFAIL, 2, LEN_AND_STR(shadow_file), save_errno); \
else \
gtm_putmsg(VARLSTCNT(5) ERR_SSFILCLNUPFAIL, 2, LEN_AND_STR(shadow_file), save_errno); \
} \
} \
} \
#define CLEANUP_SHARED_MEMORY(ss_shmid) \
{ \
int save_errno; \
struct shmid_ds ss_shmstat; \
\
if ((INVALID_SHMID != ss_shmid) && (0 == shmctl((int)ss_shmid, IPC_STAT, &ss_shmstat))) \
{ \
if (0 != shmctl((int)ss_shmid, IPC_RMID, &ss_shmstat)) \
{ \
save_errno = errno; \
if (IS_MUMPS_IMAGE) \
send_msg(VARLSTCNT(6) ERR_SSSHMCLNUPFAIL, 3, LEN_AND_LIT("shmctl"), ss_shmid, save_errno); \
else \
gtm_putmsg(VARLSTCNT(6) ERR_SSSHMCLNUPFAIL, 3, LEN_AND_LIT("shmctl"), ss_shmid, save_errno); \
} \
} \
} \
#define ADJUST_SHARED_MEMORY_FIELDS(cnl, ss_shm_ptr) \
{ \
if (0 < cnl->num_snapshots_in_effect) \
cnl->num_snapshots_in_effect--; \
if (0 == cnl->num_snapshots_in_effect) \
{ \
CLEAR_SNAPSHOTS_IN_PROG(cnl); \
cnl->ss_shmid = INVALID_SHMID; \
} \
SS_DEFAULT_INIT_POOL(ss_shm_ptr); \
cnl->ss_shmcycle++; \
}
void ss_release(snapshot_context_ptr_t *ss_ctx)
{
int status, ss_shmsize;
long ss_shmid;
boolean_t preserve_snapshot = FALSE;
sgmnt_addrs *csa;
DEBUG_ONLY(sgmnt_data *csd;)
node_local_ptr_t cnl;
shm_snapshot_ptr_t ss_shm_ptr;
snapshot_context_ptr_t lcl_ss_ctx;
boolean_t was_crit;
struct shmid_ds ss_shmstat;
struct stat stat_buf;
char shadow_file[GTM_PATH_MAX];
ss_proc_status cur_state;
assert(NULL != cs_addrs && (NULL != gv_cur_region));
csa = cs_addrs;
cnl = csa->nl;
was_crit = csa->now_crit;
DEBUG_ONLY(csd = csa->hdr;)
if (NULL == ss_ctx) /* orphaned cleanup */
{
assert(ss_lock_held_by_us(gv_cur_region));
ss_shm_ptr = (shm_snapshot_ptr_t)(SS_GETSTARTPTR(csa));
DBG_ENSURE_PTR_WITHIN_SS_BOUNDS(csa, (sm_uc_ptr_t)ss_shm_ptr);
ss_shmid = ss_shm_ptr->ss_info.ss_shmid;
CLEANUP_SHADOW_FILE(FALSE, ss_shm_ptr->ss_info.shadow_file);
CLEANUP_SHARED_MEMORY(ss_shmid);
ADJUST_SHARED_MEMORY_FIELDS(cnl, ss_shm_ptr);
return;
}
assert(NULL != *ss_ctx);
lcl_ss_ctx = *ss_ctx;
cur_state = lcl_ss_ctx->cur_state;
if (SNAPSHOT_INIT_DONE == cur_state)
{
/* Ensure that we don't try to grab_crit and wait for Phase2 commits to complete if we are dying */
assert(!process_exiting);
ss_shm_ptr = lcl_ss_ctx->ss_shm_ptr;
DBG_ENSURE_PTR_WITHIN_SS_BOUNDS(csa, (sm_uc_ptr_t)ss_shm_ptr);
ss_shmsize = ss_shm_ptr->ss_info.ss_shmsize;
assert(SNAPSHOTS_IN_PROG(cnl));
assert(ss_shm_ptr->in_use);
preserve_snapshot = ss_shm_ptr->preserve_snapshot;
/* Irrespective of whether there was an error or not, announce GT.M that it should now stop writing before images.
* After rel_crit below any process that enters transaction logic will either see cnl->snapshot_in_prog set to FALSE
* or a change in cnl->ss_shmid and cnl->ss_shmcycle in which case it will restart itself in t_end or tp_tend.
*/
if (!was_crit)
grab_crit(gv_cur_region);
assert(cs_data == cs_addrs->hdr);
if (dba_bg == cs_data->acc_meth)
{
/* Now that we have crit, wait for any pending phase2 updates to finish. Since phase2 updates happen
* outside of crit, we dont want them to keep writing to the snapshot file even after the snapshot
* is complete. This is needed as otherwise a GT.M process might see the value of csa->snapshot_in_prog
* as TRUE and before it can proceed any further(starvation, maybe), we went ahead and removed the
* snapshot file(below). Now, if the GT.M process resumes execution, it might end up writing
* the before image to a temporary file which is no longer available.
*/
if (cnl->wcs_phase2_commit_pidcnt && !wcs_phase2_commit_wait(csa, NULL))
{
assert(FALSE);
gtm_putmsg(VARLSTCNT(7) ERR_COMMITWAITSTUCK, 5, process_id, 1,
cnl->wcs_phase2_commit_pidcnt, DB_LEN_STR(gv_cur_region));
}
}
ADJUST_SHARED_MEMORY_FIELDS(cnl, ss_shm_ptr);
if (!was_crit)
rel_crit(gv_cur_region);
if (preserve_snapshot)
{
assert(lcl_ss_ctx->shadow_vbn >= csd->start_vbn);
assert(ss_shmsize == (lcl_ss_ctx->shadow_vbn - csd->start_vbn) * DISK_BLOCK_SIZE);
LSEEKWRITE(lcl_ss_ctx->shdw_fd, 0, (sm_uc_ptr_t)(lcl_ss_ctx->start_shmaddr), ss_shmsize, status);
if (0 != status)
{
util_out_print("!/Failed while writing the snapshot file header. ",
TRUE);
assert(FALSE);
}
}
}
STRCPY(shadow_file, lcl_ss_ctx->shadow_file);
ss_shmid = lcl_ss_ctx->attach_shmid;
ss_destroy_context(lcl_ss_ctx);
/* Do cleanup depending on what state of the snapshot init we are in */
switch(cur_state)
{
case SNAPSHOT_INIT_DONE:
case AFTER_SHM_CREAT:
/* Remove shared memory identifier. Note, because of a race condition, it is possible that some GT.M
* process is still attached to this identifier. In such a case, the identifier will be marked to be
* delted by the OS until number of processes attached to this shared segment becomes zero. GT.M
* at the end of each transaction, will try to detach itself from this shared memory segment and will
* eventually lead to number of attached processes becoming zero.*/
CLEANUP_SHARED_MEMORY(ss_shmid);
/* intentional fall through */
case AFTER_SHADOW_FIL_CREAT:
CLEANUP_SHADOW_FILE(preserve_snapshot, shadow_file);
/* intentional fall through */
case BEFORE_SHADOW_FIL_CREAT:
if (NULL != *ss_ctx)
{
free(*ss_ctx);
*ss_ctx = NULL;
}
break;
default:
assert(FALSE);
GTMASSERT;
}
return;
}
|
