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