2019-05-27 09:55:06 +03:00
/* SPDX-License-Identifier: GPL-2.0-or-later */
2008-12-02 09:32:11 +03:00
/*
* iSCSI over TCP / IP Data - Path lib
*
* Copyright ( C ) 2008 Mike Christie
* Copyright ( C ) 2008 Red Hat , Inc . All rights reserved .
* maintained by open - iscsi @ googlegroups . com
*/
# ifndef LIBISCSI_TCP_H
# define LIBISCSI_TCP_H
# include <scsi/libiscsi.h>
struct iscsi_tcp_conn ;
struct iscsi_segment ;
struct sk_buff ;
2016-01-24 16:19:41 +03:00
struct ahash_request ;
2008-12-02 09:32:11 +03:00
typedef int iscsi_segment_done_fn_t ( struct iscsi_tcp_conn * ,
struct iscsi_segment * ) ;
struct iscsi_segment {
unsigned char * data ;
unsigned int size ;
unsigned int copied ;
unsigned int total_size ;
unsigned int total_copied ;
2016-01-24 16:19:41 +03:00
struct ahash_request * hash ;
2009-01-11 06:06:07 +03:00
unsigned char padbuf [ ISCSI_PAD_LEN ] ;
2008-12-02 09:32:11 +03:00
unsigned char recv_digest [ ISCSI_DIGEST_SIZE ] ;
unsigned char digest [ ISCSI_DIGEST_SIZE ] ;
unsigned int digest_len ;
struct scatterlist * sg ;
void * sg_mapped ;
unsigned int sg_offset ;
2011-03-18 00:22:17 +03:00
bool atomic_mapped ;
2008-12-02 09:32:11 +03:00
iscsi_segment_done_fn_t * done ;
} ;
2011-03-31 05:57:33 +04:00
/* Socket connection receive helper */
2008-12-02 09:32:11 +03:00
struct iscsi_tcp_recv {
struct iscsi_hdr * hdr ;
struct iscsi_segment segment ;
/* Allocate buffer for BHS + AHS */
uint32_t hdr_buf [ 64 ] ;
/* copied and flipped values */
int datalen ;
} ;
struct iscsi_tcp_conn {
struct iscsi_conn * iscsi_conn ;
void * dd_data ;
int stop_stage ; /* conn_stop() flag: *
* stop to recover , *
* stop to terminate */
/* control data */
struct iscsi_tcp_recv in ; /* TCP receive context */
/* CRC32C (Rx) LLD should set this is they do not offload */
2016-01-24 16:19:41 +03:00
struct ahash_request * rx_hash ;
2008-12-02 09:32:11 +03:00
} ;
struct iscsi_tcp_task {
uint32_t exp_datasn ; /* expected target's R2TSN/DataSN */
int data_offset ;
struct iscsi_r2t_info * r2t ; /* in progress solict R2T */
struct iscsi_pool r2tpool ;
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 r2tqueue ;
2008-12-02 09:32:11 +03:00
void * dd_data ;
[SCSI] libiscsi: Reduce locking contention in fast path
Replace the session lock with two locks, a forward lock and
a backwards lock named frwd_lock and back_lock respectively.
The forward lock protects resources that change while sending a
request to the target, such as cmdsn, queued_cmdsn, and allocating
task from the commands' pool with kfifo_out.
The backward lock protects resources that change while processing
a response or in error path, such as cmdsn_exp, cmdsn_max, and
returning tasks to the commands' pool with kfifo_in.
Under a steady state fast-path situation, that is when one
or more processes/threads submit IO to an iscsi device and
a single kernel upcall (e.g softirq) is dealing with processing
of responses without errors, this patch eliminates the contention
between the queuecommand()/request response/scsi_done() flows
associated with iscsi sessions.
Between the forward and the backward locks exists a strict locking
hierarchy. The mutual exclusion zone protected by the forward lock can
enclose the mutual exclusion zone protected by the backward lock but not
vice versa.
For example, in iscsi_conn_teardown or in iscsi_xmit_data when there is
a failure and __iscsi_put_task is called, the backward lock is taken while
the forward lock is still taken. On the other hand, if in the RX path a nop
is to be sent, for example in iscsi_handle_reject or __iscsi_complete_pdu
than the forward lock is released and the backward lock is taken for the
duration of iscsi_send_nopout, later the backward lock is released and the
forward lock is retaken.
libiscsi_tcp uses two kernel fifos the r2t pool and the r2t queue.
The insertion and deletion from these queues didn't corespond to the
assumption taken by the new forward/backwards session locking paradigm.
That is, in iscsi_tcp_clenup_task which belongs to the RX (backwards)
path, r2t is taken out from r2t queue and inserted to the r2t pool.
In iscsi_tcp_get_curr_r2t which belong to the TX (forward) path, r2t
is also inserted to the r2t pool and another r2t is pulled from r2t
queue.
Only in iscsi_tcp_r2t_rsp which is called in the RX path but can requeue
to the TX path, r2t is taken from the r2t pool and inserted to the r2t
queue.
In order to cope with this situation, two spin locks were added,
pool2queue and queue2pool. The former protects extracting from the
r2t pool and inserting to the r2t queue, and the later protects the
extracing from the r2t queue and inserting to the r2t pool.
Signed-off-by: Shlomo Pongratz <shlomop@mellanox.com>
Signed-off-by: Or Gerlitz <ogerlitz@mellanox.com>
[minor fix up to apply cleanly and compile fix]
Signed-off-by: Mike Christie <michaelc@cs.wisc.edu>
Signed-off-by: James Bottomley <JBottomley@Parallels.com>
2014-02-07 10:41:38 +04:00
spinlock_t pool2queue ;
spinlock_t queue2pool ;
2008-12-02 09:32:11 +03:00
} ;
enum {
ISCSI_TCP_SEGMENT_DONE , /* curr seg has been processed */
ISCSI_TCP_SKB_DONE , /* skb is out of data */
ISCSI_TCP_CONN_ERR , /* iscsi layer has fired a conn err */
ISCSI_TCP_SUSPENDED , /* conn is suspended */
} ;
extern void iscsi_tcp_hdr_recv_prep ( struct iscsi_tcp_conn * tcp_conn ) ;
extern int iscsi_tcp_recv_skb ( struct iscsi_conn * conn , struct sk_buff * skb ,
unsigned int offset , bool offloaded , int * status ) ;
extern void iscsi_tcp_cleanup_task ( struct iscsi_task * task ) ;
extern int iscsi_tcp_task_init ( struct iscsi_task * task ) ;
extern int iscsi_tcp_task_xmit ( struct iscsi_task * task ) ;
/* segment helpers */
extern int iscsi_tcp_recv_segment_is_hdr ( struct iscsi_tcp_conn * tcp_conn ) ;
2008-12-02 09:32:16 +03:00
extern int iscsi_tcp_segment_done ( struct iscsi_tcp_conn * tcp_conn ,
struct iscsi_segment * segment , int recv ,
2008-12-02 09:32:11 +03:00
unsigned copied ) ;
extern void iscsi_tcp_segment_unmap ( struct iscsi_segment * segment ) ;
extern void iscsi_segment_init_linear ( struct iscsi_segment * segment ,
void * data , size_t size ,
iscsi_segment_done_fn_t * done ,
2016-01-24 16:19:41 +03:00
struct ahash_request * hash ) ;
2008-12-02 09:32:11 +03:00
extern int
iscsi_segment_seek_sg ( struct iscsi_segment * segment ,
struct scatterlist * sg_list , unsigned int sg_count ,
unsigned int offset , size_t size ,
2016-01-24 16:19:41 +03:00
iscsi_segment_done_fn_t * done ,
struct ahash_request * hash ) ;
2008-12-02 09:32:11 +03:00
/* digest helpers */
2016-01-24 16:19:41 +03:00
extern void iscsi_tcp_dgst_header ( struct ahash_request * hash , const void * hdr ,
2008-12-02 09:32:11 +03:00
size_t hdrlen ,
unsigned char digest [ ISCSI_DIGEST_SIZE ] ) ;
extern struct iscsi_cls_conn *
iscsi_tcp_conn_setup ( struct iscsi_cls_session * cls_session , int dd_data_size ,
uint32_t conn_idx ) ;
extern void iscsi_tcp_conn_teardown ( struct iscsi_cls_conn * cls_conn ) ;
/* misc helpers */
extern int iscsi_tcp_r2tpool_alloc ( struct iscsi_session * session ) ;
extern void iscsi_tcp_r2tpool_free ( struct iscsi_session * session ) ;
2012-01-27 07:13:10 +04:00
extern int iscsi_tcp_set_max_r2t ( struct iscsi_conn * conn , char * buf ) ;
2008-12-02 09:32:11 +03:00
extern void iscsi_tcp_conn_get_stats ( struct iscsi_cls_conn * cls_conn ,
struct iscsi_stats * stats ) ;
# endif /* LIBISCSI_TCP_H */
