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,
33 static void zfcp_unit_scsi_scan_work(struct work_struct *work)
35 struct zfcp_unit *unit = container_of(work, struct zfcp_unit,
38 zfcp_unit_scsi_scan(unit);
39 put_device(&unit->dev);
43 * zfcp_unit_queue_scsi_scan - Register configured units on port
44 * @port: The zfcp_port where to register units
46 * After opening a port, all units configured on this port have to be
47 * registered with the SCSI midlayer. This function should be called
48 * after calling fc_remote_port_add, so that the fc_rport is already
49 * ONLINE and the call to scsi_scan_target runs the same way as the
50 * call in the FC transport class.
52 void zfcp_unit_queue_scsi_scan(struct zfcp_port *port)
54 struct zfcp_unit *unit;
56 read_lock_irq(&port->unit_list_lock);
57 list_for_each_entry(unit, &port->unit_list, list) {
58 get_device(&unit->dev);
59 if (scsi_queue_work(port->adapter->scsi_host,
60 &unit->scsi_work) <= 0)
61 put_device(&unit->dev);
63 read_unlock_irq(&port->unit_list_lock);
66 static struct zfcp_unit *_zfcp_unit_find(struct zfcp_port *port, u64 fcp_lun)
68 struct zfcp_unit *unit;
70 list_for_each_entry(unit, &port->unit_list, list)
71 if (unit->fcp_lun == fcp_lun) {
72 get_device(&unit->dev);
80 * zfcp_unit_find - Find and return zfcp_unit with specified FCP LUN
81 * @port: zfcp_port where to look for the unit
82 * @fcp_lun: 64 Bit FCP LUN used to identify the zfcp_unit
84 * If zfcp_unit is found, a reference is acquired that has to be
87 * Returns: Pointer to the zfcp_unit, or NULL if there is no zfcp_unit
88 * with the specified FCP LUN.
90 struct zfcp_unit *zfcp_unit_find(struct zfcp_port *port, u64 fcp_lun)
92 struct zfcp_unit *unit;
94 read_lock_irq(&port->unit_list_lock);
95 unit = _zfcp_unit_find(port, fcp_lun);
96 read_unlock_irq(&port->unit_list_lock);
101 * zfcp_unit_release - Drop reference to zfcp_port and free memory of zfcp_unit.
102 * @dev: pointer to device in zfcp_unit
104 static void zfcp_unit_release(struct device *dev)
106 struct zfcp_unit *unit = container_of(dev, struct zfcp_unit, dev);
108 atomic_dec(&unit->port->units);
113 * zfcp_unit_enqueue - enqueue unit to unit list of a port.
114 * @port: pointer to port where unit is added
115 * @fcp_lun: FCP LUN of unit to be enqueued
118 * Sets up some unit internal structures and creates sysfs entry.
120 int zfcp_unit_add(struct zfcp_port *port, u64 fcp_lun)
122 struct zfcp_unit *unit;
125 mutex_lock(&zfcp_sysfs_port_units_mutex);
126 if (zfcp_sysfs_port_is_removing(port)) {
127 /* port is already gone */
132 unit = zfcp_unit_find(port, fcp_lun);
134 put_device(&unit->dev);
139 unit = kzalloc(sizeof(struct zfcp_unit), GFP_KERNEL);
146 unit->fcp_lun = fcp_lun;
147 unit->dev.parent = &port->dev;
148 unit->dev.release = zfcp_unit_release;
149 unit->dev.groups = zfcp_unit_attr_groups;
150 INIT_WORK(&unit->scsi_work, zfcp_unit_scsi_scan_work);
152 if (dev_set_name(&unit->dev, "0x%016llx",
153 (unsigned long long) fcp_lun)) {
159 if (device_register(&unit->dev)) {
160 put_device(&unit->dev);
165 atomic_inc(&port->units); /* under zfcp_sysfs_port_units_mutex ! */
167 write_lock_irq(&port->unit_list_lock);
168 list_add_tail(&unit->list, &port->unit_list);
169 write_unlock_irq(&port->unit_list_lock);
171 * lock order: shost->scan_mutex before zfcp_sysfs_port_units_mutex
172 * due to zfcp_unit_scsi_scan() => zfcp_scsi_slave_alloc()
174 mutex_unlock(&zfcp_sysfs_port_units_mutex);
176 zfcp_unit_scsi_scan(unit);
180 mutex_unlock(&zfcp_sysfs_port_units_mutex);
185 * zfcp_unit_sdev - Return SCSI device for zfcp_unit
186 * @unit: The zfcp_unit where to get the SCSI device for
188 * Returns: scsi_device pointer on success, NULL if there is no SCSI
189 * device for this zfcp_unit
191 * On success, the caller also holds a reference to the SCSI device
192 * that must be released with scsi_device_put.
194 struct scsi_device *zfcp_unit_sdev(struct zfcp_unit *unit)
196 struct Scsi_Host *shost;
197 struct zfcp_port *port;
200 lun = scsilun_to_int((struct scsi_lun *) &unit->fcp_lun);
202 shost = port->adapter->scsi_host;
203 return scsi_device_lookup(shost, 0, port->starget_id, lun);
207 * zfcp_unit_sdev_status - Return zfcp LUN status for SCSI device
208 * @unit: The unit to lookup the SCSI device for
210 * Returns the zfcp LUN status field of the SCSI device if the SCSI device
211 * for the zfcp_unit exists, 0 otherwise.
213 unsigned int zfcp_unit_sdev_status(struct zfcp_unit *unit)
215 unsigned int status = 0;
216 struct scsi_device *sdev;
217 struct zfcp_scsi_dev *zfcp_sdev;
219 sdev = zfcp_unit_sdev(unit);
221 zfcp_sdev = sdev_to_zfcp(sdev);
222 status = atomic_read(&zfcp_sdev->status);
223 scsi_device_put(sdev);
230 * zfcp_unit_remove - Remove entry from list of configured units
231 * @port: The port where to remove the unit from the configuration
232 * @fcp_lun: The 64 bit LUN of the unit to remove
234 * Returns: -EINVAL if a unit with the specified LUN does not exist,
237 int zfcp_unit_remove(struct zfcp_port *port, u64 fcp_lun)
239 struct zfcp_unit *unit;
240 struct scsi_device *sdev;
242 write_lock_irq(&port->unit_list_lock);
243 unit = _zfcp_unit_find(port, fcp_lun);
245 list_del(&unit->list);
246 write_unlock_irq(&port->unit_list_lock);
251 sdev = zfcp_unit_sdev(unit);
253 scsi_remove_device(sdev);
254 scsi_device_put(sdev);
257 put_device(&unit->dev);
259 device_unregister(&unit->dev);