sync done

Author: HawxChen

assignment03/driver_dev/Makefile

@@ -1,6 +1,6 @@
 NAME = eosi_barrier
 TESTER_NAME = $(NAME)-test
-TESTER_FLAGS = -Wall -g -lpthread -std=c99
+TESTER_FLAGS = -Wall -g -lpthread
 
 IOT_HOME = /opt/iot-devkit/1.7.3/sysroots
 #KDIR := /root/source/galileo/galileo-linux-stable_backup
@@ -26,14 +26,15 @@ $(TESTER_NAME): $(TESTER_NAME).c $(NAME)_user.h $(NAME)_common.h $(NAME)_kernel.
 
 .PHONY: install uninstall dellog reinstall
 install:
-cp -f `pwd`/hc_sr04.ko /lib/modules/3.8.7-yocto-standard/kernel/drivers/hc_sr04/hc_sr04.ko 
-modprobe hc_sr04
+cp -f `pwd`/eosi_barrier.ko /lib/modules/3.8.7-yocto-standard/kernel/drivers/eosi_barrier/eosi_barrier.ko 
+modprobe eosi_barrier
 uninstall:
-modprobe -r hc_sr04
+modprobe -r eosi_barrier
 
 reinstall:
-modprobe -r hc_sr04
-modprobe hc_sr04
+modprobe -r eosi_barrier
+cp -f `pwd`/eosi_barrier.ko /lib/modules/3.8.7-yocto-standard/kernel/drivers/eosi_barrier/eosi_barrier.ko 
+modprobe eosi_barrier
 
 dellog:
 cat /dev/null > /var/log/kern.log

assignment03/driver_dev/eosi_barrier-test.c

@@ -8,6 +8,7 @@
 #include<sys/wait.h>
 #include<sys/types.h>
 #include<errno.h>
+#include<features.h>
 #include"eosi_barrier_user.h"
 static unsigned int sleep_time = 1;
 
