blob: 157defe5e0693c06c6432ddfbd65d0f6632a6f90 [file] [log] [blame]
Stefan Weinhuber8e09f212008-01-26 14:11:23 +01001/*
2 * PAV alias management for the DASD ECKD discipline
3 *
Heiko Carstensa53c8fa2012-07-20 11:15:04 +02004 * Copyright IBM Corp. 2007
Stefan Weinhuber8e09f212008-01-26 14:11:23 +01005 * Author(s): Stefan Weinhuber <wein@de.ibm.com>
6 */
7
Stefan Haberlandca99dab2009-09-11 10:28:30 +02008#define KMSG_COMPONENT "dasd-eckd"
Stefan Haberlandfc19f382009-03-26 15:23:49 +01009
Stefan Weinhuber8e09f212008-01-26 14:11:23 +010010#include <linux/list.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090011#include <linux/slab.h>
Stefan Weinhuber8e09f212008-01-26 14:11:23 +010012#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
43static void summary_unit_check_handling_work(struct work_struct *);
44static void lcu_update_work(struct work_struct *);
45static int _schedule_lcu_update(struct alias_lcu *, struct dasd_device *);
46
47static struct alias_root aliastree = {
48 .serverlist = LIST_HEAD_INIT(aliastree.serverlist),
49 .lock = __SPIN_LOCK_UNLOCKED(aliastree.lock),
50};
51
52static 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
65static 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
76static 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) {
Stefan Weinhuber4abb08c2008-08-01 16:39:09 +020097 if (pos->uid.base_unit_addr == search_unit_addr &&
98 !strncmp(pos->uid.vduit, uid->vduit, sizeof(uid->vduit)))
Stefan Weinhuber8e09f212008-01-26 14:11:23 +010099 return pos;
100 };
101 return NULL;
102}
103
104static 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
118static void _free_server(struct alias_server *server)
119{
120 kfree(server);
121}
122
123static 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);
Stefan Weinhuberf4ac1d02009-12-07 12:51:53 +0100156 init_completion(&lcu->lcu_setup);
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100157 return lcu;
158
159out_err4:
160 kfree(lcu->rsu_cqr->cpaddr);
161out_err3:
162 kfree(lcu->rsu_cqr);
163out_err2:
164 kfree(lcu->uac);
165out_err1:
166 kfree(lcu);
167 return ERR_PTR(-ENOMEM);
168}
169
170static 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 */
186int 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;
Stefan Haberland2dedf0d2010-05-17 10:00:11 +0200192 struct dasd_uid uid;
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100193
194 private = (struct dasd_eckd_private *) device->private;
Stefan Haberland2dedf0d2010-05-17 10:00:11 +0200195
196 device->discipline->get_uid(device, &uid);
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100197 spin_lock_irqsave(&aliastree.lock, flags);
Stefan Haberland2dedf0d2010-05-17 10:00:11 +0200198 server = _find_server(&uid);
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100199 if (!server) {
200 spin_unlock_irqrestore(&aliastree.lock, flags);
Stefan Haberland2dedf0d2010-05-17 10:00:11 +0200201 newserver = _allocate_server(&uid);
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100202 if (IS_ERR(newserver))
203 return PTR_ERR(newserver);
204 spin_lock_irqsave(&aliastree.lock, flags);
Stefan Haberland2dedf0d2010-05-17 10:00:11 +0200205 server = _find_server(&uid);
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100206 if (!server) {
207 list_add(&newserver->server, &aliastree.serverlist);
208 server = newserver;
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100209 } else {
210 /* someone was faster */
211 _free_server(newserver);
212 }
213 }
214
Stefan Haberland2dedf0d2010-05-17 10:00:11 +0200215 lcu = _find_lcu(server, &uid);
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100216 if (!lcu) {
217 spin_unlock_irqrestore(&aliastree.lock, flags);
Stefan Haberland2dedf0d2010-05-17 10:00:11 +0200218 newlcu = _allocate_lcu(&uid);
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100219 if (IS_ERR(newlcu))
Roel Kluin6d53cfe2009-12-18 17:43:17 +0100220 return PTR_ERR(newlcu);
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100221 spin_lock_irqsave(&aliastree.lock, flags);
Stefan Haberland2dedf0d2010-05-17 10:00:11 +0200222 lcu = _find_lcu(server, &uid);
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100223 if (!lcu) {
224 list_add(&newlcu->lcu, &server->lculist);
225 lcu = newlcu;
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100226 } else {
227 /* someone was faster */
228 _free_lcu(newlcu);
229 }
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100230 }
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
Stefan Haberlandf9f8d022012-01-18 18:03:40 +0100237 return 0;
Stefan Weinhuberf4ac1d02009-12-07 12:51:53 +0100238}
239
240/*
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100241 * 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 */
245void 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;
Stefan Haberland2dedf0d2010-05-17 10:00:11 +0200252 struct dasd_uid uid;
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100253
254 private = (struct dasd_eckd_private *) device->private;
255 lcu = private->lcu;
Stefan Haberlandf602f6d62011-01-31 11:30:03 +0100256 /* nothing to do if already disconnected */
257 if (!lcu)
258 return;
Stefan Haberland2dedf0d2010-05-17 10:00:11 +0200259 device->discipline->get_uid(device, &uid);
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100260 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 }
Stefan Haberland2dedf0d2010-05-17 10:00:11 +0200296 server = _find_server(&uid);
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100297 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 */
Stefan Haberland2dedf0d2010-05-17 10:00:11 +0200309
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100310static int _add_device_to_lcu(struct alias_lcu *lcu,
Stefan Haberland2dedf0d2010-05-17 10:00:11 +0200311 struct dasd_device *device,
312 struct dasd_device *pos)
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100313{
314
315 struct dasd_eckd_private *private;
316 struct alias_pav_group *group;
Stefan Haberland2dedf0d2010-05-17 10:00:11 +0200317 struct dasd_uid uid;
318 unsigned long flags;
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100319
320 private = (struct dasd_eckd_private *) device->private;
Stefan Haberland2dedf0d2010-05-17 10:00:11 +0200321
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);
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100333
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
Stefan Haberland2dedf0d2010-05-17 10:00:11 +0200340 group = _find_group(lcu, &uid);
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100341 if (!group) {
342 group = kzalloc(sizeof(*group), GFP_ATOMIC);
343 if (!group)
344 return -ENOMEM;
Stefan Haberland2dedf0d2010-05-17 10:00:11 +0200345 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;
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100350 else
Stefan Haberland2dedf0d2010-05-17 10:00:11 +0200351 group->uid.base_unit_addr = uid.base_unit_addr;
352 memcpy(group->uid.vduit, uid.vduit, sizeof(uid.vduit));
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100353 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 }
Stefan Haberland2dedf0d2010-05-17 10:00:11 +0200358 if (uid.type == UA_BASE_DEVICE)
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100359 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
366static 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
387static int read_unit_address_configuration(struct dasd_device *device,
388 struct alias_lcu *lcu)
389{
390 struct dasd_psf_prssd_data *prssdp;
391 struct dasd_ccw_req *cqr;
392 struct ccw1 *ccw;
393 int rc;
394 unsigned long flags;
395
Stefan Haberland68b781f2009-09-11 10:28:29 +0200396 cqr = dasd_kmalloc_request(DASD_ECKD_MAGIC, 1 /* PSF */ + 1 /* RSSD */,
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100397 (sizeof(struct dasd_psf_prssd_data)),
398 device);
399 if (IS_ERR(cqr))
400 return PTR_ERR(cqr);
401 cqr->startdev = device;
402 cqr->memdev = device;
403 clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
404 cqr->retries = 10;
405 cqr->expires = 20 * HZ;
406
407 /* Prepare for Read Subsystem Data */
408 prssdp = (struct dasd_psf_prssd_data *) cqr->data;
409 memset(prssdp, 0, sizeof(struct dasd_psf_prssd_data));
410 prssdp->order = PSF_ORDER_PRSSD;
411 prssdp->suborder = 0x0e; /* Read unit address configuration */
412 /* all other bytes of prssdp must be zero */
413
414 ccw = cqr->cpaddr;
415 ccw->cmd_code = DASD_ECKD_CCW_PSF;
416 ccw->count = sizeof(struct dasd_psf_prssd_data);
417 ccw->flags |= CCW_FLAG_CC;
418 ccw->cda = (__u32)(addr_t) prssdp;
419
420 /* Read Subsystem Data - feature codes */
421 memset(lcu->uac, 0, sizeof(*(lcu->uac)));
422
423 ccw++;
424 ccw->cmd_code = DASD_ECKD_CCW_RSSD;
425 ccw->count = sizeof(*(lcu->uac));
426 ccw->cda = (__u32)(addr_t) lcu->uac;
427
428 cqr->buildclk = get_clock();
429 cqr->status = DASD_CQR_FILLED;
430
431 /* need to unset flag here to detect race with summary unit check */
432 spin_lock_irqsave(&lcu->lock, flags);
433 lcu->flags &= ~NEED_UAC_UPDATE;
434 spin_unlock_irqrestore(&lcu->lock, flags);
435
436 do {
437 rc = dasd_sleep_on(cqr);
438 } while (rc && (cqr->retries > 0));
439 if (rc) {
440 spin_lock_irqsave(&lcu->lock, flags);
441 lcu->flags |= NEED_UAC_UPDATE;
442 spin_unlock_irqrestore(&lcu->lock, flags);
443 }
444 dasd_kfree_request(cqr, cqr->memdev);
445 return rc;
446}
447
448static int _lcu_update(struct dasd_device *refdev, struct alias_lcu *lcu)
449{
450 unsigned long flags;
451 struct alias_pav_group *pavgroup, *tempgroup;
452 struct dasd_device *device, *tempdev;
453 int i, rc;
454 struct dasd_eckd_private *private;
455
456 spin_lock_irqsave(&lcu->lock, flags);
457 list_for_each_entry_safe(pavgroup, tempgroup, &lcu->grouplist, group) {
458 list_for_each_entry_safe(device, tempdev, &pavgroup->baselist,
459 alias_list) {
460 list_move(&device->alias_list, &lcu->active_devices);
461 private = (struct dasd_eckd_private *) device->private;
462 private->pavgroup = NULL;
463 }
464 list_for_each_entry_safe(device, tempdev, &pavgroup->aliaslist,
465 alias_list) {
466 list_move(&device->alias_list, &lcu->active_devices);
467 private = (struct dasd_eckd_private *) device->private;
468 private->pavgroup = NULL;
469 }
470 list_del(&pavgroup->group);
471 kfree(pavgroup);
472 }
473 spin_unlock_irqrestore(&lcu->lock, flags);
474
475 rc = read_unit_address_configuration(refdev, lcu);
476 if (rc)
477 return rc;
478
Stefan Haberland2dedf0d2010-05-17 10:00:11 +0200479 /* need to take cdev lock before lcu lock */
480 spin_lock_irqsave_nested(get_ccwdev_lock(refdev->cdev), flags,
481 CDEV_NESTED_FIRST);
482 spin_lock(&lcu->lock);
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100483 lcu->pav = NO_PAV;
484 for (i = 0; i < MAX_DEVICES_PER_LCU; ++i) {
485 switch (lcu->uac->unit[i].ua_type) {
486 case UA_BASE_PAV_ALIAS:
487 lcu->pav = BASE_PAV;
488 break;
489 case UA_HYPER_PAV_ALIAS:
490 lcu->pav = HYPER_PAV;
491 break;
492 }
493 if (lcu->pav != NO_PAV)
494 break;
495 }
496
497 list_for_each_entry_safe(device, tempdev, &lcu->active_devices,
498 alias_list) {
Stefan Haberland2dedf0d2010-05-17 10:00:11 +0200499 _add_device_to_lcu(lcu, device, refdev);
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100500 }
Stefan Haberland2dedf0d2010-05-17 10:00:11 +0200501 spin_unlock(&lcu->lock);
502 spin_unlock_irqrestore(get_ccwdev_lock(refdev->cdev), flags);
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100503 return 0;
504}
505
506static void lcu_update_work(struct work_struct *work)
507{
508 struct alias_lcu *lcu;
509 struct read_uac_work_data *ruac_data;
510 struct dasd_device *device;
511 unsigned long flags;
512 int rc;
513
514 ruac_data = container_of(work, struct read_uac_work_data, dwork.work);
515 lcu = container_of(ruac_data, struct alias_lcu, ruac_data);
516 device = ruac_data->device;
517 rc = _lcu_update(device, lcu);
518 /*
519 * Need to check flags again, as there could have been another
520 * prepare_update or a new device a new device while we were still
521 * processing the data
522 */
523 spin_lock_irqsave(&lcu->lock, flags);
524 if (rc || (lcu->flags & NEED_UAC_UPDATE)) {
Stefan Haberlandfc19f382009-03-26 15:23:49 +0100525 DBF_DEV_EVENT(DBF_WARNING, device, "could not update"
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100526 " alias data in lcu (rc = %d), retry later", rc);
527 schedule_delayed_work(&lcu->ruac_data.dwork, 30*HZ);
528 } else {
529 lcu->ruac_data.device = NULL;
530 lcu->flags &= ~UPDATE_PENDING;
531 }
532 spin_unlock_irqrestore(&lcu->lock, flags);
533}
534
535static int _schedule_lcu_update(struct alias_lcu *lcu,
536 struct dasd_device *device)
537{
538 struct dasd_device *usedev = NULL;
539 struct alias_pav_group *group;
540
541 lcu->flags |= NEED_UAC_UPDATE;
542 if (lcu->ruac_data.device) {
543 /* already scheduled or running */
544 return 0;
545 }
546 if (device && !list_empty(&device->alias_list))
547 usedev = device;
548
549 if (!usedev && !list_empty(&lcu->grouplist)) {
550 group = list_first_entry(&lcu->grouplist,
551 struct alias_pav_group, group);
552 if (!list_empty(&group->baselist))
553 usedev = list_first_entry(&group->baselist,
554 struct dasd_device,
555 alias_list);
556 else if (!list_empty(&group->aliaslist))
557 usedev = list_first_entry(&group->aliaslist,
558 struct dasd_device,
559 alias_list);
560 }
561 if (!usedev && !list_empty(&lcu->active_devices)) {
562 usedev = list_first_entry(&lcu->active_devices,
563 struct dasd_device, alias_list);
564 }
565 /*
566 * if we haven't found a proper device yet, give up for now, the next
567 * device that will be set active will trigger an lcu update
568 */
569 if (!usedev)
570 return -EINVAL;
571 lcu->ruac_data.device = usedev;
572 schedule_delayed_work(&lcu->ruac_data.dwork, 0);
573 return 0;
574}
575
576int dasd_alias_add_device(struct dasd_device *device)
577{
578 struct dasd_eckd_private *private;
579 struct alias_lcu *lcu;
580 unsigned long flags;
581 int rc;
582
583 private = (struct dasd_eckd_private *) device->private;
584 lcu = private->lcu;
585 rc = 0;
Stefan Haberland2dedf0d2010-05-17 10:00:11 +0200586
587 /* need to take cdev lock before lcu lock */
588 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
589 spin_lock(&lcu->lock);
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100590 if (!(lcu->flags & UPDATE_PENDING)) {
Stefan Haberland2dedf0d2010-05-17 10:00:11 +0200591 rc = _add_device_to_lcu(lcu, device, device);
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100592 if (rc)
593 lcu->flags |= UPDATE_PENDING;
594 }
595 if (lcu->flags & UPDATE_PENDING) {
596 list_move(&device->alias_list, &lcu->active_devices);
597 _schedule_lcu_update(lcu, device);
598 }
Stefan Haberland2dedf0d2010-05-17 10:00:11 +0200599 spin_unlock(&lcu->lock);
600 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100601 return rc;
602}
603
Stefan Haberland501183f2010-05-17 10:00:10 +0200604int dasd_alias_update_add_device(struct dasd_device *device)
605{
606 struct dasd_eckd_private *private;
607 private = (struct dasd_eckd_private *) device->private;
608 private->lcu->flags |= UPDATE_PENDING;
609 return dasd_alias_add_device(device);
610}
611
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100612int dasd_alias_remove_device(struct dasd_device *device)
613{
614 struct dasd_eckd_private *private;
615 struct alias_lcu *lcu;
616 unsigned long flags;
617
618 private = (struct dasd_eckd_private *) device->private;
619 lcu = private->lcu;
Stefan Haberlandf602f6d62011-01-31 11:30:03 +0100620 /* nothing to do if already removed */
621 if (!lcu)
622 return 0;
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100623 spin_lock_irqsave(&lcu->lock, flags);
624 _remove_device_from_lcu(lcu, device);
625 spin_unlock_irqrestore(&lcu->lock, flags);
626 return 0;
627}
628
629struct dasd_device *dasd_alias_get_start_dev(struct dasd_device *base_device)
630{
631
632 struct dasd_device *alias_device;
633 struct alias_pav_group *group;
634 struct alias_lcu *lcu;
635 struct dasd_eckd_private *private, *alias_priv;
636 unsigned long flags;
637
638 private = (struct dasd_eckd_private *) base_device->private;
639 group = private->pavgroup;
640 lcu = private->lcu;
641 if (!group || !lcu)
642 return NULL;
643 if (lcu->pav == NO_PAV ||
644 lcu->flags & (NEED_UAC_UPDATE | UPDATE_PENDING))
645 return NULL;
Stefan Haberlandb38f27e2011-12-27 11:27:28 +0100646 if (unlikely(!(private->features.feature[8] & 0x01))) {
647 /*
648 * PAV enabled but prefix not, very unlikely
649 * seems to be a lost pathgroup
650 * use base device to do IO
651 */
652 DBF_DEV_EVENT(DBF_ERR, base_device, "%s",
653 "Prefix not enabled with PAV enabled\n");
654 return NULL;
655 }
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100656
657 spin_lock_irqsave(&lcu->lock, flags);
658 alias_device = group->next;
659 if (!alias_device) {
660 if (list_empty(&group->aliaslist)) {
661 spin_unlock_irqrestore(&lcu->lock, flags);
662 return NULL;
663 } else {
664 alias_device = list_first_entry(&group->aliaslist,
665 struct dasd_device,
666 alias_list);
667 }
668 }
669 if (list_is_last(&alias_device->alias_list, &group->aliaslist))
670 group->next = list_first_entry(&group->aliaslist,
671 struct dasd_device, alias_list);
672 else
673 group->next = list_first_entry(&alias_device->alias_list,
674 struct dasd_device, alias_list);
675 spin_unlock_irqrestore(&lcu->lock, flags);
676 alias_priv = (struct dasd_eckd_private *) alias_device->private;
677 if ((alias_priv->count < private->count) && !alias_device->stopped)
678 return alias_device;
679 else
680 return NULL;
681}
682
683/*
684 * Summary unit check handling depends on the way alias devices
685 * are handled so it is done here rather then in dasd_eckd.c
686 */
687static int reset_summary_unit_check(struct alias_lcu *lcu,
688 struct dasd_device *device,
689 char reason)
690{
691 struct dasd_ccw_req *cqr;
692 int rc = 0;
Stefan Weinhuberf3eb5382009-03-26 15:23:48 +0100693 struct ccw1 *ccw;
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100694
695 cqr = lcu->rsu_cqr;
696 strncpy((char *) &cqr->magic, "ECKD", 4);
697 ASCEBC((char *) &cqr->magic, 4);
Stefan Weinhuberf3eb5382009-03-26 15:23:48 +0100698 ccw = cqr->cpaddr;
699 ccw->cmd_code = DASD_ECKD_CCW_RSCK;
700 ccw->flags = 0 ;
701 ccw->count = 16;
702 ccw->cda = (__u32)(addr_t) cqr->data;
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100703 ((char *)cqr->data)[0] = reason;
704
705 clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
706 cqr->retries = 255; /* set retry counter to enable basic ERP */
707 cqr->startdev = device;
708 cqr->memdev = device;
709 cqr->block = NULL;
710 cqr->expires = 5 * HZ;
711 cqr->buildclk = get_clock();
712 cqr->status = DASD_CQR_FILLED;
713
714 rc = dasd_sleep_on_immediatly(cqr);
715 return rc;
716}
717
718static void _restart_all_base_devices_on_lcu(struct alias_lcu *lcu)
719{
720 struct alias_pav_group *pavgroup;
721 struct dasd_device *device;
722 struct dasd_eckd_private *private;
Stefan Haberland2dedf0d2010-05-17 10:00:11 +0200723 unsigned long flags;
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100724
725 /* active and inactive list can contain alias as well as base devices */
726 list_for_each_entry(device, &lcu->active_devices, alias_list) {
727 private = (struct dasd_eckd_private *) device->private;
Stefan Haberland2dedf0d2010-05-17 10:00:11 +0200728 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
729 if (private->uid.type != UA_BASE_DEVICE) {
730 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev),
731 flags);
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100732 continue;
Stefan Haberland2dedf0d2010-05-17 10:00:11 +0200733 }
734 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100735 dasd_schedule_block_bh(device->block);
736 dasd_schedule_device_bh(device);
737 }
738 list_for_each_entry(device, &lcu->inactive_devices, alias_list) {
739 private = (struct dasd_eckd_private *) device->private;
Stefan Haberland2dedf0d2010-05-17 10:00:11 +0200740 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
741 if (private->uid.type != UA_BASE_DEVICE) {
742 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev),
743 flags);
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100744 continue;
Stefan Haberland2dedf0d2010-05-17 10:00:11 +0200745 }
746 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100747 dasd_schedule_block_bh(device->block);
748 dasd_schedule_device_bh(device);
749 }
750 list_for_each_entry(pavgroup, &lcu->grouplist, group) {
751 list_for_each_entry(device, &pavgroup->baselist, alias_list) {
752 dasd_schedule_block_bh(device->block);
753 dasd_schedule_device_bh(device);
754 }
755 }
756}
757
758static void flush_all_alias_devices_on_lcu(struct alias_lcu *lcu)
759{
760 struct alias_pav_group *pavgroup;
761 struct dasd_device *device, *temp;
762 struct dasd_eckd_private *private;
763 int rc;
764 unsigned long flags;
765 LIST_HEAD(active);
766
767 /*
768 * Problem here ist that dasd_flush_device_queue may wait
769 * for termination of a request to complete. We can't keep
770 * the lcu lock during that time, so we must assume that
771 * the lists may have changed.
772 * Idea: first gather all active alias devices in a separate list,
773 * then flush the first element of this list unlocked, and afterwards
774 * check if it is still on the list before moving it to the
775 * active_devices list.
776 */
777
778 spin_lock_irqsave(&lcu->lock, flags);
779 list_for_each_entry_safe(device, temp, &lcu->active_devices,
780 alias_list) {
781 private = (struct dasd_eckd_private *) device->private;
782 if (private->uid.type == UA_BASE_DEVICE)
783 continue;
784 list_move(&device->alias_list, &active);
785 }
786
787 list_for_each_entry(pavgroup, &lcu->grouplist, group) {
788 list_splice_init(&pavgroup->aliaslist, &active);
789 }
790 while (!list_empty(&active)) {
791 device = list_first_entry(&active, struct dasd_device,
792 alias_list);
793 spin_unlock_irqrestore(&lcu->lock, flags);
794 rc = dasd_flush_device_queue(device);
795 spin_lock_irqsave(&lcu->lock, flags);
796 /*
797 * only move device around if it wasn't moved away while we
798 * were waiting for the flush
799 */
800 if (device == list_first_entry(&active,
801 struct dasd_device, alias_list))
802 list_move(&device->alias_list, &lcu->active_devices);
803 }
804 spin_unlock_irqrestore(&lcu->lock, flags);
805}
806
Heiko Carstensa8061702008-04-17 07:46:26 +0200807static void __stop_device_on_lcu(struct dasd_device *device,
808 struct dasd_device *pos)
809{
810 /* If pos == device then device is already locked! */
811 if (pos == device) {
Stefan Weinhubereb6e1992009-12-07 12:51:51 +0100812 dasd_device_set_stop_bits(pos, DASD_STOPPED_SU);
Heiko Carstensa8061702008-04-17 07:46:26 +0200813 return;
814 }
815 spin_lock(get_ccwdev_lock(pos->cdev));
Stefan Weinhubereb6e1992009-12-07 12:51:51 +0100816 dasd_device_set_stop_bits(pos, DASD_STOPPED_SU);
Heiko Carstensa8061702008-04-17 07:46:26 +0200817 spin_unlock(get_ccwdev_lock(pos->cdev));
818}
819
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100820/*
821 * This function is called in interrupt context, so the
822 * cdev lock for device is already locked!
823 */
824static void _stop_all_devices_on_lcu(struct alias_lcu *lcu,
825 struct dasd_device *device)
826{
827 struct alias_pav_group *pavgroup;
828 struct dasd_device *pos;
829
Heiko Carstensa8061702008-04-17 07:46:26 +0200830 list_for_each_entry(pos, &lcu->active_devices, alias_list)
831 __stop_device_on_lcu(device, pos);
832 list_for_each_entry(pos, &lcu->inactive_devices, alias_list)
833 __stop_device_on_lcu(device, pos);
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100834 list_for_each_entry(pavgroup, &lcu->grouplist, group) {
Heiko Carstensa8061702008-04-17 07:46:26 +0200835 list_for_each_entry(pos, &pavgroup->baselist, alias_list)
836 __stop_device_on_lcu(device, pos);
837 list_for_each_entry(pos, &pavgroup->aliaslist, alias_list)
838 __stop_device_on_lcu(device, pos);
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100839 }
840}
841
842static void _unstop_all_devices_on_lcu(struct alias_lcu *lcu)
843{
844 struct alias_pav_group *pavgroup;
845 struct dasd_device *device;
846 unsigned long flags;
847
848 list_for_each_entry(device, &lcu->active_devices, alias_list) {
849 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
Stefan Weinhubereb6e1992009-12-07 12:51:51 +0100850 dasd_device_remove_stop_bits(device, DASD_STOPPED_SU);
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100851 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
852 }
853
854 list_for_each_entry(device, &lcu->inactive_devices, alias_list) {
855 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
Stefan Weinhubereb6e1992009-12-07 12:51:51 +0100856 dasd_device_remove_stop_bits(device, DASD_STOPPED_SU);
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100857 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
858 }
859
860 list_for_each_entry(pavgroup, &lcu->grouplist, group) {
861 list_for_each_entry(device, &pavgroup->baselist, alias_list) {
862 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
Stefan Weinhubereb6e1992009-12-07 12:51:51 +0100863 dasd_device_remove_stop_bits(device, DASD_STOPPED_SU);
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100864 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev),
865 flags);
866 }
867 list_for_each_entry(device, &pavgroup->aliaslist, alias_list) {
868 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
Stefan Weinhubereb6e1992009-12-07 12:51:51 +0100869 dasd_device_remove_stop_bits(device, DASD_STOPPED_SU);
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100870 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev),
871 flags);
872 }
873 }
874}
875
876static void summary_unit_check_handling_work(struct work_struct *work)
877{
878 struct alias_lcu *lcu;
879 struct summary_unit_check_work_data *suc_data;
880 unsigned long flags;
881 struct dasd_device *device;
882
883 suc_data = container_of(work, struct summary_unit_check_work_data,
884 worker);
885 lcu = container_of(suc_data, struct alias_lcu, suc_data);
886 device = suc_data->device;
887
888 /* 1. flush alias devices */
889 flush_all_alias_devices_on_lcu(lcu);
890
891 /* 2. reset summary unit check */
892 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
Stefan Weinhubereb6e1992009-12-07 12:51:51 +0100893 dasd_device_remove_stop_bits(device,
894 (DASD_STOPPED_SU | DASD_STOPPED_PENDING));
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100895 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
896 reset_summary_unit_check(lcu, device, suc_data->reason);
897
898 spin_lock_irqsave(&lcu->lock, flags);
899 _unstop_all_devices_on_lcu(lcu);
900 _restart_all_base_devices_on_lcu(lcu);
901 /* 3. read new alias configuration */
902 _schedule_lcu_update(lcu, device);
903 lcu->suc_data.device = NULL;
904 spin_unlock_irqrestore(&lcu->lock, flags);
905}
906
907/*
908 * note: this will be called from int handler context (cdev locked)
909 */
910void dasd_alias_handle_summary_unit_check(struct dasd_device *device,
911 struct irb *irb)
912{
913 struct alias_lcu *lcu;
914 char reason;
915 struct dasd_eckd_private *private;
Stefan Weinhuberf3eb5382009-03-26 15:23:48 +0100916 char *sense;
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100917
918 private = (struct dasd_eckd_private *) device->private;
919
Stefan Weinhuberf3eb5382009-03-26 15:23:48 +0100920 sense = dasd_get_sense(irb);
921 if (sense) {
922 reason = sense[8];
923 DBF_DEV_EVENT(DBF_NOTICE, device, "%s %x",
924 "eckd handle summary unit check: reason", reason);
925 } else {
926 DBF_DEV_EVENT(DBF_WARNING, device, "%s",
927 "eckd handle summary unit check:"
928 " no reason code available");
929 return;
930 }
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100931
932 lcu = private->lcu;
933 if (!lcu) {
Stefan Haberlandfc19f382009-03-26 15:23:49 +0100934 DBF_DEV_EVENT(DBF_WARNING, device, "%s",
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100935 "device not ready to handle summary"
936 " unit check (no lcu structure)");
937 return;
938 }
939 spin_lock(&lcu->lock);
940 _stop_all_devices_on_lcu(lcu, device);
941 /* prepare for lcu_update */
942 private->lcu->flags |= NEED_UAC_UPDATE | UPDATE_PENDING;
943 /* If this device is about to be removed just return and wait for
944 * the next interrupt on a different device
945 */
946 if (list_empty(&device->alias_list)) {
Stefan Haberlandfc19f382009-03-26 15:23:49 +0100947 DBF_DEV_EVENT(DBF_WARNING, device, "%s",
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100948 "device is in offline processing,"
949 " don't do summary unit check handling");
950 spin_unlock(&lcu->lock);
951 return;
952 }
953 if (lcu->suc_data.device) {
954 /* already scheduled or running */
Stefan Haberlandfc19f382009-03-26 15:23:49 +0100955 DBF_DEV_EVENT(DBF_WARNING, device, "%s",
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100956 "previous instance of summary unit check worker"
957 " still pending");
958 spin_unlock(&lcu->lock);
959 return ;
960 }
961 lcu->suc_data.reason = reason;
962 lcu->suc_data.device = device;
963 spin_unlock(&lcu->lock);
964 schedule_work(&lcu->suc_data.worker);
965};