db_server_proc.c

mysql数据库源代码

/*-
 * See the file LICENSE for redistribution information.
 *
 * Copyright (c) 2000-2002
 *      Sleepycat Software.  All rights reserved.
 */

#include "db_config.h"

#ifdef HAVE_RPC
#ifndef lint
static const char revid[] = "$Id: db_server_proc.c,v 1.92 2002/07/29 15:21:20 sue Exp $";
#endif /* not lint */

#ifndef NO_SYSTEM_INCLUDES
#include <sys/types.h>

#include <rpc/rpc.h>

#include <string.h>
#endif
#include "dbinc_auto/db_server.h"

#include "db_int.h"
#include "dbinc/db_server_int.h"
#include "dbinc_auto/rpc_server_ext.h"

/* BEGIN __env_cachesize_proc */
/*
 * PUBLIC: void __env_cachesize_proc __P((long, u_int32_t, u_int32_t,
 * PUBLIC:      u_int32_t, __env_cachesize_reply *));
 */
void
__env_cachesize_proc(dbenvcl_id, gbytes, bytes,
		ncache, replyp)
	long dbenvcl_id;
	u_int32_t gbytes;
	u_int32_t bytes;
	u_int32_t ncache;
	__env_cachesize_reply *replyp;
/* END __env_cachesize_proc */
{
	DB_ENV *dbenv;
	ct_entry *dbenv_ctp;
	int ret;

	ACTIVATE_CTP(dbenv_ctp, dbenvcl_id, CT_ENV);
	dbenv = (DB_ENV *)dbenv_ctp->ct_anyp;

	ret = dbenv->set_cachesize(dbenv, gbytes, bytes, ncache);

	replyp->status = ret;
	return;
}

/* BEGIN __env_close_proc */
/*
 * PUBLIC: void __env_close_proc __P((long, u_int32_t, __env_close_reply *));
 */
void
__env_close_proc(dbenvcl_id, flags, replyp)
	long dbenvcl_id;
	u_int32_t flags;
	__env_close_reply *replyp;
/* END __env_close_proc */
{
	ct_entry *dbenv_ctp;

	ACTIVATE_CTP(dbenv_ctp, dbenvcl_id, CT_ENV);
	replyp->status = __dbenv_close_int(dbenvcl_id, flags, 0);
	return;
}

/* BEGIN __env_create_proc */
/*
 * PUBLIC: void __env_create_proc __P((u_int32_t, __env_create_reply *));
 */
void
__env_create_proc(timeout, replyp)
	u_int32_t timeout;
	__env_create_reply *replyp;
/* END __env_create_proc */
{
	DB_ENV *dbenv;
	ct_entry *ctp;
	int ret;

	ctp = new_ct_ent(&replyp->status);
	if (ctp == NULL)
		return;
	if ((ret = db_env_create(&dbenv, 0)) == 0) {
		ctp->ct_envp = dbenv;
		ctp->ct_type = CT_ENV;
		ctp->ct_parent = NULL;
		ctp->ct_envparent = ctp;
		__dbsrv_settimeout(ctp, timeout);
		__dbsrv_active(ctp);
		replyp->envcl_id = ctp->ct_id;
	} else
		__dbclear_ctp(ctp);

	replyp->status = ret;
	return;
}

/* BEGIN __env_dbremove_proc */
/*
 * PUBLIC: void __env_dbremove_proc __P((long, long, char *, char *, u_int32_t,
 * PUBLIC:      __env_dbremove_reply *));
 */
void
__env_dbremove_proc(dbenvcl_id, txnpcl_id, name,
		subdb, flags, replyp)
	long dbenvcl_id;
	long txnpcl_id;
	char *name;
	char *subdb;
	u_int32_t flags;
	__env_dbremove_reply *replyp;
