3 * modules/driver/driver_to_buffer.c
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19 * Copyright (C) Samsung Electronics, 2013
21 * 2013 Alexander Aksenov <a.aksenov@samsung.com>: SWAP device driver implement
25 #include <linux/string.h>
26 #include <linux/slab.h>
27 #include <linux/splice.h>
28 #include <asm/uaccess.h>
29 #include <linux/spinlock.h>
32 #include <buffer/swap_buffer_module.h>
33 #include <buffer/swap_buffer_errors.h>
34 #include <buffer/buffer_description.h>
35 #include <writer/swap_writer_module.h>
37 #include "driver_defs.h"
38 #include "swap_driver_errors.h"
39 #include "device_driver_to_driver_to_buffer.h"
41 /* Current busy buffer */
42 static struct swap_subbuffer *busy_buffer = NULL;
44 /* Buffers count ready to be read */
45 static int buffers_to_read = 0;
47 /* Pages count in one subbuffer */
48 static int pages_per_buffer = 0;
50 /* Used to sync changes of the buffers_to_read var */
51 static spinlock_t buf_to_read;
54 static inline void init_buffers_to_read(void)
56 spin_lock_init(&buf_to_read);
60 static inline void inc_buffers_to_read(void)
64 spin_lock_irqsave(&buf_to_read, flags);
66 spin_unlock_irqrestore(&buf_to_read, flags);
69 static inline void dec_buffers_to_read(void)
73 spin_lock_irqsave(&buf_to_read, flags);
75 spin_unlock_irqrestore(&buf_to_read, flags);
78 static inline void set_buffers_to_read(int count)
82 spin_lock_irqsave(&buf_to_read, flags);
83 buffers_to_read = count;
84 spin_unlock_irqrestore(&buf_to_read, flags);
87 static inline int something_to_read(void)
92 spin_lock_irqsave(&buf_to_read, flags);
93 result = buffers_to_read;
94 spin_unlock_irqrestore(&buf_to_read, flags);
99 /* TODO Get subbuffer for reading */
100 static size_t driver_to_buffer_get(void)
104 /* If there is no readable buffers, return error */
105 result = swap_buffer_get(&busy_buffer);
106 if (result == -E_SB_NO_READABLE_BUFFERS) {
108 return -E_SD_NO_DATA_TO_READ;
109 } else if (result < 0) {
110 print_err("swap_buffer_get unhandle error %d\n", result);
111 return -E_SD_BUFFER_ERROR;
114 return busy_buffer->full_buffer_part;
117 /* TODO Release subbuffer */
118 static int driver_to_buffer_release(void)
123 return -E_SD_NO_BUSY_SUBBUFFER;
125 result = swap_buffer_release(&busy_buffer);
126 if (result == -E_SB_NO_SUBBUFFER_IN_BUSY) {
127 return -E_SD_WRONG_SUBBUFFER_PTR;
128 } else if (result < 0) {
129 print_err("swap_buffer_release unhandle error %d\n", result);
130 return -E_SD_BUFFER_ERROR;
138 /* Buffers callback function */
139 int driver_to_buffer_callback(void)
141 /* Increment buffers_to_read counter */
142 inc_buffers_to_read();
143 swap_device_wake_up_process();
149 ssize_t driver_to_buffer_read(char __user *buf, size_t count)
151 size_t bytes_to_copy;
152 size_t bytes_to_read = 0;
153 int page_counter = 0;
155 /* Reading from swap_device means reading only current busy_buffer. So, if
156 * there is no busy_buffer, we don't get next to read, we just read nothing.
157 * In this case, or if there is nothing to read from busy_buffer - return
158 * -E_SD_NO_DATA_TO_READ. It should be correctly handled in device_driver */
159 if (!busy_buffer || !busy_buffer->full_buffer_part)
160 return -E_SD_NO_DATA_TO_READ;
162 /* Bytes count that we're going to copy to user buffer is equal to user
163 * buffer size or to subbuffer readable size whichever is less */
164 bytes_to_copy = (count > busy_buffer->full_buffer_part) ?
165 busy_buffer->full_buffer_part : count;
167 /* Copy data from each page to buffer */
168 while(bytes_to_copy > 0) {
169 /* Get size that should be copied from current page */
170 size_t read_from_this_page = (bytes_to_copy > PAGE_SIZE) ? PAGE_SIZE
173 /* Copy and add size to copied bytes count */
175 // TODO Check with more than one page
176 bytes_to_read += read_from_this_page -
177 copy_to_user(buf, page_address(busy_buffer->data_buffer) +
178 (sizeof(struct page*) *
180 read_from_this_page);
181 bytes_to_copy -= read_from_this_page;
185 return bytes_to_read;
188 /* Flush swap_buffer */
189 int driver_to_buffer_flush(void)
191 unsigned int flushed;
193 flushed = swap_buffer_flush();
194 set_buffers_to_read(flushed);
195 swap_device_wake_up_process();
200 /* Fills spd structure */
201 int driver_to_buffer_fill_spd(struct splice_pipe_desc *spd)
203 size_t data_to_splice = busy_buffer->full_buffer_part;
204 struct page **pages = spd->pages;
205 struct partial_page *partial = spd->partial;
207 while (data_to_splice) {
208 size_t read_from_current_page = min(data_to_splice, (size_t)PAGE_SIZE);
210 pages[spd->nr_pages] = alloc_page(GFP_KERNEL);
211 if (!pages[spd->nr_pages]) {
212 print_err("Cannot alloc page for splice\n");
216 /* FIXME: maybe there is more efficient way */
217 memcpy(page_address(pages[spd->nr_pages]),
218 page_address(&busy_buffer->data_buffer[spd->nr_pages]),
219 read_from_current_page);
221 /* Always beginning of the page */
222 partial[spd->nr_pages].offset = 0;
223 partial[spd->nr_pages].len = read_from_current_page;
225 /* Private is not used */
226 partial[spd->nr_pages].private = 0;
229 data_to_splice -= read_from_current_page;
231 /* TODO: add check for pipe->buffers exceeding */
232 /* if (spd->nr_pages == pipe->buffers) { */
239 /* Check for subbuffers ready to be read */
240 int driver_to_buffer_buffer_to_read(void)
242 return busy_buffer ? 1 : 0;
245 /* Set buffers size and count */
246 int driver_to_buffer_initialize(size_t size, unsigned int count)
249 struct buffer_init_t buf_init = {
250 .subbuffer_size = size,
251 .nr_subbuffers = count,
252 .subbuffer_full_cb = driver_to_buffer_callback,
253 .lower_threshold = 20,
256 .enough_mem_cb = NULL,
259 if (size == 0 && count == 0) {
260 return -E_SD_WRONG_ARGS;
263 result = swap_buffer_init(&buf_init);
264 if (result == -E_SB_NO_MEM_QUEUE_BUSY
265 || result == -E_SB_NO_MEM_BUFFER_STRUCT) {
266 return -E_SD_NO_MEMORY;
269 // TODO Race condition: buffer can be used in other thread till we're in
271 /* Initialize driver_to_buffer variables */
272 pages_per_buffer = result;
274 init_buffers_to_read();
279 /* Uninitialize buffer */
280 int driver_to_buffer_uninitialize(void)
284 /* Release occupied buffer */
286 result = driver_to_buffer_release();
287 // TODO Maybe release anyway
294 result = swap_buffer_uninit();
295 if (result == -E_SB_UNRELEASED_BUFFERS) {
296 print_err("Can't uninit buffer! There are busy subbuffers!\n");
297 result = -E_SD_BUFFER_ERROR;
298 } else if (result < 0) {
299 print_err("swap_buffer_uninit error %d\n", result);
300 result = -E_SD_BUFFER_ERROR;
302 result = E_SD_SUCCESS;
305 /* Reinit driver_to_buffer vars */
306 init_buffers_to_read();
307 pages_per_buffer = 0;
312 /* Get next buffer to read */
313 int driver_to_buffer_next_buffer_to_read(void)
317 /* If there is busy_buffer first release it */
319 result = driver_to_buffer_release();
324 /* If there is no buffers to read, return E_SD_NO_DATA_TO_READ.
325 * SHOULD BE POSITIVE, cause there is no real error. */
326 if (!something_to_read()) {
327 return E_SD_NO_DATA_TO_READ;
330 /* Get next buffer to read */
331 result = driver_to_buffer_get();
333 print_err("buffer_to_reads > 0, but there are no buffers to read\n");
337 /* Decrement buffers_to_read counter */
338 dec_buffers_to_read();