4 * Tracking of manually configured LUNs and helper functions to
5 * register the LUNs with the SCSI midlayer.
7 * Copyright IBM Corp. 2010
14 * zfcp_unit_scsi_scan - Register LUN with SCSI midlayer
15 * @unit: The zfcp LUN/unit to register
17 * When the SCSI midlayer is not allowed to automatically scan and
18 * attach SCSI devices, zfcp has to register the single devices with
21 void zfcp_unit_scsi_scan(struct zfcp_unit
*unit
)
23 struct fc_rport
*rport
= unit
->port
->rport
;
26 lun
= scsilun_to_int((struct scsi_lun
*) &unit
->fcp_lun
);
28 if (rport
&& rport
->port_state
== FC_PORTSTATE_ONLINE
)
29 scsi_scan_target(&rport
->dev
, 0, rport
->scsi_target_id
, lun
, 1);
32 static void zfcp_unit_scsi_scan_work(struct work_struct
*work
)
34 struct zfcp_unit
*unit
= container_of(work
, struct zfcp_unit
,
37 zfcp_unit_scsi_scan(unit
);
38 put_device(&unit
->dev
);
42 * zfcp_unit_queue_scsi_scan - Register configured units on port
43 * @port: The zfcp_port where to register units
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.
51 void zfcp_unit_queue_scsi_scan(struct zfcp_port
*port
)
53 struct zfcp_unit
*unit
;
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
);
62 read_unlock_irq(&port
->unit_list_lock
);
65 static struct zfcp_unit
*_zfcp_unit_find(struct zfcp_port
*port
, u64 fcp_lun
)
67 struct zfcp_unit
*unit
;
69 list_for_each_entry(unit
, &port
->unit_list
, list
)
70 if (unit
->fcp_lun
== fcp_lun
) {
71 get_device(&unit
->dev
);
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
83 * If zfcp_unit is found, a reference is acquired that has to be
86 * Returns: Pointer to the zfcp_unit, or NULL if there is no zfcp_unit
87 * with the specified FCP LUN.
89 struct zfcp_unit
*zfcp_unit_find(struct zfcp_port
*port
, u64 fcp_lun
)
91 struct zfcp_unit
*unit
;
93 read_lock_irq(&port
->unit_list_lock
);
94 unit
= _zfcp_unit_find(port
, fcp_lun
);
95 read_unlock_irq(&port
->unit_list_lock
);
100 * zfcp_unit_release - Drop reference to zfcp_port and free memory of zfcp_unit.
101 * @dev: pointer to device in zfcp_unit
103 static void zfcp_unit_release(struct device
*dev
)
105 struct zfcp_unit
*unit
= container_of(dev
, struct zfcp_unit
, dev
);
107 atomic_dec(&unit
->port
->units
);
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
117 * Sets up some unit internal structures and creates sysfs entry.
119 int zfcp_unit_add(struct zfcp_port
*port
, u64 fcp_lun
)
121 struct zfcp_unit
*unit
;
124 mutex_lock(&zfcp_sysfs_port_units_mutex
);
125 if (atomic_read(&port
->units
) == -1) {
126 /* port is already gone */
131 unit
= zfcp_unit_find(port
, fcp_lun
);
133 put_device(&unit
->dev
);
138 unit
= kzalloc(sizeof(struct zfcp_unit
), GFP_KERNEL
);
145 unit
->fcp_lun
= fcp_lun
;
146 unit
->dev
.parent
= &port
->dev
;
147 unit
->dev
.release
= zfcp_unit_release
;
148 INIT_WORK(&unit
->scsi_work
, zfcp_unit_scsi_scan_work
);
150 if (dev_set_name(&unit
->dev
, "0x%016llx",
151 (unsigned long long) fcp_lun
)) {
157 if (device_register(&unit
->dev
)) {
158 put_device(&unit
->dev
);
163 if (sysfs_create_group(&unit
->dev
.kobj
, &zfcp_sysfs_unit_attrs
)) {
164 device_unregister(&unit
->dev
);
169 atomic_inc(&port
->units
); /* under zfcp_sysfs_port_units_mutex ! */
171 write_lock_irq(&port
->unit_list_lock
);
172 list_add_tail(&unit
->list
, &port
->unit_list
);
173 write_unlock_irq(&port
->unit_list_lock
);
175 zfcp_unit_scsi_scan(unit
);
178 mutex_unlock(&zfcp_sysfs_port_units_mutex
);
183 * zfcp_unit_sdev - Return SCSI device for zfcp_unit
184 * @unit: The zfcp_unit where to get the SCSI device for
186 * Returns: scsi_device pointer on success, NULL if there is no SCSI
187 * device for this zfcp_unit
189 * On success, the caller also holds a reference to the SCSI device
190 * that must be released with scsi_device_put.
192 struct scsi_device
*zfcp_unit_sdev(struct zfcp_unit
*unit
)
194 struct Scsi_Host
*shost
;
195 struct zfcp_port
*port
;
198 lun
= scsilun_to_int((struct scsi_lun
*) &unit
->fcp_lun
);
200 shost
= port
->adapter
->scsi_host
;
201 return scsi_device_lookup(shost
, 0, port
->starget_id
, lun
);
205 * zfcp_unit_sdev_status - Return zfcp LUN status for SCSI device
206 * @unit: The unit to lookup the SCSI device for
208 * Returns the zfcp LUN status field of the SCSI device if the SCSI device
209 * for the zfcp_unit exists, 0 otherwise.
211 unsigned int zfcp_unit_sdev_status(struct zfcp_unit
*unit
)
213 unsigned int status
= 0;
214 struct scsi_device
*sdev
;
215 struct zfcp_scsi_dev
*zfcp_sdev
;
217 sdev
= zfcp_unit_sdev(unit
);
219 zfcp_sdev
= sdev_to_zfcp(sdev
);
220 status
= atomic_read(&zfcp_sdev
->status
);
221 scsi_device_put(sdev
);
228 * zfcp_unit_remove - Remove entry from list of configured units
229 * @port: The port where to remove the unit from the configuration
230 * @fcp_lun: The 64 bit LUN of the unit to remove
232 * Returns: -EINVAL if a unit with the specified LUN does not exist,
235 int zfcp_unit_remove(struct zfcp_port
*port
, u64 fcp_lun
)
237 struct zfcp_unit
*unit
;
238 struct scsi_device
*sdev
;
240 write_lock_irq(&port
->unit_list_lock
);
241 unit
= _zfcp_unit_find(port
, fcp_lun
);
243 list_del(&unit
->list
);
244 write_unlock_irq(&port
->unit_list_lock
);
249 sdev
= zfcp_unit_sdev(unit
);
251 scsi_remove_device(sdev
);
252 scsi_device_put(sdev
);
255 put_device(&unit
->dev
);
257 zfcp_device_unregister(&unit
->dev
, &zfcp_sysfs_unit_attrs
);