예제 #1
0
파일: kvs_bdb.c 프로젝트: Machyne/mongo
static int
kvs_cursor_reset(WT_CURSOR *wtcursor)
{
	CURSOR_SOURCE *cursor;
	DBC *dbc;
	WT_EXTENSION_API *wt_api;
	WT_SESSION *session;
	int ret = 0;

	session = wtcursor->session;
	cursor = (CURSOR_SOURCE *)wtcursor;
	wt_api = cursor->wt_api;

	/* Close and re-open the Berkeley DB cursor */
	if ((dbc = cursor->dbc) != NULL) {
		cursor->dbc = NULL;
		if ((ret = dbc->close(dbc)) != 0)
			ERET(wt_api, session, WT_ERROR,
			    "DbCursor.close: %s", db_strerror(ret));

		if ((ret = cursor->db->cursor(cursor->db, NULL, &dbc, 0)) != 0)
			ERET(wt_api, session, WT_ERROR,
			    "Db.cursor: %s", db_strerror(ret));
		cursor->dbc = dbc;
	}
	return (0);
}
예제 #2
0
/*
 * kvs_call --
 *	Call a KVS function.
 */
static INLINE int
kvs_call(WT_CURSOR *wt_cursor, const char *fname,
    int (*f)(kvs_t, struct kvs_record *, unsigned long, unsigned long))
{
	CURSOR *cursor;
	WT_SESSION *session;
	kvs_t kvs;
	int ret;
	char *p;

	cursor = (CURSOR *)wt_cursor;
	session = cursor->session;
	kvs = cursor->data_source->kvs;
	ret = 0;

	cursor->record.val = cursor->val;

restart:
	if ((ret = f(kvs, &cursor->record,
	    (unsigned long)0, (unsigned long)cursor->val_len)) != 0) {
		if (ret == KVS_E_KEY_NOT_FOUND)
			return (WT_NOTFOUND);
		ERET(session, WT_ERROR, "%s: %s", fname, kvs_strerror(ret));
	}

	/*
	 * If the returned length is larger than our passed-in length, we didn't
	 * get the complete value.  Grow the buffer and use kvs_get to complete
	 * the retrieval (kvs_get because the call succeeded and the key was
	 * copied out, so calling kvs_next/kvs_prev again would skip key/value
	 * pairs).
	 *
	 * We have to loop, another thread of control might change the length of
	 * the value, requiring we grow our buffer multiple times.
	 *
	 * We have to potentially restart the entire call in case the underlying
	 * key/value disappears.
	 */
	for (;;) {
		if (cursor->val_len >= cursor->record.val_len)
			return (0);

		/* Grow the value buffer. */
		if ((p = realloc(
		    cursor->val, cursor->record.val_len + 32)) == NULL)
			return (os_errno());
		cursor->val = cursor->record.val = p;
		cursor->val_len = cursor->record.val_len + 32;

		if ((ret = kvs_get(kvs, &cursor->record,
		    (unsigned long)0, (unsigned long)cursor->val_len)) != 0) {
			if (ret == KVS_E_KEY_NOT_FOUND)
				goto restart;
			ERET(session,
			    WT_ERROR, "kvs_get: %s", kvs_strerror(ret));
		}
	}
	/* NOTREACHED */
}
예제 #3
0
파일: kvs_bdb.c 프로젝트: Machyne/mongo
static int
kvs_cursor_search(WT_CURSOR *wtcursor)
{
	CURSOR_SOURCE *cursor;
	DBC *dbc;
	DBT *key, *value;
	WT_EXTENSION_API *wt_api;
	WT_SESSION *session;
	int ret = 0;

	session = wtcursor->session;
	cursor = (CURSOR_SOURCE *)wtcursor;
	wt_api = cursor->wt_api;

	dbc = cursor->dbc;
	key = &cursor->key;
	value = &cursor->value;

	if ((ret = copyin_key(wtcursor)) != 0)
		return (ret);

	if ((ret = dbc->get(dbc, key, value, DB_SET)) == 0) {
		copyout_key(wtcursor);
		copyout_value(wtcursor);
		return (0);
	}

	if (ret == DB_NOTFOUND || ret == DB_KEYEMPTY)
		return (WT_NOTFOUND);
	ERET(wt_api, session, WT_ERROR, "DbCursor.get: %s", db_strerror(ret));
}
예제 #4
0
파일: kvs_bdb.c 프로젝트: Machyne/mongo
static int
kvs_cursor_update(WT_CURSOR *wtcursor)
{
	CURSOR_SOURCE *cursor;
	DBC *dbc;
	DBT *key, *value;
	WT_EXTENSION_API *wt_api;
	WT_SESSION *session;
	int ret = 0;

	session = wtcursor->session;
	cursor = (CURSOR_SOURCE *)wtcursor;
	wt_api = cursor->wt_api;

	dbc = cursor->dbc;
	key = &cursor->key;
	value = &cursor->value;

	if ((ret = copyin_key(wtcursor)) != 0)
		return (ret);
	copyin_value(wtcursor);

	if ((ret = dbc->put(dbc, key, value, DB_KEYFIRST)) != 0)
		ERET(wt_api,
		    session, WT_ERROR, "DbCursor.put: %s", db_strerror(ret));

	return (0);
}
예제 #5
0
/*
 * kvs_cursor_remove --
 *	WT_CURSOR::remove method.
 */
