2006-11-30 21:00:50 +03:00
# ifndef __LIBSRP_H__
# define __LIBSRP_H__
# include <linux/list.h>
2009-12-30 22:21:06 +03:00
# include <linux/kfifo.h>
2006-11-30 21:00:50 +03:00
# include <scsi/scsi_cmnd.h>
# include <scsi/scsi_host.h>
# include <scsi/srp.h>
enum iue_flags {
V_DIOVER ,
V_WRITE ,
V_LINKED ,
V_FLYING ,
} ;
struct srp_buf {
dma_addr_t dma ;
void * buf ;
} ;
struct srp_queue {
void * pool ;
void * items ;
kfifo: move struct kfifo in place
This is a new generic kernel FIFO implementation.
The current kernel fifo API is not very widely used, because it has to
many constrains. Only 17 files in the current 2.6.31-rc5 used it.
FIFO's are like list's a very basic thing and a kfifo API which handles
the most use case would save a lot of development time and memory
resources.
I think this are the reasons why kfifo is not in use:
- The API is to simple, important functions are missing
- A fifo can be only allocated dynamically
- There is a requirement of a spinlock whether you need it or not
- There is no support for data records inside a fifo
So I decided to extend the kfifo in a more generic way without blowing up
the API to much. The new API has the following benefits:
- Generic usage: For kernel internal use and/or device driver.
- Provide an API for the most use case.
- Slim API: The whole API provides 25 functions.
- Linux style habit.
- DECLARE_KFIFO, DEFINE_KFIFO and INIT_KFIFO Macros
- Direct copy_to_user from the fifo and copy_from_user into the fifo.
- The kfifo itself is an in place member of the using data structure, this save an
indirection access and does not waste the kernel allocator.
- Lockless access: if only one reader and one writer is active on the fifo,
which is the common use case, no additional locking is necessary.
- Remove spinlock - give the user the freedom of choice what kind of locking to use if
one is required.
- Ability to handle records. Three type of records are supported:
- Variable length records between 0-255 bytes, with a record size
field of 1 bytes.
- Variable length records between 0-65535 bytes, with a record size
field of 2 bytes.
- Fixed size records, which no record size field.
- Preserve memory resource.
- Performance!
- Easy to use!
This patch:
Since most users want to have the kfifo as part of another object,
reorganize the code to allow including struct kfifo in another data
structure. This requires changing the kfifo_alloc and kfifo_init
prototypes so that we pass an existing kfifo pointer into them. This
patch changes the implementation and all existing users.
[akpm@linux-foundation.org: fix warning]
Signed-off-by: Stefani Seibold <stefani@seibold.net>
Acked-by: Greg Kroah-Hartman <gregkh@suse.de>
Acked-by: Mauro Carvalho Chehab <mchehab@redhat.com>
Acked-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-12-22 01:37:26 +03:00
struct kfifo queue ;
2006-11-30 21:00:50 +03:00
spinlock_t lock ;
} ;
struct srp_target {
struct Scsi_Host * shost ;
struct device * dev ;
spinlock_t lock ;
struct list_head cmd_queue ;
size_t srp_iu_size ;
struct srp_queue iu_queue ;
size_t rx_ring_size ;
struct srp_buf * * rx_ring ;
void * ldata ;
} ;
struct iu_entry {
struct srp_target * target ;
struct list_head ilist ;
dma_addr_t remote_token ;
unsigned long flags ;
struct srp_buf * sbuf ;
} ;
typedef int ( srp_rdma_t ) ( struct scsi_cmnd * , struct scatterlist * , int ,
struct srp_direct_buf * , int ,
enum dma_data_direction , unsigned int ) ;
extern int srp_target_alloc ( struct srp_target * , struct device * , size_t , size_t ) ;
extern void srp_target_free ( struct srp_target * ) ;
extern struct iu_entry * srp_iu_get ( struct srp_target * ) ;
extern void srp_iu_put ( struct iu_entry * ) ;
2007-07-11 10:08:21 +04:00
extern int srp_cmd_queue ( struct Scsi_Host * , struct srp_cmd * , void * , u64 , u64 ) ;
2006-11-30 21:00:50 +03:00
extern int srp_transfer_data ( struct scsi_cmnd * , struct srp_cmd * ,
srp_rdma_t , int , int ) ;
static inline struct srp_target * host_to_srp_target ( struct Scsi_Host * host )
{
return ( struct srp_target * ) host - > hostdata ;
}
static inline int srp_cmd_direction ( struct srp_cmd * cmd )
{
return ( cmd - > buf_fmt > > 4 ) ? DMA_TO_DEVICE : DMA_FROM_DEVICE ;
}
# endif
