1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * PAV alias management for the DASD ECKD discipline
4  *
5  * Copyright IBM Corp. 2007
6  * Author(s): Stefan Weinhuber <wein@de.ibm.com>
7  */
8 
9 #define KMSG_COMPONENT "dasd-eckd"
10 
11 #include <linux/list.h>
12 #include <linux/slab.h>
13 #include <asm/ebcdic.h>
14 #include "dasd_int.h"
15 #include "dasd_eckd.h"
16 
17 #ifdef PRINTK_HEADER
18 #undef PRINTK_HEADER
19 #endif				/* PRINTK_HEADER */
20 #define PRINTK_HEADER "dasd(eckd):"
21 
22 
23 /*
24  * General concept of alias management:
25  * - PAV and DASD alias management is specific to the eckd discipline.
26  * - A device is connected to an lcu as long as the device exists.
27  *   dasd_alias_make_device_known_to_lcu will be called wenn the
28  *   device is checked by the eckd discipline and
29  *   dasd_alias_disconnect_device_from_lcu will be called
30  *   before the device is deleted.
31  * - The dasd_alias_add_device / dasd_alias_remove_device
32  *   functions mark the point when a device is 'ready for service'.
33  * - A summary unit check is a rare occasion, but it is mandatory to
34  *   support it. It requires some complex recovery actions before the
35  *   devices can be used again (see dasd_alias_handle_summary_unit_check).
36  * - dasd_alias_get_start_dev will find an alias device that can be used
37  *   instead of the base device and does some (very simple) load balancing.
38  *   This is the function that gets called for each I/O, so when improving
39  *   something, this function should get faster or better, the rest has just
40  *   to be correct.
41  */
42 
43 
44 static void summary_unit_check_handling_work(struct work_struct *);
45 static void lcu_update_work(struct work_struct *);
46 static int _schedule_lcu_update(struct alias_lcu *, struct dasd_device *);
47 
48 static struct alias_root aliastree = {
49 	.serverlist = LIST_HEAD_INIT(aliastree.serverlist),
50 	.lock = __SPIN_LOCK_UNLOCKED(aliastree.lock),
51 };
52 
_find_server(struct dasd_uid * uid)53 static struct alias_server *_find_server(struct dasd_uid *uid)
54 {
55 	struct alias_server *pos;
56 	list_for_each_entry(pos, &aliastree.serverlist, server) {
57 		if (!strncmp(pos->uid.vendor, uid->vendor,
58 			     sizeof(uid->vendor))
59 		    && !strncmp(pos->uid.serial, uid->serial,
60 				sizeof(uid->serial)))
61 			return pos;
62 	}
63 	return NULL;
64 }
65 
_find_lcu(struct alias_server * server,struct dasd_uid * uid)66 static struct alias_lcu *_find_lcu(struct alias_server *server,
67 				   struct dasd_uid *uid)
68 {
69 	struct alias_lcu *pos;
70 	list_for_each_entry(pos, &server->lculist, lcu) {
71 		if (pos->uid.ssid == uid->ssid)
72 			return pos;
73 	}
74 	return NULL;
75 }
76 
_find_group(struct alias_lcu * lcu,struct dasd_uid * uid)77 static struct alias_pav_group *_find_group(struct alias_lcu *lcu,
78 					   struct dasd_uid *uid)
79 {
80 	struct alias_pav_group *pos;
81 	__u8 search_unit_addr;
82 
83 	/* for hyper pav there is only one group */
84 	if (lcu->pav == HYPER_PAV) {
85 		if (list_empty(&lcu->grouplist))
86 			return NULL;
87 		else
88 			return list_first_entry(&lcu->grouplist,
89 						struct alias_pav_group, group);
90 	}
91 
92 	/* for base pav we have to find the group that matches the base */
93 	if (uid->type == UA_BASE_DEVICE)
94 		search_unit_addr = uid->real_unit_addr;
95 	else
96 		search_unit_addr = uid->base_unit_addr;
97 	list_for_each_entry(pos, &lcu->grouplist, group) {
98 		if (pos->uid.base_unit_addr == search_unit_addr &&
99 		    !strncmp(pos->uid.vduit, uid->vduit, sizeof(uid->vduit)))
100 			return pos;
101 	}
102 	return NULL;
103 }
104 
_allocate_server(struct dasd_uid * uid)105 static struct alias_server *_allocate_server(struct dasd_uid *uid)
106 {
107 	struct alias_server *server;
108 
109 	server = kzalloc(sizeof(*server), GFP_KERNEL);
110 	if (!server)
111 		return ERR_PTR(-ENOMEM);
112 	memcpy(server->uid.vendor, uid->vendor, sizeof(uid->vendor));
113 	memcpy(server->uid.serial, uid->serial, sizeof(uid->serial));
114 	INIT_LIST_HEAD(&server->server);
115 	INIT_LIST_HEAD(&server->lculist);
116 	return server;
117 }
118 
_free_server(struct alias_server * server)119 static void _free_server(struct alias_server *server)
120 {
121 	kfree(server);
122 }
123 
_allocate_lcu(struct dasd_uid * uid)124 static struct alias_lcu *_allocate_lcu(struct dasd_uid *uid)
125 {
126 	struct alias_lcu *lcu;
127 
128 	lcu = kzalloc(sizeof(*lcu), GFP_KERNEL);
129 	if (!lcu)
130 		return ERR_PTR(-ENOMEM);
131 	lcu->uac = kzalloc(sizeof(*(lcu->uac)), GFP_KERNEL | GFP_DMA);
132 	if (!lcu->uac)
133 		goto out_err1;
134 	lcu->rsu_cqr = kzalloc(sizeof(*lcu->rsu_cqr), GFP_KERNEL | GFP_DMA);
135 	if (!lcu->rsu_cqr)
136 		goto out_err2;
137 	lcu->rsu_cqr->cpaddr = kzalloc(sizeof(struct ccw1),
138 				       GFP_KERNEL | GFP_DMA);
139 	if (!lcu->rsu_cqr->cpaddr)
140 		goto out_err3;
141 	lcu->rsu_cqr->data = kzalloc(16, GFP_KERNEL | GFP_DMA);
142 	if (!lcu->rsu_cqr->data)
143 		goto out_err4;
144 
145 	memcpy(lcu->uid.vendor, uid->vendor, sizeof(uid->vendor));
146 	memcpy(lcu->uid.serial, uid->serial, sizeof(uid->serial));
147 	lcu->uid.ssid = uid->ssid;
148 	lcu->pav = NO_PAV;
149 	lcu->flags = NEED_UAC_UPDATE | UPDATE_PENDING;
150 	INIT_LIST_HEAD(&lcu->lcu);
151 	INIT_LIST_HEAD(&lcu->inactive_devices);
152 	INIT_LIST_HEAD(&lcu->active_devices);
153 	INIT_LIST_HEAD(&lcu->grouplist);
154 	INIT_WORK(&lcu->suc_data.worker, summary_unit_check_handling_work);
155 	INIT_DELAYED_WORK(&lcu->ruac_data.dwork, lcu_update_work);
156 	spin_lock_init(&lcu->lock);
157 	init_completion(&lcu->lcu_setup);
158 	return lcu;
159 
160 out_err4:
161 	kfree(lcu->rsu_cqr->cpaddr);
162 out_err3:
163 	kfree(lcu->rsu_cqr);
164 out_err2:
165 	kfree(lcu->uac);
166 out_err1:
167 	kfree(lcu);
168 	return ERR_PTR(-ENOMEM);
169 }
170 
_free_lcu(struct alias_lcu * lcu)171 static void _free_lcu(struct alias_lcu *lcu)
172 {
173 	kfree(lcu->rsu_cqr->data);
174 	kfree(lcu->rsu_cqr->cpaddr);
175 	kfree(lcu->rsu_cqr);
176 	kfree(lcu->uac);
177 	kfree(lcu);
178 }
179 
180 /*
181  * This is the function that will allocate all the server and lcu data,
182  * so this function must be called first for a new device.
183  * If the return value is 1, the lcu was already known before, if it
184  * is 0, this is a new lcu.
185  * Negative return code indicates that something went wrong (e.g. -ENOMEM)
186  */
dasd_alias_make_device_known_to_lcu(struct dasd_device * device)187 int dasd_alias_make_device_known_to_lcu(struct dasd_device *device)
188 {
189 	struct dasd_eckd_private *private = device->private;
190 	unsigned long flags;
191 	struct alias_server *server, *newserver;
192 	struct alias_lcu *lcu, *newlcu;
193 	struct dasd_uid uid;
194 
195 	device->discipline->get_uid(device, &uid);
196 	spin_lock_irqsave(&aliastree.lock, flags);
197 	server = _find_server(&uid);
198 	if (!server) {
199 		spin_unlock_irqrestore(&aliastree.lock, flags);
200 		newserver = _allocate_server(&uid);
201 		if (IS_ERR(newserver))
202 			return PTR_ERR(newserver);
203 		spin_lock_irqsave(&aliastree.lock, flags);
204 		server = _find_server(&uid);
205 		if (!server) {
206 			list_add(&newserver->server, &aliastree.serverlist);
207 			server = newserver;
208 		} else {
209 			/* someone was faster */
210 			_free_server(newserver);
211 		}
212 	}
213 
214 	lcu = _find_lcu(server, &uid);
215 	if (!lcu) {
216 		spin_unlock_irqrestore(&aliastree.lock, flags);
217 		newlcu = _allocate_lcu(&uid);
218 		if (IS_ERR(newlcu))
219 			return PTR_ERR(newlcu);
220 		spin_lock_irqsave(&aliastree.lock, flags);
221 		lcu = _find_lcu(server, &uid);
222 		if (!lcu) {
223 			list_add(&newlcu->lcu, &server->lculist);
224 			lcu = newlcu;
225 		} else {
226 			/* someone was faster */
227 			_free_lcu(newlcu);
228 		}
229 	}
230 	spin_lock(&lcu->lock);
231 	list_add(&device->alias_list, &lcu->inactive_devices);
232 	private->lcu = lcu;
233 	spin_unlock(&lcu->lock);
234 	spin_unlock_irqrestore(&aliastree.lock, flags);
235 
236 	return 0;
237 }
238 
239 /*
240  * This function removes a device from the scope of alias management.
241  * The complicated part is to make sure that it is not in use by
242  * any of the workers. If necessary cancel the work.
243  */
dasd_alias_disconnect_device_from_lcu(struct dasd_device * device)244 void dasd_alias_disconnect_device_from_lcu(struct dasd_device *device)
245 {
246 	struct dasd_eckd_private *private = device->private;
247 	unsigned long flags;
248 	struct alias_lcu *lcu;
249 	struct alias_server *server;
250 	int was_pending;
251 	struct dasd_uid uid;
252 
253 	lcu = private->lcu;
254 	/* nothing to do if already disconnected */
255 	if (!lcu)
256 		return;
257 	device->discipline->get_uid(device, &uid);
258 	spin_lock_irqsave(&lcu->lock, flags);
259 	/* make sure that the workers don't use this device */
260 	if (device == lcu->suc_data.device) {
261 		spin_unlock_irqrestore(&lcu->lock, flags);
262 		cancel_work_sync(&lcu->suc_data.worker);
263 		spin_lock_irqsave(&lcu->lock, flags);
264 		if (device == lcu->suc_data.device) {
265 			dasd_put_device(device);
266 			lcu->suc_data.device = NULL;
267 		}
268 	}
269 	was_pending = 0;
270 	if (device == lcu->ruac_data.device) {
271 		spin_unlock_irqrestore(&lcu->lock, flags);
272 		was_pending = 1;
273 		cancel_delayed_work_sync(&lcu->ruac_data.dwork);
274 		spin_lock_irqsave(&lcu->lock, flags);
275 		if (device == lcu->ruac_data.device) {
276 			dasd_put_device(device);
277 			lcu->ruac_data.device = NULL;
278 		}
279 	}
280 	private->lcu = NULL;
281 	spin_unlock_irqrestore(&lcu->lock, flags);
282 
283 	spin_lock_irqsave(&aliastree.lock, flags);
284 	spin_lock(&lcu->lock);
285 	list_del_init(&device->alias_list);
286 	if (list_empty(&lcu->grouplist) &&
287 	    list_empty(&lcu->active_devices) &&
288 	    list_empty(&lcu->inactive_devices)) {
289 		list_del(&lcu->lcu);
290 		spin_unlock(&lcu->lock);
291 		_free_lcu(lcu);
292 		lcu = NULL;
293 	} else {
294 		if (was_pending)
295 			_schedule_lcu_update(lcu, NULL);
296 		spin_unlock(&lcu->lock);
297 	}
298 	server = _find_server(&uid);
299 	if (server && list_empty(&server->lculist)) {
300 		list_del(&server->server);
301 		_free_server(server);
302 	}
303 	spin_unlock_irqrestore(&aliastree.lock, flags);
304 }
305 
306 /*
307  * This function assumes that the unit address configuration stored
308  * in the lcu is up to date and will update the device uid before
309  * adding it to a pav group.
310  */
311 
_add_device_to_lcu(struct alias_lcu * lcu,struct dasd_device * device,struct dasd_device * pos)312 static int _add_device_to_lcu(struct alias_lcu *lcu,
313 			      struct dasd_device *device,
314 			      struct dasd_device *pos)
315 {
316 
317 	struct dasd_eckd_private *private = device->private;
318 	struct alias_pav_group *group;
319 	struct dasd_uid uid;
320 
321 	spin_lock(get_ccwdev_lock(device->cdev));
322 	private->uid.type = lcu->uac->unit[private->uid.real_unit_addr].ua_type;
323 	private->uid.base_unit_addr =
324 		lcu->uac->unit[private->uid.real_unit_addr].base_ua;
325 	uid = private->uid;
326 	spin_unlock(get_ccwdev_lock(device->cdev));
327 	/* if we have no PAV anyway, we don't need to bother with PAV groups */
328 	if (lcu->pav == NO_PAV) {
329 		list_move(&device->alias_list, &lcu->active_devices);
330 		return 0;
331 	}
332 	group = _find_group(lcu, &uid);
333 	if (!group) {
334 		group = kzalloc(sizeof(*group), GFP_ATOMIC);
335 		if (!group)
336 			return -ENOMEM;
337 		memcpy(group->uid.vendor, uid.vendor, sizeof(uid.vendor));
338 		memcpy(group->uid.serial, uid.serial, sizeof(uid.serial));
339 		group->uid.ssid = uid.ssid;
340 		if (uid.type == UA_BASE_DEVICE)
341 			group->uid.base_unit_addr = uid.real_unit_addr;
342 		else
343 			group->uid.base_unit_addr = uid.base_unit_addr;
344 		memcpy(group->uid.vduit, uid.vduit, sizeof(uid.vduit));
345 		INIT_LIST_HEAD(&group->group);
346 		INIT_LIST_HEAD(&group->baselist);
347 		INIT_LIST_HEAD(&group->aliaslist);
348 		list_add(&group->group, &lcu->grouplist);
349 	}
350 	if (uid.type == UA_BASE_DEVICE)
351 		list_move(&device->alias_list, &group->baselist);
352 	else
353 		list_move(&device->alias_list, &group->aliaslist);
354 	private->pavgroup = group;
355 	return 0;
356 };
357 
_remove_device_from_lcu(struct alias_lcu * lcu,struct dasd_device * device)358 static void _remove_device_from_lcu(struct alias_lcu *lcu,
359 				    struct dasd_device *device)
360 {
361 	struct dasd_eckd_private *private = device->private;
362 	struct alias_pav_group *group;
363 
364 	list_move(&device->alias_list, &lcu->inactive_devices);
365 	group = private->pavgroup;
366 	if (!group)
367 		return;
368 	private->pavgroup = NULL;
369 	if (list_empty(&group->baselist) && list_empty(&group->aliaslist)) {
370 		list_del(&group->group);
371 		kfree(group);
372 		return;
373 	}
374 	if (group->next == device)
375 		group->next = NULL;
376 };
377 
378 static int
suborder_not_supported(struct dasd_ccw_req * cqr)379 suborder_not_supported(struct dasd_ccw_req *cqr)
380 {
381 	char *sense;
382 	char reason;
383 	char msg_format;
384 	char msg_no;
385 
386 	/*
387 	 * intrc values ENODEV, ENOLINK and EPERM
388 	 * will be optained from sleep_on to indicate that no
389 	 * IO operation can be started
390 	 */
391 	if (cqr->intrc == -ENODEV)
392 		return 1;
393 
394 	if (cqr->intrc == -ENOLINK)
395 		return 1;
396 
397 	if (cqr->intrc == -EPERM)
398 		return 1;
399 
400 	sense = dasd_get_sense(&cqr->irb);
401 	if (!sense)
402 		return 0;
403 
404 	reason = sense[0];
405 	msg_format = (sense[7] & 0xF0);
406 	msg_no = (sense[7] & 0x0F);
407 
408 	/* command reject, Format 0 MSG 4 - invalid parameter */
409 	if ((reason == 0x80) && (msg_format == 0x00) && (msg_no == 0x04))
410 		return 1;
411 
412 	return 0;
413 }
414 
read_unit_address_configuration(struct dasd_device * device,struct alias_lcu * lcu)415 static int read_unit_address_configuration(struct dasd_device *device,
416 					   struct alias_lcu *lcu)
417 {
418 	struct dasd_psf_prssd_data *prssdp;
419 	struct dasd_ccw_req *cqr;
420 	struct ccw1 *ccw;
421 	int rc;
422 	unsigned long flags;
423 
424 	cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1 /* PSF */	+ 1 /* RSSD */,
425 				   (sizeof(struct dasd_psf_prssd_data)),
426 				   device, NULL);
427 	if (IS_ERR(cqr))
428 		return PTR_ERR(cqr);
429 	cqr->startdev = device;
430 	cqr->memdev = device;
431 	clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
432 	cqr->retries = 10;
433 	cqr->expires = 20 * HZ;
434 
435 	/* Prepare for Read Subsystem Data */
436 	prssdp = (struct dasd_psf_prssd_data *) cqr->data;
437 	memset(prssdp, 0, sizeof(struct dasd_psf_prssd_data));
438 	prssdp->order = PSF_ORDER_PRSSD;
439 	prssdp->suborder = 0x0e;	/* Read unit address configuration */
440 	/* all other bytes of prssdp must be zero */
441 
442 	ccw = cqr->cpaddr;
443 	ccw->cmd_code = DASD_ECKD_CCW_PSF;
444 	ccw->count = sizeof(struct dasd_psf_prssd_data);
445 	ccw->flags |= CCW_FLAG_CC;
446 	ccw->cda = (__u32)(addr_t) prssdp;
447 
448 	/* Read Subsystem Data - feature codes */
449 	memset(lcu->uac, 0, sizeof(*(lcu->uac)));
450 
451 	ccw++;
452 	ccw->cmd_code = DASD_ECKD_CCW_RSSD;
453 	ccw->count = sizeof(*(lcu->uac));
454 	ccw->cda = (__u32)(addr_t) lcu->uac;
455 
456 	cqr->buildclk = get_tod_clock();
457 	cqr->status = DASD_CQR_FILLED;
458 
459 	/* need to unset flag here to detect race with summary unit check */
460 	spin_lock_irqsave(&lcu->lock, flags);
461 	lcu->flags &= ~NEED_UAC_UPDATE;
462 	spin_unlock_irqrestore(&lcu->lock, flags);
463 
464 	rc = dasd_sleep_on(cqr);
465 	if (!rc)
466 		goto out;
467 
468 	if (suborder_not_supported(cqr)) {
469 		/* suborder not supported or device unusable for IO */
470 		rc = -EOPNOTSUPP;
471 	} else {
472 		/* IO failed but should be retried */
473 		spin_lock_irqsave(&lcu->lock, flags);
474 		lcu->flags |= NEED_UAC_UPDATE;
475 		spin_unlock_irqrestore(&lcu->lock, flags);
476 	}
477 out:
478 	dasd_sfree_request(cqr, cqr->memdev);
479 	return rc;
480 }
481 
_lcu_update(struct dasd_device * refdev,struct alias_lcu * lcu)482 static int _lcu_update(struct dasd_device *refdev, struct alias_lcu *lcu)
483 {
484 	unsigned long flags;
485 	struct alias_pav_group *pavgroup, *tempgroup;
486 	struct dasd_device *device, *tempdev;
487 	int i, rc;
488 	struct dasd_eckd_private *private;
489 
490 	spin_lock_irqsave(&lcu->lock, flags);
491 	list_for_each_entry_safe(pavgroup, tempgroup, &lcu->grouplist, group) {
492 		list_for_each_entry_safe(device, tempdev, &pavgroup->baselist,
493 					 alias_list) {
494 			list_move(&device->alias_list, &lcu->active_devices);
495 			private = device->private;
496 			private->pavgroup = NULL;
497 		}
498 		list_for_each_entry_safe(device, tempdev, &pavgroup->aliaslist,
499 					 alias_list) {
500 			list_move(&device->alias_list, &lcu->active_devices);
501 			private = device->private;
502 			private->pavgroup = NULL;
503 		}
504 		list_del(&pavgroup->group);
505 		kfree(pavgroup);
506 	}
507 	spin_unlock_irqrestore(&lcu->lock, flags);
508 
509 	rc = read_unit_address_configuration(refdev, lcu);
510 	if (rc)
511 		return rc;
512 
513 	spin_lock_irqsave(&lcu->lock, flags);
514 	/*
515 	 * there is another update needed skip the remaining handling
516 	 * the data might already be outdated
517 	 * but especially do not add the device to an LCU with pending
518 	 * update
519 	 */
520 	if (lcu->flags & NEED_UAC_UPDATE)
521 		goto out;
522 	lcu->pav = NO_PAV;
523 	for (i = 0; i < MAX_DEVICES_PER_LCU; ++i) {
524 		switch (lcu->uac->unit[i].ua_type) {
525 		case UA_BASE_PAV_ALIAS:
526 			lcu->pav = BASE_PAV;
527 			break;
528 		case UA_HYPER_PAV_ALIAS:
529 			lcu->pav = HYPER_PAV;
530 			break;
531 		}
532 		if (lcu->pav != NO_PAV)
533 			break;
534 	}
535 
536 	list_for_each_entry_safe(device, tempdev, &lcu->active_devices,
537 				 alias_list) {
538 		_add_device_to_lcu(lcu, device, refdev);
539 	}
540 out:
541 	spin_unlock_irqrestore(&lcu->lock, flags);
542 	return 0;
543 }
544 
lcu_update_work(struct work_struct * work)545 static void lcu_update_work(struct work_struct *work)
546 {
547 	struct alias_lcu *lcu;
548 	struct read_uac_work_data *ruac_data;
549 	struct dasd_device *device;
550 	unsigned long flags;
551 	int rc;
552 
553 	ruac_data = container_of(work, struct read_uac_work_data, dwork.work);
554 	lcu = container_of(ruac_data, struct alias_lcu, ruac_data);
555 	device = ruac_data->device;
556 	rc = _lcu_update(device, lcu);
557 	/*
558 	 * Need to check flags again, as there could have been another
559 	 * prepare_update or a new device a new device while we were still
560 	 * processing the data
561 	 */
562 	spin_lock_irqsave(&lcu->lock, flags);
563 	if ((rc && (rc != -EOPNOTSUPP)) || (lcu->flags & NEED_UAC_UPDATE)) {
564 		DBF_DEV_EVENT(DBF_WARNING, device, "could not update"
565 			    " alias data in lcu (rc = %d), retry later", rc);
566 		if (!schedule_delayed_work(&lcu->ruac_data.dwork, 30*HZ))
567 			dasd_put_device(device);
568 	} else {
569 		dasd_put_device(device);
570 		lcu->ruac_data.device = NULL;
571 		lcu->flags &= ~UPDATE_PENDING;
572 	}
573 	spin_unlock_irqrestore(&lcu->lock, flags);
574 }
575 
_schedule_lcu_update(struct alias_lcu * lcu,struct dasd_device * device)576 static int _schedule_lcu_update(struct alias_lcu *lcu,
577 				struct dasd_device *device)
578 {
579 	struct dasd_device *usedev = NULL;
580 	struct alias_pav_group *group;
581 
582 	lcu->flags |= NEED_UAC_UPDATE;
583 	if (lcu->ruac_data.device) {
584 		/* already scheduled or running */
585 		return 0;
586 	}
587 	if (device && !list_empty(&device->alias_list))
588 		usedev = device;
589 
590 	if (!usedev && !list_empty(&lcu->grouplist)) {
591 		group = list_first_entry(&lcu->grouplist,
592 					 struct alias_pav_group, group);
593 		if (!list_empty(&group->baselist))
594 			usedev = list_first_entry(&group->baselist,
595 						  struct dasd_device,
596 						  alias_list);
597 		else if (!list_empty(&group->aliaslist))
598 			usedev = list_first_entry(&group->aliaslist,
599 						  struct dasd_device,
600 						  alias_list);
601 	}
602 	if (!usedev && !list_empty(&lcu->active_devices)) {
603 		usedev = list_first_entry(&lcu->active_devices,
604 					  struct dasd_device, alias_list);
605 	}
606 	/*
607 	 * if we haven't found a proper device yet, give up for now, the next
608 	 * device that will be set active will trigger an lcu update
609 	 */
610 	if (!usedev)
611 		return -EINVAL;
612 	dasd_get_device(usedev);
613 	lcu->ruac_data.device = usedev;
614 	if (!schedule_delayed_work(&lcu->ruac_data.dwork, 0))
615 		dasd_put_device(usedev);
616 	return 0;
617 }
618 
dasd_alias_add_device(struct dasd_device * device)619 int dasd_alias_add_device(struct dasd_device *device)
620 {
621 	struct dasd_eckd_private *private = device->private;
622 	__u8 uaddr = private->uid.real_unit_addr;
623 	struct alias_lcu *lcu = private->lcu;
624 	unsigned long flags;
625 	int rc;
626 
627 	rc = 0;
628 	spin_lock_irqsave(&lcu->lock, flags);
629 	/*
630 	 * Check if device and lcu type differ. If so, the uac data may be
631 	 * outdated and needs to be updated.
632 	 */
633 	if (private->uid.type !=  lcu->uac->unit[uaddr].ua_type) {
634 		lcu->flags |= UPDATE_PENDING;
635 		DBF_DEV_EVENT(DBF_WARNING, device, "%s",
636 			      "uid type mismatch - trigger rescan");
637 	}
638 	if (!(lcu->flags & UPDATE_PENDING)) {
639 		rc = _add_device_to_lcu(lcu, device, device);
640 		if (rc)
641 			lcu->flags |= UPDATE_PENDING;
642 	}
643 	if (lcu->flags & UPDATE_PENDING) {
644 		list_move(&device->alias_list, &lcu->active_devices);
645 		private->pavgroup = NULL;
646 		_schedule_lcu_update(lcu, device);
647 	}
648 	spin_unlock_irqrestore(&lcu->lock, flags);
649 	return rc;
650 }
651 
dasd_alias_update_add_device(struct dasd_device * device)652 int dasd_alias_update_add_device(struct dasd_device *device)
653 {
654 	struct dasd_eckd_private *private = device->private;
655 
656 	private->lcu->flags |= UPDATE_PENDING;
657 	return dasd_alias_add_device(device);
658 }
659 
dasd_alias_remove_device(struct dasd_device * device)660 int dasd_alias_remove_device(struct dasd_device *device)
661 {
662 	struct dasd_eckd_private *private = device->private;
663 	struct alias_lcu *lcu = private->lcu;
664 	unsigned long flags;
665 
666 	/* nothing to do if already removed */
667 	if (!lcu)
668 		return 0;
669 	spin_lock_irqsave(&lcu->lock, flags);
670 	_remove_device_from_lcu(lcu, device);
671 	spin_unlock_irqrestore(&lcu->lock, flags);
672 	return 0;
673 }
674 
dasd_alias_get_start_dev(struct dasd_device * base_device)675 struct dasd_device *dasd_alias_get_start_dev(struct dasd_device *base_device)
676 {
677 	struct dasd_eckd_private *alias_priv, *private = base_device->private;
678 	struct alias_lcu *lcu = private->lcu;
679 	struct dasd_device *alias_device;
680 	struct alias_pav_group *group;
681 	unsigned long flags;
682 
683 	if (!lcu)
684 		return NULL;
685 	if (lcu->pav == NO_PAV ||
686 	    lcu->flags & (NEED_UAC_UPDATE | UPDATE_PENDING))
687 		return NULL;
688 	if (unlikely(!(private->features.feature[8] & 0x01))) {
689 		/*
690 		 * PAV enabled but prefix not, very unlikely
691 		 * seems to be a lost pathgroup
692 		 * use base device to do IO
693 		 */
694 		DBF_DEV_EVENT(DBF_ERR, base_device, "%s",
695 			      "Prefix not enabled with PAV enabled\n");
696 		return NULL;
697 	}
698 
699 	spin_lock_irqsave(&lcu->lock, flags);
700 	group = private->pavgroup;
701 	if (!group) {
702 		spin_unlock_irqrestore(&lcu->lock, flags);
703 		return NULL;
704 	}
705 	alias_device = group->next;
706 	if (!alias_device) {
707 		if (list_empty(&group->aliaslist)) {
708 			spin_unlock_irqrestore(&lcu->lock, flags);
709 			return NULL;
710 		} else {
711 			alias_device = list_first_entry(&group->aliaslist,
712 							struct dasd_device,
713 							alias_list);
714 		}
715 	}
716 	if (list_is_last(&alias_device->alias_list, &group->aliaslist))
717 		group->next = list_first_entry(&group->aliaslist,
718 					       struct dasd_device, alias_list);
719 	else
720 		group->next = list_first_entry(&alias_device->alias_list,
721 					       struct dasd_device, alias_list);
722 	spin_unlock_irqrestore(&lcu->lock, flags);
723 	alias_priv = alias_device->private;
724 	if ((alias_priv->count < private->count) && !alias_device->stopped &&
725 	    !test_bit(DASD_FLAG_OFFLINE, &alias_device->flags))
726 		return alias_device;
727 	else
728 		return NULL;
729 }
730 
731 /*
732  * Summary unit check handling depends on the way alias devices
733  * are handled so it is done here rather then in dasd_eckd.c
734  */
reset_summary_unit_check(struct alias_lcu * lcu,struct dasd_device * device,char reason)735 static int reset_summary_unit_check(struct alias_lcu *lcu,
736 				    struct dasd_device *device,
737 				    char reason)
738 {
739 	struct dasd_ccw_req *cqr;
740 	int rc = 0;
741 	struct ccw1 *ccw;
742 
743 	cqr = lcu->rsu_cqr;
744 	memcpy((char *) &cqr->magic, "ECKD", 4);
745 	ASCEBC((char *) &cqr->magic, 4);
746 	ccw = cqr->cpaddr;
747 	ccw->cmd_code = DASD_ECKD_CCW_RSCK;
748 	ccw->flags = CCW_FLAG_SLI;
749 	ccw->count = 16;
750 	ccw->cda = (__u32)(addr_t) cqr->data;
751 	((char *)cqr->data)[0] = reason;
752 
753 	clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
754 	cqr->retries = 255;	/* set retry counter to enable basic ERP */
755 	cqr->startdev = device;
756 	cqr->memdev = device;
757 	cqr->block = NULL;
758 	cqr->expires = 5 * HZ;
759 	cqr->buildclk = get_tod_clock();
760 	cqr->status = DASD_CQR_FILLED;
761 
762 	rc = dasd_sleep_on_immediatly(cqr);
763 	return rc;
764 }
765 
_restart_all_base_devices_on_lcu(struct alias_lcu * lcu)766 static void _restart_all_base_devices_on_lcu(struct alias_lcu *lcu)
767 {
768 	struct alias_pav_group *pavgroup;
769 	struct dasd_device *device;
770 	struct dasd_eckd_private *private;
771 
772 	/* active and inactive list can contain alias as well as base devices */
773 	list_for_each_entry(device, &lcu->active_devices, alias_list) {
774 		private = device->private;
775 		if (private->uid.type != UA_BASE_DEVICE)
776 			continue;
777 		dasd_schedule_block_bh(device->block);
778 		dasd_schedule_device_bh(device);
779 	}
780 	list_for_each_entry(device, &lcu->inactive_devices, alias_list) {
781 		private = device->private;
782 		if (private->uid.type != UA_BASE_DEVICE)
783 			continue;
784 		dasd_schedule_block_bh(device->block);
785 		dasd_schedule_device_bh(device);
786 	}
787 	list_for_each_entry(pavgroup, &lcu->grouplist, group) {
788 		list_for_each_entry(device, &pavgroup->baselist, alias_list) {
789 			dasd_schedule_block_bh(device->block);
790 			dasd_schedule_device_bh(device);
791 		}
792 	}
793 }
794 
flush_all_alias_devices_on_lcu(struct alias_lcu * lcu)795 static void flush_all_alias_devices_on_lcu(struct alias_lcu *lcu)
796 {
797 	struct alias_pav_group *pavgroup;
798 	struct dasd_device *device, *temp;
799 	struct dasd_eckd_private *private;
800 	unsigned long flags;
801 	LIST_HEAD(active);
802 
803 	/*
804 	 * Problem here ist that dasd_flush_device_queue may wait
805 	 * for termination of a request to complete. We can't keep
806 	 * the lcu lock during that time, so we must assume that
807 	 * the lists may have changed.
808 	 * Idea: first gather all active alias devices in a separate list,
809 	 * then flush the first element of this list unlocked, and afterwards
810 	 * check if it is still on the list before moving it to the
811 	 * active_devices list.
812 	 */
813 
814 	spin_lock_irqsave(&lcu->lock, flags);
815 	list_for_each_entry_safe(device, temp, &lcu->active_devices,
816 				 alias_list) {
817 		private = device->private;
818 		if (private->uid.type == UA_BASE_DEVICE)
819 			continue;
820 		list_move(&device->alias_list, &active);
821 	}
822 
823 	list_for_each_entry(pavgroup, &lcu->grouplist, group) {
824 		list_splice_init(&pavgroup->aliaslist, &active);
825 	}
826 	while (!list_empty(&active)) {
827 		device = list_first_entry(&active, struct dasd_device,
828 					  alias_list);
829 		spin_unlock_irqrestore(&lcu->lock, flags);
830 		dasd_flush_device_queue(device);
831 		spin_lock_irqsave(&lcu->lock, flags);
832 		/*
833 		 * only move device around if it wasn't moved away while we
834 		 * were waiting for the flush
835 		 */
836 		if (device == list_first_entry(&active,
837 					       struct dasd_device, alias_list)) {
838 			list_move(&device->alias_list, &lcu->active_devices);
839 			private = device->private;
840 			private->pavgroup = NULL;
841 		}
842 	}
843 	spin_unlock_irqrestore(&lcu->lock, flags);
844 }
845 
_stop_all_devices_on_lcu(struct alias_lcu * lcu)846 static void _stop_all_devices_on_lcu(struct alias_lcu *lcu)
847 {
848 	struct alias_pav_group *pavgroup;
849 	struct dasd_device *device;
850 
851 	list_for_each_entry(device, &lcu->active_devices, alias_list) {
852 		spin_lock(get_ccwdev_lock(device->cdev));
853 		dasd_device_set_stop_bits(device, DASD_STOPPED_SU);
854 		spin_unlock(get_ccwdev_lock(device->cdev));
855 	}
856 	list_for_each_entry(device, &lcu->inactive_devices, alias_list) {
857 		spin_lock(get_ccwdev_lock(device->cdev));
858 		dasd_device_set_stop_bits(device, DASD_STOPPED_SU);
859 		spin_unlock(get_ccwdev_lock(device->cdev));
860 	}
861 	list_for_each_entry(pavgroup, &lcu->grouplist, group) {
862 		list_for_each_entry(device, &pavgroup->baselist, alias_list) {
863 			spin_lock(get_ccwdev_lock(device->cdev));
864 			dasd_device_set_stop_bits(device, DASD_STOPPED_SU);
865 			spin_unlock(get_ccwdev_lock(device->cdev));
866 		}
867 		list_for_each_entry(device, &pavgroup->aliaslist, alias_list) {
868 			spin_lock(get_ccwdev_lock(device->cdev));
869 			dasd_device_set_stop_bits(device, DASD_STOPPED_SU);
870 			spin_unlock(get_ccwdev_lock(device->cdev));
871 		}
872 	}
873 }
874 
_unstop_all_devices_on_lcu(struct alias_lcu * lcu)875 static void _unstop_all_devices_on_lcu(struct alias_lcu *lcu)
876 {
877 	struct alias_pav_group *pavgroup;
878 	struct dasd_device *device;
879 
880 	list_for_each_entry(device, &lcu->active_devices, alias_list) {
881 		spin_lock(get_ccwdev_lock(device->cdev));
882 		dasd_device_remove_stop_bits(device, DASD_STOPPED_SU);
883 		spin_unlock(get_ccwdev_lock(device->cdev));
884 	}
885 	list_for_each_entry(device, &lcu->inactive_devices, alias_list) {
886 		spin_lock(get_ccwdev_lock(device->cdev));
887 		dasd_device_remove_stop_bits(device, DASD_STOPPED_SU);
888 		spin_unlock(get_ccwdev_lock(device->cdev));
889 	}
890 	list_for_each_entry(pavgroup, &lcu->grouplist, group) {
891 		list_for_each_entry(device, &pavgroup->baselist, alias_list) {
892 			spin_lock(get_ccwdev_lock(device->cdev));
893 			dasd_device_remove_stop_bits(device, DASD_STOPPED_SU);
894 			spin_unlock(get_ccwdev_lock(device->cdev));
895 		}
896 		list_for_each_entry(device, &pavgroup->aliaslist, alias_list) {
897 			spin_lock(get_ccwdev_lock(device->cdev));
898 			dasd_device_remove_stop_bits(device, DASD_STOPPED_SU);
899 			spin_unlock(get_ccwdev_lock(device->cdev));
900 		}
901 	}
902 }
903 
summary_unit_check_handling_work(struct work_struct * work)904 static void summary_unit_check_handling_work(struct work_struct *work)
905 {
906 	struct alias_lcu *lcu;
907 	struct summary_unit_check_work_data *suc_data;
908 	unsigned long flags;
909 	struct dasd_device *device;
910 
911 	suc_data = container_of(work, struct summary_unit_check_work_data,
912 				worker);
913 	lcu = container_of(suc_data, struct alias_lcu, suc_data);
914 	device = suc_data->device;
915 
916 	/* 1. flush alias devices */
917 	flush_all_alias_devices_on_lcu(lcu);
918 
919 	/* 2. reset summary unit check */
920 	spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
921 	dasd_device_remove_stop_bits(device,
922 				     (DASD_STOPPED_SU | DASD_STOPPED_PENDING));
923 	spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
924 	reset_summary_unit_check(lcu, device, suc_data->reason);
925 
926 	spin_lock_irqsave(&lcu->lock, flags);
927 	_unstop_all_devices_on_lcu(lcu);
928 	_restart_all_base_devices_on_lcu(lcu);
929 	/* 3. read new alias configuration */
930 	_schedule_lcu_update(lcu, device);
931 	lcu->suc_data.device = NULL;
932 	dasd_put_device(device);
933 	spin_unlock_irqrestore(&lcu->lock, flags);
934 }
935 
dasd_alias_handle_summary_unit_check(struct work_struct * work)936 void dasd_alias_handle_summary_unit_check(struct work_struct *work)
937 {
938 	struct dasd_device *device = container_of(work, struct dasd_device,
939 						  suc_work);
940 	struct dasd_eckd_private *private = device->private;
941 	struct alias_lcu *lcu;
942 	unsigned long flags;
943 
944 	lcu = private->lcu;
945 	if (!lcu) {
946 		DBF_DEV_EVENT(DBF_WARNING, device, "%s",
947 			    "device not ready to handle summary"
948 			    " unit check (no lcu structure)");
949 		goto out;
950 	}
951 	spin_lock_irqsave(&lcu->lock, flags);
952 	/* If this device is about to be removed just return and wait for
953 	 * the next interrupt on a different device
954 	 */
955 	if (list_empty(&device->alias_list)) {
956 		DBF_DEV_EVENT(DBF_WARNING, device, "%s",
957 			    "device is in offline processing,"
958 			    " don't do summary unit check handling");
959 		goto out_unlock;
960 	}
961 	if (lcu->suc_data.device) {
962 		/* already scheduled or running */
963 		DBF_DEV_EVENT(DBF_WARNING, device, "%s",
964 			    "previous instance of summary unit check worker"
965 			    " still pending");
966 		goto out_unlock;
967 	}
968 	_stop_all_devices_on_lcu(lcu);
969 	/* prepare for lcu_update */
970 	lcu->flags |= NEED_UAC_UPDATE | UPDATE_PENDING;
971 	lcu->suc_data.reason = private->suc_reason;
972 	lcu->suc_data.device = device;
973 	dasd_get_device(device);
974 	if (!schedule_work(&lcu->suc_data.worker))
975 		dasd_put_device(device);
976 out_unlock:
977 	spin_unlock_irqrestore(&lcu->lock, flags);
978 out:
979 	clear_bit(DASD_FLAG_SUC, &device->flags);
980 	dasd_put_device(device);
981 };
982