1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28#include <linux/module.h>
29#include <linux/init.h>
30#include <linux/slab.h>
31#include <linux/delay.h>
32#include <linux/kernel.h>
33#include <linux/bsg-lib.h>
34#include <scsi/scsi_device.h>
35#include <scsi/scsi_host.h>
36#include <scsi/scsi_transport.h>
37#include <scsi/scsi_transport_fc.h>
38#include <scsi/scsi_cmnd.h>
39#include <net/netlink.h>
40#include <scsi/scsi_netlink_fc.h>
41#include <scsi/scsi_bsg_fc.h>
42#include "scsi_priv.h"
43
44static int fc_queue_work(struct Scsi_Host *, struct work_struct *);
45static void fc_vport_sched_delete(struct work_struct *work);
46static int fc_vport_setup(struct Scsi_Host *shost, int channel,
47 struct device *pdev, struct fc_vport_identifiers *ids,
48 struct fc_vport **vport);
49static int fc_bsg_hostadd(struct Scsi_Host *, struct fc_host_attrs *);
50static int fc_bsg_rportadd(struct Scsi_Host *, struct fc_rport *);
51static void fc_bsg_remove(struct request_queue *);
52static void fc_bsg_goose_queue(struct fc_rport *);
53
54
55
56
57
58
59
60
61
62
63static unsigned int fc_dev_loss_tmo = 60;
64
65module_param_named(dev_loss_tmo, fc_dev_loss_tmo, uint, S_IRUGO|S_IWUSR);
66MODULE_PARM_DESC(dev_loss_tmo,
67 "Maximum number of seconds that the FC transport should"
68 " insulate the loss of a remote port. Once this value is"
69 " exceeded, the scsi target is removed. Value should be"
70 " between 1 and SCSI_DEVICE_BLOCK_MAX_TIMEOUT if"
71 " fast_io_fail_tmo is not set.");
72
73
74
75
76
77#define FC_DEVICE_ATTR(_prefix,_name,_mode,_show,_store) \
78struct device_attribute device_attr_##_prefix##_##_name = \
79 __ATTR(_name,_mode,_show,_store)
80
81#define fc_enum_name_search(title, table_type, table) \
82static const char *get_fc_##title##_name(enum table_type table_key) \
83{ \
84 int i; \
85 char *name = NULL; \
86 \
87 for (i = 0; i < ARRAY_SIZE(table); i++) { \
88 if (table[i].value == table_key) { \
89 name = table[i].name; \
90 break; \
91 } \
92 } \
93 return name; \
94}
95
96#define fc_enum_name_match(title, table_type, table) \
97static int get_fc_##title##_match(const char *table_key, \
98 enum table_type *value) \
99{ \
100 int i; \
101 \
102 for (i = 0; i < ARRAY_SIZE(table); i++) { \
103 if (strncmp(table_key, table[i].name, \
104 table[i].matchlen) == 0) { \
105 *value = table[i].value; \
106 return 0; \
107 } \
108 } \
109 return 1; \
110}
111
112
113
114static struct {
115 enum fc_port_type value;
116 char *name;
117} fc_port_type_names[] = {
118 { FC_PORTTYPE_UNKNOWN, "Unknown" },
119 { FC_PORTTYPE_OTHER, "Other" },
120 { FC_PORTTYPE_NOTPRESENT, "Not Present" },
121 { FC_PORTTYPE_NPORT, "NPort (fabric via point-to-point)" },
122 { FC_PORTTYPE_NLPORT, "NLPort (fabric via loop)" },
123 { FC_PORTTYPE_LPORT, "LPort (private loop)" },
124 { FC_PORTTYPE_PTP, "Point-To-Point (direct nport connection)" },
125 { FC_PORTTYPE_NPIV, "NPIV VPORT" },
126};
127fc_enum_name_search(port_type, fc_port_type, fc_port_type_names)
128#define FC_PORTTYPE_MAX_NAMELEN 50
129
130
131#define get_fc_vport_type_name get_fc_port_type_name
132
133
134
135static const struct {
136 enum fc_host_event_code value;
137 char *name;
138} fc_host_event_code_names[] = {
139 { FCH_EVT_LIP, "lip" },
140 { FCH_EVT_LINKUP, "link_up" },
141 { FCH_EVT_LINKDOWN, "link_down" },
142 { FCH_EVT_LIPRESET, "lip_reset" },
143 { FCH_EVT_RSCN, "rscn" },
144 { FCH_EVT_ADAPTER_CHANGE, "adapter_chg" },
145 { FCH_EVT_PORT_UNKNOWN, "port_unknown" },
146 { FCH_EVT_PORT_ONLINE, "port_online" },
147 { FCH_EVT_PORT_OFFLINE, "port_offline" },
148 { FCH_EVT_PORT_FABRIC, "port_fabric" },
149 { FCH_EVT_LINK_UNKNOWN, "link_unknown" },
150 { FCH_EVT_VENDOR_UNIQUE, "vendor_unique" },
151};
152fc_enum_name_search(host_event_code, fc_host_event_code,
153 fc_host_event_code_names)
154#define FC_HOST_EVENT_CODE_MAX_NAMELEN 30
155
156
157
158static struct {
159 enum fc_port_state value;
160 char *name;
161} fc_port_state_names[] = {
162 { FC_PORTSTATE_UNKNOWN, "Unknown" },
163 { FC_PORTSTATE_NOTPRESENT, "Not Present" },
164 { FC_PORTSTATE_ONLINE, "Online" },
165 { FC_PORTSTATE_OFFLINE, "Offline" },
166 { FC_PORTSTATE_BLOCKED, "Blocked" },
167 { FC_PORTSTATE_BYPASSED, "Bypassed" },
168 { FC_PORTSTATE_DIAGNOSTICS, "Diagnostics" },
169 { FC_PORTSTATE_LINKDOWN, "Linkdown" },
170 { FC_PORTSTATE_ERROR, "Error" },
171 { FC_PORTSTATE_LOOPBACK, "Loopback" },
172 { FC_PORTSTATE_DELETED, "Deleted" },
173};
174fc_enum_name_search(port_state, fc_port_state, fc_port_state_names)
175#define FC_PORTSTATE_MAX_NAMELEN 20
176
177
178
179static struct {
180 enum fc_vport_state value;
181 char *name;
182} fc_vport_state_names[] = {
183 { FC_VPORT_UNKNOWN, "Unknown" },
184 { FC_VPORT_ACTIVE, "Active" },
185 { FC_VPORT_DISABLED, "Disabled" },
186 { FC_VPORT_LINKDOWN, "Linkdown" },
187 { FC_VPORT_INITIALIZING, "Initializing" },
188 { FC_VPORT_NO_FABRIC_SUPP, "No Fabric Support" },
189 { FC_VPORT_NO_FABRIC_RSCS, "No Fabric Resources" },
190 { FC_VPORT_FABRIC_LOGOUT, "Fabric Logout" },
191 { FC_VPORT_FABRIC_REJ_WWN, "Fabric Rejected WWN" },
192 { FC_VPORT_FAILED, "VPort Failed" },
193};
194fc_enum_name_search(vport_state, fc_vport_state, fc_vport_state_names)
195#define FC_VPORTSTATE_MAX_NAMELEN 24
196
197
198#define get_fc_vport_last_state_name get_fc_vport_state_name
199
200
201
202static const struct {
203 enum fc_tgtid_binding_type value;
204 char *name;
205 int matchlen;
206} fc_tgtid_binding_type_names[] = {
207 { FC_TGTID_BIND_NONE, "none", 4 },
208 { FC_TGTID_BIND_BY_WWPN, "wwpn (World Wide Port Name)", 4 },
209 { FC_TGTID_BIND_BY_WWNN, "wwnn (World Wide Node Name)", 4 },
210 { FC_TGTID_BIND_BY_ID, "port_id (FC Address)", 7 },
211};
212fc_enum_name_search(tgtid_bind_type, fc_tgtid_binding_type,
213 fc_tgtid_binding_type_names)
214fc_enum_name_match(tgtid_bind_type, fc_tgtid_binding_type,
215 fc_tgtid_binding_type_names)
216#define FC_BINDTYPE_MAX_NAMELEN 30
217
218
219#define fc_bitfield_name_search(title, table) \
220static ssize_t \
221get_fc_##title##_names(u32 table_key, char *buf) \
222{ \
223 char *prefix = ""; \
224 ssize_t len = 0; \
225 int i; \
226 \
227 for (i = 0; i < ARRAY_SIZE(table); i++) { \
228 if (table[i].value & table_key) { \
229 len += sprintf(buf + len, "%s%s", \
230 prefix, table[i].name); \
231 prefix = ", "; \
232 } \
233 } \
234 len += sprintf(buf + len, "\n"); \
235 return len; \
236}
237
238
239
240static const struct {
241 u32 value;
242 char *name;
243} fc_cos_names[] = {
244 { FC_COS_CLASS1, "Class 1" },
245 { FC_COS_CLASS2, "Class 2" },
246 { FC_COS_CLASS3, "Class 3" },
247 { FC_COS_CLASS4, "Class 4" },
248 { FC_COS_CLASS6, "Class 6" },
249};
250fc_bitfield_name_search(cos, fc_cos_names)
251
252
253
254static const struct {
255 u32 value;
256 char *name;
257} fc_port_speed_names[] = {
258 { FC_PORTSPEED_1GBIT, "1 Gbit" },
259 { FC_PORTSPEED_2GBIT, "2 Gbit" },
260 { FC_PORTSPEED_4GBIT, "4 Gbit" },
261 { FC_PORTSPEED_10GBIT, "10 Gbit" },
262 { FC_PORTSPEED_8GBIT, "8 Gbit" },
263 { FC_PORTSPEED_16GBIT, "16 Gbit" },
264 { FC_PORTSPEED_32GBIT, "32 Gbit" },
265 { FC_PORTSPEED_20GBIT, "20 Gbit" },
266 { FC_PORTSPEED_40GBIT, "40 Gbit" },
267 { FC_PORTSPEED_50GBIT, "50 Gbit" },
268 { FC_PORTSPEED_100GBIT, "100 Gbit" },
269 { FC_PORTSPEED_25GBIT, "25 Gbit" },
270 { FC_PORTSPEED_64GBIT, "64 Gbit" },
271 { FC_PORTSPEED_128GBIT, "128 Gbit" },
272 { FC_PORTSPEED_NOT_NEGOTIATED, "Not Negotiated" },
273};
274fc_bitfield_name_search(port_speed, fc_port_speed_names)
275
276
277static int
278show_fc_fc4s (char *buf, u8 *fc4_list)
279{
280 int i, len=0;
281
282 for (i = 0; i < FC_FC4_LIST_SIZE; i++, fc4_list++)
283 len += sprintf(buf + len , "0x%02x ", *fc4_list);
284 len += sprintf(buf + len, "\n");
285 return len;
286}
287
288
289
290static const struct {
291 u32 value;
292 char *name;
293} fc_port_role_names[] = {
294 { FC_PORT_ROLE_FCP_TARGET, "FCP Target" },
295 { FC_PORT_ROLE_FCP_INITIATOR, "FCP Initiator" },
296 { FC_PORT_ROLE_IP_PORT, "IP Port" },
297 { FC_PORT_ROLE_FCP_DUMMY_INITIATOR, "FCP Dummy Initiator" },
298};
299fc_bitfield_name_search(port_roles, fc_port_role_names)
300
301
302
303
304#define FC_WELLKNOWN_PORTID_MASK 0xfffff0
305#define FC_WELLKNOWN_ROLE_MASK 0x00000f
306#define FC_FPORT_PORTID 0x00000e
307#define FC_FABCTLR_PORTID 0x00000d
308#define FC_DIRSRVR_PORTID 0x00000c
309#define FC_TIMESRVR_PORTID 0x00000b
310#define FC_MGMTSRVR_PORTID 0x00000a
311
312
313static void fc_timeout_deleted_rport(struct work_struct *work);
314static void fc_timeout_fail_rport_io(struct work_struct *work);
315static void fc_scsi_scan_rport(struct work_struct *work);
316
317
318
319
320
321#define FC_STARGET_NUM_ATTRS 3
322#define FC_RPORT_NUM_ATTRS 10
323#define FC_VPORT_NUM_ATTRS 9
324#define FC_HOST_NUM_ATTRS 29
325
326struct fc_internal {
327 struct scsi_transport_template t;
328 struct fc_function_template *f;
329
330
331
332
333
334
335
336
337
338
339
340 struct device_attribute private_starget_attrs[
341 FC_STARGET_NUM_ATTRS];
342 struct device_attribute *starget_attrs[FC_STARGET_NUM_ATTRS + 1];
343
344 struct device_attribute private_host_attrs[FC_HOST_NUM_ATTRS];
345 struct device_attribute *host_attrs[FC_HOST_NUM_ATTRS + 1];
346
347 struct transport_container rport_attr_cont;
348 struct device_attribute private_rport_attrs[FC_RPORT_NUM_ATTRS];
349 struct device_attribute *rport_attrs[FC_RPORT_NUM_ATTRS + 1];
350
351 struct transport_container vport_attr_cont;
352 struct device_attribute private_vport_attrs[FC_VPORT_NUM_ATTRS];
353 struct device_attribute *vport_attrs[FC_VPORT_NUM_ATTRS + 1];
354};
355
356#define to_fc_internal(tmpl) container_of(tmpl, struct fc_internal, t)
357
358static int fc_target_setup(struct transport_container *tc, struct device *dev,
359 struct device *cdev)
360{
361 struct scsi_target *starget = to_scsi_target(dev);
362 struct fc_rport *rport = starget_to_rport(starget);
363
364
365
366
367
368
369 if (rport) {
370 fc_starget_node_name(starget) = rport->node_name;
371 fc_starget_port_name(starget) = rport->port_name;
372 fc_starget_port_id(starget) = rport->port_id;
373 } else {
374 fc_starget_node_name(starget) = -1;
375 fc_starget_port_name(starget) = -1;
376 fc_starget_port_id(starget) = -1;
377 }
378
379 return 0;
380}
381
382static DECLARE_TRANSPORT_CLASS(fc_transport_class,
383 "fc_transport",
384 fc_target_setup,
385 NULL,
386 NULL);
387
388static int fc_host_setup(struct transport_container *tc, struct device *dev,
389 struct device *cdev)
390{
391 struct Scsi_Host *shost = dev_to_shost(dev);
392 struct fc_host_attrs *fc_host = shost_to_fc_host(shost);
393
394
395
396
397
398
399 fc_host->node_name = -1;
400 fc_host->port_name = -1;
401 fc_host->permanent_port_name = -1;
402 fc_host->supported_classes = FC_COS_UNSPECIFIED;
403 memset(fc_host->supported_fc4s, 0,
404 sizeof(fc_host->supported_fc4s));
405 fc_host->supported_speeds = FC_PORTSPEED_UNKNOWN;
406 fc_host->maxframe_size = -1;
407 fc_host->max_npiv_vports = 0;
408 memset(fc_host->serial_number, 0,
409 sizeof(fc_host->serial_number));
410 memset(fc_host->manufacturer, 0,
411 sizeof(fc_host->manufacturer));
412 memset(fc_host->model, 0,
413 sizeof(fc_host->model));
414 memset(fc_host->model_description, 0,
415 sizeof(fc_host->model_description));
416 memset(fc_host->hardware_version, 0,
417 sizeof(fc_host->hardware_version));
418 memset(fc_host->driver_version, 0,
419 sizeof(fc_host->driver_version));
420 memset(fc_host->firmware_version, 0,
421 sizeof(fc_host->firmware_version));
422 memset(fc_host->optionrom_version, 0,
423 sizeof(fc_host->optionrom_version));
424
425 fc_host->port_id = -1;
426 fc_host->port_type = FC_PORTTYPE_UNKNOWN;
427 fc_host->port_state = FC_PORTSTATE_UNKNOWN;
428 memset(fc_host->active_fc4s, 0,
429 sizeof(fc_host->active_fc4s));
430 fc_host->speed = FC_PORTSPEED_UNKNOWN;
431 fc_host->fabric_name = -1;
432 memset(fc_host->symbolic_name, 0, sizeof(fc_host->symbolic_name));
433 memset(fc_host->system_hostname, 0, sizeof(fc_host->system_hostname));
434
435 fc_host->tgtid_bind_type = FC_TGTID_BIND_BY_WWPN;
436
437 INIT_LIST_HEAD(&fc_host->rports);
438 INIT_LIST_HEAD(&fc_host->rport_bindings);
439 INIT_LIST_HEAD(&fc_host->vports);
440 fc_host->next_rport_number = 0;
441 fc_host->next_target_id = 0;
442 fc_host->next_vport_number = 0;
443 fc_host->npiv_vports_inuse = 0;
444
445 snprintf(fc_host->work_q_name, sizeof(fc_host->work_q_name),
446 "fc_wq_%d", shost->host_no);
447 fc_host->work_q = alloc_workqueue("%s", 0, 0, fc_host->work_q_name);
448 if (!fc_host->work_q)
449 return -ENOMEM;
450
451 fc_host->dev_loss_tmo = fc_dev_loss_tmo;
452 snprintf(fc_host->devloss_work_q_name,
453 sizeof(fc_host->devloss_work_q_name),
454 "fc_dl_%d", shost->host_no);
455 fc_host->devloss_work_q = alloc_workqueue("%s", 0, 0,
456 fc_host->devloss_work_q_name);
457 if (!fc_host->devloss_work_q) {
458 destroy_workqueue(fc_host->work_q);
459 fc_host->work_q = NULL;
460 return -ENOMEM;
461 }
462
463 fc_bsg_hostadd(shost, fc_host);
464
465
466 return 0;
467}
468
469static int fc_host_remove(struct transport_container *tc, struct device *dev,
470 struct device *cdev)
471{
472 struct Scsi_Host *shost = dev_to_shost(dev);
473 struct fc_host_attrs *fc_host = shost_to_fc_host(shost);
474
475 fc_bsg_remove(fc_host->rqst_q);
476 return 0;
477}
478
479static DECLARE_TRANSPORT_CLASS(fc_host_class,
480 "fc_host",
481 fc_host_setup,
482 fc_host_remove,
483 NULL);
484
485
486
487
488
489static DECLARE_TRANSPORT_CLASS(fc_rport_class,
490 "fc_remote_ports",
491 NULL,
492 NULL,
493 NULL);
494
495
496
497
498
499static DECLARE_TRANSPORT_CLASS(fc_vport_class,
500 "fc_vports",
501 NULL,
502 NULL,
503 NULL);
504
505
506
507
508
509static atomic_t fc_event_seq;
510
511
512
513
514
515
516
517
518
519u32
520fc_get_event_number(void)
521{
522 return atomic_add_return(1, &fc_event_seq);
523}
524EXPORT_SYMBOL(fc_get_event_number);
525
526
527
528
529
530
531
532
533
534
535
536
537void
538fc_host_post_event(struct Scsi_Host *shost, u32 event_number,
539 enum fc_host_event_code event_code, u32 event_data)
540{
541 struct sk_buff *skb;
542 struct nlmsghdr *nlh;
543 struct fc_nl_event *event;
544 const char *name;
545 u32 len;
546 int err;
547
548 if (!scsi_nl_sock) {
549 err = -ENOENT;
550 goto send_fail;
551 }
552
553 len = FC_NL_MSGALIGN(sizeof(*event));
554
555 skb = nlmsg_new(len, GFP_KERNEL);
556 if (!skb) {
557 err = -ENOBUFS;
558 goto send_fail;
559 }
560
561 nlh = nlmsg_put(skb, 0, 0, SCSI_TRANSPORT_MSG, len, 0);
562 if (!nlh) {
563 err = -ENOBUFS;
564 goto send_fail_skb;
565 }
566 event = nlmsg_data(nlh);
567
568 INIT_SCSI_NL_HDR(&event->snlh, SCSI_NL_TRANSPORT_FC,
569 FC_NL_ASYNC_EVENT, len);
570 event->seconds = ktime_get_real_seconds();
571 event->vendor_id = 0;
572 event->host_no = shost->host_no;
573 event->event_datalen = sizeof(u32);
574 event->event_num = event_number;
575 event->event_code = event_code;
576 event->event_data = event_data;
577
578 nlmsg_multicast(scsi_nl_sock, skb, 0, SCSI_NL_GRP_FC_EVENTS,
579 GFP_KERNEL);
580 return;
581
582send_fail_skb:
583 kfree_skb(skb);
584send_fail:
585 name = get_fc_host_event_code_name(event_code);
586 printk(KERN_WARNING
587 "%s: Dropped Event : host %d %s data 0x%08x - err %d\n",
588 __func__, shost->host_no,
589 (name) ? name : "<unknown>", event_data, err);
590 return;
591}
592EXPORT_SYMBOL(fc_host_post_event);
593
594
595
596
597
598
599
600
601
602
603
604
605
606void
607fc_host_post_vendor_event(struct Scsi_Host *shost, u32 event_number,
608 u32 data_len, char * data_buf, u64 vendor_id)
609{
610 struct sk_buff *skb;
611 struct nlmsghdr *nlh;
612 struct fc_nl_event *event;
613 u32 len;
614 int err;
615
616 if (!scsi_nl_sock) {
617 err = -ENOENT;
618 goto send_vendor_fail;
619 }
620
621 len = FC_NL_MSGALIGN(sizeof(*event) + data_len);
622
623 skb = nlmsg_new(len, GFP_KERNEL);
624 if (!skb) {
625 err = -ENOBUFS;
626 goto send_vendor_fail;
627 }
628
629 nlh = nlmsg_put(skb, 0, 0, SCSI_TRANSPORT_MSG, len, 0);
630 if (!nlh) {
631 err = -ENOBUFS;
632 goto send_vendor_fail_skb;
633 }
634 event = nlmsg_data(nlh);
635
636 INIT_SCSI_NL_HDR(&event->snlh, SCSI_NL_TRANSPORT_FC,
637 FC_NL_ASYNC_EVENT, len);
638 event->seconds = ktime_get_real_seconds();
639 event->vendor_id = vendor_id;
640 event->host_no = shost->host_no;
641 event->event_datalen = data_len;
642 event->event_num = event_number;
643 event->event_code = FCH_EVT_VENDOR_UNIQUE;
644 memcpy(&event->event_data, data_buf, data_len);
645
646 nlmsg_multicast(scsi_nl_sock, skb, 0, SCSI_NL_GRP_FC_EVENTS,
647 GFP_KERNEL);
648 return;
649
650send_vendor_fail_skb:
651 kfree_skb(skb);
652send_vendor_fail:
653 printk(KERN_WARNING
654 "%s: Dropped Event : host %d vendor_unique - err %d\n",
655 __func__, shost->host_no, err);
656 return;
657}
658EXPORT_SYMBOL(fc_host_post_vendor_event);
659
660
661
662static __init int fc_transport_init(void)
663{
664 int error;
665
666 atomic_set(&fc_event_seq, 0);
667
668 error = transport_class_register(&fc_host_class);
669 if (error)
670 return error;
671 error = transport_class_register(&fc_vport_class);
672 if (error)
673 goto unreg_host_class;
674 error = transport_class_register(&fc_rport_class);
675 if (error)
676 goto unreg_vport_class;
677 error = transport_class_register(&fc_transport_class);
678 if (error)
679 goto unreg_rport_class;
680 return 0;
681
682unreg_rport_class:
683 transport_class_unregister(&fc_rport_class);
684unreg_vport_class:
685 transport_class_unregister(&fc_vport_class);
686unreg_host_class:
687 transport_class_unregister(&fc_host_class);
688 return error;
689}
690
691static void __exit fc_transport_exit(void)
692{
693 transport_class_unregister(&fc_transport_class);
694 transport_class_unregister(&fc_rport_class);
695 transport_class_unregister(&fc_host_class);
696 transport_class_unregister(&fc_vport_class);
697}
698
699
700
701
702
703#define fc_rport_show_function(field, format_string, sz, cast) \
704static ssize_t \
705show_fc_rport_##field (struct device *dev, \
706 struct device_attribute *attr, char *buf) \
707{ \
708 struct fc_rport *rport = transport_class_to_rport(dev); \
709 struct Scsi_Host *shost = rport_to_shost(rport); \
710 struct fc_internal *i = to_fc_internal(shost->transportt); \
711 if ((i->f->get_rport_##field) && \
712 !((rport->port_state == FC_PORTSTATE_BLOCKED) || \
713 (rport->port_state == FC_PORTSTATE_DELETED) || \
714 (rport->port_state == FC_PORTSTATE_NOTPRESENT))) \
715 i->f->get_rport_##field(rport); \
716 return snprintf(buf, sz, format_string, cast rport->field); \
717}
718
719#define fc_rport_store_function(field) \
720static ssize_t \
721store_fc_rport_##field(struct device *dev, \
722 struct device_attribute *attr, \
723 const char *buf, size_t count) \
724{ \
725 int val; \
726 struct fc_rport *rport = transport_class_to_rport(dev); \
727 struct Scsi_Host *shost = rport_to_shost(rport); \
728 struct fc_internal *i = to_fc_internal(shost->transportt); \
729 char *cp; \
730 if ((rport->port_state == FC_PORTSTATE_BLOCKED) || \
731 (rport->port_state == FC_PORTSTATE_DELETED) || \
732 (rport->port_state == FC_PORTSTATE_NOTPRESENT)) \
733 return -EBUSY; \
734 val = simple_strtoul(buf, &cp, 0); \
735 if (*cp && (*cp != '\n')) \
736 return -EINVAL; \
737 i->f->set_rport_##field(rport, val); \
738 return count; \
739}
740
741#define fc_rport_rd_attr(field, format_string, sz) \
742 fc_rport_show_function(field, format_string, sz, ) \
743static FC_DEVICE_ATTR(rport, field, S_IRUGO, \
744 show_fc_rport_##field, NULL)
745
746#define fc_rport_rd_attr_cast(field, format_string, sz, cast) \
747 fc_rport_show_function(field, format_string, sz, (cast)) \
748static FC_DEVICE_ATTR(rport, field, S_IRUGO, \
749 show_fc_rport_##field, NULL)
750
751#define fc_rport_rw_attr(field, format_string, sz) \
752 fc_rport_show_function(field, format_string, sz, ) \
753 fc_rport_store_function(field) \
754static FC_DEVICE_ATTR(rport, field, S_IRUGO | S_IWUSR, \
755 show_fc_rport_##field, \
756 store_fc_rport_##field)
757
758
759#define fc_private_rport_show_function(field, format_string, sz, cast) \
760static ssize_t \
761show_fc_rport_##field (struct device *dev, \
762 struct device_attribute *attr, char *buf) \
763{ \
764 struct fc_rport *rport = transport_class_to_rport(dev); \
765 return snprintf(buf, sz, format_string, cast rport->field); \
766}
767
768#define fc_private_rport_rd_attr(field, format_string, sz) \
769 fc_private_rport_show_function(field, format_string, sz, ) \
770static FC_DEVICE_ATTR(rport, field, S_IRUGO, \
771 show_fc_rport_##field, NULL)
772
773#define fc_private_rport_rd_attr_cast(field, format_string, sz, cast) \
774 fc_private_rport_show_function(field, format_string, sz, (cast)) \
775static FC_DEVICE_ATTR(rport, field, S_IRUGO, \
776 show_fc_rport_##field, NULL)
777
778
779#define fc_private_rport_rd_enum_attr(title, maxlen) \
780static ssize_t \
781show_fc_rport_##title (struct device *dev, \
782 struct device_attribute *attr, char *buf) \
783{ \
784 struct fc_rport *rport = transport_class_to_rport(dev); \
785 const char *name; \
786 name = get_fc_##title##_name(rport->title); \
787 if (!name) \
788 return -EINVAL; \
789 return snprintf(buf, maxlen, "%s\n", name); \
790} \
791static FC_DEVICE_ATTR(rport, title, S_IRUGO, \
792 show_fc_rport_##title, NULL)
793
794
795#define SETUP_RPORT_ATTRIBUTE_RD(field) \
796 i->private_rport_attrs[count] = device_attr_rport_##field; \
797 i->private_rport_attrs[count].attr.mode = S_IRUGO; \
798 i->private_rport_attrs[count].store = NULL; \
799 i->rport_attrs[count] = &i->private_rport_attrs[count]; \
800 if (i->f->show_rport_##field) \
801 count++
802
803#define SETUP_PRIVATE_RPORT_ATTRIBUTE_RD(field) \
804 i->private_rport_attrs[count] = device_attr_rport_##field; \
805 i->private_rport_attrs[count].attr.mode = S_IRUGO; \
806 i->private_rport_attrs[count].store = NULL; \
807 i->rport_attrs[count] = &i->private_rport_attrs[count]; \
808 count++
809
810#define SETUP_RPORT_ATTRIBUTE_RW(field) \
811 i->private_rport_attrs[count] = device_attr_rport_##field; \
812 if (!i->f->set_rport_##field) { \
813 i->private_rport_attrs[count].attr.mode = S_IRUGO; \
814 i->private_rport_attrs[count].store = NULL; \
815 } \
816 i->rport_attrs[count] = &i->private_rport_attrs[count]; \
817 if (i->f->show_rport_##field) \
818 count++
819
820#define SETUP_PRIVATE_RPORT_ATTRIBUTE_RW(field) \
821{ \
822 i->private_rport_attrs[count] = device_attr_rport_##field; \
823 i->rport_attrs[count] = &i->private_rport_attrs[count]; \
824 count++; \
825}
826
827
828
829
830
831
832fc_private_rport_rd_attr(maxframe_size, "%u bytes\n", 20);
833
834static ssize_t
835show_fc_rport_supported_classes (struct device *dev,
836 struct device_attribute *attr, char *buf)
837{
838 struct fc_rport *rport = transport_class_to_rport(dev);
839 if (rport->supported_classes == FC_COS_UNSPECIFIED)
840 return snprintf(buf, 20, "unspecified\n");
841 return get_fc_cos_names(rport->supported_classes, buf);
842}
843static FC_DEVICE_ATTR(rport, supported_classes, S_IRUGO,
844 show_fc_rport_supported_classes, NULL);
845
846
847
848
849
850
851static int fc_str_to_dev_loss(const char *buf, unsigned long *val)
852{
853 char *cp;
854
855 *val = simple_strtoul(buf, &cp, 0);
856 if (*cp && (*cp != '\n'))
857 return -EINVAL;
858
859
860
861 if (*val > UINT_MAX)
862 return -EINVAL;
863
864 return 0;
865}
866
867static int fc_rport_set_dev_loss_tmo(struct fc_rport *rport,
868 unsigned long val)
869{
870 struct Scsi_Host *shost = rport_to_shost(rport);
871 struct fc_internal *i = to_fc_internal(shost->transportt);
872
873 if ((rport->port_state == FC_PORTSTATE_BLOCKED) ||
874 (rport->port_state == FC_PORTSTATE_DELETED) ||
875 (rport->port_state == FC_PORTSTATE_NOTPRESENT))
876 return -EBUSY;
877
878
879
880 if (val > UINT_MAX)
881 return -EINVAL;
882
883
884
885
886
887 if (rport->fast_io_fail_tmo == -1 &&
888 val > SCSI_DEVICE_BLOCK_MAX_TIMEOUT)
889 return -EINVAL;
890
891 i->f->set_rport_dev_loss_tmo(rport, val);
892 return 0;
893}
894
895fc_rport_show_function(dev_loss_tmo, "%d\n", 20, )
896static ssize_t
897store_fc_rport_dev_loss_tmo(struct device *dev, struct device_attribute *attr,
898 const char *buf, size_t count)
899{
900 struct fc_rport *rport = transport_class_to_rport(dev);
901 unsigned long val;
902 int rc;
903
904 rc = fc_str_to_dev_loss(buf, &val);
905 if (rc)
906 return rc;
907
908 rc = fc_rport_set_dev_loss_tmo(rport, val);
909 if (rc)
910 return rc;
911 return count;
912}
913static FC_DEVICE_ATTR(rport, dev_loss_tmo, S_IRUGO | S_IWUSR,
914 show_fc_rport_dev_loss_tmo, store_fc_rport_dev_loss_tmo);
915
916
917
918
919fc_private_rport_rd_attr_cast(node_name, "0x%llx\n", 20, unsigned long long);
920fc_private_rport_rd_attr_cast(port_name, "0x%llx\n", 20, unsigned long long);
921fc_private_rport_rd_attr(port_id, "0x%06x\n", 20);
922
923static ssize_t
924show_fc_rport_roles (struct device *dev, struct device_attribute *attr,
925 char *buf)
926{
927 struct fc_rport *rport = transport_class_to_rport(dev);
928
929
930 if ((rport->port_id != -1) &&
931 (rport->port_id & FC_WELLKNOWN_PORTID_MASK) ==
932 FC_WELLKNOWN_PORTID_MASK) {
933 switch (rport->port_id & FC_WELLKNOWN_ROLE_MASK) {
934 case FC_FPORT_PORTID:
935 return snprintf(buf, 30, "Fabric Port\n");
936 case FC_FABCTLR_PORTID:
937 return snprintf(buf, 30, "Fabric Controller\n");
938 case FC_DIRSRVR_PORTID:
939 return snprintf(buf, 30, "Directory Server\n");
940 case FC_TIMESRVR_PORTID:
941 return snprintf(buf, 30, "Time Server\n");
942 case FC_MGMTSRVR_PORTID:
943 return snprintf(buf, 30, "Management Server\n");
944 default:
945 return snprintf(buf, 30, "Unknown Fabric Entity\n");
946 }
947 } else {
948 if (rport->roles == FC_PORT_ROLE_UNKNOWN)
949 return snprintf(buf, 20, "unknown\n");
950 return get_fc_port_roles_names(rport->roles, buf);
951 }
952}
953static FC_DEVICE_ATTR(rport, roles, S_IRUGO,
954 show_fc_rport_roles, NULL);
955
956fc_private_rport_rd_enum_attr(port_state, FC_PORTSTATE_MAX_NAMELEN);
957fc_private_rport_rd_attr(scsi_target_id, "%d\n", 20);
958
959
960
961
962static ssize_t
963show_fc_rport_fast_io_fail_tmo (struct device *dev,
964 struct device_attribute *attr, char *buf)
965{
966 struct fc_rport *rport = transport_class_to_rport(dev);
967
968 if (rport->fast_io_fail_tmo == -1)
969 return snprintf(buf, 5, "off\n");
970 return snprintf(buf, 20, "%d\n", rport->fast_io_fail_tmo);
971}
972
973static ssize_t
974store_fc_rport_fast_io_fail_tmo(struct device *dev,
975 struct device_attribute *attr, const char *buf,
976 size_t count)
977{
978 int val;
979 char *cp;
980 struct fc_rport *rport = transport_class_to_rport(dev);
981
982 if ((rport->port_state == FC_PORTSTATE_BLOCKED) ||
983 (rport->port_state == FC_PORTSTATE_DELETED) ||
984 (rport->port_state == FC_PORTSTATE_NOTPRESENT))
985 return -EBUSY;
986 if (strncmp(buf, "off", 3) == 0)
987 rport->fast_io_fail_tmo = -1;
988 else {
989 val = simple_strtoul(buf, &cp, 0);
990 if ((*cp && (*cp != '\n')) || (val < 0))
991 return -EINVAL;
992
993
994
995
996 if ((val >= rport->dev_loss_tmo) ||
997 (val > SCSI_DEVICE_BLOCK_MAX_TIMEOUT))
998 return -EINVAL;
999
1000 rport->fast_io_fail_tmo = val;
1001 }
1002 return count;
1003}
1004static FC_DEVICE_ATTR(rport, fast_io_fail_tmo, S_IRUGO | S_IWUSR,
1005 show_fc_rport_fast_io_fail_tmo, store_fc_rport_fast_io_fail_tmo);
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018#define fc_starget_show_function(field, format_string, sz, cast) \
1019static ssize_t \
1020show_fc_starget_##field (struct device *dev, \
1021 struct device_attribute *attr, char *buf) \
1022{ \
1023 struct scsi_target *starget = transport_class_to_starget(dev); \
1024 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); \
1025 struct fc_internal *i = to_fc_internal(shost->transportt); \
1026 struct fc_rport *rport = starget_to_rport(starget); \
1027 if (rport) \
1028 fc_starget_##field(starget) = rport->field; \
1029 else if (i->f->get_starget_##field) \
1030 i->f->get_starget_##field(starget); \
1031 return snprintf(buf, sz, format_string, \
1032 cast fc_starget_##field(starget)); \
1033}
1034
1035#define fc_starget_rd_attr(field, format_string, sz) \
1036 fc_starget_show_function(field, format_string, sz, ) \
1037static FC_DEVICE_ATTR(starget, field, S_IRUGO, \
1038 show_fc_starget_##field, NULL)
1039
1040#define fc_starget_rd_attr_cast(field, format_string, sz, cast) \
1041 fc_starget_show_function(field, format_string, sz, (cast)) \
1042static FC_DEVICE_ATTR(starget, field, S_IRUGO, \
1043 show_fc_starget_##field, NULL)
1044
1045#define SETUP_STARGET_ATTRIBUTE_RD(field) \
1046 i->private_starget_attrs[count] = device_attr_starget_##field; \
1047 i->private_starget_attrs[count].attr.mode = S_IRUGO; \
1048 i->private_starget_attrs[count].store = NULL; \
1049 i->starget_attrs[count] = &i->private_starget_attrs[count]; \
1050 if (i->f->show_starget_##field) \
1051 count++
1052
1053#define SETUP_STARGET_ATTRIBUTE_RW(field) \
1054 i->private_starget_attrs[count] = device_attr_starget_##field; \
1055 if (!i->f->set_starget_##field) { \
1056 i->private_starget_attrs[count].attr.mode = S_IRUGO; \
1057 i->private_starget_attrs[count].store = NULL; \
1058 } \
1059 i->starget_attrs[count] = &i->private_starget_attrs[count]; \
1060 if (i->f->show_starget_##field) \
1061 count++
1062
1063
1064fc_starget_rd_attr_cast(node_name, "0x%llx\n", 20, unsigned long long);
1065fc_starget_rd_attr_cast(port_name, "0x%llx\n", 20, unsigned long long);
1066fc_starget_rd_attr(port_id, "0x%06x\n", 20);
1067
1068
1069
1070
1071
1072
1073#define fc_vport_show_function(field, format_string, sz, cast) \
1074static ssize_t \
1075show_fc_vport_##field (struct device *dev, \
1076 struct device_attribute *attr, char *buf) \
1077{ \
1078 struct fc_vport *vport = transport_class_to_vport(dev); \
1079 struct Scsi_Host *shost = vport_to_shost(vport); \
1080 struct fc_internal *i = to_fc_internal(shost->transportt); \
1081 if ((i->f->get_vport_##field) && \
1082 !(vport->flags & (FC_VPORT_DEL | FC_VPORT_CREATING))) \
1083 i->f->get_vport_##field(vport); \
1084 return snprintf(buf, sz, format_string, cast vport->field); \
1085}
1086
1087#define fc_vport_store_function(field) \
1088static ssize_t \
1089store_fc_vport_##field(struct device *dev, \
1090 struct device_attribute *attr, \
1091 const char *buf, size_t count) \
1092{ \
1093 int val; \
1094 struct fc_vport *vport = transport_class_to_vport(dev); \
1095 struct Scsi_Host *shost = vport_to_shost(vport); \
1096 struct fc_internal *i = to_fc_internal(shost->transportt); \
1097 char *cp; \
1098 if (vport->flags & (FC_VPORT_DEL | FC_VPORT_CREATING)) \
1099 return -EBUSY; \
1100 val = simple_strtoul(buf, &cp, 0); \
1101 if (*cp && (*cp != '\n')) \
1102 return -EINVAL; \
1103 i->f->set_vport_##field(vport, val); \
1104 return count; \
1105}
1106
1107#define fc_vport_store_str_function(field, slen) \
1108static ssize_t \
1109store_fc_vport_##field(struct device *dev, \
1110 struct device_attribute *attr, \
1111 const char *buf, size_t count) \
1112{ \
1113 struct fc_vport *vport = transport_class_to_vport(dev); \
1114 struct Scsi_Host *shost = vport_to_shost(vport); \
1115 struct fc_internal *i = to_fc_internal(shost->transportt); \
1116 unsigned int cnt=count; \
1117 \
1118 \
1119 if (buf[cnt-1] == '\n') \
1120 cnt--; \
1121 if (cnt > ((slen) - 1)) \
1122 return -EINVAL; \
1123 memcpy(vport->field, buf, cnt); \
1124 i->f->set_vport_##field(vport); \
1125 return count; \
1126}
1127
1128#define fc_vport_rd_attr(field, format_string, sz) \
1129 fc_vport_show_function(field, format_string, sz, ) \
1130static FC_DEVICE_ATTR(vport, field, S_IRUGO, \
1131 show_fc_vport_##field, NULL)
1132
1133#define fc_vport_rd_attr_cast(field, format_string, sz, cast) \
1134 fc_vport_show_function(field, format_string, sz, (cast)) \
1135static FC_DEVICE_ATTR(vport, field, S_IRUGO, \
1136 show_fc_vport_##field, NULL)
1137
1138#define fc_vport_rw_attr(field, format_string, sz) \
1139 fc_vport_show_function(field, format_string, sz, ) \
1140 fc_vport_store_function(field) \
1141static FC_DEVICE_ATTR(vport, field, S_IRUGO | S_IWUSR, \
1142 show_fc_vport_##field, \
1143 store_fc_vport_##field)
1144
1145#define fc_private_vport_show_function(field, format_string, sz, cast) \
1146static ssize_t \
1147show_fc_vport_##field (struct device *dev, \
1148 struct device_attribute *attr, char *buf) \
1149{ \
1150 struct fc_vport *vport = transport_class_to_vport(dev); \
1151 return snprintf(buf, sz, format_string, cast vport->field); \
1152}
1153
1154#define fc_private_vport_store_u32_function(field) \
1155static ssize_t \
1156store_fc_vport_##field(struct device *dev, \
1157 struct device_attribute *attr, \
1158 const char *buf, size_t count) \
1159{ \
1160 u32 val; \
1161 struct fc_vport *vport = transport_class_to_vport(dev); \
1162 char *cp; \
1163 if (vport->flags & (FC_VPORT_DEL | FC_VPORT_CREATING)) \
1164 return -EBUSY; \
1165 val = simple_strtoul(buf, &cp, 0); \
1166 if (*cp && (*cp != '\n')) \
1167 return -EINVAL; \
1168 vport->field = val; \
1169 return count; \
1170}
1171
1172
1173#define fc_private_vport_rd_attr(field, format_string, sz) \
1174 fc_private_vport_show_function(field, format_string, sz, ) \
1175static FC_DEVICE_ATTR(vport, field, S_IRUGO, \
1176 show_fc_vport_##field, NULL)
1177
1178#define fc_private_vport_rd_attr_cast(field, format_string, sz, cast) \
1179 fc_private_vport_show_function(field, format_string, sz, (cast)) \
1180static FC_DEVICE_ATTR(vport, field, S_IRUGO, \
1181 show_fc_vport_##field, NULL)
1182
1183#define fc_private_vport_rw_u32_attr(field, format_string, sz) \
1184 fc_private_vport_show_function(field, format_string, sz, ) \
1185 fc_private_vport_store_u32_function(field) \
1186static FC_DEVICE_ATTR(vport, field, S_IRUGO | S_IWUSR, \
1187 show_fc_vport_##field, \
1188 store_fc_vport_##field)
1189
1190
1191#define fc_private_vport_rd_enum_attr(title, maxlen) \
1192static ssize_t \
1193show_fc_vport_##title (struct device *dev, \
1194 struct device_attribute *attr, \
1195 char *buf) \
1196{ \
1197 struct fc_vport *vport = transport_class_to_vport(dev); \
1198 const char *name; \
1199 name = get_fc_##title##_name(vport->title); \
1200 if (!name) \
1201 return -EINVAL; \
1202 return snprintf(buf, maxlen, "%s\n", name); \
1203} \
1204static FC_DEVICE_ATTR(vport, title, S_IRUGO, \
1205 show_fc_vport_##title, NULL)
1206
1207
1208#define SETUP_VPORT_ATTRIBUTE_RD(field) \
1209 i->private_vport_attrs[count] = device_attr_vport_##field; \
1210 i->private_vport_attrs[count].attr.mode = S_IRUGO; \
1211 i->private_vport_attrs[count].store = NULL; \
1212 i->vport_attrs[count] = &i->private_vport_attrs[count]; \
1213 if (i->f->get_##field) \
1214 count++
1215
1216
1217#define SETUP_PRIVATE_VPORT_ATTRIBUTE_RD(field) \
1218 i->private_vport_attrs[count] = device_attr_vport_##field; \
1219 i->private_vport_attrs[count].attr.mode = S_IRUGO; \
1220 i->private_vport_attrs[count].store = NULL; \
1221 i->vport_attrs[count] = &i->private_vport_attrs[count]; \
1222 count++
1223
1224#define SETUP_VPORT_ATTRIBUTE_WR(field) \
1225 i->private_vport_attrs[count] = device_attr_vport_##field; \
1226 i->vport_attrs[count] = &i->private_vport_attrs[count]; \
1227 if (i->f->field) \
1228 count++
1229
1230
1231#define SETUP_VPORT_ATTRIBUTE_RW(field) \
1232 i->private_vport_attrs[count] = device_attr_vport_##field; \
1233 if (!i->f->set_vport_##field) { \
1234 i->private_vport_attrs[count].attr.mode = S_IRUGO; \
1235 i->private_vport_attrs[count].store = NULL; \
1236 } \
1237 i->vport_attrs[count] = &i->private_vport_attrs[count]; \
1238 count++
1239
1240
1241#define SETUP_PRIVATE_VPORT_ATTRIBUTE_RW(field) \
1242{ \
1243 i->private_vport_attrs[count] = device_attr_vport_##field; \
1244 i->vport_attrs[count] = &i->private_vport_attrs[count]; \
1245 count++; \
1246}
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257fc_private_vport_rd_enum_attr(vport_state, FC_VPORTSTATE_MAX_NAMELEN);
1258fc_private_vport_rd_enum_attr(vport_last_state, FC_VPORTSTATE_MAX_NAMELEN);
1259fc_private_vport_rd_attr_cast(node_name, "0x%llx\n", 20, unsigned long long);
1260fc_private_vport_rd_attr_cast(port_name, "0x%llx\n", 20, unsigned long long);
1261
1262static ssize_t
1263show_fc_vport_roles (struct device *dev, struct device_attribute *attr,
1264 char *buf)
1265{
1266 struct fc_vport *vport = transport_class_to_vport(dev);
1267
1268 if (vport->roles == FC_PORT_ROLE_UNKNOWN)
1269 return snprintf(buf, 20, "unknown\n");
1270 return get_fc_port_roles_names(vport->roles, buf);
1271}
1272static FC_DEVICE_ATTR(vport, roles, S_IRUGO, show_fc_vport_roles, NULL);
1273
1274fc_private_vport_rd_enum_attr(vport_type, FC_PORTTYPE_MAX_NAMELEN);
1275
1276fc_private_vport_show_function(symbolic_name, "%s\n",
1277 FC_VPORT_SYMBOLIC_NAMELEN + 1, )
1278fc_vport_store_str_function(symbolic_name, FC_VPORT_SYMBOLIC_NAMELEN)
1279static FC_DEVICE_ATTR(vport, symbolic_name, S_IRUGO | S_IWUSR,
1280 show_fc_vport_symbolic_name, store_fc_vport_symbolic_name);
1281
1282static ssize_t
1283store_fc_vport_delete(struct device *dev, struct device_attribute *attr,
1284 const char *buf, size_t count)
1285{
1286 struct fc_vport *vport = transport_class_to_vport(dev);
1287 struct Scsi_Host *shost = vport_to_shost(vport);
1288 unsigned long flags;
1289
1290 spin_lock_irqsave(shost->host_lock, flags);
1291 if (vport->flags & (FC_VPORT_DEL | FC_VPORT_CREATING | FC_VPORT_DELETING)) {
1292 spin_unlock_irqrestore(shost->host_lock, flags);
1293 return -EBUSY;
1294 }
1295 vport->flags |= FC_VPORT_DELETING;
1296 spin_unlock_irqrestore(shost->host_lock, flags);
1297
1298 fc_queue_work(shost, &vport->vport_delete_work);
1299 return count;
1300}
1301static FC_DEVICE_ATTR(vport, vport_delete, S_IWUSR,
1302 NULL, store_fc_vport_delete);
1303
1304
1305
1306
1307
1308
1309static ssize_t
1310store_fc_vport_disable(struct device *dev, struct device_attribute *attr,
1311 const char *buf,
1312 size_t count)
1313{
1314 struct fc_vport *vport = transport_class_to_vport(dev);
1315 struct Scsi_Host *shost = vport_to_shost(vport);
1316 struct fc_internal *i = to_fc_internal(shost->transportt);
1317 int stat;
1318
1319 if (vport->flags & (FC_VPORT_DEL | FC_VPORT_CREATING))
1320 return -EBUSY;
1321
1322 if (*buf == '0') {
1323 if (vport->vport_state != FC_VPORT_DISABLED)
1324 return -EALREADY;
1325 } else if (*buf == '1') {
1326 if (vport->vport_state == FC_VPORT_DISABLED)
1327 return -EALREADY;
1328 } else
1329 return -EINVAL;
1330
1331 stat = i->f->vport_disable(vport, ((*buf == '0') ? false : true));
1332 return stat ? stat : count;
1333}
1334static FC_DEVICE_ATTR(vport, vport_disable, S_IWUSR,
1335 NULL, store_fc_vport_disable);
1336
1337
1338
1339
1340
1341
1342#define fc_host_show_function(field, format_string, sz, cast) \
1343static ssize_t \
1344show_fc_host_##field (struct device *dev, \
1345 struct device_attribute *attr, char *buf) \
1346{ \
1347 struct Scsi_Host *shost = transport_class_to_shost(dev); \
1348 struct fc_internal *i = to_fc_internal(shost->transportt); \
1349 if (i->f->get_host_##field) \
1350 i->f->get_host_##field(shost); \
1351 return snprintf(buf, sz, format_string, cast fc_host_##field(shost)); \
1352}
1353
1354#define fc_host_store_function(field) \
1355static ssize_t \
1356store_fc_host_##field(struct device *dev, \
1357 struct device_attribute *attr, \
1358 const char *buf, size_t count) \
1359{ \
1360 int val; \
1361 struct Scsi_Host *shost = transport_class_to_shost(dev); \
1362 struct fc_internal *i = to_fc_internal(shost->transportt); \
1363 char *cp; \
1364 \
1365 val = simple_strtoul(buf, &cp, 0); \
1366 if (*cp && (*cp != '\n')) \
1367 return -EINVAL; \
1368 i->f->set_host_##field(shost, val); \
1369 return count; \
1370}
1371
1372#define fc_host_store_str_function(field, slen) \
1373static ssize_t \
1374store_fc_host_##field(struct device *dev, \
1375 struct device_attribute *attr, \
1376 const char *buf, size_t count) \
1377{ \
1378 struct Scsi_Host *shost = transport_class_to_shost(dev); \
1379 struct fc_internal *i = to_fc_internal(shost->transportt); \
1380 unsigned int cnt=count; \
1381 \
1382 \
1383 if (buf[cnt-1] == '\n') \
1384 cnt--; \
1385 if (cnt > ((slen) - 1)) \
1386 return -EINVAL; \
1387 memcpy(fc_host_##field(shost), buf, cnt); \
1388 i->f->set_host_##field(shost); \
1389 return count; \
1390}
1391
1392#define fc_host_rd_attr(field, format_string, sz) \
1393 fc_host_show_function(field, format_string, sz, ) \
1394static FC_DEVICE_ATTR(host, field, S_IRUGO, \
1395 show_fc_host_##field, NULL)
1396
1397#define fc_host_rd_attr_cast(field, format_string, sz, cast) \
1398 fc_host_show_function(field, format_string, sz, (cast)) \
1399static FC_DEVICE_ATTR(host, field, S_IRUGO, \
1400 show_fc_host_##field, NULL)
1401
1402#define fc_host_rw_attr(field, format_string, sz) \
1403 fc_host_show_function(field, format_string, sz, ) \
1404 fc_host_store_function(field) \
1405static FC_DEVICE_ATTR(host, field, S_IRUGO | S_IWUSR, \
1406 show_fc_host_##field, \
1407 store_fc_host_##field)
1408
1409#define fc_host_rd_enum_attr(title, maxlen) \
1410static ssize_t \
1411show_fc_host_##title (struct device *dev, \
1412 struct device_attribute *attr, char *buf) \
1413{ \
1414 struct Scsi_Host *shost = transport_class_to_shost(dev); \
1415 struct fc_internal *i = to_fc_internal(shost->transportt); \
1416 const char *name; \
1417 if (i->f->get_host_##title) \
1418 i->f->get_host_##title(shost); \
1419 name = get_fc_##title##_name(fc_host_##title(shost)); \
1420 if (!name) \
1421 return -EINVAL; \
1422 return snprintf(buf, maxlen, "%s\n", name); \
1423} \
1424static FC_DEVICE_ATTR(host, title, S_IRUGO, show_fc_host_##title, NULL)
1425
1426#define SETUP_HOST_ATTRIBUTE_RD(field) \
1427 i->private_host_attrs[count] = device_attr_host_##field; \
1428 i->private_host_attrs[count].attr.mode = S_IRUGO; \
1429 i->private_host_attrs[count].store = NULL; \
1430 i->host_attrs[count] = &i->private_host_attrs[count]; \
1431 if (i->f->show_host_##field) \
1432 count++
1433
1434#define SETUP_HOST_ATTRIBUTE_RD_NS(field) \
1435 i->private_host_attrs[count] = device_attr_host_##field; \
1436 i->private_host_attrs[count].attr.mode = S_IRUGO; \
1437 i->private_host_attrs[count].store = NULL; \
1438 i->host_attrs[count] = &i->private_host_attrs[count]; \
1439 count++
1440
1441#define SETUP_HOST_ATTRIBUTE_RW(field) \
1442 i->private_host_attrs[count] = device_attr_host_##field; \
1443 if (!i->f->set_host_##field) { \
1444 i->private_host_attrs[count].attr.mode = S_IRUGO; \
1445 i->private_host_attrs[count].store = NULL; \
1446 } \
1447 i->host_attrs[count] = &i->private_host_attrs[count]; \
1448 if (i->f->show_host_##field) \
1449 count++
1450
1451
1452#define fc_private_host_show_function(field, format_string, sz, cast) \
1453static ssize_t \
1454show_fc_host_##field (struct device *dev, \
1455 struct device_attribute *attr, char *buf) \
1456{ \
1457 struct Scsi_Host *shost = transport_class_to_shost(dev); \
1458 return snprintf(buf, sz, format_string, cast fc_host_##field(shost)); \
1459}
1460
1461#define fc_private_host_rd_attr(field, format_string, sz) \
1462 fc_private_host_show_function(field, format_string, sz, ) \
1463static FC_DEVICE_ATTR(host, field, S_IRUGO, \
1464 show_fc_host_##field, NULL)
1465
1466#define fc_private_host_rd_attr_cast(field, format_string, sz, cast) \
1467 fc_private_host_show_function(field, format_string, sz, (cast)) \
1468static FC_DEVICE_ATTR(host, field, S_IRUGO, \
1469 show_fc_host_##field, NULL)
1470
1471#define SETUP_PRIVATE_HOST_ATTRIBUTE_RD(field) \
1472 i->private_host_attrs[count] = device_attr_host_##field; \
1473 i->private_host_attrs[count].attr.mode = S_IRUGO; \
1474 i->private_host_attrs[count].store = NULL; \
1475 i->host_attrs[count] = &i->private_host_attrs[count]; \
1476 count++
1477
1478#define SETUP_PRIVATE_HOST_ATTRIBUTE_RW(field) \
1479{ \
1480 i->private_host_attrs[count] = device_attr_host_##field; \
1481 i->host_attrs[count] = &i->private_host_attrs[count]; \
1482 count++; \
1483}
1484
1485
1486
1487
1488static ssize_t
1489show_fc_host_supported_classes (struct device *dev,
1490 struct device_attribute *attr, char *buf)
1491{
1492 struct Scsi_Host *shost = transport_class_to_shost(dev);
1493
1494 if (fc_host_supported_classes(shost) == FC_COS_UNSPECIFIED)
1495 return snprintf(buf, 20, "unspecified\n");
1496
1497 return get_fc_cos_names(fc_host_supported_classes(shost), buf);
1498}
1499static FC_DEVICE_ATTR(host, supported_classes, S_IRUGO,
1500 show_fc_host_supported_classes, NULL);
1501
1502static ssize_t
1503show_fc_host_supported_fc4s (struct device *dev,
1504 struct device_attribute *attr, char *buf)
1505{
1506 struct Scsi_Host *shost = transport_class_to_shost(dev);
1507 return (ssize_t)show_fc_fc4s(buf, fc_host_supported_fc4s(shost));
1508}
1509static FC_DEVICE_ATTR(host, supported_fc4s, S_IRUGO,
1510 show_fc_host_supported_fc4s, NULL);
1511
1512static ssize_t
1513show_fc_host_supported_speeds (struct device *dev,
1514 struct device_attribute *attr, char *buf)
1515{
1516 struct Scsi_Host *shost = transport_class_to_shost(dev);
1517
1518 if (fc_host_supported_speeds(shost) == FC_PORTSPEED_UNKNOWN)
1519 return snprintf(buf, 20, "unknown\n");
1520
1521 return get_fc_port_speed_names(fc_host_supported_speeds(shost), buf);
1522}
1523static FC_DEVICE_ATTR(host, supported_speeds, S_IRUGO,
1524 show_fc_host_supported_speeds, NULL);
1525
1526
1527fc_private_host_rd_attr_cast(node_name, "0x%llx\n", 20, unsigned long long);
1528fc_private_host_rd_attr_cast(port_name, "0x%llx\n", 20, unsigned long long);
1529fc_private_host_rd_attr_cast(permanent_port_name, "0x%llx\n", 20,
1530 unsigned long long);
1531fc_private_host_rd_attr(maxframe_size, "%u bytes\n", 20);
1532fc_private_host_rd_attr(max_npiv_vports, "%u\n", 20);
1533fc_private_host_rd_attr(serial_number, "%s\n", (FC_SERIAL_NUMBER_SIZE +1));
1534fc_private_host_rd_attr(manufacturer, "%s\n", FC_SERIAL_NUMBER_SIZE + 1);
1535fc_private_host_rd_attr(model, "%s\n", FC_SYMBOLIC_NAME_SIZE + 1);
1536fc_private_host_rd_attr(model_description, "%s\n", FC_SYMBOLIC_NAME_SIZE + 1);
1537fc_private_host_rd_attr(hardware_version, "%s\n", FC_VERSION_STRING_SIZE + 1);
1538fc_private_host_rd_attr(driver_version, "%s\n", FC_VERSION_STRING_SIZE + 1);
1539fc_private_host_rd_attr(firmware_version, "%s\n", FC_VERSION_STRING_SIZE + 1);
1540fc_private_host_rd_attr(optionrom_version, "%s\n", FC_VERSION_STRING_SIZE + 1);
1541
1542
1543
1544
1545static ssize_t
1546show_fc_host_active_fc4s (struct device *dev,
1547 struct device_attribute *attr, char *buf)
1548{
1549 struct Scsi_Host *shost = transport_class_to_shost(dev);
1550 struct fc_internal *i = to_fc_internal(shost->transportt);
1551
1552 if (i->f->get_host_active_fc4s)
1553 i->f->get_host_active_fc4s(shost);
1554
1555 return (ssize_t)show_fc_fc4s(buf, fc_host_active_fc4s(shost));
1556}
1557static FC_DEVICE_ATTR(host, active_fc4s, S_IRUGO,
1558 show_fc_host_active_fc4s, NULL);
1559
1560static ssize_t
1561show_fc_host_speed (struct device *dev,
1562 struct device_attribute *attr, char *buf)
1563{
1564 struct Scsi_Host *shost = transport_class_to_shost(dev);
1565 struct fc_internal *i = to_fc_internal(shost->transportt);
1566
1567 if (i->f->get_host_speed)
1568 i->f->get_host_speed(shost);
1569
1570 if (fc_host_speed(shost) == FC_PORTSPEED_UNKNOWN)
1571 return snprintf(buf, 20, "unknown\n");
1572
1573 return get_fc_port_speed_names(fc_host_speed(shost), buf);
1574}
1575static FC_DEVICE_ATTR(host, speed, S_IRUGO,
1576 show_fc_host_speed, NULL);
1577
1578
1579fc_host_rd_attr(port_id, "0x%06x\n", 20);
1580fc_host_rd_enum_attr(port_type, FC_PORTTYPE_MAX_NAMELEN);
1581fc_host_rd_enum_attr(port_state, FC_PORTSTATE_MAX_NAMELEN);
1582fc_host_rd_attr_cast(fabric_name, "0x%llx\n", 20, unsigned long long);
1583fc_host_rd_attr(symbolic_name, "%s\n", FC_SYMBOLIC_NAME_SIZE + 1);
1584
1585fc_private_host_show_function(system_hostname, "%s\n",
1586 FC_SYMBOLIC_NAME_SIZE + 1, )
1587fc_host_store_str_function(system_hostname, FC_SYMBOLIC_NAME_SIZE)
1588static FC_DEVICE_ATTR(host, system_hostname, S_IRUGO | S_IWUSR,
1589 show_fc_host_system_hostname, store_fc_host_system_hostname);
1590
1591
1592
1593
1594static ssize_t
1595show_fc_private_host_tgtid_bind_type(struct device *dev,
1596 struct device_attribute *attr, char *buf)
1597{
1598 struct Scsi_Host *shost = transport_class_to_shost(dev);
1599 const char *name;
1600
1601 name = get_fc_tgtid_bind_type_name(fc_host_tgtid_bind_type(shost));
1602 if (!name)
1603 return -EINVAL;
1604 return snprintf(buf, FC_BINDTYPE_MAX_NAMELEN, "%s\n", name);
1605}
1606
1607#define get_list_head_entry(pos, head, member) \
1608 pos = list_entry((head)->next, typeof(*pos), member)
1609
1610static ssize_t
1611store_fc_private_host_tgtid_bind_type(struct device *dev,
1612 struct device_attribute *attr, const char *buf, size_t count)
1613{
1614 struct Scsi_Host *shost = transport_class_to_shost(dev);
1615 struct fc_rport *rport;
1616 enum fc_tgtid_binding_type val;
1617 unsigned long flags;
1618
1619 if (get_fc_tgtid_bind_type_match(buf, &val))
1620 return -EINVAL;
1621
1622
1623 if (val != fc_host_tgtid_bind_type(shost)) {
1624 spin_lock_irqsave(shost->host_lock, flags);
1625 while (!list_empty(&fc_host_rport_bindings(shost))) {
1626 get_list_head_entry(rport,
1627 &fc_host_rport_bindings(shost), peers);
1628 list_del(&rport->peers);
1629 rport->port_state = FC_PORTSTATE_DELETED;
1630 fc_queue_work(shost, &rport->rport_delete_work);
1631 }
1632 spin_unlock_irqrestore(shost->host_lock, flags);
1633 }
1634
1635 fc_host_tgtid_bind_type(shost) = val;
1636 return count;
1637}
1638
1639static FC_DEVICE_ATTR(host, tgtid_bind_type, S_IRUGO | S_IWUSR,
1640 show_fc_private_host_tgtid_bind_type,
1641 store_fc_private_host_tgtid_bind_type);
1642
1643static ssize_t
1644store_fc_private_host_issue_lip(struct device *dev,
1645 struct device_attribute *attr, const char *buf, size_t count)
1646{
1647 struct Scsi_Host *shost = transport_class_to_shost(dev);
1648 struct fc_internal *i = to_fc_internal(shost->transportt);
1649 int ret;
1650
1651
1652 if (i->f->issue_fc_host_lip) {
1653 ret = i->f->issue_fc_host_lip(shost);
1654 return ret ? ret: count;
1655 }
1656
1657 return -ENOENT;
1658}
1659
1660static FC_DEVICE_ATTR(host, issue_lip, S_IWUSR, NULL,
1661 store_fc_private_host_issue_lip);
1662
1663static ssize_t
1664store_fc_private_host_dev_loss_tmo(struct device *dev,
1665 struct device_attribute *attr,
1666 const char *buf, size_t count)
1667{
1668 struct Scsi_Host *shost = transport_class_to_shost(dev);
1669 struct fc_host_attrs *fc_host = shost_to_fc_host(shost);
1670 struct fc_rport *rport;
1671 unsigned long val, flags;
1672 int rc;
1673
1674 rc = fc_str_to_dev_loss(buf, &val);
1675 if (rc)
1676 return rc;
1677
1678 fc_host_dev_loss_tmo(shost) = val;
1679 spin_lock_irqsave(shost->host_lock, flags);
1680 list_for_each_entry(rport, &fc_host->rports, peers)
1681 fc_rport_set_dev_loss_tmo(rport, val);
1682 spin_unlock_irqrestore(shost->host_lock, flags);
1683 return count;
1684}
1685
1686fc_private_host_show_function(dev_loss_tmo, "%d\n", 20, );
1687static FC_DEVICE_ATTR(host, dev_loss_tmo, S_IRUGO | S_IWUSR,
1688 show_fc_host_dev_loss_tmo,
1689 store_fc_private_host_dev_loss_tmo);
1690
1691fc_private_host_rd_attr(npiv_vports_inuse, "%u\n", 20);
1692
1693
1694
1695
1696
1697
1698static ssize_t
1699fc_stat_show(const struct device *dev, char *buf, unsigned long offset)
1700{
1701 struct Scsi_Host *shost = transport_class_to_shost(dev);
1702 struct fc_internal *i = to_fc_internal(shost->transportt);
1703 struct fc_host_statistics *stats;
1704 ssize_t ret = -ENOENT;
1705
1706 if (offset > sizeof(struct fc_host_statistics) ||
1707 offset % sizeof(u64) != 0)
1708 WARN_ON(1);
1709
1710 if (i->f->get_fc_host_stats) {
1711 stats = (i->f->get_fc_host_stats)(shost);
1712 if (stats)
1713 ret = snprintf(buf, 20, "0x%llx\n",
1714 (unsigned long long)*(u64 *)(((u8 *) stats) + offset));
1715 }
1716 return ret;
1717}
1718
1719
1720
1721#define fc_host_statistic(name) \
1722static ssize_t show_fcstat_##name(struct device *cd, \
1723 struct device_attribute *attr, \
1724 char *buf) \
1725{ \
1726 return fc_stat_show(cd, buf, \
1727 offsetof(struct fc_host_statistics, name)); \
1728} \
1729static FC_DEVICE_ATTR(host, name, S_IRUGO, show_fcstat_##name, NULL)
1730
1731fc_host_statistic(seconds_since_last_reset);
1732fc_host_statistic(tx_frames);
1733fc_host_statistic(tx_words);
1734fc_host_statistic(rx_frames);
1735fc_host_statistic(rx_words);
1736fc_host_statistic(lip_count);
1737fc_host_statistic(nos_count);
1738fc_host_statistic(error_frames);
1739fc_host_statistic(dumped_frames);
1740fc_host_statistic(link_failure_count);
1741fc_host_statistic(loss_of_sync_count);
1742fc_host_statistic(loss_of_signal_count);
1743fc_host_statistic(prim_seq_protocol_err_count);
1744fc_host_statistic(invalid_tx_word_count);
1745fc_host_statistic(invalid_crc_count);
1746fc_host_statistic(fcp_input_requests);
1747fc_host_statistic(fcp_output_requests);
1748fc_host_statistic(fcp_control_requests);
1749fc_host_statistic(fcp_input_megabytes);
1750fc_host_statistic(fcp_output_megabytes);
1751fc_host_statistic(fcp_packet_alloc_failures);
1752fc_host_statistic(fcp_packet_aborts);
1753fc_host_statistic(fcp_frame_alloc_failures);
1754fc_host_statistic(fc_no_free_exch);
1755fc_host_statistic(fc_no_free_exch_xid);
1756fc_host_statistic(fc_xid_not_found);
1757fc_host_statistic(fc_xid_busy);
1758fc_host_statistic(fc_seq_not_found);
1759fc_host_statistic(fc_non_bls_resp);
1760
1761static ssize_t
1762fc_reset_statistics(struct device *dev, struct device_attribute *attr,
1763 const char *buf, size_t count)
1764{
1765 struct Scsi_Host *shost = transport_class_to_shost(dev);
1766 struct fc_internal *i = to_fc_internal(shost->transportt);
1767
1768
1769 if (i->f->reset_fc_host_stats) {
1770 i->f->reset_fc_host_stats(shost);
1771 return count;
1772 }
1773
1774 return -ENOENT;
1775}
1776static FC_DEVICE_ATTR(host, reset_statistics, S_IWUSR, NULL,
1777 fc_reset_statistics);
1778
1779static struct attribute *fc_statistics_attrs[] = {
1780 &device_attr_host_seconds_since_last_reset.attr,
1781 &device_attr_host_tx_frames.attr,
1782 &device_attr_host_tx_words.attr,
1783 &device_attr_host_rx_frames.attr,
1784 &device_attr_host_rx_words.attr,
1785 &device_attr_host_lip_count.attr,
1786 &device_attr_host_nos_count.attr,
1787 &device_attr_host_error_frames.attr,
1788 &device_attr_host_dumped_frames.attr,
1789 &device_attr_host_link_failure_count.attr,
1790 &device_attr_host_loss_of_sync_count.attr,
1791 &device_attr_host_loss_of_signal_count.attr,
1792 &device_attr_host_prim_seq_protocol_err_count.attr,
1793 &device_attr_host_invalid_tx_word_count.attr,
1794 &device_attr_host_invalid_crc_count.attr,
1795 &device_attr_host_fcp_input_requests.attr,
1796 &device_attr_host_fcp_output_requests.attr,
1797 &device_attr_host_fcp_control_requests.attr,
1798 &device_attr_host_fcp_input_megabytes.attr,
1799 &device_attr_host_fcp_output_megabytes.attr,
1800 &device_attr_host_fcp_packet_alloc_failures.attr,
1801 &device_attr_host_fcp_packet_aborts.attr,
1802 &device_attr_host_fcp_frame_alloc_failures.attr,
1803 &device_attr_host_fc_no_free_exch.attr,
1804 &device_attr_host_fc_no_free_exch_xid.attr,
1805 &device_attr_host_fc_xid_not_found.attr,
1806 &device_attr_host_fc_xid_busy.attr,
1807 &device_attr_host_fc_seq_not_found.attr,
1808 &device_attr_host_fc_non_bls_resp.attr,
1809 &device_attr_host_reset_statistics.attr,
1810 NULL
1811};
1812
1813static struct attribute_group fc_statistics_group = {
1814 .name = "statistics",
1815 .attrs = fc_statistics_attrs,
1816};
1817
1818
1819
1820
1821static int
1822fc_parse_wwn(const char *ns, u64 *nm)
1823{
1824 unsigned int i, j;
1825 u8 wwn[8];
1826
1827 memset(wwn, 0, sizeof(wwn));
1828
1829
1830 for (i=0, j=0; i < 16; i++) {
1831 int value;
1832
1833 value = hex_to_bin(*ns++);
1834 if (value >= 0)
1835 j = (j << 4) | value;
1836 else
1837 return -EINVAL;
1838 if (i % 2) {
1839 wwn[i/2] = j & 0xff;
1840 j = 0;
1841 }
1842 }
1843
1844 *nm = wwn_to_u64(wwn);
1845
1846 return 0;
1847}
1848
1849
1850
1851
1852
1853
1854
1855
1856static ssize_t
1857store_fc_host_vport_create(struct device *dev, struct device_attribute *attr,
1858 const char *buf, size_t count)
1859{
1860 struct Scsi_Host *shost = transport_class_to_shost(dev);
1861 struct fc_vport_identifiers vid;
1862 struct fc_vport *vport;
1863 unsigned int cnt=count;
1864 int stat;
1865
1866 memset(&vid, 0, sizeof(vid));
1867
1868
1869 if (buf[cnt-1] == '\n')
1870 cnt--;
1871
1872
1873 if ((cnt != (16+1+16)) || (buf[16] != ':'))
1874 return -EINVAL;
1875
1876 stat = fc_parse_wwn(&buf[0], &vid.port_name);
1877 if (stat)
1878 return stat;
1879
1880 stat = fc_parse_wwn(&buf[17], &vid.node_name);
1881 if (stat)
1882 return stat;
1883
1884 vid.roles = FC_PORT_ROLE_FCP_INITIATOR;
1885 vid.vport_type = FC_PORTTYPE_NPIV;
1886
1887 vid.disable = false;
1888
1889
1890 stat = fc_vport_setup(shost, 0, &shost->shost_gendev, &vid, &vport);
1891 return stat ? stat : count;
1892}
1893static FC_DEVICE_ATTR(host, vport_create, S_IWUSR, NULL,
1894 store_fc_host_vport_create);
1895
1896
1897
1898
1899
1900
1901
1902
1903static ssize_t
1904store_fc_host_vport_delete(struct device *dev, struct device_attribute *attr,
1905 const char *buf, size_t count)
1906{
1907 struct Scsi_Host *shost = transport_class_to_shost(dev);
1908 struct fc_host_attrs *fc_host = shost_to_fc_host(shost);
1909 struct fc_vport *vport;
1910 u64 wwpn, wwnn;
1911 unsigned long flags;
1912 unsigned int cnt=count;
1913 int stat, match;
1914
1915
1916 if (buf[cnt-1] == '\n')
1917 cnt--;
1918
1919
1920 if ((cnt != (16+1+16)) || (buf[16] != ':'))
1921 return -EINVAL;
1922
1923 stat = fc_parse_wwn(&buf[0], &wwpn);
1924 if (stat)
1925 return stat;
1926
1927 stat = fc_parse_wwn(&buf[17], &wwnn);
1928 if (stat)
1929 return stat;
1930
1931 spin_lock_irqsave(shost->host_lock, flags);
1932 match = 0;
1933
1934 list_for_each_entry(vport, &fc_host->vports, peers) {
1935 if ((vport->channel == 0) &&
1936 (vport->port_name == wwpn) && (vport->node_name == wwnn)) {
1937 if (vport->flags & (FC_VPORT_DEL | FC_VPORT_CREATING))
1938 break;
1939 vport->flags |= FC_VPORT_DELETING;
1940 match = 1;
1941 break;
1942 }
1943 }
1944 spin_unlock_irqrestore(shost->host_lock, flags);
1945
1946 if (!match)
1947 return -ENODEV;
1948
1949 stat = fc_vport_terminate(vport);
1950 return stat ? stat : count;
1951}
1952static FC_DEVICE_ATTR(host, vport_delete, S_IWUSR, NULL,
1953 store_fc_host_vport_delete);
1954
1955
1956static int fc_host_match(struct attribute_container *cont,
1957 struct device *dev)
1958{
1959 struct Scsi_Host *shost;
1960 struct fc_internal *i;
1961
1962 if (!scsi_is_host_device(dev))
1963 return 0;
1964
1965 shost = dev_to_shost(dev);
1966 if (!shost->transportt || shost->transportt->host_attrs.ac.class
1967 != &fc_host_class.class)
1968 return 0;
1969
1970 i = to_fc_internal(shost->transportt);
1971
1972 return &i->t.host_attrs.ac == cont;
1973}
1974
1975static int fc_target_match(struct attribute_container *cont,
1976 struct device *dev)
1977{
1978 struct Scsi_Host *shost;
1979 struct fc_internal *i;
1980
1981 if (!scsi_is_target_device(dev))
1982 return 0;
1983
1984 shost = dev_to_shost(dev->parent);
1985 if (!shost->transportt || shost->transportt->host_attrs.ac.class
1986 != &fc_host_class.class)
1987 return 0;
1988
1989 i = to_fc_internal(shost->transportt);
1990
1991 return &i->t.target_attrs.ac == cont;
1992}
1993
1994static void fc_rport_dev_release(struct device *dev)
1995{
1996 struct fc_rport *rport = dev_to_rport(dev);
1997 put_device(dev->parent);
1998 kfree(rport);
1999}
2000
2001int scsi_is_fc_rport(const struct device *dev)
2002{
2003 return dev->release == fc_rport_dev_release;
2004}
2005EXPORT_SYMBOL(scsi_is_fc_rport);
2006
2007static int fc_rport_match(struct attribute_container *cont,
2008 struct device *dev)
2009{
2010 struct Scsi_Host *shost;
2011 struct fc_internal *i;
2012
2013 if (!scsi_is_fc_rport(dev))
2014 return 0;
2015
2016 shost = dev_to_shost(dev->parent);
2017 if (!shost->transportt || shost->transportt->host_attrs.ac.class
2018 != &fc_host_class.class)
2019 return 0;
2020
2021 i = to_fc_internal(shost->transportt);
2022
2023 return &i->rport_attr_cont.ac == cont;
2024}
2025
2026
2027static void fc_vport_dev_release(struct device *dev)
2028{
2029 struct fc_vport *vport = dev_to_vport(dev);
2030 put_device(dev->parent);
2031 kfree(vport);
2032}
2033
2034static int scsi_is_fc_vport(const struct device *dev)
2035{
2036 return dev->release == fc_vport_dev_release;
2037}
2038
2039static int fc_vport_match(struct attribute_container *cont,
2040 struct device *dev)
2041{
2042 struct fc_vport *vport;
2043 struct Scsi_Host *shost;
2044 struct fc_internal *i;
2045
2046 if (!scsi_is_fc_vport(dev))
2047 return 0;
2048 vport = dev_to_vport(dev);
2049
2050 shost = vport_to_shost(vport);
2051 if (!shost->transportt || shost->transportt->host_attrs.ac.class
2052 != &fc_host_class.class)
2053 return 0;
2054
2055 i = to_fc_internal(shost->transportt);
2056 return &i->vport_attr_cont.ac == cont;
2057}
2058
2059
2060
2061
2062
2063
2064
2065
2066
2067
2068
2069
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082enum blk_eh_timer_return
2083fc_eh_timed_out(struct scsi_cmnd *scmd)
2084{
2085 struct fc_rport *rport = starget_to_rport(scsi_target(scmd->device));
2086
2087 if (rport->port_state == FC_PORTSTATE_BLOCKED)
2088 return BLK_EH_RESET_TIMER;
2089
2090 return BLK_EH_DONE;
2091}
2092EXPORT_SYMBOL(fc_eh_timed_out);
2093
2094
2095
2096
2097
2098
2099static void
2100fc_user_scan_tgt(struct Scsi_Host *shost, uint channel, uint id, u64 lun)
2101{
2102 struct fc_rport *rport;
2103 unsigned long flags;
2104
2105 spin_lock_irqsave(shost->host_lock, flags);
2106
2107 list_for_each_entry(rport, &fc_host_rports(shost), peers) {
2108 if (rport->scsi_target_id == -1)
2109 continue;
2110
2111 if (rport->port_state != FC_PORTSTATE_ONLINE)
2112 continue;
2113
2114 if ((channel == rport->channel) &&
2115 (id == rport->scsi_target_id)) {
2116 spin_unlock_irqrestore(shost->host_lock, flags);
2117 scsi_scan_target(&rport->dev, channel, id, lun,
2118 SCSI_SCAN_MANUAL);
2119 return;
2120 }
2121 }
2122
2123 spin_unlock_irqrestore(shost->host_lock, flags);
2124}
2125
2126
2127
2128
2129
2130
2131
2132static int
2133fc_user_scan(struct Scsi_Host *shost, uint channel, uint id, u64 lun)
2134{
2135 uint chlo, chhi;
2136 uint tgtlo, tgthi;
2137
2138 if (((channel != SCAN_WILD_CARD) && (channel > shost->max_channel)) ||
2139 ((id != SCAN_WILD_CARD) && (id >= shost->max_id)) ||
2140 ((lun != SCAN_WILD_CARD) && (lun > shost->max_lun)))
2141 return -EINVAL;
2142
2143 if (channel == SCAN_WILD_CARD) {
2144 chlo = 0;
2145 chhi = shost->max_channel + 1;
2146 } else {
2147 chlo = channel;
2148 chhi = channel + 1;
2149 }
2150
2151 if (id == SCAN_WILD_CARD) {
2152 tgtlo = 0;
2153 tgthi = shost->max_id;
2154 } else {
2155 tgtlo = id;
2156 tgthi = id + 1;
2157 }
2158
2159 for ( ; chlo < chhi; chlo++)
2160 for ( ; tgtlo < tgthi; tgtlo++)
2161 fc_user_scan_tgt(shost, chlo, tgtlo, lun);
2162
2163 return 0;
2164}
2165
2166struct scsi_transport_template *
2167fc_attach_transport(struct fc_function_template *ft)
2168{
2169 int count;
2170 struct fc_internal *i = kzalloc(sizeof(struct fc_internal),
2171 GFP_KERNEL);
2172
2173 if (unlikely(!i))
2174 return NULL;
2175
2176 i->t.target_attrs.ac.attrs = &i->starget_attrs[0];
2177 i->t.target_attrs.ac.class = &fc_transport_class.class;
2178 i->t.target_attrs.ac.match = fc_target_match;
2179 i->t.target_size = sizeof(struct fc_starget_attrs);
2180 transport_container_register(&i->t.target_attrs);
2181
2182 i->t.host_attrs.ac.attrs = &i->host_attrs[0];
2183 i->t.host_attrs.ac.class = &fc_host_class.class;
2184 i->t.host_attrs.ac.match = fc_host_match;
2185 i->t.host_size = sizeof(struct fc_host_attrs);
2186 if (ft->get_fc_host_stats)
2187 i->t.host_attrs.statistics = &fc_statistics_group;
2188 transport_container_register(&i->t.host_attrs);
2189
2190 i->rport_attr_cont.ac.attrs = &i->rport_attrs[0];
2191 i->rport_attr_cont.ac.class = &fc_rport_class.class;
2192 i->rport_attr_cont.ac.match = fc_rport_match;
2193 transport_container_register(&i->rport_attr_cont);
2194
2195 i->vport_attr_cont.ac.attrs = &i->vport_attrs[0];
2196 i->vport_attr_cont.ac.class = &fc_vport_class.class;
2197 i->vport_attr_cont.ac.match = fc_vport_match;
2198 transport_container_register(&i->vport_attr_cont);
2199
2200 i->f = ft;
2201
2202
2203 i->t.create_work_queue = 1;
2204
2205 i->t.user_scan = fc_user_scan;
2206
2207
2208
2209
2210 count = 0;
2211 SETUP_STARGET_ATTRIBUTE_RD(node_name);
2212 SETUP_STARGET_ATTRIBUTE_RD(port_name);
2213 SETUP_STARGET_ATTRIBUTE_RD(port_id);
2214
2215 BUG_ON(count > FC_STARGET_NUM_ATTRS);
2216
2217 i->starget_attrs[count] = NULL;
2218
2219
2220
2221
2222
2223 count=0;
2224 SETUP_HOST_ATTRIBUTE_RD(node_name);
2225 SETUP_HOST_ATTRIBUTE_RD(port_name);
2226 SETUP_HOST_ATTRIBUTE_RD(permanent_port_name);
2227 SETUP_HOST_ATTRIBUTE_RD(supported_classes);
2228 SETUP_HOST_ATTRIBUTE_RD(supported_fc4s);
2229 SETUP_HOST_ATTRIBUTE_RD(supported_speeds);
2230 SETUP_HOST_ATTRIBUTE_RD(maxframe_size);
2231 if (ft->vport_create) {
2232 SETUP_HOST_ATTRIBUTE_RD_NS(max_npiv_vports);
2233 SETUP_HOST_ATTRIBUTE_RD_NS(npiv_vports_inuse);
2234 }
2235 SETUP_HOST_ATTRIBUTE_RD(serial_number);
2236 SETUP_HOST_ATTRIBUTE_RD(manufacturer);
2237 SETUP_HOST_ATTRIBUTE_RD(model);
2238 SETUP_HOST_ATTRIBUTE_RD(model_description);
2239 SETUP_HOST_ATTRIBUTE_RD(hardware_version);
2240 SETUP_HOST_ATTRIBUTE_RD(driver_version);
2241 SETUP_HOST_ATTRIBUTE_RD(firmware_version);
2242 SETUP_HOST_ATTRIBUTE_RD(optionrom_version);
2243
2244 SETUP_HOST_ATTRIBUTE_RD(port_id);
2245 SETUP_HOST_ATTRIBUTE_RD(port_type);
2246 SETUP_HOST_ATTRIBUTE_RD(port_state);
2247 SETUP_HOST_ATTRIBUTE_RD(active_fc4s);
2248 SETUP_HOST_ATTRIBUTE_RD(speed);
2249 SETUP_HOST_ATTRIBUTE_RD(fabric_name);
2250 SETUP_HOST_ATTRIBUTE_RD(symbolic_name);
2251 SETUP_HOST_ATTRIBUTE_RW(system_hostname);
2252
2253
2254 SETUP_PRIVATE_HOST_ATTRIBUTE_RW(dev_loss_tmo);
2255 SETUP_PRIVATE_HOST_ATTRIBUTE_RW(tgtid_bind_type);
2256 if (ft->issue_fc_host_lip)
2257 SETUP_PRIVATE_HOST_ATTRIBUTE_RW(issue_lip);
2258 if (ft->vport_create)
2259 SETUP_PRIVATE_HOST_ATTRIBUTE_RW(vport_create);
2260 if (ft->vport_delete)
2261 SETUP_PRIVATE_HOST_ATTRIBUTE_RW(vport_delete);
2262
2263 BUG_ON(count > FC_HOST_NUM_ATTRS);
2264
2265 i->host_attrs[count] = NULL;
2266
2267
2268
2269
2270 count=0;
2271 SETUP_RPORT_ATTRIBUTE_RD(maxframe_size);
2272 SETUP_RPORT_ATTRIBUTE_RD(supported_classes);
2273 SETUP_RPORT_ATTRIBUTE_RW(dev_loss_tmo);
2274 SETUP_PRIVATE_RPORT_ATTRIBUTE_RD(node_name);
2275 SETUP_PRIVATE_RPORT_ATTRIBUTE_RD(port_name);
2276 SETUP_PRIVATE_RPORT_ATTRIBUTE_RD(port_id);
2277 SETUP_PRIVATE_RPORT_ATTRIBUTE_RD(roles);
2278 SETUP_PRIVATE_RPORT_ATTRIBUTE_RD(port_state);
2279 SETUP_PRIVATE_RPORT_ATTRIBUTE_RD(scsi_target_id);
2280 SETUP_PRIVATE_RPORT_ATTRIBUTE_RW(fast_io_fail_tmo);
2281
2282 BUG_ON(count > FC_RPORT_NUM_ATTRS);
2283
2284 i->rport_attrs[count] = NULL;
2285
2286
2287
2288
2289 count=0;
2290 SETUP_PRIVATE_VPORT_ATTRIBUTE_RD(vport_state);
2291 SETUP_PRIVATE_VPORT_ATTRIBUTE_RD(vport_last_state);
2292 SETUP_PRIVATE_VPORT_ATTRIBUTE_RD(node_name);
2293 SETUP_PRIVATE_VPORT_ATTRIBUTE_RD(port_name);
2294 SETUP_PRIVATE_VPORT_ATTRIBUTE_RD(roles);
2295 SETUP_PRIVATE_VPORT_ATTRIBUTE_RD(vport_type);
2296 SETUP_VPORT_ATTRIBUTE_RW(symbolic_name);
2297 SETUP_VPORT_ATTRIBUTE_WR(vport_delete);
2298 SETUP_VPORT_ATTRIBUTE_WR(vport_disable);
2299
2300 BUG_ON(count > FC_VPORT_NUM_ATTRS);
2301
2302 i->vport_attrs[count] = NULL;
2303
2304 return &i->t;
2305}
2306EXPORT_SYMBOL(fc_attach_transport);
2307
2308void fc_release_transport(struct scsi_transport_template *t)
2309{
2310 struct fc_internal *i = to_fc_internal(t);
2311
2312 transport_container_unregister(&i->t.target_attrs);
2313 transport_container_unregister(&i->t.host_attrs);
2314 transport_container_unregister(&i->rport_attr_cont);
2315 transport_container_unregister(&i->vport_attr_cont);
2316
2317 kfree(i);
2318}
2319EXPORT_SYMBOL(fc_release_transport);
2320
2321
2322
2323
2324
2325
2326
2327
2328
2329
2330
2331static int
2332fc_queue_work(struct Scsi_Host *shost, struct work_struct *work)
2333{
2334 if (unlikely(!fc_host_work_q(shost))) {
2335 printk(KERN_ERR
2336 "ERROR: FC host '%s' attempted to queue work, "
2337 "when no workqueue created.\n", shost->hostt->name);
2338 dump_stack();
2339
2340 return -EINVAL;
2341 }
2342
2343 return queue_work(fc_host_work_q(shost), work);
2344}
2345
2346
2347
2348
2349
2350static void
2351fc_flush_work(struct Scsi_Host *shost)
2352{
2353 if (!fc_host_work_q(shost)) {
2354 printk(KERN_ERR
2355 "ERROR: FC host '%s' attempted to flush work, "
2356 "when no workqueue created.\n", shost->hostt->name);
2357 dump_stack();
2358 return;
2359 }
2360
2361 flush_workqueue(fc_host_work_q(shost));
2362}
2363
2364
2365
2366
2367
2368
2369
2370
2371
2372
2373static int
2374fc_queue_devloss_work(struct Scsi_Host *shost, struct delayed_work *work,
2375 unsigned long delay)
2376{
2377 if (unlikely(!fc_host_devloss_work_q(shost))) {
2378 printk(KERN_ERR
2379 "ERROR: FC host '%s' attempted to queue work, "
2380 "when no workqueue created.\n", shost->hostt->name);
2381 dump_stack();
2382
2383 return -EINVAL;
2384 }
2385
2386 return queue_delayed_work(fc_host_devloss_work_q(shost), work, delay);
2387}
2388
2389
2390
2391
2392
2393static void
2394fc_flush_devloss(struct Scsi_Host *shost)
2395{
2396 if (!fc_host_devloss_work_q(shost)) {
2397 printk(KERN_ERR
2398 "ERROR: FC host '%s' attempted to flush work, "
2399 "when no workqueue created.\n", shost->hostt->name);
2400 dump_stack();
2401 return;
2402 }
2403
2404 flush_workqueue(fc_host_devloss_work_q(shost));
2405}
2406
2407
2408
2409
2410
2411
2412
2413
2414
2415
2416
2417
2418
2419
2420
2421
2422
2423void
2424fc_remove_host(struct Scsi_Host *shost)
2425{
2426 struct fc_vport *vport = NULL, *next_vport = NULL;
2427 struct fc_rport *rport = NULL, *next_rport = NULL;
2428 struct workqueue_struct *work_q;
2429 struct fc_host_attrs *fc_host = shost_to_fc_host(shost);
2430 unsigned long flags;
2431
2432 spin_lock_irqsave(shost->host_lock, flags);
2433
2434
2435 list_for_each_entry_safe(vport, next_vport, &fc_host->vports, peers) {
2436 vport->flags |= FC_VPORT_DELETING;
2437 fc_queue_work(shost, &vport->vport_delete_work);
2438 }
2439
2440
2441 list_for_each_entry_safe(rport, next_rport,
2442 &fc_host->rports, peers) {
2443 list_del(&rport->peers);
2444 rport->port_state = FC_PORTSTATE_DELETED;
2445 fc_queue_work(shost, &rport->rport_delete_work);
2446 }
2447
2448 list_for_each_entry_safe(rport, next_rport,
2449 &fc_host->rport_bindings, peers) {
2450 list_del(&rport->peers);
2451 rport->port_state = FC_PORTSTATE_DELETED;
2452 fc_queue_work(shost, &rport->rport_delete_work);
2453 }
2454
2455 spin_unlock_irqrestore(shost->host_lock, flags);
2456
2457
2458 scsi_flush_work(shost);
2459
2460
2461 if (fc_host->work_q) {
2462 work_q = fc_host->work_q;
2463 fc_host->work_q = NULL;
2464 destroy_workqueue(work_q);
2465 }
2466
2467
2468 if (fc_host->devloss_work_q) {
2469 work_q = fc_host->devloss_work_q;
2470 fc_host->devloss_work_q = NULL;
2471 destroy_workqueue(work_q);
2472 }
2473}
2474EXPORT_SYMBOL(fc_remove_host);
2475
2476static void fc_terminate_rport_io(struct fc_rport *rport)
2477{
2478 struct Scsi_Host *shost = rport_to_shost(rport);
2479 struct fc_internal *i = to_fc_internal(shost->transportt);
2480
2481
2482 if (i->f->terminate_rport_io)
2483 i->f->terminate_rport_io(rport);
2484
2485
2486
2487
2488 scsi_target_unblock(&rport->dev, SDEV_TRANSPORT_OFFLINE);
2489}
2490
2491
2492
2493
2494
2495
2496
2497static void
2498fc_starget_delete(struct work_struct *work)
2499{
2500 struct fc_rport *rport =
2501 container_of(work, struct fc_rport, stgt_delete_work);
2502
2503 fc_terminate_rport_io(rport);
2504 scsi_remove_target(&rport->dev);
2505}
2506
2507
2508
2509
2510
2511
2512static void
2513fc_rport_final_delete(struct work_struct *work)
2514{
2515 struct fc_rport *rport =
2516 container_of(work, struct fc_rport, rport_delete_work);
2517 struct device *dev = &rport->dev;
2518 struct Scsi_Host *shost = rport_to_shost(rport);
2519 struct fc_internal *i = to_fc_internal(shost->transportt);
2520 unsigned long flags;
2521 int do_callback = 0;
2522
2523 fc_terminate_rport_io(rport);
2524
2525
2526
2527
2528
2529 if (rport->flags & FC_RPORT_SCAN_PENDING)
2530 scsi_flush_work(shost);
2531
2532
2533
2534
2535
2536
2537 spin_lock_irqsave(shost->host_lock, flags);
2538 if (rport->flags & FC_RPORT_DEVLOSS_PENDING) {
2539 spin_unlock_irqrestore(shost->host_lock, flags);
2540 if (!cancel_delayed_work(&rport->fail_io_work))
2541 fc_flush_devloss(shost);
2542 if (!cancel_delayed_work(&rport->dev_loss_work))
2543 fc_flush_devloss(shost);
2544 cancel_work_sync(&rport->scan_work);
2545 spin_lock_irqsave(shost->host_lock, flags);
2546 rport->flags &= ~FC_RPORT_DEVLOSS_PENDING;
2547 }
2548 spin_unlock_irqrestore(shost->host_lock, flags);
2549
2550
2551 if (rport->scsi_target_id != -1)
2552 fc_starget_delete(&rport->stgt_delete_work);
2553
2554
2555
2556
2557
2558
2559
2560
2561 spin_lock_irqsave(shost->host_lock, flags);
2562 if (!(rport->flags & FC_RPORT_DEVLOSS_CALLBK_DONE) &&
2563 (i->f->dev_loss_tmo_callbk)) {
2564 rport->flags |= FC_RPORT_DEVLOSS_CALLBK_DONE;
2565 do_callback = 1;
2566 }
2567 spin_unlock_irqrestore(shost->host_lock, flags);
2568
2569 if (do_callback)
2570 i->f->dev_loss_tmo_callbk(rport);
2571
2572 fc_bsg_remove(rport->rqst_q);
2573
2574 transport_remove_device(dev);
2575 device_del(dev);
2576 transport_destroy_device(dev);
2577 scsi_host_put(shost);
2578 put_device(dev);
2579}
2580
2581
2582
2583
2584
2585
2586
2587
2588
2589
2590
2591
2592
2593
2594
2595static struct fc_rport *
2596fc_remote_port_create(struct Scsi_Host *shost, int channel,
2597 struct fc_rport_identifiers *ids)
2598{
2599 struct fc_host_attrs *fc_host = shost_to_fc_host(shost);
2600 struct fc_internal *fci = to_fc_internal(shost->transportt);
2601 struct fc_rport *rport;
2602 struct device *dev;
2603 unsigned long flags;
2604 int error;
2605 size_t size;
2606
2607 size = (sizeof(struct fc_rport) + fci->f->dd_fcrport_size);
2608 rport = kzalloc(size, GFP_KERNEL);
2609 if (unlikely(!rport)) {
2610 printk(KERN_ERR "%s: allocation failure\n", __func__);
2611 return NULL;
2612 }
2613
2614 rport->maxframe_size = -1;
2615 rport->supported_classes = FC_COS_UNSPECIFIED;
2616 rport->dev_loss_tmo = fc_host->dev_loss_tmo;
2617 memcpy(&rport->node_name, &ids->node_name, sizeof(rport->node_name));
2618 memcpy(&rport->port_name, &ids->port_name, sizeof(rport->port_name));
2619 rport->port_id = ids->port_id;
2620 rport->roles = ids->roles;
2621 rport->port_state = FC_PORTSTATE_ONLINE;
2622 if (fci->f->dd_fcrport_size)
2623 rport->dd_data = &rport[1];
2624 rport->channel = channel;
2625 rport->fast_io_fail_tmo = -1;
2626
2627 INIT_DELAYED_WORK(&rport->dev_loss_work, fc_timeout_deleted_rport);
2628 INIT_DELAYED_WORK(&rport->fail_io_work, fc_timeout_fail_rport_io);
2629 INIT_WORK(&rport->scan_work, fc_scsi_scan_rport);
2630 INIT_WORK(&rport->stgt_delete_work, fc_starget_delete);
2631 INIT_WORK(&rport->rport_delete_work, fc_rport_final_delete);
2632
2633 spin_lock_irqsave(shost->host_lock, flags);
2634
2635 rport->number = fc_host->next_rport_number++;
2636 if ((rport->roles & FC_PORT_ROLE_FCP_TARGET) ||
2637 (rport->roles & FC_PORT_ROLE_FCP_DUMMY_INITIATOR))
2638 rport->scsi_target_id = fc_host->next_target_id++;
2639 else
2640 rport->scsi_target_id = -1;
2641 list_add_tail(&rport->peers, &fc_host->rports);
2642 scsi_host_get(shost);
2643
2644 spin_unlock_irqrestore(shost->host_lock, flags);
2645
2646 dev = &rport->dev;
2647 device_initialize(dev);
2648 dev->parent = get_device(&shost->shost_gendev);
2649 dev->release = fc_rport_dev_release;
2650 dev_set_name(dev, "rport-%d:%d-%d",
2651 shost->host_no, channel, rport->number);
2652 transport_setup_device(dev);
2653
2654 error = device_add(dev);
2655 if (error) {
2656 printk(KERN_ERR "FC Remote Port device_add failed\n");
2657 goto delete_rport;
2658 }
2659 transport_add_device(dev);
2660 transport_configure_device(dev);
2661
2662 fc_bsg_rportadd(shost, rport);
2663
2664
2665 if (rport->roles & FC_PORT_ROLE_FCP_TARGET) {
2666
2667 rport->flags |= FC_RPORT_SCAN_PENDING;
2668 scsi_queue_work(shost, &rport->scan_work);
2669 }
2670
2671 return rport;
2672
2673delete_rport:
2674 transport_destroy_device(dev);
2675 spin_lock_irqsave(shost->host_lock, flags);
2676 list_del(&rport->peers);
2677 scsi_host_put(shost);
2678 spin_unlock_irqrestore(shost->host_lock, flags);
2679 put_device(dev->parent);
2680 kfree(rport);
2681 return NULL;
2682}
2683
2684
2685
2686
2687
2688
2689
2690
2691
2692
2693
2694
2695
2696
2697
2698
2699
2700
2701
2702
2703
2704
2705
2706
2707
2708
2709
2710
2711
2712
2713
2714
2715
2716
2717
2718
2719
2720
2721
2722struct fc_rport *
2723fc_remote_port_add(struct Scsi_Host *shost, int channel,
2724 struct fc_rport_identifiers *ids)
2725{
2726 struct fc_internal *fci = to_fc_internal(shost->transportt);
2727 struct fc_host_attrs *fc_host = shost_to_fc_host(shost);
2728 struct fc_rport *rport;
2729 unsigned long flags;
2730 int match = 0;
2731
2732
2733 fc_flush_work(shost);
2734
2735
2736
2737
2738
2739
2740 spin_lock_irqsave(shost->host_lock, flags);
2741
2742 list_for_each_entry(rport, &fc_host->rports, peers) {
2743
2744 if ((rport->port_state == FC_PORTSTATE_BLOCKED ||
2745 rport->port_state == FC_PORTSTATE_NOTPRESENT) &&
2746 (rport->channel == channel)) {
2747
2748 switch (fc_host->tgtid_bind_type) {
2749 case FC_TGTID_BIND_BY_WWPN:
2750 case FC_TGTID_BIND_NONE:
2751 if (rport->port_name == ids->port_name)
2752 match = 1;
2753 break;
2754 case FC_TGTID_BIND_BY_WWNN:
2755 if (rport->node_name == ids->node_name)
2756 match = 1;
2757 break;
2758 case FC_TGTID_BIND_BY_ID:
2759 if (rport->port_id == ids->port_id)
2760 match = 1;
2761 break;
2762 }
2763
2764 if (match) {
2765
2766 memcpy(&rport->node_name, &ids->node_name,
2767 sizeof(rport->node_name));
2768 memcpy(&rport->port_name, &ids->port_name,
2769 sizeof(rport->port_name));
2770 rport->port_id = ids->port_id;
2771
2772 rport->port_state = FC_PORTSTATE_ONLINE;
2773 rport->roles = ids->roles;
2774
2775 spin_unlock_irqrestore(shost->host_lock, flags);
2776
2777 if (fci->f->dd_fcrport_size)
2778 memset(rport->dd_data, 0,
2779 fci->f->dd_fcrport_size);
2780
2781
2782
2783
2784
2785
2786
2787
2788
2789
2790
2791
2792
2793
2794
2795
2796
2797
2798 if ((rport->scsi_target_id != -1) &&
2799 (!(ids->roles & FC_PORT_ROLE_FCP_TARGET)))
2800 return rport;
2801
2802
2803
2804
2805
2806
2807 if (!cancel_delayed_work(&rport->fail_io_work))
2808 fc_flush_devloss(shost);
2809 if (!cancel_delayed_work(&rport->dev_loss_work))
2810 fc_flush_devloss(shost);
2811
2812 spin_lock_irqsave(shost->host_lock, flags);
2813
2814 rport->flags &= ~(FC_RPORT_FAST_FAIL_TIMEDOUT |
2815 FC_RPORT_DEVLOSS_PENDING |
2816 FC_RPORT_DEVLOSS_CALLBK_DONE);
2817
2818 spin_unlock_irqrestore(shost->host_lock, flags);
2819
2820
2821 if (rport->scsi_target_id != -1) {
2822 scsi_target_unblock(&rport->dev,
2823 SDEV_RUNNING);
2824 spin_lock_irqsave(shost->host_lock,
2825 flags);
2826 rport->flags |= FC_RPORT_SCAN_PENDING;
2827 scsi_queue_work(shost,
2828 &rport->scan_work);
2829 spin_unlock_irqrestore(shost->host_lock,
2830 flags);
2831 }
2832
2833 fc_bsg_goose_queue(rport);
2834
2835 return rport;
2836 }
2837 }
2838 }
2839
2840
2841
2842
2843
2844 if (fc_host->tgtid_bind_type != FC_TGTID_BIND_NONE) {
2845
2846
2847
2848 list_for_each_entry(rport, &fc_host->rport_bindings,
2849 peers) {
2850 if (rport->channel != channel)
2851 continue;
2852
2853 switch (fc_host->tgtid_bind_type) {
2854 case FC_TGTID_BIND_BY_WWPN:
2855 if (rport->port_name == ids->port_name)
2856 match = 1;
2857 break;
2858 case FC_TGTID_BIND_BY_WWNN:
2859 if (rport->node_name == ids->node_name)
2860 match = 1;
2861 break;
2862 case FC_TGTID_BIND_BY_ID:
2863 if (rport->port_id == ids->port_id)
2864 match = 1;
2865 break;
2866 case FC_TGTID_BIND_NONE:
2867 break;
2868 }
2869
2870 if (match) {
2871 list_move_tail(&rport->peers, &fc_host->rports);
2872 break;
2873 }
2874 }
2875
2876 if (match) {
2877 memcpy(&rport->node_name, &ids->node_name,
2878 sizeof(rport->node_name));
2879 memcpy(&rport->port_name, &ids->port_name,
2880 sizeof(rport->port_name));
2881 rport->port_id = ids->port_id;
2882 rport->port_state = FC_PORTSTATE_ONLINE;
2883 rport->flags &= ~FC_RPORT_FAST_FAIL_TIMEDOUT;
2884
2885 if (fci->f->dd_fcrport_size)
2886 memset(rport->dd_data, 0,
2887 fci->f->dd_fcrport_size);
2888 spin_unlock_irqrestore(shost->host_lock, flags);
2889
2890 fc_remote_port_rolechg(rport, ids->roles);
2891 return rport;
2892 }
2893 }
2894
2895 spin_unlock_irqrestore(shost->host_lock, flags);
2896
2897
2898 rport = fc_remote_port_create(shost, channel, ids);
2899
2900 return rport;
2901}
2902EXPORT_SYMBOL(fc_remote_port_add);
2903
2904
2905
2906
2907
2908
2909
2910
2911
2912
2913
2914
2915
2916
2917
2918
2919
2920
2921
2922
2923
2924
2925
2926
2927
2928
2929
2930
2931
2932
2933
2934
2935
2936
2937
2938
2939
2940
2941
2942
2943
2944
2945
2946
2947
2948
2949
2950
2951
2952
2953
2954
2955
2956
2957void
2958fc_remote_port_delete(struct fc_rport *rport)
2959{
2960 struct Scsi_Host *shost = rport_to_shost(rport);
2961 unsigned long timeout = rport->dev_loss_tmo;
2962 unsigned long flags;
2963
2964
2965
2966
2967
2968
2969
2970
2971
2972 spin_lock_irqsave(shost->host_lock, flags);
2973
2974 if (rport->port_state != FC_PORTSTATE_ONLINE) {
2975 spin_unlock_irqrestore(shost->host_lock, flags);
2976 return;
2977 }
2978
2979
2980
2981
2982
2983
2984
2985
2986
2987
2988
2989
2990
2991
2992 rport->port_state = FC_PORTSTATE_BLOCKED;
2993
2994 rport->flags |= FC_RPORT_DEVLOSS_PENDING;
2995
2996 spin_unlock_irqrestore(shost->host_lock, flags);
2997
2998 scsi_target_block(&rport->dev);
2999
3000
3001 if ((rport->fast_io_fail_tmo != -1) &&
3002 (rport->fast_io_fail_tmo < timeout))
3003 fc_queue_devloss_work(shost, &rport->fail_io_work,
3004 rport->fast_io_fail_tmo * HZ);
3005
3006
3007 fc_queue_devloss_work(shost, &rport->dev_loss_work, timeout * HZ);
3008}
3009EXPORT_SYMBOL(fc_remote_port_delete);
3010
3011
3012
3013
3014
3015
3016
3017
3018
3019
3020
3021
3022
3023
3024
3025
3026
3027
3028
3029
3030
3031void
3032fc_remote_port_rolechg(struct fc_rport *rport, u32 roles)
3033{
3034 struct Scsi_Host *shost = rport_to_shost(rport);
3035 struct fc_host_attrs *fc_host = shost_to_fc_host(shost);
3036 unsigned long flags;
3037 int create = 0;
3038
3039 spin_lock_irqsave(shost->host_lock, flags);
3040 if (roles & FC_PORT_ROLE_FCP_TARGET) {
3041 if (rport->scsi_target_id == -1) {
3042 rport->scsi_target_id = fc_host->next_target_id++;
3043 create = 1;
3044 } else if (!(rport->roles & FC_PORT_ROLE_FCP_TARGET))
3045 create = 1;
3046 }
3047
3048 rport->roles = roles;
3049
3050 spin_unlock_irqrestore(shost->host_lock, flags);
3051
3052 if (create) {
3053
3054
3055
3056
3057
3058
3059
3060
3061
3062
3063
3064
3065 if (!cancel_delayed_work(&rport->fail_io_work))
3066 fc_flush_devloss(shost);
3067 if (!cancel_delayed_work(&rport->dev_loss_work))
3068 fc_flush_devloss(shost);
3069
3070 spin_lock_irqsave(shost->host_lock, flags);
3071 rport->flags &= ~(FC_RPORT_FAST_FAIL_TIMEDOUT |
3072 FC_RPORT_DEVLOSS_PENDING |
3073 FC_RPORT_DEVLOSS_CALLBK_DONE);
3074 spin_unlock_irqrestore(shost->host_lock, flags);
3075
3076
3077 fc_flush_work(shost);
3078
3079 scsi_target_unblock(&rport->dev, SDEV_RUNNING);
3080
3081 spin_lock_irqsave(shost->host_lock, flags);
3082 rport->flags |= FC_RPORT_SCAN_PENDING;
3083 scsi_queue_work(shost, &rport->scan_work);
3084 spin_unlock_irqrestore(shost->host_lock, flags);
3085 }
3086}
3087EXPORT_SYMBOL(fc_remote_port_rolechg);
3088
3089
3090
3091
3092
3093
3094
3095
3096static void
3097fc_timeout_deleted_rport(struct work_struct *work)
3098{
3099 struct fc_rport *rport =
3100 container_of(work, struct fc_rport, dev_loss_work.work);
3101 struct Scsi_Host *shost = rport_to_shost(rport);
3102 struct fc_internal *i = to_fc_internal(shost->transportt);
3103 struct fc_host_attrs *fc_host = shost_to_fc_host(shost);
3104 unsigned long flags;
3105 int do_callback = 0;
3106
3107 spin_lock_irqsave(shost->host_lock, flags);
3108
3109 rport->flags &= ~FC_RPORT_DEVLOSS_PENDING;
3110
3111
3112
3113
3114
3115
3116 if ((rport->port_state == FC_PORTSTATE_ONLINE) &&
3117 (rport->scsi_target_id != -1) &&
3118 !(rport->roles & FC_PORT_ROLE_FCP_TARGET)) {
3119 dev_printk(KERN_ERR, &rport->dev,
3120 "blocked FC remote port time out: no longer"
3121 " a FCP target, removing starget\n");
3122 spin_unlock_irqrestore(shost->host_lock, flags);
3123 scsi_target_unblock(&rport->dev, SDEV_TRANSPORT_OFFLINE);
3124 fc_queue_work(shost, &rport->stgt_delete_work);
3125 return;
3126 }
3127
3128
3129 if (rport->port_state != FC_PORTSTATE_BLOCKED) {
3130 spin_unlock_irqrestore(shost->host_lock, flags);
3131 dev_printk(KERN_ERR, &rport->dev,
3132 "blocked FC remote port time out: leaving"
3133 " rport%s alone\n",
3134 (rport->scsi_target_id != -1) ? " and starget" : "");
3135 return;
3136 }
3137
3138 if ((fc_host->tgtid_bind_type == FC_TGTID_BIND_NONE) ||
3139 (rport->scsi_target_id == -1)) {
3140 list_del(&rport->peers);
3141 rport->port_state = FC_PORTSTATE_DELETED;
3142 dev_printk(KERN_ERR, &rport->dev,
3143 "blocked FC remote port time out: removing"
3144 " rport%s\n",
3145 (rport->scsi_target_id != -1) ? " and starget" : "");
3146 fc_queue_work(shost, &rport->rport_delete_work);
3147 spin_unlock_irqrestore(shost->host_lock, flags);
3148 return;
3149 }
3150
3151 dev_printk(KERN_ERR, &rport->dev,
3152 "blocked FC remote port time out: removing target and "
3153 "saving binding\n");
3154
3155 list_move_tail(&rport->peers, &fc_host->rport_bindings);
3156
3157
3158
3159
3160
3161
3162
3163
3164
3165
3166 rport->maxframe_size = -1;
3167 rport->supported_classes = FC_COS_UNSPECIFIED;
3168 rport->roles = FC_PORT_ROLE_UNKNOWN;
3169 rport->port_state = FC_PORTSTATE_NOTPRESENT;
3170 rport->flags &= ~FC_RPORT_FAST_FAIL_TIMEDOUT;
3171
3172
3173
3174
3175
3176
3177 spin_unlock_irqrestore(shost->host_lock, flags);
3178 fc_terminate_rport_io(rport);
3179
3180 spin_lock_irqsave(shost->host_lock, flags);
3181
3182 if (rport->port_state == FC_PORTSTATE_NOTPRESENT) {
3183
3184
3185 switch (fc_host->tgtid_bind_type) {
3186 case FC_TGTID_BIND_BY_WWPN:
3187 rport->node_name = -1;
3188 rport->port_id = -1;
3189 break;
3190 case FC_TGTID_BIND_BY_WWNN:
3191 rport->port_name = -1;
3192 rport->port_id = -1;
3193 break;
3194 case FC_TGTID_BIND_BY_ID:
3195 rport->node_name = -1;
3196 rport->port_name = -1;
3197 break;
3198 case FC_TGTID_BIND_NONE:
3199 break;
3200 }
3201
3202
3203
3204
3205
3206
3207 rport->flags |= FC_RPORT_DEVLOSS_CALLBK_DONE;
3208 fc_queue_work(shost, &rport->stgt_delete_work);
3209
3210 do_callback = 1;
3211 }
3212
3213 spin_unlock_irqrestore(shost->host_lock, flags);
3214
3215
3216
3217
3218
3219
3220
3221 if (do_callback && i->f->dev_loss_tmo_callbk)
3222 i->f->dev_loss_tmo_callbk(rport);
3223}
3224
3225
3226
3227
3228
3229
3230
3231
3232
3233static void
3234fc_timeout_fail_rport_io(struct work_struct *work)
3235{
3236 struct fc_rport *rport =
3237 container_of(work, struct fc_rport, fail_io_work.work);
3238
3239 if (rport->port_state != FC_PORTSTATE_BLOCKED)
3240 return;
3241
3242 rport->flags |= FC_RPORT_FAST_FAIL_TIMEDOUT;
3243 fc_terminate_rport_io(rport);
3244}
3245
3246
3247
3248
3249
3250static void
3251fc_scsi_scan_rport(struct work_struct *work)
3252{
3253 struct fc_rport *rport =
3254 container_of(work, struct fc_rport, scan_work);
3255 struct Scsi_Host *shost = rport_to_shost(rport);
3256 struct fc_internal *i = to_fc_internal(shost->transportt);
3257 unsigned long flags;
3258
3259 if ((rport->port_state == FC_PORTSTATE_ONLINE) &&
3260 (rport->roles & FC_PORT_ROLE_FCP_TARGET) &&
3261 !(i->f->disable_target_scan)) {
3262 scsi_scan_target(&rport->dev, rport->channel,
3263 rport->scsi_target_id, SCAN_WILD_CARD,
3264 SCSI_SCAN_RESCAN);
3265 }
3266
3267 spin_lock_irqsave(shost->host_lock, flags);
3268 rport->flags &= ~FC_RPORT_SCAN_PENDING;
3269 spin_unlock_irqrestore(shost->host_lock, flags);
3270}
3271
3272
3273
3274
3275
3276
3277
3278
3279
3280
3281
3282
3283
3284
3285
3286int fc_block_rport(struct fc_rport *rport)
3287{
3288 struct Scsi_Host *shost = rport_to_shost(rport);
3289 unsigned long flags;
3290
3291 spin_lock_irqsave(shost->host_lock, flags);
3292 while (rport->port_state == FC_PORTSTATE_BLOCKED &&
3293 !(rport->flags & FC_RPORT_FAST_FAIL_TIMEDOUT)) {
3294 spin_unlock_irqrestore(shost->host_lock, flags);
3295 msleep(1000);
3296 spin_lock_irqsave(shost->host_lock, flags);
3297 }
3298 spin_unlock_irqrestore(shost->host_lock, flags);
3299
3300 if (rport->flags & FC_RPORT_FAST_FAIL_TIMEDOUT)
3301 return FAST_IO_FAIL;
3302
3303 return 0;
3304}
3305EXPORT_SYMBOL(fc_block_rport);
3306
3307
3308
3309
3310
3311
3312
3313
3314
3315
3316
3317
3318
3319
3320
3321int fc_block_scsi_eh(struct scsi_cmnd *cmnd)
3322{
3323 struct fc_rport *rport = starget_to_rport(scsi_target(cmnd->device));
3324
3325 if (WARN_ON_ONCE(!rport))
3326 return FAST_IO_FAIL;
3327
3328 return fc_block_rport(rport);
3329}
3330EXPORT_SYMBOL(fc_block_scsi_eh);
3331
3332
3333
3334
3335
3336
3337
3338
3339
3340
3341
3342
3343
3344
3345
3346
3347static int
3348fc_vport_setup(struct Scsi_Host *shost, int channel, struct device *pdev,
3349 struct fc_vport_identifiers *ids, struct fc_vport **ret_vport)
3350{
3351 struct fc_host_attrs *fc_host = shost_to_fc_host(shost);
3352 struct fc_internal *fci = to_fc_internal(shost->transportt);
3353 struct fc_vport *vport;
3354 struct device *dev;
3355 unsigned long flags;
3356 size_t size;
3357 int error;
3358
3359 *ret_vport = NULL;
3360
3361 if ( ! fci->f->vport_create)
3362 return -ENOENT;
3363
3364 size = (sizeof(struct fc_vport) + fci->f->dd_fcvport_size);
3365 vport = kzalloc(size, GFP_KERNEL);
3366 if (unlikely(!vport)) {
3367 printk(KERN_ERR "%s: allocation failure\n", __func__);
3368 return -ENOMEM;
3369 }
3370
3371 vport->vport_state = FC_VPORT_UNKNOWN;
3372 vport->vport_last_state = FC_VPORT_UNKNOWN;
3373 vport->node_name = ids->node_name;
3374 vport->port_name = ids->port_name;
3375 vport->roles = ids->roles;
3376 vport->vport_type = ids->vport_type;
3377 if (fci->f->dd_fcvport_size)
3378 vport->dd_data = &vport[1];
3379 vport->shost = shost;
3380 vport->channel = channel;
3381 vport->flags = FC_VPORT_CREATING;
3382 INIT_WORK(&vport->vport_delete_work, fc_vport_sched_delete);
3383
3384 spin_lock_irqsave(shost->host_lock, flags);
3385
3386 if (fc_host->npiv_vports_inuse >= fc_host->max_npiv_vports) {
3387 spin_unlock_irqrestore(shost->host_lock, flags);
3388 kfree(vport);
3389 return -ENOSPC;
3390 }
3391 fc_host->npiv_vports_inuse++;
3392 vport->number = fc_host->next_vport_number++;
3393 list_add_tail(&vport->peers, &fc_host->vports);
3394 scsi_host_get(shost);
3395
3396 spin_unlock_irqrestore(shost->host_lock, flags);
3397
3398 dev = &vport->dev;
3399 device_initialize(dev);
3400 dev->parent = get_device(pdev);
3401 dev->release = fc_vport_dev_release;
3402 dev_set_name(dev, "vport-%d:%d-%d",
3403 shost->host_no, channel, vport->number);
3404 transport_setup_device(dev);
3405
3406 error = device_add(dev);
3407 if (error) {
3408 printk(KERN_ERR "FC Virtual Port device_add failed\n");
3409 goto delete_vport;
3410 }
3411 transport_add_device(dev);
3412 transport_configure_device(dev);
3413
3414 error = fci->f->vport_create(vport, ids->disable);
3415 if (error) {
3416 printk(KERN_ERR "FC Virtual Port LLDD Create failed\n");
3417 goto delete_vport_all;
3418 }
3419
3420
3421
3422
3423
3424 if (pdev != &shost->shost_gendev) {
3425 error = sysfs_create_link(&shost->shost_gendev.kobj,
3426 &dev->kobj, dev_name(dev));
3427 if (error)
3428 printk(KERN_ERR
3429 "%s: Cannot create vport symlinks for "
3430 "%s, err=%d\n",
3431 __func__, dev_name(dev), error);
3432 }
3433 spin_lock_irqsave(shost->host_lock, flags);
3434 vport->flags &= ~FC_VPORT_CREATING;
3435 spin_unlock_irqrestore(shost->host_lock, flags);
3436
3437 dev_printk(KERN_NOTICE, pdev,
3438 "%s created via shost%d channel %d\n", dev_name(dev),
3439 shost->host_no, channel);
3440
3441 *ret_vport = vport;
3442
3443 return 0;
3444
3445delete_vport_all:
3446 transport_remove_device(dev);
3447 device_del(dev);
3448delete_vport:
3449 transport_destroy_device(dev);
3450 spin_lock_irqsave(shost->host_lock, flags);
3451 list_del(&vport->peers);
3452 scsi_host_put(shost);
3453 fc_host->npiv_vports_inuse--;
3454 spin_unlock_irqrestore(shost->host_lock, flags);
3455 put_device(dev->parent);
3456 kfree(vport);
3457
3458 return error;
3459}
3460
3461
3462
3463
3464
3465
3466
3467
3468
3469
3470
3471struct fc_vport *
3472fc_vport_create(struct Scsi_Host *shost, int channel,
3473 struct fc_vport_identifiers *ids)
3474{
3475 int stat;
3476 struct fc_vport *vport;
3477
3478 stat = fc_vport_setup(shost, channel, &shost->shost_gendev,
3479 ids, &vport);
3480 return stat ? NULL : vport;
3481}
3482EXPORT_SYMBOL(fc_vport_create);
3483
3484
3485
3486
3487
3488
3489
3490
3491
3492
3493
3494int
3495fc_vport_terminate(struct fc_vport *vport)
3496{
3497 struct Scsi_Host *shost = vport_to_shost(vport);
3498 struct fc_host_attrs *fc_host = shost_to_fc_host(shost);
3499 struct fc_internal *i = to_fc_internal(shost->transportt);
3500 struct device *dev = &vport->dev;
3501 unsigned long flags;
3502 int stat;
3503
3504 if (i->f->vport_delete)
3505 stat = i->f->vport_delete(vport);
3506 else
3507 stat = -ENOENT;
3508
3509 spin_lock_irqsave(shost->host_lock, flags);
3510 vport->flags &= ~FC_VPORT_DELETING;
3511 if (!stat) {
3512 vport->flags |= FC_VPORT_DELETED;
3513 list_del(&vport->peers);
3514 fc_host->npiv_vports_inuse--;
3515 scsi_host_put(shost);
3516 }
3517 spin_unlock_irqrestore(shost->host_lock, flags);
3518
3519 if (stat)
3520 return stat;
3521
3522 if (dev->parent != &shost->shost_gendev)
3523 sysfs_remove_link(&shost->shost_gendev.kobj, dev_name(dev));
3524 transport_remove_device(dev);
3525 device_del(dev);
3526 transport_destroy_device(dev);
3527
3528
3529
3530
3531
3532
3533 put_device(dev);
3534
3535 return 0;
3536}
3537EXPORT_SYMBOL(fc_vport_terminate);
3538
3539
3540
3541
3542
3543static void
3544fc_vport_sched_delete(struct work_struct *work)
3545{
3546 struct fc_vport *vport =
3547 container_of(work, struct fc_vport, vport_delete_work);
3548 int stat;
3549
3550 stat = fc_vport_terminate(vport);
3551 if (stat)
3552 dev_printk(KERN_ERR, vport->dev.parent,
3553 "%s: %s could not be deleted created via "
3554 "shost%d channel %d - error %d\n", __func__,
3555 dev_name(&vport->dev), vport->shost->host_no,
3556 vport->channel, stat);
3557}
3558
3559
3560
3561
3562
3563
3564
3565
3566
3567
3568static enum blk_eh_timer_return
3569fc_bsg_job_timeout(struct request *req)
3570{
3571 struct bsg_job *job = blk_mq_rq_to_pdu(req);
3572 struct Scsi_Host *shost = fc_bsg_to_shost(job);
3573 struct fc_rport *rport = fc_bsg_to_rport(job);
3574 struct fc_internal *i = to_fc_internal(shost->transportt);
3575 int err = 0, inflight = 0;
3576
3577 if (rport && rport->port_state == FC_PORTSTATE_BLOCKED)
3578 return BLK_EH_RESET_TIMER;
3579
3580 inflight = bsg_job_get(job);
3581
3582 if (inflight && i->f->bsg_timeout) {
3583
3584 err = i->f->bsg_timeout(job);
3585 if (err == -EAGAIN) {
3586 bsg_job_put(job);
3587 return BLK_EH_RESET_TIMER;
3588 } else if (err)
3589 printk(KERN_ERR "ERROR: FC BSG request timeout - LLD "
3590 "abort failed with status %d\n", err);
3591 }
3592
3593
3594 if (inflight)
3595 blk_mq_end_request(req, BLK_STS_IOERR);
3596 return BLK_EH_DONE;
3597}
3598
3599
3600
3601
3602
3603
3604static int fc_bsg_host_dispatch(struct Scsi_Host *shost, struct bsg_job *job)
3605{
3606 struct fc_internal *i = to_fc_internal(shost->transportt);
3607 struct fc_bsg_request *bsg_request = job->request;
3608 struct fc_bsg_reply *bsg_reply = job->reply;
3609 int cmdlen = sizeof(uint32_t);
3610 int ret;
3611
3612
3613 if (job->request_len < cmdlen) {
3614 ret = -ENOMSG;
3615 goto fail_host_msg;
3616 }
3617
3618
3619 switch (bsg_request->msgcode) {
3620 case FC_BSG_HST_ADD_RPORT:
3621 cmdlen += sizeof(struct fc_bsg_host_add_rport);
3622 break;
3623
3624 case FC_BSG_HST_DEL_RPORT:
3625 cmdlen += sizeof(struct fc_bsg_host_del_rport);
3626 break;
3627
3628 case FC_BSG_HST_ELS_NOLOGIN:
3629 cmdlen += sizeof(struct fc_bsg_host_els);
3630
3631 if ((!job->request_payload.payload_len) ||
3632 (!job->reply_payload.payload_len)) {
3633 ret = -EINVAL;
3634 goto fail_host_msg;
3635 }
3636 break;
3637
3638 case FC_BSG_HST_CT:
3639 cmdlen += sizeof(struct fc_bsg_host_ct);
3640
3641 if ((!job->request_payload.payload_len) ||
3642 (!job->reply_payload.payload_len)) {
3643 ret = -EINVAL;
3644 goto fail_host_msg;
3645 }
3646 break;
3647
3648 case FC_BSG_HST_VENDOR:
3649 cmdlen += sizeof(struct fc_bsg_host_vendor);
3650 if ((shost->hostt->vendor_id == 0L) ||
3651 (bsg_request->rqst_data.h_vendor.vendor_id !=
3652 shost->hostt->vendor_id)) {
3653 ret = -ESRCH;
3654 goto fail_host_msg;
3655 }
3656 break;
3657
3658 default:
3659 ret = -EBADR;
3660 goto fail_host_msg;
3661 }
3662
3663 ret = i->f->bsg_request(job);
3664 if (!ret)
3665 return 0;
3666
3667fail_host_msg:
3668
3669 BUG_ON(job->reply_len < sizeof(uint32_t));
3670 bsg_reply->reply_payload_rcv_len = 0;
3671 bsg_reply->result = ret;
3672 job->reply_len = sizeof(uint32_t);
3673 bsg_job_done(job, bsg_reply->result,
3674 bsg_reply->reply_payload_rcv_len);
3675 return 0;
3676}
3677
3678
3679
3680
3681
3682
3683static void
3684fc_bsg_goose_queue(struct fc_rport *rport)
3685{
3686 struct request_queue *q = rport->rqst_q;
3687
3688 if (q)
3689 blk_mq_run_hw_queues(q, true);
3690}
3691
3692
3693
3694
3695
3696
3697static int fc_bsg_rport_dispatch(struct Scsi_Host *shost, struct bsg_job *job)
3698{
3699 struct fc_internal *i = to_fc_internal(shost->transportt);
3700 struct fc_bsg_request *bsg_request = job->request;
3701 struct fc_bsg_reply *bsg_reply = job->reply;
3702 int cmdlen = sizeof(uint32_t);
3703 int ret;
3704
3705
3706 if (job->request_len < cmdlen) {
3707 ret = -ENOMSG;
3708 goto fail_rport_msg;
3709 }
3710
3711
3712 switch (bsg_request->msgcode) {
3713 case FC_BSG_RPT_ELS:
3714 cmdlen += sizeof(struct fc_bsg_rport_els);
3715 goto check_bidi;
3716
3717 case FC_BSG_RPT_CT:
3718 cmdlen += sizeof(struct fc_bsg_rport_ct);
3719check_bidi:
3720
3721 if ((!job->request_payload.payload_len) ||
3722 (!job->reply_payload.payload_len)) {
3723 ret = -EINVAL;
3724 goto fail_rport_msg;
3725 }
3726 break;
3727 default:
3728 ret = -EBADR;
3729 goto fail_rport_msg;
3730 }
3731
3732 ret = i->f->bsg_request(job);
3733 if (!ret)
3734 return 0;
3735
3736fail_rport_msg:
3737
3738 BUG_ON(job->reply_len < sizeof(uint32_t));
3739 bsg_reply->reply_payload_rcv_len = 0;
3740 bsg_reply->result = ret;
3741 job->reply_len = sizeof(uint32_t);
3742 bsg_job_done(job, bsg_reply->result,
3743 bsg_reply->reply_payload_rcv_len);
3744 return 0;
3745}
3746
3747static int fc_bsg_dispatch(struct bsg_job *job)
3748{
3749 struct Scsi_Host *shost = fc_bsg_to_shost(job);
3750
3751 if (scsi_is_fc_rport(job->dev))
3752 return fc_bsg_rport_dispatch(shost, job);
3753 else
3754 return fc_bsg_host_dispatch(shost, job);
3755}
3756
3757static blk_status_t fc_bsg_rport_prep(struct fc_rport *rport)
3758{
3759 if (rport->port_state == FC_PORTSTATE_BLOCKED &&
3760 !(rport->flags & FC_RPORT_FAST_FAIL_TIMEDOUT))
3761 return BLK_STS_RESOURCE;
3762
3763 if (rport->port_state != FC_PORTSTATE_ONLINE)
3764 return BLK_STS_IOERR;
3765
3766 return BLK_STS_OK;
3767}
3768
3769
3770static int fc_bsg_dispatch_prep(struct bsg_job *job)
3771{
3772 struct fc_rport *rport = fc_bsg_to_rport(job);
3773 blk_status_t ret;
3774
3775 ret = fc_bsg_rport_prep(rport);
3776 switch (ret) {
3777 case BLK_STS_OK:
3778 break;
3779 case BLK_STS_RESOURCE:
3780 return -EAGAIN;
3781 default:
3782 return -EIO;
3783 }
3784
3785 return fc_bsg_dispatch(job);
3786}
3787
3788
3789
3790
3791
3792
3793static int
3794fc_bsg_hostadd(struct Scsi_Host *shost, struct fc_host_attrs *fc_host)
3795{
3796 struct device *dev = &shost->shost_gendev;
3797 struct fc_internal *i = to_fc_internal(shost->transportt);
3798 struct request_queue *q;
3799 char bsg_name[20];
3800
3801 fc_host->rqst_q = NULL;
3802
3803 if (!i->f->bsg_request)
3804 return -ENOTSUPP;
3805
3806 snprintf(bsg_name, sizeof(bsg_name),
3807 "fc_host%d", shost->host_no);
3808
3809 q = bsg_setup_queue(dev, bsg_name, fc_bsg_dispatch, fc_bsg_job_timeout,
3810 i->f->dd_bsg_size);
3811 if (IS_ERR(q)) {
3812 dev_err(dev,
3813 "fc_host%d: bsg interface failed to initialize - setup queue\n",
3814 shost->host_no);
3815 return PTR_ERR(q);
3816 }
3817 __scsi_init_queue(shost, q);
3818 blk_queue_rq_timeout(q, FC_DEFAULT_BSG_TIMEOUT);
3819 fc_host->rqst_q = q;
3820 return 0;
3821}
3822
3823
3824
3825
3826
3827
3828static int
3829fc_bsg_rportadd(struct Scsi_Host *shost, struct fc_rport *rport)
3830{
3831 struct device *dev = &rport->dev;
3832 struct fc_internal *i = to_fc_internal(shost->transportt);
3833 struct request_queue *q;
3834
3835 rport->rqst_q = NULL;
3836
3837 if (!i->f->bsg_request)
3838 return -ENOTSUPP;
3839
3840 q = bsg_setup_queue(dev, dev_name(dev), fc_bsg_dispatch_prep,
3841 fc_bsg_job_timeout, i->f->dd_bsg_size);
3842 if (IS_ERR(q)) {
3843 dev_err(dev, "failed to setup bsg queue\n");
3844 return PTR_ERR(q);
3845 }
3846 __scsi_init_queue(shost, q);
3847 blk_queue_rq_timeout(q, BLK_DEFAULT_SG_TIMEOUT);
3848 rport->rqst_q = q;
3849 return 0;
3850}
3851
3852
3853
3854
3855
3856
3857
3858
3859
3860
3861
3862static void
3863fc_bsg_remove(struct request_queue *q)
3864{
3865 bsg_remove_queue(q);
3866}
3867
3868
3869
3870MODULE_AUTHOR("James Smart");
3871MODULE_DESCRIPTION("FC Transport Attributes");
3872MODULE_LICENSE("GPL");
3873
3874module_init(fc_transport_init);
3875module_exit(fc_transport_exit);
3876
