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