From f923add0a9b6bd17d43f72c21eec4e01e19240cf Mon Sep 17 00:00:00 2001
From: zilio nicolas <nicolas.zilio@kit.edu>
Date: Tue, 7 Jul 2015 11:12:52 +0200
Subject: clean version for locks

---
 pcilib/CMakeLists.txt |   4 +-
 pcilib/kmem.h         |   1 +
 pcilib/lock.c         | 116 ++++++++++++++++++++++++++++++++++++++++++++++++++
 pcilib/lock.h         |  55 ++++++++++++++++++++++++
 pcilib/locking.c      |  74 ++++++++++++++++++++++++++++++++
 pcilib/locking.h      |  44 +++++++++++++++++++
 pcilib/pci.c          |   8 ++++
 pcilib/pci.h          |   2 +-
 8 files changed, 301 insertions(+), 3 deletions(-)
 create mode 100644 pcilib/lock.c
 create mode 100644 pcilib/lock.h
 create mode 100644 pcilib/locking.c
 create mode 100644 pcilib/locking.h

(limited to 'pcilib')

diff --git a/pcilib/CMakeLists.txt b/pcilib/CMakeLists.txt
index c9bf0fb..ebb5cec 100644
--- a/pcilib/CMakeLists.txt
+++ b/pcilib/CMakeLists.txt
@@ -3,8 +3,8 @@ include_directories(
     ${CMAKE_SOURCE_DIR}/pcilib
 )
 
-set(HEADERS pcilib.h pci.h export.h bar.h fifo.h model.h bank.h register.h kmem.h irq.h dma.h event.h plugin.h tools.h error.h debug.h env.h version.h config.h)
-add_library(pcilib SHARED pci.c export.c bar.c fifo.c model.c bank.c register.c kmem.c irq.c dma.c event.c plugin.c tools.c error.c debug.c env.c)
+set(HEADERS pcilib.h pci.h export.h bar.h fifo.h model.h bank.h register.h kmem.h irq.h dma.h event.h plugin.h tools.h error.h debug.h env.h version.h config.h locking.h lock.h)
+add_library(pcilib SHARED pci.c export.c bar.c fifo.c model.c bank.c register.c kmem.c irq.c dma.c event.c plugin.c tools.c error.c debug.c env.c locking.c lock.c)
 target_link_libraries(pcilib dma protocols ${CMAKE_THREAD_LIBS_INIT} ${UFODECODE_LIBRARIES} ${CMAKE_DL_LIBS})
 add_dependencies(pcilib dma protocols)
 
diff --git a/pcilib/kmem.h b/pcilib/kmem.h
index 8299379..65bdf04 100644
--- a/pcilib/kmem.h
+++ b/pcilib/kmem.h
@@ -31,6 +31,7 @@ typedef enum {
     PCILIB_KMEM_USE_DMA_RING = 1,
     PCILIB_KMEM_USE_DMA_PAGES = 2,
     PCILIB_KMEM_USE_SOFTWARE_REGISTERS = 3,
+	PCILIB_KMEM_USE_MUTEXES = 4,
     PCILIB_KMEM_USE_USER = 0x10
 } pcilib_kmem_use_t;
 
