fsc_device.c

Go to the documentation of this file.

#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/version.h>
#include <linux/fs.h>
#include <linux/sched.h>
#include <linux/statfs.h>
#include <linux/mm.h>
#include <asm/uaccess.h>
#include <asm/errno.h>
#include <linux/buffer_head.h>
#include <linux/pagemap.h>      /* unlock_page */
#include <linux/proc_fs.h>
#include <asm/atomic.h>


#include "fsc_debug.h"
#include "fsc_device.h"


struct buffer fsc_output_buffer;


struct buffer fsc_input_buffer; 


atomic_t fsc_available = ATOMIC_INIT(1);


struct semaphore fsc_sem; 


struct mutex query_mutex;


int fsc_major = 0;


module_param(fsc_major, int, S_IRUSR);


/* char device functions declarations */
ssize_t fsc_read(struct file *, char *, size_t, loff_t *);
ssize_t fsc_write(struct file *, const char *, size_t, loff_t *);
int fsc_release(struct inode *, struct file *);
int fsc_open(struct inode *, struct file *);


struct file_operations fsc_fops = {
  .read = fsc_read,        
  .write = fsc_write,      
  .open = fsc_open,        
  .release = fsc_release   
};


void fsc_init(void) {
    fsc_output_buffer.length = 0;
    fsc_input_buffer.length = 0;
    init_MUTEX(&fsc_sem);
    mutex_init(&query_mutex);
    init_waitqueue_head(&fsc_output_buffer.deamon_queue);
    init_waitqueue_head(&fsc_output_buffer.kernel_queue);
    init_waitqueue_head(&fsc_input_buffer.deamon_queue);
    init_waitqueue_head(&fsc_input_buffer.kernel_queue);
}


void fsc_fini(void) {
    mutex_destroy(&query_mutex);
}


int fsc_read_procmem(char *buf, char **start, off_t offset, int count, int *eof, void *data) {
                
  *eof=1; /* No further reading after this info print */        
  return sprintf(buf, "FSC input buffer: %s\n"
                     "FSC input buffer length declared: %d\n"
                     "FSC output buffer: %s\n"
                     "FSC output buffer length declared: %d\n",
                      fsc_input_buffer.data, fsc_input_buffer.length, 
                      fsc_output_buffer.data, fsc_output_buffer.length);
}

 
int fsc_open(struct inode *inode, struct file *filp) {
        PDEBUG("fsc_open(%p, %p), major=%d minor=%d\n", inode, filp, 
                        MAJOR(inode->i_rdev), MINOR(inode->i_rdev));
        if (! atomic_dec_and_test (&fsc_available)) {
                atomic_inc(&fsc_available);
                return -EBUSY;
        }
        
        try_module_get(THIS_MODULE);
        return 0;
}


int fsc_release(struct inode *inode, struct file *filp) {
        atomic_inc(&fsc_available);
        PDEBUG("fsc_release(%p, %p), major=%d minor=%d\n", inode, filp, 
                        MAJOR(inode->i_rdev), MINOR(inode->i_rdev));
        module_put(THIS_MODULE);
        return 0;
}


int fsc_waitforempty_output(void) {
        while (fsc_output_buffer.length != 0) {
                up(&fsc_sem);
                PDEBUG("fsc_waitforempty_output (len=%d) - going to sleep\n", fsc_output_buffer.length);
                if (wait_event_interruptible(fsc_output_buffer.kernel_queue, fsc_output_buffer.length == 0)) {
                        /* signal: tell the fs layer to handle it */
                        return -ERESTARTSYS; 
                }
                
                if (signal_pending(current)) {
                        /* signal: tell the fs layer to handle it */
                        return -ERESTARTSYS; 
                }
                
                if (down_interruptible(&fsc_sem)) {
                        /* semaphore: char device in use */
                        return -ERESTARTSYS; 
                }
                
        }
        return 0;
}