static int
kvs_cursor_remove(WT_CURSOR *wt_cursor)
{
	CURSOR *cursor;
	WT_SESSION *session;
	int ret;

	cursor = (CURSOR *)wt_cursor;
	session = cursor->session;
	ret = 0;

	/*
	 * WiredTiger's "remove" of a bitfield is really an update with a value
	 * of a single byte of zero.
	 */
	if (cursor->config_bitfield) {
		wt_cursor->value.size = 1;
		wt_cursor->value.data = "\0";
		return (kvs_cursor_update(wt_cursor));
	}

	if ((ret = copyin_key(wt_cursor)) != 0)
		return (ret);
	if ((ret = kvs_del(cursor->data_source->kvs, &cursor->record)) == 0)
		return (0);
	if (ret == KVS_E_KEY_NOT_FOUND)
		return (WT_NOTFOUND);
	ERET(session, WT_ERROR, "kvs_del: %s", kvs_strerror(ret));
}
예제 #6
0
/*
 * kvs_config_read --
 *	Read KVS configuration.
 */
static int
kvs_config_read(WT_SESSION *session, WT_CONFIG_ARG *config,
    char ***devices, struct kvs_config *kvs_config, int *flagsp)
{
	const KVS_OPTIONS *p;
	WT_CONFIG_ITEM v;
	int ret;
	char *t, name[128];

	*flagsp = 0;				/* Clear return values */
	memset(kvs_config, 0, sizeof(*kvs_config));

	ret = 0;

	for (p = kvs_options; p->name != NULL; ++p) {
		/* Truncate the name, discarding the trailing value. */
		(void)snprintf(name, sizeof(name), "%s", p->name);
		if ((t = strchr(name, '=')) != NULL)
			*t = '\0';
		if ((ret =
		    wt_ext->config_get(wt_ext, session, config, name, &v)) != 0)
			ERET(session, ret,
			    "WT_EXTENSION_API.config: %s: %s",
			    name, wt_ext->strerror(ret));

		if (strcmp(name, "kvs_devices") == 0) {
			if ((ret =
			    kvs_config_devices(session, &v, devices)) != 0)
				return (ret);
			continue;
		}

#define	KVS_CONFIG_SET(n, f)						\
		if (strcmp(name, n) == 0) {				\
			kvs_config->f = (unsigned long)v.val;		\
			continue;					\
		}
		KVS_CONFIG_SET("kvs_parallelism", parallelism);
		KVS_CONFIG_SET("kvs_granularity", granularity);
		KVS_CONFIG_SET("kvs_avg_key_len", avg_key_len);
		KVS_CONFIG_SET("kvs_avg_val_len", avg_val_len);
		KVS_CONFIG_SET("kvs_write_bufs", write_bufs);
		KVS_CONFIG_SET("kvs_read_bufs", read_bufs);
		KVS_CONFIG_SET("kvs_commit_timeout", commit_timeout);
		KVS_CONFIG_SET("kvs_reclaim_threshold", reclaim_threshold);

#define	KVS_FLAG_SET(n, f)						\
		if (strcmp(name, n) == 0) {				\
			if (v.val != 0)					\
				*flagsp |= f;				\
			continue;					\
		}
		KVS_FLAG_SET("kvs_open_o_debug", KVS_O_DEBUG);
		KVS_FLAG_SET("kvs_open_o_reclaim", KVS_O_SCAN);
		KVS_FLAG_SET("kvs_open_o_scan",  KVS_O_RECLAIM);
	}
	return (0);
}
예제 #7
0
/*
 * writelock --
 *	Acquire a write lock.
 */
static INLINE int
writelock(WT_SESSION *session, pthread_rwlock_t *lockp)
{
	int ret;

	if ((ret = pthread_rwlock_wrlock(lockp)) != 0)
		ERET(session, WT_PANIC, "lock: %s", strerror(ret));
	return (ret);
}
예제 #8
0
/*
 * lock_destroy --
 *	Destroy an object's lock.
 */
