[SCSI] zfcp: Issue FCP command without holding SCSI host_lock
[linux-2.6.git] / drivers / s390 / scsi / zfcp_unit.c
1 /*
2  * zfcp device driver
3  *
4  * Tracking of manually configured LUNs and helper functions to
5  * register the LUNs with the SCSI midlayer.
6  *
7  * Copyright IBM Corporation 2010
8  */
9
10 #include "zfcp_def.h"
11 #include "zfcp_ext.h"
12
13 /**
14  * zfcp_unit_scsi_scan - Register LUN with SCSI midlayer
15  * @unit: The zfcp LUN/unit to register
16  *
17  * When the SCSI midlayer is not allowed to automatically scan and
18  * attach SCSI devices, zfcp has to register the single devices with
19  * the SCSI midlayer.
20  */
21 void zfcp_unit_scsi_scan(struct zfcp_unit *unit)
22 {
23         struct fc_rport *rport = unit->port->rport;
24         unsigned int lun;
25
26         lun = scsilun_to_int((struct scsi_lun *) &unit->fcp_lun);
27
28         if (rport && rport->port_state == FC_PORTSTATE_ONLINE)
29                 scsi_scan_target(&rport->dev, 0, rport->scsi_target_id, lun, 1);
30 }
31
32 static void zfcp_unit_scsi_scan_work(struct work_struct *work)
33 {
34         struct zfcp_unit *unit = container_of(work, struct zfcp_unit,
35                                               scsi_work);
36
37         zfcp_unit_scsi_scan(unit);
38         put_device(&unit->dev);
39 }
40
41 /**
42  * zfcp_unit_queue_scsi_scan - Register configured units on port
43  * @port: The zfcp_port where to register units
44  *
45  * After opening a port, all units configured on this port have to be
46  * registered with the SCSI midlayer. This function should be called
47  * after calling fc_remote_port_add, so that the fc_rport is already
48  * ONLINE and the call to scsi_scan_target runs the same way as the
49  * call in the FC transport class.
50  */
51 void zfcp_unit_queue_scsi_scan(struct zfcp_port *port)
52 {
53         struct zfcp_unit *unit;
54
55         read_lock_irq(&port->unit_list_lock);
56         list_for_each_entry(unit, &port->unit_list, list) {
57                 get_device(&unit->dev);
58                 if (scsi_queue_work(port->adapter->scsi_host,
59                                     &unit->scsi_work) <= 0)
60                         put_device(&unit->dev);
61         }
62         read_unlock_irq(&port->unit_list_lock);
63 }
64
65 static struct zfcp_unit *_zfcp_unit_find(struct zfcp_port *port, u64 fcp_lun)
66 {
67         struct zfcp_unit *unit;
68
69         list_for_each_entry(unit, &port->unit_list, list)
70                 if (unit->fcp_lun == fcp_lun) {
71                         get_device(&unit->dev);
72                         return unit;
73                 }
74
75         return NULL;
76 }
77
78 /**
79  * zfcp_unit_find - Find and return zfcp_unit with specified FCP LUN
80  * @port: zfcp_port where to look for the unit
81  * @fcp_lun: 64 Bit FCP LUN used to identify the zfcp_unit
82  *
83  * If zfcp_unit is found, a reference is acquired that has to be
84  * released later.
85  *
86  * Returns: Pointer to the zfcp_unit, or NULL if there is no zfcp_unit
87  *          with the specified FCP LUN.
88  */
89 struct zfcp_unit *zfcp_unit_find(struct zfcp_port *port, u64 fcp_lun)
90 {
91         struct zfcp_unit *unit;
92
93         read_lock_irq(&port->unit_list_lock);
94         unit = _zfcp_unit_find(port, fcp_lun);
95         read_unlock_irq(&port->unit_list_lock);
96         return unit;
97 }
98
99 /**
100  * zfcp_unit_release - Drop reference to zfcp_port and free memory of zfcp_unit.
101  * @dev: pointer to device in zfcp_unit
102  */
103 static void zfcp_unit_release(struct device *dev)
104 {
105         struct zfcp_unit *unit = container_of(dev, struct zfcp_unit, dev);
106
107         put_device(&unit->port->dev);
108         kfree(unit);
109 }
110
111 /**
112  * zfcp_unit_enqueue - enqueue unit to unit list of a port.
113  * @port: pointer to port where unit is added
114  * @fcp_lun: FCP LUN of unit to be enqueued
115  * Returns: 0 success
116  *
117  * Sets up some unit internal structures and creates sysfs entry.
118  */
119 int zfcp_unit_add(struct zfcp_port *port, u64 fcp_lun)
120 {
121         struct zfcp_unit *unit;
122
123         unit = zfcp_unit_find(port, fcp_lun);
124         if (unit) {
125                 put_device(&unit->dev);
126                 return -EEXIST;
127         }
128
129         unit = kzalloc(sizeof(struct zfcp_unit), GFP_KERNEL);
130         if (!unit)
131                 return -ENOMEM;
132
133         unit->port = port;
134         unit->fcp_lun = fcp_lun;
135         unit->dev.parent = &port->dev;
136         unit->dev.release = zfcp_unit_release;
137         INIT_WORK(&unit->scsi_work, zfcp_unit_scsi_scan_work);
138
139         if (dev_set_name(&unit->dev, "0x%016llx",
140                          (unsigned long long) fcp_lun)) {
141                 kfree(unit);
142                 return -ENOMEM;
143         }
144
145         get_device(&port->dev);
146
147         if (device_register(&unit->dev)) {
148                 put_device(&unit->dev);
149                 return -ENOMEM;
150         }
151
152         if (sysfs_create_group(&unit->dev.kobj, &zfcp_sysfs_unit_attrs)) {
153                 device_unregister(&unit->dev);
154                 return -EINVAL;
155         }
156
157         write_lock_irq(&port->unit_list_lock);
158         list_add_tail(&unit->list, &port->unit_list);
159         write_unlock_irq(&port->unit_list_lock);
160
161         zfcp_unit_scsi_scan(unit);
162
163         return 0;
164 }
165
166 /**
167  * zfcp_unit_sdev - Return SCSI device for zfcp_unit
168  * @unit: The zfcp_unit where to get the SCSI device for
169  *
170  * Returns: scsi_device pointer on success, NULL if there is no SCSI
171  *          device for this zfcp_unit
172  *
173  * On success, the caller also holds a reference to the SCSI device
174  * that must be released with scsi_device_put.
175  */
176 struct scsi_device *zfcp_unit_sdev(struct zfcp_unit *unit)
177 {
178         struct Scsi_Host *shost;
179         struct zfcp_port *port;
180         unsigned int lun;
181
182         lun = scsilun_to_int((struct scsi_lun *) &unit->fcp_lun);
183         port = unit->port;
184         shost = port->adapter->scsi_host;
185         return scsi_device_lookup(shost, 0, port->starget_id, lun);
186 }
187
188 /**
189  * zfcp_unit_sdev_status - Return zfcp LUN status for SCSI device
190  * @unit: The unit to lookup the SCSI device for
191  *
192  * Returns the zfcp LUN status field of the SCSI device if the SCSI device
193  * for the zfcp_unit exists, 0 otherwise.
194  */
195 unsigned int zfcp_unit_sdev_status(struct zfcp_unit *unit)
196 {
197         unsigned int status = 0;
198         struct scsi_device *sdev;
199         struct zfcp_scsi_dev *zfcp_sdev;
200
201         sdev = zfcp_unit_sdev(unit);
202         if (sdev) {
203                 zfcp_sdev = sdev_to_zfcp(sdev);
204                 status = atomic_read(&zfcp_sdev->status);
205                 scsi_device_put(sdev);
206         }
207
208         return status;
209 }
210
211 /**
212  * zfcp_unit_remove - Remove entry from list of configured units
213  * @port: The port where to remove the unit from the configuration
214  * @fcp_lun: The 64 bit LUN of the unit to remove
215  *
216  * Returns: -EINVAL if a unit with the specified LUN does not exist,
217  *          0 on success.
218  */
219 int zfcp_unit_remove(struct zfcp_port *port, u64 fcp_lun)
220 {
221         struct zfcp_unit *unit;
222         struct scsi_device *sdev;
223
224         write_lock_irq(&port->unit_list_lock);
225         unit = _zfcp_unit_find(port, fcp_lun);
226         if (unit)
227                 list_del(&unit->list);
228         write_unlock_irq(&port->unit_list_lock);
229
230         if (!unit)
231                 return -EINVAL;
232
233         sdev = zfcp_unit_sdev(unit);
234         if (sdev) {
235                 scsi_remove_device(sdev);
236                 scsi_device_put(sdev);
237         }
238
239         put_device(&unit->dev);
240
241         zfcp_device_unregister(&unit->dev, &zfcp_sysfs_unit_attrs);
242
243         return 0;
244 }