• Jiri Olsa's avatar
    x86, 64-bit: Fix copy_[to/from]_user() checks for the userspace address limit · 26afb7c6
    Jiri Olsa authored
    As reported in BZ #30352:
    
      https://bugzilla.kernel.org/show_bug.cgi?id=30352
    
    there's a kernel bug related to reading the last allowed page on x86_64.
    
    The _copy_to_user() and _copy_from_user() functions use the following
    check for address limit:
    
      if (buf + size >= limit)
    	fail();
    
    while it should be more permissive:
    
      if (buf + size > limit)
    	fail();
    
    That's because the size represents the number of bytes being
    read/write from/to buf address AND including the buf address.
    So the copy function will actually never touch the limit
    address even if "buf + size == limit".
    
    Following program fails to use the last page as buffer
    due to the wrong limit check:
    
     #include <sys/mman.h>
     #include <sys/socket.h>
     #include <assert.h>
    
     #define PAGE_SIZE       (4096)
     #define LAST_PAGE       ((void*)(0x7fffffffe000))
    
     int main()
     {
            int fds[2], err;
            void * ptr = mmap(LAST_PAGE, PAGE_SIZE, PROT_READ | PROT_WRITE,
                              MAP_ANONYMOUS | MAP_PRIVATE | MAP_FIXED, -1, 0);
            assert(ptr == LAST_PAGE);
            err = socketpair(AF_LOCAL, SOCK_STREAM, 0, fds);
            assert(err == 0);
            err = send(fds[0], ptr, PAGE_SIZE, 0);
            perror("send");
            assert(err == PAGE_SIZE);
            err = recv(fds[1], ptr, PAGE_SIZE, MSG_WAITALL);
            perror("recv");
            assert(err == PAGE_SIZE);
            return 0;
     }
    
    The other place checking the addr limit is the access_ok() function,
    which is working properly. There's just a misleading comment
    for the __range_not_ok() macro - which this patch fixes as well.
    
    The last page of the user-space address range is a guard page and
    Brian Gerst observed that the guard page itself due to an erratum on K8 cpus
    (#121 Sequential Execution Across Non-Canonical Boundary Causes Processor
    Hang).
    
    However, the test code is using the last valid page before the guard page.
    The bug is that the last byte before the guard page can't be read
    because of the off-by-one error. The guard page is left in place.
    
    This bug would normally not show up because the last page is
    part of the process stack and never accessed via syscalls.
    Signed-off-by: default avatarJiri Olsa <jolsa@redhat.com>
    Acked-by: default avatarBrian Gerst <brgerst@gmail.com>
    Acked-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
    Cc: <stable@kernel.org>
    Link: http://lkml.kernel.org/r/1305210630-7136-1-git-send-email-jolsa@redhat.comSigned-off-by: default avatarIngo Molnar <mingo@elte.hu>
    26afb7c6
copy_user_64.S 6.04 KB