static int
lock_destroy(WT_SESSION *session, pthread_rwlock_t *lockp)
{
	int ret;

	if ((ret = pthread_rwlock_destroy(lockp)) != 0)
		ERET(session, WT_PANIC, "lock destroy: %s", strerror(ret));
	return (0);
}
예제 #9
0
파일: kvs_bdb.c 프로젝트: Machyne/mongo
/*
 * unlock --
 *	Release an object's lock.
 */
static INLINE int
unlock(WT_EXTENSION_API *wt_api, WT_SESSION *session, pthread_rwlock_t *lockp)
{
	int ret = 0;

	if ((ret = pthread_rwlock_unlock(lockp)) != 0)
		ERET(wt_api, session, WT_PANIC, "unlock: %s", strerror(ret));
	return (0);
}
예제 #10
0
/*
 * lock_init --
 *	Initialize an object's lock.
 */
static int
lock_init(WT_SESSION *session, pthread_rwlock_t *lockp)
{
	int ret;

	if ((ret = pthread_rwlock_init(lockp, NULL)) != 0)
		ERET(session, WT_PANIC, "lock init: %s", strerror(ret));
	return (ret);
}
예제 #11
0
/*
 * kvs_session_verify --
 *	WT_SESSION::verify method.
 */
static int
kvs_session_verify(WT_DATA_SOURCE *dsrc,
    WT_SESSION *session, const char *uri, WT_CONFIG_ARG *config)
{
	(void)dsrc;				/* Unused parameters */
	(void)uri;
	(void)config;

	ERET(session, ENOTSUP, "verify: %s", strerror(ENOTSUP));
}
예제 #12
0
파일: kvs_bdb.c 프로젝트: Machyne/mongo
static int
kvs_cursor_remove(WT_CURSOR *wtcursor)
{
	CURSOR_SOURCE *cursor;
	DBC *dbc;
	DBT *key, *value;
	WT_EXTENSION_API *wt_api;
	WT_SESSION *session;
	int ret = 0;

	session = wtcursor->session;
	cursor = (CURSOR_SOURCE *)wtcursor;
	wt_api = cursor->wt_api;

	dbc = cursor->dbc;
	key = &cursor->key;
	value = &cursor->value;

	/*
	 * WiredTiger's "remove" of a bitfield is really an update with a value
	 * of a single byte of zero.
	 */
	if (cursor->config_bitfield) {
		wtcursor->value.size = 1;
		wtcursor->value.data = "\0";
		return (kvs_cursor_update(wtcursor));
	}

	if ((ret = copyin_key(wtcursor)) != 0)
		return (ret);

	if ((ret = dbc->get(dbc, key, value, DB_SET)) != 0) {
		if (ret == DB_NOTFOUND || ret == DB_KEYEMPTY)
			return (WT_NOTFOUND);
		ERET(wt_api,
		    session, WT_ERROR, "DbCursor.get: %s", db_strerror(ret));
	}
	if ((ret = dbc->del(dbc, 0)) != 0)
		ERET(wt_api,
		    session, WT_ERROR, "DbCursor.del: %s", db_strerror(ret));

	return (0);
}
예제 #13
0
파일: kvs_bdb.c 프로젝트: Machyne/mongo
/*
 * lock_init --
 *	Initialize an object's lock.
 */
static int
lock_init(
    WT_EXTENSION_API *wt_api, WT_SESSION *session, pthread_rwlock_t *lockp)
{
	int ret = 0;

	if ((ret = pthread_rwlock_init(lockp, NULL)) != 0)
		ERET(wt_api, session, WT_PANIC, "lock init: %s", strerror(ret));
	return (0);
}
예제 #14
0
/*
 * wiredtiger_extension_init --
 *	Initialize the KVS connector code.
 */
