/* lock_resource & unlock_resource
* are the simplified, synchronous API.
* Aways uses the default lockspace.
*/
int lock_resource(const char *resource, int mode, int flags, int *lockid)
{
int status;
struct lock_wait lwait;
if (default_ls == NULL)
{
if (dlm_pthread_init())
{
return -1;
}
}
if (!lockid)
{
errno = EINVAL;
return -1;
}
/* Conversions need the lockid in the LKSB */
if (flags & LKF_CONVERT)
lwait.lksb.sb_lkid = *lockid;
pthread_cond_init(&lwait.cond, NULL);
pthread_mutex_init(&lwait.mutex, NULL);
pthread_mutex_lock(&lwait.mutex);
status = dlm_lock(mode,
&lwait.lksb,
flags,
resource,
strlen(resource),
0,
sync_ast_routine,
&lwait,
NULL,
NULL);
if (status)
return status;
/* Wait for it to complete */
pthread_cond_wait(&lwait.cond, &lwait.mutex);
pthread_mutex_unlock(&lwait.mutex);
*lockid = lwait.lksb.sb_lkid;
errno = lwait.lksb.sb_status;
if (lwait.lksb.sb_status)
return -1;
else
return 0;
}
int main(int argc, char *argv[])
{
if (argc < 3)
{
printf("usage: %s <maxnodes> <us>\n", argv[0]);
return 2;
}
maxnode = atoi(argv[1]);
us = atoi(argv[2]);
dlm_pthread_init();
start_lock();
while(1)
sleep(100000);
return 0;
}
int main(int argc, char *argv[])
{
const char *resource = "LOCK-NAME";
int flags = 0;
int delay = 0;
int status;
int mode = LKM_EXMODE;
int convmode = -1;
int do_unlock = 1;
int do_crash = 0;
signed char opt;
/* Deal with command-line arguments */
opterr = 0;
optind = 0;
while ((opt=getopt(argc,argv,"?m:nqupc:d:CvV")) != EOF)
{
switch(opt)
{
case 'h':
usage(argv[0], stdout);
exit(0);
case '?':
usage(argv[0], stderr);
exit(0);
case 'm':
mode = modetonum(optarg);
break;
case 'c':
convmode = modetonum(optarg);
break;
case 'p':
use_threads++;
break;
case 'n':
flags |= LKF_NOQUEUE;
break;
case 'q':
quiet = 1;
break;
case 'u':
do_unlock = 0;
break;
case 'C':
do_crash = 1;
break;
case 'd':
delay = atoi(optarg);
break;
case 'V':
printf("\nasttest version 0.1\n\n");
exit(1);
break;
}
}
if (argv[optind])
resource = argv[optind];
if (!quiet)
fprintf(stderr, "locking %s %s %s...", resource,
numtomode(mode),
(flags&LKF_NOQUEUE?"(NOQUEUE)":""));
fflush(stderr);
if (use_threads)
{
pthread_cond_init(&cond, NULL);
pthread_mutex_init(&mutex, NULL);
pthread_mutex_lock(&mutex);
dlm_pthread_init();
}
status = dlm_lock(mode,
&lksb,
flags,
resource,
strlen(resource),
0, // Parent,
ast_routine,
&lksb,
bast_routine,
NULL); // Range
if (status == -1)
{
if (!quiet) fprintf(stderr, "\n");
perror("lock");
return -1;
}
printf("(lkid=%x)", lksb.sb_lkid);
if (do_crash)
*(int *)0 = 0xdeadbeef;
/* Wait */
if (use_threads)
pthread_cond_wait(&cond, &mutex);
else
poll_for_ast();
if (delay)
sleep(delay);
if (!quiet)
{
fprintf(stderr, "unlocking %s...", resource);
fflush(stderr);
}
if (do_unlock)
{
status = dlm_unlock(lksb.sb_lkid,
0, // flags
&lksb,
&lksb); // AST args
if (status == -1)
{
if (!quiet) fprintf(stderr, "\n");
perror("unlock");
return -1;
}
/* Wait */
if (use_threads)
pthread_cond_wait(&cond, &mutex);
else
poll_for_ast();
}
return 0;
}
int main(int argc, char *argv[])
{
int flags = 0;
int lockops = 0;
int maxlocks = 100000;
int rescount = 10;
int increment = 1000;
int quiet = 0;
int status;
int i;
int mode = LKM_CRMODE;
int lksbnum = 0;
signed char opt;
char **resources;
struct dlm_lksb *lksbs;
/* Deal with command-line arguments */
opterr = 0;
optind = 0;
while ((opt=getopt(argc,argv,"?m:i:qn:vV")) != EOF)
{
switch(opt)
{
case 'h':
usage(argv[0], stdout);
exit(0);
case '?':
usage(argv[0], stderr);
exit(0);
case 'm':
maxlocks = atoi(optarg);
break;
case 'i':
increment = atoi(optarg);
break;
case 'n':
rescount = atoi(optarg);
break;
case 'q':
quiet = 1;
break;
case 'V':
printf("\nflood version 0.3\n\n");
exit(1);
break;
}
}
if ((resources = malloc(sizeof(char*) * rescount)) == NULL)
{
perror("exhausted virtual memory");
return 1;
}
for (i=0; i < rescount; i++) {
char resname[256];
sprintf(resname, "TESTLOCK%d", i);
resources[i] = strdup(resname);
}
lksbs = malloc(sizeof(struct dlm_lksb) * maxlocks);
if (!lksbs)
{
perror("cannot allocate lksbs");
return 1;
}
pthread_cond_init(&cond, NULL);
pthread_mutex_init(&mutex, NULL);
pthread_mutex_lock(&mutex);
dlm_pthread_init();
while (1) {
char *resource = resources[rand() % rescount];
status = dlm_lock(mode,
&lksbs[lksbnum],
flags,
resource,
strlen(resource),
0, // Parent,
ast_routine,
&lksbs[lksbnum],
NULL, // bast_routine,
NULL); // Range
if (status == -1)
{
perror("lock failed");
return -1;
}
count++;
lockops++;
if ((lockops % increment) == 0 && !quiet)
fprintf(stderr, "%d lockops, %d locks\n", lockops, count);
while (count > maxlocks) {
sleep(1);
}
lksbnum = (lksbnum+1)%maxlocks;
}
return 0;
}