int fsc_waitforfull_input(void) {
        while (fsc_input_buffer.length == 0) {
                up(&fsc_sem);
                PDEBUG("fsc_waitforfull_input (len=%d) - going to sleep\n", fsc_input_buffer.length);
                if (wait_event_interruptible(fsc_input_buffer.kernel_queue, fsc_input_buffer.length != 0)) {
                        /* signal: tell the fs layer to handle it */
                        return -ERESTARTSYS; 
                }
                
                if (signal_pending(current)) {
                        /* signal: tell the fs layer to handle it */
                        return -ERESTARTSYS; 
                }
                
                if (down_interruptible(&fsc_sem)) {
                        /* semaphore: char device in use */
                        return -ERESTARTSYS; 
                }
                
        }
        return 0;
}


/* forward declaration */
int __fsc_query__(const char*, const int, char*, int);


int fsc_query(const char * out_buf, const int out_count, char* in_buf, int in_count) {
  static int result;
  mutex_lock(&query_mutex);
  result = __fsc_query__(out_buf, out_count, in_buf, in_count);
  mutex_unlock(&query_mutex);
  return result;
}

int __fsc_query__(const char * out_buf, const int out_count, char* in_buf, int in_count) {
        int i;
        int result;
        int response_len;
        PDEBUG("fsc_query(%s, %d, %s, %d)\n", out_buf, out_count, in_buf, in_count);
        if (down_interruptible(&fsc_sem)) { /* lock the char device internals */
                PDEBUG("fsc_query returning error on semaphore: -ERESTARTSYS\n");
                return -ERESTARTSYS;
        }
        
        result = fsc_waitforempty_output();
        
        /* if error occurs, return it */
        if (result) {
                PDEBUG("fsc_query returning error from waitforempty_output - ERESTARTSYS: %d\n", result);
                /* up called by waitforempty_output() */
                return result; 
        }
        
        if (out_count >= MAX_BUFFER_LENGTH) {   /* just for case */
                up(&fsc_sem);
                return -EINVAL;
        }
        
        /* copy the out_buffer to output_buffer */
        for (i=0; i<out_count; i++) {  
                fsc_output_buffer.data[i] = out_buf[i];
        }
        
        fsc_output_buffer.data[out_count] = '\0';
        fsc_output_buffer.length = out_count; 
        up(&fsc_sem);
        PDEBUG("output buffer filled, waking up sleeping deamon reader\n");
        
        /* the buffer is full, wake up sleaping reader - FS Deamon */
        wake_up_interruptible(&fsc_output_buffer.deamon_queue); 

        /* hold the semaphore lock */
        if (down_interruptible(&fsc_sem)) { 
                PDEBUG("fsc_query returning error on semaphore: -ERESTARTSYS\n");
                return -ERESTARTSYS;
        }
        
        result = fsc_waitforfull_input();
        if (result) {
                PDEBUG("fsc_query returning error from waitforempty_output - ERESTARTSYS: %d\n", result);
                /* up called by waitforempty_output() */
                return result; 
        }
        
        /* copy the input buffer to in_buf */
        for (i = 0; i<fsc_input_buffer.length && i<in_count; i++) {
                /* the leading zero isn't copied, for writing to log add it later */ 
                in_buf[i] = fsc_input_buffer.data[i];   
        }
        
        /* storing number of recieved chars in the response */
        response_len = fsc_input_buffer.length; 
        in_buf[response_len] = '\0';
        /* declare input buffer as empty, for the deamon can fill it again */
        fsc_input_buffer.length = 0; 
        up(&fsc_sem); 
        PDEBUG("input buffer read, waking up sleeping deamon writer\n");
        
        /* the buffer is empty, the FS Deamon writer can be woken up again. */
        wake_up_interruptible(&fsc_input_buffer.deamon_queue); 
        return response_len;
}


