Commit | Line | Data |
---|---|---|
1daa4eb5 CS |
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 | * | |
a53c8fab | 7 | * Copyright IBM Corp. 2010 |
1daa4eb5 CS |
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; | |
1daa4eb5 | 137 | INIT_WORK(&unit->scsi_work, zfcp_unit_scsi_scan_work); |
1daa4eb5 CS |
138 | |
139 | if (dev_set_name(&unit->dev, "0x%016llx", | |
140 | (unsigned long long) fcp_lun)) { | |
141 | kfree(unit); | |
142 | return -ENOMEM; | |
143 | } | |
144 | ||
1a9708cd CS |
145 | get_device(&port->dev); |
146 | ||
1daa4eb5 CS |
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 | ||
1daa4eb5 CS |
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 | ||
1daa4eb5 CS |
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 | ||
1daa4eb5 CS |
241 | zfcp_device_unregister(&unit->dev, &zfcp_sysfs_unit_attrs); |
242 | ||
243 | return 0; | |
244 | } |