/* END __env_dbremove_proc */
{
	int ret;
	DB_ENV * dbenv;
	ct_entry *dbenv_ctp;
	DB_TXN * txnp;
	ct_entry *txnp_ctp;

	ACTIVATE_CTP(dbenv_ctp, dbenvcl_id, CT_ENV);
	dbenv = (DB_ENV *)dbenv_ctp->ct_anyp;

	if (txnpcl_id != 0) {
		ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);
		txnp = (DB_TXN *)txnp_ctp->ct_anyp;
	} else
		txnp = NULL;

	ret = dbenv->dbremove(dbenv, txnp, name, subdb, flags);

	replyp->status = ret;
	return;
}

/* BEGIN __env_dbrename_proc */
/*
 * PUBLIC: void __env_dbrename_proc __P((long, long, char *, char *, char *,
 * PUBLIC:      u_int32_t, __env_dbrename_reply *));
 */
void
__env_dbrename_proc(dbenvcl_id, txnpcl_id, name,
		subdb, newname, flags, replyp)
	long dbenvcl_id;
	long txnpcl_id;
	char *name;
	char *subdb;
	char *newname;
	u_int32_t flags;
	__env_dbrename_reply *replyp;
/* END __env_dbrename_proc */
{
	int ret;
	DB_ENV * dbenv;
	ct_entry *dbenv_ctp;
	DB_TXN * txnp;
	ct_entry *txnp_ctp;

	ACTIVATE_CTP(dbenv_ctp, dbenvcl_id, CT_ENV);
	dbenv = (DB_ENV *)dbenv_ctp->ct_anyp;

	if (txnpcl_id != 0) {
		ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);
		txnp = (DB_TXN *)txnp_ctp->ct_anyp;
	} else
		txnp = NULL;

	ret = dbenv->dbrename(dbenv, txnp, name, subdb, newname, flags);

	replyp->status = ret;
	return;
}

/* BEGIN __env_encrypt_proc */
/*
 * PUBLIC: void __env_encrypt_proc __P((long, char *, u_int32_t,
 * PUBLIC:      __env_encrypt_reply *));
 */
void
__env_encrypt_proc(dbenvcl_id, passwd, flags, replyp)
	long dbenvcl_id;
	char *passwd;
	u_int32_t flags;
	__env_encrypt_reply *replyp;
/* END __env_encrypt_proc */
{
	int ret;
	DB_ENV * dbenv;
	ct_entry *dbenv_ctp;

	ACTIVATE_CTP(dbenv_ctp, dbenvcl_id, CT_ENV);
	dbenv = (DB_ENV *)dbenv_ctp->ct_anyp;

	ret = dbenv->set_encrypt(dbenv, passwd, flags);

	replyp->status = ret;
	return;
}

/* BEGIN __env_flags_proc */
/*
 * PUBLIC: void __env_flags_proc __P((long, u_int32_t, u_int32_t,
 * PUBLIC:      __env_flags_reply *));
 */
void
__env_flags_proc(dbenvcl_id, flags, onoff, replyp)
	long dbenvcl_id;
	u_int32_t flags;
	u_int32_t onoff;
	__env_flags_reply *replyp;
/* END __env_flags_proc */
{
	DB_ENV *dbenv;
	ct_entry *dbenv_ctp;
	int ret;

	ACTIVATE_CTP(dbenv_ctp, dbenvcl_id, CT_ENV);
	dbenv = (DB_ENV *)dbenv_ctp->ct_anyp;

	ret = dbenv->set_flags(dbenv, flags, onoff);
	if (onoff)
		dbenv_ctp->ct_envdp.onflags = flags;
	else
		dbenv_ctp->ct_envdp.offflags = flags;

	replyp->status = ret;
	return;
}
/* BEGIN __env_open_proc */
/*
 * PUBLIC: void __env_open_proc __P((long, char *, u_int32_t, u_int32_t,
 * PUBLIC:      __env_open_reply *));
 */
void
__env_open_proc(dbenvcl_id, home, flags,
		mode, replyp)
	long dbenvcl_id;
	char *home;
	u_int32_t flags;
	u_int32_t mode;
	__env_open_reply *replyp;
