| blob | 05b77e9e39dda0409c18eba5309161204c94b3a2 |
1 From 10f26ba1e4e0058a25c87b2ad00c71f152212a3a Mon Sep 17 00:00:00 2001
2 From: Rakesh Ranjan <rakesh@chelsio.com>
3 Date: Tue, 10 Nov 2009 19:02:13 +0530
4 Subject: [PATCH] libiscsi 2.6.14-23_compat port
7 Signed-off-by: Rakesh Ranjan <rakesh@chelsio.com>
8 ---
9 iscsi_tcp.c | 13 +--
10 libiscsi.c | 102 ++++++++++-----
11 libiscsi.h | 1 +
12 libiscsi_tcp.c | 22 ++-
13 open_iscsi_compat.h | 356 ++++++++++++++++++++++++++++++++++++++++++++++++
14 scsi_transport_iscsi.c | 273 +++++++++++++++++++------------------
15 scsi_transport_iscsi.h | 3 +-
16 7 files changed, 586 insertions(+), 184 deletions(-)
17 create mode 100644 open_iscsi_compat.h
19 diff --git a/iscsi_tcp.c b/iscsi_tcp.c
20 index aa4abdb..2c21157 100644
21 --- a/iscsi_tcp.c
22 +++ b/iscsi_tcp.c
23 @@ -477,10 +477,9 @@ static int iscsi_sw_tcp_pdu_init(struct iscsi_task *task,
24 if (!task->sc)
25 iscsi_sw_tcp_send_linear_data_prep(conn, task->data, count);
26 else {
27 - struct scsi_data_buffer *sdb = scsi_out(task->sc);
29 - err = iscsi_sw_tcp_send_data_prep(conn, sdb->table.sgl,
30 - sdb->table.nents, offset,
31 + err = iscsi_sw_tcp_send_data_prep(conn, scsi_sglist(task->sc),
32 + scsi_sg_count(task->sc), offset,
33 count);
34 }
36 @@ -853,12 +852,6 @@ static void iscsi_sw_tcp_session_destroy(struct iscsi_cls_session *cls_session)
37 iscsi_host_free(shost);
38 }
40 -static int iscsi_sw_tcp_slave_alloc(struct scsi_device *sdev)
41 -{
42 - set_bit(QUEUE_FLAG_BIDI, &sdev->request_queue->queue_flags);
43 - return 0;
44 -}
45 -
46 static int iscsi_sw_tcp_slave_configure(struct scsi_device *sdev)
47 {
48 blk_queue_bounce_limit(sdev->request_queue, BLK_BOUNCE_ANY);
49 @@ -877,9 +870,7 @@ static struct scsi_host_template iscsi_sw_tcp_sht = {
50 .cmd_per_lun = ISCSI_DEF_CMD_PER_LUN,
51 .eh_abort_handler = iscsi_eh_abort,
52 .eh_device_reset_handler= iscsi_eh_device_reset,
53 - .eh_target_reset_handler= iscsi_eh_target_reset,
54 .use_clustering = DISABLE_CLUSTERING,
55 - .slave_alloc = iscsi_sw_tcp_slave_alloc,
56 .slave_configure = iscsi_sw_tcp_slave_configure,
57 .target_alloc = iscsi_target_alloc,
58 .proc_name = "iscsi_tcp",
59 diff --git a/libiscsi.c b/libiscsi.c
60 index 0b810b6..8eb6ec0 100644
61 --- a/libiscsi.c
62 +++ b/libiscsi.c
63 @@ -24,7 +24,10 @@
64 #include <linux/types.h>
65 #include <linux/kfifo.h>
66 #include <linux/delay.h>
67 +#include <linux/version.h>
68 +#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,19)
69 #include <linux/log2.h>
70 +#endif
71 #include <asm/unaligned.h>
72 #include <net/tcp.h>
73 #include <scsi/scsi_cmnd.h>
74 @@ -38,6 +41,8 @@
75 #include "scsi_transport_iscsi.h"
76 #include "libiscsi.h"
78 +#include "open_iscsi_compat.h"
79 +
80 static int iscsi_dbg_lib_conn;
81 module_param_named(debug_libiscsi_conn, iscsi_dbg_lib_conn, int,
82 S_IRUGO | S_IWUSR);
83 @@ -255,7 +260,7 @@ static int iscsi_prep_bidi_ahs(struct iscsi_task *task)
84 sizeof(rlen_ahdr->reserved));
85 rlen_ahdr->ahstype = ISCSI_AHSTYPE_RLENGTH;
86 rlen_ahdr->reserved = 0;
87 - rlen_ahdr->read_length = cpu_to_be32(scsi_in(sc)->length);
88 + rlen_ahdr->read_length = cpu_to_be32(scsi_bufflen(sc));
90 ISCSI_DBG_SESSION(task->conn->session,
91 "bidi-in rlen_ahdr->read_length(%d) "
92 @@ -265,6 +270,40 @@ static int iscsi_prep_bidi_ahs(struct iscsi_task *task)
93 return 0;
94 }
96 +#if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,22)) && \
97 + !defined(SLEC1)
98 +/**
99 + * scsilun_to_int: convert a scsi_lun to an int
100 + * @scsilun: struct scsi_lun to be converted.
101 + *
102 + * Description:
103 + * Convert @scsilun from a struct scsi_lun to a four byte host byte-ordered
104 + * integer, and return the result. The caller must check for
105 + * truncation before using this function.
106 + *
107 + * Notes:
108 + * The struct scsi_lun is assumed to be four levels, with each level
109 + * effectively containing a SCSI byte-ordered (big endian) short; the
110 + * addressing bits of each level are ignored (the highest two bits).
111 + * For a description of the LUN format, post SCSI-3 see the SCSI
112 + * Architecture Model, for SCSI-3 see the SCSI Controller Commands.
113 + *
114 + * Given a struct scsi_lun of: 0a 04 0b 03 00 00 00 00, this function returns
115 + * the integer: 0x0b030a04
116 + **/
117 +static int scsilun_to_int(struct scsi_lun *scsilun)
118 +{
119 + int i;
120 + unsigned int lun;
121 +
122 + lun = 0;
123 + for (i = 0; i < sizeof(lun); i += 2)
124 + lun = lun | (((scsilun->scsi_lun[i] << 8) |
125 + scsilun->scsi_lun[i + 1]) << (i * 8));
126 + return lun;
127 +}
128 +#endif
129 +
130 /**
131 * iscsi_check_tmf_restrictions - check if a task is affected by TMF
132 * @task: iscsi task
133 @@ -410,7 +449,7 @@ static int iscsi_prep_scsi_cmd_pdu(struct iscsi_task *task)
134 return rc;
135 }
136 if (sc->sc_data_direction == DMA_TO_DEVICE) {
137 - unsigned out_len = scsi_out(sc)->length;
138 + unsigned out_len = scsi_bufflen(sc);
139 struct iscsi_r2t_info *r2t = &task->unsol_r2t;
141 hdr->data_length = cpu_to_be32(out_len);
142 @@ -456,7 +495,7 @@ static int iscsi_prep_scsi_cmd_pdu(struct iscsi_task *task)
143 } else {
144 hdr->flags |= ISCSI_FLAG_CMD_FINAL;
145 zero_data(hdr->dlength);
146 - hdr->data_length = cpu_to_be32(scsi_in(sc)->length);
147 + hdr->data_length = cpu_to_be32(scsi_bufflen(sc));
149 if (sc->sc_data_direction == DMA_FROM_DEVICE)
150 hdr->flags |= ISCSI_FLAG_CMD_READ;
151 @@ -485,7 +524,7 @@ static int iscsi_prep_scsi_cmd_pdu(struct iscsi_task *task)
152 sc->sc_data_direction == DMA_TO_DEVICE ?
153 "write" : "read", conn->id, sc, sc->cmnd[0],
154 task->itt, scsi_bufflen(sc),
155 - scsi_bidi_cmnd(sc) ? scsi_in(sc)->length : 0,
156 + scsi_bidi_cmnd(sc) ? scsi_bufflen(sc) : 0,
157 session->cmdsn,
158 session->max_cmdsn - session->exp_cmdsn + 1);
159 return 0;
160 @@ -647,12 +686,7 @@ static void fail_scsi_task(struct iscsi_task *task, int err)
161 state = ISCSI_TASK_ABRT_TMF;
163 sc->result = err << 16;
164 - if (!scsi_bidi_cmnd(sc))
165 - scsi_set_resid(sc, scsi_bufflen(sc));
166 - else {
167 - scsi_out(sc)->resid = scsi_out(sc)->length;
168 - scsi_in(sc)->resid = scsi_in(sc)->length;
169 - }
170 + scsi_set_resid(sc, scsi_bufflen(sc));
172 iscsi_complete_task(task, state);
173 }
174 @@ -852,7 +886,7 @@ invalid_datalen:
175 goto out;
176 }
178 - senselen = get_unaligned_be16(data);
179 + senselen = be16_to_cpu(get_unaligned((__be16 *) data));
180 if (datalen < senselen)
181 goto invalid_datalen;
183 @@ -869,8 +903,8 @@ invalid_datalen:
185 if (scsi_bidi_cmnd(sc) && res_count > 0 &&
186 (rhdr->flags & ISCSI_FLAG_CMD_BIDI_OVERFLOW ||
187 - res_count <= scsi_in(sc)->length))
188 - scsi_in(sc)->resid = res_count;
189 + res_count <= scsi_bufflen(sc)))
190 + scsi_set_resid(sc, res_count);
191 else
192 sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status;
193 }
194 @@ -919,8 +953,8 @@ iscsi_data_in_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
196 if (res_count > 0 &&
197 (rhdr->flags & ISCSI_FLAG_CMD_OVERFLOW ||
198 - res_count <= scsi_in(sc)->length))
199 - scsi_in(sc)->resid = res_count;
200 + res_count <= scsi_bufflen(sc)))
201 + scsi_set_resid(sc, res_count);
202 else
203 sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status;
204 }
205 @@ -1716,7 +1750,11 @@ reject:
206 ISCSI_DBG_SESSION(session, "cmd 0x%x rejected (%d)\n",
207 sc->cmnd[0], reason);
208 spin_lock(host->host_lock);
209 +#if (defined RHELC1) || (defined SLEC1)
210 + return SCSI_MLQUEUE_DEVICE_BUSY;
211 +#else
212 return SCSI_MLQUEUE_TARGET_BUSY;
213 +#endif
215 prepd_fault:
216 sc->scsi_done = NULL;
217 @@ -1725,12 +1763,7 @@ fault:
218 spin_unlock(&session->lock);
219 ISCSI_DBG_SESSION(session, "iscsi: cmd 0x%x is not queued (%d)\n",
220 sc->cmnd[0], reason);
221 - if (!scsi_bidi_cmnd(sc))
222 - scsi_set_resid(sc, scsi_bufflen(sc));
223 - else {
224 - scsi_out(sc)->resid = scsi_out(sc)->length;
225 - scsi_in(sc)->resid = scsi_in(sc)->length;
226 - }
227 + scsi_set_resid(sc, scsi_bufflen(sc));
228 done(sc);
229 spin_lock(host->host_lock);
230 return 0;
231 @@ -2283,13 +2316,11 @@ EXPORT_SYMBOL_GPL(iscsi_session_recovery_timedout);
232 * This function will wait for a relogin, session termination from
233 * userspace, or a recovery/replacement timeout.
234 */
235 -static int iscsi_eh_session_reset(struct scsi_cmnd *sc)
236 +static int iscsi_eh_session_reset(struct iscsi_cls_session *cls_session)
237 {
238 - struct iscsi_cls_session *cls_session;
239 struct iscsi_session *session;
240 struct iscsi_conn *conn;
242 - cls_session = starget_to_session(scsi_target(sc->device));
243 session = cls_session->dd_data;
244 conn = session->leadconn;
246 @@ -2335,7 +2366,7 @@ failed:
247 return SUCCESS;
248 }
250 -static void iscsi_prep_tgt_reset_pdu(struct scsi_cmnd *sc, struct iscsi_tm *hdr)
251 +static void iscsi_prep_tgt_reset_pdu(struct iscsi_cls_session *cls_session, struct iscsi_tm *hdr)
252 {
253 memset(hdr, 0, sizeof(*hdr));
254 hdr->opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE;
255 @@ -2345,24 +2376,22 @@ static void iscsi_prep_tgt_reset_pdu(struct scsi_cmnd *sc, struct iscsi_tm *hdr)
256 }
258 /**
259 - * iscsi_eh_target_reset - reset target
260 + * iscsi_target_reset - reset target
261 * @sc: scsi command
262 *
263 * This will attempt to send a warm target reset. If that fails
264 * then we will drop the session and attempt ERL0 recovery.
265 */
266 -int iscsi_eh_target_reset(struct scsi_cmnd *sc)
267 +int iscsi_target_reset(struct iscsi_cls_session *cls_session)
268 {
269 - struct iscsi_cls_session *cls_session;
270 struct iscsi_session *session;
271 struct iscsi_conn *conn;
272 struct iscsi_tm *hdr;
273 int rc = FAILED;
275 - cls_session = starget_to_session(scsi_target(sc->device));
276 session = cls_session->dd_data;
278 - ISCSI_DBG_EH(session, "tgt Reset [sc %p tgt %s]\n", sc,
279 + ISCSI_DBG_EH(session, "tgt Reset [cls_session %p tgt %s]\n", cls_session,
280 session->targetname);
282 mutex_lock(&session->eh_mutex);
283 @@ -2381,7 +2410,7 @@ int iscsi_eh_target_reset(struct scsi_cmnd *sc)
284 conn->tmf_state = TMF_QUEUED;
286 hdr = &conn->tmhdr;
287 - iscsi_prep_tgt_reset_pdu(sc, hdr);
288 + iscsi_prep_tgt_reset_pdu(cls_session, hdr);
290 if (iscsi_exec_task_mgmt_fn(conn, hdr, session->age,
291 session->tgt_reset_timeout)) {
292 @@ -2423,9 +2452,18 @@ done:
293 mutex_unlock(&session->eh_mutex);
295 if (rc == FAILED)
296 - rc = iscsi_eh_session_reset(sc);
297 + rc = iscsi_eh_session_reset(cls_session);
298 return rc;
299 }
300 +EXPORT_SYMBOL_GPL(iscsi_target_reset);
301 +
302 +int iscsi_eh_target_reset(struct scsi_cmnd *sc)
303 +{
304 + struct iscsi_cls_session *cls_session;
305 +
306 + cls_session = starget_to_session(scsi_target(sc->device));
307 + return iscsi_target_reset(cls_session);
308 +}
309 EXPORT_SYMBOL_GPL(iscsi_eh_target_reset);
311 /*
312 diff --git a/libiscsi.h b/libiscsi.h
313 index 76e80e7..41c287d 100644
314 --- a/libiscsi.h
315 +++ b/libiscsi.h
316 @@ -337,6 +337,7 @@ struct iscsi_host {
317 extern int iscsi_change_queue_depth(struct scsi_device *sdev, int depth);
318 extern int iscsi_eh_abort(struct scsi_cmnd *sc);
319 extern int iscsi_eh_target_reset(struct scsi_cmnd *sc);
320 +extern int iscsi_target_reset(struct iscsi_cls_session *cls_session);
321 extern int iscsi_eh_device_reset(struct scsi_cmnd *sc);
322 extern int iscsi_queuecommand(struct scsi_cmnd *sc,
323 void (*done)(struct scsi_cmnd *));
324 diff --git a/libiscsi_tcp.c b/libiscsi_tcp.c
325 index 4051e62..a031e2e 100644
326 --- a/libiscsi_tcp.c
327 +++ b/libiscsi_tcp.c
328 @@ -360,6 +360,17 @@ iscsi_segment_seek_sg(struct iscsi_segment *segment,
329 struct scatterlist *sg;
330 unsigned int i;
332 + /*
333 + * older kernels could send use_sg=0 for commands like sgio
334 + * or scsi-ml commands.
335 + */
336 +
337 + if (!sg_count) {
338 + iscsi_segment_init_linear(segment, (void *)sg_list + offset,
339 + size, done, hash);
340 + return 0;
341 + }
342 +
343 __iscsi_segment_init(segment, size, done, hash);
344 for_each_sg(sg_list, sg, sg_count, i) {
345 if (offset < sg->length) {
346 @@ -471,7 +482,7 @@ static int iscsi_tcp_data_in(struct iscsi_conn *conn, struct iscsi_task *task)
347 struct iscsi_tcp_task *tcp_task = task->dd_data;
348 struct iscsi_data_rsp *rhdr = (struct iscsi_data_rsp *)tcp_conn->in.hdr;
349 int datasn = be32_to_cpu(rhdr->datasn);
350 - unsigned total_in_length = scsi_in(task->sc)->length;
351 + unsigned total_in_length = scsi_bufflen(task->sc);
353 /*
354 * lib iscsi will update this in the completion handling if there
355 @@ -565,11 +576,11 @@ static int iscsi_tcp_r2t_rsp(struct iscsi_conn *conn, struct iscsi_task *task)
356 r2t->data_length, session->max_burst);
358 r2t->data_offset = be32_to_cpu(rhdr->data_offset);
359 - if (r2t->data_offset + r2t->data_length > scsi_out(task->sc)->length) {
360 + if (r2t->data_offset + r2t->data_length > scsi_bufflen(task->sc)) {
361 iscsi_conn_printk(KERN_ERR, conn,
362 "invalid R2T with data len %u at offset %u "
363 "and total length %d\n", r2t->data_length,
364 - r2t->data_offset, scsi_out(task->sc)->length);
365 + r2t->data_offset, scsi_bufflen(task->sc));
366 __kfifo_put(tcp_task->r2tpool.queue, (void*)&r2t,
367 sizeof(void*));
368 return ISCSI_ERR_DATALEN;
369 @@ -668,7 +679,6 @@ iscsi_tcp_hdr_dissect(struct iscsi_conn *conn, struct iscsi_hdr *hdr)
370 if (tcp_conn->in.datalen) {
371 struct iscsi_tcp_task *tcp_task = task->dd_data;
372 struct hash_desc *rx_hash = NULL;
373 - struct scsi_data_buffer *sdb = scsi_in(task->sc);
375 /*
376 * Setup copy of Data-In into the Scsi_Cmnd
377 @@ -688,8 +698,8 @@ iscsi_tcp_hdr_dissect(struct iscsi_conn *conn, struct iscsi_hdr *hdr)
378 tcp_conn->in.datalen);
379 task->last_xfer = jiffies;
380 rc = iscsi_segment_seek_sg(&tcp_conn->in.segment,
381 - sdb->table.sgl,
382 - sdb->table.nents,
383 + scsi_sglist(task->sc),
384 + scsi_sg_count(task->sc),
385 tcp_task->data_offset,
386 tcp_conn->in.datalen,
387 iscsi_tcp_process_data_in,
388 diff --git a/open_iscsi_compat.h b/open_iscsi_compat.h
389 new file mode 100644
390 index 0000000..5c98fef
391 --- /dev/null
392 +++ b/open_iscsi_compat.h
393 @@ -0,0 +1,356 @@
394 +#ifndef OPEN_ISCSI_COMPAT
395 +#define OPEN_ISCSI_COMPAT
396 +
397 +#include <linux/version.h>
398 +#include <linux/kernel.h>
399 +#include <scsi/scsi.h>
400 +#include <scsi/scsi_cmnd.h>
401 +#include <scsi/scsi_host.h>
402 +
403 +#ifndef SCAN_WILD_CARD
404 +#define SCAN_WILD_CARD ~0
405 +#endif
406 +
407 +#ifndef NIPQUAD_FMT
408 +#define NIPQUAD_FMT "%u.%u.%u.%u"
409 +#endif
410 +
411 +#ifndef NIP6_FMT
412 +#define NIP6_FMT "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x"
413 +#endif
414 +
415 +#ifndef DEFINE_MUTEX
416 +
417 +/* mutex changes from 2.6.16-rc1 and up */
418 +#define DEFINE_MUTEX DECLARE_MUTEX
419 +#define mutex_lock down
420 +#define mutex_unlock up
421 +#define mutex semaphore
422 +#define mutex_init init_MUTEX
423 +#endif
424 +
425 +#ifdef RHEL_RELEASE_CODE
426 +#if (RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(6, 0))
427 +#define RHELC1 1
428 +#endif
429 +#endif
430 +
431 +#ifdef SLE_VERSION_CODE
432 +#if (SLE_VERSION_CODE < SLE_VERSION(11, 0, 0))
433 +#define SLEC1 1
434 +#endif
435 +#endif
436 +
437 +
438 +#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,19)
439 +struct delayed_work {
440 + struct work_struct work;
441 +};
442 +
443 +#define cancel_delayed_work(_dwork) cancel_delayed_work(&(_dwork)->work)
444 +#define INIT_DELAYED_WORK(_work,_func) INIT_WORK(&(_work)->work, _func)
445 +
446 +static inline void INIT_WORK_compat(struct work_struct *work, void *func)
447 +{
448 + INIT_WORK(work, func, work);
449 +}
450 +
451 +#undef INIT_WORK
452 +#define INIT_WORK(_work, _func) INIT_WORK_compat(_work, _func)
453 +#endif
454 +
455 +#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,12)
456 +
457 +void int_to_scsilun(unsigned int lun, struct scsi_lun *scsilun)
458 +{
459 + int i;
460 +
461 + memset(scsilun->scsi_lun, 0, sizeof(scsilun->scsi_lun));
462 +
463 + for (i = 0; i < sizeof(lun); i += 2) {
464 + scsilun->scsi_lun[i] = (lun >> 8) & 0xFF;
465 + scsilun->scsi_lun[i+1] = lun & 0xFF;
466 + lun = lun >> 16;
467 + }
468 +}
469 +
470 +#define __nlmsg_put(skb, daemon_pid, seq, type, len, flags) \
471 + __nlmsg_put(skb, daemon_pid, 0, 0, len)
472 +
473 +#endif
474 +
475 +#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,13)
476 +#ifdef RHEL_RELEASE_CODE && \
477 + RHEL_RELEASE_CODE != RHEL_RELEASE_VERSION(4,8)
478 +
479 +#define gfp_t unsigned
480 +
481 +void *kzalloc(size_t size, gfp_t flags)
482 +{
483 + void *ret = kmalloc(size, flags);
484 + if (ret)
485 + memset(ret, 0, size);
486 +}
487 +
488 +#endif
489 +#endif
490 +
491 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)
492 +
493 +#include "linux/crypto.h"
494 +
495 +#if !defined SLEC1
496 +#define CRYPTO_ALG_ASYNC 0x00000080
497 +struct hash_desc
498 +{
499 + struct crypto_tfm *tfm;
500 + u32 flags;
501 +};
502 +
503 +static inline int crypto_hash_init(struct hash_desc *desc)
504 +{
505 + crypto_digest_init(desc->tfm);
506 + return 0;
507 +}
508 +
509 +static inline int crypto_hash_digest(struct hash_desc *desc,
510 + struct scatterlist *sg,
511 + unsigned int nbytes, u8 *out)
512 +{
513 + crypto_digest_digest(desc->tfm, sg, 1, out);
514 + return nbytes;
515 +}
516 +
517 +static inline int crypto_hash_update(struct hash_desc *desc,
518 + struct scatterlist *sg,
519 + unsigned int nbytes)
520 +{
521 + crypto_digest_update(desc->tfm, sg, 1);
522 + return nbytes;
523 +}
524 +
525 +static inline int crypto_hash_final(struct hash_desc *desc, u8 *out)
526 +{
527 + crypto_digest_final(desc->tfm, out);
528 + return 0;
529 +}
530 +
531 +static inline struct crypto_tfm *crypto_alloc_hash(const char *alg_name,
532 + u32 type, u32 mask)
533 +{
534 + struct crypto_tfm *ret = crypto_alloc_tfm(alg_name ,type);
535 + return ret ? ret : ERR_PTR(-ENOMEM);
536 +}
537 +
538 +static inline void crypto_free_hash(struct crypto_tfm *tfm)
539 +{
540 + crypto_free_tfm(tfm);
541 +}
542 +#endif
543 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)) \
544 + && !(defined RHELC1)
545 +static inline int kernel_getsockname(struct socket *sock, struct sockaddr *addr,
546 + int *addrlen)
547 +{
548 + return sock->ops->getname(sock, addr, addrlen, 0);
549 +}
550 +
551 +static inline int kernel_getpeername(struct socket *sock, struct sockaddr *addr,
552 + int *addrlen)
553 +{
554 + return sock->ops->getname(sock, addr, addrlen, 1);
555 +}
556 +#endif
557 +#endif
558 +
559 +#ifndef bool
560 +#define bool int
561 +#endif
562 +
563 +#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,20)
564 +#ifdef RHEL_RELEASE_VERSION
565 +#if RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(5,2) && \
566 + RHEL_RELEASE_CODE != RHEL_RELEASE_VERSION(4,8)
567 +static inline int is_power_of_2(unsigned long n)
568 +{
569 + return (n != 0 && ((n & (n - 1)) == 0));
570 +}
571 +#endif
572 +#else
573 +/* not a redhat kernel */
574 +static inline int is_power_of_2(unsigned long n)
575 +{
576 + return (n != 0 && ((n & (n - 1)) == 0));
577 +}
578 +#endif
579 +#endif
580 +
581 +#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,21)
582 +
583 +static inline struct nlmsghdr *nlmsg_hdr(const struct sk_buff *skb)
584 +{
585 + return (struct nlmsghdr *)skb->data;
586 +}
587 +
588 +#endif
589 +
590 +#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,22)
591 +#ifdef RHEL_RELEASE_VERSION
592 +#if RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(5,2)
593 +static inline void *shost_priv(struct Scsi_Host *shost)
594 +{
595 + return (void *)shost->hostdata;
596 +}
597 +#endif
598 +#else
599 +/* not a redhat kernel */
600 +static inline void *shost_priv(struct Scsi_Host *shost)
601 +{
602 + return (void *)shost->hostdata;
603 +}
604 +#endif
605 +
606 +/*
607 + * Note: We do not support bidi for the compat modules if the kernel
608 + * does not have support.
609 + */
610 +#define scsi_sg_count(cmd) ((cmd)->use_sg)
611 +#define scsi_sglist(cmd) ((struct scatterlist *)(cmd)->request_buffer)
612 +#define scsi_bufflen(cmd) ((cmd)->request_bufflen)
613 +
614 +#ifdef RHEL_RELEASE_VERSION
615 +#if RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(5,2)
616 +static inline void scsi_set_resid(struct scsi_cmnd *cmd, int resid)
617 +{
618 + cmd->resid = resid;
619 +}
620 +
621 +static inline int scsi_get_resid(struct scsi_cmnd *cmd)
622 +{
623 + return cmd->resid;
624 +}
625 +#endif
626 +#else
627 +/* not a redhat kernel */
628 +static inline void scsi_set_resid(struct scsi_cmnd *cmd, int resid)
629 +{
630 + cmd->resid = resid;
631 +}
632 +
633 +static inline int scsi_get_resid(struct scsi_cmnd *cmd)
634 +{
635 + return cmd->resid;
636 +}
637 +#endif
638 +
639 +#endif
640 +
641 +#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,23)
642 +
643 +#ifdef SLE_VERSION_CODE
644 +#if SLE_VERSION_CODE == SLE_VERSION(10,2,0)
645 +
646 +static inline unsigned fls_long(unsigned long l)
647 +{
648 + if (sizeof(l) == 4)
649 + return fls(l);
650 + return fls64(l);
651 +}
652 +
653 +#endif
654 +#endif
655 +
656 +static inline unsigned long rounddown_pow_of_two(unsigned long n)
657 +{
658 + return 1UL << (fls_long(n) - 1);
659 +}
660 +
661 +
662 +static inline struct scatterlist *sg_next(struct scatterlist *sg)
663 +{
664 + if (!sg) {
665 + BUG();
666 + return NULL;
667 + }
668 + return sg + 1;
669 +}
670 +
671 +#define for_each_sg(sglist, sg, nr, __i) \
672 + for (__i = 0, sg = (sglist); __i < (nr); __i++, sg = sg_next(sg))
673 +
674 +#define sg_page(_sg) _sg->page
675 +
676 +static inline void sg_set_page(struct scatterlist *sg, struct page *page,
677 + unsigned int len, unsigned int offset)
678 +{
679 + sg->page = page;
680 + sg->offset = offset;
681 + sg->length = len;
682 +}
683 +
684 +static inline void sg_init_table(struct scatterlist *sgl, unsigned int nents)
685 +{
686 + memset(sgl, 0, sizeof(*sgl) * nents);
687 +}
688 +#endif
689 +
690 +#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,24)
691 +
692 +static inline int scsi_bidi_cmnd(struct scsi_cmnd *cmd)
693 +{
694 + return 0;
695 +}
696 +
697 +#define netlink_kernel_release(_nls) \
698 + sock_release(_nls->sk_socket)
699 +
700 +#endif
701 +
702 +#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,13)
703 +
704 +#define netlink_kernel_create(net, uint, groups, input, cb_mutex, mod) \
705 + netlink_kernel_create(uint, groups, input, cb_mutex, mod)
706 +
707 +#elif LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,21)
708 +
709 +#define netlink_kernel_create(net, uint, groups, input, cb_mutex, mod) \
710 + netlink_kernel_create(uint, groups, input, mod)
711 +
712 +#elif LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,22)
713 +
714 +#define netlink_kernel_create(net, uint, groups, input, cb_mutex, mod) \
715 + netlink_kernel_create(uint, groups, input, cb_mutex, mod)
716 +
717 +#elif LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,23)
718 +
719 +#define netlink_kernel_create(net, uint, groups, input, cb_mutex, mod) \
720 + netlink_kernel_create(uint, groups, input, cb_mutex, mod)
721 +
722 +#endif
723 +
724 +#ifndef DID_TRANSPORT_DISRUPTED
725 +#define DID_TRANSPORT_DISRUPTED DID_BUS_BUSY
726 +#endif
727 +
728 +#ifndef DID_TRANSPORT_FAILFAST
729 +#define DID_TRANSPORT_FAILFAST DID_NO_CONNECT
730 +#endif
731 +
732 +#ifndef SCSI_MLQUEUE_TARGET_BUSY
733 +#define SCSI_MLQUEUE_TARGET_BUSY SCSI_MLQUEUE_HOST_BUSY
734 +#endif
735 +
736 +#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,27)
737 +
738 +#define BLK_EH_NOT_HANDLED EH_NOT_HANDLED
739 +#define BLK_EH_RESET_TIMER EH_RESET_TIMER
740 +
741 +#define blk_eh_timer_return scsi_eh_timer_return
742 +
743 +#endif
744 +
745 +#ifndef SCSI_MAX_VARLEN_CDB_SIZE
746 +#define SCSI_MAX_VARLEN_CDB_SIZE 16
747 +#endif
748 +
749 +#endif
750 diff --git a/scsi_transport_iscsi.c b/scsi_transport_iscsi.c
751 index f64ffa7..d0cdeb7 100644
752 --- a/scsi_transport_iscsi.c
753 +++ b/scsi_transport_iscsi.c
754 @@ -72,13 +72,13 @@ struct iscsi_internal {
755 struct scsi_transport_template t;
756 struct iscsi_transport *iscsi_transport;
757 struct list_head list;
758 - struct device dev;
759 + struct class_device cdev;
761 - struct device_attribute *host_attrs[ISCSI_HOST_ATTRS + 1];
762 + struct class_device_attribute *host_attrs[ISCSI_HOST_ATTRS + 1];
763 struct transport_container conn_cont;
764 - struct device_attribute *conn_attrs[ISCSI_CONN_ATTRS + 1];
765 + struct class_device_attribute *conn_attrs[ISCSI_CONN_ATTRS + 1];
766 struct transport_container session_cont;
767 - struct device_attribute *session_attrs[ISCSI_SESSION_ATTRS + 1];
768 + struct class_device_attribute *session_attrs[ISCSI_SESSION_ATTRS + 1];
769 };
771 static atomic_t iscsi_session_nr; /* sysfs session id for next new session */
772 @@ -95,12 +95,12 @@ static DEFINE_SPINLOCK(iscsi_transport_lock);
773 #define to_iscsi_internal(tmpl) \
774 container_of(tmpl, struct iscsi_internal, t)
776 -#define dev_to_iscsi_internal(_dev) \
777 - container_of(_dev, struct iscsi_internal, dev)
778 +#define cdev_to_iscsi_internal(_cdev) \
779 + container_of(_cdev, struct iscsi_internal, cdev)
781 -static void iscsi_transport_release(struct device *dev)
782 +static void iscsi_transport_release(struct class_device *cdev)
783 {
784 - struct iscsi_internal *priv = dev_to_iscsi_internal(dev);
785 + struct iscsi_internal *priv = cdev_to_iscsi_internal(cdev);
786 kfree(priv);
787 }
789 @@ -110,33 +110,31 @@ static void iscsi_transport_release(struct device *dev)
790 */
791 static struct class iscsi_transport_class = {
792 .name = "iscsi_transport",
793 - .dev_release = iscsi_transport_release,
794 + .release = iscsi_transport_release,
795 };
797 static ssize_t
798 -show_transport_handle(struct device *dev, struct device_attribute *attr,
799 - char *buf)
800 +show_transport_handle(struct class_device *cdev, char *buf)
801 {
802 - struct iscsi_internal *priv = dev_to_iscsi_internal(dev);
803 + struct iscsi_internal *priv = cdev_to_iscsi_internal(cdev);
804 return sprintf(buf, "%llu\n", (unsigned long long)iscsi_handle(priv->iscsi_transport));
805 }
806 -static DEVICE_ATTR(handle, S_IRUGO, show_transport_handle, NULL);
807 +static CLASS_DEVICE_ATTR(handle, S_IRUGO, show_transport_handle, NULL);
809 #define show_transport_attr(name, format) \
810 static ssize_t \
811 -show_transport_##name(struct device *dev, \
812 - struct device_attribute *attr,char *buf) \
813 +show_transport_##name(struct class_device *cdev, char *buf) \
814 { \
815 - struct iscsi_internal *priv = dev_to_iscsi_internal(dev); \
816 + struct iscsi_internal *priv = cdev_to_iscsi_internal(cdev); \
817 return sprintf(buf, format"\n", priv->iscsi_transport->name); \
818 } \
819 -static DEVICE_ATTR(name, S_IRUGO, show_transport_##name, NULL);
820 +static CLASS_DEVICE_ATTR(name, S_IRUGO, show_transport_##name, NULL);
822 show_transport_attr(caps, "0x%x");
824 static struct attribute *iscsi_transport_attrs[] = {
825 - &dev_attr_handle.attr,
826 - &dev_attr_caps.attr,
827 + &class_device_attr_handle.attr,
828 + &class_device_attr_caps.attr,
829 NULL,
830 };
832 @@ -154,27 +152,28 @@ static struct attribute_group iscsi_transport_group = {
833 struct device_attribute dev_attr_##_prefix##_##_name = \
834 __ATTR(_name,_mode,_show,_store)
836 -static void iscsi_endpoint_release(struct device *dev)
837 +static void iscsi_endpoint_release(struct class_device *cdev)
838 {
839 - struct iscsi_endpoint *ep = iscsi_dev_to_endpoint(dev);
840 + struct iscsi_endpoint *ep = iscsi_dev_to_endpoint(cdev);
841 kfree(ep);
842 }
844 static struct class iscsi_endpoint_class = {
845 .name = "iscsi_endpoint",
846 - .dev_release = iscsi_endpoint_release,
847 + .release = iscsi_endpoint_release,
848 };
850 static ssize_t
851 -show_ep_handle(struct device *dev, struct device_attribute *attr, char *buf)
852 +show_ep_handle(struct class_device *cdev, char *buf)
853 {
854 - struct iscsi_endpoint *ep = iscsi_dev_to_endpoint(dev);
855 + struct iscsi_endpoint *ep = iscsi_dev_to_endpoint(cdev);
856 return sprintf(buf, "%llu\n", (unsigned long long) ep->id);
857 }
858 -static ISCSI_ATTR(ep, handle, S_IRUGO, show_ep_handle, NULL);
859 +static struct class_device_attribute class_device_attr_ep_handle =
860 + __ATTR(handle, S_IRUGO, show_ep_handle, NULL);
862 static struct attribute *iscsi_endpoint_attrs[] = {
863 - &dev_attr_ep_handle.attr,
864 + &class_device_attr_ep_handle.attr,
865 NULL,
866 };
868 @@ -184,26 +183,15 @@ static struct attribute_group iscsi_endpoint_group = {
870 #define ISCSI_MAX_EPID -1
872 -static int iscsi_match_epid(struct device *dev, void *data)
873 -{
874 - struct iscsi_endpoint *ep = iscsi_dev_to_endpoint(dev);
875 - uint64_t *epid = (uint64_t *) data;
876 -
877 - return *epid == ep->id;
878 -}
879 -
880 struct iscsi_endpoint *
881 iscsi_create_endpoint(int dd_size)
882 {
883 - struct device *dev;
884 struct iscsi_endpoint *ep;
885 uint64_t id;
886 int err;
888 for (id = 1; id < ISCSI_MAX_EPID; id++) {
889 - dev = class_find_device(&iscsi_endpoint_class, NULL, &id,
890 - iscsi_match_epid);
891 - if (!dev)
892 + if (!iscsi_lookup_endpoint(id))
893 break;
894 }
895 if (id == ISCSI_MAX_EPID) {
896 @@ -218,8 +206,9 @@ iscsi_create_endpoint(int dd_size)
898 ep->id = id;
899 ep->dev.class = &iscsi_endpoint_class;
900 - dev_set_name(&ep->dev, "ep-%llu", (unsigned long long) id);
901 - err = device_register(&ep->dev);
902 + snprintf(ep->dev.class_id, BUS_ID_SIZE, "ep-%llu",
903 + (unsigned long long) id);
904 + err = class_device_register(&ep->dev);
905 if (err)
906 goto free_ep;
908 @@ -232,7 +221,7 @@ iscsi_create_endpoint(int dd_size)
909 return ep;
911 unregister_dev:
912 - device_unregister(&ep->dev);
913 + class_device_unregister(&ep->dev);
914 return NULL;
916 free_ep:
917 @@ -244,32 +233,38 @@ EXPORT_SYMBOL_GPL(iscsi_create_endpoint);
918 void iscsi_destroy_endpoint(struct iscsi_endpoint *ep)
919 {
920 sysfs_remove_group(&ep->dev.kobj, &iscsi_endpoint_group);
921 - device_unregister(&ep->dev);
922 + class_device_unregister(&ep->dev);
923 }
924 EXPORT_SYMBOL_GPL(iscsi_destroy_endpoint);
926 struct iscsi_endpoint *iscsi_lookup_endpoint(u64 handle)
927 {
928 - struct iscsi_endpoint *ep;
929 - struct device *dev;
930 -
931 - dev = class_find_device(&iscsi_endpoint_class, NULL, &handle,
932 - iscsi_match_epid);
933 - if (!dev)
934 - return NULL;
935 + struct iscsi_endpoint *ep = NULL;
936 + struct class_device *cdev;
937 +
938 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22)
939 + down_read(&iscsi_endpoint_class.subsys.rwsem);
940 +#else
941 + spin_lock(&iscsi_endpoint_class.subsys.list_lock);
942 +#endif
943 + list_for_each_entry(cdev, &iscsi_endpoint_class.children, node) {
944 + ep = iscsi_dev_to_endpoint(cdev);
945 + if (ep->id == handle)
946 + break;
947 + ep = NULL;
948 + }
949 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22)
950 + up_read(&iscsi_endpoint_class.subsys.rwsem);
951 +#else
952 + spin_unlock(&iscsi_endpoint_class.subsys.list_lock);
953 +#endif
955 - ep = iscsi_dev_to_endpoint(dev);
956 - /*
957 - * we can drop this now because the interface will prevent
958 - * removals and lookups from racing.
959 - */
960 - put_device(dev);
961 return ep;
962 }
963 EXPORT_SYMBOL_GPL(iscsi_lookup_endpoint);
965 static int iscsi_setup_host(struct transport_container *tc, struct device *dev,
966 - struct device *cdev)
967 + struct class_device *cdev)
968 {
969 struct Scsi_Host *shost = dev_to_shost(dev);
970 struct iscsi_cls_host *ihost = shost->shost_data;
971 @@ -570,8 +565,6 @@ static void __iscsi_unblock_session(struct work_struct *work)
972 struct iscsi_cls_session *session =
973 container_of(work, struct iscsi_cls_session,
974 unblock_work);
975 - struct Scsi_Host *shost = iscsi_session_to_shost(session);
976 - struct iscsi_cls_host *ihost = shost->shost_data;
977 unsigned long flags;
979 ISCSI_DBG_TRANS_SESSION(session, "Unblocking session\n");
980 @@ -585,15 +578,6 @@ static void __iscsi_unblock_session(struct work_struct *work)
981 spin_unlock_irqrestore(&session->lock, flags);
982 /* start IO */
983 scsi_target_unblock(&session->dev);
984 - /*
985 - * Only do kernel scanning if the driver is properly hooked into
986 - * the async scanning code (drivers like iscsi_tcp do login and
987 - * scanning from userspace).
988 - */
989 - if (shost->hostt->scan_finished) {
990 - if (scsi_queue_work(shost, &session->scan_work))
991 - atomic_inc(&ihost->nr_scans);
992 - }
993 ISCSI_DBG_TRANS_SESSION(session, "Completed unblocking session\n");
994 }
996 @@ -749,7 +733,7 @@ int iscsi_add_session(struct iscsi_cls_session *session, unsigned int target_id)
997 }
998 session->target_id = id;
1000 - dev_set_name(&session->dev, "session%u", session->sid);
1001 + snprintf(session->dev.bus_id, BUS_ID_SIZE, "session%u", session->sid);
1002 err = device_add(&session->dev);
1003 if (err) {
1004 iscsi_cls_session_printk(KERN_ERR, session,
1005 @@ -929,7 +913,8 @@ iscsi_create_conn(struct iscsi_cls_session *session, int dd_size, uint32_t cid)
1006 if (!get_device(&session->dev))
1007 goto free_conn;
1009 - dev_set_name(&conn->dev, "connection%d:%u", session->sid, cid);
1010 + snprintf(conn->dev.bus_id, BUS_ID_SIZE, "connection%d:%u",
1011 + session->sid, cid);
1012 conn->dev.parent = &session->dev;
1013 conn->dev.release = iscsi_conn_release;
1014 err = device_register(&conn->dev);
1015 @@ -1002,7 +987,15 @@ iscsi_if_transport_lookup(struct iscsi_transport *tt)
1016 static int
1017 iscsi_multicast_skb(struct sk_buff *skb, uint32_t group, gfp_t gfp)
1018 {
1019 - return nlmsg_multicast(nls, skb, 0, group, gfp);
1020 + int err;
1021 +
1022 + NETLINK_CB(skb).dst_group = group;
1023 +
1024 + err = netlink_broadcast(nls, skb, 0, group, gfp);
1025 + if (err > 0)
1026 + err = 0;
1027 +
1028 + return err;
1029 }
1031 int iscsi_recv_pdu(struct iscsi_cls_conn *conn, struct iscsi_hdr *hdr,
1032 @@ -1642,51 +1635,65 @@ iscsi_if_recv_msg(struct sk_buff *skb, struct nlmsghdr *nlh, uint32_t *group)
1033 * Malformed skbs with wrong lengths or invalid creds are not processed.
1034 */
1035 static void
1036 -iscsi_if_rx(struct sk_buff *skb)
1037 +iscsi_if_rx(struct sock *sk, int len)
1038 {
1039 - mutex_lock(&rx_queue_mutex);
1040 - while (skb->len >= NLMSG_SPACE(0)) {
1041 - int err;
1042 - uint32_t rlen;
1043 - struct nlmsghdr *nlh;
1044 - struct iscsi_uevent *ev;
1045 - uint32_t group;
1046 -
1047 - nlh = nlmsg_hdr(skb);
1048 - if (nlh->nlmsg_len < sizeof(*nlh) ||
1049 - skb->len < nlh->nlmsg_len) {
1050 - break;
1051 - }
1052 -
1053 - ev = NLMSG_DATA(nlh);
1054 - rlen = NLMSG_ALIGN(nlh->nlmsg_len);
1055 - if (rlen > skb->len)
1056 - rlen = skb->len;
1057 + struct sk_buff *skb;
1059 - err = iscsi_if_recv_msg(skb, nlh, &group);
1060 - if (err) {
1061 - ev->type = ISCSI_KEVENT_IF_ERROR;
1062 - ev->iferror = err;
1063 + mutex_lock(&rx_queue_mutex);
1064 + while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) {
1065 + if (NETLINK_CREDS(skb)->uid) {
1066 + skb_pull(skb, skb->len);
1067 + goto free_skb;
1068 }
1069 - do {
1070 - /*
1071 - * special case for GET_STATS:
1072 - * on success - sending reply and stats from
1073 - * inside of if_recv_msg(),
1074 - * on error - fall through.
1075 - */
1076 - if (ev->type == ISCSI_UEVENT_GET_STATS && !err)
1077 +
1078 + while (skb->len >= NLMSG_SPACE(0)) {
1079 + int err;
1080 + uint32_t rlen;
1081 + struct nlmsghdr *nlh;
1082 + struct iscsi_uevent *ev;
1083 + uint32_t group;
1084 +
1085 + nlh = nlmsg_hdr(skb);
1086 + if (nlh->nlmsg_len < sizeof(*nlh) ||
1087 + skb->len < nlh->nlmsg_len) {
1088 break;
1089 - err = iscsi_if_send_reply(group, nlh->nlmsg_seq,
1090 - nlh->nlmsg_type, 0, 0, ev, sizeof(*ev));
1091 - } while (err < 0 && err != -ECONNREFUSED);
1092 - skb_pull(skb, rlen);
1093 + }
1094 +
1095 + ev = NLMSG_DATA(nlh);
1096 + rlen = NLMSG_ALIGN(nlh->nlmsg_len);
1097 + if (rlen > skb->len)
1098 + rlen = skb->len;
1099 +
1100 + err = iscsi_if_recv_msg(skb, nlh, &group);
1101 + if (err) {
1102 + ev->type = ISCSI_KEVENT_IF_ERROR;
1103 + ev->iferror = err;
1104 + }
1105 + do {
1106 + /*
1107 + * special case for GET_STATS:
1108 + * on success - sending reply and stats from
1109 + * inside of if_recv_msg(),
1110 + * on error - fall through.
1111 + */
1112 + if (ev->type == ISCSI_UEVENT_GET_STATS && !err)
1113 + break;
1114 + err = iscsi_if_send_reply(group, nlh->nlmsg_seq,
1115 + nlh->nlmsg_type, 0, 0, ev, sizeof(*ev));
1116 + } while (err < 0 && err != -ECONNREFUSED);
1117 + skb_pull(skb, rlen);
1118 + }
1119 +free_skb:
1120 + kfree_skb(skb);
1121 }
1122 mutex_unlock(&rx_queue_mutex);
1123 }
1125 +#define iscsi_cdev_to_conn(_cdev) \
1126 + iscsi_dev_to_conn(_cdev->dev)
1127 +
1128 #define ISCSI_CLASS_ATTR(_prefix,_name,_mode,_show,_store) \
1129 -struct device_attribute dev_attr_##_prefix##_##_name = \
1130 +struct class_device_attribute class_device_attr_##_prefix##_##_name = \
1131 __ATTR(_name,_mode,_show,_store)
1133 /*
1134 @@ -1694,10 +1701,9 @@ struct device_attribute dev_attr_##_prefix##_##_name = \
1135 */
1136 #define iscsi_conn_attr_show(param) \
1137 static ssize_t \
1138 -show_conn_param_##param(struct device *dev, \
1139 - struct device_attribute *attr, char *buf) \
1140 +show_conn_param_##param(struct class_device *cdev, char *buf) \
1141 { \
1142 - struct iscsi_cls_conn *conn = iscsi_dev_to_conn(dev->parent); \
1143 + struct iscsi_cls_conn *conn = iscsi_cdev_to_conn(cdev); \
1144 struct iscsi_transport *t = conn->transport; \
1145 return t->get_conn_param(conn, param, buf); \
1146 }
1147 @@ -1721,16 +1727,18 @@ iscsi_conn_attr(address, ISCSI_PARAM_CONN_ADDRESS);
1148 iscsi_conn_attr(ping_tmo, ISCSI_PARAM_PING_TMO);
1149 iscsi_conn_attr(recv_tmo, ISCSI_PARAM_RECV_TMO);
1151 +#define iscsi_cdev_to_session(_cdev) \
1152 + iscsi_dev_to_session(_cdev->dev)
1153 +
1154 /*
1155 * iSCSI session attrs
1156 */
1157 #define iscsi_session_attr_show(param, perm) \
1158 static ssize_t \
1159 -show_session_param_##param(struct device *dev, \
1160 - struct device_attribute *attr, char *buf) \
1161 +show_session_param_##param(struct class_device *cdev, char *buf) \
1162 { \
1163 struct iscsi_cls_session *session = \
1164 - iscsi_dev_to_session(dev->parent); \
1165 + iscsi_cdev_to_session(cdev); \
1166 struct iscsi_transport *t = session->transport; \
1167 \
1168 if (perm && !capable(CAP_SYS_ADMIN)) \
1169 @@ -1765,10 +1773,9 @@ iscsi_session_attr(ifacename, ISCSI_PARAM_IFACE_NAME, 0);
1170 iscsi_session_attr(initiatorname, ISCSI_PARAM_INITIATOR_NAME, 0)
1172 static ssize_t
1173 -show_priv_session_state(struct device *dev, struct device_attribute *attr,
1174 - char *buf)
1175 +show_priv_session_state(struct class_device *cdev, char *buf)
1176 {
1177 - struct iscsi_cls_session *session = iscsi_dev_to_session(dev->parent);
1178 + struct iscsi_cls_session *session = iscsi_cdev_to_session(cdev);
1179 return sprintf(buf, "%s\n", iscsi_session_state_name(session->state));
1180 }
1181 static ISCSI_CLASS_ATTR(priv_sess, state, S_IRUGO, show_priv_session_state,
1182 @@ -1776,11 +1783,10 @@ static ISCSI_CLASS_ATTR(priv_sess, state, S_IRUGO, show_priv_session_state,
1184 #define iscsi_priv_session_attr_show(field, format) \
1185 static ssize_t \
1186 -show_priv_session_##field(struct device *dev, \
1187 - struct device_attribute *attr, char *buf) \
1188 +show_priv_session_##field(struct class_device *cdev, char *buf) \
1189 { \
1190 struct iscsi_cls_session *session = \
1191 - iscsi_dev_to_session(dev->parent); \
1192 + iscsi_cdev_to_session(cdev); \
1193 return sprintf(buf, format"\n", session->field); \
1194 }
1196 @@ -1795,10 +1801,9 @@ iscsi_priv_session_attr(recovery_tmo, "%d");
1197 */
1198 #define iscsi_host_attr_show(param) \
1199 static ssize_t \
1200 -show_host_param_##param(struct device *dev, \
1201 - struct device_attribute *attr, char *buf) \
1202 +show_host_param_##param(struct class_device *cdev, char *buf) \
1203 { \
1204 - struct Scsi_Host *shost = transport_class_to_shost(dev); \
1205 + struct Scsi_Host *shost = transport_class_to_shost(cdev); \
1206 struct iscsi_internal *priv = to_iscsi_internal(shost->transportt); \
1207 return priv->iscsi_transport->get_host_param(shost, param, buf); \
1208 }
1209 @@ -1815,7 +1820,7 @@ iscsi_host_attr(initiatorname, ISCSI_HOST_PARAM_INITIATOR_NAME);
1211 #define SETUP_PRIV_SESSION_RD_ATTR(field) \
1212 do { \
1213 - priv->session_attrs[count] = &dev_attr_priv_sess_##field; \
1214 + priv->session_attrs[count] = &class_device_attr_priv_sess_##field; \
1215 count++; \
1216 } while (0)
1218 @@ -1823,7 +1828,7 @@ do { \
1219 #define SETUP_SESSION_RD_ATTR(field, param_flag) \
1220 do { \
1221 if (tt->param_mask & param_flag) { \
1222 - priv->session_attrs[count] = &dev_attr_sess_##field; \
1223 + priv->session_attrs[count] = &class_device_attr_sess_##field; \
1224 count++; \
1225 } \
1226 } while (0)
1227 @@ -1831,7 +1836,7 @@ do { \
1228 #define SETUP_CONN_RD_ATTR(field, param_flag) \
1229 do { \
1230 if (tt->param_mask & param_flag) { \
1231 - priv->conn_attrs[count] = &dev_attr_conn_##field; \
1232 + priv->conn_attrs[count] = &class_device_attr_conn_##field; \
1233 count++; \
1234 } \
1235 } while (0)
1236 @@ -1839,7 +1844,7 @@ do { \
1237 #define SETUP_HOST_RD_ATTR(field, param_flag) \
1238 do { \
1239 if (tt->host_param_mask & param_flag) { \
1240 - priv->host_attrs[count] = &dev_attr_host_##field; \
1241 + priv->host_attrs[count] = &class_device_attr_host_##field; \
1242 count++; \
1243 } \
1244 } while (0)
1245 @@ -1930,15 +1935,15 @@ iscsi_register_transport(struct iscsi_transport *tt)
1246 priv->t.user_scan = iscsi_user_scan;
1247 priv->t.create_work_queue = 1;
1249 - priv->dev.class = &iscsi_transport_class;
1250 - dev_set_name(&priv->dev, "%s", tt->name);
1251 - err = device_register(&priv->dev);
1252 + priv->cdev.class = &iscsi_transport_class;
1253 + snprintf(priv->cdev.class_id, BUS_ID_SIZE, "%s", tt->name);
1254 + err = class_device_register(&priv->cdev);
1255 if (err)
1256 goto free_priv;
1258 - err = sysfs_create_group(&priv->dev.kobj, &iscsi_transport_group);
1259 + err = sysfs_create_group(&priv->cdev.kobj, &iscsi_transport_group);
1260 if (err)
1261 - goto unregister_dev;
1262 + goto unregister_cdev;
1264 /* host parameters */
1265 priv->t.host_attrs.ac.attrs = &priv->host_attrs[0];
1266 @@ -2018,8 +2023,8 @@ iscsi_register_transport(struct iscsi_transport *tt)
1267 printk(KERN_NOTICE "iscsi: registered transport (%s)\n", tt->name);
1268 return &priv->t;
1270 -unregister_dev:
1271 - device_unregister(&priv->dev);
1272 +unregister_cdev:
1273 + class_device_unregister(&priv->cdev);
1274 return NULL;
1275 free_priv:
1276 kfree(priv);
1277 @@ -2047,8 +2052,8 @@ int iscsi_unregister_transport(struct iscsi_transport *tt)
1278 transport_container_unregister(&priv->session_cont);
1279 transport_container_unregister(&priv->t.host_attrs);
1281 - sysfs_remove_group(&priv->dev.kobj, &iscsi_transport_group);
1282 - device_unregister(&priv->dev);
1283 + sysfs_remove_group(&priv->cdev.kobj, &iscsi_transport_group);
1284 + class_device_unregister(&priv->cdev);
1285 mutex_unlock(&rx_queue_mutex);
1287 return 0;
1288 diff --git a/scsi_transport_iscsi.h b/scsi_transport_iscsi.h
1289 index ef4b697..a633ee0 100644
1290 --- a/scsi_transport_iscsi.h
1291 +++ b/scsi_transport_iscsi.h
1292 @@ -27,6 +27,7 @@
1293 #include <linux/list.h>
1294 #include <linux/mutex.h>
1295 #include "iscsi_if.h"
1296 +#include "open_iscsi_compat.h"
1298 struct scsi_transport_template;
1299 struct iscsi_transport;
1300 @@ -219,7 +220,7 @@ extern void iscsi_host_for_each_session(struct Scsi_Host *shost,
1302 struct iscsi_endpoint {
1303 void *dd_data; /* LLD private data */
1304 - struct device dev;
1305 + struct class_device dev;
1306 uint64_t id;
1307 };
1309 --
1310 1.6.0.6