void
it_free_page (index_tree_t * it, buffer_desc_t * buf)
{
short l;
it_map_t * itm;
dp_addr_t remap;
ASSERT_IN_MAP (buf->bd_tree, buf->bd_page);
itm = IT_DP_MAP (buf->bd_tree, buf->bd_page);
remap = (dp_addr_t) (ptrlong) gethash (DP_ADDR2VOID (buf->bd_page), &itm->itm_remap);
if (!buf->bd_is_write)
GPF_T1 ("isp_free_page without write access to buffer.");
dp_may_compact (buf->bd_storage, buf->bd_page); /* no need to keep deld buffers in checked for compact list */
l=SHORT_REF (buf->bd_buffer + DP_FLAGS);
if (!(l == DPF_BLOB || l == DPF_BLOB_DIR)
&& !remap)
GPF_T1 ("Freeing a page that is not remapped");
if (DPF_INDEX == l)
it->it_n_index_est--;
else
it->it_n_blob_est--;
if (buf->bd_page != buf->bd_physical_page && (DPF_BLOB_DIR == l || DPF_BLOB == l))
GPF_T1 ("blob is not supposed to be remapped");
DBG_PT_PRINTF ((" Delete %ld remap %ld FL=%d buf=%p\n", buf->bd_page, buf->bd_physical_page, l, buf));
if (buf->bd_iq)
{
mutex_leave (&itm->itm_mtx);
buf_cancel_write (buf);
mutex_enter (&itm->itm_mtx);
}
if (!remap)
{
/* a blob in checkpoint space can be deleted without a remap existing in commit space. */
if (DPF_BLOB != l && DPF_BLOB_DIR != l )
GPF_T1 ("not supposed to delete a buffer in a different space unless it's a blob");
if (buf->bd_is_dirty)
GPF_T1 ("blob in checkpoint space can't be dirty - has no remap, in commit, hence is in checkpoint");
sethash (DP_ADDR2VOID (buf->bd_page), &itm->itm_remap, (void*) (ptrlong) DP_DELETED);
remhash (DP_ADDR2VOID (buf->bd_page), &itm->itm_dp_to_buf);
page_leave_as_deleted (buf);
return;
}
if (IS_NEW_BUFFER (buf))
/* if this was CREATED AND DELETED without intervening checkpoint the delete
* does not carry outside the commit space. */
remhash (DP_ADDR2VOID (buf->bd_page), &itm->itm_remap);
else
sethash (DP_ADDR2VOID (buf->bd_page), &itm->itm_remap, (void *) (ptrlong) DP_DELETED);
if (!remhash (DP_ADDR2VOID (buf->bd_page), &itm->itm_dp_to_buf))
GPF_T1 ("it_free_page does not hit the buffer in tree cache");
it_free_remap (it, buf->bd_page, buf->bd_physical_page, l);
page_leave_as_deleted (buf);
}
buffer_desc_t *
itc_delta_this_buffer (it_cursor_t * itc, buffer_desc_t * buf, int stay_in_map)
{
/* The caller has no access but intends to change the parent link. */
it_map_t * itm;
dp_addr_t remap_to;
#ifdef PAGE_TRACE
dp_addr_t old_dp = buf->bd_physical_page;
#endif
#ifdef _NOT
FAILCK (itc);
#endif
ASSERT_IN_MAP (itc->itc_tree, buf->bd_page);
itm = IT_DP_MAP (itc->itc_tree, buf->bd_page);
#ifdef MTX_DEBUG
if (buf->bd_is_dirty && !gethash (DP_ADDR2VOID (buf->bd_page), &itm->itm_remap))
GPF_T1 ("dirty but not remapped in checking delta");
#endif
if (gethash (DP_ADDR2VOID (buf->bd_page), &itm->itm_remap))
{
buf->bd_is_dirty = 1;
return (buf);
}
if (it_can_reuse_logical (itc->itc_tree, buf->bd_page))
remap_to = buf->bd_page;
else
remap_to = em_new_dp (itc->itc_tree->it_extent_map, EXT_REMAP, 0, &itc->itc_n_pages_on_hold);
if (!remap_to)
{
if (LT_CLOSING == itc->itc_ltrx->lt_status)
{
log_error ("Out if disk during commit. The transaction is in effect and will be replayed from the log at restart. Exiting due to no disk space, thus cannot maintain separation of checkpoint and commit space and transactional semantic."
"This happens due to running out of safety margin, which is not expected to happen. If this takes place without in fact being out of disk on the database or consistently in a given situation, the condition may be reported to support. This is a planned exit and not a database corruption. A core will be made for possible support.");
GPF_T1 ("Deliberately made core for possible support");
}
if (itc->itc_n_pages_on_hold)
GPF_T1 ("The database is out of disk during an insert. The insert has exceeded its space safety margin. This does not normally happen. This is a planned exit and not a corruption. Make more disk space available. If this occurs continuously or without in fact running out of space, this may be reported to support.");
if (DELTA_STAY_INSIDE == stay_in_map)
GPF_T1 ("out of disk on reloc_right_leaves.");
log_error ("Out of disk space for database");
itc->itc_ltrx->lt_error = LTE_NO_DISK;
itc_bust_this_trx (itc, &buf, ITC_BUST_THROW);
}
buf->bd_physical_page = remap_to;
sethash (DP_ADDR2VOID (buf->bd_page), &itm->itm_remap,
DP_ADDR2VOID (remap_to));
buf->bd_is_dirty = 1;
DBG_PT_DELTA_CLEAN (buf, old_dp);
return buf;
}
int
DBGP_NAME (page_wait_access) (DBGP_PARAMS it_cursor_t * itc, dp_addr_t dp, buffer_desc_t * buf_from,
buffer_desc_t ** buf_ret, int mode, int max_change)
{
buffer_desc_t decoy;
buffer_desc_t *buf;
dp_addr_t phys_dp;
itc->itc_to_reset = RWG_NO_WAIT;
itc->itc_max_transit_change = max_change;
itc->itc_must_kill_trx = 0;
if (!dp)
GPF_T1 ("Zero DP in page_fault_map_sem");
if (buf_from)
{
ITC_IN_TRANSIT (itc, dp, buf_from->bd_page);
}
else
ASSERT_IN_MAP (itc->itc_tree, dp);
buf = IT_DP_TO_BUF (itc->itc_tree, dp);
if (!buf)
{
ra_req_t * ra = NULL;
IT_DP_REMAP (itc->itc_tree, dp, phys_dp);
#ifdef MTX_DEBUG
em_check_dp (itc->itc_tree->it_extent_map, phys_dp);
if (phys_dp != dp)
em_check_dp (itc->itc_tree->it_extent_map, dp);
#endif
if ((DP_DELETED == phys_dp || dbs_is_free_page (itc->itc_tree->it_storage, phys_dp))
&& !strchr (wi_inst.wi_open_mode, 'a'))
{
log_error ("Reference to page with free remap dp = %ld, remap = %ld",
(long) phys_dp, (long) dp);
if (0 && DBS_PAGE_IN_RANGE (itc->itc_tree->it_storage, phys_dp))
dbs_page_allocated (itc->itc_tree->it_storage, phys_dp);
else
{
*buf_ret = PF_OF_DELETED;
itc->itc_must_kill_trx = 1;
itc->itc_to_reset = RWG_WAIT_ANY;
ITC_LEAVE_MAPS (itc);
return RWG_WAIT_ANY;
}
}
memset (&decoy, 0, sizeof (buffer_desc_t));
decoy.bd_being_read = 1;
if (PA_READ == mode)
decoy.bd_readers = 1;
else
BD_SET_IS_WRITE (&decoy, 1);
sethash (DP_ADDR2VOID (dp), &IT_DP_MAP (itc->itc_tree, dp)->itm_dp_to_buf, (void*)&decoy);
ITC_LEAVE_MAPS (itc);
buf = bp_get_buffer (NULL, BP_BUF_REQUIRED);
is_read_pending++;
buf->bd_being_read = 1;
buf->bd_page = dp;
buf->bd_storage = itc->itc_tree->it_storage;
buf->bd_physical_page = phys_dp;
BD_SET_IS_WRITE (buf, 0);
buf->bd_write_waiting = NULL;
if (buf_from && !itc->itc_landed)
ra = itc_read_aside (itc, buf_from, dp);
itc->itc_n_reads++;
ITC_MARK_READ (itc);
buf->bd_tree = itc->itc_tree;
buf_disk_read (buf);
is_read_pending--;
if (ra)
itc_read_ahead_blob (itc, ra, RAB_SPECULATIVE);
if (buf_from)
{
ITC_IN_TRANSIT (itc, dp, buf_from->bd_page)
}
else
void
it_free_dp_no_read (index_tree_t * it, dp_addr_t dp, int dp_type)
{
buffer_desc_t * buf;
dp_addr_t phys_dp = 0;
it_map_t * itm = IT_DP_MAP (it, dp);
ASSERT_IN_MAP (it, dp);
buf = IT_DP_TO_BUF (it, dp);
if (buf)
phys_dp = buf->bd_physical_page;
else
IT_DP_REMAP (it, dp, phys_dp);
if (buf && buf->bd_being_read)
{
log_info ("Deleting blob page while it is being read dp=%d .\n", dp);
/* the buffer can be a being read decoy with no dp, so check dps only if not being read */
}
else if (phys_dp != dp)
GPF_T1 ("A blob/hash temp dp is not supposed to be remapped in isp_free_blob_dp_no_read");
if (buf)
{
it_cursor_t itc_auto;
it_cursor_t * itc = &itc_auto;
ITC_INIT (itc, isp, NULL);
itc_from_it (itc, it);
itc->itc_itm1 = itm; /* already inside, set itc_itm1 to mark this */
/* Note that the the buf is not passed to page_wait_access. This is because of 'being read' possibility. page_fault will detect this and sync. */
page_wait_access (itc, dp, NULL, &buf, PA_WRITE, RWG_WAIT_ANY);
if (PF_OF_DELETED == buf)
{
ITC_LEAVE_MAPS (itc);
return;
}
if (dp_type != SHORT_REF (buf->bd_buffer + DP_FLAGS))
GPF_T1 ("About to delete non-blob page from blob page dir.");
ITC_IN_KNOWN_MAP (itc, dp); /* get back in, could have come out if waited */
it_free_page (it, buf);
return;
}
DBG_PT_PRINTF (("Free absent blob L=%d \n", dp));
{
dp_addr_t remap = (dp_addr_t) (ptrlong) gethash (DP_ADDR2VOID (dp), &itm->itm_remap);
dp_addr_t cpt_remap = (dp_addr_t) (ptrlong) DP_CHECKPOINT_REMAP (it->it_storage, dp);
if (cpt_remap)
GPF_T1 ("Blob/hash temp dp not expected to have cpt remap in delete no read");
if (DPF_BLOB == dp_type)
it->it_n_blob_est--;
if (remap)
{
/* if this was CREATED AND DELETED without intervening checkpoint the delete
* does not carry outside commit space. */
remhash (DP_ADDR2VOID (dp), &itm->itm_remap);
em_free_dp (it->it_extent_map, dp, DPF_BLOB == dp_type ? EXT_BLOB : EXT_INDEX);
}
else
{
if (DPF_HASH == dp_type) GPF_T1 ("a hash temp page is not supposed to be in cpt s[space");
sethash (DP_ADDR2VOID (dp), &itm->itm_remap, (void *) (ptrlong) DP_DELETED);
}
}
}