/* END __env_open_proc */
{
	DB_ENV *dbenv;
	ct_entry *dbenv_ctp, *new_ctp;
	u_int32_t newflags, shareflags;
	int ret;
	home_entry *fullhome;

	ACTIVATE_CTP(dbenv_ctp, dbenvcl_id, CT_ENV);
	dbenv = (DB_ENV *)dbenv_ctp->ct_anyp;
	fullhome = get_home(home);
	if (fullhome == NULL) {
		ret = DB_NOSERVER_HOME;
		goto out;
	}

	/*
	 * If they are using locking do deadlock detection for them,
	 * internally.
	 */
	if ((flags & DB_INIT_LOCK) &&
	    (ret = dbenv->set_lk_detect(dbenv, DB_LOCK_DEFAULT)) != 0)
		goto out;

	if (__dbsrv_verbose) {
		dbenv->set_errfile(dbenv, stderr);
		dbenv->set_errpfx(dbenv, fullhome->home);
	}

	/*
	 * Mask off flags we ignore
	 */
	newflags = (flags & ~DB_SERVER_FLAGMASK);
	shareflags = (newflags & DB_SERVER_ENVFLAGS);
	/*
	 * Check now whether we can share a handle for this env.
	 */
	replyp->envcl_id = dbenvcl_id;
	if ((new_ctp = __dbsrv_shareenv(dbenv_ctp, fullhome, shareflags))
	    != NULL) {
		/*
		 * We can share, clean up old  ID, set new one.
		 */
		if (__dbsrv_verbose)
			printf("Sharing env ID %ld\n", new_ctp->ct_id);
		replyp->envcl_id = new_ctp->ct_id;
		ret = __dbenv_close_int(dbenvcl_id, 0, 0);
	} else {
		ret = dbenv->open(dbenv, fullhome->home, newflags, mode);
		dbenv_ctp->ct_envdp.home = fullhome;
		dbenv_ctp->ct_envdp.envflags = shareflags;
	}
out:	replyp->status = ret;
	return;
}

/* BEGIN __env_remove_proc */
/*
 * PUBLIC: void __env_remove_proc __P((long, char *, u_int32_t,
 * PUBLIC:      __env_remove_reply *));
 */
void
__env_remove_proc(dbenvcl_id, home, flags, replyp)
	long dbenvcl_id;
	char *home;
	u_int32_t flags;
	__env_remove_reply *replyp;
/* END __env_remove_proc */
{
	DB_ENV *dbenv;
	ct_entry *dbenv_ctp;
	int ret;
	home_entry *fullhome;

	ACTIVATE_CTP(dbenv_ctp, dbenvcl_id, CT_ENV);
	dbenv = (DB_ENV *)dbenv_ctp->ct_anyp;

	fullhome = get_home(home);
	if (fullhome == NULL) {
		replyp->status = DB_NOSERVER_HOME;
		return;
	}

	ret = dbenv->remove(dbenv, fullhome->home, flags);
	__dbdel_ctp(dbenv_ctp);
	replyp->status = ret;
	return;
}

/* BEGIN __txn_abort_proc */
/*
 * PUBLIC: void __txn_abort_proc __P((long, __txn_abort_reply *));
 */
void
__txn_abort_proc(txnpcl_id, replyp)
	long txnpcl_id;
	__txn_abort_reply *replyp;
/* END __txn_abort_proc */
{
	DB_TXN *txnp;
	ct_entry *txnp_ctp;
	int ret;

	ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);
	txnp = (DB_TXN *)txnp_ctp->ct_anyp;

	ret = txnp->abort(txnp);
	__dbdel_ctp(txnp_ctp);
	replyp->status = ret;
	return;
}

/* BEGIN __txn_begin_proc */
/*
 * PUBLIC: void __txn_begin_proc __P((long, long, u_int32_t,
 * PUBLIC:      __txn_begin_reply *));
 */
void
__txn_begin_proc(dbenvcl_id, parentcl_id,
		flags, replyp)
	long dbenvcl_id;
	long parentcl_id;
	u_int32_t flags;
	__txn_begin_reply *replyp;