@@ -18,18 +19,17 @@ void* pfunction(void* datain) {
  printf("pid: 0x%x, tid: 0x%x\n", (int)getpid(), (unsigned int)pthread_self());
 
 re_cnt:
- if(cnt == 100) return NULL;
+ if(cnt++ == 3) return 0;
+ sleep(1);
  barrier_wait(barrier_id);
- cnt++;
  goto re_cnt;
 
  return NULL;
 }
 
 void* run_barriers(void* datain) {
  int num_threads = *(int*)datain;
- pthread_t tids[num_threads];
- int idx = 0;
+ pthread_t tids[num_threads]; int idx = 0;
  unsigned int barrier_id = 0;
 
  barrier_init(num_threads, &barrier_id);
@@ -45,6 +45,7 @@ void* run_barriers(void* datain) {
  return NULL;
 }
 
+//for official use 
 void fork_run() {
  int t1_num = 5;
  int t2_num = 20;
@@ -57,6 +58,15 @@ void fork_run() {
  pthread_join(t1, NULL);
  pthread_join(t2, NULL);
 }
+
+//for development use
+void dev_run() {
+ pthread_t t1;
+ int t_num = 2;
+ pthread_create(&t1, NULL, run_barriers, &t_num);
+ pthread_join(t1, NULL);
+}
+
 int main(int argc, char*argv[]) {
  if(2 == argc) {
  sleep_time = atoi(argv[1]);
@@ -65,13 +75,17 @@ int main(int argc, char*argv[]) {
  return 0;
  }
 
+ eosi_barrer_fd = open("/dev/eosi_barrier_1", O_RDWR);
  if(0 == fork()) {
  //fork_run();
+ dev_run();
  return 0;
  }
+ sleep(5);
+ puts("--------");
 
  if(0 == fork()) {
- fork_run();
+ //fork_run();
  return 0;
  }
 

assignment03/driver_dev/eosi_barrier.c

@@ -1,4 +1,3 @@
-#include<linux/kernel.h>
 #include<linux/module.h>
 #include<linux/init.h>
 #include<linux/hashtable.h>
@@ -18,6 +17,7 @@
 #include<linux/kthread.h>
 #include<linux/ktime.h>
 #include<linux/sched.h>
+#include<linux/kernel.h>
 #include"eosi_barrier_kernel.h"
 
 static struct file_operations eosi_barrier_fops = {
@@ -39,7 +39,7 @@ static struct miscdevice eosi_barrier_B = {
  .fops = &eosi_barrier_fops,
 };
 
-static LIST_HEAD(barrier_list);
+static LIST_HEAD(tgid_list);
 
 
 struct barrier_struct* get_curr_barrier(struct inode* node) {
@@ -57,7 +57,8 @@ struct barrier_struct* get_curr_barrier(struct inode* node) {
 
 //init
 static int eosi_barrier_open(struct inode* node, struct file* file) {
- printk(KERN_ALERT "eosi_barrier: Open\n");
+ printk(KERN_ALERT "eosi_barrier2: Open\n");
+ printk(KERN_ALERT "eosi_barrier: sizeof(unsigned long):%d sizeof(int):%d\n", sizeof(unsigned long long), sizeof(int));
  printk(KERN_ALERT "eosi_barrier: Open Done\n");
  return 0;
 }
@@ -68,16 +69,141 @@ static int eosi_barrier_release(struct inode* node, struct file* file) {
  printk(KERN_ALERT "eosi_barrier: Release Done\n"); return 0;
 }
 
+barrier_struct* barray[10];
+static unsigned int basic_bid = 0;
+int barrier_init(barrier_info* binfo) {
+ barrier_struct* barrier = NULL;
+
+ printk(KERN_ALERT "barrier_init\n");
+
+ if(0 > binfo->count) return -1;
+ //search tgid linkedlist
+ //if the tgid block does not exist, then allocate the new one tgid block.
+
+ binfo->barrier_id = basic_bid;
+ basic_bid++;
+ barrier = kmalloc(sizeof(barrier_struct), GFP_KERNEL);
+ init_barrier_struct(barrier, binfo->count, binfo->barrier_id);
+
+ //link the corresponding barrier block.
+ barray[basic_bid-1] = barrier;
+
+ printk(KERN_ALERT "barrier_init done\n");
+ return 0;
+}
+
+void printSYNC_start(char* fun, barrier_struct* barrier) {
+ printk(KERN_ALERT "%s: tgid:%d, tid:%d, id:%d, curr(tgid, tid):(%d,%d)\n", fun, barrier->tgid, barrier->tid, barrier->id, task_tgid_vnr(current), task_pid_vnr(current));
+}
+
+void printSYNC_done(char* fun, barrier_struct* barrier) {
+ char s[30];
+ snprintf(s, 30, "%s Done", fun);
+
+ printk(KERN_ALERT "%s: tgid:%d, tid:%d, id:%d, curr (tgid, tid):(%d, %d)\n", s, barrier->tgid, barrier->tid, barrier->id, task_tgid_vnr(current), task_pid_vnr(current));
+
+}
+void wake_up_here (barrier_struct* barrier) {
+ char*s = "wake_up_here";
+
+ printSYNC_start(s, barrier);
+ wake_up_interruptible_all(&(barrier->waitQ));
+ printSYNC_done(s, barrier);
+
+}
+
+void wait_here (barrier_struct* barrier) {
+ char*s = "wait_here";
+ DEFINE_WAIT(wait);
+
+ printSYNC_start(s, barrier);
+
+ prepare_to_wait(&(barrier->waitQ), &wait, TASK_INTERRUPTIBLE);
+ schedule();
+ finish_wait(&(barrier->waitQ), &wait);
+ printSYNC_done(s, barrier);
+
+}
+
+int barrier_wait(unsigned int barrier_id) {
+ barrier_struct* barrier = barray[barrier_id];
+ char*s = "barrier_wait";
+
+ printSYNC_start(s, barrier);
+
+ spin_lock(&(barrier->lock_total));
+
+ while(barrier->total > BARRIER_FLAG) {
+ spin_unlock(&(barrier->lock_total));
+ wait_here(barrier);
+ spin_lock(&(barrier->lock_total));
+ }
+
+ if(BARRIER_FLAG == barrier->total) barrier->total = 0;
+
+ barrier->total++;
+
+ if(barrier->total == barrier->count) {
+ barrier->total += BARRIER_FLAG - 1;
+ wake_up_here(barrier);
+ //spin_unlock(&(barrier->lock_total));
+
+ } else { //sleep here;
+ while(barrier->total < BARRIER_FLAG) {
+ spin_unlock(&(barrier->lock_total));
+ wait_here(barrier);
+ spin_lock(&(barrier->lock_total));
+ }
+
+ barrier->total--;
+
+ if(barrier->total == BARRIER_FLAG) {
+ wake_up_here(barrier);
+ }
+
+ // spin_unlock(&(barrier->lock_total));
+ }
+
+ spin_unlock(&(barrier->lock_total));
+ printSYNC_done(s, barrier);
+ return 0;
+}
+
+int barrier_destroy(unsigned int barrier_id) {
+ char* s = "barrier_destroy";
+ barrier_struct* barrier = barray[barrier_id];
+
+ printSYNC_start(s, barrier);
+
+ spin_lock(&(barrier->lock_total));
+
+ while(barrier->total > BARRIER_FLAG) {
+ spin_unlock(&(barrier->lock_total));
+ wait_here(barrier);
+ spin_lock(&(barrier->lock_total));
+ }
+
+ spin_unlock(&(barrier->lock_total));
+
+ //Recycle HERE//
+
+ printSYNC_done(s, barrier);
+ return 0;
+}
+
 static long eosi_barrier_ioctl(struct file* file, unsigned int cmd, unsigned long arg) {
- int ret;
+ int ret = 0;
 
  printk(KERN_ALERT "ioctl\n");
- switch (arg) {
+ switch (cmd) {
  case BARRIER_INIT:
+ ret = barrier_init((barrier_info*)arg);
  break;
  case BARRIER_WAIT:
+ ret = barrier_wait((unsigned int)arg);
  break;
  case BARRIER_DESTROY:
+ ret = barrier_destroy((unsigned int)arg);
  break;
  default: 
  return -EINVAL;
@@ -95,24 +221,38 @@ static int reg_misc(struct miscdevice* md) {
 
  return error;
 }
+
 static void dereg_misc(struct miscdevice* md) {
  misc_deregister(md);
 }
 
-static void init_barrier_struct(barrier_struct* barrier, int count, int* id) {
+static void init_barrier_struct(barrier_struct* barrier, int count, unsigned int id) {
+ barrier->count = count;
+ barrier->total = BARRIER_FLAG;
+ barrier->id = id;
+ barrier->tgid = task_tgid_vnr(current);
+ barrier->tid = task_pid_vnr(current);
+ spin_lock_init(&(barrier->lock_total));
+ init_waitqueue_head(&(barrier->waitQ));
+}
+
+static void init_per_tgid(per_tgid* each_tgid) {
+ each_tgid->tgid = task_tgid_vnr(current);
 }
+#ifndef _BARRIER_MGMT_
+#endif
 
 static int __init eosi_barrier_init(void) {
  /*!!!!!*/
  //CHECK!!! INIT
- printk(KERN_ALERT "hc_sr04: INIT\n");
+ printk(KERN_ALERT "eosi_barrier: INIT\n");
  if( reg_misc(&eosi_barrier_A) || reg_misc(&eosi_barrier_B) )
  return 0;
 
-// init_hcsr_struct(&hcA, &hc_sr04_A, A_pins, A_pin_str);
-// init_hcsr_struct(&hcB, &hc_sr04_B, B_pins, B_pin_str);
+// init_hcsr_struct(&hcA, &eosi_barrier_A, A_pins, A_pin_str);
+// init_hcsr_struct(&hcB, &eosi_barrier_B, B_pins, B_pin_str);
 
- printk(KERN_ALERT "hc_sr04: INIT DONE\n");
+ printk(KERN_ALERT "eosi_barrier: INIT DONE\n");
  return 0;
 }
 

assignment03/driver_dev/eosi_barrier_common.h

@@ -1,9 +1,12 @@
 #ifndef _HC_SR04_COMMON_H_
 #define _HC_SR04_COMMON_H_
-#define __DEUBG__
 #include<linux/ioctl.h>
 #define BARRIER_W_MAGIC ('B')
 #define BARRIER_INIT _IOW (BARRIER_W_MAGIC, 1, char*)
 #define BARRIER_WAIT _IOR (BARRIER_W_MAGIC, 2, char*)
 #define BARRIER_DESTROY _IOW (BARRIER_W_MAGIC, 3, char*)
+typedef struct barrier_info {
+ int count;
+ unsigned int barrier_id;
+} barrier_info;
 #endif

assignment03/driver_dev/eosi_barrier_kernel.h

@@ -1,19 +1,34 @@
 #ifndef _HC_SR04_KERNEL_H_
 #define _HC_SR04_KERNEL_H_
 
+#define _BARRIER_MGMT_
 #include "eosi_barrier_common.h"
 #include <linux/spinlock.h>
 #include <linux/semaphore.h>
 #include <linux/wait.h>
-static int eosi_barrier_open(struct inode* node, struct file* file);
-static int eosi_barrier_release(struct inode* node, struct file* file);
-static long eosi_barrier_ioctl(struct file* file, unsigned int cmd, unsigned long arg);
+#define BARRIER_FLAG (1ULL<<63)
 
 typedef struct barrier_struct {
- pid_t tgid;
- wait_queue_head_t waitQ;
- struct list_head list;
+ unsigned int id;
+ pid_t tgid;
+ pid_t tid;
+ unsigned long long count;
+ unsigned long long total;
+ spinlock_t lock_total;
+ wait_queue_head_t waitQ;
+ struct list_head list;
 } barrier_struct;
 
-
+typedef struct per_tgid {
+ pid_t tgid;
+ unsigned int bid_count;
+ int barrier_size;
+ barrier_struct barrier_dummy_head;
+ struct list_head list;
+} per_tgid;
+static int eosi_barrier_open(struct inode* node, struct file* file);
+static int eosi_barrier_release(struct inode* node, struct file* file);
+static long eosi_barrier_ioctl(struct file* file, unsigned int cmd, unsigned long arg);
+static void init_barrier_struct(barrier_struct* barrier, int count, unsigned int id);
+static void init_per_tgid(per_tgid* each_tgid);
 #endif

assignment03/driver_dev/eosi_barrier_user.h

@@ -3,10 +3,18 @@
 #include"eosi_barrier_common.h"
 #include <unistd.h>
 #include<sys/ioctl.h>
+int eosi_barrer_fd;
+barrier_info b1info;
+barrier_info b2info;
 int barrier_init(int count, unsigned int* barrier_id) {
+ b1info.count = count;
+ ioctl(eosi_barrer_fd, BARRIER_INIT, (unsigned long)&b1info);
+ *barrier_id = b1info.barrier_id;
  return 0;
 }
+
 int barrier_wait(unsigned int barrier_id) {
+ ioctl(eosi_barrer_fd, BARRIER_WAIT, barrier_id);
  return 0;
 }