Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge branch 'pm-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/suspend-2.6
* 'pm-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/suspend-2.6:
PM: Remove some debug messages producing too much noise
PM: Fix warning on suspend errors
PM / Hibernate: Add newline to load_image() fail path
PM / Hibernate: Fix error handling in save_image()
PM / Hibernate: Fix blkdev refleaks
PM / yenta: Split resume into early and late parts (rev. 4)
+90
-56
+1
drivers/base/power/main.c
+1
drivers/base/power/main.c
-4
drivers/base/power/runtime.c
-4
drivers/base/power/runtime.c
···
51
51
{
52
52
int retval = 0;
53
53
54
-
dev_dbg(dev, "__pm_runtime_idle()!\n");
55
-
56
54
if (dev->power.runtime_error)
57
55
retval = -EINVAL;
58
56
else if (dev->power.idle_notification)
···
91
93
wake_up_all(&dev->power.wait_queue);
92
94
93
95
out:
94
-
dev_dbg(dev, "__pm_runtime_idle() returns %d!\n", retval);
95
-
96
96
return retval;
97
97
}
98
98
+44
-27
drivers/pcmcia/cs.c
+44
-27
drivers/pcmcia/cs.c
···
98
98
* These functions check for the appropriate struct pcmcia_soket arrays,
99
99
* and pass them to the low-level functions pcmcia_{suspend,resume}_socket
100
100
*/
101
+
static int socket_early_resume(struct pcmcia_socket *skt);
102
+
static int socket_late_resume(struct pcmcia_socket *skt);
101
103
static int socket_resume(struct pcmcia_socket *skt);
102
104
static int socket_suspend(struct pcmcia_socket *skt);
103
105
104
-
int pcmcia_socket_dev_suspend(struct device *dev)
106
+
static void pcmcia_socket_dev_run(struct device *dev,
107
+
int (*cb)(struct pcmcia_socket *))
105
108
{
106
109
struct pcmcia_socket *socket;
107
110
···
113
110
if (socket->dev.parent != dev)
114
111
continue;
115
112
mutex_lock(&socket->skt_mutex);
116
-
socket_suspend(socket);
113
+
cb(socket);
117
114
mutex_unlock(&socket->skt_mutex);
118
115
}
119
116
up_read(&pcmcia_socket_list_rwsem);
117
+
}
120
118
119
+
int pcmcia_socket_dev_suspend(struct device *dev)
120
+
{
121
+
pcmcia_socket_dev_run(dev, socket_suspend);
121
122
return 0;
122
123
}
123
124
EXPORT_SYMBOL(pcmcia_socket_dev_suspend);
124
125
126
+
void pcmcia_socket_dev_early_resume(struct device *dev)
127
+
{
128
+
pcmcia_socket_dev_run(dev, socket_early_resume);
129
+
}
130
+
EXPORT_SYMBOL(pcmcia_socket_dev_early_resume);
131
+
132
+
void pcmcia_socket_dev_late_resume(struct device *dev)
133
+
{
134
+
pcmcia_socket_dev_run(dev, socket_late_resume);
135
+
}
136
+
EXPORT_SYMBOL(pcmcia_socket_dev_late_resume);
137
+
125
138
int pcmcia_socket_dev_resume(struct device *dev)
126
139
{
127
-
struct pcmcia_socket *socket;
128
-
129
-
down_read(&pcmcia_socket_list_rwsem);
130
-
list_for_each_entry(socket, &pcmcia_socket_list, socket_list) {
131
-
if (socket->dev.parent != dev)
132
-
continue;
133
-
mutex_lock(&socket->skt_mutex);
134
-
socket_resume(socket);
135
-
mutex_unlock(&socket->skt_mutex);
136
-
}
137
-
up_read(&pcmcia_socket_list_rwsem);
138
-
140
+
pcmcia_socket_dev_run(dev, socket_resume);
139
141
return 0;
140
142
}
141
143
EXPORT_SYMBOL(pcmcia_socket_dev_resume);
···
554
546
return 0;
555
547
}
556
548
557
-
/*
558
-
* Resume a socket. If a card is present, verify its CIS against
559
-
* our cached copy. If they are different, the card has been
560
-
* replaced, and we need to tell the drivers.
561
-
*/
562
-
static int socket_resume(struct pcmcia_socket *skt)
549
+
static int socket_early_resume(struct pcmcia_socket *skt)
563
550
{
564
-
int ret;
565
-
566
-
if (!(skt->state & SOCKET_SUSPEND))
567
-
return -EBUSY;
568
-
569
551
skt->socket = dead_socket;
570
552
skt->ops->init(skt);
571
553
skt->ops->set_socket(skt, &skt->socket);
554
+
if (skt->state & SOCKET_PRESENT)
555
+
skt->resume_status = socket_setup(skt, resume_delay);
556
+
return 0;
557
+
}
572
558
559
+
static int socket_late_resume(struct pcmcia_socket *skt)
560
+
{
573
561
if (!(skt->state & SOCKET_PRESENT)) {
574
562
skt->state &= ~SOCKET_SUSPEND;
575
563
return socket_insert(skt);
576
564
}
577
565
578
-
ret = socket_setup(skt, resume_delay);
579
-
if (ret == 0) {
566
+
if (skt->resume_status == 0) {
580
567
/*
581
568
* FIXME: need a better check here for cardbus cards.
582
569
*/
···
597
594
skt->state &= ~SOCKET_SUSPEND;
598
595
599
596
return 0;
597
+
}
598
+
599
+
/*
600
+
* Resume a socket. If a card is present, verify its CIS against
601
+
* our cached copy. If they are different, the card has been
602
+
* replaced, and we need to tell the drivers.
603
+
*/
604
+
static int socket_resume(struct pcmcia_socket *skt)
605
+
{
606
+
if (!(skt->state & SOCKET_SUSPEND))
607
+
return -EBUSY;
608
+
609
+
socket_early_resume(skt);
610
+
return socket_late_resume(skt);
600
611
}
601
612
602
613
static void socket_remove(struct pcmcia_socket *skt)
+11
-1
drivers/pcmcia/yenta_socket.c
+11
-1
drivers/pcmcia/yenta_socket.c
···
1275
1275
if (socket->type && socket->type->restore_state)
1276
1276
socket->type->restore_state(socket);
1277
1277
1278
-
return pcmcia_socket_dev_resume(dev);
1278
+
pcmcia_socket_dev_early_resume(dev);
1279
+
return 0;
1280
+
}
1281
+
1282
+
static int yenta_dev_resume(struct device *dev)
1283
+
{
1284
+
pcmcia_socket_dev_late_resume(dev);
1285
+
return 0;
1279
1286
}
1280
1287
1281
1288
static struct dev_pm_ops yenta_pm_ops = {
1282
1289
.suspend_noirq = yenta_dev_suspend_noirq,
1283
1290
.resume_noirq = yenta_dev_resume_noirq,
1291
+
.resume = yenta_dev_resume,
1284
1292
.freeze_noirq = yenta_dev_suspend_noirq,
1285
1293
.thaw_noirq = yenta_dev_resume_noirq,
1294
+
.thaw = yenta_dev_resume,
1286
1295
.poweroff_noirq = yenta_dev_suspend_noirq,
1287
1296
.restore_noirq = yenta_dev_resume_noirq,
1297
+
.restore = yenta_dev_resume,
1288
1298
};
1289
1299
1290
1300
#define YENTA_PM_OPS (¥ta_pm_ops)
+4
include/pcmcia/ss.h
+4
include/pcmcia/ss.h
···
262
262
struct device dev;
263
263
/* data internal to the socket driver */
264
264
void *driver_data;
265
+
/* status of the card during resume from a system sleep state */
266
+
int resume_status;
265
267
};
266
268
267
269
···
282
280
283
281
/* socket drivers are expected to use these callbacks in their .drv struct */
284
282
extern int pcmcia_socket_dev_suspend(struct device *dev);
283
+
extern void pcmcia_socket_dev_early_resume(struct device *dev);
284
+
extern void pcmcia_socket_dev_late_resume(struct device *dev);
285
285
extern int pcmcia_socket_dev_resume(struct device *dev);
286
286
287
287
/* socket drivers use this callback in their IRQ handler */
+8
-3
kernel/power/hibernate.c
+8
-3
kernel/power/hibernate.c
···
693
693
/* The snapshot device should not be opened while we're running */
694
694
if (!atomic_add_unless(&snapshot_device_available, -1, 0)) {
695
695
error = -EBUSY;
696
+
swsusp_close(FMODE_READ);
696
697
goto Unlock;
697
698
}
698
699
699
700
pm_prepare_console();
700
701
error = pm_notifier_call_chain(PM_RESTORE_PREPARE);
701
702
if (error)
702
-
goto Finish;
703
+
goto close_finish;
703
704
704
705
error = usermodehelper_disable();
705
706
if (error)
706
-
goto Finish;
707
+
goto close_finish;
707
708
708
709
error = create_basic_memory_bitmaps();
709
710
if (error)
710
-
goto Finish;
711
+
goto close_finish;
711
712
712
713
pr_debug("PM: Preparing processes for restore.\n");
713
714
error = prepare_processes();
···
720
719
pr_debug("PM: Reading hibernation image.\n");
721
720
722
721
error = swsusp_read(&flags);
722
+
swsusp_close(FMODE_READ);
723
723
if (!error)
724
724
hibernation_restore(flags & SF_PLATFORM_MODE);
725
725
···
739
737
mutex_unlock(&pm_mutex);
740
738
pr_debug("PM: Resume from disk failed.\n");
741
739
return error;
740
+
close_finish:
741
+
swsusp_close(FMODE_READ);
742
+
goto Finish;
742
743
}
743
744
744
745
late_initcall(software_resume);
+22
-21
kernel/power/swap.c
+22
-21
kernel/power/swap.c
···
314
314
{
315
315
unsigned int m;
316
316
int ret;
317
-
int error = 0;
318
317
int nr_pages;
319
318
int err2;
320
319
struct bio *bio;
···
328
329
nr_pages = 0;
329
330
bio = NULL;
330
331
do_gettimeofday(&start);
331
-
do {
332
+
while (1) {
332
333
ret = snapshot_read_next(snapshot, PAGE_SIZE);
333
-
if (ret > 0) {
334
-
error = swap_write_page(handle, data_of(*snapshot),
335
-
&bio);
336
-
if (error)
337
-
break;
338
-
if (!(nr_pages % m))
339
-
printk("\b\b\b\b%3d%%", nr_pages / m);
340
-
nr_pages++;
341
-
}
342
-
} while (ret > 0);
334
+
if (ret <= 0)
335
+
break;
336
+
ret = swap_write_page(handle, data_of(*snapshot), &bio);
337
+
if (ret)
338
+
break;
339
+
if (!(nr_pages % m))
340
+
printk("\b\b\b\b%3d%%", nr_pages / m);
341
+
nr_pages++;
342
+
}
343
343
err2 = wait_on_bio_chain(&bio);
344
344
do_gettimeofday(&stop);
345
-
if (!error)
346
-
error = err2;
347
-
if (!error)
345
+
if (!ret)
346
+
ret = err2;
347
+
if (!ret)
348
348
printk("\b\b\b\bdone\n");
349
+
else
350
+
printk("\n");
349
351
swsusp_show_speed(&start, &stop, nr_to_write, "Wrote");
350
-
return error;
352
+
return ret;
351
353
}
352
354
353
355
/**
···
536
536
snapshot_write_finalize(snapshot);
537
537
if (!snapshot_image_loaded(snapshot))
538
538
error = -ENODATA;
539
-
}
539
+
} else
540
+
printk("\n");
540
541
swsusp_show_speed(&start, &stop, nr_to_read, "Read");
541
542
return error;
542
543
}
···
573
572
error = load_image(&handle, &snapshot, header->pages - 1);
574
573
release_swap_reader(&handle);
575
574
576
-
blkdev_put(resume_bdev, FMODE_READ);
577
-
578
575
if (!error)
579
576
pr_debug("PM: Image successfully loaded\n");
580
577
else
···
595
596
error = bio_read_page(swsusp_resume_block,
596
597
swsusp_header, NULL);
597
598
if (error)
598
-
return error;
599
+
goto put;
599
600
600
601
if (!memcmp(SWSUSP_SIG, swsusp_header->sig, 10)) {
601
602
memcpy(swsusp_header->sig, swsusp_header->orig_sig, 10);
···
603
604
error = bio_write_page(swsusp_resume_block,
604
605
swsusp_header, NULL);
605
606
} else {
606
-
return -EINVAL;
607
+
error = -EINVAL;
607
608
}
609
+
610
+
put:
608
611
if (error)
609
612
blkdev_put(resume_bdev, FMODE_READ);
610
613
else