Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/s390/linux
* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/s390/linux:
[S390] dasd: revalidate server for new pathgroup
[S390] dasd: revert LCU optimization
[S390] cleanup entry point definition
+48
-92
-1
arch/s390/Makefile
-1
arch/s390/Makefile
+2
-2
arch/s390/kernel/vmlinux.lds.S
+2
-2
arch/s390/kernel/vmlinux.lds.S
···
9
9
#ifndef CONFIG_64BIT
10
10
OUTPUT_FORMAT("elf32-s390", "elf32-s390", "elf32-s390")
11
11
OUTPUT_ARCH(s390)
12
-
ENTRY(_start)
12
+
ENTRY(startup)
13
13
jiffies = jiffies_64 + 4;
14
14
#else
15
15
OUTPUT_FORMAT("elf64-s390", "elf64-s390", "elf64-s390")
16
16
OUTPUT_ARCH(s390:64-bit)
17
-
ENTRY(_start)
17
+
ENTRY(startup)
18
18
jiffies = jiffies_64;
19
19
#endif
20
20
+6
drivers/s390/block/dasd.c
+6
drivers/s390/block/dasd.c
···
3261
3261
device->path_data.tbvpm |= eventlpm;
3262
3262
dasd_schedule_device_bh(device);
3263
3263
}
3264
+
if (path_event[chp] & PE_PATHGROUP_ESTABLISHED) {
3265
+
DBF_DEV_EVENT(DBF_WARNING, device, "%s",
3266
+
"Pathgroup re-established\n");
3267
+
if (device->discipline->kick_validate)
3268
+
device->discipline->kick_validate(device);
3269
+
}
3264
3270
}
3265
3271
dasd_put_device(device);
3266
3272
}
+1
-63
drivers/s390/block/dasd_alias.c
+1
-63
drivers/s390/block/dasd_alias.c
···
189
189
unsigned long flags;
190
190
struct alias_server *server, *newserver;
191
191
struct alias_lcu *lcu, *newlcu;
192
-
int is_lcu_known;
193
192
struct dasd_uid uid;
194
193
195
194
private = (struct dasd_eckd_private *) device->private;
196
195
197
196
device->discipline->get_uid(device, &uid);
198
197
spin_lock_irqsave(&aliastree.lock, flags);
199
-
is_lcu_known = 1;
200
198
server = _find_server(&uid);
201
199
if (!server) {
202
200
spin_unlock_irqrestore(&aliastree.lock, flags);
···
206
208
if (!server) {
207
209
list_add(&newserver->server, &aliastree.serverlist);
208
210
server = newserver;
209
-
is_lcu_known = 0;
210
211
} else {
211
212
/* someone was faster */
212
213
_free_server(newserver);
···
223
226
if (!lcu) {
224
227
list_add(&newlcu->lcu, &server->lculist);
225
228
lcu = newlcu;
226
-
is_lcu_known = 0;
227
229
} else {
228
230
/* someone was faster */
229
231
_free_lcu(newlcu);
230
232
}
231
-
is_lcu_known = 0;
232
233
}
233
234
spin_lock(&lcu->lock);
234
235
list_add(&device->alias_list, &lcu->inactive_devices);
···
234
239
spin_unlock(&lcu->lock);
235
240
spin_unlock_irqrestore(&aliastree.lock, flags);
236
241
237
-
return is_lcu_known;
238
-
}
239
-
240
-
/*
241
-
* The first device to be registered on an LCU will have to do
242
-
* some additional setup steps to configure that LCU on the
243
-
* storage server. All further devices should wait with their
244
-
* initialization until the first device is done.
245
-
* To synchronize this work, the first device will call
246
-
* dasd_alias_lcu_setup_complete when it is done, and all
247
-
* other devices will wait for it with dasd_alias_wait_for_lcu_setup.
248
-
*/
249
-
void dasd_alias_lcu_setup_complete(struct dasd_device *device)
250
-
{
251
-
unsigned long flags;
252
-
struct alias_server *server;
253
-
struct alias_lcu *lcu;
254
-
struct dasd_uid uid;
255
-
256
-
device->discipline->get_uid(device, &uid);
257
-
lcu = NULL;
258
-
spin_lock_irqsave(&aliastree.lock, flags);
259
-
server = _find_server(&uid);
260
-
if (server)
261
-
lcu = _find_lcu(server, &uid);
262
-
spin_unlock_irqrestore(&aliastree.lock, flags);
263
-
if (!lcu) {
264
-
DBF_EVENT_DEVID(DBF_ERR, device->cdev,
265
-
"could not find lcu for %04x %02x",
266
-
uid.ssid, uid.real_unit_addr);
267
-
WARN_ON(1);
268
-
return;
269
-
}
270
-
complete_all(&lcu->lcu_setup);
271
-
}
272
-
273
-
void dasd_alias_wait_for_lcu_setup(struct dasd_device *device)
274
-
{
275
-
unsigned long flags;
276
-
struct alias_server *server;
277
-
struct alias_lcu *lcu;
278
-
struct dasd_uid uid;
279
-
280
-
device->discipline->get_uid(device, &uid);
281
-
lcu = NULL;
282
-
spin_lock_irqsave(&aliastree.lock, flags);
283
-
server = _find_server(&uid);
284
-
if (server)
285
-
lcu = _find_lcu(server, &uid);
286
-
spin_unlock_irqrestore(&aliastree.lock, flags);
287
-
if (!lcu) {
288
-
DBF_EVENT_DEVID(DBF_ERR, device->cdev,
289
-
"could not find lcu for %04x %02x",
290
-
uid.ssid, uid.real_unit_addr);
291
-
WARN_ON(1);
292
-
return;
293
-
}
294
-
wait_for_completion(&lcu->lcu_setup);
242
+
return 0;
295
243
}
296
244
297
245
/*
+37
-26
drivers/s390/block/dasd_eckd.c
+37
-26
drivers/s390/block/dasd_eckd.c
···
1534
1534
struct dasd_eckd_private *private;
1535
1535
int enable_pav;
1536
1536
1537
+
private = (struct dasd_eckd_private *) device->private;
1538
+
if (private->uid.type == UA_BASE_PAV_ALIAS ||
1539
+
private->uid.type == UA_HYPER_PAV_ALIAS)
1540
+
return;
1537
1541
if (dasd_nopav || MACHINE_IS_VM)
1538
1542
enable_pav = 0;
1539
1543
else
···
1546
1542
1547
1543
/* may be requested feature is not available on server,
1548
1544
* therefore just report error and go ahead */
1549
-
private = (struct dasd_eckd_private *) device->private;
1550
1545
DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "PSF-SSC for SSID %04x "
1551
1546
"returned rc=%d", private->uid.ssid, rc);
1547
+
}
1548
+
1549
+
/*
1550
+
* worker to do a validate server in case of a lost pathgroup
1551
+
*/
1552
+
static void dasd_eckd_do_validate_server(struct work_struct *work)
1553
+
{
1554
+
struct dasd_device *device = container_of(work, struct dasd_device,
1555
+
kick_validate);
1556
+
dasd_eckd_validate_server(device);
1557
+
dasd_put_device(device);
1558
+
}
1559
+
1560
+
static void dasd_eckd_kick_validate_server(struct dasd_device *device)
1561
+
{
1562
+
dasd_get_device(device);
1563
+
/* queue call to do_validate_server to the kernel event daemon. */
1564
+
schedule_work(&device->kick_validate);
1552
1565
}
1553
1566
1554
1567
static u32 get_fcx_max_data(struct dasd_device *device)
···
1609
1588
struct dasd_eckd_private *private;
1610
1589
struct dasd_block *block;
1611
1590
struct dasd_uid temp_uid;
1612
-
int is_known, rc, i;
1591
+
int rc, i;
1613
1592
int readonly;
1614
1593
unsigned long value;
1594
+
1595
+
/* setup work queue for validate server*/
1596
+
INIT_WORK(&device->kick_validate, dasd_eckd_do_validate_server);
1615
1597
1616
1598
if (!ccw_device_is_pathgroup(device->cdev)) {
1617
1599
dev_warn(&device->cdev->dev,
···
1675
1651
block->base = device;
1676
1652
}
1677
1653
1678
-
/* register lcu with alias handling, enable PAV if this is a new lcu */
1679
-
is_known = dasd_alias_make_device_known_to_lcu(device);
1680
-
if (is_known < 0) {
1681
-
rc = is_known;
1654
+
/* register lcu with alias handling, enable PAV */
1655
+
rc = dasd_alias_make_device_known_to_lcu(device);
1656
+
if (rc)
1682
1657
goto out_err2;
1683
-
}
1684
-
/*
1685
-
* dasd_eckd_validate_server is done on the first device that
1686
-
* is found for an LCU. All later other devices have to wait
1687
-
* for it, so they will read the correct feature codes.
1688
-
*/
1689
-
if (!is_known) {
1690
-
dasd_eckd_validate_server(device);
1691
-
dasd_alias_lcu_setup_complete(device);
1692
-
} else
1693
-
dasd_alias_wait_for_lcu_setup(device);
1658
+
1659
+
dasd_eckd_validate_server(device);
1694
1660
1695
1661
/* device may report different configuration data after LCU setup */
1696
1662
rc = dasd_eckd_read_conf(device);
···
4112
4098
{
4113
4099
struct dasd_eckd_private *private;
4114
4100
struct dasd_eckd_characteristics temp_rdc_data;
4115
-
int is_known, rc;
4101
+
int rc;
4116
4102
struct dasd_uid temp_uid;
4117
4103
unsigned long flags;
4118
4104
···
4135
4121
goto out_err;
4136
4122
4137
4123
/* register lcu with alias handling, enable PAV if this is a new lcu */
4138
-
is_known = dasd_alias_make_device_known_to_lcu(device);
4139
-
if (is_known < 0)
4140
-
return is_known;
4141
-
if (!is_known) {
4142
-
dasd_eckd_validate_server(device);
4143
-
dasd_alias_lcu_setup_complete(device);
4144
-
} else
4145
-
dasd_alias_wait_for_lcu_setup(device);
4124
+
rc = dasd_alias_make_device_known_to_lcu(device);
4125
+
if (rc)
4126
+
return rc;
4127
+
dasd_eckd_validate_server(device);
4146
4128
4147
4129
/* RE-Read Configuration Data */
4148
4130
rc = dasd_eckd_read_conf(device);
···
4280
4270
.restore = dasd_eckd_restore_device,
4281
4271
.reload = dasd_eckd_reload_device,
4282
4272
.get_uid = dasd_eckd_get_uid,
4273
+
.kick_validate = dasd_eckd_kick_validate_server,
4283
4274
};
4284
4275
4285
4276
static int __init
+2
drivers/s390/block/dasd_int.h
+2
drivers/s390/block/dasd_int.h
···
355
355
int (*reload) (struct dasd_device *);
356
356
357
357
int (*get_uid) (struct dasd_device *, struct dasd_uid *);
358
+
void (*kick_validate) (struct dasd_device *);
358
359
};
359
360
360
361
extern struct dasd_discipline *dasd_diag_discipline_pointer;
···
456
455
struct work_struct kick_work;
457
456
struct work_struct restore_device;
458
457
struct work_struct reload_device;
458
+
struct work_struct kick_validate;
459
459
struct timer_list timer;
460
460
461
461
debug_info_t *debug_area;