for (k = i->start; k < bset_bkey_last(i); k = next) {
                next = bkey_next(k);
 
-               printk(KERN_ERR "block %u key %u/%u: ", set,
+               pr_err("block %u key %u/%u: ", set,
                       (unsigned int) ((u64 *) k - i->d), i->keys);
 
                if (b->ops->key_dump)
                        b->ops->key_dump(b, k);
                else
-                       printk("%llu:%llu\n", KEY_INODE(k), KEY_OFFSET(k));
+                       pr_err("%llu:%llu\n", KEY_INODE(k), KEY_OFFSET(k));
 
                if (next < bset_bkey_last(i) &&
                    bkey_cmp(k, b->ops->is_extents ?
                             &START_KEY(next) : next) > 0)
-                       printk(KERN_ERR "Key skipped backwards\n");
+                       pr_err("Key skipped backwards\n");
        }
 }
 
                unsigned int i = 1, j = rounddown_pow_of_two(size - 1);
 
                if (!(size % 4096))
-                       printk(KERN_NOTICE "loop %u, %llu per us\n", size,
+                       pr_notice("loop %u, %llu per us\n", size,
                               done / ktime_us_delta(ktime_get(), start));
 
                while (1) {
 
 
                console_lock();
 
-               printk(KERN_ERR "*** in memory:\n");
+               pr_err("*** in memory:\n");
                bch_dump_bset(&b->keys, inmemory, 0);
 
-               printk(KERN_ERR "*** read back in:\n");
+               pr_err("*** read back in:\n");
                bch_dump_bset(&v->keys, sorted, 0);
 
                for_each_written_bset(b, ondisk, i) {
                        unsigned int block = ((void *) i - (void *) ondisk) /
                                block_bytes(b->c);
 
-                       printk(KERN_ERR "*** on disk block %u:\n", block);
+                       pr_err("*** on disk block %u:\n", block);
                        bch_dump_bset(&b->keys, i, block);
                }
 
-               printk(KERN_ERR "*** block %zu not written\n",
+               pr_err("*** block %zu not written\n",
                       ((void *) i - (void *) ondisk) / block_bytes(b->c));
 
                for (j = 0; j < inmemory->keys; j++)
                        if (inmemory->d[j] != sorted->d[j])
                                break;
 
-               printk(KERN_ERR "b->written %u\n", b->written);
+               pr_err("b->written %u\n", b->written);
 
                console_unlock();
                panic("verify failed at %u\n", j);
 
        char buf[80];
 
        bch_extent_to_text(buf, sizeof(buf), k);
-       printk(" %s", buf);
+       pr_err(" %s", buf);
 
        for (j = 0; j < KEY_PTRS(k); j++) {
                size_t n = PTR_BUCKET_NR(b->c, k, j);
 
-               printk(" bucket %zu", n);
+               pr_err(" bucket %zu", n);
                if (n >= b->c->sb.first_bucket && n < b->c->sb.nbuckets)
-                       printk(" prio %i",
+                       pr_err(" prio %i",
                               PTR_BUCKET(b->c, k, j)->prio);
        }
 
-       printk(" %s\n", bch_ptr_status(b->c, k));
+       pr_err(" %s\n", bch_ptr_status(b->c, k));
 }
 
 /* Btree ptrs */
 
        acquire_console_sem();
        */
 
-       printk(KERN_ERR "bcache: error on %pU: ", c->sb.set_uuid);
+       pr_err("bcache: error on %pU: ", c->sb.set_uuid);
 
        va_start(args, fmt);
        vprintk(fmt, args);
        va_end(args);
 
-       printk(", disabling caching\n");
+       pr_err(", disabling caching\n");
 
        if (c->on_error == ON_ERROR_PANIC)
                panic("panic forced after error\n");