$ sudo dmsetup create dust1 --table '0 33552384 dust /dev/vdb1 0 4096'
 
 Check the status of the read behavior ("bypass" indicates that all I/O
-will be passed through to the underlying device)::
+will be passed through to the underlying device; "verbose" indicates that
+bad block additions, removals, and remaps will be verbosely logged)::
 
         $ sudo dmsetup status dust1
-        0 33552384 dust 252:17 bypass
+        0 33552384 dust 252:17 bypass verbose
 
         $ sudo dd if=/dev/mapper/dust1 of=/dev/null bs=512 count=128 iflag=direct
         128+0 records in
 A message will print with the number of bad blocks currently
 configured on the device::
 
-        kernel: device-mapper: dust: countbadblocks: 895 badblock(s) found
+        countbadblocks: 895 badblock(s) found
 
 Querying for specific bad blocks
 --------------------------------
 
 The following message will print if the block is in the list::
 
-        device-mapper: dust: queryblock: block 72 found in badblocklist
+        dust_query_block: block 72 found in badblocklist
 
 The following message will print if the block is not in the list::
 
-        device-mapper: dust: queryblock: block 72 not found in badblocklist
+        dust_query_block: block 72 not found in badblocklist
 
 The "queryblock" message command will work in both the "enabled"
 and "disabled" modes, allowing the verification of whether a block
 
 After clearing the bad block list, the following message will appear::
 
-        kernel: device-mapper: dust: clearbadblocks: badblocks cleared
+        dust_clear_badblocks: badblocks cleared
 
 If there were no bad blocks to clear, the following message will
 appear::
 
-        kernel: device-mapper: dust: clearbadblocks: no badblocks found
+        dust_clear_badblocks: no badblocks found
 
 Message commands list
 ---------------------
 
        return 0;
 }
 
-static int dust_query_block(struct dust_device *dd, unsigned long long block)
+static int dust_query_block(struct dust_device *dd, unsigned long long block, char *result,
+                           unsigned int maxlen, unsigned int *sz_ptr)
 {
        struct badblock *bblock;
        unsigned long flags;
+       unsigned int sz = *sz_ptr;
 
        spin_lock_irqsave(&dd->dust_lock, flags);
        bblock = dust_rb_search(&dd->badblocklist, block);
        if (bblock != NULL)
-               DMINFO("%s: block %llu found in badblocklist", __func__, block);
+               DMEMIT("%s: block %llu found in badblocklist", __func__, block);
        else
-               DMINFO("%s: block %llu not found in badblocklist", __func__, block);
+               DMEMIT("%s: block %llu not found in badblocklist", __func__, block);
        spin_unlock_irqrestore(&dd->dust_lock, flags);
 
-       return 0;
+       return 1;
 }
 
 static int __dust_map_read(struct dust_device *dd, sector_t thisblock)
        return true;
 }
 
-static int dust_clear_badblocks(struct dust_device *dd)
+static int dust_clear_badblocks(struct dust_device *dd, char *result, unsigned int maxlen,
+                               unsigned int *sz_ptr)
 {
        unsigned long flags;
        struct rb_root badblocklist;
        unsigned long long badblock_count;
+       unsigned int sz = *sz_ptr;
 
        spin_lock_irqsave(&dd->dust_lock, flags);
        badblocklist = dd->badblocklist;
        spin_unlock_irqrestore(&dd->dust_lock, flags);
 
        if (!__dust_clear_badblocks(&badblocklist, badblock_count))
-               DMINFO("%s: no badblocks found", __func__);
+               DMEMIT("%s: no badblocks found", __func__);
        else
-               DMINFO("%s: badblocks cleared", __func__);
+               DMEMIT("%s: badblocks cleared", __func__);
 
-       return 0;
+       return 1;
 }
 
 /*
 }
 
 static int dust_message(struct dm_target *ti, unsigned int argc, char **argv,
-                       char *result_buf, unsigned int maxlen)
+                       char *result, unsigned int maxlen)
 {
        struct dust_device *dd = ti->private;
        sector_t size = i_size_read(dd->dev->bdev->bd_inode) >> SECTOR_SHIFT;
        unsigned char wr_fail_cnt;
        unsigned int tmp_ui;
        unsigned long flags;
+       unsigned int sz = 0;
        char dummy;
 
        if (argc == 1) {
                        r = 0;
                } else if (!strcasecmp(argv[0], "countbadblocks")) {
                        spin_lock_irqsave(&dd->dust_lock, flags);
-                       DMINFO("countbadblocks: %llu badblock(s) found",
+                       DMEMIT("countbadblocks: %llu badblock(s) found",
                               dd->badblock_count);
                        spin_unlock_irqrestore(&dd->dust_lock, flags);
-                       r = 0;
+                       r = 1;
                } else if (!strcasecmp(argv[0], "clearbadblocks")) {
-                       r = dust_clear_badblocks(dd);
+                       r = dust_clear_badblocks(dd, result, maxlen, &sz);
                } else if (!strcasecmp(argv[0], "quiet")) {
                        if (!dd->quiet_mode)
                                dd->quiet_mode = true;
                else if (!strcasecmp(argv[0], "removebadblock"))
                        r = dust_remove_block(dd, block);
                else if (!strcasecmp(argv[0], "queryblock"))
-                       r = dust_query_block(dd, block);
+                       r = dust_query_block(dd, block, result, maxlen, &sz);
                else
                        invalid_msg = true;