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