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