/* END __txn_begin_proc */
{
	DB_ENV *dbenv;
	DB_TXN *parent, *txnp;
	ct_entry *ctp, *dbenv_ctp, *parent_ctp;
	int ret;

	ACTIVATE_CTP(dbenv_ctp, dbenvcl_id, CT_ENV);
	dbenv = (DB_ENV *)dbenv_ctp->ct_anyp;
	parent_ctp = NULL;

	ctp = new_ct_ent(&replyp->status);
	if (ctp == NULL)
		return;

	if (parentcl_id != 0) {
		ACTIVATE_CTP(parent_ctp, parentcl_id, CT_TXN);
		parent = (DB_TXN *)parent_ctp->ct_anyp;
		ctp->ct_activep = parent_ctp->ct_activep;
	} else
		parent = NULL;

	ret = dbenv->txn_begin(dbenv, parent, &txnp, flags);
	if (ret == 0) {
		ctp->ct_txnp = txnp;
		ctp->ct_type = CT_TXN;
		ctp->ct_parent = parent_ctp;
		ctp->ct_envparent = dbenv_ctp;
		replyp->txnidcl_id = ctp->ct_id;
		__dbsrv_settimeout(ctp, dbenv_ctp->ct_timeout);
		__dbsrv_active(ctp);
	} else
		__dbclear_ctp(ctp);

	replyp->status = ret;
	return;
}

/* BEGIN __txn_commit_proc */
/*
 * PUBLIC: void __txn_commit_proc __P((long, u_int32_t,
 * PUBLIC:      __txn_commit_reply *));
 */
void
__txn_commit_proc(txnpcl_id, flags, replyp)
	long txnpcl_id;
	u_int32_t flags;
	__txn_commit_reply *replyp;
/* END __txn_commit_proc */
{
	DB_TXN *txnp;
	ct_entry *txnp_ctp;
	int ret;

	ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);
	txnp = (DB_TXN *)txnp_ctp->ct_anyp;

	ret = txnp->commit(txnp, flags);
	__dbdel_ctp(txnp_ctp);

	replyp->status = ret;
	return;
}

/* BEGIN __txn_discard_proc */
/*
 * PUBLIC: void __txn_discard_proc __P((long, u_int32_t,
 * PUBLIC:      __txn_discard_reply *));
 */
void
__txn_discard_proc(txnpcl_id, flags, replyp)
	long txnpcl_id;
	u_int32_t flags;
	__txn_discard_reply *replyp;
/* END __txn_discard_proc */
{
	DB_TXN *txnp;
	ct_entry *txnp_ctp;
	int ret;

	ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);
	txnp = (DB_TXN *)txnp_ctp->ct_anyp;

	ret = txnp->discard(txnp, flags);
	__dbdel_ctp(txnp_ctp);

	replyp->status = ret;
	return;
}

/* BEGIN __txn_prepare_proc */
/*
 * PUBLIC: void __txn_prepare_proc __P((long, u_int8_t *,
 * PUBLIC:      __txn_prepare_reply *));
 */
void
__txn_prepare_proc(txnpcl_id, gid, replyp)
	long txnpcl_id;
	u_int8_t *gid;
	__txn_prepare_reply *replyp;
/* END __txn_prepare_proc */
{
	DB_TXN *txnp;
	ct_entry *txnp_ctp;
	int ret;

	ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);
	txnp = (DB_TXN *)txnp_ctp->ct_anyp;

	ret = txnp->prepare(txnp, gid);
	replyp->status = ret;
	return;
}

/* BEGIN __txn_recover_proc */
/*
 * PUBLIC: void __txn_recover_proc __P((long, u_int32_t, u_int32_t,
 * PUBLIC:      __txn_recover_reply *, int *));
 */
void
__txn_recover_proc(dbenvcl_id, count,
		flags, replyp, freep)
	long dbenvcl_id;
	u_int32_t count;
	u_int32_t flags;
	__txn_recover_reply *replyp;
	int * freep;