diff --git a/pcilib/lock.c b/pcilib/lock.c
new file mode 100644
index 0000000..8715d21
--- /dev/null
+++ b/pcilib/lock.c
@@ -0,0 +1,116 @@
+#define _GNU_SOURCE
+#define _XOPEN_SOURCE 600
+
+#include <string.h>
+#include <stdint.h>
+#include "error.h"
+#include "lock.h"
+#include "pci.h"
+
+/*
+ * this function will take the lock for the semaphore pointed by semId
+ */
+void pcilib_lock(pcilib_lock_t *lock_ctx, pcilib_lock_flags_t flags, ...){
+	int err;
+	struct timespec *time;
+	va_list pa;
+	va_start(pa,flags);
+
+	if(flags & MUTEX_LOCK){
+	err=pthread_mutex_lock(lock_ctx);/**< we try to lock here*/
+	if(errno!=EOWNERDEAD && err!=0) pcilib_error("can't acquire lock %s, error %i\n",(char*)(lock_ctx+sizeof(pcilib_lock_t)),errno);
+	/** if the lock haven't been acquired and errno==EOWNERDEAD, it means the previous application that got the lock crashed, we have to remake the lock "consistent" so*/
+	else if(errno==EOWNERDEAD){
+		pthread_mutex_consistent(lock_ctx);
+		pthread_mutex_lock(lock_ctx);
+		if(err!=0) pcilib_error("can't acquire lock %s, error %i\n",(char*)(lock_ctx+sizeof(pcilib_lock_t)),errno);
+	}
+	}
+	else if(flags & MUTEX_TRYLOCK){
+	err=pthread_mutex_trylock(lock_ctx);/**< we try to lock here*/
+	if(errno!=EOWNERDEAD && err!=0) pcilib_error("can't acquire lock %s, error %i\n",(char*)(lock_ctx+sizeof(pcilib_lock_t)),errno);
+	else if(errno==EOWNERDEAD){
+		pthread_mutex_consistent(lock_ctx);
+		pthread_mutex_lock(lock_ctx);
+		if(err!=0) pcilib_error("can't acquire lock %s, error %i\n",(char*)(lock_ctx+sizeof(pcilib_lock_t)),errno);
+	}
+	}
+	else if(flags & MUTEX_TIMEDLOCK){
+	  time=va_arg(pa,struct timespec*);
+	  va_end(pa);
+	  err=pthread_mutex_timedlock(lock_ctx, time);/**< we try to lock here*/
+	  if(errno!=EOWNERDEAD && err!=0) pcilib_error("can't acquire lock %s, error %i\n",(char*)(lock_ctx+sizeof(pcilib_lock_t)),errno);
+	else if(errno==EOWNERDEAD){
+		pthread_mutex_consistent(lock_ctx);
+		pthread_mutex_timedlock(lock_ctx, time);
+		if(err!=0) pcilib_error("can't acquire lock %s, error %i\n",(char*)(lock_ctx+sizeof(pcilib_lock_t)), errno);
+	}
+	}
+	else pcilib_error("wrong flag for pcilib_lock");
+}
+
+/**
+ * this function will unlock the semaphore pointed by lock_ctx. 
+ */
+void pcilib_unlock(pcilib_lock_t* lock_ctx){
+	int err;
+	if((err=pthread_mutex_unlock(lock_ctx))!=0) pcilib_error("can't unlock semaphore\n");
+}
+
+/**
+ * pcilib_init_lock 
+ * this function initialize a new semaphore in the kernel if it's not already initialized given the key that permits to differentiate semaphores, and then return the integer that points to the semaphore that have been initialized or to a previously already initialized semaphore
+ * @param[out] lock_ctx the pointer that will points to the semaphore for other functions
+ * @param[in] keysem the integer that permits to define to what the semaphore is attached
+ */
+pcilib_lock_t* pcilib_init_lock(pcilib_t *ctx, char* lock_id, ...){
+	int err;
+	pthread_mutexattr_t attr;
+	int i,j;
+	void* addr,*locks_addr;
+	va_list pa;
+	va_start(pa,lock_id);
+	
+	pcilib_lock_init_flags_t flag;
+	flag=va_arg(pa,pcilib_lock_init_flags_t);
+	va_end(pa);
+
+	if(strlen(lock_id)>PCILIB_LOCK_SIZE-sizeof(pcilib_lock_t)) pcilib_error("the entered protocol name is too long");
+	if(((PCILIB_MAX_NUMBER_LOCKS*PCILIB_LOCK_SIZE)%PCILIB_KMEM_PAGE_SIZE)!=0) pcilib_error("PCILIB_MAX_NUMBER_LOCKS*PCILIB_LOCK_SIZE should be a multiple of kmem page size");
+	
+	addr=pcilib_kmem_get_block_ua(ctx,ctx->locks_handle,0);
+	if(flag & LOCK_INIT) pcilib_lock((pcilib_lock_t*)addr,MUTEX_LOCK);
+	/* we search for the given lock if it was already initialized*/
+	for(j=0;j<PCILIB_NUMBER_OF_LOCK_PAGES;j++){
+		i=0;
+		locks_addr=pcilib_kmem_get_block_ua(ctx,ctx->locks_handle,j);
+			while((*(char*)(locks_addr+i*PCILIB_LOCK_SIZE+sizeof(pcilib_lock_t))!=0) && (i<PCILIB_LOCKS_PER_PAGE)){
+		  if(strcmp(lock_id,(char*)(locks_addr+i*PCILIB_LOCK_SIZE+sizeof(pcilib_lock_t)))==0){
+			    return (pcilib_lock_t*)(locks_addr+i*PCILIB_LOCK_SIZE);}
+		 i++;
+		}
+		if(i<PCILIB_LOCKS_PER_PAGE) break;
+	}
+	if(i==PCILIB_LOCKS_PER_PAGE) pcilib_error("no more free space for a new lock\n");
+	/* if not, we create a new one*/
+		if((err= pthread_mutexattr_init(&attr))!=0) pcilib_error("can't initialize semaphore attribute\n");
+		if((err = pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED))!=0) pcilib_error("can't set a shared mutex\n");
+		if((err= pthread_mutexattr_setrobust(&attr,PTHREAD_MUTEX_ROBUST))!=0) pcilib_error("can't set a robust mutex\n");
+		if((err=pthread_mutex_init((pcilib_lock_t*)(locks_addr+i*PCILIB_LOCK_SIZE),&attr))!=0) pcilib_error("can't set attributes to semaphore\n");
+		pthread_mutexattr_destroy(&attr);
+
+		strcpy((char*)(locks_addr+i*PCILIB_LOCK_SIZE+sizeof(pcilib_lock_t)),lock_id);
+
+		if(flag & LOCK_INIT) pcilib_unlock((pcilib_lock_t*)addr);
+		return (pcilib_lock_t*)(locks_addr+i*PCILIB_LOCK_SIZE);
+	
+}
+
+/*
+ * pcilib_lock_free does nothing for now, as we don't want to erase possible locks in the kernel memory (or at any erasing, we should rearrange the locks to have no free space between locks). A thing i think of would be to use chained lists in kernel memory, but how?
+ */
+void pcilib_free_lock(pcilib_lock_t *lock_ctx){
+   int err;
+   if((err=pthread_mutex_destroy(lock_ctx))==-1) pcilib_warning("can't clean lock properly\n");
+   memset((char*)(lock_ctx+sizeof(pcilib_lock_t)),0,PCILIB_LOCK_SIZE-sizeof(pcilib_lock_t));
+ }
diff --git a/pcilib/lock.h b/pcilib/lock.h
new file mode 100644
index 0000000..53da543
--- /dev/null
+++ b/pcilib/lock.h
@@ -0,0 +1,55 @@
+/**
+ * @file lock.h
+ * @skip author zilio nicolas, nicolas.zilio@hotmail.fr
+ * @brief this file is the header file for the functions that implement a semaphore API for the pcitool program, using pthread robust mutexes.
+ * @details the use of pthread robust mutexes  was chosen due to the fact we privilege security over fastness, and that pthread mutexes permits to recover semaphores even with crash ,and that it does not require access to resources that can be easily accessible from extern usage as flock file locking mechanism. A possible other locking mechanism could be the sysv semaphores, but we have a problem of how determine a perfect hash for the init function, and more, benchmarks proves that sysv semaphore aren't that stable and that with more than 10 locks/unlocks, pthread is better in performance, so that should suits more to the final pcitool program. 
+ * We considered that mutex implmentation is enough compared to a reader/writer implementation. If it should change, please go to sysv semaphore.
+ *  Basic explanation on how semaphores here work: a semaphore here is a positive integer, thus that can't go below zero, which is initiated with a value. when a process want access to the critical resource, it asks to decrement the value of the semaphore, and when it has finished, it reincrements it.basically, when the semaphore is equal to zero, any process must have to wait for it to be reincremented before decrementing it again. Here are defined two types of access to the semaphore corresponding to the reader/writer problem : an exclusive lock, which means that no other process than the one who have the resource can access it; a shared lock, which means that other processes who want to access to the resource with a shared lock can have the access, but a concurrent process who want to access the semaphore with an exclusive lock won't be able to.
+ */
+
+#ifndef _LOCK_
+#define _LOCK_
+
+#include "locking.h"
+
+typedef enum{
+  MUTEX_LOCK=1,
+  MUTEX_TRYLOCK=2,
+  MUTEX_TIMEDLOCK=4
+} pcilib_lock_flags_t;
+
+typedef enum{
+  LOCK_INIT=16
+}pcilib_lock_init_flags_t;
+
+
+
+/**
+  * this function initialize a new semaphore in the kernel given a name that corresponds to a specific processus if the semaphore is not already initialized given the name that permits to differentiate semaphores, and then return the integer that points to the semaphore that have been initialized or to a previously already initialized semaphore.
+ * @param[in] ctx the pcilib_t running
+ * @param[in] id_protocol_name the name of the protocol that permits to define to what the semaphore is attached. It suppose that there is one semaphore by protocol, but if it's not the case, create one semaphore by each sub-protocol name.
+ *@return a mutex for the given protocol name
+ */
+pcilib_lock_t* pcilib_init_lock(pcilib_t *ctx,char* lock_id, ...);
+
+/**
+ * this function does nothing for the moment, as we don't want to destroy the locks put in kernel memory. 
+ * @param[in] lock_ctx the pointer that points to the semaphore set.
+ */
+void pcilib_free_lock(pcilib_lock_t *lock_ctx);
+
+/**
+ * this function will take a lock for the mutex pointed by lock_ctx
+ * @param[in] lock_ctx the pointer to the mutex
+ * @param[in] lock_flags define the type of lock wanted : MUTEX_LOCK (normal lock), MUTEX_TRYLOCK (will return if it can't acquire lock), MUTEX_TIMEDLOCK (will wait if it can't acquire lock for a given time, after it returns)
+ * 
+ */
+void pcilib_lock(pcilib_lock_t* lock_ctx,pcilib_lock_flags_t flags, ...);
+
+/**
+  * this function will unlock the semaphore pointed by lock_ctx 
+ * @param[in] lock_ctx the integer that points to the semaphore
+ */
+void pcilib_unlock(pcilib_lock_t* lock_ctx);
+
+#endif /*_LOCK_*/
diff --git a/pcilib/locking.c b/pcilib/locking.c
new file mode 100644
index 0000000..93e6fdd
--- /dev/null
+++ b/pcilib/locking.c
@@ -0,0 +1,74 @@
+#define _XOPEN_SOURCE 700
+
+#include "error.h"
+#include "pci.h"
+#include <sys/file.h>
+#include <string.h>
+#include "lock.h"
+
+/*
+ * this function clean all locks created by the pcitool program
+ */
+void pcilib_clean_all_locks(pcilib_t* ctx){
+int i,j;
+void* addr;
+	i=0;
+	while(i<PCILIB_NUMBER_OF_LOCK_PAGES){
+addr=pcilib_kmem_get_block_ua(ctx,ctx->locks_handle,i);
+for(j=0;j<PCILIB_LOCKS_PER_PAGE;j++)
+	  pcilib_free_lock((pcilib_lock_t*)(addr+i*PCILIB_LOCK_SIZE));
+		i++;
+	}
+
+}
+
+void pcilib_free_locking(pcilib_t* ctx){
+  pcilib_clean_all_locks(ctx);
+  pcilib_free_kernel_memory(ctx,ctx->locks_handle,PCILIB_KMEM_FLAG_REUSE);
+}
+
+/*
+ * this function allocates the kernel memory for the locks for software registers
+ */
+int pcilib_init_locking(pcilib_t* ctx, ...){
+/*for future possible more args
+	va_list pa;
+	va_start(pa,ctx);*/
+	pcilib_kmem_handle_t *handle;
+	int err;
+	pcilib_kmem_reuse_state_t reused;
+	
+	
+	if((err=flock(ctx->handle,LOCK_EX))==-1) pcilib_warning("can't get flock on /dev/fpga0");
+	handle=pcilib_alloc_kernel_memory(ctx,PCILIB_KMEM_TYPE_PAGE,PCILIB_NUMBER_OF_LOCK_PAGES,PCILIB_KMEM_PAGE_SIZE,0,PCILIB_KMEM_USE(PCILIB_KMEM_USE_MUTEXES,0),PCILIB_KMEM_FLAG_REUSE|PCILIB_KMEM_FLAG_PERSISTENT);
+
+	if (!handle) {
+         pcilib_error("Allocation of kernel memory for mutexes has failed");
+         return 1;
+    }
+
+	ctx->locks_handle=handle;
+        reused = pcilib_kmem_is_reused(ctx, handle);
+//#define DEBUG_REUSE
+#ifdef DEBUG_REUSE
+reused=0;
+#endif
+	if ((reused & PCILIB_KMEM_REUSE_REUSED) == 0) {
+	    pcilib_register_t i;
+
+	    if (reused & PCILIB_KMEM_REUSE_PARTIAL) {
+		pcilib_error("Inconsistent software registers are found (only part of required buffers is available)");
+	        pcilib_clean_all_locks(ctx);
+		return 1;
+	    }
+            for(i=0;i<PCILIB_NUMBER_OF_LOCK_PAGES;i++){
+                memset(pcilib_kmem_get_block_ua(ctx,handle,i),0,PCILIB_KMEM_PAGE_SIZE);
+            }
+            pcilib_init_lock(ctx,"pcilib_locking",LOCK_INIT);
+	
+	}
+	    
+	if((err=flock(ctx->handle,LOCK_UN))==-1) pcilib_warning("could not remove lock correctly on /dev/fpga0");
+
+	return 0;
+}
diff --git a/pcilib/locking.h b/pcilib/locking.h
new file mode 100644
index 0000000..f7570f6
--- /dev/null
+++ b/pcilib/locking.h
@@ -0,0 +1,44 @@
+/**
+ * @file lock_global.h
+ * @brief this file is the header file for functions that touch all locks allocated for software registers.
+ * @details for more details about implementation choice, please read the file lock.h
+ */
+#define _XOPEN_SOURCE 700
+
+#ifndef _LOCKING_
+#define _LOCKING_
+
+#include <pthread.h>
+
+/** number of maximum locks*/
+#define PCILIB_MAX_NUMBER_LOCKS 64
+
+/**size of one lock, determine so the size of the protocol_name in the way locks are registered. 40 bytes are necessary for the mutex structure, so we have a protocol name of length LOCK_SIZE-40*/
+#define PCILIB_LOCK_SIZE 128
+
+#define PCILIB_LOCKS_PER_PAGE PCILIB_KMEM_PAGE_SIZE/PCILIB_LOCK_SIZE
+
+#define PCILIB_NUMBER_OF_LOCK_PAGES (PCILIB_MAX_NUMBER_LOCKS*PCILIB_LOCK_SIZE)/PCILIB_KMEM_PAGE_SIZE
+
+
+/**
+* new type to define a semaphore. It was made to differentiate from the library type.
+*/
+typedef pthread_mutex_t pcilib_lock_t;
+
+/**
+ * this function destroy all locks created 
+ *@param[in] ctx, the pcilib_t running
+ */
+void pcilib_clean_all_locks(pcilib_t* ctx);
+
+/**
+* this function initialize the kmem pages containing locks
+*@param[in] ctx the pcilib_t running
+*/
+int pcilib_init_locking(pcilib_t* ctx, ...);
+
+
+void pcilib_free_all_locks(pcilib_t* ctx);
+
+#endif /* _LOCK_GLOBAL_ */
diff --git a/pcilib/pci.c b/pcilib/pci.c
index 3a18ccd..c7b86e8 100644
--- a/pcilib/pci.c
+++ b/pcilib/pci.c
@@ -1,4 +1,5 @@
 //#define PCILIB_FILE_IO