int
wiredtiger_extension_init(WT_CONNECTION *connection, WT_CONFIG_ARG *config)
{
	static WT_DATA_SOURCE data_source;	/* Enclosing data source */
	int ret;

	(void)config;				/* Unused parameters */

	ret = 0;
						/* Acquire the extension API */
	wt_ext = connection->get_extension_api(connection);

						/* Check the library version */
#if KVS_VERSION_MAJOR != 2 || KVS_VERSION_MINOR != 8
	ERET(NULL, EINVAL,
	    "unsupported KVS library version %d.%d",
	    KVS_VERSION_MAJOR, KVS_VERSION_MINOR);
#endif

	/* Initialize the WT_DATA_SOURCE structure. */
	memset(&data_source, 0, sizeof(data_source));
	data_source.create = kvs_session_create;
	data_source.compact = NULL;		/* No compaction */
	data_source.drop = kvs_session_drop;
	data_source.open_cursor = kvs_session_open_cursor;
	data_source.rename = kvs_session_rename;
	data_source.salvage = NULL;		/* No salvage */
	data_source.truncate = kvs_session_truncate;
	data_source.verify = kvs_session_verify;
	if ((ret = connection->add_data_source(
	    connection, "memrata:", &data_source, NULL)) != 0)
		ERET(NULL, ret,
		    "WT_CONNECTION.add_data_source: %s", wt_ext->strerror(ret));

	/* Add the KVS-specific configuration options. */
	if ((ret = kvs_config_add(connection)) != 0)
		return (ret);

	if ((ret = lock_init(NULL, &global_lock)) != 0)
		return (ret);

	return (0);
}
예제 #15
0
/*
 * kvs_cursor_insert --
 *	WT_CURSOR::insert method.
 */
static int
kvs_cursor_insert(WT_CURSOR *wt_cursor)
{
	CURSOR *cursor;
	WT_SESSION *session;
	int ret;

	cursor = (CURSOR *)wt_cursor;
	session = cursor->session;
	ret = 0;

	/* Allocate a new record for append operations. */
	if (cursor->config_append && (ret = kvs_recno_alloc(wt_cursor)) != 0)
		return (ret);

	if ((ret = copyin_key(wt_cursor)) != 0)
		return (ret);
	if ((ret = copyin_val(wt_cursor)) != 0)
		return (ret);

	/*
	 * WT_CURSOR::insert with overwrite set (create the record if it does
	 * not exist, update the record if it does exist), maps to kvs_set.
	 *
	 * WT_CURSOR::insert without overwrite set (create the record if it
	 * does not exist, fail if it does exist), maps to kvs_add.
	 */
	if (cursor->config_overwrite) {
		if ((ret = kvs_set(
		    cursor->data_source->kvs, &cursor->record)) != 0)
			ERET(session, WT_ERROR,
			    "kvs_set: %s", kvs_strerror(ret));
	} else
		if ((ret = kvs_add(
		    cursor->data_source->kvs, &cursor->record)) != 0) {
			if (ret == KVS_E_KEY_EXISTS)
				return (WT_DUPLICATE_KEY);
			ERET(session, WT_ERROR,
			    "kvs_add: %s", kvs_strerror(ret));
		}
	return (0);
}
예제 #16
0
파일: kvs_bdb.c 프로젝트: Machyne/mongo
static int
uri2name(WT_EXTENSION_API *wt_api,
    WT_SESSION *session, const char *uri, const char **namep)
{
	const char *name;

	if ((name = strchr(uri, ':')) == NULL || *++name == '\0')
		ERET(wt_api, session, EINVAL, "unsupported object: %s", uri);
	*namep = name;
	return (0);
}
예제 #17
0
파일: kvs_bdb.c 프로젝트: Machyne/mongo
static int
kvs_cursor_close(WT_CURSOR *wtcursor)
{
	CURSOR_SOURCE *cursor;
	DATA_SOURCE *ds;
	DB *db;
	DBC *dbc;
	WT_EXTENSION_API *wt_api;
	WT_SESSION *session;
	int ret = 0;

	session = wtcursor->session;
	cursor = (CURSOR_SOURCE *)wtcursor;
	ds = cursor->ds;
	wt_api = cursor->wt_api;

	dbc = cursor->dbc;
	cursor->dbc = NULL;
	if (dbc != NULL && (ret = dbc->close(dbc)) != 0)
		ERET(wt_api, session, WT_ERROR,
		    "DbCursor.close: %s", db_strerror(ret));

	db = cursor->db;
	cursor->db = NULL;
	if (db != NULL && (ret = db->close(db, 0)) != 0)
		ERET(wt_api,
		    session, WT_ERROR, "Db.close: %s", db_strerror(ret));
	free(wtcursor);

	if ((ret = writelock(wt_api, session, &ds->rwlock)) != 0)
		return (ret);
	--ds->open_cursors;
	if ((ret = unlock(wt_api, session, &ds->rwlock)) != 0)
		return (ret);

	return (0);
}
예제 #18
0
파일: kvs_bdb.c 프로젝트: Machyne/mongo
static int
kvs_session_create(WT_DATA_SOURCE *wtds,
    WT_SESSION *session, const char *uri, WT_CONFIG_ARG *config)
{
	DATA_SOURCE *ds;
	DB *db;
	DBTYPE type;
	WT_CONFIG_ITEM v;
	WT_EXTENSION_API *wt_api;
	int ret = 0;
	const char *name;

	ds = (DATA_SOURCE *)wtds;
	wt_api = ds->wt_api;
						/* Get the object name */
	if ((ret = uri2name(wt_api, session, uri, &name)) != 0)
		return (ret);
						/* Check key/value formats */
	if ((ret =
	    wt_api->config_get(wt_api, session, config, "key_format", &v)) != 0)
		ERET(wt_api, session, ret,
		    "key_format configuration: %s",
		    wt_api->strerror(wt_api, session, ret));
	type = v.len == 1 && v.str[0] == 'r' ? DB_RECNO : DB_BTREE;

	/* Create the Berkeley DB table */
	if ((ret = db_create(&db, ds->dbenv, 0)) != 0)
		ERET(wt_api,
		    session, WT_ERROR, "db_create: %s", db_strerror(ret));
	if ((ret = db->open(db, NULL, name, NULL, type, DB_CREATE, 0)) != 0)
		ERET(wt_api,
		    session, WT_ERROR, "Db.open: %s", uri, db_strerror(ret));
	if ((ret = db->close(db, 0)) != 0)
		ERET(wt_api, session, WT_ERROR, "Db.close", db_strerror(ret));

	return (0);
}
예제 #19
0
파일: kvs_bdb.c 프로젝트: Machyne/mongo
static int
bdb_dump(WT_CURSOR *wtcursor, WT_SESSION *session, const char *tag)
{
	CURSOR_SOURCE *cursor;
	DB *db;
	DBC *dbc;
	DBT *key, *value;
	WT_EXTENSION_API *wt_api;
	int ret = 0;

	cursor = (CURSOR_SOURCE *)wtcursor;
	wt_api = cursor->wt_api;

	db = cursor->db;
	key = &cursor->key;
	value = &cursor->value;

	if ((ret = db->cursor(db, NULL, &dbc, 0)) != 0)
		ERET(wt_api,
		    session, WT_ERROR, "Db.cursor: %s", db_strerror(ret));
	printf("==> %s\n", tag);
	while ((ret = dbc->get(dbc, key, value, DB_NEXT)) == 0)
		if (cursor->config_recno)
			printf("\t%llu/%.*s\n",
			    (unsigned long long)*(db_recno_t *)key->data,
			    (int)value->size, (char *)value->data);
		else
			printf("\t%.*s/%.*s\n",
			    (int)key->size, (char *)key->data,
			    (int)value->size, (char *)value->data);

	if (ret != DB_NOTFOUND)
		ERET(wt_api,
		    session, WT_ERROR, "DbCursor.get: %s", db_strerror(ret));

	return (0);
}
예제 #20
0
파일: kvs_bdb.c 프로젝트: Machyne/mongo
static INLINE int
recno_convert(WT_CURSOR *wtcursor, db_recno_t *recnop)
{
	CURSOR_SOURCE *cursor;
	WT_EXTENSION_API *wt_api;
	WT_SESSION *session;

	session = wtcursor->session;
	cursor = (CURSOR_SOURCE *)wtcursor;
	wt_api = cursor->wt_api;

	if (wtcursor->recno > UINT32_MAX)
		ERET(wt_api,
		    session, ERANGE, "record number %" PRIuMAX ": %s",
		    (uintmax_t)wtcursor->recno, strerror(ERANGE));

	*recnop = (uint32_t)wtcursor->recno;
	return (0);
}
예제 #21
0
/*
 * copy_key --
 *	Copy the key for methods where the underlying KVS call returns a key.
 */
