fb_write unaligned writes
Subsystems (2)
Hi,
I came across a problem in fb_write (drivers/video/fbmem.c) which doesn't make any effort to avoid unaligned writes. It copies up to a page at a time from userspace into a buffer, then fb_writel's as much as possible from the buffer into the framebuffer, then fb_writeb's any remaining bytes. However on architectures which don't perform unaligned writes this can cause a bus error or silently fail when it tries to fb_writel to an unaligned framebuffer position.
My question is how best should this be fixed? I know I could avoid writing more than 3 bytes to an unaligned framebuffer offset, but the standard write syscall should be able to handle this, and Documentation/unaligned-memory- access.txt makes it clear that unaligned accesses are to be avoided and with good reason.
Is it possible to just copy_from_user straight into the framebuffer, or should I define an fb_memcpy to go with the other definitions around line 925 of include/linux/fb.h, or something else?
Thanks
James
Hi,
Quoted 16 lines · James Hogan
Hi,
I came across a problem in
fb_write(drivers/video/fbmem.c) which doesn't make any effort to avoid unaligned writes. It copies up to a page at a time from userspace into a buffer, then fb_writel's as much as possible from the buffer into the framebuffer, then fb_writeb's any remaining bytes. However on architectures which don't perform unaligned writes this can cause a bus error or silently fail when it tries tofb_writelto an unaligned framebuffer position.My question is how best should this be fixed? I know I could avoid writing more than 3 bytes to an unaligned framebuffer offset, but the standard write syscall should be able to handle this, and
Documentation/unaligned-memory-access.txt makes it clear that unaligned accesses are to be avoided and with good reason.
Quoted 3 lines
Is it possible to just
copy_from_userstraight into the framebuffer, or should I define anfb_memcpyto go with the other definitions around line 925 ofinclude/linux/fb.h, or something else?
Just doing copy_from_user straight into the framebuffer sounds like the right thing to me but my knowledge is limited to x86. As far as I can see this would make the functions (doing the same for fb_read can't hurt, can it?) in fbmem.c very similar to those in fb_sys_fops.c. Most users of the later functions can be easily eliminated as simply removing ".fb_{read,write} = fb_sys_{read,write}" is sufficient, only xen-fbfront.c looks more difficult as it also refreshes the screen so I'd suggest the following:
Merging fb_sys_fops.c in fbmem.c, adjusting the fb_{read,write} functions to use the the fb_sys_{read,write} copying and removing all trivial uses of fb_sys_{read,write}. As far as I can see this should solve your problem and would be a cleanup at the same time.
But it would be good if someone who knows other archs (especially sparc as they currently seem to perform some assembler that I can't decipher) could comment on this topic.
Thanks,
Florian Tobias Schandinat
PATCH 1/1 fbmem: Fix fb_read, fb_write unaligned accesses.
In reply to James HoganComments? I'd also appreciate if somebody familiar with sbus on sparc could check this patch is sane since I know virtually nothing about sbus and am not in a position to compile for sparc, let alone test on it:
fb_{read,write} access the framebuffer using lots of fb_{read,write}l's but don't check that the file position is aligned which can cause problems on some architectures which do not support unaligned accesses.
Since the operations are essentially memcpy_{from,to}io, new fb_memcpy_{from,to}fb macros have been defined and these are used instead.
For Sparc, fb_{read,write} macros use sbus_{read,write}, so this defines new sbus_memcpy_{from,to}io functions the same as memcpy_{from,to}io but using sbus_{read,write}b instead of {read,write}b.
--- arch/sparc/include/asm/io_32.h | 31 +++++++++++++++++++++++++++ arch/sparc/include/asm/io_64.h | 31 +++++++++++++++++++++++++++ drivers/video/fbmem.c | 46 ++++++++++++--------------------------- include/linux/fb.h | 6 +++++ 4 files changed, 82 insertions(+), 32 deletions(-)
arch/sparc/include/asm/io_32.h +15 -0
@@ -208,6 +208,21 @@ _memset_io(volatile void __iomem *dst, int c, __kernel_size_t n)#define memset_io (d,c,sz) _memset_io(d,c,sz)static inline void +_sbus_memcpy_fromio (void *dst,const volatile void __iomem *src, +__kernel_size_t n) +{ +char *d = dst; + +while (n--) { +char tmp =sbus_readb (src); + *d++ = tmp; + src++; + } +} + +#define sbus_memcpy_fromio (d, s, sz) _sbus_memcpy_fromio(d, s, sz) + +static inline void _memcpy_fromio (void *dst,const volatile void __iomem *src,__kernel_size_t n) {char *d = dst;
@@ -222,6 +237,22 @@ _memcpy_fromio(void *dst, const volatile void __iomem *src,
__kernel_size_t n)
#define memcpy_fromio(d,s,sz) _memcpy_fromio(d,s,sz)
static inline void
+_sbus_memcpy_toio(volatile void __iomem *dst, const void *src,
+ __kernel_size_t n)
+{
+ const char *s = src;
+ volatile void __iomem *d = dst;
+
+ while (n--) {
+ char tmp = *s++;
+ sbus_writeb(tmp, d);
+ d++;
+ }
+}
+
+#define sbus_memcpy_toio(d, s, sz) _sbus_memcpy_toio(d, s, sz)
+
+static inline void
_memcpy_toio(volatile void __iomem *dst, const void *src, __kernel_size_t n) {
const char *s = src;
arch/sparc/include/asm/io_64.h +15 -0
@@ -419,6 +419,21 @@ _memset_io(volatile void __iomem *dst, int c, __kernel_size_t n)#define memset_io (d,c,sz) _memset_io(d,c,sz)static inline void +_sbus_memcpy_fromio (void *dst,const volatile void __iomem *src, +__kernel_size_t n) +{ +char *d = dst; + +while (n--) { +char tmp =sbus_readb (src); + *d++ = tmp; + src++; + } +} + +#define sbus_memcpy_fromio (d, s, sz) _sbus_memcpy_fromio(d, s, sz) + +static inline void _memcpy_fromio (void *dst,const volatile void __iomem *src,__kernel_size_t n) {char *d = dst;
@@ -433,6 +448,22 @@ _memcpy_fromio(void *dst, const volatile void __iomem *src,
__kernel_size_t n)
#define memcpy_fromio(d,s,sz) _memcpy_fromio(d,s,sz)
static inline void
+_sbus_memcpy_toio(volatile void __iomem *dst, const void *src,
+ __kernel_size_t n)
+{
+ const char *s = src;
+ volatile void __iomem *d = dst;
+
+ while (n--) {
+ char tmp = *s++;
+ sbus_writeb(tmp, d);
+ d++;
+ }
+}
+
+#define sbus_memcpy_toio(d, s, sz) _sbus_memcpy_toio(d, s, sz)
+
+static inline void
_memcpy_toio(volatile void __iomem *dst, const void *src, __kernel_size_t n) {
const char *s = src;
drivers/video/fbmem.c +0 -0
@@ -697,9 +697,9 @@ fb_read(struct file *file, char __user *buf, size_t count, loff_t
*ppos)
struct inode *inode = file->f_path.dentry->d_inode; int fbidx = iminor(inode);
struct fb_info *info = registered_fb[fbidx];
- u32 *buffer, *dst;
- u32 __iomem *src;
- int c, i, cnt = 0, err = 0;
+ u8 *buffer, *dst;
+ u8 __iomem *src;
+ int c, cnt = 0, err = 0;
unsigned long total_size;
if (!info || ! info->screen_base)
@@ -730,7 +730,7 @@ fb_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
if (!buffer)
return -ENOMEM;
- src = (u32 __iomem *) (info->screen_base + p);
+ src = (u8 __iomem *) (info->screen_base + p);
if (info->fbops->fb_sync)
info->fbops->fb_sync(info);
@@ -738,17 +738,9 @@ fb_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
while (count) {
c = (count > PAGE_SIZE) ? PAGE_SIZE : count;
dst = buffer;
- for (i = c >> 2; i--; )
- *dst++ = fb_readl(src++);
- if (c & 3) {
- u8 *dst8 = (u8 *) dst;
- u8 __iomem *src8 = (u8 __iomem *) src;
-
- for (i = c & 3; i--;)
- *dst8++ = fb_readb(src8++);
-
- src = (u32 __iomem *) src8;
- }
+ fb_memcpy_fromfb(dst, src, c);
+ dst += c;
+ src += c;
if (copy_to_user(buf, buffer, c)) {
err = -EFAULT;
@@ -772,9 +764,9 @@ fb_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
struct inode *inode = file->f_path.dentry->d_inode;
int fbidx = iminor(inode);
struct fb_info *info = registered_fb[fbidx];
- u32 *buffer, *src;
- u32 __iomem *dst;
- int c, i, cnt = 0, err = 0;
+ u8 *buffer, *src;
+ u8 __iomem *dst;
+ int c, cnt = 0, err = 0;
unsigned long total_size;
if (!info || !info->screen_base)
@@ -811,7 +803,7 @@ fb_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
if (!buffer)
return -ENOMEM;
- dst = (u32 __iomem *) (info->screen_base + p);
+ dst = (u8 __iomem *) (info->screen_base + p);
if (info->fbops->fb_sync)
info->fbops->fb_sync(info);
@@ -825,19 +817,9 @@ fb_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
break;
}
- for (i = c >> 2; i--; )
- fb_writel(*src++, dst++);
-
- if (c & 3) {
- u8 *src8 = (u8 *) src;
- u8 __iomem *dst8 = (u8 __iomem *) dst;
-
- for (i = c & 3; i--; )
- fb_writeb(*src8++, dst8++);
-
- dst = (u32 __iomem *) dst8;
- }
-
+ fb_memcpy_tofb(dst, src, c);
+ dst += c;
+ src += c;
*ppos += c;
buf += c;
cnt += c;
include/linux/fb.h +0 -0
@@ -931,6 +931,8 @@ static inline struct apertures_struct *alloc_apertures(unsigned int
max_num) {
#define fb_writel sbus_writel
#define fb_writeq sbus_writeq
#define fb_memset sbus_memset_io
+#define fb_memcpy_fromfb sbus_memcpy_fromio
+#define fb_memcpy_tofb sbus_memcpy_toio
#elif defined(__i386__) || defined(__alpha__) || defined(__x86_64__) ||defined(__hppa__) || defined(__sh__) || defined(__powerpc__) || defined(__avr32__) || defined(__bfin__)
@@ -943,6 +945,8 @@ static inline struct apertures_struct *alloc_apertures(unsigned int max_num) {
#define fb_writel __raw_writel
#define fb_writeq __raw_writeq
#define fb_memset memset_io
+#define fb_memcpy_fromfb memcpy_fromio
+#define fb_memcpy_tofb memcpy_toio
#else
@@ -955,6 +959,8 @@ static inline struct apertures_struct *alloc_apertures(unsigned int max_num) {
#define fb_writel(b,addr) (*(volatile u32 *) (addr) = (b))
#define fb_writeq(b,addr) (*(volatile u64 *) (addr) = (b))
#define fb_memset memset
+#define fb_memcpy_fromfb memcpy
+#define fb_memcpy_tofb memcpy
#endif
Signature · 1 line
1.7.2.3
David Miller
maintainerRe: [PATCH] fbmem: Fix fb_read, fb_write unaligned accesses.
Nobody can test your patch because your email client corrupted it, by breaking up long lines.
Thanks for the response Florian,
Quoted 18 lines
Quoted 14 lines
I came across a problem in
fb_write(drivers/video/fbmem.c) which doesn't make any effort to avoid unaligned writes. It copies up to a page at a time from userspace into a buffer, then fb_writel's as much as possible from the buffer into the framebuffer, then fb_writeb's any remaining bytes. However on architectures which don't perform unaligned writes this can cause a bus error or silently fail when it tries tofb_writelto an unaligned framebuffer position.My question is how best should this be fixed? I know I could avoid writing more than 3 bytes to an unaligned framebuffer offset, but the standard write syscall should be able to handle this, and
Documentation/unaligned-memory-access.txt makes it clear that unaligned accesses are to be avoided and with good reason.Quoted 3 lines
Is it possible to just
copy_from_userstraight into the framebuffer, or should I define anfb_memcpyto go with the other definitions around line 925 ofinclude/linux/fb.h, or something else?
Quoted 8 lines
Just doing
copy_from_userstraight into the framebuffer sounds like the right thing to me but my knowledge is limited to x86. As far as I can see this would make the functions (doing the same forfb_readcan't hurt, can it?) infbmem.cvery similar to those infb_sys_fops.c. Most users of the later functions can be easily eliminated as simply removing ".fb_{read,write} = fb_sys_{read,write}" is sufficient, onlyxen-fbfront.clooks more difficult as it also refreshes the screen so I'd suggest the following:
Yes, I noticed fb_read has the same issue after I sent the first email. Having looked a bit deeper though I'm not so sure copy_from_user straight into iomem is a good idea, since as far as I can see iomem isn't necessarily readable or writeable in the normal way (c pointer dereferences) on all architectures.
Cheers
James