shaba/lvm2
1
0
Fork 0
mirror of git://sourceware.org/git/lvm2.git synced 2025-03-10 16:58:47 +03:00
Code Releases Activity

Use hash functions in libdevmapper.

Browse Source
This commit is contained in:
Patrick Caulfield 2005-11-09 09:24:10 +00:00
parent 5f4b2acfe5
commit c650c19805
4 changed files with 74 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
daemons/clvmd/clvmd-command.c
View File

@ -65,6 +65,7 @@
#include <unistd.h>
#include <errno.h>
#include "libdevmapper.h"
#include "list.h"
#include "locking.h"
#include "log.h"
@ -137,7 +138,7 @@ int do_command(struct local_client *client, struct clvm_header *msg, int msglen,
static int lock_vg(struct local_client *client)
{
struct hash_table *lock_hash;
struct dm_hash_table *lock_hash;
struct clvm_header *header =
(struct clvm_header *) client->bits.localsock.cmd;
unsigned char lock_cmd;
@ -151,10 +152,10 @@ static int lock_vg(struct local_client *client)
practice there should only ever be more than two VGs locked
if a user tries to merge lots of them at once */
if (client->bits.localsock.private) {
lock_hash = (struct hash_table *)client->bits.localsock.private;
lock_hash = (struct dm_hash_table *)client->bits.localsock.private;
}
else {
lock_hash = hash_create(3);
lock_hash = dm_hash_create(3);
if (!lock_hash)
return ENOMEM;
client->bits.localsock.private = (void *)lock_hash;
@ -167,7 +168,7 @@ static int lock_vg(struct local_client *client)
if (lock_cmd == LCK_UNLOCK) {
lkid = (int)(long)hash_lookup(lock_hash, lockname);
lkid = (int)(long)dm_hash_lookup(lock_hash, lockname);
if (lkid == 0)
return EINVAL;
@ -175,7 +176,7 @@ static int lock_vg(struct local_client *client)
if (status)
status = errno;
else
hash_remove(lock_hash, lockname);
dm_hash_remove(lock_hash, lockname);
}
else {
@ -183,7 +184,7 @@ static int lock_vg(struct local_client *client)
if (status)
status = errno;
else
hash_insert(lock_hash, lockname, (void *)lkid);
dm_hash_insert(lock_hash, lockname, (void *)lkid);
}
return status;
@ -267,19 +268,19 @@ void cmd_client_cleanup(struct local_client *client)
{
if (client->bits.localsock.private) {
struct hash_node *v;
struct hash_table *lock_hash =
(struct hash_table *)client->bits.localsock.private;
struct dm_hash_node *v;
struct dm_hash_table *lock_hash =
(struct dm_hash_table *)client->bits.localsock.private;
hash_iterate(v, lock_hash) {
int lkid = (int)(long)hash_get_data(lock_hash, v);
char *lockname = hash_get_key(lock_hash, v);
dm_hash_iterate(v, lock_hash) {
int lkid = (int)(long)dm_hash_get_data(lock_hash, v);
char *lockname = dm_hash_get_key(lock_hash, v);
DEBUGLOG("cleanup: Unlocking lock %s %x\n", lockname, lkid);
sync_unlock(lockname, lkid);
}
hash_destroy(lock_hash);
dm_hash_destroy(lock_hash);
client->bits.localsock.private = 0;
}
}

69
daemons/clvmd/clvmd-gulm.c
View File

@ -41,6 +41,7 @@
#include <syslog.h>
#include <assert.h>
#include "libdevmapper.h"
#include "ccs.h"
#include "list.h"
#include "locking.h"
@ -53,10 +54,10 @@
#include "libgulm.h"
/* Hash list of nodes in the cluster */
static struct hash_table *node_hash;
static struct dm_hash_table *node_hash;
/* hash list of outstanding lock requests */
static struct hash_table *lock_hash;
static struct dm_hash_table *lock_hash;
/* Copy of the current quorate state */
static uint8_t gulm_quorate = 0;
@ -94,7 +95,7 @@ static int _csid_from_name(char *csid, char *name);
static void _cluster_closedown(void);
/* In tcp-comms.c */
extern struct hash_table *sock_hash;
extern struct dm_hash_table *sock_hash;
static int add_internal_client(int fd, fd_callback_t callback)
{
@ -176,8 +177,8 @@ static int _init_cluster(void)
pthread_mutex_lock(&lock_start_mutex);
lock_start_flag = 1;
node_hash = hash_create(100);
lock_hash = hash_create(10);
node_hash = dm_hash_create(100);
lock_hash = dm_hash_create(10);
/* Get all nodes from CCS */
if (get_all_cluster_nodes())
@ -315,8 +316,6 @@ static int core_login_reply(void *misc, uint64_t gen, uint32_t error, uint32_t r
static void set_node_state(struct node_info *ninfo, char *csid, uint8_t nodestate)
{
int oldstate = ninfo->state;
if (nodestate == lg_core_Logged_in)
{
/* Don't clobber NODE_CLVMD state */
@ -355,7 +354,7 @@ static struct node_info *add_or_set_node(char *name, struct in6_addr *ip, uint8_
{
struct node_info *ninfo;
ninfo = hash_lookup_binary(node_hash, (char *)ip, GULM_MAX_CSID_LEN);
ninfo = dm_hash_lookup_binary(node_hash, (char *)ip, GULM_MAX_CSID_LEN);
if (!ninfo)
{
/* If we can't find that node then re-read the config file in case it
@ -364,7 +363,7 @@ static struct node_info *add_or_set_node(char *name, struct in6_addr *ip, uint8_
get_all_cluster_nodes();
/* Now try again */
ninfo = hash_lookup_binary(node_hash, (char *)ip, GULM_MAX_CSID_LEN);
ninfo = dm_hash_lookup_binary(node_hash, (char *)ip, GULM_MAX_CSID_LEN);
if (!ninfo)
{
DEBUGLOG("Ignoring node %s, not part of the SAN cluster\n", name);
@ -510,7 +509,7 @@ static int lock_lock_state(void *misc, uint8_t *key, uint16_t keylen,
if (in_shutdown)
return 0;
lwait = hash_lookup(lock_hash, key);
lwait = dm_hash_lookup(lock_hash, key);
if (!lwait)
{
DEBUGLOG("Can't find hash entry for resource %s\n", key);
@ -555,22 +554,22 @@ int get_next_node_csid(void **context, char *csid)
/* First node */
if (!*context)
{
*context = hash_get_first(node_hash);
*context = dm_hash_get_first(node_hash);
}
else
{
*context = hash_get_next(node_hash, *context);
*context = dm_hash_get_next(node_hash, *context);
}
if (*context)
ninfo = hash_get_data(node_hash, *context);
ninfo = dm_hash_get_data(node_hash, *context);
/* Find a node that is UP */
while (*context && ninfo->state == NODE_DOWN)
{
*context = hash_get_next(node_hash, *context);
*context = dm_hash_get_next(node_hash, *context);
if (*context)
{
ninfo = hash_get_data(node_hash, *context);
ninfo = dm_hash_get_data(node_hash, *context);
}
}
@ -579,7 +578,7 @@ int get_next_node_csid(void **context, char *csid)
return 0;
}
memcpy(csid, hash_get_key(node_hash, *context), GULM_MAX_CSID_LEN);
memcpy(csid, dm_hash_get_key(node_hash, *context), GULM_MAX_CSID_LEN);
return 1;
}
@ -587,7 +586,7 @@ int gulm_name_from_csid(char *csid, char *name)
{
struct node_info *ninfo;
ninfo = hash_lookup_binary(node_hash, csid, GULM_MAX_CSID_LEN);
ninfo = dm_hash_lookup_binary(node_hash, csid, GULM_MAX_CSID_LEN);
if (!ninfo)
{
sprintf(name, "UNKNOWN %s", print_csid(csid));
@ -601,15 +600,15 @@ int gulm_name_from_csid(char *csid, char *name)
static int _csid_from_name(char *csid, char *name)
{
struct hash_node *hn;
struct dm_hash_node *hn;
struct node_info *ninfo;
hash_iterate(hn, node_hash)
dm_hash_iterate(hn, node_hash)
{
ninfo = hash_get_data(node_hash, hn);
ninfo = dm_hash_get_data(node_hash, hn);
if (strcmp(ninfo->name, name) == 0)
{
memcpy(csid, hash_get_key(node_hash, hn), GULM_MAX_CSID_LEN);
memcpy(csid, dm_hash_get_key(node_hash, hn), GULM_MAX_CSID_LEN);
return 0;
}
}
@ -627,7 +626,7 @@ void gulm_add_up_node(char *csid)
{
struct node_info *ninfo;
ninfo = hash_lookup_binary(node_hash, csid, GULM_MAX_CSID_LEN);
ninfo = dm_hash_lookup_binary(node_hash, csid, GULM_MAX_CSID_LEN);
if (!ninfo) {
DEBUGLOG("gulm_add_up_node no node_hash entry for csid %s\n", print_csid(csid));
return;
@ -647,7 +646,7 @@ void add_down_node(char *csid)
{
struct node_info *ninfo;
ninfo = hash_lookup_binary(node_hash, csid, GULM_MAX_CSID_LEN);
ninfo = dm_hash_lookup_binary(node_hash, csid, GULM_MAX_CSID_LEN);
if (!ninfo)
return;
@ -664,27 +663,27 @@ void add_down_node(char *csid)
static int _cluster_do_node_callback(struct local_client *master_client,
void (*callback)(struct local_client *, char *csid, int node_up))
{
struct hash_node *hn;
struct dm_hash_node *hn;
struct node_info *ninfo;
hash_iterate(hn, node_hash)
dm_hash_iterate(hn, node_hash)
{
char csid[GULM_MAX_CSID_LEN];
struct local_client *client;
ninfo = hash_get_data(node_hash, hn);
memcpy(csid, hash_get_key(node_hash, hn), GULM_MAX_CSID_LEN);
ninfo = dm_hash_get_data(node_hash, hn);
memcpy(csid, dm_hash_get_key(node_hash, hn), GULM_MAX_CSID_LEN);
DEBUGLOG("down_callback. node %s, state = %d\n", ninfo->name, ninfo->state);
client = hash_lookup_binary(sock_hash, csid, GULM_MAX_CSID_LEN);
client = dm_hash_lookup_binary(sock_hash, csid, GULM_MAX_CSID_LEN);
if (!client)
{
/* If it's up but not connected, try to make contact */
if (ninfo->state == NODE_UP)
gulm_connect_csid(csid, &client);
client = hash_lookup_binary(sock_hash, csid, GULM_MAX_CSID_LEN);
client = dm_hash_lookup_binary(sock_hash, csid, GULM_MAX_CSID_LEN);
}
if (ninfo->state != NODE_DOWN)
@ -733,7 +732,7 @@ static int _lock_resource(char *resource, int mode, int flags, int *lockid)
/* This needs to be converted from DLM/LVM2 value for GULM */
if (flags == LCK_NONBLOCK) flags = lg_lock_flag_Try;
hash_insert(lock_hash, resource, &lwait);
dm_hash_insert(lock_hash, resource, &lwait);
DEBUGLOG("lock_resource '%s', flags=%d, mode=%d\n", resource, flags, mode);
status = lg_lock_state_req(gulm_if, resource, strlen(resource)+1,
@ -749,7 +748,7 @@ static int _lock_resource(char *resource, int mode, int flags, int *lockid)
pthread_cond_wait(&lwait.cond, &lwait.mutex);
pthread_mutex_unlock(&lwait.mutex);
hash_remove(lock_hash, resource);
dm_hash_remove(lock_hash, resource);
DEBUGLOG("lock-resource returning %d\n", lwait.status);
return gulm_to_errno(lwait.status);
@ -765,7 +764,7 @@ static int _unlock_resource(char *resource, int lockid)
pthread_mutex_init(&lwait.mutex, NULL);
pthread_mutex_lock(&lwait.mutex);
hash_insert(lock_hash, resource, &lwait);
dm_hash_insert(lock_hash, resource, &lwait);
DEBUGLOG("unlock_resource %s\n", resource);
status = lg_lock_state_req(gulm_if, resource, strlen(resource)+1,
@ -788,7 +787,7 @@ static int _unlock_resource(char *resource, int lockid)
pthread_cond_wait(&lwait.cond, &lwait.mutex);
pthread_mutex_unlock(&lwait.mutex);
hash_remove(lock_hash, resource);
dm_hash_remove(lock_hash, resource);
return gulm_to_errno(lwait.status);
}
@ -924,7 +923,7 @@ static int get_all_cluster_nodes()
struct node_info *ninfo;
/* If it's not in the list, then add it */
ninfo = hash_lookup_binary(node_hash, nodeip, GULM_MAX_CSID_LEN);
ninfo = dm_hash_lookup_binary(node_hash, nodeip, GULM_MAX_CSID_LEN);
if (!ninfo)
{
ninfo = malloc(sizeof(struct node_info));
@ -937,7 +936,7 @@ static int get_all_cluster_nodes()
strcpy(ninfo->name, nodename);
ninfo->state = NODE_DOWN;
hash_insert_binary(node_hash, nodeip, GULM_MAX_CSID_LEN, ninfo);
dm_hash_insert_binary(node_hash, nodeip, GULM_MAX_CSID_LEN, ninfo);
}
}
else

25
daemons/clvmd/lvm-functions.c
View File

@ -31,6 +31,9 @@
#include <syslog.h>
#include <assert.h>
#include "libdevmapper.h"
#include "list.h"
#include "lvm-types.h"
#include "libdlm.h"
#include "clvm.h"
#include "clvmd-comms.h"
@ -44,7 +47,7 @@
#include "locking.h"
static struct cmd_context *cmd = NULL;
static struct hash_table *lv_hash = NULL;
static struct dm_hash_table *lv_hash = NULL;
static pthread_mutex_t lv_hash_lock;
struct lv_info {
@ -58,7 +61,7 @@ static int get_current_lock(char *resource)
struct lv_info *lvi;
pthread_mutex_lock(&lv_hash_lock);
lvi = hash_lookup(lv_hash, resource);
lvi = dm_hash_lookup(lv_hash, resource);
pthread_mutex_unlock(&lv_hash_lock);
if (lvi) {
return lvi->lock_mode;
@ -70,13 +73,13 @@ static int get_current_lock(char *resource)
/* Called at shutdown to tidy the lockspace */
void unlock_all()
{
struct hash_node *v;
struct dm_hash_node *v;
pthread_mutex_lock(&lv_hash_lock);
hash_iterate(v, lv_hash) {
struct lv_info *lvi = hash_get_data(lv_hash, v);
dm_hash_iterate(v, lv_hash) {
struct lv_info *lvi = dm_hash_get_data(lv_hash, v);
sync_unlock(hash_get_key(lv_hash, v), lvi->lock_id);
sync_unlock(dm_hash_get_key(lv_hash, v), lvi->lock_id);
}
pthread_mutex_unlock(&lv_hash_lock);
}
@ -91,7 +94,7 @@ int hold_lock(char *resource, int mode, int flags)
flags &= LKF_NOQUEUE; /* Only LKF_NOQUEUE is valid here */
pthread_mutex_lock(&lv_hash_lock);
lvi = hash_lookup(lv_hash, resource);
lvi = dm_hash_lookup(lv_hash, resource);
pthread_mutex_unlock(&lv_hash_lock);
if (lvi) {
/* Already exists - convert it */
@ -121,7 +124,7 @@ int hold_lock(char *resource, int mode, int flags)
strerror(errno));
} else {
pthread_mutex_lock(&lv_hash_lock);
hash_insert(lv_hash, resource, lvi);
dm_hash_insert(lv_hash, resource, lvi);
pthread_mutex_unlock(&lv_hash_lock);
}
errno = saved_errno;
@ -137,7 +140,7 @@ int hold_unlock(char *resource)
int saved_errno;
pthread_mutex_lock(&lv_hash_lock);
lvi = hash_lookup(lv_hash, resource);
lvi = dm_hash_lookup(lv_hash, resource);
pthread_mutex_unlock(&lv_hash_lock);
if (!lvi) {
DEBUGLOG("hold_unlock, lock not already held\n");
@ -148,7 +151,7 @@ int hold_unlock(char *resource)
saved_errno = errno;
if (!status) {
pthread_mutex_lock(&lv_hash_lock);
hash_remove(lv_hash, resource);
dm_hash_remove(lv_hash, resource);
pthread_mutex_unlock(&lv_hash_lock);
free(lvi);
} else {
@ -510,7 +513,7 @@ static void check_config()
void init_lvhash()
{
/* Create hash table for keeping LV locks & status */
lv_hash = hash_create(100);
lv_hash = dm_hash_create(100);
pthread_mutex_init(&lv_hash_lock, NULL);
}

23
daemons/clvmd/tcp-comms.c
View File

@ -35,6 +35,7 @@
#include <netdb.h>
#include <assert.h>
#include "libdevmapper.h"
#include "clvm.h"
#include "clvmd-comms.h"
#include "clvmd.h"
@ -44,7 +45,7 @@
static int listen_fd = -1;
static int tcp_port;
struct hash_table *sock_hash;
struct dm_hash_table *sock_hash;
static int get_our_ip_address(char *addr, int *family);
static int read_from_tcpsock(struct local_client *fd, char *buf, int len, char *csid,
@ -55,7 +56,7 @@ int init_comms(unsigned short port)
{
struct sockaddr_in6 addr;
sock_hash = hash_create(100);
sock_hash = dm_hash_create(100);
tcp_port = port ? port : DEFAULT_TCP_PORT;
listen_fd = socket(AF_INET6, SOCK_STREAM, 0);
@ -100,10 +101,10 @@ void tcp_remove_client(char *csid)
job of clvmd.c whch will do the job when it notices the
other end has gone. We just need to remove the client(s) from
the hash table so we don't try to use it for sending any more */
client = hash_lookup_binary(sock_hash, csid, GULM_MAX_CSID_LEN);
client = dm_hash_lookup_binary(sock_hash, csid, GULM_MAX_CSID_LEN);
if (client)
{
hash_remove_binary(sock_hash, csid, GULM_MAX_CSID_LEN);
dm_hash_remove_binary(sock_hash, csid, GULM_MAX_CSID_LEN);
client->removeme = 1;
close(client->fd);
}
@ -111,10 +112,10 @@ void tcp_remove_client(char *csid)
/* Look for a mangled one too */
csid[0] ^= 0x80;
client = hash_lookup_binary(sock_hash, csid, GULM_MAX_CSID_LEN);
client = dm_hash_lookup_binary(sock_hash, csid, GULM_MAX_CSID_LEN);
if (client)
{
hash_remove_binary(sock_hash, csid, GULM_MAX_CSID_LEN);
dm_hash_remove_binary(sock_hash, csid, GULM_MAX_CSID_LEN);
client->removeme = 1;
close(client->fd);
}
@ -145,7 +146,7 @@ int alloc_client(int fd, char *csid, struct local_client **new_client)
*new_client = client;
/* Add to our list of node sockets */
if (hash_lookup_binary(sock_hash, csid, GULM_MAX_CSID_LEN))
if (dm_hash_lookup_binary(sock_hash, csid, GULM_MAX_CSID_LEN))
{
DEBUGLOG("alloc_client mangling CSID for second connection\n");
/* This is a duplicate connection but we can't close it because
@ -158,7 +159,7 @@ int alloc_client(int fd, char *csid, struct local_client **new_client)
/* If it still exists then kill the connection as we should only
ever have one incoming connection from each node */
if (hash_lookup_binary(sock_hash, csid, GULM_MAX_CSID_LEN))
if (dm_hash_lookup_binary(sock_hash, csid, GULM_MAX_CSID_LEN))
{
DEBUGLOG("Multiple incoming connections from node\n");
syslog(LOG_ERR, " Bogus incoming connection from %d.%d.%d.%d\n", csid[0],csid[1],csid[2],csid[3]);
@ -168,7 +169,7 @@ int alloc_client(int fd, char *csid, struct local_client **new_client)
return -1;
}
}
hash_insert_binary(sock_hash, csid, GULM_MAX_CSID_LEN, client);
dm_hash_insert_binary(sock_hash, csid, GULM_MAX_CSID_LEN, client);
return 0;
}
@ -301,7 +302,7 @@ static int read_from_tcpsock(struct local_client *client, char *buf, int len, ch
/* If the csid was mangled, then make sure we remove the right entry */
if (client->bits.net.flags)
remcsid[0] ^= 0x80;
hash_remove_binary(sock_hash, remcsid, GULM_MAX_CSID_LEN);
dm_hash_remove_binary(sock_hash, remcsid, GULM_MAX_CSID_LEN);
/* Tell cluster manager layer */
add_down_node(remcsid);
@ -380,7 +381,7 @@ static int tcp_send_message(void *buf, int msglen, unsigned char *csid, const ch
if (memcmp(csid, ourcsid, GULM_MAX_CSID_LEN) == 0)
return msglen;
client = hash_lookup_binary(sock_hash, csid, GULM_MAX_CSID_LEN);
client = dm_hash_lookup_binary(sock_hash, csid, GULM_MAX_CSID_LEN);
if (!client)
{
status = gulm_connect_csid(csid, &client);