+#define _XOPEN_SOURCE 700
 #define _BSD_SOURCE
 #define _POSIX_C_SOURCE 200809L
 
@@ -24,6 +25,7 @@
 #include "model.h"
 #include "plugin.h"
 #include "bar.h"
+#include "locking.h"
 
 static int pcilib_detect_model(pcilib_t *ctx, const char *model) {
     int i, j;
@@ -159,6 +161,12 @@ pcilib_t *pcilib_open(const char *device, const char *model) {
 	ctx->model_info.protocols = ctx->protocols;
 	ctx->model_info.ranges = ctx->ranges;
 
+	err=pcilib_init_locking(ctx);
+	if (err) {
+	    pcilib_error("Error (%i) initializing locking\n", err);
+	    pcilib_close(ctx);
+	    return NULL;
+	}
 
 	err = pcilib_init_register_banks(ctx);
 	if (err) {
diff --git a/pcilib/pci.h b/pcilib/pci.h
index d176caf..a7b3d50 100644
--- a/pcilib/pci.h
+++ b/pcilib/pci.h
@@ -69,7 +69,7 @@ struct pcilib_s {
     pcilib_register_bank_context_t *bank_ctx[PCILIB_MAX_REGISTER_BANKS];		/**< Contexts for registers banks if required by register protocol */
     pcilib_dma_context_t *dma_ctx;							/**< DMA context */
     pcilib_context_t *event_ctx;							/**< Implmentation context */
-
+	void* locks_handle;			/**< adress of the kernel memory use for locks from user space*/
 #ifdef PCILIB_FILE_IO
     int file_io_handle;
 #endif /* PCILIB_FILE_IO */
-- 
cgit v1.2.3


From fe821c4f1b85d2a2d358da098f85327d41212dc3 Mon Sep 17 00:00:00 2001
From: zilio nicolas <nicolas.zilio@kit.edu>
Date: Tue, 7 Jul 2015 15:38:14 +0200
Subject: modified for last remarks

---
 pcilib/lock.c    | 40 ++++++++++++++++++++++------------------
 pcilib/locking.c |  4 ++--
 2 files changed, 24 insertions(+), 20 deletions(-)

(limited to 'pcilib')

diff --git a/pcilib/lock.c b/pcilib/lock.c
index 8715d21..b99ecfc 100644
--- a/pcilib/lock.c
+++ b/pcilib/lock.c
@@ -6,7 +6,7 @@
 #include "error.h"
 #include "lock.h"
 #include "pci.h"
-
+#include <stdio.h>
 /*
  * this function will take the lock for the semaphore pointed by semId
  */
@@ -18,32 +18,32 @@ void pcilib_lock(pcilib_lock_t *lock_ctx, pcilib_lock_flags_t flags, ...){
 
 	if(flags & MUTEX_LOCK){
 	err=pthread_mutex_lock(lock_ctx);/**< we try to lock here*/
-	if(errno!=EOWNERDEAD && err!=0) pcilib_error("can't acquire lock %s, error %i\n",(char*)(lock_ctx+sizeof(pcilib_lock_t)),errno);
+	if(errno!=EOWNERDEAD && err!=0) pcilib_error("can't acquire lock %s, errno %i",(char*)(lock_ctx+sizeof(pcilib_lock_t)),errno);
 	/** if the lock haven't been acquired and errno==EOWNERDEAD, it means the previous application that got the lock crashed, we have to remake the lock "consistent" so*/
 	else if(errno==EOWNERDEAD){
 		pthread_mutex_consistent(lock_ctx);
 		pthread_mutex_lock(lock_ctx);
-		if(err!=0) pcilib_error("can't acquire lock %s, error %i\n",(char*)(lock_ctx+sizeof(pcilib_lock_t)),errno);
+		if(err!=0) pcilib_error("can't acquire lock %s, errno %i",(char*)(lock_ctx+sizeof(pcilib_lock_t)),errno);
 	}
 	}
 	else if(flags & MUTEX_TRYLOCK){
 	err=pthread_mutex_trylock(lock_ctx);/**< we try to lock here*/
-	if(errno!=EOWNERDEAD && err!=0) pcilib_error("can't acquire lock %s, error %i\n",(char*)(lock_ctx+sizeof(pcilib_lock_t)),errno);
+	if(errno!=EOWNERDEAD && err!=0) pcilib_error("can't acquire lock %s, errno %i",(char*)(lock_ctx+sizeof(pcilib_lock_t)),errno);
 	else if(errno==EOWNERDEAD){
 		pthread_mutex_consistent(lock_ctx);
 		pthread_mutex_lock(lock_ctx);
-		if(err!=0) pcilib_error("can't acquire lock %s, error %i\n",(char*)(lock_ctx+sizeof(pcilib_lock_t)),errno);
+		if(err!=0) pcilib_error("can't acquire lock %s, errno %i",(char*)(lock_ctx+sizeof(pcilib_lock_t)),errno);
 	}
 	}
 	else if(flags & MUTEX_TIMEDLOCK){
 	  time=va_arg(pa,struct timespec*);
 	  va_end(pa);
 	  err=pthread_mutex_timedlock(lock_ctx, time);/**< we try to lock here*/
-	  if(errno!=EOWNERDEAD && err!=0) pcilib_error("can't acquire lock %s, error %i\n",(char*)(lock_ctx+sizeof(pcilib_lock_t)),errno);
+	  if(errno!=EOWNERDEAD && err!=0) pcilib_error("can't acquire lock %s, errni %i",(char*)(lock_ctx+sizeof(pcilib_lock_t)),errno);
 	else if(errno==EOWNERDEAD){
 		pthread_mutex_consistent(lock_ctx);
 		pthread_mutex_timedlock(lock_ctx, time);
-		if(err!=0) pcilib_error("can't acquire lock %s, error %i\n",(char*)(lock_ctx+sizeof(pcilib_lock_t)), errno);
+		if(err!=0) pcilib_error("can't acquire lock %s, errno %i",(char*)(lock_ctx+sizeof(pcilib_lock_t)), errno);
 	}
 	}
 	else pcilib_error("wrong flag for pcilib_lock");
@@ -54,7 +54,7 @@ void pcilib_lock(pcilib_lock_t *lock_ctx, pcilib_lock_flags_t flags, ...){
  */
 void pcilib_unlock(pcilib_lock_t* lock_ctx){
 	int err;
-	if((err=pthread_mutex_unlock(lock_ctx))!=0) pcilib_error("can't unlock semaphore\n");
+	if((err=pthread_mutex_unlock(lock_ctx))!=0) pcilib_error("can't unlock mutex: errno %i",errno);
 }
 
 /**
@@ -71,21 +71,25 @@ pcilib_lock_t* pcilib_init_lock(pcilib_t *ctx, char* lock_id, ...){
 	va_list pa;
 	va_start(pa,lock_id);
 	
+	char* temp;
+	temp=malloc((strlen(lock_id)+strlen("bank_register_"))*sizeof(char));
+	sprintf(temp,"bank_register_%s",lock_id);
+	
 	pcilib_lock_init_flags_t flag;
 	flag=va_arg(pa,pcilib_lock_init_flags_t);
 	va_end(pa);
 
-	if(strlen(lock_id)>PCILIB_LOCK_SIZE-sizeof(pcilib_lock_t)) pcilib_error("the entered protocol name is too long");
+	if(strlen(temp)>PCILIB_LOCK_SIZE-sizeof(pcilib_lock_t)) pcilib_error("the entered protocol name is too long");
 	if(((PCILIB_MAX_NUMBER_LOCKS*PCILIB_LOCK_SIZE)%PCILIB_KMEM_PAGE_SIZE)!=0) pcilib_error("PCILIB_MAX_NUMBER_LOCKS*PCILIB_LOCK_SIZE should be a multiple of kmem page size");
 	
 	addr=pcilib_kmem_get_block_ua(ctx,ctx->locks_handle,0);
-	if(flag & LOCK_INIT) pcilib_lock((pcilib_lock_t*)addr,MUTEX_LOCK);
+	if((flag & LOCK_INIT)==0) pcilib_lock((pcilib_lock_t*)addr,MUTEX_LOCK);
 	/* we search for the given lock if it was already initialized*/
 	for(j=0;j<PCILIB_NUMBER_OF_LOCK_PAGES;j++){
 		i=0;
 		locks_addr=pcilib_kmem_get_block_ua(ctx,ctx->locks_handle,j);
 			while((*(char*)(locks_addr+i*PCILIB_LOCK_SIZE+sizeof(pcilib_lock_t))!=0) && (i<PCILIB_LOCKS_PER_PAGE)){
-		  if(strcmp(lock_id,(char*)(locks_addr+i*PCILIB_LOCK_SIZE+sizeof(pcilib_lock_t)))==0){
+		  if(strcmp(temp,(char*)(locks_addr+i*PCILIB_LOCK_SIZE+sizeof(pcilib_lock_t)))==0){
 			    return (pcilib_lock_t*)(locks_addr+i*PCILIB_LOCK_SIZE);}
 		 i++;
 		}
@@ -93,15 +97,15 @@ pcilib_lock_t* pcilib_init_lock(pcilib_t *ctx, char* lock_id, ...){
 	}
 	if(i==PCILIB_LOCKS_PER_PAGE) pcilib_error("no more free space for a new lock\n");
 	/* if not, we create a new one*/
-		if((err= pthread_mutexattr_init(&attr))!=0) pcilib_error("can't initialize semaphore attribute\n");
-		if((err = pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED))!=0) pcilib_error("can't set a shared mutex\n");
-		if((err= pthread_mutexattr_setrobust(&attr,PTHREAD_MUTEX_ROBUST))!=0) pcilib_error("can't set a robust mutex\n");
-		if((err=pthread_mutex_init((pcilib_lock_t*)(locks_addr+i*PCILIB_LOCK_SIZE),&attr))!=0) pcilib_error("can't set attributes to semaphore\n");
+	if((err= pthread_mutexattr_init(&attr))!=0) pcilib_error("can't initialize mutex attribute, errno %i",errno);
+		if((err = pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED))!=0) pcilib_error("can't set a shared mutex, errno %i", errno);
+		if((err= pthread_mutexattr_setrobust(&attr,PTHREAD_MUTEX_ROBUST))!=0) pcilib_error("can't set a robust mutex, errno: %i",errno);
+		if((err=pthread_mutex_init((pcilib_lock_t*)(locks_addr+i*PCILIB_LOCK_SIZE),&attr))!=0) pcilib_error("can't set attributes to mutex, errno : %i",errno);
 		pthread_mutexattr_destroy(&attr);
 
-		strcpy((char*)(locks_addr+i*PCILIB_LOCK_SIZE+sizeof(pcilib_lock_t)),lock_id);
+		strcpy((char*)(locks_addr+i*PCILIB_LOCK_SIZE+sizeof(pcilib_lock_t)),temp);
 
-		if(flag & LOCK_INIT) pcilib_unlock((pcilib_lock_t*)addr);
+		if((flag & LOCK_INIT)==0) pcilib_unlock((pcilib_lock_t*)addr);
 		return (pcilib_lock_t*)(locks_addr+i*PCILIB_LOCK_SIZE);
 	
 }
@@ -111,6 +115,6 @@ pcilib_lock_t* pcilib_init_lock(pcilib_t *ctx, char* lock_id, ...){
  */
 void pcilib_free_lock(pcilib_lock_t *lock_ctx){
    int err;
-   if((err=pthread_mutex_destroy(lock_ctx))==-1) pcilib_warning("can't clean lock properly\n");
+   if((err=pthread_mutex_destroy(lock_ctx))==-1) pcilib_warning("can't clean lock properly, errno %i",errno);
    memset((char*)(lock_ctx+sizeof(pcilib_lock_t)),0,PCILIB_LOCK_SIZE-sizeof(pcilib_lock_t));
  }
diff --git a/pcilib/locking.c b/pcilib/locking.c
index 93e6fdd..1d6b51e 100644
--- a/pcilib/locking.c
+++ b/pcilib/locking.c
@@ -49,7 +49,7 @@ int pcilib_init_locking(pcilib_t* ctx, ...){
 
 	ctx->locks_handle=handle;
         reused = pcilib_kmem_is_reused(ctx, handle);
-//#define DEBUG_REUSE
+	#define DEBUG_REUSE
 #ifdef DEBUG_REUSE
 reused=0;
 #endif
@@ -57,7 +57,7 @@ reused=0;
 	    pcilib_register_t i;
 
 	    if (reused & PCILIB_KMEM_REUSE_PARTIAL) {
-		pcilib_error("Inconsistent software registers are found (only part of required buffers is available)");
+		pcilib_error("Inconsistent memory for locks was found (only part of required buffers is available)");
 	        pcilib_clean_all_locks(ctx);
 		return 1;
 	    }
-- 
cgit v1.2.3


From edd5ccf24c146915ee475bd223e2ad695520a241 Mon Sep 17 00:00:00 2001
From: zilio nicolas <nicolas.zilio@kit.edu>
Date: Fri, 10 Jul 2015 10:52:06 +0200
Subject: last modification+comments update

---
 pcilib/lock.c    | 32 ++++++++++++++------------------
 pcilib/lock.h    | 25 +++++++++++++++++--------
 pcilib/locking.c | 15 +++++++++++----
 pcilib/locking.h |  7 ++++++-
 4 files changed, 48 insertions(+), 31 deletions(-)

(limited to 'pcilib')

diff --git a/pcilib/lock.c b/pcilib/lock.c
index b99ecfc..b92b11d 100644
--- a/pcilib/lock.c
+++ b/pcilib/lock.c
@@ -7,6 +7,7 @@
 #include "lock.h"
 #include "pci.h"
 #include <stdio.h>
+
 /*
  * this function will take the lock for the semaphore pointed by semId
  */
@@ -21,6 +22,7 @@ void pcilib_lock(pcilib_lock_t *lock_ctx, pcilib_lock_flags_t flags, ...){
 	if(errno!=EOWNERDEAD && err!=0) pcilib_error("can't acquire lock %s, errno %i",(char*)(lock_ctx+sizeof(pcilib_lock_t)),errno);
 	/** if the lock haven't been acquired and errno==EOWNERDEAD, it means the previous application that got the lock crashed, we have to remake the lock "consistent" so*/
 	else if(errno==EOWNERDEAD){
+	  /* one question is "is pthread_mutex_consistent protected in case we call twice it?", it seems to not make any importance in fact regarding man pages, but we have to survey it in future applications*/
 		pthread_mutex_consistent(lock_ctx);
 		pthread_mutex_lock(lock_ctx);
 		if(err!=0) pcilib_error("can't acquire lock %s, errno %i",(char*)(lock_ctx+sizeof(pcilib_lock_t)),errno);
@@ -31,7 +33,7 @@ void pcilib_lock(pcilib_lock_t *lock_ctx, pcilib_lock_flags_t flags, ...){
 	if(errno!=EOWNERDEAD && err!=0) pcilib_error("can't acquire lock %s, errno %i",(char*)(lock_ctx+sizeof(pcilib_lock_t)),errno);
 	else if(errno==EOWNERDEAD){
 		pthread_mutex_consistent(lock_ctx);
-		pthread_mutex_lock(lock_ctx);
+		pthread_mutex_trylock(lock_ctx);
 		if(err!=0) pcilib_error("can't acquire lock %s, errno %i",(char*)(lock_ctx+sizeof(pcilib_lock_t)),errno);
 	}
 	}
@@ -58,43 +60,37 @@ void pcilib_unlock(pcilib_lock_t* lock_ctx){
 }
 
 /**
- * pcilib_init_lock 
  * this function initialize a new semaphore in the kernel if it's not already initialized given the key that permits to differentiate semaphores, and then return the integer that points to the semaphore that have been initialized or to a previously already initialized semaphore
- * @param[out] lock_ctx the pointer that will points to the semaphore for other functions
- * @param[in] keysem the integer that permits to define to what the semaphore is attached
  */
-pcilib_lock_t* pcilib_init_lock(pcilib_t *ctx, char* lock_id, ...){
+pcilib_lock_t* pcilib_init_lock(pcilib_t *ctx, pcilib_lock_init_flags_t flag, char* lock_id, ...){
 	int err;
 	pthread_mutexattr_t attr;
 	int i,j;
 	void* addr,*locks_addr;
+	char buffer[PCILIB_LOCK_SIZE-sizeof(pcilib_lock_t)];
+	/* here lock_id is the format string for vsprintf, the lock name will so be put in adding arguments*/
 	va_list pa;
 	va_start(pa,lock_id);
-	
-	char* temp;
-	temp=malloc((strlen(lock_id)+strlen("bank_register_"))*sizeof(char));
-	sprintf(temp,"bank_register_%s",lock_id);
-	
-	pcilib_lock_init_flags_t flag;
-	flag=va_arg(pa,pcilib_lock_init_flags_t);
+	err=vsprintf(buffer,lock_id,pa);
 	va_end(pa);
 
-	if(strlen(temp)>PCILIB_LOCK_SIZE-sizeof(pcilib_lock_t)) pcilib_error("the entered protocol name is too long");
+	if(err<0) pcilib_error("error in obtaining the lock name");
 	if(((PCILIB_MAX_NUMBER_LOCKS*PCILIB_LOCK_SIZE)%PCILIB_KMEM_PAGE_SIZE)!=0) pcilib_error("PCILIB_MAX_NUMBER_LOCKS*PCILIB_LOCK_SIZE should be a multiple of kmem page size");
 	
 	addr=pcilib_kmem_get_block_ua(ctx,ctx->locks_handle,0);
-	if((flag & LOCK_INIT)==0) pcilib_lock((pcilib_lock_t*)addr,MUTEX_LOCK);
+	if((flag & PCILIB_NO_LOCK)==0) pcilib_lock((pcilib_lock_t*)addr,MUTEX_LOCK);
 	/* we search for the given lock if it was already initialized*/
 	for(j=0;j<PCILIB_NUMBER_OF_LOCK_PAGES;j++){
 		i=0;
 		locks_addr=pcilib_kmem_get_block_ua(ctx,ctx->locks_handle,j);
 			while((*(char*)(locks_addr+i*PCILIB_LOCK_SIZE+sizeof(pcilib_lock_t))!=0) && (i<PCILIB_LOCKS_PER_PAGE)){
-		  if(strcmp(temp,(char*)(locks_addr+i*PCILIB_LOCK_SIZE+sizeof(pcilib_lock_t)))==0){
+		  if(strcmp(buffer,(char*)(locks_addr+i*PCILIB_LOCK_SIZE+sizeof(pcilib_lock_t)))==0){
 			    return (pcilib_lock_t*)(locks_addr+i*PCILIB_LOCK_SIZE);}
 		 i++;
 		}
 		if(i<PCILIB_LOCKS_PER_PAGE) break;
 	}
+	/* the kernel space could be full*/
 	if(i==PCILIB_LOCKS_PER_PAGE) pcilib_error("no more free space for a new lock\n");
 	/* if not, we create a new one*/
 	if((err= pthread_mutexattr_init(&attr))!=0) pcilib_error("can't initialize mutex attribute, errno %i",errno);
@@ -103,15 +99,15 @@ pcilib_lock_t* pcilib_init_lock(pcilib_t *ctx, char* lock_id, ...){
 		if((err=pthread_mutex_init((pcilib_lock_t*)(locks_addr+i*PCILIB_LOCK_SIZE),&attr))!=0) pcilib_error("can't set attributes to mutex, errno : %i",errno);
 		pthread_mutexattr_destroy(&attr);
 
-		strcpy((char*)(locks_addr+i*PCILIB_LOCK_SIZE+sizeof(pcilib_lock_t)),temp);
+		strcpy((char*)(locks_addr+i*PCILIB_LOCK_SIZE+sizeof(pcilib_lock_t)),buffer);
 
-		if((flag & LOCK_INIT)==0) pcilib_unlock((pcilib_lock_t*)addr);
+		if((flag & PCILIB_NO_LOCK)==0) pcilib_unlock((pcilib_lock_t*)addr);
 		return (pcilib_lock_t*)(locks_addr+i*PCILIB_LOCK_SIZE);
 	
 }
 
 /*
- * pcilib_lock_free does nothing for now, as we don't want to erase possible locks in the kernel memory (or at any erasing, we should rearrange the locks to have no free space between locks). A thing i think of would be to use chained lists in kernel memory, but how?
+ * we uninitialize a mutex and set its name to 0 pointed by lock_ctx with this function. setting name to is the real destroying operation, but we need to unitialize the lock to initialize it again after
  */
 void pcilib_free_lock(pcilib_lock_t *lock_ctx){
    int err;
diff --git a/pcilib/lock.h b/pcilib/lock.h
index 53da543..ec69737 100644
--- a/pcilib/lock.h
+++ b/pcilib/lock.h
@@ -5,21 +5,29 @@
  * @details the use of pthread robust mutexes  was chosen due to the fact we privilege security over fastness, and that pthread mutexes permits to recover semaphores even with crash ,and that it does not require access to resources that can be easily accessible from extern usage as flock file locking mechanism. A possible other locking mechanism could be the sysv semaphores, but we have a problem of how determine a perfect hash for the init function, and more, benchmarks proves that sysv semaphore aren't that stable and that with more than 10 locks/unlocks, pthread is better in performance, so that should suits more to the final pcitool program. 
  * We considered that mutex implmentation is enough compared to a reader/writer implementation. If it should change, please go to sysv semaphore.
  *  Basic explanation on how semaphores here work: a semaphore here is a positive integer, thus that can't go below zero, which is initiated with a value. when a process want access to the critical resource, it asks to decrement the value of the semaphore, and when it has finished, it reincrements it.basically, when the semaphore is equal to zero, any process must have to wait for it to be reincremented before decrementing it again. Here are defined two types of access to the semaphore corresponding to the reader/writer problem : an exclusive lock, which means that no other process than the one who have the resource can access it; a shared lock, which means that other processes who want to access to the resource with a shared lock can have the access, but a concurrent process who want to access the semaphore with an exclusive lock won't be able to.
+ * explanation on locks here : here locks are registered in kernel memory, where they are defined by a pthread_mutex_t and a name, which corresponds to a register or processus. The iterations like searching a lock are done on names.
  */
 
 #ifndef _LOCK_
 #define _LOCK_
 
-#include "locking.h"
+#include "lock_global.h"
 
+/**
+ * type that defines possible flags when locking a lock by calling pcilib_lock
+ */
 typedef enum{
   MUTEX_LOCK=1,
   MUTEX_TRYLOCK=2,
   MUTEX_TIMEDLOCK=4
 } pcilib_lock_flags_t;
 
+/**
+ * type that defines flags for the pcilib_init function
+ */
 typedef enum{
-  LOCK_INIT=16
+  PCILIB_LOCK=0,
+  PCILIB_NO_LOCK=16
 }pcilib_lock_init_flags_t;
 
 
@@ -27,27 +35,28 @@ typedef enum{
 /**
   * this function initialize a new semaphore in the kernel given a name that corresponds to a specific processus if the semaphore is not already initialized given the name that permits to differentiate semaphores, and then return the integer that points to the semaphore that have been initialized or to a previously already initialized semaphore.
  * @param[in] ctx the pcilib_t running
- * @param[in] id_protocol_name the name of the protocol that permits to define to what the semaphore is attached. It suppose that there is one semaphore by protocol, but if it's not the case, create one semaphore by each sub-protocol name.
+ * @param [in] flag the flag that let(s us to know if we have to lock during the creation of a new lock
+ * @param[in] lock_id the format string that will contains the supplement args 
  *@return a mutex for the given protocol name
  */
-pcilib_lock_t* pcilib_init_lock(pcilib_t *ctx,char* lock_id, ...);
+pcilib_lock_t* pcilib_init_lock(pcilib_t *ctx, pcilib_lock_init_flags_t flag,char* lock_id, ...);
 
 /**
- * this function does nothing for the moment, as we don't want to destroy the locks put in kernel memory. 
- * @param[in] lock_ctx the pointer that points to the semaphore set.
+ * this function uninitialize a lock in kernel memory and set the corresponding name to 0
+ * @param[in] lock_ctx the pointer that points to the lock.
  */
 void pcilib_free_lock(pcilib_lock_t *lock_ctx);
 
 /**
  * this function will take a lock for the mutex pointed by lock_ctx
  * @param[in] lock_ctx the pointer to the mutex
- * @param[in] lock_flags define the type of lock wanted : MUTEX_LOCK (normal lock), MUTEX_TRYLOCK (will return if it can't acquire lock), MUTEX_TIMEDLOCK (will wait if it can't acquire lock for a given time, after it returns)
+ * @param[in] lock_flags define the type of lock wanted : MUTEX_LOCK (normal lock), MUTEX_TRYLOCK (will return if it can't acquire lock), MUTEX_TIMEDLOCK (will wait if it can't acquire lock for a given time, after it returns) and in this last case, we need to provide a timespec structure as supplementary argument
  * 
  */
 void pcilib_lock(pcilib_lock_t* lock_ctx,pcilib_lock_flags_t flags, ...);
 
 /**
-  * this function will unlock the semaphore pointed by lock_ctx 
+  * this function will unlock the lock pointed by lock_ctx 
  * @param[in] lock_ctx the integer that points to the semaphore
  */
 void pcilib_unlock(pcilib_lock_t* lock_ctx);
diff --git a/pcilib/locking.c b/pcilib/locking.c
index 1d6b51e..cbe9533 100644
--- a/pcilib/locking.c
+++ b/pcilib/locking.c
@@ -7,12 +7,13 @@
 #include "lock.h"
 
 /*
- * this function clean all locks created by the pcitool program
+ * this function destroys all locks without touching at kernel memory directly
  */
 void pcilib_clean_all_locks(pcilib_t* ctx){
 int i,j;
 void* addr;
 	i=0;
+	/* iteration on all locks*/
 	while(i<PCILIB_NUMBER_OF_LOCK_PAGES){
 addr=pcilib_kmem_get_block_ua(ctx,ctx->locks_handle,i);
 for(j=0;j<PCILIB_LOCKS_PER_PAGE;j++)
@@ -22,6 +23,9 @@ for(j=0;j<PCILIB_LOCKS_PER_PAGE;j++)
 
 }
 
+/*
+ * this functions destroy all locks and then free the kernel memory allocated for them
+ */
 void pcilib_free_locking(pcilib_t* ctx){
   pcilib_clean_all_locks(ctx);
   pcilib_free_kernel_memory(ctx,ctx->locks_handle,PCILIB_KMEM_FLAG_REUSE);
@@ -38,8 +42,9 @@ int pcilib_init_locking(pcilib_t* ctx, ...){
 	int err;
 	pcilib_kmem_reuse_state_t reused;
 	
-	
+	/* we flock() to make sure to not have two initialization in the same time (possible long time to init)*/
 	if((err=flock(ctx->handle,LOCK_EX))==-1) pcilib_warning("can't get flock on /dev/fpga0");
+
 	handle=pcilib_alloc_kernel_memory(ctx,PCILIB_KMEM_TYPE_PAGE,PCILIB_NUMBER_OF_LOCK_PAGES,PCILIB_KMEM_PAGE_SIZE,0,PCILIB_KMEM_USE(PCILIB_KMEM_USE_MUTEXES,0),PCILIB_KMEM_FLAG_REUSE|PCILIB_KMEM_FLAG_PERSISTENT);
 
 	if (!handle) {
@@ -49,10 +54,11 @@ int pcilib_init_locking(pcilib_t* ctx, ...){
 
 	ctx->locks_handle=handle;
         reused = pcilib_kmem_is_reused(ctx, handle);
-	#define DEBUG_REUSE
+//#define DEBUG_REUSE
 #ifdef DEBUG_REUSE
 reused=0;
 #endif
+/* verification about the handling memory got, first use or not, and integrity*/
 	if ((reused & PCILIB_KMEM_REUSE_REUSED) == 0) {
 	    pcilib_register_t i;
 
@@ -61,10 +67,11 @@ reused=0;
 	        pcilib_clean_all_locks(ctx);
 		return 1;
 	    }
+	    /* if we get here so this is the first initialization (after some free or new), we so set kernel pages to 0 and initialize then the first lock that will be used when we create other locks*/
             for(i=0;i<PCILIB_NUMBER_OF_LOCK_PAGES;i++){
                 memset(pcilib_kmem_get_block_ua(ctx,handle,i),0,PCILIB_KMEM_PAGE_SIZE);
             }
-            pcilib_init_lock(ctx,"pcilib_locking",LOCK_INIT);
+            pcilib_init_lock(ctx,PCILIB_NO_LOCK,"%s","pcilib_first_locking");
 	
 	}
 	    
diff --git a/pcilib/locking.h b/pcilib/locking.h
index f7570f6..3727380 100644
--- a/pcilib/locking.h
+++ b/pcilib/locking.h
@@ -16,8 +16,10 @@
 /**size of one lock, determine so the size of the protocol_name in the way locks are registered. 40 bytes are necessary for the mutex structure, so we have a protocol name of length LOCK_SIZE-40*/
 #define PCILIB_LOCK_SIZE 128
 
+/** number of locks per page of kernel memory*/
 #define PCILIB_LOCKS_PER_PAGE PCILIB_KMEM_PAGE_SIZE/PCILIB_LOCK_SIZE
 
+/** number of pages allocated for locks in kernel memory*/
 #define PCILIB_NUMBER_OF_LOCK_PAGES (PCILIB_MAX_NUMBER_LOCKS*PCILIB_LOCK_SIZE)/PCILIB_KMEM_PAGE_SIZE
 
 
@@ -38,7 +40,10 @@ void pcilib_clean_all_locks(pcilib_t* ctx);
 */
 int pcilib_init_locking(pcilib_t* ctx, ...);
 
-
+/**
+ * this function destroys all locks and then free the kernel memory allocated for them before
+ * @param[in] ctx the pcilib_t running
+ */
 void pcilib_free_all_locks(pcilib_t* ctx);
 
 #endif /* _LOCK_GLOBAL_ */
-- 
cgit v1.2.3