ssize_t fsc_write(struct file *filp, const char *buf, size_t count, loff_t *f_pos) {
  PDEBUG("fsc_write(%p, %p,  %d, %lld)\n", filp, buf, (int) count, *f_pos);
  if (count > MAX_BUFFER_LENGTH) {
        return -EINVAL;
  }
  
  /* lock the char device internals */
  if (down_interruptible(&fsc_sem)) { 
    return -ERESTARTSYS;
  }
  
  /* wait for empty input buffer */
  while (fsc_input_buffer.length != 0) { 
    up(&fsc_sem); 
    PDEBUG("attemt for writing, buffer full, going to sleep\n");
    
    /* the user space deamon waits allways in deamon_queue, kernel has got it's own */
    if (wait_event_interruptible(fsc_input_buffer.deamon_queue, fsc_input_buffer.length == 0)) {
      /* signal: tell the fs layer to handle it */      
      return -ERESTARTSYS; 
    }
    
    if (down_interruptible(&fsc_sem)) {
      /* semaphore: char device internals in use */
      return -ERESTARTSYS; 
    }
    
  }
  
  /* buffer is clear, let's write something
   * copy +1 byte for trailing zero - added for debugging printouts 
   */
  if (copy_from_user(fsc_input_buffer.data, buf, count + 1)) {  
        up(&fsc_sem); 
        /* on error release the lock first */
        return -EFAULT;
  }
  
  /* save number of written characters */
  fsc_input_buffer.length = count; 
  up(&fsc_sem);
  PDEBUG("buffer full, waking up sleeping kernel reader\n");
  
  /* the kernel can now read the content of input_buffer */
  wake_up_interruptible(&fsc_input_buffer.kernel_queue); 
  fsc_input_buffer.data[fsc_input_buffer.length] = '\0';
  PDEBUG("db response stored in fsc_input_buffer: '%s'\n", fsc_input_buffer.data);
  
  /* allways all chars written */ 
  return count; 
}


ssize_t fsc_read(struct file *filp, char *buf, size_t count, loff_t *f_pos) {
  int tmp_count;

  PDEBUG("fsc_read(%p, %p, %d, %lld)\n", filp, buf, (int) count, *f_pos);
  if (down_interruptible(&fsc_sem)) {
          return -ERESTARTSYS;
  }
  
  /* wait for non-emtpy output buffer */
  while (fsc_output_buffer.length == 0) { 
    up(&fsc_sem);
    PDEBUG("attemt for reading, buffer empty, going to sleep\n");
    
    /* the user space deamon waits allways in deamon_queue, kernel has got it's own */
    if (wait_event_interruptible(fsc_output_buffer.deamon_queue, fsc_output_buffer.length != 0)) {
      /* signal: tell the fs layer to handle it */
      return -ERESTARTSYS; 
    }
    
    if (down_interruptible(&fsc_sem)) {
      /* otherewise loop, but first reacquire the lock */
      return -ERESTARTSYS;
    }
    
  }
  
  /* User wants less data then present. It generates error, 
   * becouse fsc dont support countinuous reads 
   */
  if (count < fsc_output_buffer.length) {       
        return -EINVAL;
  }
  
  tmp_count = fsc_output_buffer.length;
  fsc_output_buffer.data[fsc_output_buffer.length]='\0';
  
  /* copy +1 byte for trailing zero - added for debugging printouts */
  if (copy_to_user(buf, fsc_output_buffer.data, fsc_output_buffer.length + 1)) { 
        up(&fsc_sem); 
        /* on error release the lock first */
        return -EFAULT;
  }
  
  fsc_output_buffer.length = 0; 
  up(&fsc_sem);
  PDEBUG("buffer empty, waking up sleeping writers\n");
  wake_up_interruptible(&fsc_output_buffer.kernel_queue); 
  
  /* the kernel can now fill the output buffer with commands and data again */
  PDEBUG("db request fetched from fsc_output_buffer: %s\n", fsc_output_buffer.data); 
  return tmp_count;
} 

---