int lm_prepare_lockspace_dlm(struct lockspace *ls)
{
char sys_clustername[MAX_ARGS+1];
char arg_clustername[MAX_ARGS+1];
uint32_t major = 0, minor = 0, patch = 0;
struct lm_dlm *lmd;
int rv;
memset(sys_clustername, 0, sizeof(sys_clustername));
memset(arg_clustername, 0, sizeof(arg_clustername));
rv = read_cluster_name(sys_clustername);
if (rv < 0)
return -EMANAGER;
rv = dlm_kernel_version(&major, &minor, &patch);
if (rv < 0) {
log_error("prepare_lockspace_dlm kernel_version not detected %d", rv);
dlm_has_lvb_bug = 1;
}
if ((major == 6) && (minor == 0) && (patch == 1)) {
log_debug("dlm kernel version %u.%u.%u has lvb bug", major, minor, patch);
dlm_has_lvb_bug = 1;
}
if (!ls->vg_args[0]) {
/* global lockspace has no vg args */
goto skip_args;
}
rv = check_args_version(ls->vg_args);
if (rv < 0)
return -EARGS;
rv = cluster_name_from_args(ls->vg_args, arg_clustername);
if (rv < 0) {
log_error("prepare_lockspace_dlm %s no cluster name from args %s", ls->name, ls->vg_args);
return -EARGS;
}
if (strcmp(sys_clustername, arg_clustername)) {
log_error("prepare_lockspace_dlm %s mismatching cluster names sys %s arg %s",
ls->name, sys_clustername, arg_clustername);
return -EARGS;
}
skip_args:
lmd = malloc(sizeof(struct lm_dlm));
if (!lmd)
return -ENOMEM;
ls->lm_data = lmd;
return 0;
}
int main(int argc, char *argv[])
{
uint32_t major, minor, patch;
struct lk *lk;
int i, rv, maxi = 0, quit = 0;
srandom(time(NULL));
decode_arguments(argc, argv);
if (maxn < maxr) {
printf("number of resources must be >= number of locks\n");
return -1;
}
if (maxn % maxr) {
printf("number of locks must be multiple of number of resources\n");
return -1;
}
printf("maxn = %d\n", maxn);
printf("maxr = %d\n", maxr);
printf("locks per resource = %d\n", maxn / maxr);
signal(SIGTERM, sigterm_handler);
client_init();
locks = malloc(maxn * sizeof(struct lk));
if (!locks) {
printf("no mem for %d locks\n", maxn);
return 0;
}
memset(locks, 0, sizeof(*locks));
lk = locks;
for (i = 0; i < maxn; i++) {
lk->id = i;
lk->grmode = -1;
lk->rqmode = -1;
lk++;
}
rv = dlm_kernel_version(&major, &minor, &patch);
if (rv < 0) {
printf("can't detect dlm in kernel %d\n", errno);
return -1;
}
printf("dlm kernel version: %u.%u.%u\n", major, minor, patch);
dlm_library_version(&major, &minor, &patch);
printf("dlm library version: %u.%u.%u\n", major, minor, patch);
if (openclose_ls) {
printf("dlm_open_lockspace...\n");
dh = dlm_open_lockspace("test");
if (!dh) {
printf("dlm_open_lockspace error %lu %d\n",
(unsigned long)dh, errno);
return -ENOTCONN;
}
} else {
printf("dlm_new_lockspace...\n");
dh = dlm_new_lockspace("test", 0600,
timewarn ? DLM_LSFL_TIMEWARN : 0);
if (!dh) {
printf("dlm_new_lockspace error %lu %d\n",
(unsigned long)dh, errno);
return -ENOTCONN;
}
}
rv = dlm_ls_get_fd(dh);
if (rv < 0) {
printf("dlm_ls_get_fd error %d %d\n", rv, errno);
dlm_release_lockspace("test", dh, 1);
return rv;
}
libdlm_fd = rv;
client_add(libdlm_fd, &maxi);
if (opt_cmd) {
process_command(&quit);
goto out;
}
client_add(STDIN_FILENO, &maxi);
printf("Type EXIT to finish, help for usage\n");
while (1) {
rv = poll(pollfd, maxi + 1, -1);
if (rv < 0 && errno == EINTR)
continue;
if (rv < 0)
printf("poll error %d errno %d\n", rv, errno);
for (i = 0; i <= maxi; i++) {
if (client[i].fd < 0)
continue;
if (pollfd[i].revents & POLLIN) {
if (pollfd[i].fd == libdlm_fd)
process_libdlm();
else if (pollfd[i].fd == STDIN_FILENO)
process_command(&quit);
}
if (pollfd[i].revents & (POLLHUP | POLLERR | POLLNVAL))
client_dead(i);
}
if (quit && all_unlocks_done())
break;
}
out:
if (openclose_ls) {
printf("dlm_close_lockspace\n");
rv = dlm_close_lockspace(dh);
if (rv < 0)
printf("dlm_close_lockspace error %d %d\n", rv, errno);
} else {
printf("dlm_release_lockspace\n");
rv = dlm_release_lockspace("test", dh, 1);
if (rv < 0)
printf("dlm_release_lockspace error %d %d\n", rv, errno);
}
return 0;
}
