iscsi tools: fix iscsiadm return value on failed login
[open-iscsi.git] / kernel / 2.6.14-23_compat.patch
blob8936615869aeb3e9973b77746fa4fcf691a8a757
1 diff --git a/iscsi_tcp.c b/iscsi_tcp.c
2 index 2a401b9..13636d4 100644
3 --- a/iscsi_tcp.c
4 +++ b/iscsi_tcp.c
5 @@ -43,6 +43,7 @@
6 #include <scsi/scsi.h>
7 #include "scsi_transport_iscsi.h"
9 +#include "open_iscsi_compat.h"
10 #include "iscsi_tcp.h"
12 MODULE_AUTHOR("Mike Christie <michaelc@cs.wisc.edu>, "
13 @@ -480,10 +481,9 @@ static int iscsi_sw_tcp_pdu_init(struct iscsi_task *task,
14 if (!task->sc)
15 iscsi_sw_tcp_send_linear_data_prep(conn, task->data, count);
16 else {
17 - struct scsi_data_buffer *sdb = scsi_out(task->sc);
19 - err = iscsi_sw_tcp_send_data_prep(conn, sdb->table.sgl,
20 - sdb->table.nents, offset,
21 + err = iscsi_sw_tcp_send_data_prep(conn, scsi_sglist(task->sc),
22 + scsi_sg_count(task->sc), offset,
23 count);
26 @@ -860,12 +860,6 @@ static void iscsi_sw_tcp_session_destroy(struct iscsi_cls_session *cls_session)
27 iscsi_host_free(shost);
30 -static int iscsi_sw_tcp_slave_alloc(struct scsi_device *sdev)
32 - set_bit(QUEUE_FLAG_BIDI, &sdev->request_queue->queue_flags);
33 - return 0;
36 static int iscsi_sw_tcp_slave_configure(struct scsi_device *sdev)
38 blk_queue_bounce_limit(sdev->request_queue, BLK_BOUNCE_ANY);
39 @@ -883,10 +877,9 @@ static struct scsi_host_template iscsi_sw_tcp_sht = {
40 .max_sectors = 0xFFFF,
41 .cmd_per_lun = ISCSI_DEF_CMD_PER_LUN,
42 .eh_abort_handler = iscsi_eh_abort,
43 + .eh_host_reset_handler = iscsi_eh_recover_target,
44 .eh_device_reset_handler= iscsi_eh_device_reset,
45 - .eh_target_reset_handler = iscsi_eh_recover_target,
46 .use_clustering = DISABLE_CLUSTERING,
47 - .slave_alloc = iscsi_sw_tcp_slave_alloc,
48 .slave_configure = iscsi_sw_tcp_slave_configure,
49 .target_alloc = iscsi_target_alloc,
50 .proc_name = "iscsi_tcp",
51 diff --git a/libiscsi.c b/libiscsi.c
52 index 59e3a5f..ee9716e 100644
53 --- a/libiscsi.c
54 +++ b/libiscsi.c
55 @@ -24,7 +24,10 @@
56 #include <linux/types.h>
57 #include <linux/kfifo.h>
58 #include <linux/delay.h>
59 +#include <linux/version.h>
60 +#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,19)
61 #include <linux/log2.h>
62 +#endif
63 #include <linux/slab.h>
64 #include <asm/unaligned.h>
65 #include <net/tcp.h>
66 @@ -39,6 +42,8 @@
67 #include "scsi_transport_iscsi.h"
68 #include "libiscsi.h"
70 +#include "open_iscsi_compat.h"
72 static int iscsi_dbg_lib_conn;
73 module_param_named(debug_libiscsi_conn, iscsi_dbg_lib_conn, int,
74 S_IRUGO | S_IWUSR);
75 @@ -256,7 +261,7 @@ static int iscsi_prep_bidi_ahs(struct iscsi_task *task)
76 sizeof(rlen_ahdr->reserved));
77 rlen_ahdr->ahstype = ISCSI_AHSTYPE_RLENGTH;
78 rlen_ahdr->reserved = 0;
79 - rlen_ahdr->read_length = cpu_to_be32(scsi_in(sc)->length);
80 + rlen_ahdr->read_length = cpu_to_be32(scsi_bufflen(sc));
82 ISCSI_DBG_SESSION(task->conn->session,
83 "bidi-in rlen_ahdr->read_length(%d) "
84 @@ -411,7 +416,7 @@ static int iscsi_prep_scsi_cmd_pdu(struct iscsi_task *task)
85 return rc;
87 if (sc->sc_data_direction == DMA_TO_DEVICE) {
88 - unsigned out_len = scsi_out(sc)->length;
89 + unsigned out_len = scsi_bufflen(sc);
90 struct iscsi_r2t_info *r2t = &task->unsol_r2t;
92 hdr->data_length = cpu_to_be32(out_len);
93 @@ -457,7 +462,7 @@ static int iscsi_prep_scsi_cmd_pdu(struct iscsi_task *task)
94 } else {
95 hdr->flags |= ISCSI_FLAG_CMD_FINAL;
96 zero_data(hdr->dlength);
97 - hdr->data_length = cpu_to_be32(scsi_in(sc)->length);
98 + hdr->data_length = cpu_to_be32(scsi_bufflen(sc));
100 if (sc->sc_data_direction == DMA_FROM_DEVICE)
101 hdr->flags |= ISCSI_FLAG_CMD_READ;
102 @@ -486,7 +491,7 @@ static int iscsi_prep_scsi_cmd_pdu(struct iscsi_task *task)
103 sc->sc_data_direction == DMA_TO_DEVICE ?
104 "write" : "read", conn->id, sc, sc->cmnd[0],
105 task->itt, scsi_bufflen(sc),
106 - scsi_bidi_cmnd(sc) ? scsi_in(sc)->length : 0,
107 + scsi_bidi_cmnd(sc) ? scsi_bufflen(sc) : 0,
108 session->cmdsn,
109 session->max_cmdsn - session->exp_cmdsn + 1);
110 return 0;
111 @@ -518,7 +523,7 @@ static void iscsi_free_task(struct iscsi_task *task)
112 if (conn->login_task == task)
113 return;
115 - kfifo_in(&session->cmdpool.queue, (void*)&task, sizeof(void*));
116 + __kfifo_put(session->cmdpool.queue, (void*)&task, sizeof(void*));
118 if (sc) {
119 task->sc = NULL;
120 @@ -648,12 +653,7 @@ static void fail_scsi_task(struct iscsi_task *task, int err)
121 state = ISCSI_TASK_ABRT_TMF;
123 sc->result = err << 16;
124 - if (!scsi_bidi_cmnd(sc))
125 - scsi_set_resid(sc, scsi_bufflen(sc));
126 - else {
127 - scsi_out(sc)->resid = scsi_out(sc)->length;
128 - scsi_in(sc)->resid = scsi_in(sc)->length;
130 + scsi_set_resid(sc, scsi_bufflen(sc));
132 iscsi_complete_task(task, state);
134 @@ -738,7 +738,7 @@ __iscsi_conn_send_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
135 BUG_ON(conn->c_stage == ISCSI_CONN_INITIAL_STAGE);
136 BUG_ON(conn->c_stage == ISCSI_CONN_STOPPED);
138 - if (!kfifo_out(&session->cmdpool.queue,
139 + if (!__kfifo_get(session->cmdpool.queue,
140 (void*)&task, sizeof(void*)))
141 return NULL;
143 @@ -853,7 +853,7 @@ invalid_datalen:
144 goto out;
147 - senselen = get_unaligned_be16(data);
148 + senselen = be16_to_cpu(get_unaligned((__be16 *) data));
149 if (datalen < senselen)
150 goto invalid_datalen;
152 @@ -870,8 +870,8 @@ invalid_datalen:
154 if (scsi_bidi_cmnd(sc) && res_count > 0 &&
155 (rhdr->flags & ISCSI_FLAG_CMD_BIDI_OVERFLOW ||
156 - res_count <= scsi_in(sc)->length))
157 - scsi_in(sc)->resid = res_count;
158 + res_count <= scsi_bufflen(sc)))
159 + scsi_set_resid(sc, res_count);
160 else
161 sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status;
163 @@ -920,8 +920,8 @@ iscsi_data_in_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
165 if (res_count > 0 &&
166 (rhdr->flags & ISCSI_FLAG_CMD_OVERFLOW ||
167 - res_count <= scsi_in(sc)->length))
168 - scsi_in(sc)->resid = res_count;
169 + res_count <= scsi_bufflen(sc)))
170 + scsi_set_resid(sc, res_count);
171 else
172 sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status;
174 @@ -1568,7 +1568,7 @@ static inline struct iscsi_task *iscsi_alloc_task(struct iscsi_conn *conn,
176 struct iscsi_task *task;
178 - if (!kfifo_out(&conn->session->cmdpool.queue,
179 + if (!__kfifo_get(conn->session->cmdpool.queue,
180 (void *) &task, sizeof(void *)))
181 return NULL;
183 @@ -1717,7 +1717,11 @@ reject:
184 ISCSI_DBG_SESSION(session, "cmd 0x%x rejected (%d)\n",
185 sc->cmnd[0], reason);
186 spin_lock(host->host_lock);
187 +#if (defined RHELC1) || (defined SLEC1)
188 + return SCSI_MLQUEUE_DEVICE_BUSY;
189 +#else
190 return SCSI_MLQUEUE_TARGET_BUSY;
191 +#endif
193 prepd_fault:
194 sc->scsi_done = NULL;
195 @@ -1726,33 +1730,16 @@ fault:
196 spin_unlock(&session->lock);
197 ISCSI_DBG_SESSION(session, "iscsi: cmd 0x%x is not queued (%d)\n",
198 sc->cmnd[0], reason);
199 - if (!scsi_bidi_cmnd(sc))
200 - scsi_set_resid(sc, scsi_bufflen(sc));
201 - else {
202 - scsi_out(sc)->resid = scsi_out(sc)->length;
203 - scsi_in(sc)->resid = scsi_in(sc)->length;
205 + scsi_set_resid(sc, scsi_bufflen(sc));
206 done(sc);
207 spin_lock(host->host_lock);
208 return 0;
210 EXPORT_SYMBOL_GPL(iscsi_queuecommand);
212 -int iscsi_change_queue_depth(struct scsi_device *sdev, int depth, int reason)
213 +int iscsi_change_queue_depth(struct scsi_device *sdev, int depth)
215 - switch (reason) {
216 - case SCSI_QDEPTH_DEFAULT:
217 - scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth);
218 - break;
219 - case SCSI_QDEPTH_QFULL:
220 - scsi_track_queue_full(sdev, depth);
221 - break;
222 - case SCSI_QDEPTH_RAMP_UP:
223 - scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth);
224 - break;
225 - default:
226 - return -EOPNOTSUPP;
228 + scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth);
229 return sdev->queue_depth;
231 EXPORT_SYMBOL_GPL(iscsi_change_queue_depth);
232 @@ -2524,7 +2511,12 @@ iscsi_pool_init(struct iscsi_pool *q, int max, void ***items, int item_size)
233 if (q->pool == NULL)
234 return -ENOMEM;
236 - kfifo_init(&q->queue, (void*)q->pool, max * sizeof(void*));
237 + q->queue = kfifo_init((void*)q->pool, max * sizeof(void*),
238 + GFP_KERNEL, NULL);
239 + if (IS_ERR(q->queue)) {
240 + q->queue = NULL;
241 + goto enomem;
244 for (i = 0; i < max; i++) {
245 q->pool[i] = kzalloc(item_size, GFP_KERNEL);
246 @@ -2532,7 +2524,7 @@ iscsi_pool_init(struct iscsi_pool *q, int max, void ***items, int item_size)
247 q->max = i;
248 goto enomem;
250 - kfifo_in(&q->queue, (void*)&q->pool[i], sizeof(void*));
251 + __kfifo_put(q->queue, (void*)&q->pool[i], sizeof(void*));
254 if (items) {
255 @@ -2555,6 +2547,7 @@ void iscsi_pool_free(struct iscsi_pool *q)
256 for (i = 0; i < q->max; i++)
257 kfree(q->pool[i]);
258 kfree(q->pool);
259 + kfree(q->queue);
261 EXPORT_SYMBOL_GPL(iscsi_pool_free);
263 @@ -2882,7 +2875,7 @@ iscsi_conn_setup(struct iscsi_cls_session *cls_session, int dd_size,
265 /* allocate login_task used for the login/text sequences */
266 spin_lock_bh(&session->lock);
267 - if (!kfifo_out(&session->cmdpool.queue,
268 + if (!__kfifo_get(session->cmdpool.queue,
269 (void*)&conn->login_task,
270 sizeof(void*))) {
271 spin_unlock_bh(&session->lock);
272 @@ -2902,7 +2895,7 @@ iscsi_conn_setup(struct iscsi_cls_session *cls_session, int dd_size,
273 return cls_conn;
275 login_task_data_alloc_fail:
276 - kfifo_in(&session->cmdpool.queue, (void*)&conn->login_task,
277 + __kfifo_put(session->cmdpool.queue, (void*)&conn->login_task,
278 sizeof(void*));
279 login_task_alloc_fail:
280 iscsi_destroy_conn(cls_conn);
281 @@ -2965,7 +2958,7 @@ void iscsi_conn_teardown(struct iscsi_cls_conn *cls_conn)
282 free_pages((unsigned long) conn->data,
283 get_order(ISCSI_DEF_MAX_RECV_SEG_LEN));
284 kfree(conn->persistent_address);
285 - kfifo_in(&session->cmdpool.queue, (void*)&conn->login_task,
286 + __kfifo_put(session->cmdpool.queue, (void*)&conn->login_task,
287 sizeof(void*));
288 if (session->leadconn == conn)
289 session->leadconn = NULL;
290 diff --git a/libiscsi.h b/libiscsi.h
291 index 0563539..4be9333 100644
292 --- a/libiscsi.h
293 +++ b/libiscsi.h
294 @@ -231,7 +231,7 @@ struct iscsi_conn {
297 struct iscsi_pool {
298 - struct kfifo queue; /* FIFO Queue */
299 + struct kfifo *queue; /* FIFO Queue */
300 void **pool; /* Pool of elements */
301 int max; /* Max number of elements */
303 @@ -334,8 +334,7 @@ struct iscsi_host {
305 * scsi host template
307 -extern int iscsi_change_queue_depth(struct scsi_device *sdev, int depth,
308 - int reason);
309 +extern int iscsi_change_queue_depth(struct scsi_device *sdev, int depth);
310 extern int iscsi_eh_abort(struct scsi_cmnd *sc);
311 extern int iscsi_eh_recover_target(struct scsi_cmnd *sc);
312 extern int iscsi_eh_session_reset(struct scsi_cmnd *sc);
313 diff --git a/libiscsi_tcp.c b/libiscsi_tcp.c
314 index 1122de4..c590df2 100644
315 --- a/libiscsi_tcp.c
316 +++ b/libiscsi_tcp.c
317 @@ -361,6 +361,17 @@ iscsi_segment_seek_sg(struct iscsi_segment *segment,
318 struct scatterlist *sg;
319 unsigned int i;
321 + /*
322 + * older kernels could send use_sg=0 for commands like sgio
323 + * or scsi-ml commands.
324 + */
326 + if (!sg_count) {
327 + iscsi_segment_init_linear(segment, (void *)sg_list + offset,
328 + size, done, hash);
329 + return 0;
332 __iscsi_segment_init(segment, size, done, hash);
333 for_each_sg(sg_list, sg, sg_count, i) {
334 if (offset < sg->length) {
335 @@ -446,15 +457,15 @@ void iscsi_tcp_cleanup_task(struct iscsi_task *task)
336 return;
338 /* flush task's r2t queues */
339 - while (kfifo_out(&tcp_task->r2tqueue, (void*)&r2t, sizeof(void*))) {
340 - kfifo_in(&tcp_task->r2tpool.queue, (void*)&r2t,
341 + while (__kfifo_get(tcp_task->r2tqueue, (void*)&r2t, sizeof(void*))) {
342 + __kfifo_put(tcp_task->r2tpool.queue, (void*)&r2t,
343 sizeof(void*));
344 ISCSI_DBG_TCP(task->conn, "pending r2t dropped\n");
347 r2t = tcp_task->r2t;
348 if (r2t != NULL) {
349 - kfifo_in(&tcp_task->r2tpool.queue, (void*)&r2t,
350 + __kfifo_put(tcp_task->r2tpool.queue, (void*)&r2t,
351 sizeof(void*));
352 tcp_task->r2t = NULL;
354 @@ -472,7 +483,7 @@ static int iscsi_tcp_data_in(struct iscsi_conn *conn, struct iscsi_task *task)
355 struct iscsi_tcp_task *tcp_task = task->dd_data;
356 struct iscsi_data_rsp *rhdr = (struct iscsi_data_rsp *)tcp_conn->in.hdr;
357 int datasn = be32_to_cpu(rhdr->datasn);
358 - unsigned total_in_length = scsi_in(task->sc)->length;
359 + unsigned total_in_length = scsi_bufflen(task->sc);
362 * lib iscsi will update this in the completion handling if there
363 @@ -542,7 +553,7 @@ static int iscsi_tcp_r2t_rsp(struct iscsi_conn *conn, struct iscsi_task *task)
364 return 0;
367 - rc = kfifo_out(&tcp_task->r2tpool.queue, (void*)&r2t, sizeof(void*));
368 + rc = __kfifo_get(tcp_task->r2tpool.queue, (void*)&r2t, sizeof(void*));
369 if (!rc) {
370 iscsi_conn_printk(KERN_ERR, conn, "Could not allocate R2T. "
371 "Target has sent more R2Ts than it "
372 @@ -555,7 +566,7 @@ static int iscsi_tcp_r2t_rsp(struct iscsi_conn *conn, struct iscsi_task *task)
373 if (r2t->data_length == 0) {
374 iscsi_conn_printk(KERN_ERR, conn,
375 "invalid R2T with zero data len\n");
376 - kfifo_in(&tcp_task->r2tpool.queue, (void*)&r2t,
377 + __kfifo_put(tcp_task->r2tpool.queue, (void*)&r2t,
378 sizeof(void*));
379 return ISCSI_ERR_DATALEN;
381 @@ -566,12 +577,12 @@ static int iscsi_tcp_r2t_rsp(struct iscsi_conn *conn, struct iscsi_task *task)
382 r2t->data_length, session->max_burst);
384 r2t->data_offset = be32_to_cpu(rhdr->data_offset);
385 - if (r2t->data_offset + r2t->data_length > scsi_out(task->sc)->length) {
386 + if (r2t->data_offset + r2t->data_length > scsi_bufflen(task->sc)) {
387 iscsi_conn_printk(KERN_ERR, conn,
388 "invalid R2T with data len %u at offset %u "
389 "and total length %d\n", r2t->data_length,
390 - r2t->data_offset, scsi_out(task->sc)->length);
391 - kfifo_in(&tcp_task->r2tpool.queue, (void*)&r2t,
392 + r2t->data_offset, scsi_bufflen(task->sc));
393 + __kfifo_put(tcp_task->r2tpool.queue, (void*)&r2t,
394 sizeof(void*));
395 return ISCSI_ERR_DATALEN;
397 @@ -581,7 +592,7 @@ static int iscsi_tcp_r2t_rsp(struct iscsi_conn *conn, struct iscsi_task *task)
398 r2t->sent = 0;
400 tcp_task->exp_datasn = r2tsn + 1;
401 - kfifo_in(&tcp_task->r2tqueue, (void*)&r2t, sizeof(void*));
402 + __kfifo_put(tcp_task->r2tqueue, (void*)&r2t, sizeof(void*));
403 conn->r2t_pdus_cnt++;
405 iscsi_requeue_task(task);
406 @@ -669,7 +680,6 @@ iscsi_tcp_hdr_dissect(struct iscsi_conn *conn, struct iscsi_hdr *hdr)
407 if (tcp_conn->in.datalen) {
408 struct iscsi_tcp_task *tcp_task = task->dd_data;
409 struct hash_desc *rx_hash = NULL;
410 - struct scsi_data_buffer *sdb = scsi_in(task->sc);
413 * Setup copy of Data-In into the Scsi_Cmnd
414 @@ -689,8 +699,8 @@ iscsi_tcp_hdr_dissect(struct iscsi_conn *conn, struct iscsi_hdr *hdr)
415 tcp_conn->in.datalen);
416 task->last_xfer = jiffies;
417 rc = iscsi_segment_seek_sg(&tcp_conn->in.segment,
418 - sdb->table.sgl,
419 - sdb->table.nents,
420 + scsi_sglist(task->sc),
421 + scsi_sg_count(task->sc),
422 tcp_task->data_offset,
423 tcp_conn->in.datalen,
424 iscsi_tcp_process_data_in,
425 @@ -952,7 +962,7 @@ int iscsi_tcp_task_init(struct iscsi_task *task)
426 return conn->session->tt->init_pdu(task, 0, task->data_count);
429 - BUG_ON(kfifo_len(&tcp_task->r2tqueue));
430 + BUG_ON(__kfifo_len(tcp_task->r2tqueue));
431 tcp_task->exp_datasn = 0;
433 /* Prepare PDU, optionally w/ immediate data */
434 @@ -983,7 +993,7 @@ static struct iscsi_r2t_info *iscsi_tcp_get_curr_r2t(struct iscsi_task *task)
435 if (r2t->data_length <= r2t->sent) {
436 ISCSI_DBG_TCP(task->conn,
437 " done with r2t %p\n", r2t);
438 - kfifo_in(&tcp_task->r2tpool.queue,
439 + __kfifo_put(tcp_task->r2tpool.queue,
440 (void *)&tcp_task->r2t,
441 sizeof(void *));
442 tcp_task->r2t = r2t = NULL;
443 @@ -991,12 +1001,9 @@ static struct iscsi_r2t_info *iscsi_tcp_get_curr_r2t(struct iscsi_task *task)
446 if (r2t == NULL) {
447 - if (kfifo_out(&tcp_task->r2tqueue,
448 - (void *)&tcp_task->r2t, sizeof(void *)) !=
449 - sizeof(void *))
450 - r2t = NULL;
451 - else
452 - r2t = tcp_task->r2t;
453 + __kfifo_get(tcp_task->r2tqueue,
454 + (void *)&tcp_task->r2t, sizeof(void *));
455 + r2t = tcp_task->r2t;
457 spin_unlock_bh(&session->lock);
459 @@ -1131,8 +1138,9 @@ int iscsi_tcp_r2tpool_alloc(struct iscsi_session *session)
462 /* R2T xmit queue */
463 - if (kfifo_alloc(&tcp_task->r2tqueue,
464 - session->max_r2t * 4 * sizeof(void*), GFP_KERNEL)) {
465 + tcp_task->r2tqueue = kfifo_alloc(
466 + session->max_r2t * 4 * sizeof(void*), GFP_KERNEL, NULL);
467 + if (tcp_task->r2tqueue == ERR_PTR(-ENOMEM)) {
468 iscsi_pool_free(&tcp_task->r2tpool);
469 goto r2t_alloc_fail;
471 @@ -1145,7 +1153,7 @@ r2t_alloc_fail:
472 struct iscsi_task *task = session->cmds[i];
473 struct iscsi_tcp_task *tcp_task = task->dd_data;
475 - kfifo_free(&tcp_task->r2tqueue);
476 + kfifo_free(tcp_task->r2tqueue);
477 iscsi_pool_free(&tcp_task->r2tpool);
479 return -ENOMEM;
480 @@ -1160,7 +1168,7 @@ void iscsi_tcp_r2tpool_free(struct iscsi_session *session)
481 struct iscsi_task *task = session->cmds[i];
482 struct iscsi_tcp_task *tcp_task = task->dd_data;
484 - kfifo_free(&tcp_task->r2tqueue);
485 + kfifo_free(tcp_task->r2tqueue);
486 iscsi_pool_free(&tcp_task->r2tpool);
489 diff --git a/libiscsi_tcp.h b/libiscsi_tcp.h
490 index c020eee..3bacef5 100644
491 --- a/libiscsi_tcp.h
492 +++ b/libiscsi_tcp.h
493 @@ -80,7 +80,7 @@ struct iscsi_tcp_task {
494 int data_offset;
495 struct iscsi_r2t_info *r2t; /* in progress solict R2T */
496 struct iscsi_pool r2tpool;
497 - struct kfifo r2tqueue;
498 + struct kfifo *r2tqueue;
499 void *dd_data;
502 diff --git a/open_iscsi_compat.h b/open_iscsi_compat.h
503 new file mode 100644
504 index 0000000..e6511d3
505 --- /dev/null
506 +++ b/open_iscsi_compat.h
507 @@ -0,0 +1,399 @@
508 +#ifndef OPEN_ISCSI_COMPAT
509 +#define OPEN_ISCSI_COMPAT
511 +#include <linux/version.h>
512 +#include <linux/kernel.h>
513 +#include <scsi/scsi.h>
514 +#include <scsi/scsi_cmnd.h>
515 +#include <scsi/scsi_host.h>
517 +#ifndef SCAN_WILD_CARD
518 +#define SCAN_WILD_CARD ~0
519 +#endif
521 +#ifndef NIPQUAD_FMT
522 +#define NIPQUAD_FMT "%u.%u.%u.%u"
523 +#endif
525 +#ifndef NIP6_FMT
526 +#define NIP6_FMT "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x"
527 +#endif
529 +#ifndef DEFINE_MUTEX
531 +/* mutex changes from 2.6.16-rc1 and up */
532 +#define DEFINE_MUTEX DECLARE_MUTEX
533 +#define mutex_lock down
534 +#define mutex_unlock up
535 +#define mutex semaphore
536 +#define mutex_init init_MUTEX
537 +#endif
539 +#ifdef RHEL_RELEASE_CODE
540 +#if (RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(6, 0))
541 +#define RHELC1 1
542 +#endif
543 +#endif
545 +#ifdef SLE_VERSION_CODE
546 +#if (SLE_VERSION_CODE < SLE_VERSION(11, 0, 0))
547 +#define SLEC1 1
548 +#endif
549 +#endif
552 +#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,19)
553 +struct delayed_work {
554 + struct work_struct work;
557 +#define cancel_delayed_work(_dwork) cancel_delayed_work(&(_dwork)->work)
558 +#define INIT_DELAYED_WORK(_work,_func) INIT_WORK(&(_work)->work, _func)
560 +static inline void INIT_WORK_compat(struct work_struct *work, void *func)
562 + INIT_WORK(work, func, work);
565 +#undef INIT_WORK
566 +#define INIT_WORK(_work, _func) INIT_WORK_compat(_work, _func)
567 +#endif
569 +#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,12)
571 +void int_to_scsilun(unsigned int lun, struct scsi_lun *scsilun)
573 + int i;
575 + memset(scsilun->scsi_lun, 0, sizeof(scsilun->scsi_lun));
577 + for (i = 0; i < sizeof(lun); i += 2) {
578 + scsilun->scsi_lun[i] = (lun >> 8) & 0xFF;
579 + scsilun->scsi_lun[i+1] = lun & 0xFF;
580 + lun = lun >> 16;
584 +#define __nlmsg_put(skb, daemon_pid, seq, type, len, flags) \
585 + __nlmsg_put(skb, daemon_pid, 0, 0, len)
587 +#endif
589 +#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,13)
590 +#ifdef RHEL_RELEASE_CODE && \
591 + RHEL_RELEASE_CODE != RHEL_RELEASE_VERSION(4,8)
593 +#define gfp_t unsigned
595 +void *kzalloc(size_t size, gfp_t flags)
597 + void *ret = kmalloc(size, flags);
598 + if (ret)
599 + memset(ret, 0, size);
602 +#endif
603 +#endif
605 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)
607 +#include "linux/crypto.h"
609 +#if !defined SLEC1
610 +#define CRYPTO_ALG_ASYNC 0x00000080
611 +struct hash_desc
613 + struct crypto_tfm *tfm;
614 + u32 flags;
617 +static inline int crypto_hash_init(struct hash_desc *desc)
619 + crypto_digest_init(desc->tfm);
620 + return 0;
623 +static inline int crypto_hash_digest(struct hash_desc *desc,
624 + struct scatterlist *sg,
625 + unsigned int nbytes, u8 *out)
627 + crypto_digest_digest(desc->tfm, sg, 1, out);
628 + return nbytes;
631 +static inline int crypto_hash_update(struct hash_desc *desc,
632 + struct scatterlist *sg,
633 + unsigned int nbytes)
635 + crypto_digest_update(desc->tfm, sg, 1);
636 + return nbytes;
639 +static inline int crypto_hash_final(struct hash_desc *desc, u8 *out)
641 + crypto_digest_final(desc->tfm, out);
642 + return 0;
645 +static inline struct crypto_tfm *crypto_alloc_hash(const char *alg_name,
646 + u32 type, u32 mask)
648 + struct crypto_tfm *ret = crypto_alloc_tfm(alg_name ,type);
649 + return ret ? ret : ERR_PTR(-ENOMEM);
652 +static inline void crypto_free_hash(struct crypto_tfm *tfm)
654 + crypto_free_tfm(tfm);
656 +#endif
657 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)) \
658 + && !(defined RHELC1)
659 +static inline int kernel_getsockname(struct socket *sock, struct sockaddr *addr,
660 + int *addrlen)
662 + return sock->ops->getname(sock, addr, addrlen, 0);
665 +static inline int kernel_getpeername(struct socket *sock, struct sockaddr *addr,
666 + int *addrlen)
668 + return sock->ops->getname(sock, addr, addrlen, 1);
670 +#endif
671 +#endif
673 +#ifndef bool
674 +#define bool int
675 +#endif
677 +#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,20)
678 +#ifdef RHEL_RELEASE_VERSION
679 +#if RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(5,2) && \
680 + RHEL_RELEASE_CODE != RHEL_RELEASE_VERSION(4,8)
681 +static inline int is_power_of_2(unsigned long n)
683 + return (n != 0 && ((n & (n - 1)) == 0));
685 +#endif
686 +#else
687 +/* not a redhat kernel */
688 +static inline int is_power_of_2(unsigned long n)
690 + return (n != 0 && ((n & (n - 1)) == 0));
692 +#endif
693 +#endif
695 +#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,21)
697 +static inline struct nlmsghdr *nlmsg_hdr(const struct sk_buff *skb)
699 + return (struct nlmsghdr *)skb->data;
702 +#endif
704 +#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,22)
705 +#ifdef RHEL_RELEASE_VERSION
706 +#if RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(5,2)
707 +static inline void *shost_priv(struct Scsi_Host *shost)
709 + return (void *)shost->hostdata;
711 +#endif
712 +#else
713 +/* not a redhat kernel */
714 +static inline void *shost_priv(struct Scsi_Host *shost)
716 + return (void *)shost->hostdata;
718 +#endif
720 +#if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,22)) && \
721 + !defined(SLEC1)
722 +/**
723 + * scsilun_to_int: convert a scsi_lun to an int
724 + * @scsilun: struct scsi_lun to be converted.
726 + * Description:
727 + * Convert @scsilun from a struct scsi_lun to a four byte host byte-ordered
728 + * integer, and return the result. The caller must check for
729 + * truncation before using this function.
731 + * Notes:
732 + * The struct scsi_lun is assumed to be four levels, with each level
733 + * effectively containing a SCSI byte-ordered (big endian) short; the
734 + * addressing bits of each level are ignored (the highest two bits).
735 + * For a description of the LUN format, post SCSI-3 see the SCSI
736 + * Architecture Model, for SCSI-3 see the SCSI Controller Commands.
738 + * Given a struct scsi_lun of: 0a 04 0b 03 00 00 00 00, this function returns
739 + * the integer: 0x0b030a04
740 + **/
741 +static inline int scsilun_to_int(struct scsi_lun *scsilun)
743 + int i;
744 + unsigned int lun;
746 + lun = 0;
747 + for (i = 0; i < sizeof(lun); i += 2)
748 + lun = lun | (((scsilun->scsi_lun[i] << 8) |
749 + scsilun->scsi_lun[i + 1]) << (i * 8));
750 + return lun;
752 +#endif
755 + * Note: We do not support bidi for the compat modules if the kernel
756 + * does not have support.
757 + */
758 +#define scsi_sg_count(cmd) ((cmd)->use_sg)
759 +#define scsi_sglist(cmd) ((struct scatterlist *)(cmd)->request_buffer)
760 +#define scsi_bufflen(cmd) ((cmd)->request_bufflen)
762 +#ifdef RHEL_RELEASE_VERSION
763 +#if RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(5,2)
764 +static inline void scsi_set_resid(struct scsi_cmnd *cmd, int resid)
766 + cmd->resid = resid;
769 +static inline int scsi_get_resid(struct scsi_cmnd *cmd)
771 + return cmd->resid;
773 +#endif
774 +#else
775 +/* not a redhat kernel */
776 +static inline void scsi_set_resid(struct scsi_cmnd *cmd, int resid)
778 + cmd->resid = resid;
781 +static inline int scsi_get_resid(struct scsi_cmnd *cmd)
783 + return cmd->resid;
785 +#endif
787 +#endif
789 +#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,23)
791 +#ifdef SLE_VERSION_CODE
792 +#if SLE_VERSION_CODE == SLE_VERSION(10,2,0)
794 +static inline unsigned fls_long(unsigned long l)
796 + if (sizeof(l) == 4)
797 + return fls(l);
798 + return fls64(l);
801 +#endif
802 +#endif
804 +static inline unsigned long rounddown_pow_of_two(unsigned long n)
806 + return 1UL << (fls_long(n) - 1);
810 +static inline struct scatterlist *sg_next(struct scatterlist *sg)
812 + if (!sg) {
813 + BUG();
814 + return NULL;
816 + return sg + 1;
819 +#define for_each_sg(sglist, sg, nr, __i) \
820 + for (__i = 0, sg = (sglist); __i < (nr); __i++, sg = sg_next(sg))
822 +#define sg_page(_sg) _sg->page
824 +static inline void sg_set_page(struct scatterlist *sg, struct page *page,
825 + unsigned int len, unsigned int offset)
827 + sg->page = page;
828 + sg->offset = offset;
829 + sg->length = len;
832 +static inline void sg_init_table(struct scatterlist *sgl, unsigned int nents)
834 + memset(sgl, 0, sizeof(*sgl) * nents);
836 +#endif
838 +#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,24)
840 +static inline int scsi_bidi_cmnd(struct scsi_cmnd *cmd)
842 + return 0;
845 +#define netlink_kernel_release(_nls) \
846 + sock_release(_nls->sk_socket)
848 +#endif
850 +#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,13)
852 +#define netlink_kernel_create(net, uint, groups, input, cb_mutex, mod) \
853 + netlink_kernel_create(uint, groups, input, cb_mutex, mod)
855 +#elif LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,21)
857 +#define netlink_kernel_create(net, uint, groups, input, cb_mutex, mod) \
858 + netlink_kernel_create(uint, groups, input, mod)
860 +#elif LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,22)
862 +#define netlink_kernel_create(net, uint, groups, input, cb_mutex, mod) \
863 + netlink_kernel_create(uint, groups, input, cb_mutex, mod)
865 +#elif LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,23)
867 +#define netlink_kernel_create(net, uint, groups, input, cb_mutex, mod) \
868 + netlink_kernel_create(uint, groups, input, cb_mutex, mod)
870 +#endif
872 +#ifndef DID_TRANSPORT_DISRUPTED
873 +#define DID_TRANSPORT_DISRUPTED DID_BUS_BUSY
874 +#endif
876 +#ifndef DID_TRANSPORT_FAILFAST
877 +#define DID_TRANSPORT_FAILFAST DID_NO_CONNECT
878 +#endif
880 +#ifndef SCSI_MLQUEUE_TARGET_BUSY
881 +#define SCSI_MLQUEUE_TARGET_BUSY SCSI_MLQUEUE_HOST_BUSY
882 +#endif
884 +#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,27)
886 +#define BLK_EH_NOT_HANDLED EH_NOT_HANDLED
887 +#define BLK_EH_RESET_TIMER EH_RESET_TIMER
889 +#define blk_eh_timer_return scsi_eh_timer_return
891 +#endif
893 +#ifndef SCSI_MAX_VARLEN_CDB_SIZE
894 +#define SCSI_MAX_VARLEN_CDB_SIZE 16
895 +#endif
897 +#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,34)
899 +static inline wait_queue_head_t *sk_sleep(struct sock *sk)
901 + return sk->sk_sleep;
904 +#endif
906 +#endif
907 diff --git a/scsi_transport_iscsi.c b/scsi_transport_iscsi.c
908 index fed8c9e..362bd4d 100644
909 --- a/scsi_transport_iscsi.c
910 +++ b/scsi_transport_iscsi.c
911 @@ -73,13 +73,13 @@ struct iscsi_internal {
912 struct scsi_transport_template t;
913 struct iscsi_transport *iscsi_transport;
914 struct list_head list;
915 - struct device dev;
916 + struct class_device cdev;
918 - struct device_attribute *host_attrs[ISCSI_HOST_ATTRS + 1];
919 + struct class_device_attribute *host_attrs[ISCSI_HOST_ATTRS + 1];
920 struct transport_container conn_cont;
921 - struct device_attribute *conn_attrs[ISCSI_CONN_ATTRS + 1];
922 + struct class_device_attribute *conn_attrs[ISCSI_CONN_ATTRS + 1];
923 struct transport_container session_cont;
924 - struct device_attribute *session_attrs[ISCSI_SESSION_ATTRS + 1];
925 + struct class_device_attribute *session_attrs[ISCSI_SESSION_ATTRS + 1];
928 static atomic_t iscsi_session_nr; /* sysfs session id for next new session */
929 @@ -96,12 +96,12 @@ static DEFINE_SPINLOCK(iscsi_transport_lock);
930 #define to_iscsi_internal(tmpl) \
931 container_of(tmpl, struct iscsi_internal, t)
933 -#define dev_to_iscsi_internal(_dev) \
934 - container_of(_dev, struct iscsi_internal, dev)
935 +#define cdev_to_iscsi_internal(_cdev) \
936 + container_of(_cdev, struct iscsi_internal, cdev)
938 -static void iscsi_transport_release(struct device *dev)
939 +static void iscsi_transport_release(struct class_device *cdev)
941 - struct iscsi_internal *priv = dev_to_iscsi_internal(dev);
942 + struct iscsi_internal *priv = cdev_to_iscsi_internal(cdev);
943 kfree(priv);
946 @@ -111,33 +111,31 @@ static void iscsi_transport_release(struct device *dev)
948 static struct class iscsi_transport_class = {
949 .name = "iscsi_transport",
950 - .dev_release = iscsi_transport_release,
951 + .release = iscsi_transport_release,
954 static ssize_t
955 -show_transport_handle(struct device *dev, struct device_attribute *attr,
956 - char *buf)
957 +show_transport_handle(struct class_device *cdev, char *buf)
959 - struct iscsi_internal *priv = dev_to_iscsi_internal(dev);
960 + struct iscsi_internal *priv = cdev_to_iscsi_internal(cdev);
961 return sprintf(buf, "%llu\n", (unsigned long long)iscsi_handle(priv->iscsi_transport));
963 -static DEVICE_ATTR(handle, S_IRUGO, show_transport_handle, NULL);
964 +static CLASS_DEVICE_ATTR(handle, S_IRUGO, show_transport_handle, NULL);
966 #define show_transport_attr(name, format) \
967 static ssize_t \
968 -show_transport_##name(struct device *dev, \
969 - struct device_attribute *attr,char *buf) \
970 +show_transport_##name(struct class_device *cdev, char *buf) \
972 - struct iscsi_internal *priv = dev_to_iscsi_internal(dev); \
973 + struct iscsi_internal *priv = cdev_to_iscsi_internal(cdev); \
974 return sprintf(buf, format"\n", priv->iscsi_transport->name); \
976 -static DEVICE_ATTR(name, S_IRUGO, show_transport_##name, NULL);
977 +static CLASS_DEVICE_ATTR(name, S_IRUGO, show_transport_##name, NULL);
979 show_transport_attr(caps, "0x%x");
981 static struct attribute *iscsi_transport_attrs[] = {
982 - &dev_attr_handle.attr,
983 - &dev_attr_caps.attr,
984 + &class_device_attr_handle.attr,
985 + &class_device_attr_caps.attr,
986 NULL,
989 @@ -155,27 +153,28 @@ static struct attribute_group iscsi_transport_group = {
990 struct device_attribute dev_attr_##_prefix##_##_name = \
991 __ATTR(_name,_mode,_show,_store)
993 -static void iscsi_endpoint_release(struct device *dev)
994 +static void iscsi_endpoint_release(struct class_device *cdev)
996 - struct iscsi_endpoint *ep = iscsi_dev_to_endpoint(dev);
997 + struct iscsi_endpoint *ep = iscsi_dev_to_endpoint(cdev);
998 kfree(ep);
1001 static struct class iscsi_endpoint_class = {
1002 .name = "iscsi_endpoint",
1003 - .dev_release = iscsi_endpoint_release,
1004 + .release = iscsi_endpoint_release,
1007 static ssize_t
1008 -show_ep_handle(struct device *dev, struct device_attribute *attr, char *buf)
1009 +show_ep_handle(struct class_device *cdev, char *buf)
1011 - struct iscsi_endpoint *ep = iscsi_dev_to_endpoint(dev);
1012 + struct iscsi_endpoint *ep = iscsi_dev_to_endpoint(cdev);
1013 return sprintf(buf, "%llu\n", (unsigned long long) ep->id);
1015 -static ISCSI_ATTR(ep, handle, S_IRUGO, show_ep_handle, NULL);
1016 +static struct class_device_attribute class_device_attr_ep_handle =
1017 + __ATTR(handle, S_IRUGO, show_ep_handle, NULL);
1019 static struct attribute *iscsi_endpoint_attrs[] = {
1020 - &dev_attr_ep_handle.attr,
1021 + &class_device_attr_ep_handle.attr,
1022 NULL,
1025 @@ -185,26 +184,15 @@ static struct attribute_group iscsi_endpoint_group = {
1027 #define ISCSI_MAX_EPID -1
1029 -static int iscsi_match_epid(struct device *dev, void *data)
1031 - struct iscsi_endpoint *ep = iscsi_dev_to_endpoint(dev);
1032 - uint64_t *epid = (uint64_t *) data;
1034 - return *epid == ep->id;
1037 struct iscsi_endpoint *
1038 iscsi_create_endpoint(int dd_size)
1040 - struct device *dev;
1041 struct iscsi_endpoint *ep;
1042 uint64_t id;
1043 int err;
1045 for (id = 1; id < ISCSI_MAX_EPID; id++) {
1046 - dev = class_find_device(&iscsi_endpoint_class, NULL, &id,
1047 - iscsi_match_epid);
1048 - if (!dev)
1049 + if (!iscsi_lookup_endpoint(id))
1050 break;
1052 if (id == ISCSI_MAX_EPID) {
1053 @@ -219,8 +207,9 @@ iscsi_create_endpoint(int dd_size)
1055 ep->id = id;
1056 ep->dev.class = &iscsi_endpoint_class;
1057 - dev_set_name(&ep->dev, "ep-%llu", (unsigned long long) id);
1058 - err = device_register(&ep->dev);
1059 + snprintf(ep->dev.class_id, BUS_ID_SIZE, "ep-%llu",
1060 + (unsigned long long) id);
1061 + err = class_device_register(&ep->dev);
1062 if (err)
1063 goto free_ep;
1065 @@ -233,7 +222,7 @@ iscsi_create_endpoint(int dd_size)
1066 return ep;
1068 unregister_dev:
1069 - device_unregister(&ep->dev);
1070 + class_device_unregister(&ep->dev);
1071 return NULL;
1073 free_ep:
1074 @@ -245,32 +234,38 @@ EXPORT_SYMBOL_GPL(iscsi_create_endpoint);
1075 void iscsi_destroy_endpoint(struct iscsi_endpoint *ep)
1077 sysfs_remove_group(&ep->dev.kobj, &iscsi_endpoint_group);
1078 - device_unregister(&ep->dev);
1079 + class_device_unregister(&ep->dev);
1081 EXPORT_SYMBOL_GPL(iscsi_destroy_endpoint);
1083 struct iscsi_endpoint *iscsi_lookup_endpoint(u64 handle)
1085 - struct iscsi_endpoint *ep;
1086 - struct device *dev;
1088 - dev = class_find_device(&iscsi_endpoint_class, NULL, &handle,
1089 - iscsi_match_epid);
1090 - if (!dev)
1091 - return NULL;
1092 + struct iscsi_endpoint *ep = NULL;
1093 + struct class_device *cdev;
1095 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22)
1096 + down_read(&iscsi_endpoint_class.subsys.rwsem);
1097 +#else
1098 + spin_lock(&iscsi_endpoint_class.subsys.list_lock);
1099 +#endif
1100 + list_for_each_entry(cdev, &iscsi_endpoint_class.children, node) {
1101 + ep = iscsi_dev_to_endpoint(cdev);
1102 + if (ep->id == handle)
1103 + break;
1104 + ep = NULL;
1106 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22)
1107 + up_read(&iscsi_endpoint_class.subsys.rwsem);
1108 +#else
1109 + spin_unlock(&iscsi_endpoint_class.subsys.list_lock);
1110 +#endif
1112 - ep = iscsi_dev_to_endpoint(dev);
1113 - /*
1114 - * we can drop this now because the interface will prevent
1115 - * removals and lookups from racing.
1116 - */
1117 - put_device(dev);
1118 return ep;
1120 EXPORT_SYMBOL_GPL(iscsi_lookup_endpoint);
1122 static int iscsi_setup_host(struct transport_container *tc, struct device *dev,
1123 - struct device *cdev)
1124 + struct class_device *cdev)
1126 struct Scsi_Host *shost = dev_to_shost(dev);
1127 struct iscsi_cls_host *ihost = shost->shost_data;
1128 @@ -571,8 +566,6 @@ static void __iscsi_unblock_session(struct work_struct *work)
1129 struct iscsi_cls_session *session =
1130 container_of(work, struct iscsi_cls_session,
1131 unblock_work);
1132 - struct Scsi_Host *shost = iscsi_session_to_shost(session);
1133 - struct iscsi_cls_host *ihost = shost->shost_data;
1134 unsigned long flags;
1136 ISCSI_DBG_TRANS_SESSION(session, "Unblocking session\n");
1137 @@ -586,15 +579,6 @@ static void __iscsi_unblock_session(struct work_struct *work)
1138 spin_unlock_irqrestore(&session->lock, flags);
1139 /* start IO */
1140 scsi_target_unblock(&session->dev);
1141 - /*
1142 - * Only do kernel scanning if the driver is properly hooked into
1143 - * the async scanning code (drivers like iscsi_tcp do login and
1144 - * scanning from userspace).
1145 - */
1146 - if (shost->hostt->scan_finished) {
1147 - if (scsi_queue_work(shost, &session->scan_work))
1148 - atomic_inc(&ihost->nr_scans);
1150 ISCSI_DBG_TRANS_SESSION(session, "Completed unblocking session\n");
1153 @@ -750,7 +734,7 @@ int iscsi_add_session(struct iscsi_cls_session *session, unsigned int target_id)
1155 session->target_id = id;
1157 - dev_set_name(&session->dev, "session%u", session->sid);
1158 + snprintf(session->dev.bus_id, BUS_ID_SIZE, "session%u", session->sid);
1159 err = device_add(&session->dev);
1160 if (err) {
1161 iscsi_cls_session_printk(KERN_ERR, session,
1162 @@ -930,7 +914,8 @@ iscsi_create_conn(struct iscsi_cls_session *session, int dd_size, uint32_t cid)
1163 if (!get_device(&session->dev))
1164 goto free_conn;
1166 - dev_set_name(&conn->dev, "connection%d:%u", session->sid, cid);
1167 + snprintf(conn->dev.bus_id, BUS_ID_SIZE, "connection%d:%u",
1168 + session->sid, cid);
1169 conn->dev.parent = &session->dev;
1170 conn->dev.release = iscsi_conn_release;
1171 err = device_register(&conn->dev);
1172 @@ -1003,7 +988,15 @@ iscsi_if_transport_lookup(struct iscsi_transport *tt)
1173 static int
1174 iscsi_multicast_skb(struct sk_buff *skb, uint32_t group, gfp_t gfp)
1176 - return nlmsg_multicast(nls, skb, 0, group, gfp);
1177 + int err;
1179 + NETLINK_CB(skb).dst_group = group;
1181 + err = netlink_broadcast(nls, skb, 0, group, gfp);
1182 + if (err > 0)
1183 + err = 0;
1185 + return err;
1188 int iscsi_recv_pdu(struct iscsi_cls_conn *conn, struct iscsi_hdr *hdr,
1189 @@ -1643,51 +1636,65 @@ iscsi_if_recv_msg(struct sk_buff *skb, struct nlmsghdr *nlh, uint32_t *group)
1190 * Malformed skbs with wrong lengths or invalid creds are not processed.
1192 static void
1193 -iscsi_if_rx(struct sk_buff *skb)
1194 +iscsi_if_rx(struct sock *sk, int len)
1196 - mutex_lock(&rx_queue_mutex);
1197 - while (skb->len >= NLMSG_SPACE(0)) {
1198 - int err;
1199 - uint32_t rlen;
1200 - struct nlmsghdr *nlh;
1201 - struct iscsi_uevent *ev;
1202 - uint32_t group;
1204 - nlh = nlmsg_hdr(skb);
1205 - if (nlh->nlmsg_len < sizeof(*nlh) ||
1206 - skb->len < nlh->nlmsg_len) {
1207 - break;
1210 - ev = NLMSG_DATA(nlh);
1211 - rlen = NLMSG_ALIGN(nlh->nlmsg_len);
1212 - if (rlen > skb->len)
1213 - rlen = skb->len;
1214 + struct sk_buff *skb;
1216 - err = iscsi_if_recv_msg(skb, nlh, &group);
1217 - if (err) {
1218 - ev->type = ISCSI_KEVENT_IF_ERROR;
1219 - ev->iferror = err;
1220 + mutex_lock(&rx_queue_mutex);
1221 + while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) {
1222 + if (NETLINK_CREDS(skb)->uid) {
1223 + skb_pull(skb, skb->len);
1224 + goto free_skb;
1226 - do {
1227 - /*
1228 - * special case for GET_STATS:
1229 - * on success - sending reply and stats from
1230 - * inside of if_recv_msg(),
1231 - * on error - fall through.
1232 - */
1233 - if (ev->type == ISCSI_UEVENT_GET_STATS && !err)
1235 + while (skb->len >= NLMSG_SPACE(0)) {
1236 + int err;
1237 + uint32_t rlen;
1238 + struct nlmsghdr *nlh;
1239 + struct iscsi_uevent *ev;
1240 + uint32_t group;
1242 + nlh = nlmsg_hdr(skb);
1243 + if (nlh->nlmsg_len < sizeof(*nlh) ||
1244 + skb->len < nlh->nlmsg_len) {
1245 break;
1246 - err = iscsi_if_send_reply(group, nlh->nlmsg_seq,
1247 - nlh->nlmsg_type, 0, 0, ev, sizeof(*ev));
1248 - } while (err < 0 && err != -ECONNREFUSED);
1249 - skb_pull(skb, rlen);
1252 + ev = NLMSG_DATA(nlh);
1253 + rlen = NLMSG_ALIGN(nlh->nlmsg_len);
1254 + if (rlen > skb->len)
1255 + rlen = skb->len;
1257 + err = iscsi_if_recv_msg(skb, nlh, &group);
1258 + if (err) {
1259 + ev->type = ISCSI_KEVENT_IF_ERROR;
1260 + ev->iferror = err;
1262 + do {
1263 + /*
1264 + * special case for GET_STATS:
1265 + * on success - sending reply and stats from
1266 + * inside of if_recv_msg(),
1267 + * on error - fall through.
1268 + */
1269 + if (ev->type == ISCSI_UEVENT_GET_STATS && !err)
1270 + break;
1271 + err = iscsi_if_send_reply(group, nlh->nlmsg_seq,
1272 + nlh->nlmsg_type, 0, 0, ev, sizeof(*ev));
1273 + } while (err < 0 && err != -ECONNREFUSED);
1274 + skb_pull(skb, rlen);
1276 +free_skb:
1277 + kfree_skb(skb);
1279 mutex_unlock(&rx_queue_mutex);
1282 +#define iscsi_cdev_to_conn(_cdev) \
1283 + iscsi_dev_to_conn(_cdev->dev)
1285 #define ISCSI_CLASS_ATTR(_prefix,_name,_mode,_show,_store) \
1286 -struct device_attribute dev_attr_##_prefix##_##_name = \
1287 +struct class_device_attribute class_device_attr_##_prefix##_##_name = \
1288 __ATTR(_name,_mode,_show,_store)
1291 @@ -1695,10 +1702,9 @@ struct device_attribute dev_attr_##_prefix##_##_name = \
1293 #define iscsi_conn_attr_show(param) \
1294 static ssize_t \
1295 -show_conn_param_##param(struct device *dev, \
1296 - struct device_attribute *attr, char *buf) \
1297 +show_conn_param_##param(struct class_device *cdev, char *buf) \
1299 - struct iscsi_cls_conn *conn = iscsi_dev_to_conn(dev->parent); \
1300 + struct iscsi_cls_conn *conn = iscsi_cdev_to_conn(cdev); \
1301 struct iscsi_transport *t = conn->transport; \
1302 return t->get_conn_param(conn, param, buf); \
1304 @@ -1722,16 +1728,18 @@ iscsi_conn_attr(address, ISCSI_PARAM_CONN_ADDRESS);
1305 iscsi_conn_attr(ping_tmo, ISCSI_PARAM_PING_TMO);
1306 iscsi_conn_attr(recv_tmo, ISCSI_PARAM_RECV_TMO);
1308 +#define iscsi_cdev_to_session(_cdev) \
1309 + iscsi_dev_to_session(_cdev->dev)
1312 * iSCSI session attrs
1314 #define iscsi_session_attr_show(param, perm) \
1315 static ssize_t \
1316 -show_session_param_##param(struct device *dev, \
1317 - struct device_attribute *attr, char *buf) \
1318 +show_session_param_##param(struct class_device *cdev, char *buf) \
1320 struct iscsi_cls_session *session = \
1321 - iscsi_dev_to_session(dev->parent); \
1322 + iscsi_cdev_to_session(cdev); \
1323 struct iscsi_transport *t = session->transport; \
1325 if (perm && !capable(CAP_SYS_ADMIN)) \
1326 @@ -1766,10 +1774,9 @@ iscsi_session_attr(ifacename, ISCSI_PARAM_IFACE_NAME, 0);
1327 iscsi_session_attr(initiatorname, ISCSI_PARAM_INITIATOR_NAME, 0)
1329 static ssize_t
1330 -show_priv_session_state(struct device *dev, struct device_attribute *attr,
1331 - char *buf)
1332 +show_priv_session_state(struct class_device *cdev, char *buf)
1334 - struct iscsi_cls_session *session = iscsi_dev_to_session(dev->parent);
1335 + struct iscsi_cls_session *session = iscsi_cdev_to_session(cdev);
1336 return sprintf(buf, "%s\n", iscsi_session_state_name(session->state));
1338 static ISCSI_CLASS_ATTR(priv_sess, state, S_IRUGO, show_priv_session_state,
1339 @@ -1777,11 +1784,10 @@ static ISCSI_CLASS_ATTR(priv_sess, state, S_IRUGO, show_priv_session_state,
1341 #define iscsi_priv_session_attr_show(field, format) \
1342 static ssize_t \
1343 -show_priv_session_##field(struct device *dev, \
1344 - struct device_attribute *attr, char *buf) \
1345 +show_priv_session_##field(struct class_device *cdev, char *buf) \
1347 struct iscsi_cls_session *session = \
1348 - iscsi_dev_to_session(dev->parent); \
1349 + iscsi_cdev_to_session(cdev); \
1350 return sprintf(buf, format"\n", session->field); \
1353 @@ -1796,10 +1802,9 @@ iscsi_priv_session_attr(recovery_tmo, "%d");
1355 #define iscsi_host_attr_show(param) \
1356 static ssize_t \
1357 -show_host_param_##param(struct device *dev, \
1358 - struct device_attribute *attr, char *buf) \
1359 +show_host_param_##param(struct class_device *cdev, char *buf) \
1361 - struct Scsi_Host *shost = transport_class_to_shost(dev); \
1362 + struct Scsi_Host *shost = transport_class_to_shost(cdev); \
1363 struct iscsi_internal *priv = to_iscsi_internal(shost->transportt); \
1364 return priv->iscsi_transport->get_host_param(shost, param, buf); \
1366 @@ -1816,7 +1821,7 @@ iscsi_host_attr(initiatorname, ISCSI_HOST_PARAM_INITIATOR_NAME);
1368 #define SETUP_PRIV_SESSION_RD_ATTR(field) \
1369 do { \
1370 - priv->session_attrs[count] = &dev_attr_priv_sess_##field; \
1371 + priv->session_attrs[count] = &class_device_attr_priv_sess_##field; \
1372 count++; \
1373 } while (0)
1375 @@ -1824,7 +1829,7 @@ do { \
1376 #define SETUP_SESSION_RD_ATTR(field, param_flag) \
1377 do { \
1378 if (tt->param_mask & param_flag) { \
1379 - priv->session_attrs[count] = &dev_attr_sess_##field; \
1380 + priv->session_attrs[count] = &class_device_attr_sess_##field; \
1381 count++; \
1383 } while (0)
1384 @@ -1832,7 +1837,7 @@ do { \
1385 #define SETUP_CONN_RD_ATTR(field, param_flag) \
1386 do { \
1387 if (tt->param_mask & param_flag) { \
1388 - priv->conn_attrs[count] = &dev_attr_conn_##field; \
1389 + priv->conn_attrs[count] = &class_device_attr_conn_##field; \
1390 count++; \
1392 } while (0)
1393 @@ -1840,7 +1845,7 @@ do { \
1394 #define SETUP_HOST_RD_ATTR(field, param_flag) \
1395 do { \
1396 if (tt->host_param_mask & param_flag) { \
1397 - priv->host_attrs[count] = &dev_attr_host_##field; \
1398 + priv->host_attrs[count] = &class_device_attr_host_##field; \
1399 count++; \
1401 } while (0)
1402 @@ -1931,15 +1936,15 @@ iscsi_register_transport(struct iscsi_transport *tt)
1403 priv->t.user_scan = iscsi_user_scan;
1404 priv->t.create_work_queue = 1;
1406 - priv->dev.class = &iscsi_transport_class;
1407 - dev_set_name(&priv->dev, "%s", tt->name);
1408 - err = device_register(&priv->dev);
1409 + priv->cdev.class = &iscsi_transport_class;
1410 + snprintf(priv->cdev.class_id, BUS_ID_SIZE, "%s", tt->name);
1411 + err = class_device_register(&priv->cdev);
1412 if (err)
1413 goto free_priv;
1415 - err = sysfs_create_group(&priv->dev.kobj, &iscsi_transport_group);
1416 + err = sysfs_create_group(&priv->cdev.kobj, &iscsi_transport_group);
1417 if (err)
1418 - goto unregister_dev;
1419 + goto unregister_cdev;
1421 /* host parameters */
1422 priv->t.host_attrs.ac.attrs = &priv->host_attrs[0];
1423 @@ -2019,8 +2024,8 @@ iscsi_register_transport(struct iscsi_transport *tt)
1424 printk(KERN_NOTICE "iscsi: registered transport (%s)\n", tt->name);
1425 return &priv->t;
1427 -unregister_dev:
1428 - device_unregister(&priv->dev);
1429 +unregister_cdev:
1430 + class_device_unregister(&priv->cdev);
1431 return NULL;
1432 free_priv:
1433 kfree(priv);
1434 @@ -2048,8 +2053,8 @@ int iscsi_unregister_transport(struct iscsi_transport *tt)
1435 transport_container_unregister(&priv->session_cont);
1436 transport_container_unregister(&priv->t.host_attrs);
1438 - sysfs_remove_group(&priv->dev.kobj, &iscsi_transport_group);
1439 - device_unregister(&priv->dev);
1440 + sysfs_remove_group(&priv->cdev.kobj, &iscsi_transport_group);
1441 + class_device_unregister(&priv->cdev);
1442 mutex_unlock(&rx_queue_mutex);
1444 return 0;
1445 diff --git a/scsi_transport_iscsi.h b/scsi_transport_iscsi.h
1446 index ef4b697..a633ee0 100644
1447 --- a/scsi_transport_iscsi.h
1448 +++ b/scsi_transport_iscsi.h
1449 @@ -27,6 +27,7 @@
1450 #include <linux/list.h>
1451 #include <linux/mutex.h>
1452 #include "iscsi_if.h"
1453 +#include "open_iscsi_compat.h"
1455 struct scsi_transport_template;
1456 struct iscsi_transport;
1457 @@ -219,7 +220,7 @@ extern void iscsi_host_for_each_session(struct Scsi_Host *shost,
1459 struct iscsi_endpoint {
1460 void *dd_data; /* LLD private data */
1461 - struct device dev;
1462 + struct class_device dev;
1463 uint64_t id;
1467 1.6.6.1