static INLINE int
copy_key(WT_CURSOR *wt_cursor)
{
	struct kvs_record *r;
	CURSOR *cursor;
	WT_SESSION *session;

	cursor = (CURSOR *)wt_cursor;
	session = cursor->session;
	r = &cursor->record;

	if (cursor->key == r->key)
		return (0);
	if (r->key_len > sizeof(cursor->key))
		ERET(session, ERANGE,
		    "key too large, maximum is %" PRIuMAX,
		    (uintmax_t)sizeof(cursor->key));
	memcpy(cursor->key, r->key, r->key_len);
	r->key = cursor->key;
	return (0);
}
예제 #22
0
/*
 * kvs_config_add --
 *	Add the KVS configuration options to the WiredTiger configuration
 * process.
 */
static int
kvs_config_add(WT_CONNECTION *conn)
{
	const KVS_OPTIONS *p;
	int ret;

	ret = 0;

	/*
	 * KVS options are currently only allowed on session.create, which means
	 * they cannot be modified for each run, the object create configuration
	 * is permanent.
	 */
	for (p = kvs_options; p->name != NULL; ++p)
		if ((ret = conn->configure_method(conn,
		    "session.create", "memrata:",
		    p->name, p->type, p->checks)) != 0)
			ERET(NULL, ret,
			    "WT_CONNECTION.configure_method: session.create: "
			    "{%s, %s, %s}",
			    p->name, p->type, p->checks, wt_ext->strerror(ret));
	return (0);
}
예제 #23
0
/*
 * kvs_cursor_update --
 *	WT_CURSOR::update method.
 */
