开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
java_DbEnv.c
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：39k
源码类别：

MySQL数据库

开发平台：

Visual C++

java_DbEnv.c：源码内容
  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 1997-2002
  5.  * Sleepycat Software.  All rights reserved.
  6.  */
  7. #include "db_config.h"
  9. #ifndef lint
  10. static const char revid[] = "$Id: java_DbEnv.c,v 11.105 2002/08/29 14:22:23 margo Exp $";
  11. #endif /* not lint */
  13. #include <jni.h>
  14. #include <stdlib.h>
  15. #include <string.h>
  17. #include "db_int.h"
  18. #include "java_util.h"
  19. #include "java_stat_auto.h"
  20. #include "com_sleepycat_db_DbEnv.h"
  22. /* We keep these lined up, and alphabetical by field name,
  23.  * for comparison with C++'s list.
  24.  */
  25. JAVADB_SET_METH_STR(DbEnv,   data_1dir, DB_ENV, data_dir)
  26. JAVADB_SET_METH(DbEnv, jint, lg_1bsize, DB_ENV, lg_bsize)
  27. JAVADB_SET_METH_STR(DbEnv,   lg_1dir, DB_ENV, lg_dir)
  28. JAVADB_SET_METH(DbEnv, jint, lg_1max, DB_ENV, lg_max)
  29. JAVADB_SET_METH(DbEnv, jint, lg_1regionmax, DB_ENV, lg_regionmax)
  30. JAVADB_SET_METH(DbEnv, jint, lk_1detect, DB_ENV, lk_detect)
  31. JAVADB_SET_METH(DbEnv, jint, lk_1max, DB_ENV, lk_max)
  32. JAVADB_SET_METH(DbEnv, jint, lk_1max_1locks, DB_ENV, lk_max_locks)
  33. JAVADB_SET_METH(DbEnv, jint, lk_1max_1lockers, DB_ENV, lk_max_lockers)
  34. JAVADB_SET_METH(DbEnv, jint, lk_1max_1objects, DB_ENV, lk_max_objects)
  35. /* mp_mmapsize is declared below, it needs an extra cast */
  36. JAVADB_SET_METH_STR(DbEnv,   tmp_1dir, DB_ENV, tmp_dir)
  37. JAVADB_SET_METH(DbEnv, jint, tx_1max, DB_ENV, tx_max)
  39. static void DbEnv_errcall_callback(const char *prefix, char *message)
  40. {
  41. JNIEnv *jnienv;
  42. DB_ENV_JAVAINFO *envinfo = (DB_ENV_JAVAINFO *)prefix;
  43. jstring pre;
  45. /*
  46.  * Note: these error cases are "impossible", and would
  47.  * normally warrant an exception.  However, without
  48.  * a jnienv, we cannot throw an exception...
  49.  * We don't want to trap or exit, since the point of
  50.  * this facility is for the user to completely control
  51.  * error situations.
  52.  */
  53. if (envinfo == NULL) {
  54. /*
  55.  * Something is *really* wrong here, the
  56.  * prefix is set in every environment created.
  57.  */
  58. fprintf(stderr, "Error callback failed!n");
  59. fprintf(stderr, "error: %sn", message);
  60. return;
  61. }
  63. /* Should always succeed... */
  64. jnienv = dbjie_get_jnienv(envinfo);
  66. if (jnienv == NULL) {
  68. /* But just in case... */
  69. fprintf(stderr, "Cannot attach to current thread!n");
  70. fprintf(stderr, "error: %sn", message);
  71. return;
  72. }
  74. pre = dbjie_get_errpfx(envinfo, jnienv);
  75. report_errcall(jnienv, dbjie_get_errcall(envinfo), pre, message);
  76. }
  78. static void DbEnv_initialize(JNIEnv *jnienv, DB_ENV *dbenv,
  79.      /*DbEnv*/ jobject jenv,
  80.      /*DbErrcall*/ jobject jerrcall,
  81.      int is_dbopen)
  82. {
  83. DB_ENV_JAVAINFO *envinfo;
  85. envinfo = get_DB_ENV_JAVAINFO(jnienv, jenv);
  86. DB_ASSERT(envinfo == NULL);
  87. envinfo = dbjie_construct(jnienv, jenv, jerrcall, is_dbopen);
  88. set_private_info(jnienv, name_DB_ENV, jenv, envinfo);
  89. dbenv->set_errpfx(dbenv, (const char*)envinfo);
  90. dbenv->set_errcall(dbenv, DbEnv_errcall_callback);
  91. dbenv->api2_internal = envinfo;
  92. set_private_dbobj(jnienv, name_DB_ENV, jenv, dbenv);
  93. }
  95. /*
  96.  * This is called when this DbEnv was made on behalf of a Db
  97.  * created directly (without a parent DbEnv), and the Db is
  98.  * being closed.  We'll zero out the pointer to the DB_ENV,
  99.  * since it is no longer valid, to prevent mistakes.
  100.  */
  101. JNIEXPORT void JNICALL Java_com_sleepycat_db_DbEnv__1notify_1db_1close
  102.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis)
  103. {
  104. DB_ENV_JAVAINFO *dbenvinfo;
  106. set_private_dbobj(jnienv, name_DB_ENV, jthis, 0);
  107. dbenvinfo = get_DB_ENV_JAVAINFO(jnienv, jthis);
  108. if (dbenvinfo != NULL)
  109. dbjie_dealloc(dbenvinfo, jnienv);
  110. }
  112. JNIEXPORT void JNICALL Java_com_sleepycat_db_DbEnv_feedback_1changed
  113.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis,
  114.    /*DbEnvFeedback*/ jobject jfeedback)
  115. {
  116. DB_ENV *dbenv;
  117. DB_ENV_JAVAINFO *dbenvinfo;
  119. dbenv = get_DB_ENV(jnienv, jthis);
  120. dbenvinfo = get_DB_ENV_JAVAINFO(jnienv, jthis);
  121. if (!verify_non_null(jnienv, dbenv) ||
  122.     !verify_non_null(jnienv, dbenvinfo))
  123. return;
  125. dbjie_set_feedback_object(dbenvinfo, jnienv, dbenv, jfeedback);
  126. }
  128. JNIEXPORT void JNICALL Java_com_sleepycat_db_DbEnv__1init
  129.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jobject /*DbErrcall*/ jerrcall,
  130.    jint flags)
  131. {
  132. int err;
  133. DB_ENV *dbenv;
  135. err = db_env_create(&dbenv, flags);
  136. if (verify_return(jnienv, err, 0))
  137. DbEnv_initialize(jnienv, dbenv, jthis, jerrcall, 0);
  138. }
  140. JNIEXPORT void JNICALL Java_com_sleepycat_db_DbEnv__1init_1using_1db
  141.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jobject /*DbErrcall*/ jerrcall,
  142.    /*Db*/ jobject jdb)
  143. {
  144. DB_ENV *dbenv;
  145. DB *db;
  147. db = get_DB(jnienv, jdb);
  148. dbenv = db->dbenv;
  149. DbEnv_initialize(jnienv, dbenv, jthis, jerrcall, 0);
  150. }
  152. JNIEXPORT void JNICALL Java_com_sleepycat_db_DbEnv_open
  153.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jstring db_home,
  154.    jint flags, jint mode)
  155. {
  156. int err;
  157. DB_ENV *dbenv;
  158. LOCKED_STRING ls_home;
  159. DB_ENV_JAVAINFO *dbenvinfo;
  161. dbenv = get_DB_ENV(jnienv, jthis);
  162. dbenvinfo = get_DB_ENV_JAVAINFO(jnienv, jthis);
  163. if (!verify_non_null(jnienv, dbenv) ||
  164.     !verify_non_null(jnienv, dbenvinfo))
  165. return;
  166. if (locked_string_get(&ls_home, jnienv, db_home) != 0)
  167. goto out;
  169. /* Java is assumed to be threaded. */
  170. flags |= DB_THREAD;
  172. err = dbenv->open(dbenv, ls_home.string, flags, mode);
  173. verify_return(jnienv, err, EXCEPTION_FILE_NOT_FOUND);
  174.  out:
  175. locked_string_put(&ls_home, jnienv);
  176. }
  178. JNIEXPORT void JNICALL Java_com_sleepycat_db_DbEnv_remove
  179.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jstring db_home, jint flags)
  180. {
  181. DB_ENV *dbenv;
  182. DB_ENV_JAVAINFO *dbenvinfo;
  183. LOCKED_STRING ls_home;
  184. int err = 0;
  186. dbenv = get_DB_ENV(jnienv, jthis);
  187. dbenvinfo = get_DB_ENV_JAVAINFO(jnienv, jthis);
  188. if (!verify_non_null(jnienv, dbenv))
  189. return;
  190. if (locked_string_get(&ls_home, jnienv, db_home) != 0)
  191. goto out;
  193. err = dbenv->remove(dbenv, ls_home.string, flags);
  194. set_private_dbobj(jnienv, name_DB_ENV, jthis, 0);
  196. verify_return(jnienv, err, 0);
  197.  out:
  198. locked_string_put(&ls_home, jnienv);
  200. if (dbenvinfo != NULL)
  201. dbjie_dealloc(dbenvinfo, jnienv);
  202. }
  204. JNIEXPORT void JNICALL Java_com_sleepycat_db_DbEnv__1close
  205.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jint flags)
  206. {
  207. int err;
  208. DB_ENV *dbenv;
  209. DB_ENV_JAVAINFO *dbenvinfo;
  211. dbenv = get_DB_ENV(jnienv, jthis);
  212. dbenvinfo = get_DB_ENV_JAVAINFO(jnienv, jthis);
  213. if (!verify_non_null(jnienv, dbenv))
  214. return;
  216. err = dbenv->close(dbenv, flags);
  217. set_private_dbobj(jnienv, name_DB_ENV, jthis, 0);
  219. if (dbenvinfo != NULL)
  220. dbjie_dealloc(dbenvinfo, jnienv);
  222. /* Throw an exception if the close failed. */
  223. verify_return(jnienv, err, 0);
  224. }
  226. JNIEXPORT void JNICALL Java_com_sleepycat_db_DbEnv_dbremove
  227.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, /*DbTxn*/ jobject jtxn,
  228.    jstring name, jstring subdb, jint flags)
  229. {
  230. LOCKED_STRING ls_name, ls_subdb;
  231. DB_ENV *dbenv;
  232. DB_TXN *txn;
  233. int err;
  235. dbenv = get_DB_ENV(jnienv, jthis);
  236. if (!verify_non_null(jnienv, dbenv))
  237. return;
  238. txn = get_DB_TXN(jnienv, jtxn);
  239. if (locked_string_get(&ls_name, jnienv, name) != 0)
  240. return;
  241. if (locked_string_get(&ls_subdb, jnienv, subdb) != 0)
  242. goto err1;
  244. err = dbenv->dbremove(dbenv, txn, ls_name.string, ls_subdb.string,
  245.     flags);
  247. /* Throw an exception if the dbremove failed. */
  248. verify_return(jnienv, err, 0);
  250. locked_string_put(&ls_subdb, jnienv);
  251. err1: locked_string_put(&ls_name, jnienv);
  252. }
  254. JNIEXPORT void JNICALL Java_com_sleepycat_db_DbEnv_dbrename
  255.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, /*DbTxn*/ jobject jtxn,
  256.    jstring name, jstring subdb, jstring newname, jint flags)
  257. {
  258. LOCKED_STRING ls_name, ls_subdb, ls_newname;
  259. DB_ENV *dbenv;
  260. DB_TXN *txn;
  261. int err;
  263. dbenv = get_DB_ENV(jnienv, jthis);
  264. if (!verify_non_null(jnienv, dbenv))
  265. return;
  266. txn = get_DB_TXN(jnienv, jtxn);
  267. if (locked_string_get(&ls_name, jnienv, name) != 0)
  268. return;
  269. if (locked_string_get(&ls_subdb, jnienv, subdb) != 0)
  270. goto err2;
  271. if (locked_string_get(&ls_newname, jnienv, newname) != 0)
  272. goto err1;
  274. err = dbenv->dbrename(dbenv, txn, ls_name.string, ls_subdb.string,
  275.     ls_newname.string, flags);
  277. /* Throw an exception if the dbrename failed. */
  278. verify_return(jnienv, err, 0);
  280. locked_string_put(&ls_newname, jnienv);
  281. err1: locked_string_put(&ls_subdb, jnienv);
  282. err2: locked_string_put(&ls_name, jnienv);
  283. }
  285. JNIEXPORT void JNICALL Java_com_sleepycat_db_DbEnv_err
  286.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jint ecode, jstring msg)
  287. {
  288. LOCKED_STRING ls_msg;
  289. DB_ENV *dbenv;
  291. dbenv = get_DB_ENV(jnienv, jthis);
  292. if (!verify_non_null(jnienv, dbenv))
  293. return;
  295. if (locked_string_get(&ls_msg, jnienv, msg) != 0)
  296. goto out;
  298. dbenv->err(dbenv, ecode, "%s", ls_msg.string);
  299.  out:
  300. locked_string_put(&ls_msg, jnienv);
  301. }
  303. JNIEXPORT void JNICALL Java_com_sleepycat_db_DbEnv_errx
  304.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jstring msg)
  305. {
  306. LOCKED_STRING ls_msg;
  307. DB_ENV *dbenv;
  309. dbenv = get_DB_ENV(jnienv, jthis);
  310. if (!verify_non_null(jnienv, dbenv))
  311. return;
  313. if (locked_string_get(&ls_msg, jnienv, msg) != 0)
  314. goto out;
  316. dbenv->errx(dbenv, "%s", ls_msg.string);
  317.  out:
  318. locked_string_put(&ls_msg, jnienv);
  319. }
  321. /*static*/
  322. JNIEXPORT jstring JNICALL Java_com_sleepycat_db_DbEnv_strerror
  323.   (JNIEnv *jnienv, jclass jthis_class, jint ecode)
  324. {
  325. const char *message;
  327. COMPQUIET(jthis_class, NULL);
  328. message = db_strerror(ecode);
  329. return (get_java_string(jnienv, message));
  330. }
  332. JAVADB_METHOD(DbEnv_set_1cachesize,
  333.     (JAVADB_ARGS, jint gbytes, jint bytes, jint ncaches), DB_ENV,
  334.     set_cachesize, (c_this, gbytes, bytes, ncaches))
  336. JNIEXPORT void JNICALL Java_com_sleepycat_db_DbEnv_set_1encrypt
  337.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jstring jpasswd, jint flags)
  338. {
  339. int err;
  340. DB_ENV *dbenv;
  341. LOCKED_STRING ls_passwd;
  343. dbenv = get_DB_ENV(jnienv, jthis);
  344. if (!verify_non_null(jnienv, dbenv))
  345. return;
  346. if (locked_string_get(&ls_passwd, jnienv, jpasswd) != 0)
  347. goto out;
  349. err = dbenv->set_encrypt(dbenv, ls_passwd.string, flags);
  350. verify_return(jnienv, err, 0);
  352. out: locked_string_put(&ls_passwd, jnienv);
  353. }
  355. JAVADB_METHOD(DbEnv_set_1flags,
  356.     (JAVADB_ARGS, jint flags, jboolean onoff), DB_ENV,
  357.     set_flags, (c_this, flags, onoff ? 1 : 0))
  359. JAVADB_METHOD(DbEnv_set_1mp_1mmapsize, (JAVADB_ARGS, jlong value), DB_ENV,
  360.     set_mp_mmapsize, (c_this, (size_t)value))
  362. JAVADB_METHOD(DbEnv_set_1tas_1spins, (JAVADB_ARGS, jint spins), DB_ENV,
  363.     set_tas_spins, (c_this, (u_int32_t)spins))
  365. JAVADB_METHOD(DbEnv_set_1timeout,
  366.     (JAVADB_ARGS, jlong timeout, jint flags), DB_ENV,
  367.     set_timeout, (c_this, (u_int32_t)timeout, flags))
  369. JNIEXPORT void JNICALL Java_com_sleepycat_db_DbEnv_set_1lk_1conflicts
  370.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jobjectArray array)
  371. {
  372. DB_ENV *dbenv;
  373. DB_ENV_JAVAINFO *dbenvinfo;
  374. int err;
  375. jsize i, len;
  376. u_char *newarr;
  377. int bytesize;
  379. dbenv = get_DB_ENV(jnienv, jthis);
  380. dbenvinfo = get_DB_ENV_JAVAINFO(jnienv, jthis);
  381. if (!verify_non_null(jnienv, dbenv) ||
  382.     !verify_non_null(jnienv, dbenvinfo))
  383. return;
  385. len = (*jnienv)->GetArrayLength(jnienv, array);
  386. bytesize = sizeof(u_char) * len * len;
  388. if ((err = __os_malloc(dbenv, bytesize, &newarr)) != 0) {
  389. if (!verify_return(jnienv, err, 0))
  390. return;
  391. }
  393. for (i=0; i<len; i++) {
  394. jobject subArray =
  395. (*jnienv)->GetObjectArrayElement(jnienv, array, i);
  396. (*jnienv)->GetByteArrayRegion(jnienv, (jbyteArray)subArray,
  397.       0, len,
  398.       (jbyte *)&newarr[i*len]);
  399. }
  400. dbjie_set_conflict(dbenvinfo, newarr, bytesize);
  401. err = dbenv->set_lk_conflicts(dbenv, newarr, len);
  402. verify_return(jnienv, err, 0);
  403. }
  405. JNIEXPORT jint JNICALL
  406.   Java_com_sleepycat_db_DbEnv_rep_1elect
  407.   (JNIEnv *jnienv, /* DbEnv */ jobject jthis, jint nsites, jint pri,
  408.    jint timeout)
  409. {
  410. DB_ENV *dbenv;
  411. int err, id;
  413. if (!verify_non_null(jnienv, jthis))
  414. return (DB_EID_INVALID);
  416. dbenv = get_DB_ENV(jnienv, jthis);
  418. err = dbenv->rep_elect(dbenv, (int)nsites,
  419.     (int)pri, (u_int32_t)timeout, &id);
  420. verify_return(jnienv, err, 0);
  422. return ((jint)id);
  423. }
  425. JNIEXPORT jint JNICALL
  426.   Java_com_sleepycat_db_DbEnv_rep_1process_1message
  427.   (JNIEnv *jnienv, /* DbEnv */ jobject jthis, /* Dbt */ jobject control,
  428.   /* Dbt */ jobject rec, /* RepProcessMessage */ jobject result)
  429. {
  430. DB_ENV *dbenv;
  431. LOCKED_DBT cdbt, rdbt;
  432. int err, envid;
  434. if (!verify_non_null(jnienv, jthis) || !verify_non_null(jnienv, result))
  435. return (-1);
  437. dbenv = get_DB_ENV(jnienv, jthis);
  438. err = 0;
  440. /* The DBTs are always inputs. */
  441. if (locked_dbt_get(&cdbt, jnienv, dbenv, control, inOp) != 0)
  442. goto out2;
  443. if (locked_dbt_get(&rdbt, jnienv, dbenv, rec, inOp) != 0)
  444. goto out1;
  446. envid = (*jnienv)->GetIntField(jnienv,
  447.     result, fid_RepProcessMessage_envid);
  449. err = dbenv->rep_process_message(dbenv, &cdbt.javainfo->dbt,
  450.     &rdbt.javainfo->dbt, &envid);
  452. if (err == DB_REP_NEWMASTER)
  453. (*jnienv)->SetIntField(jnienv,
  454.     result, fid_RepProcessMessage_envid, envid);
  455. else if (!DB_RETOK_REPPMSG(err))
  456. verify_return(jnienv, err, 0);
  458. out1: locked_dbt_put(&rdbt, jnienv, dbenv);
  459. out2: locked_dbt_put(&cdbt, jnienv, dbenv);
  461. return (err);
  462. }
  464. JNIEXPORT void JNICALL
  465.   Java_com_sleepycat_db_DbEnv_rep_1start
  466.   (JNIEnv *jnienv, /* DbEnv */ jobject jthis, /* Dbt */ jobject cookie,
  467.    jint flags)
  468. {
  469. DB_ENV *dbenv;
  470. DBT *dbtp;
  471. LOCKED_DBT ldbt;
  472. int err;
  474. if (!verify_non_null(jnienv, jthis))
  475. return;
  477. dbenv = get_DB_ENV(jnienv, jthis);
  479. /* The Dbt cookie may be null;  if so, pass in a NULL DBT. */
  480. if (cookie != NULL) {
  481. if (locked_dbt_get(&ldbt, jnienv, dbenv, cookie, inOp) != 0)
  482. goto out;
  483. dbtp = &ldbt.javainfo->dbt;
  484. } else
  485. dbtp = NULL;
  487. err = dbenv->rep_start(dbenv, dbtp, flags);
  488. verify_return(jnienv, err, 0);
  490. out: if (cookie != NULL)
  491. locked_dbt_put(&ldbt, jnienv, dbenv);
  492. }
  494. JNIEXPORT jobject JNICALL Java_com_sleepycat_db_DbEnv_rep_1stat
  495.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jint flags)
  496. {
  497. int err;
  498. DB_ENV *dbenv = get_DB_ENV(jnienv, jthis);
  499. DB_REP_STAT *statp = NULL;
  500. jobject retval = NULL;
  501. jclass dbclass;
  503. if (!verify_non_null(jnienv, dbenv))
  504. return (NULL);
  506. err = dbenv->rep_stat(dbenv, &statp, (u_int32_t)flags);
  507. if (verify_return(jnienv, err, 0)) {
  508. if ((dbclass = get_class(jnienv, name_DB_REP_STAT)) == NULL ||
  509.     (retval =
  510.       create_default_object(jnienv, name_DB_REP_STAT)) == NULL)
  511. goto err; /* An exception has been posted. */
  513. __jv_fill_rep_stat(jnienv, dbclass, retval, statp);
  515. err: __os_ufree(dbenv, statp);
  516. }
  517. return (retval);
  518. }
  520. JNIEXPORT void JNICALL
  521. Java_com_sleepycat_db_DbEnv_set_1rep_1limit
  522.   (JNIEnv *jnienv, /* DbEnv */ jobject jthis, jint gbytes, jint bytes)
  523. {
  524. DB_ENV *dbenv;
  525. int err;
  527. dbenv = get_DB_ENV(jnienv, jthis);
  529. if (verify_non_null(jnienv, dbenv)) {
  530. err = dbenv->set_rep_limit(dbenv,
  531.     (u_int32_t)gbytes, (u_int32_t)bytes);
  532. verify_return(jnienv, err, 0);
  533. }
  534. }
  536. JNIEXPORT void JNICALL
  537.   Java_com_sleepycat_db_DbEnv_rep_1transport_1changed
  538.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jint envid,
  539.    /* DbRepTransport */ jobject jreptransport)
  540. {
  541. DB_ENV *dbenv;
  542. DB_ENV_JAVAINFO *dbenvinfo;
  544. dbenv = get_DB_ENV(jnienv, jthis);
  545. dbenvinfo = get_DB_ENV_JAVAINFO(jnienv, jthis);
  546. if (!verify_non_null(jnienv, dbenv) ||
  547.     !verify_non_null(jnienv, dbenvinfo) ||
  548.     !verify_non_null(jnienv, jreptransport))
  549. return;
  551. dbjie_set_rep_transport_object(dbenvinfo,
  552.     jnienv, dbenv, envid, jreptransport);
  553. }
  555. JNIEXPORT void JNICALL
  556.   Java_com_sleepycat_db_DbEnv_set_1rpc_1server
  557.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, /*DbClient*/ jobject jclient,
  558.    jstring jhost, jlong tsec, jlong ssec, jint flags)
  559. {
  560. int err;
  561. DB_ENV *dbenv = get_DB_ENV(jnienv, jthis);
  562. const char *host = (*jnienv)->GetStringUTFChars(jnienv, jhost, NULL);
  564. if (jclient != NULL) {
  565. report_exception(jnienv, "DbEnv.set_rpc_server client arg "
  566.  "must be null; reserved for future use",
  567.  EINVAL, 0);
  568. return;
  569. }
  570. if (verify_non_null(jnienv, dbenv)) {
  571. err = dbenv->set_rpc_server(dbenv, NULL, host,
  572. (long)tsec, (long)ssec, flags);
  574. /* Throw an exception if the call failed. */
  575. verify_return(jnienv, err, 0);
  576. }
  577. }
  579. JAVADB_METHOD(DbEnv_set_1shm_1key, (JAVADB_ARGS, jlong shm_key), DB_ENV,
  580.     set_shm_key, (c_this, (long)shm_key))
  582. JNIEXPORT void JNICALL
  583.   Java_com_sleepycat_db_DbEnv__1set_1tx_1timestamp
  584.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jlong seconds)
  585. {
  586. int err;
  587. DB_ENV *dbenv = get_DB_ENV(jnienv, jthis);
  588. time_t time = seconds;
  590. if (verify_non_null(jnienv, dbenv)) {
  591. err = dbenv->set_tx_timestamp(dbenv, &time);
  593. /* Throw an exception if the call failed. */
  594. verify_return(jnienv, err, 0);
  595. }
  596. }
  598. JAVADB_METHOD(DbEnv_set_1verbose,
  599.     (JAVADB_ARGS, jint which, jboolean onoff), DB_ENV,
  600.     set_verbose, (c_this, which, onoff ? 1 : 0))
  602. /*static*/
  603. JNIEXPORT jint JNICALL Java_com_sleepycat_db_DbEnv_get_1version_1major
  604.   (JNIEnv * jnienv, jclass this_class)
  605. {
  606. COMPQUIET(jnienv, NULL);
  607. COMPQUIET(this_class, NULL);
  609. return (DB_VERSION_MAJOR);
  610. }
  612. /*static*/
  613. JNIEXPORT jint JNICALL Java_com_sleepycat_db_DbEnv_get_1version_1minor
  614.   (JNIEnv * jnienv, jclass this_class)
  615. {
  616. COMPQUIET(jnienv, NULL);
  617. COMPQUIET(this_class, NULL);
  619. return (DB_VERSION_MINOR);
  620. }
  622. /*static*/
  623. JNIEXPORT jint JNICALL Java_com_sleepycat_db_DbEnv_get_1version_1patch
  624.   (JNIEnv * jnienv, jclass this_class)
  625. {
  626. COMPQUIET(jnienv, NULL);
  627. COMPQUIET(this_class, NULL);
  629. return (DB_VERSION_PATCH);
  630. }
  632. /*static*/
  633. JNIEXPORT jstring JNICALL Java_com_sleepycat_db_DbEnv_get_1version_1string
  634.   (JNIEnv *jnienv, jclass this_class)
  635. {
  636. COMPQUIET(this_class, NULL);
  638. return ((*jnienv)->NewStringUTF(jnienv, DB_VERSION_STRING));
  639. }
  641. JNIEXPORT jint JNICALL Java_com_sleepycat_db_DbEnv_lock_1id
  642.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis)
  643. {
  644. int err;
  645. u_int32_t id;
  646. DB_ENV *dbenv = get_DB_ENV(jnienv, jthis);
  648. if (!verify_non_null(jnienv, dbenv))
  649. return (-1);
  650. err = dbenv->lock_id(dbenv, &id);
  651. verify_return(jnienv, err, 0);
  652. return (id);
  653. }
  655. JAVADB_METHOD(DbEnv_lock_1id_1free, (JAVADB_ARGS, jint id), DB_ENV,
  656.     lock_id_free, (c_this, id))
  658. JNIEXPORT jobject JNICALL Java_com_sleepycat_db_DbEnv_lock_1stat
  659.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jint flags)
  660. {
  661. int err;
  662. DB_ENV *dbenv = get_DB_ENV(jnienv, jthis);
  663. DB_LOCK_STAT *statp = NULL;
  664. jobject retval = NULL;
  665. jclass dbclass;
  667. if (!verify_non_null(jnienv, dbenv))
  668. return (NULL);
  670. err = dbenv->lock_stat(dbenv, &statp, (u_int32_t)flags);
  671. if (verify_return(jnienv, err, 0)) {
  672. if ((dbclass = get_class(jnienv, name_DB_LOCK_STAT)) == NULL ||
  673.     (retval =
  674.       create_default_object(jnienv, name_DB_LOCK_STAT)) == NULL)
  675. goto err; /* An exception has been posted. */
  677. __jv_fill_lock_stat(jnienv, dbclass, retval, statp);
  679. err: __os_ufree(dbenv, statp);
  680. }
  681. return (retval);
  682. }
  684. JNIEXPORT jint JNICALL Java_com_sleepycat_db_DbEnv_lock_1detect
  685.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jint atype, jint flags)
  686. {
  687. int err;
  688. DB_ENV *dbenv = get_DB_ENV(jnienv, jthis);
  689. int aborted;
  691. if (!verify_non_null(jnienv, dbenv))
  692. return (0);
  693. err = dbenv->lock_detect(dbenv, atype, flags, &aborted);
  694. verify_return(jnienv, err, 0);
  695. return (aborted);
  696. }
  698. JNIEXPORT /*DbLock*/ jobject JNICALL Java_com_sleepycat_db_DbEnv_lock_1get
  699.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, /*u_int32_t*/ jint locker,
  700.    jint flags, /*const Dbt*/ jobject obj, /*db_lockmode_t*/ jint lock_mode)
  701. {
  702. int err;
  703. DB_ENV *dbenv;
  704. DB_LOCK *dblock;
  705. LOCKED_DBT lobj;
  706. /*DbLock*/ jobject retval;
  708. dbenv = get_DB_ENV(jnienv, jthis);
  709. if (!verify_non_null(jnienv, dbenv))
  710. return (NULL);
  712. if ((err = __os_malloc(dbenv, sizeof(DB_LOCK), &dblock)) != 0)
  713. if (!verify_return(jnienv, err, 0))
  714. return (NULL);
  716. memset(dblock, 0, sizeof(DB_LOCK));
  717. err = 0;
  718. retval = NULL;
  719. if (locked_dbt_get(&lobj, jnienv, dbenv, obj, inOp) != 0)
  720. goto out;
  722. err = dbenv->lock_get(dbenv, locker, flags, &lobj.javainfo->dbt,
  723.        (db_lockmode_t)lock_mode, dblock);
  725. if (err == DB_LOCK_NOTGRANTED)
  726. report_notgranted_exception(jnienv,
  727.     "DbEnv.lock_get not granted",
  728.     DB_LOCK_GET, lock_mode, obj,
  729.     NULL, -1);
  730. else if (verify_return(jnienv, err, 0)) {
  731. retval = create_default_object(jnienv, name_DB_LOCK);
  732. set_private_dbobj(jnienv, name_DB_LOCK, retval, dblock);
  733. }
  735.  out:
  736. locked_dbt_put(&lobj, jnienv, dbenv);
  737. return (retval);
  738. }
  740. JNIEXPORT void JNICALL Java_com_sleepycat_db_DbEnv_lock_1vec
  741.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, /*u_int32_t*/ jint locker,
  742.    jint flags, /*const Dbt*/ jobjectArray list, jint offset, jint count)
  743. {
  744. DB_ENV *dbenv;
  745. DB_LOCKREQ *lockreq;
  746. DB_LOCKREQ *prereq; /* preprocessed requests */
  747. DB_LOCKREQ *failedreq;
  748. DB_LOCK *lockp;
  749. LOCKED_DBT *locked_dbts;
  750. int err;
  751. int alloc_err;
  752. int i;
  753. size_t bytesize;
  754. size_t ldbtsize;
  755. jobject jlockreq;
  756. db_lockop_t op;
  757. jobject jobj;
  758. jobject jlock;
  759. int completed;
  761. dbenv = get_DB_ENV(jnienv, jthis);
  762. if (!verify_non_null(jnienv, dbenv))
  763. goto out0;
  765. if ((*jnienv)->GetArrayLength(jnienv, list) < offset + count) {
  766. report_exception(jnienv,
  767.  "DbEnv.lock_vec array not large enough",
  768.  0, 0);
  769. goto out0;
  770. }
  772. bytesize = sizeof(DB_LOCKREQ) * count;
  773. if ((err = __os_malloc(dbenv, bytesize, &lockreq)) != 0) {
  774. verify_return(jnienv, err, 0);
  775. goto out0;
  776. }
  777. memset(lockreq, 0, bytesize);
  779. ldbtsize = sizeof(LOCKED_DBT) * count;
  780. if ((err = __os_malloc(dbenv, ldbtsize, &locked_dbts)) != 0) {
  781. verify_return(jnienv, err, 0);
  782. goto out1;
  783. }
  784. memset(lockreq, 0, ldbtsize);
  785. prereq = &lockreq[0];
  787. /* fill in the lockreq array */
  788. for (i = 0, prereq = &lockreq[0]; i < count; i++, prereq++) {
  789. jlockreq = (*jnienv)->GetObjectArrayElement(jnienv, list,
  790.     offset + i);
  791. if (jlockreq == NULL) {
  792. report_exception(jnienv,
  793.  "DbEnv.lock_vec list entry is null",
  794.  0, 0);
  795. goto out2;
  796. }
  797. op = (*jnienv)->GetIntField(jnienv, jlockreq,
  798.     fid_DbLockRequest_op);
  799. prereq->op = op;
  801. switch (op) {
  802. case DB_LOCK_GET_TIMEOUT:
  803. /* Needed: mode, timeout, obj.  Returned: lock. */
  804. prereq->op = (*jnienv)->GetIntField(jnienv, jlockreq,
  805.     fid_DbLockRequest_timeout);
  806. /* FALLTHROUGH */
  807. case DB_LOCK_GET:
  808. /* Needed: mode, obj.  Returned: lock. */
  809. prereq->mode = (*jnienv)->GetIntField(jnienv, jlockreq,
  810.     fid_DbLockRequest_mode);
  811. jobj = (*jnienv)->GetObjectField(jnienv, jlockreq,
  812.     fid_DbLockRequest_obj);
  813. if ((err = locked_dbt_get(&locked_dbts[i], jnienv,
  814.     dbenv, jobj, inOp)) != 0)
  815. goto out2;
  816. prereq->obj = &locked_dbts[i].javainfo->dbt;
  817. break;
  818. case DB_LOCK_PUT:
  819. /* Needed: lock.  Ignored: mode, obj. */
  820. jlock = (*jnienv)->GetObjectField(jnienv, jlockreq,
  821. fid_DbLockRequest_lock);
  822. if (!verify_non_null(jnienv, jlock))
  823. goto out2;
  824. lockp = get_DB_LOCK(jnienv, jlock);
  825. if (!verify_non_null(jnienv, lockp))
  826. goto out2;
  828. prereq->lock = *lockp;
  829. break;
  830. case DB_LOCK_PUT_ALL:
  831. case DB_LOCK_TIMEOUT:
  832. /* Needed: (none).  Ignored: lock, mode, obj. */
  833. break;
  834. case DB_LOCK_PUT_OBJ:
  835. /* Needed: obj.  Ignored: lock, mode. */
  836. jobj = (*jnienv)->GetObjectField(jnienv, jlockreq,
  837. fid_DbLockRequest_obj);
  838. if ((err = locked_dbt_get(&locked_dbts[i], jnienv,
  839.    dbenv, jobj, inOp)) != 0)
  840. goto out2;
  841. prereq->obj = &locked_dbts[i].javainfo->dbt;
  842. break;
  843. default:
  844. report_exception(jnienv,
  845.  "DbEnv.lock_vec bad op value",
  846.  0, 0);
  847. goto out2;
  848. }
  849. }
  851. err = dbenv->lock_vec(dbenv, locker, flags, lockreq, count, &failedreq);
  852. if (err == 0)
  853. completed = count;
  854. else
  855. completed = failedreq - lockreq;
  857. /* do post processing for any and all requests that completed */
  858. for (i = 0; i < completed; i++) {
  859. op = lockreq[i].op;
  860. if (op == DB_LOCK_PUT) {
  861. /*
  862.  * After a successful put, the DbLock can no longer
  863.  * be used, so we release the storage related to it.
  864.  */
  865. jlockreq = (*jnienv)->GetObjectArrayElement(jnienv,
  866.     list, i + offset);
  867. jlock = (*jnienv)->GetObjectField(jnienv, jlockreq,
  868. fid_DbLockRequest_lock);
  869. lockp = get_DB_LOCK(jnienv, jlock);
  870. __os_free(NULL, lockp);
  871. set_private_dbobj(jnienv, name_DB_LOCK, jlock, 0);
  872. }
  873. else if (op == DB_LOCK_GET) {
  874. /*
  875.  * Store the lock that was obtained.
  876.  * We need to create storage for it since
  877.  * the lockreq array only exists during this
  878.  * method call.
  879.  */
  880. alloc_err = __os_malloc(dbenv, sizeof(DB_LOCK), &lockp);
  881. if (!verify_return(jnienv, alloc_err, 0))
  882. goto out2;
  884. *lockp = lockreq[i].lock;
  886. jlockreq = (*jnienv)->GetObjectArrayElement(jnienv,
  887.     list, i + offset);
  888. jlock = create_default_object(jnienv, name_DB_LOCK);
  889. set_private_dbobj(jnienv, name_DB_LOCK, jlock, lockp);
  890. (*jnienv)->SetObjectField(jnienv, jlockreq,
  891.   fid_DbLockRequest_lock,
  892.   jlock);
  893. }
  894. }
  896. /* If one of the locks was not granted, build the exception now. */
  897. if (err == DB_LOCK_NOTGRANTED && i < count) {
  898. jlockreq = (*jnienv)->GetObjectArrayElement(jnienv,
  899.     list, i + offset);
  900. jobj = (*jnienv)->GetObjectField(jnienv, jlockreq,
  901.  fid_DbLockRequest_obj);
  902. jlock = (*jnienv)->GetObjectField(jnienv, jlockreq,
  903.   fid_DbLockRequest_lock);
  904. report_notgranted_exception(jnienv,
  905.     "DbEnv.lock_vec incomplete",
  906.     lockreq[i].op,
  907.     lockreq[i].mode,
  908.     jobj,
  909.     jlock,
  910.     i);
  911. }
  912. else
  913. verify_return(jnienv, err, 0);
  915.  out2:
  916. /* Free the dbts that we have locked */
  917. for (i = 0 ; i < (prereq - lockreq); i++) {
  918. if ((op = lockreq[i].op) == DB_LOCK_GET ||
  919.     op == DB_LOCK_PUT_OBJ)
  920. locked_dbt_put(&locked_dbts[i], jnienv, dbenv);
  921. }
  922. __os_free(dbenv, locked_dbts);
  924.  out1:
  925. __os_free(dbenv, lockreq);
  927.  out0:
  928. return;
  929. }
  931. JNIEXPORT void JNICALL Java_com_sleepycat_db_DbEnv_lock_1put
  932.   (JNIEnv *jnienv, jobject jthis, /*DbLock*/ jobject jlock)
  933. {
  934. int err;
  935. DB_ENV *dbenv;
  936. DB_LOCK *dblock;
  938. dbenv = get_DB_ENV(jnienv, jthis);
  939. if (!verify_non_null(jnienv, dbenv))
  940. return;
  942. dblock = get_DB_LOCK(jnienv, jlock);
  943. if (!verify_non_null(jnienv, dblock))
  944. return;
  946. err = dbenv->lock_put(dbenv, dblock);
  947. if (verify_return(jnienv, err, 0)) {
  948. /*
  949.  * After a successful put, the DbLock can no longer
  950.  * be used, so we release the storage related to it
  951.  * (allocated in DbEnv.lock_get()).
  952.  */
  953. __os_free(NULL, dblock);
  955. set_private_dbobj(jnienv, name_DB_LOCK, jlock, 0);
  956. }
  957. }
  959. JNIEXPORT jobjectArray JNICALL Java_com_sleepycat_db_DbEnv_log_1archive
  960.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jint flags)
  961. {
  962. int err, len, i;
  963. char** ret;
  964. jclass stringClass;
  965. jobjectArray strarray;
  966. DB_ENV *dbenv;
  968. dbenv = get_DB_ENV(jnienv, jthis);
  969. strarray = NULL;
  970. if (!verify_non_null(jnienv, dbenv))
  971. return (0);
  972. err = dbenv->log_archive(dbenv, &ret, flags);
  973. if (!verify_return(jnienv, err, 0))
  974. return (0);
  976. if (ret != NULL) {
  977. len = 0;
  978. while (ret[len] != NULL)
  979. len++;
  980. stringClass = (*jnienv)->FindClass(jnienv, "java/lang/String");
  981. if ((strarray = (*jnienv)->NewObjectArray(jnienv,
  982.     len, stringClass, 0)) == NULL)
  983. goto out;
  984. for (i=0; i<len; i++) {
  985. jstring str = (*jnienv)->NewStringUTF(jnienv, ret[i]);
  986. (*jnienv)->SetObjectArrayElement(jnienv, strarray,
  987.      i, str);
  988. }
  989. }
  990. out: return (strarray);
  991. }
  993. JNIEXPORT jint JNICALL Java_com_sleepycat_db_DbEnv_log_1compare
  994.   (JNIEnv *jnienv, jclass jthis_class,
  995.    /*DbLsn*/ jobject lsn0, /*DbLsn*/ jobject lsn1)
  996. {
  997. DB_LSN *dblsn0;
  998. DB_LSN *dblsn1;
  1000. COMPQUIET(jthis_class, NULL);
  1001. dblsn0 = get_DB_LSN(jnienv, lsn0);
  1002. dblsn1 = get_DB_LSN(jnienv, lsn1);
  1004. return (log_compare(dblsn0, dblsn1));
  1005. }
  1007. JNIEXPORT jobject JNICALL Java_com_sleepycat_db_DbEnv_log_1cursor
  1008.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jint flags)
  1009. {
  1010. int err;
  1011. DB_LOGC *dblogc;
  1012. DB_ENV *dbenv = get_DB_ENV(jnienv, jthis);
  1014. if (!verify_non_null(jnienv, dbenv))
  1015. return (NULL);
  1016. err = dbenv->log_cursor(dbenv, &dblogc, flags);
  1017. verify_return(jnienv, err, 0);
  1018. return (get_DbLogc(jnienv, dblogc));
  1019. }
  1021. JNIEXPORT jstring JNICALL Java_com_sleepycat_db_DbEnv_log_1file
  1022.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, /*DbLsn*/ jobject lsn)
  1023. {
  1024. int err;
  1025. DB_ENV *dbenv = get_DB_ENV(jnienv, jthis);
  1026. DB_LSN *dblsn = get_DB_LSN(jnienv, lsn);
  1027. char filename[FILENAME_MAX+1] = "";
  1029. if (!verify_non_null(jnienv, dbenv))
  1030. return (NULL);
  1032. err = dbenv->log_file(dbenv, dblsn, filename, FILENAME_MAX);
  1033. verify_return(jnienv, err, 0);
  1034. filename[FILENAME_MAX] = ''; /* just to be sure */
  1035. return (get_java_string(jnienv, filename));
  1036. }
  1038. JAVADB_METHOD(DbEnv_log_1flush,
  1039.     (JAVADB_ARGS, /*DbLsn*/ jobject lsn), DB_ENV,
  1040.     log_flush, (c_this, get_DB_LSN(jnienv, lsn)))
  1042. JNIEXPORT void JNICALL Java_com_sleepycat_db_DbEnv_log_1put
  1043.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, /*DbLsn*/ jobject lsn,
  1044.    /*DbDbt*/ jobject data, jint flags)
  1045. {
  1046. int err;
  1047. DB_ENV *dbenv;
  1048. DB_LSN *dblsn;
  1049. LOCKED_DBT ldata;
  1051. dbenv = get_DB_ENV(jnienv, jthis);
  1052. dblsn = get_DB_LSN(jnienv, lsn);
  1053. if (!verify_non_null(jnienv, dbenv))
  1054. return;
  1056. /* log_put's DB_LSN argument may not be NULL. */
  1057. if (!verify_non_null(jnienv, dblsn))
  1058. return;
  1060. if (locked_dbt_get(&ldata, jnienv, dbenv, data, inOp) != 0)
  1061. goto out;
  1063. err = dbenv->log_put(dbenv, dblsn, &ldata.javainfo->dbt, flags);
  1064. verify_return(jnienv, err, 0);
  1065.  out:
  1066. locked_dbt_put(&ldata, jnienv, dbenv);
  1067. }
  1069. JNIEXPORT jobject JNICALL Java_com_sleepycat_db_DbEnv_log_1stat
  1070.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jint flags)
  1071. {
  1072. int err;
  1073. DB_ENV *dbenv;
  1074. DB_LOG_STAT *statp;
  1075. jobject retval;
  1076. jclass dbclass;
  1078. retval = NULL;
  1079. statp = NULL;
  1080. dbenv = get_DB_ENV(jnienv, jthis);
  1081. if (!verify_non_null(jnienv, dbenv))
  1082. return (NULL);
  1084. err = dbenv->log_stat(dbenv, &statp, (u_int32_t)flags);
  1085. if (verify_return(jnienv, err, 0)) {
  1086. if ((dbclass = get_class(jnienv, name_DB_LOG_STAT)) == NULL ||
  1087.     (retval =
  1088.        create_default_object(jnienv, name_DB_LOG_STAT)) == NULL)
  1089. goto err; /* An exception has been posted. */
  1091. __jv_fill_log_stat(jnienv, dbclass, retval, statp);
  1093. err: __os_ufree(dbenv, statp);
  1094. }
  1095. return (retval);
  1096. }
  1098. JNIEXPORT jobject JNICALL Java_com_sleepycat_db_DbEnv_memp_1stat
  1099.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jint flags)
  1100. {
  1101. int err;
  1102. jclass dbclass;
  1103. DB_ENV *dbenv;
  1104. DB_MPOOL_STAT *statp;
  1105. jobject retval;
  1107. retval = NULL;
  1108. statp = NULL;
  1109. dbenv = get_DB_ENV(jnienv, jthis);
  1110. if (!verify_non_null(jnienv, dbenv))
  1111. return (NULL);
  1113. err = dbenv->memp_stat(dbenv, &statp, 0, (u_int32_t)flags);
  1114. if (verify_return(jnienv, err, 0)) {
  1115. if ((dbclass = get_class(jnienv, name_DB_MPOOL_STAT)) == NULL ||
  1116.     (retval =
  1117.      create_default_object(jnienv, name_DB_MPOOL_STAT)) == NULL)
  1118. goto err; /* An exception has been posted. */
  1120. __jv_fill_mpool_stat(jnienv, dbclass, retval, statp);
  1122. err: __os_ufree(dbenv, statp);
  1123. }
  1124. return (retval);
  1125. }
  1127. JNIEXPORT jobjectArray JNICALL Java_com_sleepycat_db_DbEnv_memp_1fstat
  1128.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jint flags)
  1129. {
  1130. int err, i, len;
  1131. jclass fstat_class;
  1132. DB_ENV *dbenv;
  1133. DB_MPOOL_FSTAT **fstatp;
  1134. jobjectArray retval;
  1135. jfieldID filename_id;
  1136. jstring jfilename;
  1138. fstatp = NULL;
  1139. retval = NULL;
  1140. dbenv = get_DB_ENV(jnienv, jthis);
  1141. if (!verify_non_null(jnienv, dbenv))
  1142. return (NULL);
  1144. err = dbenv->memp_stat(dbenv, 0, &fstatp, (u_int32_t)flags);
  1145. if (verify_return(jnienv, err, 0)) {
  1146. len = 0;
  1147. while (fstatp[len] != NULL)
  1148. len++;
  1149. if ((fstat_class =
  1150. get_class(jnienv, name_DB_MPOOL_FSTAT)) == NULL ||
  1151.     (retval = (*jnienv)->NewObjectArray(jnienv, len,
  1152. fstat_class, 0)) == NULL)
  1153. goto err;
  1154. for (i=0; i<len; i++) {
  1155. jobject obj;
  1156. if ((obj = create_default_object(jnienv,
  1157.     name_DB_MPOOL_FSTAT)) == NULL)
  1158. goto err;
  1159. (*jnienv)->SetObjectArrayElement(jnienv, retval,
  1160.     i, obj);
  1162. /* Set the string field. */
  1163. filename_id = (*jnienv)->GetFieldID(jnienv,
  1164.     fstat_class, "file_name", string_signature);
  1165. jfilename = get_java_string(jnienv,
  1166.     fstatp[i]->file_name);
  1167. (*jnienv)->SetObjectField(jnienv, obj,
  1168.     filename_id, jfilename);
  1169. set_int_field(jnienv, fstat_class, obj,
  1170.     "st_pagesize", fstatp[i]->st_pagesize);
  1171. set_int_field(jnienv, fstat_class, obj,
  1172.     "st_cache_hit", fstatp[i]->st_cache_hit);
  1173. set_int_field(jnienv, fstat_class, obj,
  1174.     "st_cache_miss", fstatp[i]->st_cache_miss);
  1175. set_int_field(jnienv, fstat_class, obj,
  1176.     "st_map", fstatp[i]->st_map);
  1177. set_int_field(jnienv, fstat_class, obj,
  1178.     "st_page_create", fstatp[i]->st_page_create);
  1179. set_int_field(jnienv, fstat_class, obj,
  1180.     "st_page_in", fstatp[i]->st_page_in);
  1181. set_int_field(jnienv, fstat_class, obj,
  1182.     "st_page_out", fstatp[i]->st_page_out);
  1183. __os_ufree(dbenv, fstatp[i]);
  1184. }
  1185. err: __os_ufree(dbenv, fstatp);
  1186. }
  1187. return (retval);
  1188. }
  1190. JNIEXPORT jint JNICALL Java_com_sleepycat_db_DbEnv_memp_1trickle
  1191.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jint pct)
  1192. {
  1193. int err;
  1194. DB_ENV *dbenv = get_DB_ENV(jnienv, jthis);
  1195. int result = 0;
  1197. if (verify_non_null(jnienv, dbenv)) {
  1198. err = dbenv->memp_trickle(dbenv, pct, &result);
  1199. verify_return(jnienv, err, 0);
  1200. }
  1201. return (result);
  1202. }
  1204. JNIEXPORT jobject JNICALL Java_com_sleepycat_db_DbEnv_txn_1begin
  1205.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, /*DbTxn*/ jobject pid, jint flags)
  1206. {
  1207. int err;
  1208. DB_TXN *dbpid, *result;
  1209. DB_ENV *dbenv;
  1211. dbenv = get_DB_ENV(jnienv, jthis);
  1212. if (!verify_non_null(jnienv, dbenv))
  1213. return (0);
  1215. dbpid = get_DB_TXN(jnienv, pid);
  1216. result = 0;
  1218. err = dbenv->txn_begin(dbenv, dbpid, &result, flags);
  1219. if (!verify_return(jnienv, err, 0))
  1220. return (0);
  1221. return (get_DbTxn(jnienv, result));
  1222. }
  1224. JAVADB_METHOD(DbEnv_txn_1checkpoint,
  1225.     (JAVADB_ARGS, jint kbyte, jint min, jint flags), DB_ENV,
  1226.     txn_checkpoint, (c_this, kbyte, min, flags))
  1228. JNIEXPORT void JNICALL Java_com_sleepycat_db_DbEnv_app_1dispatch_1changed
  1229.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, /*DbFeedback*/ jobject jappdispatch)
  1230. {
  1231. DB_ENV *dbenv;
  1232. DB_ENV_JAVAINFO *dbenvinfo;
  1234. dbenv = get_DB_ENV(jnienv, jthis);
  1235. dbenvinfo = get_DB_ENV_JAVAINFO(jnienv, jthis);
  1236. if (!verify_non_null(jnienv, dbenv) ||
  1237.     !verify_non_null(jnienv, dbenvinfo))
  1238. return;
  1240. dbjie_set_app_dispatch_object(dbenvinfo, jnienv, dbenv, jappdispatch);
  1241. }
  1243. JNIEXPORT jobjectArray JNICALL Java_com_sleepycat_db_DbEnv_txn_1recover
  1244.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jint count, jint flags)
  1245. {
  1246. int err;
  1247. DB_ENV *dbenv;
  1248. DB_PREPLIST *preps;
  1249. long retcount;
  1250. int i;
  1251. char signature[128];
  1252. size_t bytesize;
  1253. jobject retval;
  1254. jobject obj;
  1255. jobject txnobj;
  1256. jbyteArray bytearr;
  1257. jclass preplist_class;
  1258. jfieldID txn_fieldid;
  1259. jfieldID gid_fieldid;
  1261. retval = NULL;
  1262. dbenv = get_DB_ENV(jnienv, jthis);
  1263. if (!verify_non_null(jnienv, dbenv))
  1264. return (NULL);
  1266. /*
  1267.  * We need to allocate some local storage for the
  1268.  * returned preplist, and that requires us to do
  1269.  * our own argument validation.
  1270.  */
  1271. if (count <= 0) {
  1272. verify_return(jnienv, EINVAL, 0);
  1273. goto out;
  1274. }
  1276. bytesize = sizeof(DB_PREPLIST) * count;
  1277. if ((err = __os_malloc(dbenv, bytesize, &preps)) != 0) {
  1278. verify_return(jnienv, err, 0);
  1279. goto out;
  1280. }
  1282. err = dbenv->txn_recover(dbenv, preps, count, &retcount, flags);
  1284. if (verify_return(jnienv, err, 0)) {
  1285. if ((preplist_class =
  1286.     get_class(jnienv, name_DB_PREPLIST)) == NULL ||
  1287.     (retval = (*jnienv)->NewObjectArray(jnienv, retcount,
  1288.     preplist_class, 0)) == NULL)
  1289. goto err;
  1291. (void)snprintf(signature, sizeof(signature),
  1292.     "L%s%s;", DB_PACKAGE_NAME, name_DB_TXN);
  1293. txn_fieldid = (*jnienv)->GetFieldID(jnienv, preplist_class,
  1294.     "txn", signature);
  1295. gid_fieldid = (*jnienv)->GetFieldID(jnienv, preplist_class,
  1296.     "gid", "[B");
  1298. for (i=0; i<retcount; i++) {
  1299. /*
  1300.  * First, make a blank DbPreplist object
  1301.  * and set the array entry.
  1302.  */
  1303. if ((obj = create_default_object(jnienv,
  1304.     name_DB_PREPLIST)) == NULL)
  1305. goto err;
  1306. (*jnienv)->SetObjectArrayElement(jnienv,
  1307.     retval, i, obj);
  1309. /* Set the txn field. */
  1310. txnobj = get_DbTxn(jnienv, preps[i].txn);
  1311. (*jnienv)->SetObjectField(jnienv,
  1312.     obj, txn_fieldid, txnobj);
  1314. /* Build the gid array and set the field. */
  1315. if ((bytearr = (*jnienv)->NewByteArray(jnienv,
  1316.     sizeof(preps[i].gid))) == NULL)
  1317. goto err;
  1318. (*jnienv)->SetByteArrayRegion(jnienv, bytearr, 0,
  1319.     sizeof(preps[i].gid), (jbyte *)&preps[i].gid[0]);
  1320. (*jnienv)->SetObjectField(jnienv, obj,
  1321.     gid_fieldid, bytearr);
  1322. }
  1323. }
  1324. err: __os_free(dbenv, preps);
  1325. out: return (retval);
  1326. }
  1328. JNIEXPORT jobject JNICALL Java_com_sleepycat_db_DbEnv_txn_1stat
  1329.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jint flags)
  1330. {
  1331. int err;
  1332. DB_ENV *dbenv;
  1333. DB_TXN_STAT *statp;
  1334. jobject retval, obj;
  1335. jclass dbclass, active_class;
  1336. char active_signature[512];
  1337. jfieldID arrid;
  1338. jobjectArray actives;
  1339. unsigned int i;
  1341. retval = NULL;
  1342. statp = NULL;
  1343. dbenv = get_DB_ENV(jnienv, jthis);
  1344. if (!verify_non_null(jnienv, dbenv))
  1345. return (NULL);
  1347. err = dbenv->txn_stat(dbenv, &statp, (u_int32_t)flags);
  1348. if (verify_return(jnienv, err, 0)) {
  1349. if ((dbclass = get_class(jnienv, name_DB_TXN_STAT)) == NULL ||
  1350.     (retval =
  1351.        create_default_object(jnienv, name_DB_TXN_STAT)) == NULL)
  1352. goto err;
  1354. /* Set the individual fields */
  1355. __jv_fill_txn_stat(jnienv, dbclass, retval, statp);
  1357. if ((active_class =
  1358.     get_class(jnienv, name_DB_TXN_STAT_ACTIVE)) == NULL ||
  1359.     (actives = (*jnienv)->NewObjectArray(jnienv,
  1360.     statp->st_nactive, active_class, 0)) == NULL)
  1361. goto err;
  1363. /*
  1364.  * Set the st_txnarray field.  This is a little more involved
  1365.  * than other fields, since the type is an array, so none
  1366.  * of our utility functions help.
  1367.  */
  1368. (void)snprintf(active_signature, sizeof(active_signature),
  1369.     "[L%s%s;", DB_PACKAGE_NAME, name_DB_TXN_STAT_ACTIVE);
  1371. arrid = (*jnienv)->GetFieldID(jnienv, dbclass, "st_txnarray",
  1372.       active_signature);
  1373. (*jnienv)->SetObjectField(jnienv, retval, arrid, actives);
  1375. /* Now fill the in the elements of st_txnarray. */
  1376. for (i=0; i<statp->st_nactive; i++) {
  1377. obj = create_default_object(jnienv,
  1378. name_DB_TXN_STAT_ACTIVE);
  1379. (*jnienv)->SetObjectArrayElement(jnienv,
  1380. actives, i, obj);
  1382. set_int_field(jnienv, active_class, obj,
  1383.       "txnid", statp->st_txnarray[i].txnid);
  1384. set_int_field(jnienv, active_class, obj, "parentid",
  1385.       statp->st_txnarray[i].parentid);
  1386. set_lsn_field(jnienv, active_class, obj,
  1387.       "lsn", statp->st_txnarray[i].lsn);
  1388. }
  1390. err: __os_ufree(dbenv, statp);
  1391. }
  1392. return (retval);
  1393. }
  1395. /* See discussion on errpfx, errcall in DB_ENV_JAVAINFO */
  1396. JNIEXPORT void JNICALL Java_com_sleepycat_db_DbEnv__1set_1errcall
  1397.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jobject errcall)
  1398. {
  1399. DB_ENV *dbenv;
  1400. DB_ENV_JAVAINFO *dbenvinfo;
  1402. dbenv = get_DB_ENV(jnienv, jthis);
  1403. dbenvinfo = get_DB_ENV_JAVAINFO(jnienv, jthis);
  1405. if (verify_non_null(jnienv, dbenv) &&
  1406.     verify_non_null(jnienv, dbenvinfo)) {
  1407. dbjie_set_errcall(dbenvinfo, jnienv, errcall);
  1408. }
  1409. }
  1411. JNIEXPORT void JNICALL Java_com_sleepycat_db_DbEnv__1set_1errpfx
  1412.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jstring str)
  1413. {
  1414. DB_ENV *dbenv;
  1415. DB_ENV_JAVAINFO *dbenvinfo;
  1417. dbenv = get_DB_ENV(jnienv, jthis);
  1418. dbenvinfo = get_DB_ENV_JAVAINFO(jnienv, jthis);
  1420. if (verify_non_null(jnienv, dbenv) &&
  1421.     verify_non_null(jnienv, dbenvinfo)) {
  1422. dbjie_set_errpfx(dbenvinfo, jnienv, str);
  1423. }
  1424. }
  1426. JNIEXPORT void JNICALL Java_com_sleepycat_db_DbEnv__1finalize
  1427.     (JNIEnv *jnienv, /*DbEnv*/ jobject jthis,
  1428.      jobject /*DbErrcall*/ errcall, jstring errpfx)
  1429. {
  1430. DB_ENV *dbenv;
  1431. DB_ENV_JAVAINFO *envinfo;
  1433. dbenv = get_DB_ENV(jnienv, jthis);
  1434. envinfo = get_DB_ENV_JAVAINFO(jnienv, jthis);
  1435. DB_ASSERT(envinfo != NULL);
  1437. /* Note:  We detect and report unclosed DbEnvs. */
  1438. if (dbenv != NULL && envinfo != NULL && !dbjie_is_dbopen(envinfo)) {
  1440. /* If this error occurs, this object was never closed. */
  1441. report_errcall(jnienv, errcall, errpfx,
  1442.        "DbEnv.finalize: open DbEnv object destroyed");
  1443. }
  1445. /* Shouldn't see this object again, but just in case */
  1446. set_private_dbobj(jnienv, name_DB_ENV, jthis, 0);
  1447. set_private_info(jnienv, name_DB_ENV, jthis, 0);
  1449. dbjie_destroy(envinfo, jnienv);
  1450. }