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