QUEUE locking problem

Question

I just made 2 sample programs, the first one writes in a queue and the other reads from the queue. It seem when one of the process die (ex kill -9) between a put or get operation, the locks persist blocking all the operations (corrupting the database). The sample programs I made are the followings.
Writer program
#include <db.h>
#include <string.h>
#include <stdio.h>
#define OP_SIZE 80
main(int argc, char *argv[])
DB *dbp;
DBT clave, dato;
DB_ENV *env;
u_int32_t flags;
db_recno_t rn=0;
int ret, i=0,locks;
int maxins=10;
long id=0;
char szOp[SIZE_OP+1];
ret = db_env_create(&env, 0);
ret = env->open(env, "/disk9/tqueue", DB_CREATE | DB_INIT_MPOOL | DB_INIT_LOCK | DB_INIT_TXN | DB_REGISTER|DB_THREAD, 0);
if(ret)
printf("ERROR : Abriendo ambiente %s",db_strerror(ret));
if (argc > 1)
maxins = atoi(argv[1]);
ret = db_create(&dbp, env, 0);
if(ret != 0) {
printf("ERROR : Creando bdd %s", db_strerror(ret));
flags = DB_CREATE;
ret = dbp->set_re_len(dbp, SIZE_OP);
ret = dbp->open(dbp, NULL, "mi_bdd.db", NULL, DB_QUEUE, flags, 0);
if(ret != 0) {
dbp->err(dbp, ret, "Falla en apertura");
memset(szOp, 0, SIZE_OP+1);
memset(&clave, 0, sizeof(clave));
memset(&dato, 0, sizeof(dato));
while(i < maxins) {
sprintf(szOp, "%020d", id);
clave.data = &rn;
clave.size = sizeof(rn);
dato.data = szOp;
dato.size = strlen(szOp);
printf("Insertando par (%d, %s)\n", id, szOp);
ret = dbp->put(dbp, NULL, &clave, &dato, DB_APPEND);
printf("clave: %d\n", rn);
if(ret) {
switch(ret) {
case DB_KEYEXIST:
dbp->err(dbp, ret, "Falla en escritura, llave %d existe", id);
break;
case EINVAL:
dbp->err(dbp, ret, "Falla en escritura, llave %d EINVAL", id);
break;
default:
dbp->err(dbp, ret, "ERROR:");
id++;
i++;
dbp->close(dbp, 0);
env->close(env, 0);
Reader Program
#include <db.h>
#include <string.h>
#include <stdio.h>
#define OP_SIZE 80
main(int argc, char *argv[])
DB *dbp;
DBT clave, dato;
DB_ENV *env;
u_int32_t flags;
int ret, i=0,locks;
long id=0;
char szOp[OP_SIZE+1];
memset(szOp, 0, OP_SIZE+1);
ret = db_env_create(&env, 0);
ret = env->open(env, "/disk9/tqueue", DB_CREATE | DB_INIT_MPOOL | DB_INIT_LOCK | DB_INIT_TXN |DB_REGISTER |DB_THREAD, 0);
if(ret)
printf("ERROR : opening enviroment %s", db_strerror(ret));
ret = db_create(&dbp, env, 0);
if(ret != 0) {
dbp->err(dbp, ret, "ERROR:");
flags = 0;
ret = dbp->open(dbp, NULL, "mi_bdd.db", NULL, DB_UNKNOWN, flags, 0);
ret = dbp->stat_print(dbp, 0);
if(ret != 0) {
dbp->err(dbp, ret, "Fail Opening");
memset(&clave, 0, sizeof(clave));
memset(&dato, 0, sizeof(dato));
if(argc > 1)
id = atoi(argv[1]);
clave.data = &id;
clave.size = sizeof(id);
dato.data = szOp;
dato.ulen = OP_SIZE;
dato.flags = DB_DBT_USERMEM;
ret = 0;
while(ret == 0) {
ret = dbp->get(dbp, NULL, &clave, &dato, DB_CONSUME_WAIT);
printf("%d: Registro id:%d, dat: %s\n", i, id, szOp);
if(ret) {
switch (ret) {
case DB_NOTFOUND:
dbp->err(dbp, ret, "KEY %d DOES NOT", id);
break;
default:
dbp->err(dbp, ret, "ERROR:");
i++;
dbp->close(dbp, 0);
//env->close(env, 0);
I alredy tried the following flags combination for opening the enviroment.
flags = DB_CREATE | DB_INIT_LOCK | DB_INIT_LOG | DB_INIT_MPOOL | DB_INIT_TXN | DB_RECOVER
flags= DB_CREATE | DB_INIT_MPOOL | DB_INIT_LOCK | DB_INIT_TXN
Message edited to add the writer program

Answer 1

Hi Rodrigo,
It looks like you've posted the same program twice.
There are a number of reasons to include transactional support in your applications, and the principal one is recoverability. I don't know if for the writer you are using transactions.
For the reader, you can use DB_RDONLY when opening the db.
How do you run the applications?
A good point to start with, is to run the txn_guide.c example from your Berkeley DB distribution \examples_c\txn_guide.
Also, reading the "Berkeley DB Transactional Data Store Applications" and "The Locking Subsystem" chapters from Berkeley DB Reference Guide, can help you in merging your application with Berkeley DB.
Regards,
Bogdan Coman