Blame view
drivers/video/fb_defio.c
6.2 KB
60b59beaf fbdev: mm: Deferr... |
1 2 3 4 5 6 |
/* * linux/drivers/video/fb_defio.c * * Copyright (C) 2006 Jaya Kumar * * This file is subject to the terms and conditions of the GNU General Public |
de7c6d15e fbdev: defio and ... |
7 |
* License. See the file COPYING in the main directory of this archive |
60b59beaf fbdev: mm: Deferr... |
8 9 10 11 12 13 14 15 |
* for more details. */ #include <linux/module.h> #include <linux/kernel.h> #include <linux/errno.h> #include <linux/string.h> #include <linux/mm.h> |
60b59beaf fbdev: mm: Deferr... |
16 17 18 19 20 |
#include <linux/vmalloc.h> #include <linux/delay.h> #include <linux/interrupt.h> #include <linux/fb.h> #include <linux/list.h> |
60b59beaf fbdev: mm: Deferr... |
21 22 23 24 |
/* to support deferred IO */ #include <linux/rmap.h> #include <linux/pagemap.h> |
37b483795 video: deferred i... |
25 26 27 28 29 30 31 32 33 34 35 36 |
struct page *fb_deferred_io_page(struct fb_info *info, unsigned long offs) { void *screen_base = (void __force *) info->screen_base; struct page *page; if (is_vmalloc_addr(screen_base + offs)) page = vmalloc_to_page(screen_base + offs); else page = pfn_to_page((info->fix.smem_start + offs) >> PAGE_SHIFT); return page; } |
60b59beaf fbdev: mm: Deferr... |
37 |
/* this is to find and return the vmalloc-ed fb pages */ |
529e55b6a fb: defio nopage |
38 39 |
static int fb_deferred_io_fault(struct vm_area_struct *vma, struct vm_fault *vmf) |
60b59beaf fbdev: mm: Deferr... |
40 41 42 43 |
{ unsigned long offset; struct page *page; struct fb_info *info = vma->vm_private_data; |
529e55b6a fb: defio nopage |
44 |
offset = vmf->pgoff << PAGE_SHIFT; |
60b59beaf fbdev: mm: Deferr... |
45 |
if (offset >= info->fix.smem_len) |
529e55b6a fb: defio nopage |
46 |
return VM_FAULT_SIGBUS; |
60b59beaf fbdev: mm: Deferr... |
47 |
|
37b483795 video: deferred i... |
48 |
page = fb_deferred_io_page(info, offset); |
60b59beaf fbdev: mm: Deferr... |
49 |
if (!page) |
529e55b6a fb: defio nopage |
50 |
return VM_FAULT_SIGBUS; |
60b59beaf fbdev: mm: Deferr... |
51 52 |
get_page(page); |
de7c6d15e fbdev: defio and ... |
53 54 55 56 57 58 59 60 61 |
if (vma->vm_file) page->mapping = vma->vm_file->f_mapping; else printk(KERN_ERR "no mapping available "); BUG_ON(!page->mapping); page->index = vmf->pgoff; |
529e55b6a fb: defio nopage |
62 63 |
vmf->page = page; return 0; |
60b59beaf fbdev: mm: Deferr... |
64 |
} |
02c24a821 fs: push i_mutex ... |
65 |
int fb_deferred_io_fsync(struct file *file, loff_t start, loff_t end, int datasync) |
5e841b88d fb: fsync() metho... |
66 67 |
{ struct fb_info *info = file->private_data; |
02c24a821 fs: push i_mutex ... |
68 69 70 71 |
struct inode *inode = file->f_path.dentry->d_inode; int err = filemap_write_and_wait_range(inode->i_mapping, start, end); if (err) return err; |
5e841b88d fb: fsync() metho... |
72 |
|
94e2bd688 tree-wide: fix so... |
73 |
/* Skip if deferred io is compiled-in but disabled on this fbdev */ |
87884bd8a video: fix deferr... |
74 75 |
if (!info->fbdefio) return 0; |
02c24a821 fs: push i_mutex ... |
76 |
mutex_lock(&inode->i_mutex); |
5e841b88d fb: fsync() metho... |
77 |
/* Kill off the delayed work */ |
afe2c511f workqueue: conver... |
78 |
cancel_delayed_work_sync(&info->deferred_work); |
5e841b88d fb: fsync() metho... |
79 80 |
/* Run it immediately */ |
02c24a821 fs: push i_mutex ... |
81 82 83 |
err = schedule_delayed_work(&info->deferred_work, 0); mutex_unlock(&inode->i_mutex); return err; |
5e841b88d fb: fsync() metho... |
84 85 |
} EXPORT_SYMBOL_GPL(fb_deferred_io_fsync); |
60b59beaf fbdev: mm: Deferr... |
86 |
/* vm_ops->page_mkwrite handler */ |
7bf1ea33a make fb_deferred_... |
87 |
static int fb_deferred_io_mkwrite(struct vm_area_struct *vma, |
c2ec175c3 mm: page_mkwrite ... |
88 |
struct vm_fault *vmf) |
60b59beaf fbdev: mm: Deferr... |
89 |
{ |
c2ec175c3 mm: page_mkwrite ... |
90 |
struct page *page = vmf->page; |
60b59beaf fbdev: mm: Deferr... |
91 92 |
struct fb_info *info = vma->vm_private_data; struct fb_deferred_io *fbdefio = info->fbdefio; |
f31ad92f3 fbdev: bugfix for... |
93 |
struct page *cur; |
60b59beaf fbdev: mm: Deferr... |
94 95 96 97 98 99 100 101 102 |
/* this is a callback we get when userspace first tries to write to the page. we schedule a workqueue. that workqueue will eventually mkclean the touched pages and execute the deferred framebuffer IO. then if userspace touches a page again, we repeat the same scheme */ /* protect against the workqueue changing the page list */ mutex_lock(&fbdefio->lock); |
f31ad92f3 fbdev: bugfix for... |
103 |
|
d6d03f915 fb_defio: redo fi... |
104 105 106 107 108 109 110 111 112 |
/* * We want the page to remain locked from ->page_mkwrite until * the PTE is marked dirty to avoid page_mkclean() being called * before the PTE is updated, which would leave the page ignored * by defio. * Do this by locking the page here and informing the caller * about it with VM_FAULT_LOCKED. */ lock_page(page); |
f31ad92f3 fbdev: bugfix for... |
113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 |
/* we loop through the pagelist before adding in order to keep the pagelist sorted */ list_for_each_entry(cur, &fbdefio->pagelist, lru) { /* this check is to catch the case where a new process could start writing to the same page through a new pte. this new access can cause the mkwrite even when the original ps's pte is marked writable */ if (unlikely(cur == page)) goto page_already_added; else if (cur->index > page->index) break; } list_add_tail(&page->lru, &cur->lru); page_already_added: |
60b59beaf fbdev: mm: Deferr... |
130 131 132 133 |
mutex_unlock(&fbdefio->lock); /* come back after delay to process the deferred IO */ schedule_delayed_work(&info->deferred_work, fbdefio->delay); |
d6d03f915 fb_defio: redo fi... |
134 |
return VM_FAULT_LOCKED; |
60b59beaf fbdev: mm: Deferr... |
135 |
} |
f0f37e2f7 const: mark struc... |
136 |
static const struct vm_operations_struct fb_deferred_io_vm_ops = { |
529e55b6a fb: defio nopage |
137 |
.fault = fb_deferred_io_fault, |
60b59beaf fbdev: mm: Deferr... |
138 139 |
.page_mkwrite = fb_deferred_io_mkwrite, }; |
d847471d0 fbdefio: add set_... |
140 141 142 143 144 145 146 147 148 149 |
static int fb_deferred_io_set_page_dirty(struct page *page) { if (!PageDirty(page)) SetPageDirty(page); return 0; } static const struct address_space_operations fb_deferred_io_aops = { .set_page_dirty = fb_deferred_io_set_page_dirty, }; |
60b59beaf fbdev: mm: Deferr... |
150 151 152 |
static int fb_deferred_io_mmap(struct fb_info *info, struct vm_area_struct *vma) { vma->vm_ops = &fb_deferred_io_vm_ops; |
7164bb439 fb-defio: If FBIN... |
153 154 155 |
vma->vm_flags |= ( VM_RESERVED | VM_DONTEXPAND ); if (!(info->flags & FBINFO_VIRTFB)) vma->vm_flags |= VM_IO; |
60b59beaf fbdev: mm: Deferr... |
156 157 158 159 160 161 162 163 164 |
vma->vm_private_data = info; return 0; } /* workqueue callback */ static void fb_deferred_io_work(struct work_struct *work) { struct fb_info *info = container_of(work, struct fb_info, deferred_work.work); |
3f505ca45 Revert "fb_defio:... |
165 166 |
struct list_head *node, *next; struct page *cur; |
60b59beaf fbdev: mm: Deferr... |
167 168 169 170 |
struct fb_deferred_io *fbdefio = info->fbdefio; /* here we mkclean the pages, then do all deferred IO */ mutex_lock(&fbdefio->lock); |
3f505ca45 Revert "fb_defio:... |
171 172 173 174 |
list_for_each_entry(cur, &fbdefio->pagelist, lru) { lock_page(cur); page_mkclean(cur); unlock_page(cur); |
60b59beaf fbdev: mm: Deferr... |
175 176 177 178 |
} /* driver's callback with pagelist */ fbdefio->deferred_io(info, &fbdefio->pagelist); |
3f505ca45 Revert "fb_defio:... |
179 180 |
/* clear the list */ list_for_each_safe(node, next, &fbdefio->pagelist) { |
60b59beaf fbdev: mm: Deferr... |
181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 |
list_del(node); } mutex_unlock(&fbdefio->lock); } void fb_deferred_io_init(struct fb_info *info) { struct fb_deferred_io *fbdefio = info->fbdefio; BUG_ON(!fbdefio); mutex_init(&fbdefio->lock); info->fbops->fb_mmap = fb_deferred_io_mmap; INIT_DELAYED_WORK(&info->deferred_work, fb_deferred_io_work); INIT_LIST_HEAD(&fbdefio->pagelist); if (fbdefio->delay == 0) /* set a default of 1 s */ fbdefio->delay = HZ; } EXPORT_SYMBOL_GPL(fb_deferred_io_init); |
d847471d0 fbdefio: add set_... |
199 200 201 202 203 204 205 |
void fb_deferred_io_open(struct fb_info *info, struct inode *inode, struct file *file) { file->f_mapping->a_ops = &fb_deferred_io_aops; } EXPORT_SYMBOL_GPL(fb_deferred_io_open); |
60b59beaf fbdev: mm: Deferr... |
206 207 208 |
void fb_deferred_io_cleanup(struct fb_info *info) { struct fb_deferred_io *fbdefio = info->fbdefio; |
de7c6d15e fbdev: defio and ... |
209 210 |
struct page *page; int i; |
60b59beaf fbdev: mm: Deferr... |
211 212 |
BUG_ON(!fbdefio); |
181b74ef7 video: don't use ... |
213 |
cancel_delayed_work_sync(&info->deferred_work); |
de7c6d15e fbdev: defio and ... |
214 215 216 |
/* clear out the mapping that we setup */ for (i = 0 ; i < info->fix.smem_len; i += PAGE_SIZE) { |
37b483795 video: deferred i... |
217 |
page = fb_deferred_io_page(info, i); |
de7c6d15e fbdev: defio and ... |
218 219 |
page->mapping = NULL; } |
6e1038a95 video: deferred i... |
220 221 222 |
info->fbops->fb_mmap = NULL; mutex_destroy(&fbdefio->lock); |
60b59beaf fbdev: mm: Deferr... |
223 224 225 226 |
} EXPORT_SYMBOL_GPL(fb_deferred_io_cleanup); MODULE_LICENSE("GPL"); |