drivers/mcst/mokx/mokx_read_buf.c

   1 #define READ_BUF_DBG 0
   2 #define READ_BUF_DEBUG_MSG(x...)\
   3                 if (READ_BUF_DBG) DEBUG_MSG(x)
   4 #define RD_DBG READ_BUF_DEBUG_MSG
   5
   6 int read_buf(int link, rdma_ioc_parm_t *parm, unsigned int f_flags)
   7 {
   8         rdma_state_link_t *rdma_link;
   9         rdma_pool_buf_t *r_pool_buf;
  10         dev_rdma_sem_t *dev_sem;
  11         struct stat_rdma *pst;
  12         rw_state_p pd;
  13         size_t size;
  14         unsigned long flags, flags_r;
  15         signed long io_timeout = 0;
  16         int ret_time_dwait = 0, int_ac;
  17         int ret = 0;
  18
  19         rdma_link = &rdma_state->rdma_link[link];
  20         r_pool_buf = &rdma_link->read_pool;
  21         pd = &rdma_link->rw_states_d[READER];
  22         pst = &rdma_link->stat_rdma;
  23         size = parm->reqlen;
  24         dev_sem = &pd->dev_rdma_sem;
  25         dev_sem->time_broadcast = 0;
  26
  27         RD_DBG("%s: link: %d size: 0x%016lx\n", __FUNCTION__, link, size);
  28         dev_sem = &pd->dev_rdma_sem;
  29         raw_spin_lock_irqsave(&dev_sem->lock, flags);
  30         event_read(link, READ_1_EVENT, size, dev_sem->num_obmen);
  31         pd->int_ac = 0;
  32         /*
  33          * Check size
  34          */
  35         if (size > r_pool_buf->buf_size) {
  36                 raw_spin_unlock_irqrestore(&dev_sem->lock, flags);
  37                 fix_event(link, READ_BADSIZE_EVENT, size, dev_sem->num_obmen);
  38                 fix_event(link, READ_BADSIZE_EVENT, r_pool_buf->buf_size,
  39                           dev_sem->num_obmen);
  40                 ERROR_MSG("%s: link: %d RDMA_E_SIZE int_ac: %d "
  41                                 "num_obmen: 0x%08x size(0x%016lx) > r_pool_buf->buf_size(0x%016lx)\n",
  42                                 __FUNCTION__, link, pd->int_ac, dev_sem->num_obmen,
  43                                 size, r_pool_buf->buf_size);
  44                 parm->err_no = RDMA_E_SIZE;
  45                 parm->acclen = -1;
  46                 ret = -EMSGSIZE;
  47                 goto exit_read_buf;
  48         }
  49         /*
  50          * If nothing to read
  51          */
  52         raw_spin_lock_irqsave(&pd->lock_rd, flags_r);
  53         if (list_empty(&r_pool_buf->busy_list)) {
  54                 raw_spin_unlock_irqrestore(&pd->lock_rd, flags_r);
  55         if ( f_flags & O_NONBLOCK ) {
  56                 raw_spin_unlock_irqrestore(&dev_sem->lock, flags);
  57                 parm->err_no = RDMA_E_NULL_BUFFER;
  58                 parm->acclen = -1;
  59                 ret = -EAGAIN;
  60                 goto exit_read_buf;
  61         } else {
  62                 /*
  63                  * Set timeout
  64                  */
  65                 if (dev_sem->timeout == 0) {
  66                         io_timeout = IO_TIMEOUT;
  67                 } else  {
  68                         io_timeout = dev_sem->timeout * HZ;
  69                 }
  70                 /*
  71                  * Flag on sleep for rdma_cv_broadcast_rdma. Wait RDC.
  72                  */
  73                 pd->int_ac = 1;
  74                 event_read(link, READ_1_EVENT, pd->int_ac, raw_smp_processor_id());
  75                 ret_time_dwait = wait_for_irq_rdma_sem(dev_sem, io_timeout, link);
  76                 if (dev_sem->irq_count_rdma != 1) {
  77                         if (ev_pr)
  78                                 get_event_rdma(1);
  79                         ERROR_MSG("%s: link: %d MSG Bad irq dev_sem->irq_count_rdma: 0x%08x\n",
  80                                   __FUNCTION__, link, dev_sem->irq_count_rdma);
  81                         dev_sem->irq_count_rdma = 0;
  82                 } else {
  83                         dev_sem->irq_count_rdma = 0;
  84                 }
  85                 RD_DBG("%s: link: %d ret_time_dwait: %d\n", __FUNCTION__,
  86                        link, ret_time_dwait);
  87                 int_ac = pd->int_ac;
  88                 if (ret_time_dwait < 0) {
  89                         pd->int_ac = 0;
  90                         raw_spin_unlock_irqrestore(&dev_sem->lock, flags);
  91                         event_read(link, READ_BAD1_EVENT, ret_time_dwait,
  92                                    dev_sem->num_obmen);
  93                         switch (ret_time_dwait) {
  94                                 case -1:
  95                                         ERROR_MSG("%s: link: %d RDMA_E_READ_TIMEOUT: "
  96                                                         "int_ac: %d num_obmen: 0x%08x\n",
  97                                         __FUNCTION__, link, int_ac,
  98                                                 dev_sem->num_obmen);
  99                                         parm->err_no = RDMA_E_READ_TIMEOUT;
 100                                         ret = -ETIME;
 101                                         break;
 102                                 case -2:
 103                                         ERROR_MSG("%s: link: %d RDMA_E_SIGNAL: "
 104                                                 "int_ac: %d num_obmen: 0x%08x\n",
 105                                                 __FUNCTION__, link, int_ac,
 106                                                 dev_sem->num_obmen);
 107                                         parm->err_no = RDMA_E_SIGNAL;
 108                                         ret = -EINTR;
 109                                         break;
 110                                 default:
 111                                         ERROR_MSG("%s: link: %d RDMA_E_RD_1_ERR: %d\n",
 112                                                 __FUNCTION__, link, -ret_time_dwait);
 113                                         parm->err_no = RDMA_E_RD_1_ERR;
 114                                         ret = -EAGAIN;
 115                         }
 116                         if (ev_pr)
 117                                 get_event_rdma(1);
 118                         goto exit_read_buf;
 119                 }
 120         }
 121         } else
 122                 raw_spin_unlock_irqrestore(&pd->lock_rd, flags_r);
 123         pd->int_ac = 0;
 124         raw_spin_unlock_irqrestore(&dev_sem->lock, flags);
 125         RD_DBG("%s: link: %d size: 0x%016lx READ OK\n", __FUNCTION__, link, size);
 126         parm->err_no = RDMA_E_SUCCESS;
 127         ret = 0;
 128 exit_read_buf:
 129         event_read(link, READ_00_EVENT, ret, dev_sem->num_obmen);
 130         //get_event_rdma(1);
 131         return ret;
 132 }