static caddr_t
java_vm_attach (JNIEnv ** env)
{
caddr_t err = NULL;
mutex_enter (java_vm_mutex);
*env = NULL;
if (!java_vm)
{
err = java_vm_create (env);
if (err)
{
mutex_leave (java_vm_mutex);
return err;
}
}
else
{
if (JNI_OK != (*java_vm)->GetEnv (java_vm, (void **) env, JNI_VERSION_1_2))
{
if (0 > (*java_vm)->AttachCurrentThread (java_vm, (void **) env,
NULL))
{
err =
srv_make_new_error ("42000", "JV003",
"Can't attach to the java VM");
mutex_leave (java_vm_mutex);
return err;
}
}
}
mutex_leave (java_vm_mutex);
return err;
}
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);
}
dk_mutex_t *
mutex_allocate_typed (int type)
{
int rc;
static int is_initialized = 0;
NEW_VARZ (dk_mutex_t, mtx);
mtx->mtx_type = type;
#if HAVE_SPINLOCK
if (MUTEX_TYPE_SPIN == type)
{
pthread_spin_init (&mtx->l.spinl, 0);
}
else
#endif
{
memset ((void *) &mtx->mtx_mtx, 0, sizeof (pthread_mutex_t));
#ifndef OLD_PTHREADS
if (!is_initialized)
{
pthread_mutexattr_init (&_mutex_attr);
#if defined (PTHREAD_PROCESS_PRIVATE) && !defined(oldlinux) && !defined (__FreeBSD__)
rc = pthread_mutexattr_setpshared (&_mutex_attr, PTHREAD_PROCESS_PRIVATE);
CKRET (rc);
#endif
#ifdef PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
rc = pthread_mutexattr_settype (&_mutex_attr, PTHREAD_MUTEX_ADAPTIVE_NP);
CKRET (rc);
#endif
is_initialized = 1;
}
rc = pthread_mutex_init (&mtx->mtx_mtx, &_mutex_attr);
#else
rc = pthread_mutex_init (&mtx->mtx_mtx, _mutex_attr);
#endif
CKRET (rc);
}
#ifdef MTX_DEBUG
mtx->mtx_owner = NULL;
#endif
#ifdef MTX_METER
if (all_mtxs_mtx)
mutex_enter (all_mtxs_mtx);
dk_set_push (&all_mtxs, (void*)mtx);
if (all_mtxs_mtx)
mutex_leave (all_mtxs_mtx);
#endif
return mtx;
failed:
dk_free (mtx, sizeof (dk_mutex_t));
return NULL;
}
int
thread_wait_cond (void *event, dk_mutex_t *holds, TVAL timeout)
{
int rc;
if (holds)
{
mutex_leave (holds);
rc = _fiber_sleep (event, timeout);
mutex_enter (holds);
}
else
rc = _fiber_sleep (event, timeout);
return rc;
}
static caddr_t
java_vm_detach (void)
{
jint rc;
mutex_enter (java_vm_mutex);
rc = (*java_vm)->DetachCurrentThread (java_vm);
mutex_leave (java_vm_mutex);
if (rc < 0)
return srv_make_new_error ("42000", "JV004",
"Can't dettach from the java VM");
else
{
log_debug ("Thread %p detached from the Java VM", thread_current());
return NULL;
}
}
void
aio_fd_free (dk_hash_t * aio_ht)
{
DO_HT (dbe_storage_t *, dbs, dk_hash_t *, ht, aio_ht)
{
if ((dk_hash_t*) 1 == ht)
{
mutex_leave (dbs->dbs_file_mtx);
}
else
{
DO_HT (disk_stripe_t *, dst, ptrlong, fd, ht)
{
dst_fd_done (dst, fd);
}
END_DO_HT;
hash_table_free (ht);
}
}
int
session_flush (dk_session_t * session)
{
int ret = SER_SUCC;
if (NULL != session->dks_mtx)
mutex_enter (session->dks_mtx);
CATCH_WRITE_FAIL (session)
{
session_flush_1 (session);
ret = SER_SUCC;
}
FAILED
{
ret = SER_FAIL;
}
END_WRITE_FAIL (session);
if (NULL != session->dks_mtx)
mutex_leave (session->dks_mtx);
return (ret);
}
void
dk_mutex_destroy (dk_mutex_t *mtx)
{
#if HAVE_SPINLOCK
if (MUTEX_TYPE_SPIN == mtx->mtx_type)
{
pthread_spin_destroy (&mtx->l.spinl);
}
else
#endif
{
pthread_mutex_destroy ((pthread_mutex_t*) &mtx->mtx_mtx);
}
#ifdef MTX_DEBUG
dk_free_box (mtx->mtx_name);
#endif
#ifdef MTX_METER
mutex_enter (all_mtxs_mtx);
dk_set_delete (&all_mtxs, (void*) mtx);
mutex_leave (all_mtxs_mtx);
#endif
}
static SQLRETURN SQL_API
virtodbc__SQLDriverConnect (SQLHDBC hdbc,
HWND hwnd,
SQLTCHAR * szConnStrIn,
SQLSMALLINT cbConnStrIn,
SQLTCHAR * szConnStrOut, SQLSMALLINT cbConnStrOutMax, SQLSMALLINT * pcbConnStrOutMax, SQLUSMALLINT fDriverCompletion)
{
char tempHostName[1024];
TCHAR cmd[2500];
short fPrompt;
TCHAR *connStr;
TCHAR *DSN;
char *UID;
char *PWD;
char *HOST;
char *szHost;
char *CHARSET;
char *DATABASE;
TCHAR *UIDW;
TCHAR *PWDW;
TCHAR *HOSTW;
TCHAR *CHARSETW;
TCHAR *ENCRYPTW;
TCHAR *SERVERCERTW;
TCHAR *FORCE_DMBS_NAMEW;
TCHAR *DAYLIGHTW;
TCHAR *ROUNDROBINW;
#ifdef _SSL
TCHAR *PWDCLEARW;
#endif
TCHAR *DATABASEW;
SQLRETURN rc;
CON (con, hdbc);
CfgData cfgdata[sizeof (attrs) / sizeof (CfgRecord)];
cli_dbg_printf (("DriverConnect(%p, ..., %d) called.\n", hdbc, fDriverCompletion));
memset (cfgdata, 0, sizeof (cfgdata));
mutex_enter (con->con_environment->env_mtx);
if ((szConnStrIn == NULL) || (!cbConnStrIn) || ((cbConnStrIn == SQL_NTS) && (!szConnStrIn[0])))
{
connStr = _tcsdup (_T (""));
}
else
StrCopyInW (&connStr, (TCHAR *) szConnStrIn, cbConnStrIn);
ParseOptions (cfgdata, NULL, 1);
PutConnectionOptions (cfgdata, con);
ParseOptions (cfgdata, connStr, 0);
#ifdef DEBUG
DumpOpts (connStr, cfgdata);
#endif
fPrompt = FALSE;
if (fDriverCompletion == SQL_DRIVER_COMPLETE || fDriverCompletion == SQL_DRIVER_COMPLETE_REQUIRED)
{
if (!cfgdata[oUID].data || !cfgdata[oUID].data[0]
|| cfgdata[oUID].data[0] == ' ' || !cfgdata[oPWD].data
|| !cfgdata[oPWD].data[0] || cfgdata[oPWD].data[0] == ' '
|| !cfgdata[oHOST].data || !cfgdata[oHOST].data[0] || cfgdata[oHOST].data[0] == ' ')
fPrompt = TRUE;
}
else if (fDriverCompletion == SQL_DRIVER_PROMPT)
{
fPrompt = TRUE;
}
if (fPrompt)
{
if ((rc = DriverConnectDialog ((void *) hwnd)) != SQL_SUCCESS)
{
ParseOptions (cfgdata, NULL, 1);
mutex_leave (con->con_environment->env_mtx);
return rc;
}
}
#ifdef _SSL
if (con->con_encrypt)
{
dk_free_box (con->con_encrypt);
}
ENCRYPTW = cfgdata[oENCRYPT].data && _tcslen (cfgdata[oENCRYPT].data) ? (cfgdata[oENCRYPT].data) : NULL;
con->con_encrypt = virt_wide_to_ansi (ENCRYPTW);
PWDCLEARW = cfgdata[oPWDCLEAR].data && _tcslen (cfgdata[oPWDCLEAR].data) ? (cfgdata[oPWDCLEAR].data) : NULL;
con->con_pwd_cleartext = PWDCLEARW ? _ttoi (PWDCLEARW) : 0;
SERVERCERTW = cfgdata[oSERVERCERT].data && _tcslen (cfgdata[oSERVERCERT].data) ? (cfgdata[oSERVERCERT].data) : NULL;
con->con_ca_list = virt_wide_to_ansi (SERVERCERTW);
#else
con->con_encrypt = NULL;
ENCRYPTW = NULL;
con->con_pwd_cleartext = 0;
SERVERCERTW = NULL;
con->con_ca_list = NULL;
con->con_pwd_cleartext = 0;
#endif
if (cfgdata[oROUNDROBIN].data && _tcslen (cfgdata[oROUNDROBIN].data))
{
char *nst, nst1;
nst = virt_wide_to_ansi (cfgdata[oROUNDROBIN].data);
nst1 = toupper (*nst);
con->con_round_robin = OPTION_TRUE (nst1) ? 1 : 0;
free_wide_buffer (nst);
}
if (cfgdata[oWideUTF16].data && _tcslen (cfgdata[oWideUTF16].data))
{
char *nst, nst1;
nst = virt_wide_to_ansi (cfgdata[oWideUTF16].data);
nst1 = toupper (*nst);
con->con_wide_as_utf16 = OPTION_TRUE (nst1) ? 1 : 0;
free_wide_buffer (nst);
}
FORCE_DMBS_NAMEW = cfgdata[oFORCE_DBMS_NAME].data && _tcslen (cfgdata[oFORCE_DBMS_NAME].data) ? cfgdata[oFORCE_DBMS_NAME].data : NULL;
if (FORCE_DMBS_NAMEW)
{
char *force_dbms_name = virt_wide_to_ansi (FORCE_DMBS_NAMEW);
strncpy (__virtodbc_dbms_name, force_dbms_name, sizeof (__virtodbc_dbms_name));
__virtodbc_dbms_name[sizeof (__virtodbc_dbms_name) - 1] = 0;
free_wide_buffer (force_dbms_name);
}
else
strcpy_ck (__virtodbc_dbms_name, PRODUCT_DBMS);
DSN = cfgdata[oDSN].data;
UIDW = cfgdata[oUID].data ? cfgdata[oUID].data : (TCHAR *) _T ("");
UID = virt_wide_to_ansi (UIDW);
PWDW = cfgdata[oPWD].data ? cfgdata[oPWD].data : (TCHAR *) _T ("");
PWD = virt_wide_to_ansi (PWDW);
HOSTW = cfgdata[oHOST].data ? cfgdata[oHOST].data : attrs[oHOST].defVal;
HOST = virt_wide_to_ansi (HOSTW);
DATABASEW = cfgdata[oDATABASE].data;
DATABASE = virt_wide_to_ansi (DATABASEW);
if (cfgdata[oCHARSET].data && _tcslen (cfgdata[oCHARSET].data))
{
char * cs = virt_wide_to_ansi (cfgdata[oCHARSET].data);
if (!strcmp (cs, "UTF-8"))
{
free (cfgdata[oCHARSET].data);
cfgdata[oCHARSET].data = NULL;
cfgdata[oCHARSET].supplied = FALSE;
con->con_string_is_utf8 = 1;
}
}
CHARSETW = (cfgdata[oCHARSET].data && _tcslen (cfgdata[oCHARSET].data)) ? cfgdata[oCHARSET].data : NULL;
CHARSET = con->con_charset_name = virt_wide_to_ansi (CHARSETW);
if (strchr (HOST, ':') == NULL && strchr(HOST,',') == NULL)
{
snprintf (tempHostName, sizeof (tempHostName), "%s:1111", HOST);
szHost = tempHostName;
}
else
szHost = HOST;
DAYLIGHTW = cfgdata[oDAYLIGHT].data && _tcslen (cfgdata[oDAYLIGHT].data) ? cfgdata[oDAYLIGHT].data : NULL;
if (DAYLIGHTW)
{
char *daylight = virt_wide_to_ansi (DAYLIGHTW);
isdts_mode = (toupper (*daylight) == 'Y');
free_wide_buffer (daylight);
}
if (cfgdata[oNoSystemTables].data && _tcslen (cfgdata[oNoSystemTables].data))
{
char *nst, nst1;
nst = virt_wide_to_ansi (cfgdata[oNoSystemTables].data);
nst1 = toupper (*nst);
con->con_no_system_tables = OPTION_TRUE (nst1) ? 1 : 0;
free_wide_buffer (nst);
}
if (cfgdata[oTreatViewsAsTables].data && _tcslen (cfgdata[oTreatViewsAsTables].data))
{
char *nst, nst1;
nst = virt_wide_to_ansi (cfgdata[oTreatViewsAsTables].data);
nst1 = toupper (*nst);
con->con_treat_views_as_tables = OPTION_TRUE (nst1) ? 1 : 0;
free_wide_buffer (nst);
}
#ifdef DEBUG
DumpOpts (connStr, cfgdata);
printf (_T ("CONNECT(%s,%s,%s)\n"), szHost, UID, PWD);
#endif
rc = internal_sql_connect (hdbc, (SQLCHAR *) szHost, SQL_NTS, (SQLCHAR *) UID, SQL_NTS, (SQLCHAR *) PWD, SQL_NTS);
if (rc == SQL_SUCCESS || rc == SQL_SUCCESS_WITH_INFO)
{
if (DATABASEW && _tcslen (DATABASEW) && _tcscmp (DATABASEW, DEFAULT_DATABASE_PER_USER))
rc = virtodbc__SQLSetConnectAttr (hdbc, SQL_CURRENT_QUALIFIER, DATABASE, SQL_NTS);
else
DATABASEW = NULL;
}
if (rc == SQL_SUCCESS || rc == SQL_SUCCESS_WITH_INFO)
{
if (cfgdata[oIsolationLevel].data && _tcslen (cfgdata[oIsolationLevel].data))
{
TCHAR *szValue = cfgdata[oIsolationLevel].data;
if (!_tcsicmp (szValue, _T ("Read Uncommitted")))
con->con_isolation = SQL_TXN_READ_UNCOMMITTED;
else if (!_tcsicmp (szValue, _T ("Read Committed")))
con->con_isolation = SQL_TXN_READ_COMMITTED;
else if (!_tcsicmp (szValue, _T ("Repeatable Read")))
con->con_isolation = SQL_TXN_REPEATABLE_READ;
else if (!_tcsicmp (szValue, _T ("Serializable")))
con->con_isolation = SQL_TXN_SERIALIZABLE;
}
}
if (rc == SQL_SUCCESS || rc == SQL_SUCCESS_WITH_INFO)
{
TCHAR *p = cmd;
if (cfgdata[oDRIVER].supplied && cfgdata[oDRIVER].data)
{
p = stpcpyw (p, _T ("DRIVER="));
p = stpcpyw (p, cfgdata[oDRIVER].data);
p = stpcpyw (p, _T (";SERVER=OpenLink"));
}
else if (DSN)
{
p = stpcpyw (p, _T ("DSN="));
p = stpcpyw (p, DSN);
}
else
p = stpcpyw (p, _T ("DSN=default"));
if (DATABASEW)
{
p = stpcpyw (p, _T (";DATABASE="));
p = stpcpyw (p, DATABASEW);
}
if (FORCE_DMBS_NAMEW)
{
p = stpcpyw (p, _T (";FORCE_DBMS_NAME="));
p = stpcpyw (p, FORCE_DMBS_NAMEW);
}
if (CHARSET)
{
p = stpcpyw (p, _T (";CHARSET="));
p = stpcpyw (p, CHARSETW);
}
#ifdef _SSL
if (con->con_encrypt)
{
p = stpcpyw (p, _T (";ENCRYPT="));
p = stpcpyw (p, ENCRYPTW);
}
if (con->con_ca_list)
{
p = stpcpyw (p, _T (";SERVERCERT="));
p = stpcpyw (p, SERVERCERTW);
}
if (con->con_pwd_cleartext)
{
p = stpcpyw (p, _T (";PWDCLEAR="));
p = stpcpyw (p, PWDCLEARW);
}
#endif
if (DAYLIGHTW)
{
p = stpcpyw (p, isdts_mode ? _T (";DAYLIGHT=Y") : _T (";DAYLIGHT=N"));
}
p = stpcpyw (p, _T (";UID="));
p = stpcpyw (p, UIDW);
p = stpcpyw (p, _T (";PWD="));
p = stpcpyw (p, PWDW);
p = stpcpyw (p, _T (";HOST="));
p = stpcpyw (p, HOSTW);
if (-1 == StrCopyOut (cmd, szConnStrOut, cbConnStrOutMax, (u_short *) pcbConnStrOutMax))
{
rc = SQL_SUCCESS_WITH_INFO;
set_success_info (&con->con_error, "01004", "CLW01", "String data, right truncated", 0);
}
}
free_wide_buffer (HOST);
free_wide_buffer (UID);
free_wide_buffer (PWD);
free_wide_buffer (CHARSET);
free_wide_buffer (DATABASE);
/* Cleanup */
ParseOptions (cfgdata, NULL, 1);
if (connStr)
free (connStr);
mutex_leave (con->con_environment->env_mtx);
return rc;
}
~Guard ()
{
mutex_leave (mutex_);
};
shuric_t *shuric_load (shuric_vtable_t *vt, caddr_t uri, caddr_t ts, caddr_t uri_text_content, shuric_t *loaded_by, struct query_instance_s *qi, void *env, caddr_t *err_ret )
{
caddr_t str = NULL;
shuric_t ** cached_shuric_ptr;
shuric_t *new_cached_shuric = NULL, *old_cached_shuric = NULL;
shuric_t * new_shuric = NULL;
shuric_t * res = NULL; /* = NULL to keep compiler happy */
dk_set_t obsoletes = NULL;
dbg_printf (("shuric_load started (\"%s\", \"%s\", \"%s\" @ %p)\n",
vt->shuric_type_title, uri,
loaded_by ? loaded_by->shuric_uri : "", loaded_by ));
if (NULL != err_ret[0])
return NULL;
if (NULL != uri)
{
if (DV_STRING != DV_TYPE_OF (uri))
{
err_ret[0] = srv_make_new_error ("39000", "FA041", "A URI of a shareable XSLT/XQuery resource has invalid data type.");
goto cleanup;
}
if (box_length (uri) > MAX_SHURIC_URI_LENGTH)
{
err_ret[0] = srv_make_new_error ("39000", "FA042", "An abnormally long string is passed as URI of a shareable XSLT/XQuery resource.");
goto cleanup;
}
}
if (NULL != uri)
{
if (NULL != loaded_by)
{
shuric_t *old_inc = shuric_scan_relations (loaded_by, uri, SHURIC_SCAN_INCLUDED_BY | SHURIC_SCAN_IMPORTED_BY);
if (old_inc != NULL)
{
char impuri[300];
if (NULL != loaded_by->shuric_uri)
strcpy (impuri, "(temporary resource with no URI)");
else
{
strcpy_ck (impuri, loaded_by->shuric_uri);
}
shuric_release (old_inc);
err_ret[0] = srv_make_new_error ("39000", "FA048", "Cyclic references: '%.300s' refers to his ancestor '%.300s' as to child resource", impuri, uri);
}
}
mutex_enter (shuric_mtx);
cached_shuric_ptr = (shuric_t **) id_hash_get (shuric_global_hashtable, (caddr_t) &uri);
old_cached_shuric = ((NULL == cached_shuric_ptr) ? NULL : cached_shuric_ptr[0]);
if (NULL != old_cached_shuric)
old_cached_shuric->shuric_ref_count++; /* Temporary lock to keep the pointer valid. */
mutex_leave (shuric_mtx);
if ((NULL != old_cached_shuric) && (old_cached_shuric->_ != vt))
{
err_ret[0] = srv_make_new_error ("39000", "FA046", "Server uses the content of URI '%.200s' as '%.30s' and can not load it as '%.30s'",
uri, old_cached_shuric->_->shuric_type_title, vt->shuric_type_title );
goto cleanup;
}
}
if (NULL == uri_text_content)
{
QR_RESET_CTX
{
str = vt->shuric_uri_to_text (uri, qi, env, err_ret);
}
QR_RESET_CODE
{
du_thread_t *self = THREAD_CURRENT_THREAD;
err_ret[0] = thr_get_error_code (self);
thr_set_error_code (self, NULL);
}
END_QR_RESET;
}
int
dbs_file_extend (dbe_storage_t * dbs, extent_t ** new_ext_ret, int is_in_sys_em)
{
extent_map_t * em;
extent_t * new_ext = NULL;
int n, n_allocated = 0;
int32 em_n_free;
dp_addr_t ext_first = dbs->dbs_n_pages;
ASSERT_IN_DBS (dbs);
if (dbf_no_disk)
return 0;
if (dbs->dbs_disks)
{
n = dbs_seg_extend (dbs, EXTENT_SZ);
if (n != EXTENT_SZ)
return 0;
}
else
{
mutex_enter (dbs->dbs_file_mtx);
n = fd_extend (dbs, dbs->dbs_fd, EXTENT_SZ);
mutex_leave (dbs->dbs_file_mtx);
if (EXTENT_SZ != n)
return 0;
dbs->dbs_file_length += PAGE_SZ * EXTENT_SZ;
dbs->dbs_n_pages+= EXTENT_SZ;
dbs->dbs_n_free_pages+= EXTENT_SZ;
}
wi_storage_offsets ();
em = dbs->dbs_extent_map;
if (!em)
{
return n;
}
if (!is_in_sys_em)
mutex_enter (em->em_mtx);
if (dbs_check_extent_free_pages)
{
em_n_free = em_free_count (em, EXT_INDEX);
if (em->em_n_free_pages != em_n_free)
{
log_error ("The %s free pages incorrect %d != %d actually free", em->em_name, em->em_n_free_pages, em_n_free);
em->em_n_free_pages = em_n_free;
}
}
if (em->em_n_free_pages < 16)
{
/* extending and the system extent has little space. Make this ext a system index ext. If allocating some other ext, retry and take the next ext for that. */
int fill;
buffer_desc_t * last;
last = page_set_last (em->em_buf);
fill = LONG_REF (last->bd_buffer + DP_BLOB_LEN);
if (fill + sizeof (extent_t) > PAGE_DATA_SZ)
{
dp_addr_t em_dp = ext_first + n_allocated;
n_allocated++;
last = page_set_extend (dbs, &em->em_buf, em_dp, DPF_EXTENT_MAP);
LONG_SET (last->bd_buffer + DP_BLOB_LEN, sizeof (extent_t));
new_ext = (extent_t *) (last->bd_buffer + DP_DATA);
}
else
{
new_ext = (extent_t*) (last->bd_buffer + fill + DP_DATA);
LONG_SET (last->bd_buffer + DP_BLOB_LEN, fill + sizeof (extent_t));
}
em->em_n_pages += EXTENT_SZ;
em->em_n_free_pages += EXTENT_SZ;
new_ext->ext_flags = EXT_INDEX;
new_ext->ext_dp = ext_first;
if (gethash (DP_ADDR2VOID (new_ext->ext_dp), dbs->dbs_dp_to_extent_map))
GPF_T1 ("ext for new dp range already exists in dbs");
sethash (DP_ADDR2VOID (new_ext->ext_dp), em->em_dp_to_ext, (void*)new_ext);
sethash (DP_ADDR2VOID (new_ext->ext_dp), dbs->dbs_dp_to_extent_map, (void*)em);
new_ext->ext_prev = EXT_EXTENDS_NONE;
if (n_allocated)
{
new_ext->ext_pages[0] = 1;
em->em_n_free_pages--;
}
}
/* there is a guarantee of at least 16 pages in the dbs sys extent map */
if (dbs->dbs_n_pages > dbs->dbs_n_pages_in_sets)
{
/* add a page of global free set and backup set */
buffer_desc_t * last = page_set_extend (dbs, &dbs->dbs_free_set, 0, DPF_FREE_SET);
page_set_checksum_init (last->bd_buffer + DP_DATA);
if (n_allocated)
dbs_page_allocated (dbs, ext_first);
last->bd_page = last->bd_physical_page = em_try_get_dp (em, EXT_INDEX, DP_ANY);
if (!last->bd_page) GPF_T1 ("0 dp for page set page");
EM_DEC_FREE (em, EXT_INDEX);
last = page_set_extend (dbs, &dbs->dbs_incbackup_set, 0, DPF_INCBACKUP_SET);
page_set_checksum_init (last->bd_buffer + DP_DATA);
last->bd_page = last->bd_physical_page = em_try_get_dp (em, EXT_INDEX, DP_ANY);
if (!last->bd_page) GPF_T1 ("0 dp for page set page");
EM_DEC_FREE (em, EXT_INDEX);
dbs->dbs_n_pages_in_sets += BITS_ON_PAGE;
}
if (dbs->dbs_n_pages > dbs->dbs_n_pages_in_extent_set)
{
buffer_desc_t * last = page_set_extend (dbs, &dbs->dbs_extent_set, 0, DPF_EXTENT_SET);
last->bd_page = last->bd_physical_page = em_try_get_dp (em, EXT_INDEX, DP_ANY);
if (!last->bd_page) GPF_T1 ("0 dp for extents alloc page");
EM_DEC_FREE (em, EXT_INDEX);
LONG_SET (last->bd_buffer + DP_DATA, 1); /* the newly made ext is the 1st of this page of the ext set, so set the bm 1st bit to 1 */
page_set_checksum_init (last->bd_buffer + DP_DATA);
dbs->dbs_n_pages_in_extent_set += EXTENT_SZ * BITS_ON_PAGE;
}
if (new_ext)
{
dbs_extent_allocated (dbs, ext_first);
}
*new_ext_ret = new_ext;
if (!is_in_sys_em)
mutex_leave (em->em_mtx);
return n;
}
caddr_t bif_mediawiki_lexer_impl (caddr_t * qst, caddr_t * err, state_slot_t ** args, char *bifname, int run_lexer)
{
caddr_t rawtext = bif_string_arg (qst, args, 0, bifname);
caddr_t CLUSTER_arg = bif_string_arg (qst, args, 1, bifname);
caddr_t TOPIC = bif_string_arg (qst, args, 2, bifname);
caddr_t WIKINAME = bif_string_arg (qst, args, 3, bifname);
caddr_t *env = (caddr_t *)bif_arg (qst, args, 4, bifname);
int envlen = 0, envctr;
dk_session_t *pipe = NULL, *out = NULL;
caddr_t macroexpanded = NULL, res = NULL;
switch (DV_TYPE_OF ((caddr_t)env))
{
case DV_ARRAY_OF_POINTER:
envlen = BOX_ELEMENTS ((caddr_t)env);
if (envlen % 2)
sqlr_new_error ("22023", "WV001", "%s needs an array of even length or NULL argument 4", bifname);
for (envctr = 0; envctr < envlen; envctr++)
if (DV_STRING != DV_TYPE_OF (env[envctr]))
sqlr_new_error ("22023", "WV001", "%s needs an array of even length of strings or NULL argument 4", bifname);
break;
case DV_DB_NULL:
break;
default:
sqlr_new_error ("22023", "WV001", "%s needs an array or NULL as argument 4", bifname);
}
pipe = strses_allocate ();
mutex_enter (mediawiki_lexer_mutex);
mediawiki_env = dk_alloc_box ((8 + envlen) * sizeof (caddr_t), DV_ARRAY_OF_POINTER);
mediawiki_env[0] = "CLUSTER"; mediawiki_env[1] = mediawiki_CLUSTER = CLUSTER_arg;
mediawiki_env[2] = "TOPIC"; mediawiki_env[3] = mediawiki_TOPIC = TOPIC;
mediawiki_env[4] = "WIKINAME"; mediawiki_env[5] = mediawiki_WIKINAME = WIKINAME;
mediawiki_env[6] = "WIKIVERSION"; mediawiki_env[7] = mediawiki_WIKIVERSION;
for (envctr = 0; envctr < envlen; envctr++)
mediawiki_env[8+envctr] = env[envctr];
QR_RESET_CTX
{
mediamacyyrestart (NULL);
mediamacyylex_prepare (rawtext, pipe);
mediamacyylex ();
macroexpanded = strses_string (pipe);
if (run_lexer)
{
out = strses_allocate ();
mediawikiyyrestart (NULL);
mediawikiyylex_prepare (macroexpanded, out);
mediawikiyylex ();
}
}
QR_RESET_CODE
{
du_thread_t *self = THREAD_CURRENT_THREAD;
caddr_t err = thr_get_error_code (self);
dk_free_box (mediawiki_env); /* not dk_free_tree */
mutex_leave (mediawiki_lexer_mutex);
strses_free (pipe);
dk_free_box (macroexpanded);
if (run_lexer)
strses_free (out);
POP_QR_RESET;
sqlr_resignal (err);
}
END_QR_RESET;
dk_free_box (mediawiki_env); /* not dk_free_tree */
mutex_leave (mediawiki_lexer_mutex);
if (run_lexer)
{
res = strses_string (out);
strses_free (out);
strses_free (pipe);
dk_free_box (macroexpanded);
return res;
}
else
{
strses_free (pipe);
return macroexpanded;
}
}
void
it_cache_check (index_tree_t * it, int mode)
{
long remap;
int error = 0, gpf_on_error = 0;
short l;
int inx;
for (inx = 0; inx < IT_N_MAPS; inx++)
{
it_map_t * itm = &it->it_maps[inx];
dk_hash_iterator_t hit;
ptrlong dp;
buffer_desc_t * buf;
mutex_enter (&itm->itm_mtx);
dk_hash_iterator (&hit, &itm->itm_dp_to_buf);
while (dk_hit_next (&hit, (void**) &dp, (void**) &buf))
{
if (!buf->bd_buffer)
continue; /* this is a decoy holding a place while real buffer being read */
if (buf->bd_is_write || buf->bd_readers)
{
log_error ("Buffer %p occupied in cpt\n", buf);
/* This can be legitimate if a thread is in freeze mode and one itc is on a table scan and another is in order by or hash fill, so that the freeze is in the temp space operation . */
/* error = 1; */
}
if (dbs_cache_check_enable && DPF_INDEX == SHORT_REF (buf->bd_buffer + DP_FLAGS)
&& IT_CHECK_FAST != mode)
pg_check_map_1 (buf);
if (buf->bd_is_dirty && !gethash (DP_ADDR2VOID (buf->bd_page), &itm->itm_remap))
{
log_error ("Buffer %p dirty but no remap, tree %s", buf, it->it_key ? it->it_key->key_name : "no key");
dbg_page_map_log (buf, "missed_flush.txt", "Dirty page with no remap");
}
if (((dp_addr_t) dp) != buf->bd_page)
{
log_error ("*** Buffer %p cache dp %ld buf dp %ld \n",
(void *)buf, dp, (unsigned long) buf->bd_page);
error = 1;
}
if (IT_CHECK_POST == mode && dbs_is_free_page (it->it_storage, (dp_addr_t) dp))
{
log_error ("*** buffer with free dp L=%ld buf=%p \n",
dp, (void *)buf);
error = 1;
}
if (IT_CHECK_POST != mode && dbs_is_free_page (it->it_storage, (dp_addr_t) dp))
{
short fl = SHORT_REF (buf->bd_buffer + DP_FLAGS);
if (fl != DPF_BLOB && fl != DPF_BLOB_DIR)
{
log_error ("*** In cpt, suspect to have buffer with free dp L=%ld buf=%p while it is neither blob or blob dir, which may be free at this point if uncommitted.\n",
dp, (void *)buf);
error = 1;
}
}
if (((dp_addr_t) dp) != buf->bd_physical_page
&& dbs_is_free_page (it->it_storage, buf->bd_physical_page))
{
log_error ("*** buffer with free remap dp L=%ld P=%ld buf=%p \n",
dp, (unsigned long) buf->bd_physical_page, (void *)buf);
error = 1;
}
remap = (long) (ptrlong) gethash (DP_ADDR2VOID (dp), &itm->itm_remap);
if (!remap)
remap = (long) (ptrlong) gethash (DP_ADDR2VOID (buf->bd_page), it->it_storage->dbs_cpt_remap);
if ((remap && buf->bd_physical_page != (dp_addr_t) remap)
|| (((dp_addr_t)dp) != buf->bd_physical_page && ((dp_addr_t) remap) != buf->bd_physical_page))
{
log_error ("*** Inconsistent remap L=%ld buf P=%ld isp P=%ld \n",
dp, (unsigned long) buf->bd_physical_page, remap);
error = 1;
}
l=SHORT_REF (buf->bd_buffer + DP_FLAGS);
if (dp != buf->bd_physical_page && (DPF_BLOB == l || DPF_BLOB_DIR == l ))
{
log_error ("*** Blob not to be remapped L=%ld P=%ld \n",
dp, (unsigned long) buf->bd_physical_page);
}
if (error && IT_CHECK_FAST == mode)
log_error ("it_cache_check got errors but will not stop in mid cpt");
else if (error && gpf_on_error)
GPF_T1 ("Buffer cache consistency check failed.");
}
if (error)
{
gpf_on_error = 1;
error = 0;
mutex_leave (&itm->itm_mtx);
continue; /* loop again, this time gpf on first error. */
}
mutex_leave (&itm->itm_mtx);
}
}
buffer_desc_t *
it_new_page (index_tree_t * it, dp_addr_t addr, int type, int in_pmap,
it_cursor_t * has_hold)
{
it_map_t * itm;
extent_map_t * em = it->it_extent_map;
int ext_type = (!it->it_blobs_with_index && (DPF_BLOB == type || DPF_BLOB_DIR == type)) ? EXT_BLOB : EXT_INDEX, n_tries;
buffer_desc_t *buf;
buffer_pool_t * action_bp = NULL;
dp_addr_t physical_dp;
if (in_pmap)
GPF_T1 ("do not call isp_new_page in page map");
physical_dp = em_new_dp (em, ext_type, addr, NULL);
if (!physical_dp)
{
log_error ("Out of disk space for database");
if (DPF_INDEX == type)
{
/* a split must never fail to get a page. Use the remap hold as a backup */
physical_dp = em_new_dp (it->it_extent_map, EXT_REMAP, 0, &has_hold->itc_n_pages_on_hold);
if (!physical_dp)
{
log_error ("After running out of disk, cannot get a page from remap reserve to complete operation. Exiting.");
call_exit (-1);
}
}
else
return NULL;
}
if (DPF_INDEX == type)
it->it_n_index_est++;
else
it->it_n_blob_est++;
for (n_tries = 0; ; n_tries++)
{
buf = bp_get_buffer_1 (NULL, &action_bp, in_log_replay ? BP_BUF_REQUIRED : BP_BUF_IF_AVAIL);
if (buf)
break;
if (action_bp)
bp_delayed_stat_action (action_bp);
action_bp = NULL;
if (n_tries > 10)
{
log_error ("Signaling out of disk due to failure to get a buffer. This condition is not a case of running out of disk");
return NULL;
}
if (5 == n_tries)
log_info ("Failed to get a buffer for a new page. Retrying. If the failure repeats, an out of disk error will be signalled. The cause of this is having too many buffers wired down for preread, flush or group by/hash join temp space. To correct, increase the number of buffers in the configuration file. If this repeats in spite of having hundreds of thousands of buffers, please report to support.");
if (n_tries > 4)
virtuoso_sleep (0, 50000 * (n_tries - 4));
}
if (action_bp)
bp_delayed_stat_action (action_bp);
if (buf->bd_readers != 1)
GPF_T1 ("expecting buf to be wired down when allocated");
buf_dbg_printf (("Buf %x new in tree %x dp=%d\n", buf, isp, physical_dp));
itm = IT_DP_MAP (it, physical_dp);
mutex_enter (&itm->itm_mtx);
sethash (DP_ADDR2VOID (physical_dp), &itm->itm_dp_to_buf, (void*) buf);
sethash (DP_ADDR2VOID (physical_dp), &itm->itm_remap,
DP_ADDR2VOID (physical_dp));
buf->bd_page = physical_dp;
buf->bd_physical_page = physical_dp;
buf->bd_tree = it;
buf->bd_storage = it->it_storage;
buf->bd_pl = NULL;
buf->bd_readers = 0;
BD_SET_IS_WRITE (buf, 1);
mutex_leave (&itm->itm_mtx);
if (em != em->em_dbs->dbs_extent_map && EXT_INDEX == ext_type)
{
mutex_enter (em->em_mtx);
remhash (DP_ADDR2VOID(physical_dp), em->em_uninitialized);
mutex_leave (em->em_mtx);
}
#ifdef PAGE_TRACE
memset (buf->bd_buffer, 0, PAGE_SZ); /* all for debug view */
#else
memset (buf->bd_buffer, 0, PAGE_SZ - PAGE_DATA_SZ); /* header only */
#endif
SHORT_SET (buf->bd_buffer + DP_FLAGS, type);
if (type == DPF_INDEX)
{
page_map_t * map = buf->bd_content_map;
if (!map)
buf->bd_content_map = (page_map_t*) resource_get (PM_RC (PM_SZ_1));
else
{
if (map->pm_size > PM_SZ_1)
{
resource_store (PM_RC (map->pm_size), (void*) map);
buf->bd_content_map = (page_map_t *) resource_get (PM_RC (PM_SZ_1));
}
}
pg_map_clear (buf);
LONG_SET (buf->bd_buffer + DP_KEY_ID, it->it_key ? it->it_key->key_id : KI_TEMP);
}
else if (buf->bd_content_map)
{
resource_store (PM_RC (buf->bd_content_map->pm_size), (void*) buf->bd_content_map);
buf->bd_content_map = NULL;
}
buf_set_dirty (buf);
DBG_PT_PRINTF (("New page L=%d B=%p FL=%d K=%s \n", buf->bd_page, buf, type,
it->it_key ? (it->it_key->key_name ? it->it_key->key_name : "unnamed key") : "no key"));
TC (tc_new_page);
return buf;
}