static int
kvs_cursor_update(WT_CURSOR *wt_cursor)
{
	CURSOR *cursor;
	WT_SESSION *session;
	int ret;

	cursor = (CURSOR *)wt_cursor;
	session = cursor->session;

	if ((ret = copyin_key(wt_cursor)) != 0)
		return (ret);
	if ((ret = copyin_val(wt_cursor)) != 0)
		return (ret);

	/*
	 * WT_CURSOR::update (update the record if it does exist, fail if it
	 * does not exist), maps to kvs_replace.
	 */
	if ((ret = kvs_replace(cursor->data_source->kvs, &cursor->record)) != 0)
		ERET(session, WT_ERROR, "kvs_replace: %s", kvs_strerror(ret));

	return (0);
}
예제 #24
0
파일: l_server.cpp 프로젝트: 00c/minetest
// get_player_information()
int ModApiServer::l_get_player_information(lua_State *L)
{

	NO_MAP_LOCK_REQUIRED;
	const char * name = luaL_checkstring(L, 1);
	Player *player = getEnv(L)->getPlayer(name);
	if(player == NULL)
	{
		lua_pushnil(L); // no such player
		return 1;
	}

	Address addr;
	try
	{
		addr = getServer(L)->getPeerAddress(player->peer_id);
	}
	catch(con::PeerNotFoundException) // unlikely
	{
		dstream << FUNCTION_NAME << ": peer was not found" << std::endl;
		lua_pushnil(L); // error
		return 1;
	}

	float min_rtt,max_rtt,avg_rtt,min_jitter,max_jitter,avg_jitter;
	ClientState state;
	u32 uptime;
	u16 prot_vers;
	u8 ser_vers,major,minor,patch;
	std::string vers_string;

#define ERET(code)                                                             \
	if (!(code)) {                                                             \
		dstream << FUNCTION_NAME << ": peer was not found" << std::endl;     \
		lua_pushnil(L); /* error */                                            \
		return 1;                                                              \
	}

	ERET(getServer(L)->getClientConInfo(player->peer_id,con::MIN_RTT,&min_rtt))
	ERET(getServer(L)->getClientConInfo(player->peer_id,con::MAX_RTT,&max_rtt))
	ERET(getServer(L)->getClientConInfo(player->peer_id,con::AVG_RTT,&avg_rtt))
	ERET(getServer(L)->getClientConInfo(player->peer_id,con::MIN_JITTER,&min_jitter))
	ERET(getServer(L)->getClientConInfo(player->peer_id,con::MAX_JITTER,&max_jitter))
	ERET(getServer(L)->getClientConInfo(player->peer_id,con::AVG_JITTER,&avg_jitter))

	ERET(getServer(L)->getClientInfo(player->peer_id,
										&state, &uptime, &ser_vers, &prot_vers,
										&major, &minor, &patch, &vers_string))

	lua_newtable(L);
	int table = lua_gettop(L);

	lua_pushstring(L,"address");
	lua_pushstring(L, addr.serializeString().c_str());
	lua_settable(L, table);

	lua_pushstring(L,"ip_version");
	if (addr.getFamily() == AF_INET) {
		lua_pushnumber(L, 4);
	} else if (addr.getFamily() == AF_INET6) {
		lua_pushnumber(L, 6);
	} else {
		lua_pushnumber(L, 0);
	}
	lua_settable(L, table);

	lua_pushstring(L,"min_rtt");
	lua_pushnumber(L, min_rtt);
	lua_settable(L, table);

	lua_pushstring(L,"max_rtt");
	lua_pushnumber(L, max_rtt);
	lua_settable(L, table);

	lua_pushstring(L,"avg_rtt");
	lua_pushnumber(L, avg_rtt);
	lua_settable(L, table);

	lua_pushstring(L,"min_jitter");
	lua_pushnumber(L, min_jitter);
	lua_settable(L, table);

	lua_pushstring(L,"max_jitter");
	lua_pushnumber(L, max_jitter);
	lua_settable(L, table);

	lua_pushstring(L,"avg_jitter");
	lua_pushnumber(L, avg_jitter);
	lua_settable(L, table);

	lua_pushstring(L,"connection_uptime");
	lua_pushnumber(L, uptime);
	lua_settable(L, table);

#ifndef NDEBUG
	lua_pushstring(L,"serialization_version");
	lua_pushnumber(L, ser_vers);
	lua_settable(L, table);

	lua_pushstring(L,"protocol_version");
	lua_pushnumber(L, prot_vers);
	lua_settable(L, table);

	lua_pushstring(L,"major");
	lua_pushnumber(L, major);
	lua_settable(L, table);

	lua_pushstring(L,"minor");
	lua_pushnumber(L, minor);
	lua_settable(L, table);

	lua_pushstring(L,"patch");
	lua_pushnumber(L, patch);
	lua_settable(L, table);

	lua_pushstring(L,"version_string");
	lua_pushstring(L, vers_string.c_str());
	lua_settable(L, table);

	lua_pushstring(L,"state");
	lua_pushstring(L,ClientInterface::state2Name(state).c_str());
	lua_settable(L, table);
#endif

#undef ERET
	return 1;
}
예제 #25
0
_er90b_open(char *fname, int oflag, int mode, struct fdinfo *fio, 
	union spec_u *spec, struct ffsw *retstat, int cbits, int cblks,
	struct gl_o_inf *oinf)
{
int 		fd;		/* file descriptor */
ER90BYT 	*er90b_info;
 
