2 * MTD Oops/Panic logger
4 * Copyright (C) 2007 Nokia Corporation. All rights reserved.
6 * Author: Richard Purdie <rpurdie@openedhand.com>
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * version 2 as published by the Free Software Foundation.
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
24 #include <linux/kernel.h>
25 #include <linux/module.h>
26 #include <linux/console.h>
27 #include <linux/vmalloc.h>
28 #include <linux/workqueue.h>
29 #include <linux/sched.h>
30 #include <linux/wait.h>
31 #include <linux/spinlock.h>
32 #include <linux/mtd/mtd.h>
34 #define OOPS_PAGE_SIZE 4096
36 struct mtdoops_context
{
38 struct work_struct work_erase
;
39 struct work_struct work_write
;
47 /* writecount and disabling ready are spin lock protected */
48 spinlock_t writecount_lock
;
53 static void mtdoops_erase_callback(struct erase_info
*done
)
55 wait_queue_head_t
*wait_q
= (wait_queue_head_t
*)done
->priv
;
59 static int mtdoops_erase_block(struct mtd_info
*mtd
, int offset
)
61 struct erase_info erase
;
62 DECLARE_WAITQUEUE(wait
, current
);
63 wait_queue_head_t wait_q
;
66 init_waitqueue_head(&wait_q
);
68 erase
.callback
= mtdoops_erase_callback
;
70 if (mtd
->erasesize
< OOPS_PAGE_SIZE
)
71 erase
.len
= OOPS_PAGE_SIZE
;
73 erase
.len
= mtd
->erasesize
;
74 erase
.priv
= (u_long
)&wait_q
;
76 set_current_state(TASK_INTERRUPTIBLE
);
77 add_wait_queue(&wait_q
, &wait
);
79 ret
= mtd
->erase(mtd
, &erase
);
81 set_current_state(TASK_RUNNING
);
82 remove_wait_queue(&wait_q
, &wait
);
83 printk (KERN_WARNING
"mtdoops: erase of region [0x%x, 0x%x] "
85 erase
.addr
, erase
.len
, mtd
->name
);
89 schedule(); /* Wait for erase to finish. */
90 remove_wait_queue(&wait_q
, &wait
);
95 static void mtdoops_inc_counter(struct mtdoops_context
*cxt
)
97 struct mtd_info
*mtd
= cxt
->mtd
;
103 if (cxt
->nextpage
> cxt
->oops_pages
)
106 if (cxt
->nextcount
== 0xffffffff)
109 ret
= mtd
->read(mtd
, cxt
->nextpage
* OOPS_PAGE_SIZE
, 4,
110 &retlen
, (u_char
*) &count
);
111 if ((retlen
!= 4) || ((ret
< 0) && (ret
!= -EUCLEAN
))) {
112 printk(KERN_ERR
"mtdoops: Read failure at %d (%td of 4 read)"
113 ", err %d.\n", cxt
->nextpage
* OOPS_PAGE_SIZE
,
115 schedule_work(&cxt
->work_erase
);
119 /* See if we need to erase the next block */
120 if (count
!= 0xffffffff) {
121 schedule_work(&cxt
->work_erase
);
125 printk(KERN_DEBUG
"mtdoops: Ready %d, %d (no erase)\n",
126 cxt
->nextpage
, cxt
->nextcount
);
130 /* Scheduled work - when we can't proceed without erasing a block */
131 static void mtdoops_workfunc_erase(struct work_struct
*work
)
133 struct mtdoops_context
*cxt
=
134 container_of(work
, struct mtdoops_context
, work_erase
);
135 struct mtd_info
*mtd
= cxt
->mtd
;
136 int i
= 0, j
, ret
, mod
;
138 /* We were unregistered */
142 mod
= (cxt
->nextpage
* OOPS_PAGE_SIZE
) % mtd
->erasesize
;
144 cxt
->nextpage
= cxt
->nextpage
+ ((mtd
->erasesize
- mod
) / OOPS_PAGE_SIZE
);
145 if (cxt
->nextpage
> cxt
->oops_pages
)
149 while (mtd
->block_isbad
) {
150 ret
= mtd
->block_isbad(mtd
, cxt
->nextpage
* OOPS_PAGE_SIZE
);
154 printk(KERN_ERR
"mtdoops: block_isbad failed, aborting.\n");
158 printk(KERN_WARNING
"mtdoops: Bad block at %08x\n",
159 cxt
->nextpage
* OOPS_PAGE_SIZE
);
161 cxt
->nextpage
= cxt
->nextpage
+ (mtd
->erasesize
/ OOPS_PAGE_SIZE
);
162 if (cxt
->nextpage
> cxt
->oops_pages
)
164 if (i
== (cxt
->oops_pages
/ (mtd
->erasesize
/ OOPS_PAGE_SIZE
))) {
165 printk(KERN_ERR
"mtdoops: All blocks bad!\n");
170 for (j
= 0, ret
= -1; (j
< 3) && (ret
< 0); j
++)
171 ret
= mtdoops_erase_block(mtd
, cxt
->nextpage
* OOPS_PAGE_SIZE
);
174 printk(KERN_DEBUG
"mtdoops: Ready %d, %d \n", cxt
->nextpage
, cxt
->nextcount
);
179 if (mtd
->block_markbad
&& (ret
== -EIO
)) {
180 ret
= mtd
->block_markbad(mtd
, cxt
->nextpage
* OOPS_PAGE_SIZE
);
182 printk(KERN_ERR
"mtdoops: block_markbad failed, aborting.\n");
189 static void mtdoops_workfunc_write(struct work_struct
*work
)
191 struct mtdoops_context
*cxt
=
192 container_of(work
, struct mtdoops_context
, work_write
);
193 struct mtd_info
*mtd
= cxt
->mtd
;
197 if (cxt
->writecount
< OOPS_PAGE_SIZE
)
198 memset(cxt
->oops_buf
+ cxt
->writecount
, 0xff,
199 OOPS_PAGE_SIZE
- cxt
->writecount
);
201 ret
= mtd
->write(mtd
, cxt
->nextpage
* OOPS_PAGE_SIZE
,
202 OOPS_PAGE_SIZE
, &retlen
, cxt
->oops_buf
);
206 if ((retlen
!= OOPS_PAGE_SIZE
) || (ret
< 0))
207 printk(KERN_ERR
"mtdoops: Write failure at %d (%td of %d written), err %d.\n",
208 cxt
->nextpage
* OOPS_PAGE_SIZE
, retlen
, OOPS_PAGE_SIZE
, ret
);
210 mtdoops_inc_counter(cxt
);
213 static void find_next_position(struct mtdoops_context
*cxt
)
215 struct mtd_info
*mtd
= cxt
->mtd
;
216 int ret
, page
, maxpos
= 0;
217 u32 count
, maxcount
= 0xffffffff;
220 for (page
= 0; page
< cxt
->oops_pages
; page
++) {
221 ret
= mtd
->read(mtd
, page
* OOPS_PAGE_SIZE
, 4, &retlen
, (u_char
*) &count
);
222 if ((retlen
!= 4) || ((ret
< 0) && (ret
!= -EUCLEAN
))) {
223 printk(KERN_ERR
"mtdoops: Read failure at %d (%td of 4 read)"
224 ", err %d.\n", page
* OOPS_PAGE_SIZE
, retlen
, ret
);
228 if (count
== 0xffffffff)
230 if (maxcount
== 0xffffffff) {
233 } else if ((count
< 0x40000000) && (maxcount
> 0xc0000000)) {
236 } else if ((count
> maxcount
) && (count
< 0xc0000000)) {
239 } else if ((count
> maxcount
) && (count
> 0xc0000000)
240 && (maxcount
> 0x80000000)) {
245 if (maxcount
== 0xffffffff) {
249 printk(KERN_DEBUG
"mtdoops: Ready %d, %d (first init)\n",
250 cxt
->nextpage
, cxt
->nextcount
);
254 cxt
->nextpage
= maxpos
;
255 cxt
->nextcount
= maxcount
;
257 mtdoops_inc_counter(cxt
);
261 static void mtdoops_notify_add(struct mtd_info
*mtd
)
263 struct mtdoops_context
*cxt
= &oops_cxt
;
265 if ((mtd
->index
!= cxt
->mtd_index
) || cxt
->mtd_index
< 0)
268 if (mtd
->size
< (mtd
->erasesize
* 2)) {
269 printk(KERN_ERR
"MTD partition %d not big enough for mtdoops\n",
275 cxt
->oops_pages
= mtd
->size
/ OOPS_PAGE_SIZE
;
277 find_next_position(cxt
);
279 printk(KERN_DEBUG
"mtdoops: Attached to MTD device %d\n", mtd
->index
);
282 static void mtdoops_notify_remove(struct mtd_info
*mtd
)
284 struct mtdoops_context
*cxt
= &oops_cxt
;
286 if ((mtd
->index
!= cxt
->mtd_index
) || cxt
->mtd_index
< 0)
290 flush_scheduled_work();
293 static void mtdoops_console_sync(void)
295 struct mtdoops_context
*cxt
= &oops_cxt
;
296 struct mtd_info
*mtd
= cxt
->mtd
;
299 if (!cxt
->ready
|| !mtd
|| cxt
->writecount
== 0)
303 * Once ready is 0 and we've held the lock no further writes to the
306 spin_lock_irqsave(&cxt
->writecount_lock
, flags
);
308 spin_unlock_irqrestore(&cxt
->writecount_lock
, flags
);
312 spin_unlock_irqrestore(&cxt
->writecount_lock
, flags
);
314 schedule_work(&cxt
->work_write
);
318 mtdoops_console_write(struct console
*co
, const char *s
, unsigned int count
)
320 struct mtdoops_context
*cxt
= co
->data
;
321 struct mtd_info
*mtd
= cxt
->mtd
;
324 if (!oops_in_progress
) {
325 mtdoops_console_sync();
329 if (!cxt
->ready
|| !mtd
)
332 /* Locking on writecount ensures sequential writes to the buffer */
333 spin_lock_irqsave(&cxt
->writecount_lock
, flags
);
335 /* Check ready status didn't change whilst waiting for the lock */
339 if (cxt
->writecount
== 0) {
340 u32
*stamp
= cxt
->oops_buf
;
341 *stamp
= cxt
->nextcount
;
345 if ((count
+ cxt
->writecount
) > OOPS_PAGE_SIZE
)
346 count
= OOPS_PAGE_SIZE
- cxt
->writecount
;
348 memcpy(cxt
->oops_buf
+ cxt
->writecount
, s
, count
);
349 cxt
->writecount
+= count
;
351 spin_unlock_irqrestore(&cxt
->writecount_lock
, flags
);
353 if (cxt
->writecount
== OOPS_PAGE_SIZE
)
354 mtdoops_console_sync();
357 static int __init
mtdoops_console_setup(struct console
*co
, char *options
)
359 struct mtdoops_context
*cxt
= co
->data
;
361 if (cxt
->mtd_index
!= -1)
366 cxt
->mtd_index
= co
->index
;
370 static struct mtd_notifier mtdoops_notifier
= {
371 .add
= mtdoops_notify_add
,
372 .remove
= mtdoops_notify_remove
,
375 static struct console mtdoops_console
= {
377 .write
= mtdoops_console_write
,
378 .setup
= mtdoops_console_setup
,
379 .unblank
= mtdoops_console_sync
,
380 .flags
= CON_PRINTBUFFER
,
385 static int __init
mtdoops_console_init(void)
387 struct mtdoops_context
*cxt
= &oops_cxt
;
390 cxt
->oops_buf
= vmalloc(OOPS_PAGE_SIZE
);
392 if (!cxt
->oops_buf
) {
393 printk(KERN_ERR
"Failed to allocate oops buffer workspace\n");
397 INIT_WORK(&cxt
->work_erase
, mtdoops_workfunc_erase
);
398 INIT_WORK(&cxt
->work_write
, mtdoops_workfunc_write
);
400 register_console(&mtdoops_console
);
401 register_mtd_user(&mtdoops_notifier
);
405 static void __exit
mtdoops_console_exit(void)
407 struct mtdoops_context
*cxt
= &oops_cxt
;
409 unregister_mtd_user(&mtdoops_notifier
);
410 unregister_console(&mtdoops_console
);
411 vfree(cxt
->oops_buf
);
415 subsys_initcall(mtdoops_console_init
);
416 module_exit(mtdoops_console_exit
);
418 MODULE_LICENSE("GPL");
419 MODULE_AUTHOR("Richard Purdie <rpurdie@openedhand.com>");
420 MODULE_DESCRIPTION("MTD Oops/Panic console logger/driver");