[PATCH] fix missing includes
[linux-2.6.git] / drivers / scsi / scsi_transport_iscsi.c
1 /* 
2  * iSCSI transport class definitions
3  *
4  * Copyright (C) IBM Corporation, 2004
5  * Copyright (C) Mike Christie, 2004
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
20  */
21 #include <linux/module.h>
22 #include <linux/string.h>
23 #include <linux/slab.h>
24
25 #include <scsi/scsi.h>
26 #include <scsi/scsi_host.h>
27 #include <scsi/scsi_device.h>
28 #include <scsi/scsi_transport.h>
29 #include <scsi/scsi_transport_iscsi.h>
30
31 #define ISCSI_SESSION_ATTRS 20
32 #define ISCSI_HOST_ATTRS 2
33
34 struct iscsi_internal {
35         struct scsi_transport_template t;
36         struct iscsi_function_template *fnt;
37         /*
38          * We do not have any private or other attrs.
39          */
40         struct class_device_attribute *session_attrs[ISCSI_SESSION_ATTRS + 1];
41         struct class_device_attribute *host_attrs[ISCSI_HOST_ATTRS + 1];
42 };
43
44 #define to_iscsi_internal(tmpl) container_of(tmpl, struct iscsi_internal, t)
45
46 static DECLARE_TRANSPORT_CLASS(iscsi_transport_class,
47                                "iscsi_transport",
48                                NULL,
49                                NULL,
50                                NULL);
51
52 static DECLARE_TRANSPORT_CLASS(iscsi_host_class,
53                                "iscsi_host",
54                                NULL,
55                                NULL,
56                                NULL);
57 /*
58  * iSCSI target and session attrs
59  */
60 #define iscsi_session_show_fn(field, format)                            \
61                                                                         \
62 static ssize_t                                                          \
63 show_session_##field(struct class_device *cdev, char *buf)              \
64 {                                                                       \
65         struct scsi_target *starget = transport_class_to_starget(cdev); \
66         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);    \
67         struct iscsi_internal *i = to_iscsi_internal(shost->transportt); \
68                                                                         \
69         if (i->fnt->get_##field)                                        \
70                 i->fnt->get_##field(starget);                           \
71         return snprintf(buf, 20, format"\n", iscsi_##field(starget));   \
72 }
73
74 #define iscsi_session_rd_attr(field, format)                            \
75         iscsi_session_show_fn(field, format)                            \
76 static CLASS_DEVICE_ATTR(field, S_IRUGO, show_session_##field, NULL);
77
78 iscsi_session_rd_attr(tpgt, "%hu");
79 iscsi_session_rd_attr(tsih, "%2x");
80 iscsi_session_rd_attr(max_recv_data_segment_len, "%u");
81 iscsi_session_rd_attr(max_burst_len, "%u");
82 iscsi_session_rd_attr(first_burst_len, "%u");
83 iscsi_session_rd_attr(def_time2wait, "%hu");
84 iscsi_session_rd_attr(def_time2retain, "%hu");
85 iscsi_session_rd_attr(max_outstanding_r2t, "%hu");
86 iscsi_session_rd_attr(erl, "%d");
87
88
89 #define iscsi_session_show_bool_fn(field)                               \
90                                                                         \
91 static ssize_t                                                          \
92 show_session_bool_##field(struct class_device *cdev, char *buf)         \
93 {                                                                       \
94         struct scsi_target *starget = transport_class_to_starget(cdev); \
95         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);    \
96         struct iscsi_internal *i = to_iscsi_internal(shost->transportt); \
97                                                                         \
98         if (i->fnt->get_##field)                                        \
99                 i->fnt->get_##field(starget);                           \
100                                                                         \
101         if (iscsi_##field(starget))                                     \
102                 return sprintf(buf, "Yes\n");                           \
103         return sprintf(buf, "No\n");                                    \
104 }
105
106 #define iscsi_session_rd_bool_attr(field)                               \
107         iscsi_session_show_bool_fn(field)                               \
108 static CLASS_DEVICE_ATTR(field, S_IRUGO, show_session_bool_##field, NULL);
109
110 iscsi_session_rd_bool_attr(initial_r2t);
111 iscsi_session_rd_bool_attr(immediate_data);
112 iscsi_session_rd_bool_attr(data_pdu_in_order);
113 iscsi_session_rd_bool_attr(data_sequence_in_order);
114
115 #define iscsi_session_show_digest_fn(field)                             \
116                                                                         \
117 static ssize_t                                                          \
118 show_##field(struct class_device *cdev, char *buf)                      \
119 {                                                                       \
120         struct scsi_target *starget = transport_class_to_starget(cdev); \
121         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);    \
122         struct iscsi_internal *i = to_iscsi_internal(shost->transportt); \
123                                                                         \
124         if (i->fnt->get_##field)                                        \
125                 i->fnt->get_##field(starget);                           \
126                                                                         \
127         if (iscsi_##field(starget))                                     \
128                 return sprintf(buf, "CRC32C\n");                        \
129         return sprintf(buf, "None\n");                                  \
130 }
131
132 #define iscsi_session_rd_digest_attr(field)                             \
133         iscsi_session_show_digest_fn(field)                             \
134 static CLASS_DEVICE_ATTR(field, S_IRUGO, show_##field, NULL);
135
136 iscsi_session_rd_digest_attr(header_digest);
137 iscsi_session_rd_digest_attr(data_digest);
138
139 static ssize_t
140 show_port(struct class_device *cdev, char *buf)
141 {
142         struct scsi_target *starget = transport_class_to_starget(cdev);
143         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
144         struct iscsi_internal *i = to_iscsi_internal(shost->transportt);
145
146         if (i->fnt->get_port)
147                 i->fnt->get_port(starget);
148
149         return snprintf(buf, 20, "%hu\n", ntohs(iscsi_port(starget)));
150 }
151 static CLASS_DEVICE_ATTR(port, S_IRUGO, show_port, NULL);
152
153 static ssize_t
154 show_ip_address(struct class_device *cdev, char *buf)
155 {
156         struct scsi_target *starget = transport_class_to_starget(cdev);
157         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
158         struct iscsi_internal *i = to_iscsi_internal(shost->transportt);
159
160         if (i->fnt->get_ip_address)
161                 i->fnt->get_ip_address(starget);
162
163         if (iscsi_addr_type(starget) == AF_INET)
164                 return sprintf(buf, "%u.%u.%u.%u\n",
165                                NIPQUAD(iscsi_sin_addr(starget)));
166         else if(iscsi_addr_type(starget) == AF_INET6)
167                 return sprintf(buf, "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x\n",
168                                NIP6(iscsi_sin6_addr(starget)));
169         return -EINVAL;
170 }
171 static CLASS_DEVICE_ATTR(ip_address, S_IRUGO, show_ip_address, NULL);
172
173 static ssize_t
174 show_isid(struct class_device *cdev, char *buf)
175 {
176         struct scsi_target *starget = transport_class_to_starget(cdev);
177         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
178         struct iscsi_internal *i = to_iscsi_internal(shost->transportt);
179
180         if (i->fnt->get_isid)
181                 i->fnt->get_isid(starget);
182
183         return sprintf(buf, "%02x%02x%02x%02x%02x%02x\n",
184                        iscsi_isid(starget)[0], iscsi_isid(starget)[1],
185                        iscsi_isid(starget)[2], iscsi_isid(starget)[3],
186                        iscsi_isid(starget)[4], iscsi_isid(starget)[5]);
187 }
188 static CLASS_DEVICE_ATTR(isid, S_IRUGO, show_isid, NULL);
189
190 /*
191  * This is used for iSCSI names. Normally, we follow
192  * the transport class convention of having the lld
193  * set the field, but in these cases the value is
194  * too large.
195  */
196 #define iscsi_session_show_str_fn(field)                                \
197                                                                         \
198 static ssize_t                                                          \
199 show_session_str_##field(struct class_device *cdev, char *buf)          \
200 {                                                                       \
201         ssize_t ret = 0;                                                \
202         struct scsi_target *starget = transport_class_to_starget(cdev); \
203         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);    \
204         struct iscsi_internal *i = to_iscsi_internal(shost->transportt); \
205                                                                         \
206         if (i->fnt->get_##field)                                        \
207                 ret = i->fnt->get_##field(starget, buf, PAGE_SIZE);     \
208         return ret;                                                     \
209 }
210
211 #define iscsi_session_rd_str_attr(field)                                \
212         iscsi_session_show_str_fn(field)                                \
213 static CLASS_DEVICE_ATTR(field, S_IRUGO, show_session_str_##field, NULL);
214
215 iscsi_session_rd_str_attr(target_name);
216 iscsi_session_rd_str_attr(target_alias);
217
218 /*
219  * iSCSI host attrs
220  */
221
222 /*
223  * Again, this is used for iSCSI names. Normally, we follow
224  * the transport class convention of having the lld set
225  * the field, but in these cases the value is too large.
226  */
227 #define iscsi_host_show_str_fn(field)                                   \
228                                                                         \
229 static ssize_t                                                          \
230 show_host_str_##field(struct class_device *cdev, char *buf)             \
231 {                                                                       \
232         int ret = 0;                                                    \
233         struct Scsi_Host *shost = transport_class_to_shost(cdev);       \
234         struct iscsi_internal *i = to_iscsi_internal(shost->transportt); \
235                                                                         \
236         if (i->fnt->get_##field)                                        \
237                 ret = i->fnt->get_##field(shost, buf, PAGE_SIZE);       \
238         return ret;                                                     \
239 }
240
241 #define iscsi_host_rd_str_attr(field)                                   \
242         iscsi_host_show_str_fn(field)                                   \
243 static CLASS_DEVICE_ATTR(field, S_IRUGO, show_host_str_##field, NULL);
244
245 iscsi_host_rd_str_attr(initiator_name);
246 iscsi_host_rd_str_attr(initiator_alias);
247
248 #define SETUP_SESSION_RD_ATTR(field)                                    \
249         if (i->fnt->show_##field) {                                     \
250                 i->session_attrs[count] = &class_device_attr_##field;   \
251                 count++;                                                \
252         }
253
254 #define SETUP_HOST_RD_ATTR(field)                                       \
255         if (i->fnt->show_##field) {                                     \
256                 i->host_attrs[count] = &class_device_attr_##field;      \
257                 count++;                                                \
258         }
259
260 static int iscsi_host_match(struct attribute_container *cont,
261                           struct device *dev)
262 {
263         struct Scsi_Host *shost;
264         struct iscsi_internal *i;
265
266         if (!scsi_is_host_device(dev))
267                 return 0;
268
269         shost = dev_to_shost(dev);
270         if (!shost->transportt  || shost->transportt->host_attrs.ac.class
271             != &iscsi_host_class.class)
272                 return 0;
273
274         i = to_iscsi_internal(shost->transportt);
275         
276         return &i->t.host_attrs.ac == cont;
277 }
278
279 static int iscsi_target_match(struct attribute_container *cont,
280                             struct device *dev)
281 {
282         struct Scsi_Host *shost;
283         struct iscsi_internal *i;
284
285         if (!scsi_is_target_device(dev))
286                 return 0;
287
288         shost = dev_to_shost(dev->parent);
289         if (!shost->transportt  || shost->transportt->host_attrs.ac.class
290             != &iscsi_host_class.class)
291                 return 0;
292
293         i = to_iscsi_internal(shost->transportt);
294         
295         return &i->t.target_attrs.ac == cont;
296 }
297
298 struct scsi_transport_template *
299 iscsi_attach_transport(struct iscsi_function_template *fnt)
300 {
301         struct iscsi_internal *i = kmalloc(sizeof(struct iscsi_internal),
302                                            GFP_KERNEL);
303         int count = 0;
304
305         if (unlikely(!i))
306                 return NULL;
307
308         memset(i, 0, sizeof(struct iscsi_internal));
309         i->fnt = fnt;
310
311         i->t.target_attrs.ac.attrs = &i->session_attrs[0];
312         i->t.target_attrs.ac.class = &iscsi_transport_class.class;
313         i->t.target_attrs.ac.match = iscsi_target_match;
314         transport_container_register(&i->t.target_attrs);
315         i->t.target_size = sizeof(struct iscsi_class_session);
316
317         SETUP_SESSION_RD_ATTR(tsih);
318         SETUP_SESSION_RD_ATTR(isid);
319         SETUP_SESSION_RD_ATTR(header_digest);
320         SETUP_SESSION_RD_ATTR(data_digest);
321         SETUP_SESSION_RD_ATTR(target_name);
322         SETUP_SESSION_RD_ATTR(target_alias);
323         SETUP_SESSION_RD_ATTR(port);
324         SETUP_SESSION_RD_ATTR(tpgt);
325         SETUP_SESSION_RD_ATTR(ip_address);
326         SETUP_SESSION_RD_ATTR(initial_r2t);
327         SETUP_SESSION_RD_ATTR(immediate_data);
328         SETUP_SESSION_RD_ATTR(max_recv_data_segment_len);
329         SETUP_SESSION_RD_ATTR(max_burst_len);
330         SETUP_SESSION_RD_ATTR(first_burst_len);
331         SETUP_SESSION_RD_ATTR(def_time2wait);
332         SETUP_SESSION_RD_ATTR(def_time2retain);
333         SETUP_SESSION_RD_ATTR(max_outstanding_r2t);
334         SETUP_SESSION_RD_ATTR(data_pdu_in_order);
335         SETUP_SESSION_RD_ATTR(data_sequence_in_order);
336         SETUP_SESSION_RD_ATTR(erl);
337
338         BUG_ON(count > ISCSI_SESSION_ATTRS);
339         i->session_attrs[count] = NULL;
340
341         i->t.host_attrs.ac.attrs = &i->host_attrs[0];
342         i->t.host_attrs.ac.class = &iscsi_host_class.class;
343         i->t.host_attrs.ac.match = iscsi_host_match;
344         transport_container_register(&i->t.host_attrs);
345         i->t.host_size = 0;
346
347         count = 0;
348         SETUP_HOST_RD_ATTR(initiator_name);
349         SETUP_HOST_RD_ATTR(initiator_alias);
350
351         BUG_ON(count > ISCSI_HOST_ATTRS);
352         i->host_attrs[count] = NULL;
353
354         return &i->t;
355 }
356
357 EXPORT_SYMBOL(iscsi_attach_transport);
358
359 void iscsi_release_transport(struct scsi_transport_template *t)
360 {
361         struct iscsi_internal *i = to_iscsi_internal(t);
362
363         transport_container_unregister(&i->t.target_attrs);
364         transport_container_unregister(&i->t.host_attrs);
365   
366         kfree(i);
367 }
368
369 EXPORT_SYMBOL(iscsi_release_transport);
370
371 static __init int iscsi_transport_init(void)
372 {
373         int err = transport_class_register(&iscsi_transport_class);
374
375         if (err)
376                 return err;
377         return transport_class_register(&iscsi_host_class);
378 }
379
380 static void __exit iscsi_transport_exit(void)
381 {
382         transport_class_unregister(&iscsi_host_class);
383         transport_class_unregister(&iscsi_transport_class);
384 }
385
386 module_init(iscsi_transport_init);
387 module_exit(iscsi_transport_exit);
388
389 MODULE_AUTHOR("Mike Christie");
390 MODULE_DESCRIPTION("iSCSI Transport Attributes");
391 MODULE_LICENSE("GPL");