	struct tpdctl ctl;
	struct stat x;
	int save_err;

/*
 *	allocate *ER90BYT
 */
	if((er90b_info = (ER90BYT *)calloc(sizeof(*er90b_info),1))==NULL){
		ERETURN(retstat, FENOMEMY, 0);
	}

        if ((_numargs() > 8 ) && oinf->alreadyopen)  {
                fd = oinf->fd;   
        }
	else {

/*
 *		Open the file.
 */
		oflag = (oflag | O_RAW) & (~O_CREAT);

		fd = open(fname, oflag, 0666);

		if (fd < 0){
			free(er90b_info);
			ERETURN(retstat, errno, 0);
		}
	}

#ifndef _CRAYMPP
	/* This ioctl does not work on the MPP */
  	if ( ioctl( fd, TPC_GETFL, &ctl) < 0 ){
		/* If ioctl fails with ENOTTY, then this */
		/* isn't a tape file. Make the errno more meaningful */
		if (errno == ENOTTY)
			errno = FECONNTP;
		ERET();
	}
/*
 *	If this is not a byte-stream ER90, error 
 */
	if ((ctl.tpc_type != DT_ER90) || (ctl.tpc_dbsize != 1)) {
		errno = FDC_ERR_NOER90;
		ERET();
	}
#endif
    
 
	er90b_info->tpos = TPOS_DONE;
	er90b_info->fd = fd;
 
/*
 *	Save device number and inode for tapeinfo requests
 */
	if (fstat(fd, &x) < 0){
		ERET();
	}
#ifdef _CRAYMPP
	if (_gsys_qtape(&x) == 0) {
		errno = FECONNTP;
		ERET();
	}
	if (getenv("NOER90WARN")== NULL) {
		write(2,"Reads and writes to tape devices using the er90 layer\n",54);
		write(2,"may function differently than reads and writes using\n",53);
		write(2,"the tape layer.\n",16);
		write(2,"The use of the er90 layer with tape devices may not be\n",55);
		write(2,"supported in future releases.\n",30);
		write(2,"To disable this message, set the environment variable\n",54);
		write(2,"NOER90WARN to a non-zero value\n",31);
	}
#endif
	er90b_info->tsireq.st_dev = x.st_dev;
	er90b_info->tsireq.st_ino = x.st_ino;
	er90b_info->tsireq.fd = fd;
#ifndef _CRAYMPP
	/* Can't use an ioctl on MPP yet. */
	if (sysconf(_SC_CRAY_RELEASE) >= 8300) {
		/* With operating system versions >= 8300, we can */
 		/* use an ioctl to get tape info. Er90s only run on Model E IOS, */
		/* so this is safe. */
 		er90b_info->tsireq.ioctlreq = 1;
 	}
#endif


