Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
1daa4eb5 CS |
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 | * | |
a53c8fab | 8 | * Copyright IBM Corp. 2010 |
1daa4eb5 CS |
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 | */ | |
22 | void zfcp_unit_scsi_scan(struct zfcp_unit *unit) | |
23 | { | |
24 | struct fc_rport *rport = unit->port->rport; | |
9cb78c16 | 25 | u64 lun; |
1daa4eb5 CS |
26 | |
27 | lun = scsilun_to_int((struct scsi_lun *) &unit->fcp_lun); | |
28 | ||
29 | if (rport && rport->port_state == FC_PORTSTATE_ONLINE) | |
1d645088 | 30 | scsi_scan_target(&rport->dev, 0, rport->scsi_target_id, lun, |
98be565f | 31 | SCSI_SCAN_MANUAL); |
1daa4eb5 CS |
32 | } |
33 | ||
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 | */ | |
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 | ||
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 | */ | |
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 | */ | |
105 | static void zfcp_unit_release(struct device *dev) | |
106 | { | |
107 | struct zfcp_unit *unit = container_of(dev, struct zfcp_unit, dev); | |
108 | ||
d99b601b | 109 | atomic_dec(&unit->port->units); |
1daa4eb5 CS |
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 | */ | |
121 | int zfcp_unit_add(struct zfcp_port *port, u64 fcp_lun) | |
122 | { | |
123 | struct zfcp_unit *unit; | |
d99b601b SM |
124 | int retval = 0; |
125 | ||
126 | mutex_lock(&zfcp_sysfs_port_units_mutex); | |
127 | if (atomic_read(&port->units) == -1) { | |
128 | /* port is already gone */ | |
129 | retval = -ENODEV; | |
130 | goto out; | |
131 | } | |
1daa4eb5 CS |
132 | |
133 | unit = zfcp_unit_find(port, fcp_lun); | |
134 | if (unit) { | |
135 | put_device(&unit->dev); | |
d99b601b SM |
136 | retval = -EEXIST; |
137 | goto out; | |
1daa4eb5 CS |
138 | } |
139 | ||
140 | unit = kzalloc(sizeof(struct zfcp_unit), GFP_KERNEL); | |
d99b601b SM |
141 | if (!unit) { |
142 | retval = -ENOMEM; | |
143 | goto out; | |
144 | } | |
1daa4eb5 CS |
145 | |
146 | unit->port = port; | |
147 | unit->fcp_lun = fcp_lun; | |
148 | unit->dev.parent = &port->dev; | |
149 | unit->dev.release = zfcp_unit_release; | |
86bdf218 | 150 | unit->dev.groups = zfcp_unit_attr_groups; |
1daa4eb5 | 151 | INIT_WORK(&unit->scsi_work, zfcp_unit_scsi_scan_work); |
1daa4eb5 CS |
152 | |
153 | if (dev_set_name(&unit->dev, "0x%016llx", | |
154 | (unsigned long long) fcp_lun)) { | |
155 | kfree(unit); | |
d99b601b SM |
156 | retval = -ENOMEM; |
157 | goto out; | |
1daa4eb5 CS |
158 | } |
159 | ||
160 | if (device_register(&unit->dev)) { | |
161 | put_device(&unit->dev); | |
d99b601b SM |
162 | retval = -ENOMEM; |
163 | goto out; | |
1daa4eb5 CS |
164 | } |
165 | ||
d99b601b SM |
166 | atomic_inc(&port->units); /* under zfcp_sysfs_port_units_mutex ! */ |
167 | ||
1daa4eb5 CS |
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 | ||
1daa4eb5 CS |
172 | zfcp_unit_scsi_scan(unit); |
173 | ||
d99b601b SM |
174 | out: |
175 | mutex_unlock(&zfcp_sysfs_port_units_mutex); | |
176 | return retval; | |
1daa4eb5 CS |
177 | } |
178 | ||
179 | /** | |
180 | * zfcp_unit_sdev - Return SCSI device for zfcp_unit | |
181 | * @unit: The zfcp_unit where to get the SCSI device for | |
182 | * | |
183 | * Returns: scsi_device pointer on success, NULL if there is no SCSI | |
184 | * device for this zfcp_unit | |
185 | * | |
186 | * On success, the caller also holds a reference to the SCSI device | |
187 | * that must be released with scsi_device_put. | |
188 | */ | |
189 | struct scsi_device *zfcp_unit_sdev(struct zfcp_unit *unit) | |
190 | { | |
191 | struct Scsi_Host *shost; | |
192 | struct zfcp_port *port; | |
9cb78c16 | 193 | u64 lun; |
1daa4eb5 CS |
194 | |
195 | lun = scsilun_to_int((struct scsi_lun *) &unit->fcp_lun); | |
196 | port = unit->port; | |
197 | shost = port->adapter->scsi_host; | |
198 | return scsi_device_lookup(shost, 0, port->starget_id, lun); | |
199 | } | |
200 | ||
201 | /** | |
202 | * zfcp_unit_sdev_status - Return zfcp LUN status for SCSI device | |
203 | * @unit: The unit to lookup the SCSI device for | |
204 | * | |
205 | * Returns the zfcp LUN status field of the SCSI device if the SCSI device | |
206 | * for the zfcp_unit exists, 0 otherwise. | |
207 | */ | |
208 | unsigned int zfcp_unit_sdev_status(struct zfcp_unit *unit) | |
209 | { | |
210 | unsigned int status = 0; | |
211 | struct scsi_device *sdev; | |
212 | struct zfcp_scsi_dev *zfcp_sdev; | |
213 | ||
214 | sdev = zfcp_unit_sdev(unit); | |
215 | if (sdev) { | |
216 | zfcp_sdev = sdev_to_zfcp(sdev); | |
217 | status = atomic_read(&zfcp_sdev->status); | |
218 | scsi_device_put(sdev); | |
219 | } | |
220 | ||
221 | return status; | |
222 | } | |
223 | ||
224 | /** | |
225 | * zfcp_unit_remove - Remove entry from list of configured units | |
226 | * @port: The port where to remove the unit from the configuration | |
227 | * @fcp_lun: The 64 bit LUN of the unit to remove | |
228 | * | |
229 | * Returns: -EINVAL if a unit with the specified LUN does not exist, | |
230 | * 0 on success. | |
231 | */ | |
232 | int zfcp_unit_remove(struct zfcp_port *port, u64 fcp_lun) | |
233 | { | |
234 | struct zfcp_unit *unit; | |
235 | struct scsi_device *sdev; | |
236 | ||
237 | write_lock_irq(&port->unit_list_lock); | |
238 | unit = _zfcp_unit_find(port, fcp_lun); | |
239 | if (unit) | |
240 | list_del(&unit->list); | |
241 | write_unlock_irq(&port->unit_list_lock); | |
242 | ||
243 | if (!unit) | |
244 | return -EINVAL; | |
245 | ||
246 | sdev = zfcp_unit_sdev(unit); | |
247 | if (sdev) { | |
248 | scsi_remove_device(sdev); | |
249 | scsi_device_put(sdev); | |
250 | } | |
251 | ||
252 | put_device(&unit->dev); | |
253 | ||
86bdf218 | 254 | device_unregister(&unit->dev); |
1daa4eb5 CS |
255 | |
256 | return 0; | |
257 | } |