/* END __txn_recover_proc */
{
	DB_ENV *dbenv;
	DB_PREPLIST *dbprep, *p;
	ct_entry *dbenv_ctp, *ctp;
	long erri, i, retcount;
	u_int32_t *txnidp;
	int ret;
	u_int8_t *gid;

	ACTIVATE_CTP(dbenv_ctp, dbenvcl_id, CT_ENV);
	dbenv = (DB_ENV *)dbenv_ctp->ct_anyp;
	dbprep = NULL;
	*freep = 0;

	if ((ret =
	    __os_malloc(dbenv, count * sizeof(DB_PREPLIST), &dbprep)) != 0)
		goto out;
	if ((ret =
	    dbenv->txn_recover(dbenv, dbprep, count, &retcount, flags)) != 0)
		goto out;
	/*
	 * If there is nothing, success, but it's easy.
	 */
	replyp->retcount = retcount;
	if (retcount == 0) {
		replyp->txn.txn_val = NULL;
		replyp->txn.txn_len = 0;
		replyp->gid.gid_val = NULL;
		replyp->gid.gid_len = 0;
	}

	/*
	 * We have our txn list.  Now we need to allocate the space for
	 * the txn ID array and the GID array and set them up.
	 */
	if ((ret = __os_calloc(dbenv, retcount, sizeof(u_int32_t),
	    &replyp->txn.txn_val)) != 0)
		goto out;
	replyp->txn.txn_len = retcount * sizeof(u_int32_t);
	if ((ret = __os_calloc(dbenv, retcount, DB_XIDDATASIZE,
	    &replyp->gid.gid_val)) != 0) {
		__os_free(dbenv, replyp->txn.txn_val);
		goto out;
	}
	replyp->gid.gid_len = retcount * DB_XIDDATASIZE;

	/*
	 * Now walk through our results, creating parallel arrays
	 * to send back.  For each entry we need to create a new
	 * txn ctp and then fill in the array info.
	 */
	i = 0;
	p = dbprep;
	gid = replyp->gid.gid_val;
	txnidp = replyp->txn.txn_val;
	while (i++ < retcount) {
		ctp = new_ct_ent(&ret);
		if (ret != 0) {
			i--;
			goto out2;
		}
		ctp->ct_txnp = p->txn;
		ctp->ct_type = CT_TXN;
		ctp->ct_parent = NULL;
		ctp->ct_envparent = dbenv_ctp;
		__dbsrv_settimeout(ctp, dbenv_ctp->ct_timeout);
		__dbsrv_active(ctp);

		*txnidp = ctp->ct_id;
		memcpy(gid, p->gid, DB_XIDDATASIZE);

		p++;
		txnidp++;
		gid += DB_XIDDATASIZE;
	}
	/*
	 * If we get here, we have success and we have to set freep
	 * so it'll get properly freed next time.
	 */
	*freep = 1;
out:
	if (dbprep != NULL)
		__os_free(dbenv, dbprep);
	replyp->status = ret;
	return;
out2:
	/*
	 * We had an error in the middle of creating our new txn
	 * ct entries.  We have to unwind all that we have done.  Ugh.
	 */
	for (txnidp = replyp->txn.txn_val, erri = 0;
	    erri < i; erri++, txnidp++) {
		ctp = get_tableent(*txnidp);
		__dbclear_ctp(ctp);
	}
	__os_free(dbenv, replyp->txn.txn_val);
	__os_free(dbenv, replyp->gid.gid_val);
	__os_free(dbenv, dbprep);
	replyp->status = ret;
	return;
}

/* BEGIN __db_bt_maxkey_proc */
/*
 * PUBLIC: void __db_bt_maxkey_proc __P((long, u_int32_t,
 * PUBLIC:      __db_bt_maxkey_reply *));
 */
void
__db_bt_maxkey_proc(dbpcl_id, maxkey, replyp)
	long dbpcl_id;
	u_int32_t maxkey;
	__db_bt_maxkey_reply *replyp;
/* END __db_bt_maxkey_proc */
{
	DB *dbp;
	ct_entry *dbp_ctp;
	int ret;

	ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
	dbp = (DB *)dbp_ctp->ct_anyp;

	ret = dbp->set_bt_maxkey(dbp, maxkey);

	replyp->status = ret;
	return;
}