	fio->lyr_info = (char *)er90b_info;
	fio->realfd = fd;
	fio->rwflag = POSITIN;
	SETSTAT(retstat, 0, 0);
	return(0);

badret:
	save_err = errno;
	free(er90b_info);
	(void) close(fd);
	errno = save_err;
	ERETURN(retstat, errno, 0);
}	
예제 #26
0
파일: kvs_bdb.c 프로젝트: Machyne/mongo
static int
kvs_cursor_search_near(WT_CURSOR *wtcursor, int *exact)
{
	CURSOR_SOURCE *cursor;
	DBC *dbc;
	DBT *key, *value;
	WT_EXTENSION_API *wt_api;
	WT_SESSION *session;
	size_t len;
	int ret = 0;

	session = wtcursor->session;
	cursor = (CURSOR_SOURCE *)wtcursor;
	wt_api = cursor->wt_api;

	dbc = cursor->dbc;
	key = &cursor->key;
	value = &cursor->value;

	if ((ret = copyin_key(wtcursor)) != 0)
		return (ret);

retry:	if ((ret = dbc->get(dbc, key, value, DB_SET_RANGE)) == 0) {
		/*
		 * WiredTiger returns the logically adjacent key (which might
		 * be less than, equal to, or greater than the specified key),
		 * Berkeley DB returns a key equal to or greater than the
		 * specified key.  Check for an exact match, otherwise Berkeley
		 * DB must have returned a larger key than the one specified.
		 */
		if (key->size == wtcursor->key.size &&
		    memcmp(key->data, wtcursor->key.data, key->size) == 0)
			*exact = 0;
		else
			*exact = 1;
		copyout_key(wtcursor);
		copyout_value(wtcursor);
		return (0);
	}

	/*
	 * Berkeley DB only returns keys equal to or greater than the specified
	 * key, while WiredTiger returns adjacent keys, that is, if there's a
	 * key smaller than the specified key, it's supposed to be returned.  In
	 * other words, WiredTiger only fails if the store is empty.  Read the
	 * last key in the store, and see if it's less than the specified key,
	 * in which case we have the right key to return.  If it's not less than
	 * the specified key, we're racing with some other thread, throw up our
	 * hands and try again.
	 */
	if ((ret = dbc->get(dbc, key, value, DB_LAST)) == 0) {
		len = key->size < wtcursor->key.size ?
		    key->size : wtcursor->key.size;
		if (memcmp(key->data, wtcursor->key.data, len) < 0) {
			*exact = -1;
			copyout_key(wtcursor);
			copyout_value(wtcursor);
			return (0);
		}
		goto retry;
	}

	if (ret == DB_NOTFOUND || ret == DB_KEYEMPTY)
		return (WT_NOTFOUND);
	ERET(wt_api, session, WT_ERROR, "DbCursor.get: %s", db_strerror(ret));
}
예제 #27
0
파일: kvs_bdb.c 프로젝트: Machyne/mongo
static int
kvs_cursor_insert(WT_CURSOR *wtcursor)
{
	CURSOR_SOURCE *cursor;
	DB *db;
	DBC *dbc;
	DBT *key, *value;
	WT_EXTENSION_API *wt_api;
	WT_SESSION *session;
	int ret = 0;

	session = wtcursor->session;
	cursor = (CURSOR_SOURCE *)wtcursor;
	wt_api = cursor->wt_api;

	dbc = cursor->dbc;
	db = cursor->db;
	key = &cursor->key;
	value = &cursor->value;

	if ((ret = copyin_key(wtcursor)) != 0)
		return (ret);
	copyin_value(wtcursor);

	if (cursor->config_append) {
		/*
		 * Berkeley DB cursors have no operation to append/create a
		 * new record and set the cursor; use the DB handle instead
		 * then set the cursor explicitly.
		 *
		 * When appending, we're allocating and returning a new record
		 * number.
		 */
		if ((ret = db->put(db, NULL, key, value, DB_APPEND)) != 0)
			ERET(wt_api,
			    session, WT_ERROR, "Db.put: %s", db_strerror(ret));
		wtcursor->recno = *(db_recno_t *)key->data;

		if ((ret = dbc->get(dbc, key, value, DB_SET)) != 0)
			ERET(wt_api, session, WT_ERROR,
			    "DbCursor.get: %s", db_strerror(ret));
	} else if (cursor->config_overwrite) {
		if ((ret = dbc->put(dbc, key, value, DB_KEYFIRST)) != 0)
			ERET(wt_api, session, WT_ERROR,
			    "DbCursor.put: %s", db_strerror(ret));
	} else {
		/*
		 * Berkeley DB cursors don't have a no-overwrite flag; use
		 * the DB handle instead then set the cursor explicitly.
		 */
		if ((ret =
		    db->put(db, NULL, key, value, DB_NOOVERWRITE)) != 0) {
			if (ret == DB_KEYEXIST)
				return (WT_DUPLICATE_KEY);
			ERET(wt_api,
			    session, WT_ERROR, "Db.put: %s", db_strerror(ret));
		}
		if ((ret = dbc->get(dbc, key, value, DB_SET)) != 0)
			ERET(wt_api, session, WT_ERROR,
			    "DbCursor.get: %s", db_strerror(ret));
	}

	return (0);
}