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 */ 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 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 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 */ 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 */ 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 */ 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 */ 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