[Pvfs2-cvs] commit by aching in pvfs2-1/src/common/gen-locks:
gen-locks.c gen-locks.h lock-storage.c
CVS commit program
cvs at parl.clemson.edu
Mon Jul 21 14:19:50 EDT 2008
Update of /projects/cvsroot/pvfs2-1/src/common/gen-locks
In directory parlweb1:/tmp/cvs-serv19729/common/gen-locks
Modified Files:
Tag: locking-branch
gen-locks.c gen-locks.h lock-storage.c
Log Message:
Reverse merged and ported to HEAD.
Index: gen-locks.c
===================================================================
RCS file: /projects/cvsroot/pvfs2-1/src/common/gen-locks/gen-locks.c,v
diff -p -u -r1.7 -r1.7.50.1
--- gen-locks.c 9 Feb 2005 21:46:59 -0000 1.7
+++ gen-locks.c 21 Jul 2008 18:19:50 -0000 1.7.50.1
@@ -75,36 +75,9 @@ int gen_posix_mutex_trylock(
}
/*
- * gen_mutex_build()
- *
- * allocates storage for and initializes a new pthread_mutex_t
- *
- * returns a pointer to the new mutex on success, NULL on failure.
- */
-pthread_mutex_t *gen_posix_mutex_build(
- void)
-{
-
- pthread_mutex_t *mutex_p = NULL;
-
- mutex_p = (pthread_mutex_t *) malloc(sizeof(pthread_mutex_t));
- if (!mutex_p)
- {
- return (NULL);
- }
- if ((pthread_mutex_init(mutex_p, NULL)) < 0)
- {
- free(mutex_p);
- return (NULL);
- }
- return (mutex_p);
-}
-
-
-/*
* gen_mutex_destroy()
*
- * uninitializes the mutex and frees all memory associated with it.
+ * uninitializes the mutex.
*
* returns 0 on success, -errno on failure.
*/
@@ -117,10 +90,15 @@ int gen_posix_mutex_destroy(
return (-EINVAL);
}
pthread_mutex_destroy(mut);
- free(mut);
return (0);
}
+
+pthread_t gen_posix_thread_self(void)
+{
+ return pthread_self();
+}
+
#endif
/*
Index: gen-locks.h
===================================================================
RCS file: /projects/cvsroot/pvfs2-1/src/common/gen-locks/gen-locks.h,v
diff -p -u -r1.10 -r1.10.52.1
--- gen-locks.h 28 Jul 2004 14:32:34 -0000 1.10
+++ gen-locks.h 21 Jul 2008 18:19:50 -0000 1.10.52.1
@@ -12,7 +12,6 @@
* int gen_mutex_lock(gen_mutex_t* mut);
* int gen_mutex_unlock(gen_mutex_t* mut);
* int gen_mutex_trylock(gen_mutex_t* mut);
- * gen_mutex_t* gen_mutex_build(void);
* int gen_mutex_destroy(gen_mutex_t* mut);
*
* See the examples directory for details.
@@ -41,51 +40,53 @@ int gen_posix_mutex_unlock(
pthread_mutex_t * mut);
int gen_posix_mutex_trylock(
pthread_mutex_t * mut);
-pthread_mutex_t *gen_posix_mutex_build(
- void);
int gen_posix_mutex_destroy(
pthread_mutex_t * mut);
int gen_posix_mutex_init(
pthread_mutex_t * mut);
+pthread_t gen_posix_thread_self(void);
typedef pthread_mutex_t gen_mutex_t;
+typedef pthread_t gen_thread_t;
#define GEN_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER;
#define gen_mutex_lock(m) gen_posix_mutex_lock(m)
#define gen_mutex_unlock(m) gen_posix_mutex_unlock(m)
#define gen_mutex_trylock(m) gen_posix_mutex_trylock(m)
-#define gen_mutex_build() gen_posix_mutex_build()
#define gen_mutex_destroy(m) gen_posix_mutex_destroy(m)
#define gen_mutex_init(m) gen_posix_mutex_init(m)
+#define gen_thread_self() gen_posix_thread_self()
#endif /* __GEN_POSIX_LOCKING__ */
#ifdef __GEN_NULL_LOCKING__
/* this stuff messes around just enough to prevent warnings */
typedef int gen_mutex_t;
+typedef unsigned long gen_thread_t;
#define GEN_MUTEX_INITIALIZER 0
static inline int gen_mutex_lock(
gen_mutex_t * mutex_p)
{
+ (void) mutex_p;
return 0;
}
static inline int gen_mutex_unlock(
gen_mutex_t * mutex_p)
{
+ (void) mutex_p;
return 0;
}
static inline int gen_mutex_trylock(
gen_mutex_t * mutex_p)
{
+ (void) mutex_p;
return 0;
}
-static inline gen_mutex_t *gen_mutex_build(
- void)
+static inline gen_thread_t gen_thread_self(void)
{
- return (int *) malloc(sizeof(int));
+ return 0;
}
-
#define gen_mutex_init(m) do{}while(0)
-#define gen_mutex_destroy(m) free(m)
+#define gen_mutex_destroy(m) do{}while(0)
#endif /* __GEN_NULL_LOCKING__ */
#endif /* __GEN_LOCKS_H */
Index: lock-storage.c
===================================================================
RCS file: /projects/cvsroot/pvfs2-1/src/common/gen-locks/Attic/lock-storage.c,v
diff -p -u -r1.1.2.8 -r1.1.2.8.2.1
--- lock-storage.c 14 Jul 2008 19:56:40 -0000 1.1.2.8
+++ lock-storage.c 21 Jul 2008 18:19:50 -0000 1.1.2.8.2.1
@@ -106,8 +106,8 @@ void linked_itree_print_fn(itree_t *head
linked_itree_t *linked_itree_p =
itree_entry(head_p, linked_itree_t, itree_link);
- fprintf(stdout, "{%lld,%lld,%lld,%s,%d,",
- lld(head_p->start), lld(head_p->end), lld(head_p->max),
+ fprintf(stdout, "{%Ld,%Ld,%Ld,%s,%d,",
+ head_p->start, head_p->end, head_p->max,
(head_p->color == ITREE_RED ? "r": "b"),
linked_itree_p->lock_id);
@@ -284,7 +284,7 @@ void free_lock_req(lock_req_t *lock_req_
static PVFS_id_gen_t lock_req_id = 0;
-static gen_mutex_t *lock_file_table_mutex = NULL;
+static gen_mutex_t lock_file_table_mutex;
static int hash_key(void *key, int table_size);
static int hash_key_compare(void *key, struct qlist_head *link);
@@ -292,7 +292,7 @@ static int hash_key_compare(void *key, s
static struct qhash_table *lock_file_table;
#define LOCK_FILE_TABLE_INITIALIZED() \
-(lock_file_table_mutex && lock_file_table)
+(lock_file_table)
static int hash_key(void *key, int table_size)
{
@@ -322,13 +322,7 @@ int init_lock_file_table(void)
if (!lock_file_table)
return -PVFS_ENOMEM;
- lock_file_table_mutex = gen_mutex_build();
- if (!lock_file_table_mutex)
- {
- qhash_finalize(lock_file_table);
- lock_file_table = NULL;
- return -PVFS_ENOMEM;
- }
+ gen_mutex_init(&lock_file_table_mutex);
}
else
gossip_err("init_lock_file_table: already exists!\n");
@@ -340,12 +334,11 @@ void free_lock_file_table(void)
{
if (LOCK_FILE_TABLE_INITIALIZED())
{
- gen_mutex_lock(lock_file_table_mutex);
+ gen_mutex_lock(&lock_file_table_mutex);
qhash_finalize(lock_file_table);
lock_file_table = NULL;
- gen_mutex_unlock(lock_file_table_mutex);
- gen_mutex_destroy(lock_file_table_mutex);
- lock_file_table_mutex = NULL;
+ gen_mutex_unlock(&lock_file_table_mutex);
+ gen_mutex_destroy(&lock_file_table_mutex);
}
else
gossip_err("free_lock_file_table_all: Already NULL!\n");
@@ -359,7 +352,7 @@ void free_lock_file_table_all(void)
if (LOCK_FILE_TABLE_INITIALIZED())
{
- gen_mutex_lock(lock_file_table_mutex);
+ gen_mutex_lock(&lock_file_table_mutex);
for (i = 0; i < lock_file_table->table_size; i++)
{
do
@@ -376,9 +369,8 @@ void free_lock_file_table_all(void)
}
qhash_finalize(lock_file_table);
lock_file_table = NULL;
- gen_mutex_unlock(lock_file_table_mutex);
- gen_mutex_destroy(lock_file_table_mutex);
- lock_file_table_mutex = NULL;
+ gen_mutex_unlock(&lock_file_table_mutex);
+ gen_mutex_destroy(&lock_file_table_mutex);
}
else
fprintf(stdout, "free_lock_file_table_all: Already NULL!\n");
@@ -392,7 +384,7 @@ void print_lock_file_table_all(void)
if (LOCK_FILE_TABLE_INITIALIZED())
{
- gen_mutex_lock(lock_file_table_mutex);
+ gen_mutex_lock(&lock_file_table_mutex);
for (i = 0; i < lock_file_table->table_size; i++)
{
fprintf(stdout, "index %d: ", i);
@@ -400,13 +392,13 @@ void print_lock_file_table_all(void)
{
lock_node_p = qhash_entry(
tmp_hash_head_p, lock_node_t, hash_link);
- fprintf(stdout, "{fs=%d,id=%lld} ", lock_node_p->refn.fs_id,
- lld(lock_node_p->refn.handle));
+ fprintf(stdout, "{fs=%d,id=%Ld} ", lock_node_p->refn.fs_id,
+ lock_node_p->refn.handle);
}
fprintf(stdout, "\n");
}
- gen_mutex_unlock(lock_file_table_mutex);
+ gen_mutex_unlock(&lock_file_table_mutex);
}
else
fprintf(stdout, "print_lock_file_table_all: NULL!\n");
@@ -421,7 +413,7 @@ void print_lock_file_table_all_info(void
if (LOCK_FILE_TABLE_INITIALIZED())
{
#if 0
- gen_mutex_lock(lock_file_table_mutex);
+ gen_mutex_lock(&lock_file_table_mutex);
#endif
fprintf(stdout, "---------------------------------------------\n");
fprintf(stdout, "lock legend {start,end,max,color(red or black)}\n\n");
@@ -435,23 +427,23 @@ void print_lock_file_table_all_info(void
{
lock_node_p = qhash_entry(
tmp_hash_head_p, lock_node_t, hash_link);
- fprintf(stdout, "\n {fs=%d,id=%lld}\n",
- lock_node_p->refn.fs_id, lld(lock_node_p->refn.handle));
+ fprintf(stdout, "\n {fs=%d,id=%Ld}\n",
+ lock_node_p->refn.fs_id, lock_node_p->refn.handle);
fprintf(stdout, " all_req: ");
qlist_for_each(tmp_req_p, &(lock_node_p->all_req))
{
tmp_lock_req_p = qlist_entry(
tmp_req_p, lock_req_t, all_req_link);
- fprintf(stdout, "{req_id=%lld ", lld(tmp_lock_req_p->req_id));
+ fprintf(stdout, "{req_id=%Ld ", tmp_lock_req_p->req_id);
qlist_for_each(tmp_req_lock_p,
&(tmp_lock_req_p->lock_head))
{
tmp_linked_itree_p = qlist_entry(
tmp_req_lock_p, linked_itree_t, list_link);
- fprintf(stdout, "(%lld,%lld)",
- lld(tmp_linked_itree_p->itree_link.start),
- lld(tmp_linked_itree_p->itree_link.end));
+ fprintf(stdout, "(%Ld,%Ld)",
+ tmp_linked_itree_p->itree_link.start,
+ tmp_linked_itree_p->itree_link.end);
}
fprintf(stdout, "}");
}
@@ -463,7 +455,7 @@ void print_lock_file_table_all_info(void
{
tmp_lock_req_p = qlist_entry(
tmp_req_p, lock_req_t, queued_req_link);
- fprintf(stdout, "{req_id=%lld} ", lld(tmp_lock_req_p->req_id));
+ fprintf(stdout, "{req_id=%Ld} ", tmp_lock_req_p->req_id);
}
fprintf(stdout, "\n write_itree: ");
itree_inorder_tree_print_fn(lock_node_p->write_itree,
@@ -488,7 +480,7 @@ void print_lock_file_table_all_info(void
fprintf(stdout, "\n");
}
#if 0
- gen_mutex_unlock(lock_file_table_mutex);
+ gen_mutex_unlock(&lock_file_table_mutex);
#endif
}
else
@@ -531,8 +523,8 @@ static inline int add_locks(lock_req_t *
offset_arr = lock_req_p->lock_result_p->offset_array;
size_arr = lock_req_p->lock_result_p->size_array;
- gossip_debug(GOSSIP_LOCK_DEBUG, "add_locks: actual_locked_bytes = %lld\n",
- lld(lock_req_p->actual_locked_bytes));
+ gossip_debug(GOSSIP_LOCK_DEBUG, "add_locks: actual_locked_bytes = %Ld\n",
+ lock_req_p->actual_locked_bytes);
while (ret == 0)
{
@@ -548,9 +540,9 @@ static inline int add_locks(lock_req_t *
lock_origin = REMOVED_LIST;
gossip_debug(GOSSIP_LOCK_DEBUG,
- "add_locks: Getting (start offset=%lld,end_offset=%lld)"
- " from removed list\n", lld(tmp_start_offset),
- lld(tmp_end_offset));
+ "add_locks: Getting (start offset=%Ld,end_offset=%Ld)"
+ " from removed list\n", tmp_start_offset,
+ tmp_end_offset);
}
else /* Process request if necessary then get the next piece */
{
@@ -596,18 +588,18 @@ static inline int add_locks(lock_req_t *
}
gossip_debug(GOSSIP_LOCK_DEBUG,
- "add_locks: Lock (local off=%lld,end=%lld) "
- "max_abs_off=%lld...\n",
- lld(tmp_start_offset),
- lld(tmp_end_offset),
- lld(final_abs_offset));
+ "add_locks: Lock (local off=%Ld,end=%Ld) "
+ "max_abs_off=%Ld...\n",
+ tmp_start_offset,
+ tmp_end_offset,
+ final_abs_offset);
/* Ensure that the lock requests are valid */
#if 1
if ((tmp_start_offset < 0) || (tmp_end_offset < 0))
{
- gossip_err("add_locks: Lock offset=%lld with end offset=%lld "
- "invalid\n", lld(tmp_start_offset), lld(tmp_end_offset));
+ gossip_err("add_locks: Lock offset=%Ld with end offset=%Ld "
+ "invalid\n", tmp_start_offset, tmp_end_offset);
ret = -PVFS_EINVAL;
break;
}
@@ -625,10 +617,10 @@ static inline int add_locks(lock_req_t *
{
gossip_debug(GOSSIP_LOCK_DEBUG,
"add_locks: Lock not added since "
- "(start=%lld,end=%lld) >= final_abs_offset=%lld\n",
- lld(tmp_abs_offset),
- lld(tmp_end_offset - tmp_start_offset + 1),
- lld(final_abs_offset));
+ "(start=%Ld,end=%Ld) >= final_abs_offset=%Ld\n",
+ tmp_abs_offset,
+ tmp_end_offset - tmp_start_offset + 1,
+ final_abs_offset);
*next_abs_offset_p = tmp_abs_offset;
ret = 1;
@@ -640,13 +632,13 @@ static inline int add_locks(lock_req_t *
(tmp_abs_offset + tmp_end_offset - tmp_start_offset + 1))
{
gossip_debug(GOSSIP_LOCK_DEBUG,
- "add_locks: Trimming lock from (start=%lld,end=%lld) to"
- " (start=%lld,end=%lld)\n",
- lld(tmp_abs_offset),
- lld(tmp_end_offset),
- lld(tmp_abs_offset),
- lld(tmp_start_offset + (final_abs_offset -
- tmp_abs_offset - 1)));
+ "add_locks: Trimming lock from (start=%Ld,end=%Ld) to"
+ " (start=%Ld,end=%Ld)\n",
+ tmp_abs_offset,
+ tmp_end_offset,
+ tmp_abs_offset,
+ tmp_start_offset + (final_abs_offset -
+ tmp_abs_offset - 1));
tmp_end_offset =
tmp_start_offset + (final_abs_offset - tmp_abs_offset - 1);
}
@@ -658,8 +650,8 @@ static inline int add_locks(lock_req_t *
if (itree_p != &ITREE_NIL)
{
gossip_debug(GOSSIP_LOCK_DEBUG,
- "itree_interval_search WRITE (int=%lld,%lld,rw=%s)"
- " failed\n", lld(tmp_start_offset), lld(tmp_end_offset),
+ "itree_interval_search WRITE (int=%Ld,%Ld,rw=%s)"
+ " failed\n", tmp_start_offset, tmp_end_offset,
((lock_req_p->io_type ==
PVFS_IO_READ) ? "r" : "w"));
/* Still may be able to add part of this lock depending on
@@ -672,8 +664,8 @@ static inline int add_locks(lock_req_t *
tmp_end_offset = itree_p->start - 1;
gossip_debug(GOSSIP_LOCK_DEBUG,
"add_locks: WRITE reset interval to "
- "(%lld,%lld)\n", lld(tmp_start_offset),
- lld(tmp_end_offset));
+ "(%Ld,%Ld)\n", tmp_start_offset,
+ tmp_end_offset);
}
else
{
@@ -705,8 +697,8 @@ static inline int add_locks(lock_req_t *
if (itree_p != &ITREE_NIL)
{
gossip_debug(GOSSIP_LOCK_DEBUG,
- "itree_interval_search READ (int=%lld,%lld,rw=%s)"
- " failed\n", lld(tmp_start_offset), lld(tmp_end_offset),
+ "itree_interval_search READ (int=%Ld,%Ld,rw=%s)"
+ " failed\n", tmp_start_offset, tmp_end_offset,
((lock_req_p->io_type ==
PVFS_IO_READ) ? "r" : "w"));
/* Still may be able to add part of this lock depending on
@@ -719,8 +711,8 @@ static inline int add_locks(lock_req_t *
tmp_end_offset = itree_p->start - 1;
gossip_debug(GOSSIP_LOCK_DEBUG,
"add_locks: READ reset interval to "
- "(%lld,%lld)\n", lld(tmp_start_offset),
- lld(tmp_end_offset));
+ "(%Ld,%Ld)\n", tmp_start_offset,
+ tmp_end_offset);
}
else
{
@@ -754,16 +746,16 @@ static inline int add_locks(lock_req_t *
if (linked_itree_p->itree_link.start >
linked_itree_p->itree_link.end)
{
- gossip_err("Invalid lock (start=%lld,end=%lld)\n",
- lld(linked_itree_p->itree_link.start),
- lld(linked_itree_p->itree_link.end));
+ gossip_err("Invalid lock (start=%Ld,end=%Ld)\n",
+ linked_itree_p->itree_link.start,
+ linked_itree_p->itree_link.end);
break;
}
gossip_debug(GOSSIP_LOCK_DEBUG,
- "Inserting (int=%lld,%lld,rw=%s)\n",
- lld(linked_itree_p->itree_link.start),
- lld(linked_itree_p->itree_link.end),
+ "Inserting (int=%Ld,%Ld,rw=%s)\n",
+ linked_itree_p->itree_link.start,
+ linked_itree_p->itree_link.end,
((lock_req_p->io_type ==
PVFS_IO_READ) ? "r" : "w"));
@@ -776,9 +768,9 @@ static inline int add_locks(lock_req_t *
if (ret != 0)
{
gossip_debug(GOSSIP_LOCK_DEBUG,
- "itree_insert of lock (int=%lld,%lld,rw=%s) "
- "failed\n", lld(linked_itree_p->itree_link.start),
- lld(linked_itree_p->itree_link.end),
+ "itree_insert of lock (int=%Ld,%Ld,rw=%s) "
+ "failed\n", linked_itree_p->itree_link.start,
+ linked_itree_p->itree_link.end,
((lock_req_p->io_type ==
PVFS_IO_READ) ? "r" : "w"));
*next_abs_offset_p = linked_itree_p->itree_link.start;
@@ -842,18 +834,18 @@ static inline int add_locks(lock_req_t *
tmp_linked_itree_p->itree_link.end);
}
- gossip_debug(GOSSIP_LOCK_DEBUG, "add_locks: granted %lld actual bytes "
- "(total %lld) of %lld requested bytes and reached "
- "logical offset %lld, last_abs_offset %lld, "
- "next_abs_offset %lld ret=%d\n",
- lld(*bytes_locked_p),
- lld(lock_req_p->actual_locked_bytes), lld(lock_req_p->aggregate_size),
- lld((*fdata_p->dist->methods->physical_to_logical_offset)
+ gossip_debug(GOSSIP_LOCK_DEBUG, "add_locks: granted %Ld actual bytes "
+ "(total %Ld) of %Ld requested bytes and reached "
+ "logical offset %Ld, last_abs_offset %Ld, "
+ "next_abs_offset %Ld ret=%d\n",
+ *bytes_locked_p,
+ lock_req_p->actual_locked_bytes, lock_req_p->aggregate_size,
+ (*fdata_p->dist->methods->physical_to_logical_offset)
(fdata_p->dist->params,
fdata_p,
- tmp_end_offset)),
- lld(*last_abs_offset_locked_p),
- lld(*next_abs_offset_p), ret);
+ tmp_end_offset),
+ *last_abs_offset_locked_p,
+ *next_abs_offset_p, ret);
return ret;
}
@@ -863,6 +855,8 @@ static inline int add_locks(lock_req_t *
* processes the reqs in the order in which they were received. */
int check_lock_reqs(lock_node_t *lock_node_p)
{
+ struct PINT_smcb *smcb = NULL;
+ struct PINT_server_op *s_op = NULL;
int ret = -1, chk_rwlock = 0;
struct qlist_head *pos = NULL, *scratch;
lock_req_t *tmp_lock_req_p = NULL;
@@ -881,13 +875,22 @@ int check_lock_reqs(lock_node_t *lock_no
{
assert(((struct job_desc *)
tmp_lock_req_p->lock_callback.data)->job_user_ptr != NULL);
+#if 1
+ smcb = (struct PINT_smcb *)
+ ((struct job_desc *) tmp_lock_req_p->lock_callback.data)
+ ->job_user_ptr;
+ s_op = PINT_sm_frame(smcb, PINT_FRAME_CURRENT);
+ resp_lock_p = &s_op->resp.u.lock;
+ /* AC - convert to the now parallel state machines */
+#else
resp_lock_p =
&((PINT_server_op *)
((struct job_desc *) tmp_lock_req_p->lock_callback.data)
->job_user_ptr)->resp.u.lock;
+#endif
gossip_debug(GOSSIP_LOCK_DEBUG,
- "check_lock_reqs: Trying lock id=%lld...\n",
- lld(tmp_lock_req_p->req_id));
+ "check_lock_reqs: Trying lock id=%Ld...\n",
+ tmp_lock_req_p->req_id);
ret = add_locks(tmp_lock_req_p, lock_node_p,
tmp_lock_req_p->wait_abs_offset,
@@ -914,8 +917,8 @@ int check_lock_reqs(lock_node_t *lock_no
{
gossip_debug(GOSSIP_LOCK_DEBUG,
"check_lock_req: Deleting req_id="
- "%lld from the queued list\n",
- lld(tmp_lock_req_p->req_id));
+ "%Ld from the queued list\n",
+ tmp_lock_req_p->req_id);
qlist_del_init(&tmp_lock_req_p->queued_req_link);
tmp_lock_req_p->lock_req_status = ALL_LOCKS_GRANTED;
tmp_lock_req_p->granted_req_link.key =
@@ -924,12 +927,12 @@ int check_lock_reqs(lock_node_t *lock_no
&(tmp_lock_req_p->granted_req_link));
gossip_debug(GOSSIP_LOCK_DEBUG,
- "check_lock_req: all %lld aggregate "
- "bytes granted to req_id=%lld "
- "(req_id=%lld added to granted list)\n",
- lld(tmp_lock_req_p->aggregate_size),
- lld(tmp_lock_req_p->req_id),
- lld(tmp_lock_req_p->req_id));
+ "check_lock_req: all %Ld aggregate "
+ "bytes granted to req_id=%Ld "
+ "(req_id=%Ld added to granted list)\n",
+ tmp_lock_req_p->aggregate_size,
+ tmp_lock_req_p->req_id,
+ tmp_lock_req_p->req_id);
}
tmp_lock_req_p->lock_callback.fn(
tmp_lock_req_p->lock_callback.data);
@@ -944,13 +947,13 @@ int check_lock_reqs(lock_node_t *lock_no
tmp_lock_req_p->wait_abs_offset)
{
gossip_debug(GOSSIP_LOCK_DEBUG,
- "check_lock_req: Returning req %lld since "
- "next_abs_offset %lld is beyond the "
- "wait_abs_offset %lld (resetting "
+ "check_lock_req: Returning req %Ld since "
+ "next_abs_offset %Ld is beyond the "
+ "wait_abs_offset %Ld (resetting "
"wait_abs_offset)\n",
- lld(tmp_lock_req_p->req_id),
- lld(resp_lock_p->next_abs_offset),
- lld(tmp_lock_req_p->wait_abs_offset));
+ tmp_lock_req_p->req_id,
+ resp_lock_p->next_abs_offset,
+ tmp_lock_req_p->wait_abs_offset);
tmp_lock_req_p->wait_abs_offset = -1;
tmp_lock_req_p->lock_callback.fn(
@@ -1006,7 +1009,7 @@ int add_lock_req(PVFS_object_ref *object
return -1;
}
- gen_mutex_lock(lock_file_table_mutex);
+ gen_mutex_lock(&lock_file_table_mutex);
/* First, search for existing lock_node. If it's not there,
* calloc it and add it to the hash table. */
@@ -1056,8 +1059,8 @@ int add_lock_req(PVFS_object_ref *object
file_req_offset + aggregate_size);
gossip_debug(GOSSIP_LOCK_DEBUG,
- "file_req_offset = %lld aggregate_size = %lld\n",
- lld(file_req_offset), lld(aggregate_size));
+ "file_req_offset = %Ld aggregate_size = %Ld\n",
+ file_req_offset, aggregate_size);
/* Set up new lock request */
lock_req_p = (lock_req_t *) calloc(1, sizeof(lock_req_t));
@@ -1101,9 +1104,9 @@ int add_lock_req(PVFS_object_ref *object
if (lock_req_p == NULL ||
lock_req_p->req_id != client_lock_req_id)
{
- gossip_err("add_lock_req: Request with id=%lld should have been "
+ gossip_err("add_lock_req: Request with id=%Ld should have been "
"found in the queued list!\n",
- lld(client_lock_req_id));
+ client_lock_req_id);
goto add_unlock_exit;
}
}
@@ -1127,7 +1130,7 @@ int add_lock_req(PVFS_object_ref *object
if (lock_req_p->lock_req_status == INCOMPLETE)
{
gossip_debug(GOSSIP_LOCK_DEBUG, "add_lock_req: Deleting req_id="
- "%lld from the queued list\n", lld(lock_req_p->req_id));
+ "%Ld from the queued list\n", lock_req_p->req_id);
qlist_del_init(&lock_req_p->queued_req_link);
}
@@ -1136,11 +1139,11 @@ int add_lock_req(PVFS_object_ref *object
rbtree_insert(&(lock_node_p->granted_req), &RBTREE_NIL,
&(lock_req_p->granted_req_link));
- gossip_debug(GOSSIP_LOCK_DEBUG, "add_lock_req: all %lld aggregate "
- "bytes granted to req_id=%lld "
- "(req_id=%lld added to granted list)\n",
- lld(lock_req_p->aggregate_size),
- lld(lock_req_p->req_id), lld(lock_req_p->req_id));
+ gossip_debug(GOSSIP_LOCK_DEBUG, "add_lock_req: all %Ld aggregate "
+ "bytes granted to req_id=%Ld "
+ "(req_id=%Ld added to granted list)\n",
+ lock_req_p->aggregate_size,
+ lock_req_p->req_id, lock_req_p->req_id);
*lock_req_p_p = NULL;
ret = 1;
resp_lock_p->request_finished = 1;
@@ -1150,7 +1153,7 @@ int add_lock_req(PVFS_object_ref *object
if (lock_req_p->lock_req_status == NEW)
{
gossip_debug(GOSSIP_LOCK_DEBUG, "add_lock_req: Adding req_id="
- "%lld to the queued list\n", lld(lock_req_p->req_id));
+ "%Ld to the queued list\n", lock_req_p->req_id);
qlist_add_tail(&(lock_req_p->queued_req_link),
&(lock_node_p->queued_req));
@@ -1158,12 +1161,12 @@ int add_lock_req(PVFS_object_ref *object
lock_req_p->lock_req_status = INCOMPLETE;
- gossip_debug(GOSSIP_LOCK_DEBUG, "add_lock_req: some %lld of %lld "
- "aggregate bytes granted to req_id=%lld (waiting "
- "til %lld)\n",
- lld(lock_req_p->actual_locked_bytes),
- lld(lock_req_p->aggregate_size),
- lld(lock_req_p->req_id), lld(lock_req_p->wait_abs_offset));
+ gossip_debug(GOSSIP_LOCK_DEBUG, "add_lock_req: some %Ld of %Ld "
+ "aggregate bytes granted to req_id=%Ld (waiting "
+ "til %Ld)\n",
+ lock_req_p->actual_locked_bytes,
+ lock_req_p->aggregate_size,
+ lock_req_p->req_id, lock_req_p->wait_abs_offset);
*lock_req_p_p = lock_req_p;
if ((lock_type == PVFS_SERVER_ACQUIRE_NEW_BLOCK) ||
@@ -1173,18 +1176,18 @@ int add_lock_req(PVFS_object_ref *object
{
lock_req_p->wait_abs_offset = -1;
ret = 1;
- gossip_debug(GOSSIP_LOCK_DEBUG, "Returning immediately (wait=%lld)"
- " since next offset=%lld is beyond final_offset=%lld "
+ gossip_debug(GOSSIP_LOCK_DEBUG, "Returning immediately (wait=%Ld)"
+ " since next offset=%Ld is beyond final_offset=%Ld "
"or request is nonblocking\n",
- lld(lock_req_p->wait_abs_offset),
- lld(resp_lock_p->next_abs_offset), lld(final_offset));
+ lock_req_p->wait_abs_offset,
+ resp_lock_p->next_abs_offset, final_offset);
}
else
{
lock_req_p->wait_abs_offset = final_offset;
ret = 0;
- gossip_debug(GOSSIP_LOCK_DEBUG, "Waiting until %lld.\n",
- lld(lock_req_p->wait_abs_offset));
+ gossip_debug(GOSSIP_LOCK_DEBUG, "Waiting until %Ld.\n",
+ lock_req_p->wait_abs_offset);
}
resp_lock_p->request_finished = 0;
}
@@ -1194,7 +1197,7 @@ int add_lock_req(PVFS_object_ref *object
}
add_unlock_exit:
- gen_mutex_unlock(lock_file_table_mutex);
+ gen_mutex_unlock(&lock_file_table_mutex);
return ret;
}
@@ -1229,7 +1232,7 @@ int revise_lock_req(PVFS_object_ref *obj
return -1;
}
- gen_mutex_lock(lock_file_table_mutex);
+ gen_mutex_lock(&lock_file_table_mutex);
/* Find the lock_node for the object_ref_p. */
hash_link_p = qhash_search(lock_file_table, object_ref_p);
@@ -1257,8 +1260,8 @@ int revise_lock_req(PVFS_object_ref *obj
{
lock_req_t *tmp_lock_req_p = NULL;
- gossip_debug(GOSSIP_LOCK_DEBUG, "revise_lock_req: req_id=%lld not "
- "found in granted list\n", lld(req_id));
+ gossip_debug(GOSSIP_LOCK_DEBUG, "revise_lock_req: req_id=%Ld not "
+ "found in granted list\n", req_id);
qhash_for_each(pos, &(lock_node_p->queued_req))
{
@@ -1268,8 +1271,8 @@ int revise_lock_req(PVFS_object_ref *obj
}
if (lock_req_p == NULL)
{
- gossip_debug(GOSSIP_LOCK_DEBUG, "revise_lock_req: req_id=%lld not "
- "found in granted or queued list\n", lld(req_id));
+ gossip_debug(GOSSIP_LOCK_DEBUG, "revise_lock_req: req_id=%Ld not "
+ "found in granted or queued list\n", req_id);
ret = -1;
goto del_unlock_exit;
}
@@ -1286,11 +1289,11 @@ int revise_lock_req(PVFS_object_ref *obj
linked_itree_p = itree_entry(pos, linked_itree_t, list_link);
gossip_debug(GOSSIP_LOCK_DEBUG,
- "removing (ALL) lock from %lld to %lld - req %d "
- "(should be %lld)\n",
- lld(linked_itree_p->itree_link.start),
- lld(linked_itree_p->itree_link.end),
- linked_itree_p->lock_id, lld(req_id));
+ "removing (ALL) lock from %Ld to %Ld - req %d "
+ "(should be %Ld)\n",
+ linked_itree_p->itree_link.start,
+ linked_itree_p->itree_link.end,
+ linked_itree_p->lock_id, req_id);
released_bytes += linked_itree_p->itree_link.end -
linked_itree_p->itree_link.start + 1;
@@ -1357,12 +1360,12 @@ int revise_lock_req(PVFS_object_ref *obj
(final_local_offset - 1);
gossip_debug(GOSSIP_LOCK_DEBUG,
- "removing (SOME) partial lock from %lld to %lld - "
- "req %d (should be %lld) - final_local_off=%lld\n",
- lld(final_local_offset),
- lld(linked_itree_p->itree_link.end),
- linked_itree_p->lock_id, lld(req_id),
- lld(final_local_offset));
+ "removing (SOME) partial lock from %Ld to %Ld - "
+ "req %d (should be %Ld) - final_local_off=%Ld\n",
+ final_local_offset,
+ linked_itree_p->itree_link.end,
+ linked_itree_p->lock_id, req_id,
+ final_local_offset);
linked_itree_p->itree_link.end = final_local_offset - 1;
@@ -1391,12 +1394,12 @@ int revise_lock_req(PVFS_object_ref *obj
linked_itree_p->itree_link.start + 1;
gossip_debug(GOSSIP_LOCK_DEBUG,
- "removing (SOME) lock from %lld to %lld - req %d "
- "(should be %lld) - final_local_off=%lld\n",
- lld(linked_itree_p->itree_link.start),
- lld(linked_itree_p->itree_link.end),
- linked_itree_p->lock_id, lld(req_id),
- lld(final_local_offset));
+ "removing (SOME) lock from %Ld to %Ld - req %d "
+ "(should be %Ld) - final_local_off=%Ld\n",
+ linked_itree_p->itree_link.start,
+ linked_itree_p->itree_link.end,
+ linked_itree_p->lock_id, req_id,
+ final_local_offset);
qlist_del(last_lock_p);
del_itree_p = itree_delete(
@@ -1427,17 +1430,17 @@ int revise_lock_req(PVFS_object_ref *obj
if (lock_req_p->lock_req_status == INCOMPLETE)
{
gossip_debug(GOSSIP_LOCK_DEBUG,
- "Remove all locks - req %lld removed from the"
+ "Remove all locks - req %Ld removed from the"
" queued list.\n",
- lld(lock_req_p->req_id));
+ lock_req_p->req_id);
qlist_del_init(&(lock_req_p->queued_req_link));
}
else
{
gossip_debug(GOSSIP_LOCK_DEBUG,
- "Remove all locks - req %lld removed from the"
+ "Remove all locks - req %Ld removed from the"
" granted list.\n",
- lld(lock_req_p->req_id));
+ lock_req_p->req_id);
del_rbtree_p =
rbtree_delete(&lock_node_p->granted_req, &RBTREE_NIL,
@@ -1475,9 +1478,9 @@ int revise_lock_req(PVFS_object_ref *obj
struct qlist_head *tmp_req_p = NULL;
gossip_debug(GOSSIP_LOCK_DEBUG,
- "Remove some locks - req %lld removed from the"
+ "Remove some locks - req %Ld removed from the"
" granted list.\n",
- lld(lock_req_p->req_id));
+ lock_req_p->req_id);
del_rbtree_p =
rbtree_delete(&(lock_node_p->granted_req), &RBTREE_NIL,
&(lock_req_p->granted_req_link),
@@ -1487,9 +1490,9 @@ int revise_lock_req(PVFS_object_ref *obj
tmp_req_p = &(lock_req_p->all_req_link);
gossip_debug(GOSSIP_LOCK_DEBUG,
- "Remove some locks - req %lld added back to the"
+ "Remove some locks - req %Ld added back to the"
" queued list.\n",
- lld(lock_req_p->req_id));
+ lock_req_p->req_id);
/* Find out where in the queued list it belongs. Search
* the all_req queue after it to see what is next and
@@ -1517,9 +1520,9 @@ int revise_lock_req(PVFS_object_ref *obj
}
else {
gossip_debug(GOSSIP_LOCK_DEBUG,
- "Remove some locks - req %lld already in "
+ "Remove some locks - req %Ld already in "
"queued list.\n",
- lld(lock_req_p->req_id));
+ lock_req_p->req_id);
}
}
@@ -1594,7 +1597,7 @@ int revise_lock_req(PVFS_object_ref *obj
}
del_unlock_exit:
- gen_mutex_unlock(lock_file_table_mutex);
+ gen_mutex_unlock(&lock_file_table_mutex);
resp_lock_p->bytes_accessed = -released_bytes;
if (released_bytes == 0)
More information about the Pvfs2-cvs
mailing list