Lines Matching refs:buffer
58 static int fill_read_buffer(struct file *file, struct configfs_buffer *buffer)
63 if (!buffer->page)
64 buffer->page = (char *) get_zeroed_page(GFP_KERNEL);
65 if (!buffer->page)
70 count = buffer->attr->show(buffer->item, buffer->page);
77 buffer->needs_read_fill = 0;
78 buffer->count = count;
85 * @buf: buffer to fill.
93 * We call fill_read_buffer() to allocate and fill the buffer from the
95 * the beginning of the file). That should fill the entire buffer with
97 * We then call flush_read_buffer() to copy the buffer to userspace
104 struct configfs_buffer *buffer = file->private_data;
107 mutex_lock(&buffer->mutex);
108 if (buffer->needs_read_fill) {
109 retval = fill_read_buffer(file, buffer);
114 __func__, count, *ppos, buffer->page);
115 retval = simple_read_from_buffer(buf, count, ppos, buffer->page,
116 buffer->count);
118 mutex_unlock(&buffer->mutex);
125 * @buf: buffer to fill.
133 * We check whether we need to refill the buffer. If so we will
135 * will pass a NULL as a buffer pointer, which the attributes' method
136 * will use to return the size of the buffer required. If no error
137 * occurs we will allocate the buffer using vmalloc and call
138 * attr->read() again passing that buffer as an argument.
147 struct configfs_buffer *buffer = file->private_data;
151 mutex_lock(&buffer->mutex);
154 if (buffer->write_in_progress) {
158 buffer->read_in_progress = true;
160 if (buffer->needs_read_fill) {
164 len = buffer->bin_attr->read(buffer->item, NULL, 0);
174 if (buffer->cb_max_size && len > buffer->cb_max_size) {
179 buffer->bin_buffer = vmalloc(len);
180 if (buffer->bin_buffer == NULL) {
184 buffer->bin_buffer_size = len;
186 /* perform second read to fill buffer */
189 len = buffer->bin_attr->read(buffer->item,
190 buffer->bin_buffer, len);
196 vfree(buffer->bin_buffer);
197 buffer->bin_buffer_size = 0;
198 buffer->bin_buffer = NULL;
202 buffer->needs_read_fill = 0;
205 retval = simple_read_from_buffer(buf, count, ppos, buffer->bin_buffer,
206 buffer->bin_buffer_size);
208 mutex_unlock(&buffer->mutex);
214 * fill_write_buffer - copy buffer from userspace.
215 * @buffer: data buffer for file.
219 * Allocate @buffer->page if it hasn't been already, then
220 * copy the user-supplied buffer into it.
224 fill_write_buffer(struct configfs_buffer * buffer, const char __user * buf, size_t count)
228 if (!buffer->page)
229 buffer->page = (char *)__get_free_pages(GFP_KERNEL, 0);
230 if (!buffer->page)
235 error = copy_from_user(buffer->page,buf,count);
236 buffer->needs_read_fill = 1;
239 buffer->page[count] = 0;
244 flush_write_buffer(struct file *file, struct configfs_buffer *buffer, size_t count)
251 res = buffer->attr->store(buffer->item, buffer->page, count);
268 * write, so we don't support them. We expect the entire buffer to come
271 * the value you're changing, then write entire buffer back.
277 struct configfs_buffer *buffer = file->private_data;
280 mutex_lock(&buffer->mutex);
281 len = fill_write_buffer(buffer, buf, count);
283 len = flush_write_buffer(file, buffer, len);
286 mutex_unlock(&buffer->mutex);
298 * We buffer the consecutive writes (binary attribute files do not
299 * support lseek) in a continuously growing buffer, but we don't
307 struct configfs_buffer *buffer = file->private_data;
311 mutex_lock(&buffer->mutex);
314 if (buffer->read_in_progress) {
318 buffer->write_in_progress = true;
320 /* buffer grows? */
321 if (*ppos + count > buffer->bin_buffer_size) {
323 if (buffer->cb_max_size &&
324 *ppos + count > buffer->cb_max_size) {
336 if (buffer->bin_buffer) {
337 memcpy(tbuf, buffer->bin_buffer,
338 buffer->bin_buffer_size);
339 vfree(buffer->bin_buffer);
343 memset(tbuf + buffer->bin_buffer_size, 0,
344 *ppos + count - buffer->bin_buffer_size);
345 buffer->bin_buffer = tbuf;
346 buffer->bin_buffer_size = *ppos + count;
349 len = simple_write_to_buffer(buffer->bin_buffer,
350 buffer->bin_buffer_size, ppos, buf, count);
352 mutex_unlock(&buffer->mutex);
361 struct configfs_buffer *buffer;
365 buffer = kzalloc(sizeof(struct configfs_buffer), GFP_KERNEL);
366 if (!buffer)
375 buffer->item = to_item(dentry->d_parent);
376 if (!buffer->item)
384 buffer->bin_attr = to_bin_attr(dentry);
385 buffer->cb_max_size = buffer->bin_attr->cb_max_size;
387 buffer->attr = attr;
390 buffer->owner = attr->ca_owner;
393 if (!try_module_get(buffer->owner))
397 if (!buffer->item->ci_type)
400 buffer->ops = buffer->item->ci_type->ct_item_ops;
411 if ((type & CONFIGFS_ITEM_BIN_ATTR) && !buffer->bin_attr->write)
424 if ((type & CONFIGFS_ITEM_BIN_ATTR) && !buffer->bin_attr->read)
428 mutex_init(&buffer->mutex);
429 buffer->needs_read_fill = 1;
430 buffer->read_in_progress = false;
431 buffer->write_in_progress = false;
432 file->private_data = buffer;
437 module_put(buffer->owner);
440 kfree(buffer);
447 struct configfs_buffer *buffer = filp->private_data;
449 module_put(buffer->owner);
450 if (buffer->page)
451 free_page((unsigned long)buffer->page);
452 mutex_destroy(&buffer->mutex);
453 kfree(buffer);
469 struct configfs_buffer *buffer = file->private_data;
471 buffer->read_in_progress = false;
473 if (buffer->write_in_progress) {
475 buffer->write_in_progress = false;
480 buffer->bin_attr->write(buffer->item,
481 buffer->bin_buffer,
482 buffer->bin_buffer_size);
487 vfree(buffer->bin_buffer);
488 buffer->bin_buffer = NULL;
489 buffer->bin_buffer_size = 0;
490 buffer->needs_read_fill = 1;