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 18struct dm_bufio_client; 19struct 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 */ 29struct dm_bufio_client * 30dm_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 */ 39void dm_bufio_client_destroy(struct dm_bufio_client *c); 40 41void dm_bufio_client_reset(struct dm_bufio_client *c); 42 43/* 44 * Set the sector range. 45 * When this function is called, there must be no I/O in progress on the bufio 46 * client. 47 */ 48void dm_bufio_set_sector_offset(struct dm_bufio_client *c, sector_t start); 49 50/* 51 * WARNING: to avoid deadlocks, these conditions are observed: 52 * 53 * - At most one thread can hold at most "reserved_buffers" simultaneously. 54 * - Each other threads can hold at most one buffer. 55 * - Threads which call only dm_bufio_get can hold unlimited number of 56 * buffers. 57 */ 58 59/* 60 * Read a given block from disk. Returns pointer to data. Returns a 61 * pointer to dm_buffer that can be used to release the buffer or to make 62 * it dirty. 63 */ 64void *dm_bufio_read(struct dm_bufio_client *c, sector_t block, 65 struct dm_buffer **bp); 66 67void *dm_bufio_read_with_ioprio(struct dm_bufio_client *c, sector_t block, 68 struct dm_buffer **bp, unsigned short ioprio); 69 70/* 71 * Like dm_bufio_read, but return buffer from cache, don't read 72 * it. If the buffer is not in the cache, return NULL. 73 */ 74void *dm_bufio_get(struct dm_bufio_client *c, sector_t block, 75 struct dm_buffer **bp); 76 77/* 78 * Like dm_bufio_read, but don't read anything from the disk. It is 79 * expected that the caller initializes the buffer and marks it dirty. 80 */ 81void *dm_bufio_new(struct dm_bufio_client *c, sector_t block, 82 struct dm_buffer **bp); 83 84/* 85 * Prefetch the specified blocks to the cache. 86 * The function starts to read the blocks and returns without waiting for 87 * I/O to finish. 88 */ 89void dm_bufio_prefetch(struct dm_bufio_client *c, 90 sector_t block, unsigned int n_blocks); 91 92void dm_bufio_prefetch_with_ioprio(struct dm_bufio_client *c, 93 sector_t block, unsigned int n_blocks, 94 unsigned short ioprio); 95 96/* 97 * Release a reference obtained with dm_bufio_{read,get,new}. The data 98 * pointer and dm_buffer pointer is no longer valid after this call. 99 */ 100void dm_bufio_release(struct dm_buffer *b); 101 102/* 103 * Mark a buffer dirty. It should be called after the buffer is modified. 104 * 105 * In case of memory pressure, the buffer may be written after 106 * dm_bufio_mark_buffer_dirty, but before dm_bufio_write_dirty_buffers. So 107 * dm_bufio_write_dirty_buffers guarantees that the buffer is on-disk but 108 * the actual writing may occur earlier. 109 */ 110void dm_bufio_mark_buffer_dirty(struct dm_buffer *b); 111 112/* 113 * Mark a part of the buffer dirty. 114 * 115 * The specified part of the buffer is scheduled to be written. dm-bufio may 116 * write the specified part of the buffer or it may write a larger superset. 117 */ 118void dm_bufio_mark_partial_buffer_dirty(struct dm_buffer *b, 119 unsigned int start, unsigned int end); 120 121/* 122 * Initiate writing of dirty buffers, without waiting for completion. 123 */ 124void dm_bufio_write_dirty_buffers_async(struct dm_bufio_client *c); 125 126/* 127 * Write all dirty buffers. Guarantees that all dirty buffers created prior 128 * to this call are on disk when this call exits. 129 */ 130int dm_bufio_write_dirty_buffers(struct dm_bufio_client *c); 131 132/* 133 * Send an empty write barrier to the device to flush hardware disk cache. 134 */ 135int dm_bufio_issue_flush(struct dm_bufio_client *c); 136 137/* 138 * Send a discard request to the underlying device. 139 */ 140int dm_bufio_issue_discard(struct dm_bufio_client *c, sector_t block, sector_t count); 141 142/* 143 * Free the given buffer. 144 * This is just a hint, if the buffer is in use or dirty, this function 145 * does nothing. 146 */ 147void dm_bufio_forget(struct dm_bufio_client *c, sector_t block); 148 149/* 150 * Free the given range of buffers. 151 * This is just a hint, if the buffer is in use or dirty, this function 152 * does nothing. 153 */ 154void dm_bufio_forget_buffers(struct dm_bufio_client *c, sector_t block, sector_t n_blocks); 155 156/* 157 * Set the minimum number of buffers before cleanup happens. 158 */ 159void dm_bufio_set_minimum_buffers(struct dm_bufio_client *c, unsigned int n); 160 161unsigned int dm_bufio_get_block_size(struct dm_bufio_client *c); 162sector_t dm_bufio_get_device_size(struct dm_bufio_client *c); 163struct dm_io_client *dm_bufio_get_dm_io_client(struct dm_bufio_client *c); 164sector_t dm_bufio_get_block_number(struct dm_buffer *b); 165void *dm_bufio_get_block_data(struct dm_buffer *b); 166void *dm_bufio_get_aux_data(struct dm_buffer *b); 167struct dm_bufio_client *dm_bufio_get_client(struct dm_buffer *b); 168 169/*----------------------------------------------------------------*/ 170 171#endif 172