struct dm_bufio_client *dm_bufio_client_create(struct block_device *bdev, unsigned block_size,
                                               unsigned reserved_buffers, unsigned aux_size,
                                               void (*alloc_callback)(struct dm_buffer *),
-                                              void (*write_callback)(struct dm_buffer *))
+                                              void (*write_callback)(struct dm_buffer *),
+                                              unsigned int flags)
 {
        int r;
        struct dm_bufio_client *c;
 
                goto bad;
        }
 
-       ec->bufio = dm_bufio_client_create(ec->dev->bdev, to_bytes(ec->u_bs), 1, 0, NULL, NULL);
+       ec->bufio = dm_bufio_client_create(ec->dev->bdev, to_bytes(ec->u_bs), 1,
+                                          0, NULL, NULL, 0);
        if (IS_ERR(ec->bufio)) {
                ti->error = "Cannot create dm bufio client";
                r = PTR_ERR(ec->bufio);
 
        }
 
        ic->bufio = dm_bufio_client_create(ic->meta_dev ? ic->meta_dev->bdev : ic->dev->bdev,
-                       1U << (SECTOR_SHIFT + ic->log2_buffer_sectors), 1, 0, NULL, NULL);
+                       1U << (SECTOR_SHIFT + ic->log2_buffer_sectors), 1, 0, NULL, NULL, 0);
        if (IS_ERR(ic->bufio)) {
                r = PTR_ERR(ic->bufio);
                ti->error = "Cannot initialize dm-bufio";
 
 
        client = dm_bufio_client_create(dm_snap_cow(ps->store->snap)->bdev,
                                        ps->store->chunk_size << SECTOR_SHIFT,
-                                       1, 0, NULL, NULL);
+                                       1, 0, NULL, NULL, 0);
 
        if (IS_ERR(client))
                return PTR_ERR(client);
 
 
        f->bufio = dm_bufio_client_create(f->dev->bdev,
                                          f->io_size,
-                                         1, 0, NULL, NULL);
+                                         1, 0, NULL, NULL, 0);
        if (IS_ERR(f->bufio)) {
                ti->error = "Cannot initialize FEC bufio client";
                return PTR_ERR(f->bufio);
 
        f->data_bufio = dm_bufio_client_create(v->data_dev->bdev,
                                               1 << v->data_dev_block_bits,
-                                              1, 0, NULL, NULL);
+                                              1, 0, NULL, NULL, 0);
        if (IS_ERR(f->data_bufio)) {
                ti->error = "Cannot initialize FEC data bufio client";
                return PTR_ERR(f->data_bufio);
 
 
        v->bufio = dm_bufio_client_create(v->hash_dev->bdev,
                1 << v->hash_dev_block_bits, 1, sizeof(struct buffer_aux),
-               dm_bufio_alloc_callback, NULL);
+               dm_bufio_alloc_callback, NULL, 0);
        if (IS_ERR(v->bufio)) {
                ti->error = "Cannot initialize dm-bufio";
                r = PTR_ERR(v->bufio);
 
        bm->bufio = dm_bufio_client_create(bdev, block_size, max_held_per_thread,
                                           sizeof(struct buffer_aux),
                                           dm_block_manager_alloc_callback,
-                                          dm_block_manager_write_callback);
+                                          dm_block_manager_write_callback,
+                                          0);
        if (IS_ERR(bm->bufio)) {
                r = PTR_ERR(bm->bufio);
                kfree(bm);
 
 dm_bufio_client_create(struct block_device *bdev, unsigned block_size,
                       unsigned reserved_buffers, unsigned aux_size,
                       void (*alloc_callback)(struct dm_buffer *),
-                      void (*write_callback)(struct dm_buffer *));
+                      void (*write_callback)(struct dm_buffer *),
+                      unsigned int flags);
 
 /*
  * Release a buffered IO cache.