Пример #1
0
extern "C" int
__db_close_int(long id, u_int32_t flags)
{
	Db *dbp;
	int ret;
	ct_entry *ctp;

	ret = 0;
	ctp = get_tableent(id);
	if (ctp == NULL)
		return (DB_NOSERVER_ID);
	DB_ASSERT(ctp->ct_type == CT_DB);
	if (__dbsrv_verbose && ctp->ct_refcount != 1)
		printf("Deref'ing dbp id %ld, refcount %d\n",
		    id, ctp->ct_refcount);
	if (--ctp->ct_refcount != 0)
		return (ret);
	dbp = ctp->ct_dbp;
	if (__dbsrv_verbose)
		printf("Closing dbp id %ld\n", id);

	ret = dbp->close(flags);
	__dbdel_ctp(ctp);
	return (ret);
}
Пример #2
0
extern "C" int
__dbenv_close_int(long id, u_int32_t flags, int force)
{
	DbEnv *dbenv;
	int ret;
	ct_entry *ctp;

	ret = 0;
	ctp = get_tableent(id);
	if (ctp == NULL)
		return (DB_NOSERVER_ID);
	DB_ASSERT(ctp->ct_type == CT_ENV);
	if (__dbsrv_verbose && ctp->ct_refcount != 1)
		printf("Deref'ing env id %ld, refcount %d\n",
		    id, ctp->ct_refcount);
	/*
	 * If we are timing out, we need to force the close, no matter
	 * what the refcount.
	 */
	if (--ctp->ct_refcount != 0 && !force)
		return (ret);
	dbenv = ctp->ct_envp;
	if (__dbsrv_verbose)
		printf("Closing env id %ld\n", id);

	ret = dbenv->close(flags);
	__dbdel_ctp(ctp);
	return (ret);
}
Пример #3
0
int dbji_call_dup_compare(DB_JAVAINFO *dbji, DB *db, jobject jdb,
                          const DBT *dbt1, const DBT *dbt2)
{
    JNIEnv *jnienv;
    jobject jdbt1, jdbt2;
    DBT_JAVAINFO *dbtji1, *dbtji2;

    COMPQUIET(db, NULL);
    jnienv = dbji_get_jnienv(dbji);
    if (jnienv == NULL) {
        fprintf(stderr, "Cannot attach to current thread!\n");
        return (0);
    }

    /* XXX
     * We should have a pool of Dbt objects used for this purpose
     * instead of creating new ones each time.  Because of
     * multithreading, we may need an arbitrary number (more than two).
     * We might also have a byte arrays that grow as needed,
     * so we don't need to allocate those either.
     */
    jdbt1 = create_default_object(jnienv, name_DBT);
    jdbt2 = create_default_object(jnienv, name_DBT);
    dbtji1 = get_DBT_JAVAINFO(jnienv, jdbt1);
    memcpy(&dbtji1->dbt, dbt1, sizeof(DBT));
    dbtji1->create_array_ = 1;
    dbtji2 = get_DBT_JAVAINFO(jnienv, jdbt2);
    memcpy(&dbtji2->dbt, dbt2, sizeof(DBT));
    dbtji2->create_array_ = 1;

    DB_ASSERT(dbji->dup_compare_method_id_ != NULL);
    return (*jnienv)->CallIntMethod(jnienv, dbji->dup_compare_,
                                    dbji->dup_compare_method_id_,
                                    jdb, jdbt1, jdbt2);
}
Пример #4
0
static void DbEnv_feedback_callback(DB_ENV *dbenv, int opcode, int percent)
{
    DB_ENV_JAVAINFO *dbinfo;

    DB_ASSERT(dbenv != NULL);
    dbinfo = (DB_ENV_JAVAINFO *)dbenv->cj_internal;
    dbjie_call_feedback(dbinfo, dbenv, dbinfo->jenvref_, opcode, percent);
}
Пример #5
0
static void Db_feedback_callback(DB *db, int opcode, int percent)
{
    DB_JAVAINFO *dbinfo;

    DB_ASSERT(db != NULL);
    dbinfo = (DB_JAVAINFO *)db->cj_internal;
    dbji_call_feedback(dbinfo, db, dbinfo->jdbref_, opcode, percent);
}
Пример #6
0
static int DbEnv_tx_recover_callback(DB_ENV *dbenv, DBT *dbt,
                                     DB_LSN *lsn, db_recops recops)
{
    DB_ENV_JAVAINFO *dbinfo;

    DB_ASSERT(dbenv != NULL);
    dbinfo = (DB_ENV_JAVAINFO *)dbenv->cj_internal;
    return dbjie_call_tx_recover(dbinfo, dbenv, dbinfo->jenvref_, dbt,
                                 lsn, recops);
}
Пример #7
0
void dbji_call_feedback(DB_JAVAINFO *dbji, DB *db, jobject jdb,
                        int opcode, int percent)
{
    JNIEnv *jnienv;

    COMPQUIET(db, NULL);
    jnienv = dbji_get_jnienv(dbji);
    if (jnienv == NULL) {
        fprintf(stderr, "Cannot attach to current thread!\n");
        return;
    }

    DB_ASSERT(dbji->feedback_method_id_ != NULL);
    (*jnienv)->CallVoidMethod(jnienv, dbji->feedback_,
                              dbji->feedback_method_id_,
                              jdb, (jint)opcode, (jint)percent);
}
Пример #8
0
int dbji_call_h_hash(DB_JAVAINFO *dbji, DB *db, jobject jdb,
                     const void *data, int len)
{
    JNIEnv *jnienv;
    jbyteArray jarray;

    COMPQUIET(db, NULL);
    jnienv = dbji_get_jnienv(dbji);
    if (jnienv == NULL) {
        fprintf(stderr, "Cannot attach to current thread!\n");
        return (0);
    }

    DB_ASSERT(dbji->h_hash_method_id_ != NULL);

    jarray = (*jnienv)->NewByteArray(jnienv, len);
    (*jnienv)->SetByteArrayRegion(jnienv, jarray, 0, len, (void *)data);
    return (*jnienv)->CallIntMethod(jnienv, dbji->h_hash_,
                                    dbji->h_hash_method_id_,
                                    jdb, jarray, len);
}
Пример #9
0
extern int dbji_call_append_recno(DB_JAVAINFO *dbji, DB *db, jobject jdb,
                                  DBT *dbt, jint recno)
{
    JNIEnv *jnienv;
    jobject jdbt;
    DBT_JAVAINFO *dbtji;
    jbyteArray arr;
    unsigned int arraylen;
    unsigned char *data;

    COMPQUIET(db, NULL);
    jnienv = dbji_get_jnienv(dbji);
    if (jnienv == NULL) {
        fprintf(stderr, "Cannot attach to current thread!\n");
        return (0);
    }

    /* XXX
     * We should have a pool of Dbt objects used for this purpose
     * instead of creating new ones each time.  Because of
     * multithreading, we may need an arbitrary number (more than two).
     * We might also have a byte arrays that grow as needed,
     * so we don't need to allocate those either.
     *
     * Note, we do not set the 'create_array_' flag as on other
     * callbacks as we are creating the array here.
     */
    jdbt = create_default_object(jnienv, name_DBT);
    dbtji = get_DBT_JAVAINFO(jnienv, jdbt);
    memcpy(&dbtji->dbt, dbt, sizeof(DBT));
    dbtji->dbt.data = NULL;
    arr = (*jnienv)->NewByteArray(jnienv, dbt->size);
    (*jnienv)->SetByteArrayRegion(jnienv, arr, 0, dbt->size,
                                  (jbyte *)dbt->data);
    dbtji->array_ = (jbyteArray)NEW_GLOBAL_REF(jnienv, arr);

    DB_ASSERT(dbji->append_recno_method_id_ != NULL);
    (*jnienv)->CallVoidMethod(jnienv, dbji->append_recno_,
                              dbji->append_recno_method_id_,
                              jdb, jdbt, recno);

    /* The underlying C API requires that an errno be returned
     * on error.  Java users know nothing of errnos, so we
     * allow them to throw exceptions instead.  We leave the
     * exception in place and return DB_JAVA_CALLBACK to the C API
     * that called us.  Eventually the DB->get will fail and
     * when java prepares to throw an exception in
     * report_exception(), this will be spotted as a special case,
     * and the original exception will be preserved.
     *
     * Note: we have sometimes noticed strange behavior with
     * exceptions under Linux 1.1.7 JVM.  (i.e. multiple calls
     * to ExceptionOccurred() may report different results).
     * Currently we don't know of any problems related to this
     * in our code, but if it pops up in the future, users are
     * encouranged to get a more recent JVM.
     */
    if ((*jnienv)->ExceptionOccurred(jnienv) != NULL)
        return (DB_JAVA_CALLBACK);

    if (dbtji->array_ == NULL) {
        report_exception(jnienv, "Dbt.data is null", 0, 0);
        return (EFAULT);
    }

    arraylen = (*jnienv)->GetArrayLength(jnienv, dbtji->array_);
    if (dbtji->offset_ < 0 ) {
        report_exception(jnienv, "Dbt.offset illegal", 0, 0);
        return (EFAULT);
    }
    if (dbt->ulen + dbtji->offset_ > arraylen) {
        report_exception(jnienv,
                         "Dbt.ulen + Dbt.offset greater than array length", 0, 0);
        return (EFAULT);
    }

    data = (*jnienv)->GetByteArrayElements(jnienv, dbtji->array_,
                                           (jboolean *)0);
    dbt->data = data + dbtji->offset_;
    return (0);
}