include/linux/dm-bufio.h

   1 /*
   2  * Copyright (C) 2009-2011 Red Hat, Inc.
   3  *
   4  * Author: Mikulas Patocka <mpatocka@redhat.com>
   5  *
   6  * This file is released under the GPL.
   7  */
   8
   9 #ifndef _LINUX_DM_BUFIO_H
  10 #define _LINUX_DM_BUFIO_H
  11
  12 #include <linux/blkdev.h>
  13 #include <linux/types.h>
  14
  15 /*----------------------------------------------------------------*/
  16
  17 struct dm_bufio_client;
  18 struct dm_buffer;
  19
  20 /*
  21  * Create a buffered IO cache on a given device
  22  */
  23 struct dm_bufio_client *
  24 dm_bufio_client_create(struct block_device *bdev, unsigned block_size,
  25                        unsigned reserved_buffers, unsigned aux_size,
  26                        void (*alloc_callback)(struct dm_buffer *),
  27                        void (*write_callback)(struct dm_buffer *));
  28
  29 /*
  30  * Release a buffered IO cache.
  31  */
  32 void dm_bufio_client_destroy(struct dm_bufio_client *c);
  33
  34 /*
  35  * Set the sector range.
  36  * When this function is called, there must be no I/O in progress on the bufio
  37  * client.
  38  */
  39 void dm_bufio_set_sector_offset(struct dm_bufio_client *c, sector_t start);
  40
  41 /*
  42  * WARNING: to avoid deadlocks, these conditions are observed:
  43  *
  44  * - At most one thread can hold at most "reserved_buffers" simultaneously.
  45  * - Each other threads can hold at most one buffer.
  46  * - Threads which call only dm_bufio_get can hold unlimited number of
  47  *   buffers.
  48  */
  49
  50 /*
  51  * Read a given block from disk. Returns pointer to data.  Returns a
  52  * pointer to dm_buffer that can be used to release the buffer or to make
  53  * it dirty.
  54  */
  55 void *dm_bufio_read(struct dm_bufio_client *c, sector_t block,
  56                     struct dm_buffer **bp);
  57
  58 /*
  59  * Like dm_bufio_read, but return buffer from cache, don't read
  60  * it. If the buffer is not in the cache, return NULL.
  61  */
  62 void *dm_bufio_get(struct dm_bufio_client *c, sector_t block,
  63                    struct dm_buffer **bp);
  64
  65 /*
  66  * Like dm_bufio_read, but don't read anything from the disk.  It is
  67  * expected that the caller initializes the buffer and marks it dirty.
  68  */
  69 void *dm_bufio_new(struct dm_bufio_client *c, sector_t block,
  70                    struct dm_buffer **bp);
  71
  72 /*
  73  * Prefetch the specified blocks to the cache.
  74  * The function starts to read the blocks and returns without waiting for
  75  * I/O to finish.
  76  */
  77 void dm_bufio_prefetch(struct dm_bufio_client *c,
  78                        sector_t block, unsigned n_blocks);
  79
  80 /*
  81  * Release a reference obtained with dm_bufio_{read,get,new}. The data
  82  * pointer and dm_buffer pointer is no longer valid after this call.
  83  */
  84 void dm_bufio_release(struct dm_buffer *b);
  85
  86 /*
  87  * Mark a buffer dirty. It should be called after the buffer is modified.
  88  *
  89  * In case of memory pressure, the buffer may be written after
  90  * dm_bufio_mark_buffer_dirty, but before dm_bufio_write_dirty_buffers.  So
  91  * dm_bufio_write_dirty_buffers guarantees that the buffer is on-disk but
  92  * the actual writing may occur earlier.
  93  */
  94 void dm_bufio_mark_buffer_dirty(struct dm_buffer *b);
  95
  96 /*
  97  * Mark a part of the buffer dirty.
  98  *
  99  * The specified part of the buffer is scheduled to be written. dm-bufio may
 100  * write the specified part of the buffer or it may write a larger superset.
 101  */
 102 void dm_bufio_mark_partial_buffer_dirty(struct dm_buffer *b,
 103                                         unsigned start, unsigned end);
 104
 105 /*
 106  * Initiate writing of dirty buffers, without waiting for completion.
 107  */
 108 void dm_bufio_write_dirty_buffers_async(struct dm_bufio_client *c);
 109
 110 /*
 111  * Write all dirty buffers. Guarantees that all dirty buffers created prior
 112  * to this call are on disk when this call exits.
 113  */
 114 int dm_bufio_write_dirty_buffers(struct dm_bufio_client *c);
 115
 116 /*
 117  * Send an empty write barrier to the device to flush hardware disk cache.
 118  */
 119 int dm_bufio_issue_flush(struct dm_bufio_client *c);
 120
 121 /*
 122  * Send a discard request to the underlying device.
 123  */
 124 int dm_bufio_issue_discard(struct dm_bufio_client *c, sector_t block, sector_t count);
 125
 126 /*
 127  * Like dm_bufio_release but also move the buffer to the new
 128  * block. dm_bufio_write_dirty_buffers is needed to commit the new block.
 129  */
 130 void dm_bufio_release_move(struct dm_buffer *b, sector_t new_block);
 131
 132 /*
 133  * Free the given buffer.
 134  * This is just a hint, if the buffer is in use or dirty, this function
 135  * does nothing.
 136  */
 137 void dm_bufio_forget(struct dm_bufio_client *c, sector_t block);
 138
 139 /*
 140  * Free the given range of buffers.
 141  * This is just a hint, if the buffer is in use or dirty, this function
 142  * does nothing.
 143  */
 144 void dm_bufio_forget_buffers(struct dm_bufio_client *c, sector_t block, sector_t n_blocks);
 145
 146 /*
 147  * Set the minimum number of buffers before cleanup happens.
 148  */
 149 void dm_bufio_set_minimum_buffers(struct dm_bufio_client *c, unsigned n);
 150
 151 unsigned dm_bufio_get_block_size(struct dm_bufio_client *c);
 152 sector_t dm_bufio_get_device_size(struct dm_bufio_client *c);
 153 struct dm_io_client *dm_bufio_get_dm_io_client(struct dm_bufio_client *c);
 154 sector_t dm_bufio_get_block_number(struct dm_buffer *b);
 155 void *dm_bufio_get_block_data(struct dm_buffer *b);
 156 void *dm_bufio_get_aux_data(struct dm_buffer *b);
 157 struct dm_bufio_client *dm_bufio_get_client(struct dm_buffer *b);
 158
 159 /*----------------------------------------------------------------*/
 160
 161 #endif