diff --git a/[refs] b/[refs] index 207b8ac133b3..6cb4cd7b2c98 100644 --- a/[refs] +++ b/[refs] @@ -1,2 +1,2 @@ --- -refs/heads/master: 293a032eb95f3c6c212c1541e94c14b111731313 +refs/heads/master: b47e8608a08766ef8121cd747d3aaf6c3dc22649 diff --git a/trunk/CREDITS b/trunk/CREDITS index 832436e1dd91..10c214dc95e7 100644 --- a/trunk/CREDITS +++ b/trunk/CREDITS @@ -966,7 +966,6 @@ N: Pekka Enberg E: penberg@cs.helsinki.fi W: http://www.cs.helsinki.fi/u/penberg/ D: Various kernel hacks, fixes, and cleanups. -D: Slab allocators S: Finland N: David Engebretsen @@ -1940,8 +1939,8 @@ D: for Menuconfig's lxdialog. N: Christoph Lameter E: christoph@lameter.com D: Digiboard PC/Xe and PC/Xi, Digiboard EPCA -D: NUMA support, Slab allocators, Page migration -D: Scalability, Time subsystem +D: Early protocol filter for bridging code +D: Bug fixes N: Paul Laufer E: paul@laufernet.com diff --git a/trunk/Documentation/lguest/extract b/trunk/Documentation/lguest/extract deleted file mode 100644 index 7730bb6e4b94..000000000000 --- a/trunk/Documentation/lguest/extract +++ /dev/null @@ -1,58 +0,0 @@ -#! /bin/sh - -set -e - -PREFIX=$1 -shift - -trap 'rm -r $TMPDIR' 0 -TMPDIR=`mktemp -d` - -exec 3>/dev/null -for f; do - while IFS=" -" read -r LINE; do - case "$LINE" in - *$PREFIX:[0-9]*:\**) - NUM=`echo "$LINE" | sed "s/.*$PREFIX:\([0-9]*\).*/\1/"` - if [ -f $TMPDIR/$NUM ]; then - echo "$TMPDIR/$NUM already exits prior to $f" - exit 1 - fi - exec 3>>$TMPDIR/$NUM - echo $f | sed 's,\.\./,,g' > $TMPDIR/.$NUM - /bin/echo "$LINE" | sed -e "s/$PREFIX:[0-9]*//" -e "s/:\*/*/" >&3 - ;; - *$PREFIX:[0-9]*) - NUM=`echo "$LINE" | sed "s/.*$PREFIX:\([0-9]*\).*/\1/"` - if [ -f $TMPDIR/$NUM ]; then - echo "$TMPDIR/$NUM already exits prior to $f" - exit 1 - fi - exec 3>>$TMPDIR/$NUM - echo $f | sed 's,\.\./,,g' > $TMPDIR/.$NUM - /bin/echo "$LINE" | sed "s/$PREFIX:[0-9]*//" >&3 - ;; - *:\**) - /bin/echo "$LINE" | sed -e "s/:\*/*/" -e "s,/\*\*/,," >&3 - echo >&3 - exec 3>/dev/null - ;; - *) - /bin/echo "$LINE" >&3 - ;; - esac - done < $f - echo >&3 - exec 3>/dev/null -done - -LASTFILE="" -for f in $TMPDIR/*; do - if [ "$LASTFILE" != $(cat $TMPDIR/.$(basename $f) ) ]; then - LASTFILE=$(cat $TMPDIR/.$(basename $f) ) - echo "[ $LASTFILE ]" - fi - cat $f -done - diff --git a/trunk/Documentation/lguest/lguest.c b/trunk/Documentation/lguest/lguest.c index f7918401a007..62a8133393e1 100644 --- a/trunk/Documentation/lguest/lguest.c +++ b/trunk/Documentation/lguest/lguest.c @@ -1,10 +1,5 @@ -/*P:100 This is the Launcher code, a simple program which lays out the - * "physical" memory for the new Guest by mapping the kernel image and the - * virtual devices, then reads repeatedly from /dev/lguest to run the Guest. - * - * The only trick: the Makefile links it at a high address so it will be clear - * of the guest memory region. It means that each Guest cannot have more than - * about 2.5G of memory on a normally configured Host. :*/ +/* Simple program to layout "physical" memory for new lguest guest. + * Linked high to avoid likely physical memory. */ #define _LARGEFILE64_SOURCE #define _GNU_SOURCE #include @@ -34,20 +29,12 @@ #include #include #include -/*L:110 We can ignore the 28 include files we need for this program, but I do - * want to draw attention to the use of kernel-style types. - * - * As Linus said, "C is a Spartan language, and so should your naming be." I - * like these abbreviations and the header we need uses them, so we define them - * here. - */ typedef unsigned long long u64; typedef uint32_t u32; typedef uint16_t u16; typedef uint8_t u8; #include "../../include/linux/lguest_launcher.h" #include "../../include/asm-i386/e820.h" -/*:*/ #define PAGE_PRESENT 0x7 /* Present, RW, Execute */ #define NET_PEERNUM 1 @@ -56,52 +43,33 @@ typedef uint8_t u8; #define SIOCBRADDIF 0x89a2 /* add interface to bridge */ #endif -/*L:120 verbose is both a global flag and a macro. The C preprocessor allows - * this, and although I wouldn't recommend it, it works quite nicely here. */ static bool verbose; #define verbose(args...) \ do { if (verbose) printf(args); } while(0) -/*:*/ - -/* The pipe to send commands to the waker process */ static int waker_fd; -/* The top of guest physical memory. */ static u32 top; -/* This is our list of devices. */ struct device_list { - /* Summary information about the devices in our list: ready to pass to - * select() to ask which need servicing.*/ fd_set infds; int max_infd; - /* The descriptor page for the devices. */ struct lguest_device_desc *descs; - - /* A single linked list of devices. */ struct device *dev; - /* ... And an end pointer so we can easily append new devices */ struct device **lastdev; }; -/* The device structure describes a single device. */ struct device { - /* The linked-list pointer. */ struct device *next; - /* The descriptor for this device, as mapped into the Guest. */ struct lguest_device_desc *desc; - /* The memory page(s) of this device, if any. Also mapped in Guest. */ void *mem; - /* If handle_input is set, it wants to be called when this file - * descriptor is ready. */ + /* Watch this fd if handle_input non-NULL. */ int fd; bool (*handle_input)(int fd, struct device *me); - /* If handle_output is set, it wants to be called when the Guest sends - * DMA to this key. */ + /* Watch DMA to this key if handle_input non-NULL. */ unsigned long watch_key; u32 (*handle_output)(int fd, const struct iovec *iov, unsigned int num, struct device *me); @@ -110,11 +78,6 @@ struct device void *priv; }; -/*L:130 - * Loading the Kernel. - * - * We start with couple of simple helper routines. open_or_die() avoids - * error-checking code cluttering the callers: */ static int open_or_die(const char *name, int flags) { int fd = open(name, flags); @@ -123,38 +86,26 @@ static int open_or_die(const char *name, int flags) return fd; } -/* map_zeroed_pages() takes a (page-aligned) address and a number of pages. */ static void *map_zeroed_pages(unsigned long addr, unsigned int num) { - /* We cache the /dev/zero file-descriptor so we only open it once. */ static int fd = -1; if (fd == -1) fd = open_or_die("/dev/zero", O_RDONLY); - /* We use a private mapping (ie. if we write to the page, it will be - * copied), and obviously we insist that it be mapped where we ask. */ if (mmap((void *)addr, getpagesize() * num, PROT_READ|PROT_WRITE|PROT_EXEC, MAP_FIXED|MAP_PRIVATE, fd, 0) != (void *)addr) err(1, "Mmaping %u pages of /dev/zero @%p", num, (void *)addr); - - /* Returning the address is just a courtesy: can simplify callers. */ return (void *)addr; } -/* To find out where to start we look for the magic Guest string, which marks - * the code we see in lguest_asm.S. This is a hack which we are currently - * plotting to replace with the normal Linux entry point. */ +/* Find magic string marking entry point, return entry point. */ static unsigned long entry_point(void *start, void *end, unsigned long page_offset) { void *p; - /* The scan gives us the physical starting address. We want the - * virtual address in this case, and fortunately, we already figured - * out the physical-virtual difference and passed it here in - * "page_offset". */ for (p = start; p < end; p++) if (memcmp(p, "GenuineLguest", strlen("GenuineLguest")) == 0) return (long)p + strlen("GenuineLguest") + page_offset; @@ -162,17 +113,7 @@ static unsigned long entry_point(void *start, void *end, err(1, "Is this image a genuine lguest?"); } -/* This routine takes an open vmlinux image, which is in ELF, and maps it into - * the Guest memory. ELF = Embedded Linking Format, which is the format used - * by all modern binaries on Linux including the kernel. - * - * The ELF headers give *two* addresses: a physical address, and a virtual - * address. The Guest kernel expects to be placed in memory at the physical - * address, and the page tables set up so it will correspond to that virtual - * address. We return the difference between the virtual and physical - * addresses in the "page_offset" pointer. - * - * We return the starting address. */ +/* Returns the entry point */ static unsigned long map_elf(int elf_fd, const Elf32_Ehdr *ehdr, unsigned long *page_offset) { @@ -181,61 +122,40 @@ static unsigned long map_elf(int elf_fd, const Elf32_Ehdr *ehdr, unsigned int i; unsigned long start = -1UL, end = 0; - /* Sanity checks on the main ELF header: an x86 executable with a - * reasonable number of correctly-sized program headers. */ + /* Sanity checks. */ if (ehdr->e_type != ET_EXEC || ehdr->e_machine != EM_386 || ehdr->e_phentsize != sizeof(Elf32_Phdr) || ehdr->e_phnum < 1 || ehdr->e_phnum > 65536U/sizeof(Elf32_Phdr)) errx(1, "Malformed elf header"); - /* An ELF executable contains an ELF header and a number of "program" - * headers which indicate which parts ("segments") of the program to - * load where. */ - - /* We read in all the program headers at once: */ if (lseek(elf_fd, ehdr->e_phoff, SEEK_SET) < 0) err(1, "Seeking to program headers"); if (read(elf_fd, phdr, sizeof(phdr)) != sizeof(phdr)) err(1, "Reading program headers"); - /* We don't know page_offset yet. */ *page_offset = 0; - - /* Try all the headers: there are usually only three. A read-only one, - * a read-write one, and a "note" section which isn't loadable. */ + /* We map the loadable segments at virtual addresses corresponding + * to their physical addresses (our virtual == guest physical). */ for (i = 0; i < ehdr->e_phnum; i++) { - /* If this isn't a loadable segment, we ignore it */ if (phdr[i].p_type != PT_LOAD) continue; verbose("Section %i: size %i addr %p\n", i, phdr[i].p_memsz, (void *)phdr[i].p_paddr); - /* We expect a simple linear address space: every segment must - * have the same difference between virtual (p_vaddr) and - * physical (p_paddr) address. */ + /* We expect linear address space. */ if (!*page_offset) *page_offset = phdr[i].p_vaddr - phdr[i].p_paddr; else if (*page_offset != phdr[i].p_vaddr - phdr[i].p_paddr) errx(1, "Page offset of section %i different", i); - /* We track the first and last address we mapped, so we can - * tell entry_point() where to scan. */ if (phdr[i].p_paddr < start) start = phdr[i].p_paddr; if (phdr[i].p_paddr + phdr[i].p_filesz > end) end = phdr[i].p_paddr + phdr[i].p_filesz; - /* We map this section of the file at its physical address. We - * map it read & write even if the header says this segment is - * read-only. The kernel really wants to be writable: it - * patches its own instructions which would normally be - * read-only. - * - * MAP_PRIVATE means that the page won't be copied until a - * write is done to it. This allows us to share much of the - * kernel memory between Guests. */ + /* We map everything private, writable. */ addr = mmap((void *)phdr[i].p_paddr, phdr[i].p_filesz, PROT_READ|PROT_WRITE|PROT_EXEC, @@ -249,31 +169,7 @@ static unsigned long map_elf(int elf_fd, const Elf32_Ehdr *ehdr, return entry_point((void *)start, (void *)end, *page_offset); } -/*L:170 Prepare to be SHOCKED and AMAZED. And possibly a trifle nauseated. - * - * We know that CONFIG_PAGE_OFFSET sets what virtual address the kernel expects - * to be. We don't know what that option was, but we can figure it out - * approximately by looking at the addresses in the code. I chose the common - * case of reading a memory location into the %eax register: - * - * movl , %eax - * - * This gets encoded as five bytes: "0xA1 <4-byte-address>". For example, - * "0xA1 0x18 0x60 0x47 0xC0" reads the address 0xC0476018 into %eax. - * - * In this example can guess that the kernel was compiled with - * CONFIG_PAGE_OFFSET set to 0xC0000000 (it's always a round number). If the - * kernel were larger than 16MB, we might see 0xC1 addresses show up, but our - * kernel isn't that bloated yet. - * - * Unfortunately, x86 has variable-length instructions, so finding this - * particular instruction properly involves writing a disassembler. Instead, - * we rely on statistics. We look for "0xA1" and tally the different bytes - * which occur 4 bytes later (the "0xC0" in our example above). When one of - * those bytes appears three times, we can be reasonably confident that it - * forms the start of CONFIG_PAGE_OFFSET. - * - * This is amazingly reliable. */ +/* This is amazingly reliable. */ static unsigned long intuit_page_offset(unsigned char *img, unsigned long len) { unsigned int i, possibilities[256] = { 0 }; @@ -286,52 +182,30 @@ static unsigned long intuit_page_offset(unsigned char *img, unsigned long len) errx(1, "could not determine page offset"); } -/*L:160 Unfortunately the entire ELF image isn't compressed: the segments - * which need loading are extracted and compressed raw. This denies us the - * information we need to make a fully-general loader. */ static unsigned long unpack_bzimage(int fd, unsigned long *page_offset) { gzFile f; int ret, len = 0; - /* A bzImage always gets loaded at physical address 1M. This is - * actually configurable as CONFIG_PHYSICAL_START, but as the comment - * there says, "Don't change this unless you know what you are doing". - * Indeed. */ void *img = (void *)0x100000; - /* gzdopen takes our file descriptor (carefully placed at the start of - * the GZIP header we found) and returns a gzFile. */ f = gzdopen(fd, "rb"); - /* We read it into memory in 64k chunks until we hit the end. */ while ((ret = gzread(f, img + len, 65536)) > 0) len += ret; if (ret < 0) err(1, "reading image from bzImage"); verbose("Unpacked size %i addr %p\n", len, img); - - /* Without the ELF header, we can't tell virtual-physical gap. This is - * CONFIG_PAGE_OFFSET, and people do actually change it. Fortunately, - * I have a clever way of figuring it out from the code itself. */ *page_offset = intuit_page_offset(img, len); return entry_point(img, img + len, *page_offset); } -/*L:150 A bzImage, unlike an ELF file, is not meant to be loaded. You're - * supposed to jump into it and it will unpack itself. We can't do that - * because the Guest can't run the unpacking code, and adding features to - * lguest kills puppies, so we don't want to. - * - * The bzImage is formed by putting the decompressing code in front of the - * compressed kernel code. So we can simple scan through it looking for the - * first "gzip" header, and start decompressing from there. */ static unsigned long load_bzimage(int fd, unsigned long *page_offset) { unsigned char c; int state = 0; - /* GZIP header is 0x1F 0x8B ... . */ + /* Ugly brute force search for gzip header. */ while (read(fd, &c, 1) == 1) { switch (state) { case 0: @@ -348,10 +222,8 @@ static unsigned long load_bzimage(int fd, unsigned long *page_offset) state++; break; case 9: - /* Seek back to the start of the gzip header. */ lseek(fd, -10, SEEK_CUR); - /* One final check: "compressed under UNIX". */ - if (c != 0x03) + if (c != 0x03) /* Compressed under UNIX. */ state = -1; else return unpack_bzimage(fd, page_offset); @@ -360,43 +232,25 @@ static unsigned long load_bzimage(int fd, unsigned long *page_offset) errx(1, "Could not find kernel in bzImage"); } -/*L:140 Loading the kernel is easy when it's a "vmlinux", but most kernels - * come wrapped up in the self-decompressing "bzImage" format. With some funky - * coding, we can load those, too. */ static unsigned long load_kernel(int fd, unsigned long *page_offset) { Elf32_Ehdr hdr; - /* Read in the first few bytes. */ if (read(fd, &hdr, sizeof(hdr)) != sizeof(hdr)) err(1, "Reading kernel"); - /* If it's an ELF file, it starts with "\177ELF" */ if (memcmp(hdr.e_ident, ELFMAG, SELFMAG) == 0) return map_elf(fd, &hdr, page_offset); - /* Otherwise we assume it's a bzImage, and try to unpack it */ return load_bzimage(fd, page_offset); } -/* This is a trivial little helper to align pages. Andi Kleen hated it because - * it calls getpagesize() twice: "it's dumb code." - * - * Kernel guys get really het up about optimization, even when it's not - * necessary. I leave this code as a reaction against that. */ static inline unsigned long page_align(unsigned long addr) { - /* Add upwards and truncate downwards. */ return ((addr + getpagesize()-1) & ~(getpagesize()-1)); } -/*L:180 An "initial ram disk" is a disk image loaded into memory along with - * the kernel which the kernel can use to boot from without needing any - * drivers. Most distributions now use this as standard: the initrd contains - * the code to load the appropriate driver modules for the current machine. - * - * Importantly, James Morris works for RedHat, and Fedora uses initrds for its - * kernels. He sent me this (and tells me when I break it). */ +/* initrd gets loaded at top of memory: return length. */ static unsigned long load_initrd(const char *name, unsigned long mem) { int ifd; @@ -405,35 +259,21 @@ static unsigned long load_initrd(const char *name, unsigned long mem) void *iaddr; ifd = open_or_die(name, O_RDONLY); - /* fstat() is needed to get the file size. */ if (fstat(ifd, &st) < 0) err(1, "fstat() on initrd '%s'", name); - /* The length needs to be rounded up to a page size: mmap needs the - * address to be page aligned. */ len = page_align(st.st_size); - /* We map the initrd at the top of memory. */ iaddr = mmap((void *)mem - len, st.st_size, PROT_READ|PROT_EXEC|PROT_WRITE, MAP_FIXED|MAP_PRIVATE, ifd, 0); if (iaddr != (void *)mem - len) err(1, "Mmaping initrd '%s' returned %p not %p", name, iaddr, (void *)mem - len); - /* Once a file is mapped, you can close the file descriptor. It's a - * little odd, but quite useful. */ close(ifd); verbose("mapped initrd %s size=%lu @ %p\n", name, st.st_size, iaddr); - - /* We return the initrd size. */ return len; } -/* Once we know how much memory we have, and the address the Guest kernel - * expects, we can construct simple linear page tables which will get the Guest - * far enough into the boot to create its own. - * - * We lay them out of the way, just below the initrd (which is why we need to - * know its size). */ static unsigned long setup_pagetables(unsigned long mem, unsigned long initrd_size, unsigned long page_offset) @@ -442,32 +282,23 @@ static unsigned long setup_pagetables(unsigned long mem, unsigned int mapped_pages, i, linear_pages; unsigned int ptes_per_page = getpagesize()/sizeof(u32); - /* Ideally we map all physical memory starting at page_offset. - * However, if page_offset is 0xC0000000 we can only map 1G of physical - * (0xC0000000 + 1G overflows). */ + /* If we can map all of memory above page_offset, we do so. */ if (mem <= -page_offset) mapped_pages = mem/getpagesize(); else mapped_pages = -page_offset/getpagesize(); - /* Each PTE page can map ptes_per_page pages: how many do we need? */ + /* Each linear PTE page can map ptes_per_page pages. */ linear_pages = (mapped_pages + ptes_per_page-1)/ptes_per_page; - /* We put the toplevel page directory page at the top of memory. */ + /* We lay out top-level then linear mapping immediately below initrd */ pgdir = (void *)mem - initrd_size - getpagesize(); - - /* Now we use the next linear_pages pages as pte pages */ linear = (void *)pgdir - linear_pages*getpagesize(); - /* Linear mapping is easy: put every page's address into the mapping in - * order. PAGE_PRESENT contains the flags Present, Writable and - * Executable. */ for (i = 0; i < mapped_pages; i++) linear[i] = ((i * getpagesize()) | PAGE_PRESENT); - /* The top level points to the linear page table pages above. The - * entry representing page_offset points to the first one, and they - * continue from there. */ + /* Now set up pgd so that this memory is at page_offset */ for (i = 0; i < mapped_pages; i += ptes_per_page) { pgdir[(i + page_offset/getpagesize())/ptes_per_page] = (((u32)linear + i*sizeof(u32)) | PAGE_PRESENT); @@ -476,13 +307,9 @@ static unsigned long setup_pagetables(unsigned long mem, verbose("Linear mapping of %u pages in %u pte pages at %p\n", mapped_pages, linear_pages, linear); - /* We return the top level (guest-physical) address: the kernel needs - * to know where it is. */ return (unsigned long)pgdir; } -/* Simple routine to roll all the commandline arguments together with spaces - * between them. */ static void concat(char *dst, char *args[]) { unsigned int i, len = 0; @@ -496,10 +323,6 @@ static void concat(char *dst, char *args[]) dst[len] = '\0'; } -/* This is where we actually tell the kernel to initialize the Guest. We saw - * the arguments it expects when we looked at initialize() in lguest_user.c: - * the top physical page to allow, the top level pagetable, the entry point and - * the page_offset constant for the Guest. */ static int tell_kernel(u32 pgdir, u32 start, u32 page_offset) { u32 args[] = { LHREQ_INITIALIZE, @@ -509,11 +332,8 @@ static int tell_kernel(u32 pgdir, u32 start, u32 page_offset) fd = open_or_die("/dev/lguest", O_RDWR); if (write(fd, args, sizeof(args)) < 0) err(1, "Writing to /dev/lguest"); - - /* We return the /dev/lguest file descriptor to control this Guest */ return fd; } -/*:*/ static void set_fd(int fd, struct device_list *devices) { @@ -522,108 +342,61 @@ static void set_fd(int fd, struct device_list *devices) devices->max_infd = fd; } -/*L:200 - * The Waker. - * - * With a console and network devices, we can have lots of input which we need - * to process. We could try to tell the kernel what file descriptors to watch, - * but handing a file descriptor mask through to the kernel is fairly icky. - * - * Instead, we fork off a process which watches the file descriptors and writes - * the LHREQ_BREAK command to the /dev/lguest filedescriptor to tell the Host - * loop to stop running the Guest. This causes it to return from the - * /dev/lguest read with -EAGAIN, where it will write to /dev/lguest to reset - * the LHREQ_BREAK and wake us up again. - * - * This, of course, is merely a different *kind* of icky. - */ +/* When input arrives, we tell the kernel to kick lguest out with -EAGAIN. */ static void wake_parent(int pipefd, int lguest_fd, struct device_list *devices) { - /* Add the pipe from the Launcher to the fdset in the device_list, so - * we watch it, too. */ set_fd(pipefd, devices); for (;;) { fd_set rfds = devices->infds; u32 args[] = { LHREQ_BREAK, 1 }; - /* Wait until input is ready from one of the devices. */ select(devices->max_infd+1, &rfds, NULL, NULL, NULL); - /* Is it a message from the Launcher? */ if (FD_ISSET(pipefd, &rfds)) { int ignorefd; - /* If read() returns 0, it means the Launcher has - * exited. We silently follow. */ if (read(pipefd, &ignorefd, sizeof(ignorefd)) == 0) exit(0); - /* Otherwise it's telling us there's a problem with one - * of the devices, and we should ignore that file - * descriptor from now on. */ FD_CLR(ignorefd, &devices->infds); - } else /* Send LHREQ_BREAK command. */ + } else write(lguest_fd, args, sizeof(args)); } } -/* This routine just sets up a pipe to the Waker process. */ static int setup_waker(int lguest_fd, struct device_list *device_list) { int pipefd[2], child; - /* We create a pipe to talk to the waker, and also so it knows when the - * Launcher dies (and closes pipe). */ pipe(pipefd); child = fork(); if (child == -1) err(1, "forking"); if (child == 0) { - /* Close the "writing" end of our copy of the pipe */ close(pipefd[1]); wake_parent(pipefd[0], lguest_fd, device_list); } - /* Close the reading end of our copy of the pipe. */ close(pipefd[0]); - /* Here is the fd used to talk to the waker. */ return pipefd[1]; } -/*L:210 - * Device Handling. - * - * When the Guest sends DMA to us, it sends us an array of addresses and sizes. - * We need to make sure it's not trying to reach into the Launcher itself, so - * we have a convenient routine which check it and exits with an error message - * if something funny is going on: - */ static void *_check_pointer(unsigned long addr, unsigned int size, unsigned int line) { - /* We have to separately check addr and addr+size, because size could - * be huge and addr + size might wrap around. */ if (addr >= top || addr + size >= top) errx(1, "%s:%i: Invalid address %li", __FILE__, line, addr); - /* We return a pointer for the caller's convenience, now we know it's - * safe to use. */ return (void *)addr; } -/* A macro which transparently hands the line number to the real function. */ #define check_pointer(addr,size) _check_pointer(addr, size, __LINE__) -/* The Guest has given us the address of a "struct lguest_dma". We check it's - * OK and convert it to an iovec (which is a simple array of ptr/size - * pairs). */ +/* Returns pointer to dma->used_len */ static u32 *dma2iov(unsigned long dma, struct iovec iov[], unsigned *num) { unsigned int i; struct lguest_dma *udma; - /* First we make sure that the array memory itself is valid. */ udma = check_pointer(dma, sizeof(*udma)); - /* Now we check each element */ for (i = 0; i < LGUEST_MAX_DMA_SECTIONS; i++) { - /* A zero length ends the array. */ if (!udma->len[i]) break; @@ -631,15 +404,9 @@ static u32 *dma2iov(unsigned long dma, struct iovec iov[], unsigned *num) iov[i].iov_len = udma->len[i]; } *num = i; - - /* We return the pointer to where the caller should write the amount of - * the buffer used. */ return &udma->used_len; } -/* This routine gets a DMA buffer from the Guest for a given key, and converts - * it to an iovec array. It returns the interrupt the Guest wants when we're - * finished, and a pointer to the "used_len" field to fill in. */ static u32 *get_dma_buffer(int fd, void *key, struct iovec iov[], unsigned int *num, u32 *irq) { @@ -647,21 +414,16 @@ static u32 *get_dma_buffer(int fd, void *key, unsigned long udma; u32 *res; - /* Ask the kernel for a DMA buffer corresponding to this key. */ udma = write(fd, buf, sizeof(buf)); - /* They haven't registered any, or they're all used? */ if (udma == (unsigned long)-1) return NULL; - /* Convert it into our iovec array */ + /* Kernel stashes irq in ->used_len. */ res = dma2iov(udma, iov, num); - /* The kernel stashes irq in ->used_len to get it out to us. */ *irq = *res; - /* Return a pointer to ((struct lguest_dma *)udma)->used_len. */ return res; } -/* This is a convenient routine to send the Guest an interrupt. */ static void trigger_irq(int fd, u32 irq) { u32 buf[] = { LHREQ_IRQ, irq }; @@ -669,10 +431,6 @@ static void trigger_irq(int fd, u32 irq) err(1, "Triggering irq %i", irq); } -/* This simply sets up an iovec array where we can put data to be discarded. - * This happens when the Guest doesn't want or can't handle the input: we have - * to get rid of it somewhere, and if we bury it in the ceiling space it will - * start to smell after a week. */ static void discard_iovec(struct iovec *iov, unsigned int *num) { static char discard_buf[1024]; @@ -681,24 +439,19 @@ static void discard_iovec(struct iovec *iov, unsigned int *num) iov->iov_len = sizeof(discard_buf); } -/* Here is the input terminal setting we save, and the routine to restore them - * on exit so the user can see what they type next. */ static struct termios orig_term; static void restore_term(void) { tcsetattr(STDIN_FILENO, TCSANOW, &orig_term); } -/* We associate some data with the console for our exit hack. */ struct console_abort { - /* How many times have they hit ^C? */ int count; - /* When did they start? */ struct timeval start; }; -/* This is the routine which handles console input (ie. stdin). */ +/* We DMA input to buffer bound at start of console page. */ static bool handle_console_input(int fd, struct device *dev) { u32 irq = 0, *lenp; @@ -707,38 +460,24 @@ static bool handle_console_input(int fd, struct device *dev) struct iovec iov[LGUEST_MAX_DMA_SECTIONS]; struct console_abort *abort = dev->priv; - /* First we get the console buffer from the Guest. The key is dev->mem - * which was set to 0 in setup_console(). */ lenp = get_dma_buffer(fd, dev->mem, iov, &num, &irq); if (!lenp) { - /* If it's not ready for input, warn and set up to discard. */ warn("console: no dma buffer!"); discard_iovec(iov, &num); } - /* This is why we convert to iovecs: the readv() call uses them, and so - * it reads straight into the Guest's buffer. */ len = readv(dev->fd, iov, num); if (len <= 0) { - /* This implies that the console is closed, is /dev/null, or - * something went terribly wrong. We still go through the rest - * of the logic, though, especially the exit handling below. */ warnx("Failed to get console input, ignoring console."); len = 0; } - /* If we read the data into the Guest, fill in the length and send the - * interrupt. */ if (lenp) { *lenp = len; trigger_irq(fd, irq); } - /* Three ^C within one second? Exit. - * - * This is such a hack, but works surprisingly well. Each ^C has to be - * in a buffer by itself, so they can't be too fast. But we check that - * we get three within about a second, so they can't be too slow. */ + /* Three ^C within one second? Exit. */ if (len == 1 && ((char *)iov[0].iov_base)[0] == 3) { if (!abort->count++) gettimeofday(&abort->start, NULL); @@ -746,60 +485,43 @@ static bool handle_console_input(int fd, struct device *dev) struct timeval now; gettimeofday(&now, NULL); if (now.tv_sec <= abort->start.tv_sec+1) { + /* Make sure waker is not blocked in BREAK */ u32 args[] = { LHREQ_BREAK, 0 }; - /* Close the fd so Waker will know it has to - * exit. */ close(waker_fd); - /* Just in case waker is blocked in BREAK, send - * unbreak now. */ write(fd, args, sizeof(args)); exit(2); } abort->count = 0; } } else - /* Any other key resets the abort counter. */ abort->count = 0; - /* Now, if we didn't read anything, put the input terminal back and - * return failure (meaning, don't call us again). */ if (!len) { restore_term(); return false; } - /* Everything went OK! */ return true; } -/* Handling console output is much simpler than input. */ static u32 handle_console_output(int fd, const struct iovec *iov, unsigned num, struct device*dev) { - /* Whatever the Guest sends, write it to standard output. Return the - * number of bytes written. */ return writev(STDOUT_FILENO, iov, num); } -/* Guest->Host network output is also pretty easy. */ static u32 handle_tun_output(int fd, const struct iovec *iov, unsigned num, struct device *dev) { - /* We put a flag in the "priv" pointer of the network device, and set - * it as soon as we see output. We'll see why in handle_tun_input() */ + /* Now we've seen output, we should warn if we can't get buffers. */ *(bool *)dev->priv = true; - /* Whatever packet the Guest sent us, write it out to the tun - * device. */ return writev(dev->fd, iov, num); } -/* This matches the peer_key() in lguest_net.c. The key for any given slot - * is the address of the network device's page plus 4 * the slot number. */ static unsigned long peer_offset(unsigned int peernum) { return 4 * peernum; } -/* This is where we handle a packet coming in from the tun device */ static bool handle_tun_input(int fd, struct device *dev) { u32 irq = 0, *lenp; @@ -807,28 +529,17 @@ static bool handle_tun_input(int fd, struct device *dev) unsigned num; struct iovec iov[LGUEST_MAX_DMA_SECTIONS]; - /* First we get a buffer the Guest has bound to its key. */ lenp = get_dma_buffer(fd, dev->mem+peer_offset(NET_PEERNUM), iov, &num, &irq); if (!lenp) { - /* Now, it's expected that if we try to send a packet too - * early, the Guest won't be ready yet. This is why we set a - * flag when the Guest sends its first packet. If it's sent a - * packet we assume it should be ready to receive them. - * - * Actually, this is what the status bits in the descriptor are - * for: we should *use* them. FIXME! */ if (*(bool *)dev->priv) warn("network: no dma buffer!"); discard_iovec(iov, &num); } - /* Read the packet from the device directly into the Guest's buffer. */ len = readv(dev->fd, iov, num); if (len <= 0) err(1, "reading network"); - - /* Write the used_len, and trigger the interrupt for the Guest */ if (lenp) { *lenp = len; trigger_irq(fd, irq); @@ -836,13 +547,9 @@ static bool handle_tun_input(int fd, struct device *dev) verbose("tun input packet len %i [%02x %02x] (%s)\n", len, ((u8 *)iov[0].iov_base)[0], ((u8 *)iov[0].iov_base)[1], lenp ? "sent" : "discarded"); - /* All good. */ return true; } -/* The last device handling routine is block output: the Guest has sent a DMA - * to the block device. It will have placed the command it wants in the - * "struct lguest_block_page". */ static u32 handle_block_output(int fd, const struct iovec *iov, unsigned num, struct device *dev) { @@ -852,64 +559,36 @@ static u32 handle_block_output(int fd, const struct iovec *iov, struct iovec reply[LGUEST_MAX_DMA_SECTIONS]; off64_t device_len, off = (off64_t)p->sector * 512; - /* First we extract the device length from the dev->priv pointer. */ device_len = *(off64_t *)dev->priv; - /* We first check that the read or write is within the length of the - * block file. */ if (off >= device_len) err(1, "Bad offset %llu vs %llu", off, device_len); - /* Move to the right location in the block file. This shouldn't fail, - * but best to check. */ if (lseek64(dev->fd, off, SEEK_SET) != off) err(1, "Bad seek to sector %i", p->sector); verbose("Block: %s at offset %llu\n", p->type ? "WRITE" : "READ", off); - /* They were supposed to bind a reply buffer at key equal to the start - * of the block device memory. We need this to tell them when the - * request is finished. */ lenp = get_dma_buffer(fd, dev->mem, reply, &reply_num, &irq); if (!lenp) err(1, "Block request didn't give us a dma buffer"); if (p->type) { - /* A write request. The DMA they sent contained the data, so - * write it out. */ len = writev(dev->fd, iov, num); - /* Grr... Now we know how long the "struct lguest_dma" they - * sent was, we make sure they didn't try to write over the end - * of the block file (possibly extending it). */ if (off + len > device_len) { - /* Trim it back to the correct length */ ftruncate(dev->fd, device_len); - /* Die, bad Guest, die. */ errx(1, "Write past end %llu+%u", off, len); } - /* The reply length is 0: we just send back an empty DMA to - * interrupt them and tell them the write is finished. */ *lenp = 0; } else { - /* A read request. They sent an empty DMA to start the - * request, and we put the read contents into the reply - * buffer. */ len = readv(dev->fd, reply, reply_num); *lenp = len; } - /* The result is 1 (done), 2 if there was an error (short read or - * write). */ p->result = 1 + (p->bytes != len); - /* Now tell them we've used their reply buffer. */ trigger_irq(fd, irq); - - /* We're supposed to return the number of bytes of the output buffer we - * used. But the block device uses the "result" field instead, so we - * don't bother. */ return 0; } -/* This is the generic routine we call when the Guest sends some DMA out. */ static void handle_output(int fd, unsigned long dma, unsigned long key, struct device_list *devices) { @@ -918,53 +597,30 @@ static void handle_output(int fd, unsigned long dma, unsigned long key, struct iovec iov[LGUEST_MAX_DMA_SECTIONS]; unsigned num = 0; - /* Convert the "struct lguest_dma" they're sending to a "struct - * iovec". */ lenp = dma2iov(dma, iov, &num); - - /* Check each device: if they expect output to this key, tell them to - * handle it. */ for (i = devices->dev; i; i = i->next) { if (i->handle_output && key == i->watch_key) { - /* We write the result straight into the used_len field - * for them. */ *lenp = i->handle_output(fd, iov, num, i); return; } } - - /* This can happen: the kernel sends any SEND_DMA which doesn't match - * another Guest to us. It could be that another Guest just left a - * network, for example. But it's unusual. */ warnx("Pending dma %p, key %p", (void *)dma, (void *)key); } -/* This is called when the waker wakes us up: check for incoming file - * descriptors. */ static void handle_input(int fd, struct device_list *devices) { - /* select() wants a zeroed timeval to mean "don't wait". */ struct timeval poll = { .tv_sec = 0, .tv_usec = 0 }; for (;;) { struct device *i; fd_set fds = devices->infds; - /* If nothing is ready, we're done. */ if (select(devices->max_infd+1, &fds, NULL, NULL, &poll) == 0) break; - /* Otherwise, call the device(s) which have readable - * file descriptors and a method of handling them. */ for (i = devices->dev; i; i = i->next) { if (i->handle_input && FD_ISSET(i->fd, &fds)) { - /* If handle_input() returns false, it means we - * should no longer service it. - * handle_console_input() does this. */ if (!i->handle_input(fd, i)) { - /* Clear it from the set of input file - * descriptors kept at the head of the - * device list. */ FD_CLR(i->fd, &devices->infds); /* Tell waker to ignore it too... */ write(waker_fd, &i->fd, sizeof(i->fd)); @@ -974,15 +630,6 @@ static void handle_input(int fd, struct device_list *devices) } } -/*L:190 - * Device Setup - * - * All devices need a descriptor so the Guest knows it exists, and a "struct - * device" so the Launcher can keep track of it. We have common helper - * routines to allocate them. - * - * This routine allocates a new "struct lguest_device_desc" from descriptor - * table in the devices array just above the Guest's normal memory. */ static struct lguest_device_desc * new_dev_desc(struct lguest_device_desc *descs, u16 type, u16 features, u16 num_pages) @@ -994,8 +641,6 @@ new_dev_desc(struct lguest_device_desc *descs, descs[i].type = type; descs[i].features = features; descs[i].num_pages = num_pages; - /* If they said the device needs memory, we allocate - * that now, bumping up the top of Guest memory. */ if (num_pages) { map_zeroed_pages(top, num_pages); descs[i].pfn = top/getpagesize(); @@ -1007,9 +652,6 @@ new_dev_desc(struct lguest_device_desc *descs, errx(1, "too many devices"); } -/* This monster routine does all the creation and setup of a new device, - * including caling new_dev_desc() to allocate the descriptor and device - * memory. */ static struct device *new_device(struct device_list *devices, u16 type, u16 num_pages, u16 features, int fd, @@ -1022,18 +664,12 @@ static struct device *new_device(struct device_list *devices, { struct device *dev = malloc(sizeof(*dev)); - /* Append to device list. Prepending to a single-linked list is - * easier, but the user expects the devices to be arranged on the bus - * in command-line order. The first network device on the command line - * is eth0, the first block device /dev/lgba, etc. */ + /* Append to device list. */ *devices->lastdev = dev; dev->next = NULL; devices->lastdev = &dev->next; - /* Now we populate the fields one at a time. */ dev->fd = fd; - /* If we have an input handler for this file descriptor, then we add it - * to the device_list's fdset and maxfd. */ if (handle_input) set_fd(dev->fd, devices); dev->desc = new_dev_desc(devices->descs, type, features, num_pages); @@ -1044,37 +680,27 @@ static struct device *new_device(struct device_list *devices, return dev; } -/* Our first setup routine is the console. It's a fairly simple device, but - * UNIX tty handling makes it uglier than it could be. */ static void setup_console(struct device_list *devices) { struct device *dev; - /* If we can save the initial standard input settings... */ if (tcgetattr(STDIN_FILENO, &orig_term) == 0) { struct termios term = orig_term; - /* Then we turn off echo, line buffering and ^C etc. We want a - * raw input stream to the Guest. */ term.c_lflag &= ~(ISIG|ICANON|ECHO); tcsetattr(STDIN_FILENO, TCSANOW, &term); - /* If we exit gracefully, the original settings will be - * restored so the user can see what they're typing. */ atexit(restore_term); } - /* We don't currently require any memory for the console, so we ask for - * 0 pages. */ + /* We don't currently require a page for the console. */ dev = new_device(devices, LGUEST_DEVICE_T_CONSOLE, 0, 0, STDIN_FILENO, handle_console_input, LGUEST_CONSOLE_DMA_KEY, handle_console_output); - /* We store the console state in dev->priv, and initialize it. */ dev->priv = malloc(sizeof(struct console_abort)); ((struct console_abort *)dev->priv)->count = 0; verbose("device %p: console\n", (void *)(dev->desc->pfn * getpagesize())); } -/* Setting up a block file is also fairly straightforward. */ static void setup_block_file(const char *filename, struct device_list *devices) { int fd; @@ -1082,47 +708,20 @@ static void setup_block_file(const char *filename, struct device_list *devices) off64_t *device_len; struct lguest_block_page *p; - /* We open with O_LARGEFILE because otherwise we get stuck at 2G. We - * open with O_DIRECT because otherwise our benchmarks go much too - * fast. */ fd = open_or_die(filename, O_RDWR|O_LARGEFILE|O_DIRECT); - - /* We want one page, and have no input handler (the block file never - * has anything interesting to say to us). Our timing will be quite - * random, so it should be a reasonable randomness source. */ dev = new_device(devices, LGUEST_DEVICE_T_BLOCK, 1, LGUEST_DEVICE_F_RANDOMNESS, fd, NULL, 0, handle_block_output); - - /* We store the device size in the private area */ device_len = dev->priv = malloc(sizeof(*device_len)); - /* This is the safe way of establishing the size of our device: it - * might be a normal file or an actual block device like /dev/hdb. */ *device_len = lseek64(fd, 0, SEEK_END); - - /* The device memory is a "struct lguest_block_page". It's zeroed - * already, we just need to put in the device size. Block devices - * think in sectors (ie. 512 byte chunks), so we translate here. */ p = dev->mem; + p->num_sectors = *device_len/512; verbose("device %p: block %i sectors\n", (void *)(dev->desc->pfn * getpagesize()), p->num_sectors); } -/* - * Network Devices. - * - * Setting up network devices is quite a pain, because we have three types. - * First, we have the inter-Guest network. This is a file which is mapped into - * the address space of the Guests who are on the network. Because it is a - * shared mapping, the same page underlies all the devices, and they can send - * DMA to each other. - * - * Remember from our network driver, the Guest is told what slot in the page it - * is to use. We use exclusive fnctl locks to reserve a slot. If another - * Guest is using a slot, the lock will fail and we try another. Because fnctl - * locks are cleaned up automatically when we die, this cleverly means that our - * reservation on the slot will vanish if we crash. */ +/* We use fnctl locks to reserve network slots (autocleanup!) */ static unsigned int find_slot(int netfd, const char *filename) { struct flock fl; @@ -1130,33 +729,26 @@ static unsigned int find_slot(int netfd, const char *filename) fl.l_type = F_WRLCK; fl.l_whence = SEEK_SET; fl.l_len = 1; - /* Try a 1 byte lock in each possible position number */ for (fl.l_start = 0; fl.l_start < getpagesize()/sizeof(struct lguest_net); fl.l_start++) { - /* If we succeed, return the slot number. */ if (fcntl(netfd, F_SETLK, &fl) == 0) return fl.l_start; } errx(1, "No free slots in network file %s", filename); } -/* This function sets up the network file */ static void setup_net_file(const char *filename, struct device_list *devices) { int netfd; struct device *dev; - /* We don't use open_or_die() here: for friendliness we create the file - * if it doesn't already exist. */ netfd = open(filename, O_RDWR, 0); if (netfd < 0) { if (errno == ENOENT) { netfd = open(filename, O_RDWR|O_CREAT, 0600); if (netfd >= 0) { - /* If we succeeded, initialize the file with a - * blank page. */ char page[getpagesize()]; memset(page, 0, sizeof(page)); write(netfd, page, sizeof(page)); @@ -1166,15 +758,11 @@ static void setup_net_file(const char *filename, err(1, "cannot open net file '%s'", filename); } - /* We need 1 page, and the features indicate the slot to use and that - * no checksum is needed. We never touch this device again; it's - * between the Guests on the network, so we don't register input or - * output handlers. */ dev = new_device(devices, LGUEST_DEVICE_T_NET, 1, find_slot(netfd, filename)|LGUEST_NET_F_NOCSUM, -1, NULL, 0, NULL); - /* Map the shared file. */ + /* We overwrite the /dev/zero mapping with the actual file. */ if (mmap(dev->mem, getpagesize(), PROT_READ|PROT_WRITE, MAP_FIXED|MAP_SHARED, netfd, 0) != dev->mem) err(1, "could not mmap '%s'", filename); @@ -1182,7 +770,6 @@ static void setup_net_file(const char *filename, (void *)(dev->desc->pfn * getpagesize()), filename, dev->desc->features & ~LGUEST_NET_F_NOCSUM); } -/*:*/ static u32 str2ip(const char *ipaddr) { @@ -1192,11 +779,7 @@ static u32 str2ip(const char *ipaddr) return (byte[0] << 24) | (byte[1] << 16) | (byte[2] << 8) | byte[3]; } -/* This code is "adapted" from libbridge: it attaches the Host end of the - * network device to the bridge device specified by the command line. - * - * This is yet another James Morris contribution (I'm an IP-level guy, so I - * dislike bridging), and I just try not to break it. */ +/* adapted from libbridge */ static void add_to_bridge(int fd, const char *if_name, const char *br_name) { int ifidx; @@ -1215,16 +798,12 @@ static void add_to_bridge(int fd, const char *if_name, const char *br_name) err(1, "can't add %s to bridge %s", if_name, br_name); } -/* This sets up the Host end of the network device with an IP address, brings - * it up so packets will flow, the copies the MAC address into the hwaddr - * pointer (in practice, the Host's slot in the network device's memory). */ static void configure_device(int fd, const char *devname, u32 ipaddr, unsigned char hwaddr[6]) { struct ifreq ifr; struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr; - /* Don't read these incantations. Just cut & paste them like I did! */ memset(&ifr, 0, sizeof(ifr)); strcpy(ifr.ifr_name, devname); sin->sin_family = AF_INET; @@ -1235,19 +814,12 @@ static void configure_device(int fd, const char *devname, u32 ipaddr, if (ioctl(fd, SIOCSIFFLAGS, &ifr) != 0) err(1, "Bringing interface %s up", devname); - /* SIOC stands for Socket I/O Control. G means Get (vs S for Set - * above). IF means Interface, and HWADDR is hardware address. - * Simple! */ if (ioctl(fd, SIOCGIFHWADDR, &ifr) != 0) err(1, "getting hw address for %s", devname); + memcpy(hwaddr, ifr.ifr_hwaddr.sa_data, 6); } -/*L:195 The other kind of network is a Host<->Guest network. This can either - * use briding or routing, but the principle is the same: it uses the "tun" - * device to inject packets into the Host as if they came in from a normal - * network card. We just shunt packets between the Guest and the tun - * device. */ static void setup_tun_net(const char *arg, struct device_list *devices) { struct device *dev; @@ -1256,56 +828,36 @@ static void setup_tun_net(const char *arg, struct device_list *devices) u32 ip; const char *br_name = NULL; - /* We open the /dev/net/tun device and tell it we want a tap device. A - * tap device is like a tun device, only somehow different. To tell - * the truth, I completely blundered my way through this code, but it - * works now! */ netfd = open_or_die("/dev/net/tun", O_RDWR); memset(&ifr, 0, sizeof(ifr)); ifr.ifr_flags = IFF_TAP | IFF_NO_PI; strcpy(ifr.ifr_name, "tap%d"); if (ioctl(netfd, TUNSETIFF, &ifr) != 0) err(1, "configuring /dev/net/tun"); - /* We don't need checksums calculated for packets coming in this - * device: trust us! */ ioctl(netfd, TUNSETNOCSUM, 1); - /* We create the net device with 1 page, using the features field of - * the descriptor to tell the Guest it is in slot 1 (NET_PEERNUM), and - * that the device has fairly random timing. We do *not* specify - * LGUEST_NET_F_NOCSUM: these packets can reach the real world. - * - * We will put our MAC address is slot 0 for the Guest to see, so - * it will send packets to us using the key "peer_offset(0)": */ + /* You will be peer 1: we should create enough jitter to randomize */ dev = new_device(devices, LGUEST_DEVICE_T_NET, 1, NET_PEERNUM|LGUEST_DEVICE_F_RANDOMNESS, netfd, handle_tun_input, peer_offset(0), handle_tun_output); - - /* We keep a flag which says whether we've seen packets come out from - * this network device. */ dev->priv = malloc(sizeof(bool)); *(bool *)dev->priv = false; - /* We need a socket to perform the magic network ioctls to bring up the - * tap interface, connect to the bridge etc. Any socket will do! */ ipfd = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP); if (ipfd < 0) err(1, "opening IP socket"); - /* If the command line was --tunnet=bridge: do bridging. */ if (!strncmp(BRIDGE_PFX, arg, strlen(BRIDGE_PFX))) { ip = INADDR_ANY; br_name = arg + strlen(BRIDGE_PFX); add_to_bridge(ipfd, ifr.ifr_name, br_name); - } else /* It is an IP address to set up the device with */ + } else ip = str2ip(arg); - /* We are peer 0, ie. first slot, so we hand dev->mem to this routine - * to write the MAC address at the start of the device memory. */ + /* We are peer 0, ie. first slot. */ configure_device(ipfd, ifr.ifr_name, ip, dev->mem); - /* Set "promisc" bit: we want every single packet if we're going to - * bridge to other machines (and otherwise it doesn't matter). */ + /* Set "promisc" bit: we want every single packet. */ *((u8 *)dev->mem) |= 0x1; close(ipfd); @@ -1316,10 +868,7 @@ static void setup_tun_net(const char *arg, struct device_list *devices) if (br_name) verbose("attached to bridge: %s\n", br_name); } -/* That's the end of device setup. */ -/*L:220 Finally we reach the core of the Launcher, which runs the Guest, serves - * its input and output, and finally, lays it to rest. */ static void __attribute__((noreturn)) run_guest(int lguest_fd, struct device_list *device_list) { @@ -1331,37 +880,20 @@ run_guest(int lguest_fd, struct device_list *device_list) /* We read from the /dev/lguest device to run the Guest. */ readval = read(lguest_fd, arr, sizeof(arr)); - /* The read can only really return sizeof(arr) (the Guest did a - * SEND_DMA to us), or an error. */ - - /* For a successful read, arr[0] is the address of the "struct - * lguest_dma", and arr[1] is the key the Guest sent to. */ if (readval == sizeof(arr)) { handle_output(lguest_fd, arr[0], arr[1], device_list); continue; - /* ENOENT means the Guest died. Reading tells us why. */ } else if (errno == ENOENT) { char reason[1024] = { 0 }; read(lguest_fd, reason, sizeof(reason)-1); errx(1, "%s", reason); - /* EAGAIN means the waker wanted us to look at some input. - * Anything else means a bug or incompatible change. */ } else if (errno != EAGAIN) err(1, "Running guest failed"); - - /* Service input, then unset the BREAK which releases - * the Waker. */ handle_input(lguest_fd, device_list); if (write(lguest_fd, args, sizeof(args)) < 0) err(1, "Resetting break"); } } -/* - * This is the end of the Launcher. - * - * But wait! We've seen I/O from the Launcher, and we've seen I/O from the - * Drivers. If we were to see the Host kernel I/O code, our understanding - * would be complete... :*/ static struct option opts[] = { { "verbose", 0, NULL, 'v' }, @@ -1379,49 +911,20 @@ static void usage(void) " vmlinux [args...]"); } -/*L:100 The Launcher code itself takes us out into userspace, that scary place - * where pointers run wild and free! Unfortunately, like most userspace - * programs, it's quite boring (which is why everyone like to hack on the - * kernel!). Perhaps if you make up an Lguest Drinking Game at this point, it - * will get you through this section. Or, maybe not. - * - * The Launcher binary sits up high, usually starting at address 0xB8000000. - * Everything below this is the "physical" memory for the Guest. For example, - * if the Guest were to write a "1" at physical address 0, we would see a "1" - * in the Launcher at "(int *)0". Guest physical == Launcher virtual. - * - * This can be tough to get your head around, but usually it just means that we - * don't need to do any conversion when the Guest gives us it's "physical" - * addresses. - */ int main(int argc, char *argv[]) { - /* Memory, top-level pagetable, code startpoint, PAGE_OFFSET and size - * of the (optional) initrd. */ unsigned long mem = 0, pgdir, start, page_offset, initrd_size = 0; - /* A temporary and the /dev/lguest file descriptor. */ int i, c, lguest_fd; - /* The list of Guest devices, based on command line arguments. */ struct device_list device_list; - /* The boot information for the Guest: at guest-physical address 0. */ void *boot = (void *)0; - /* If they specify an initrd file to load. */ const char *initrd_name = NULL; - /* First we initialize the device list. Since console and network - * device receive input from a file descriptor, we keep an fdset - * (infds) and the maximum fd number (max_infd) with the head of the - * list. We also keep a pointer to the last device, for easy appending - * to the list. */ device_list.max_infd = -1; device_list.dev = NULL; device_list.lastdev = &device_list.dev; FD_ZERO(&device_list.infds); - /* We need to know how much memory so we can set up the device - * descriptor and memory pages for the devices as we parse the command - * line. So we quickly look through the arguments to find the amount - * of memory now. */ + /* We need to know how much memory so we can allocate devices. */ for (i = 1; i < argc; i++) { if (argv[i][0] != '-') { mem = top = atoi(argv[i]) * 1024 * 1024; @@ -1430,8 +933,6 @@ int main(int argc, char *argv[]) break; } } - - /* The options are fairly straight-forward */ while ((c = getopt_long(argc, argv, "v", opts, NULL)) != EOF) { switch (c) { case 'v': @@ -1454,71 +955,42 @@ int main(int argc, char *argv[]) usage(); } } - /* After the other arguments we expect memory and kernel image name, - * followed by command line arguments for the kernel. */ if (optind + 2 > argc) usage(); - /* We always have a console device */ + /* We need a console device */ setup_console(&device_list); - /* We start by mapping anonymous pages over all of guest-physical - * memory range. This fills it with 0, and ensures that the Guest - * won't be killed when it tries to access it. */ + /* First we map /dev/zero over all of guest-physical memory. */ map_zeroed_pages(0, mem / getpagesize()); /* Now we load the kernel */ start = load_kernel(open_or_die(argv[optind+1], O_RDONLY), &page_offset); - /* Map the initrd image if requested (at top of physical memory) */ + /* Map the initrd image if requested */ if (initrd_name) { initrd_size = load_initrd(initrd_name, mem); - /* These are the location in the Linux boot header where the - * start and size of the initrd are expected to be found. */ *(unsigned long *)(boot+0x218) = mem - initrd_size; *(unsigned long *)(boot+0x21c) = initrd_size; - /* The bootloader type 0xFF means "unknown"; that's OK. */ *(unsigned char *)(boot+0x210) = 0xFF; } - /* Set up the initial linear pagetables, starting below the initrd. */ + /* Set up the initial linar pagetables. */ pgdir = setup_pagetables(mem, initrd_size, page_offset); - /* The Linux boot header contains an "E820" memory map: ours is a - * simple, single region. */ + /* E820 memory map: ours is a simple, single region. */ *(char*)(boot+E820NR) = 1; *((struct e820entry *)(boot+E820MAP)) = ((struct e820entry) { 0, mem, E820_RAM }); - /* The boot header contains a command line pointer: we put the command - * line after the boot header (at address 4096) */ + /* Command line pointer and command line (at 4096) */ *(void **)(boot + 0x228) = boot + 4096; concat(boot + 4096, argv+optind+2); - - /* The guest type value of "1" tells the Guest it's under lguest. */ + /* Paravirt type: 1 == lguest */ *(int *)(boot + 0x23c) = 1; - /* We tell the kernel to initialize the Guest: this returns the open - * /dev/lguest file descriptor. */ lguest_fd = tell_kernel(pgdir, start, page_offset); - - /* We fork off a child process, which wakes the Launcher whenever one - * of the input file descriptors needs attention. Otherwise we would - * run the Guest until it tries to output something. */ waker_fd = setup_waker(lguest_fd, &device_list); - /* Finally, run the Guest. This doesn't return. */ run_guest(lguest_fd, &device_list); } -/*:*/ - -/*M:999 - * Mastery is done: you now know everything I do. - * - * But surely you have seen code, features and bugs in your wanderings which - * you now yearn to attack? That is the real game, and I look forward to you - * patching and forking lguest into the Your-Name-Here-visor. - * - * Farewell, and good coding! - * Rusty Russell. - */ diff --git a/trunk/MAINTAINERS b/trunk/MAINTAINERS index babd00b0c65c..01f222e51871 100644 --- a/trunk/MAINTAINERS +++ b/trunk/MAINTAINERS @@ -3339,14 +3339,6 @@ M: thomas@winischhofer.net W: http://www.winischhofer.at/linuxsisusbvga.shtml S: Maintained -SLAB ALLOCATOR -P: Christoph Lameter -M: clameter@sgi.com -P: Pekka Enberg -M: penberg@cs.helsinki.fi -L: linux-mm@kvack.org -S: Maintained - SMC91x ETHERNET DRIVER P: Nicolas Pitre M: nico@cam.org diff --git a/trunk/arch/alpha/kernel/head.S b/trunk/arch/alpha/kernel/head.S index 7ac1f1372c36..e27d23c74ba8 100644 --- a/trunk/arch/alpha/kernel/head.S +++ b/trunk/arch/alpha/kernel/head.S @@ -10,7 +10,6 @@ #include #include -.section .text.head, "ax" .globl swapper_pg_dir .globl _stext swapper_pg_dir=SWAPPER_PGD diff --git a/trunk/arch/alpha/kernel/pci.c b/trunk/arch/alpha/kernel/pci.c index 9dc1cee43265..ab642a4f08de 100644 --- a/trunk/arch/alpha/kernel/pci.c +++ b/trunk/arch/alpha/kernel/pci.c @@ -195,7 +195,7 @@ pcibios_init(void) subsys_initcall(pcibios_init); -char * __devinit +char * __init pcibios_setup(char *str) { return str; @@ -204,7 +204,7 @@ pcibios_setup(char *str) #ifdef ALPHA_RESTORE_SRM_SETUP static struct pdev_srm_saved_conf *srm_saved_configs; -void __devinit +void __init pdev_save_srm_config(struct pci_dev *dev) { struct pdev_srm_saved_conf *tmp; @@ -247,14 +247,14 @@ pci_restore_srm_config(void) } #endif -void __devinit +void __init pcibios_fixup_resource(struct resource *res, struct resource *root) { res->start += root->start; res->end += root->start; } -void __devinit +void __init pcibios_fixup_device_resources(struct pci_dev *dev, struct pci_bus *bus) { /* Update device resources. */ @@ -273,7 +273,7 @@ pcibios_fixup_device_resources(struct pci_dev *dev, struct pci_bus *bus) } } -void __devinit +void __init pcibios_fixup_bus(struct pci_bus *bus) { /* Propagate hose info into the subordinate devices. */ diff --git a/trunk/arch/alpha/kernel/pci_iommu.c b/trunk/arch/alpha/kernel/pci_iommu.c index e1c470752ebc..6b07f89a72c7 100644 --- a/trunk/arch/alpha/kernel/pci_iommu.c +++ b/trunk/arch/alpha/kernel/pci_iommu.c @@ -58,7 +58,7 @@ size_for_memory(unsigned long max) return max; } -struct pci_iommu_arena * __init +struct pci_iommu_arena * iommu_arena_new_node(int nid, struct pci_controller *hose, dma_addr_t base, unsigned long window_size, unsigned long align) { @@ -117,7 +117,7 @@ iommu_arena_new_node(int nid, struct pci_controller *hose, dma_addr_t base, return arena; } -struct pci_iommu_arena * __init +struct pci_iommu_arena * iommu_arena_new(struct pci_controller *hose, dma_addr_t base, unsigned long window_size, unsigned long align) { diff --git a/trunk/arch/alpha/kernel/smp.c b/trunk/arch/alpha/kernel/smp.c index 0804b6abe203..b28731437c31 100644 --- a/trunk/arch/alpha/kernel/smp.c +++ b/trunk/arch/alpha/kernel/smp.c @@ -358,7 +358,7 @@ secondary_cpu_start(int cpuid, struct task_struct *idle) /* * Bring one cpu online. */ -static int __cpuinit +static int __devinit smp_boot_one_cpu(int cpuid) { struct task_struct *idle; @@ -487,7 +487,7 @@ smp_prepare_boot_cpu(void) { } -int __cpuinit +int __devinit __cpu_up(unsigned int cpu) { smp_boot_one_cpu(cpu); @@ -541,7 +541,7 @@ smp_percpu_timer_interrupt(struct pt_regs *regs) set_irq_regs(old_regs); } -int +int __init setup_profiling_timer(unsigned int multiplier) { return -EINVAL; diff --git a/trunk/arch/alpha/kernel/vmlinux.lds.S b/trunk/arch/alpha/kernel/vmlinux.lds.S index 7af07d3ad5f0..fe13daa5cb2c 100644 --- a/trunk/arch/alpha/kernel/vmlinux.lds.S +++ b/trunk/arch/alpha/kernel/vmlinux.lds.S @@ -15,7 +15,6 @@ SECTIONS _text = .; /* Text and read-only data */ .text : { - *(.text.head) TEXT_TEXT SCHED_TEXT LOCK_TEXT diff --git a/trunk/arch/i386/kernel/alternative.c b/trunk/arch/i386/kernel/alternative.c index c85598acb8fd..c3750c2c4113 100644 --- a/trunk/arch/i386/kernel/alternative.c +++ b/trunk/arch/i386/kernel/alternative.c @@ -430,12 +430,22 @@ void __init alternative_instructions(void) * And on the local CPU you need to be protected again NMI or MCE handlers * seeing an inconsistent instruction while you patch. */ -void __kprobes text_poke(void *addr, unsigned char *opcode, int len) +void __kprobes text_poke(void *oaddr, unsigned char *opcode, int len) { + u8 *addr = oaddr; + if (!pte_write(*lookup_address((unsigned long)addr))) { + struct page *p[2] = { virt_to_page(addr), virt_to_page(addr+PAGE_SIZE) }; + addr = vmap(p, 2, VM_MAP, PAGE_KERNEL); + if (!addr) + return; + addr += ((unsigned long)oaddr) % PAGE_SIZE; + } memcpy(addr, opcode, len); sync_core(); /* Not strictly needed, but can speed CPU recovery up. Ignore cross cacheline case. */ if (cpu_has_clflush) - asm("clflush (%0) " :: "r" (addr) : "memory"); + asm("clflush (%0) " :: "r" (oaddr) : "memory"); + if (addr != oaddr) + vunmap(addr); } diff --git a/trunk/arch/i386/kernel/cpu/cpufreq/Kconfig b/trunk/arch/i386/kernel/cpu/cpufreq/Kconfig index d8c6f132dc7a..094118ba00da 100644 --- a/trunk/arch/i386/kernel/cpu/cpufreq/Kconfig +++ b/trunk/arch/i386/kernel/cpu/cpufreq/Kconfig @@ -92,7 +92,7 @@ config X86_POWERNOW_K8 config X86_POWERNOW_K8_ACPI bool "ACPI Support" select ACPI_PROCESSOR - depends on ACPI && X86_POWERNOW_K8 + depends on X86_POWERNOW_K8 default y help This provides access to the K8s Processor Performance States via ACPI. diff --git a/trunk/arch/i386/mm/init.c b/trunk/arch/i386/mm/init.c index 4c4809f13cb1..1b1a1e66d099 100644 --- a/trunk/arch/i386/mm/init.c +++ b/trunk/arch/i386/mm/init.c @@ -800,17 +800,9 @@ void mark_rodata_ro(void) unsigned long start = PFN_ALIGN(_text); unsigned long size = PFN_ALIGN(_etext) - start; -#ifndef CONFIG_KPROBES -#ifdef CONFIG_HOTPLUG_CPU - /* It must still be possible to apply SMP alternatives. */ - if (num_possible_cpus() <= 1) -#endif - { - change_page_attr(virt_to_page(start), - size >> PAGE_SHIFT, PAGE_KERNEL_RX); - printk("Write protecting the kernel text: %luk\n", size >> 10); - } -#endif + change_page_attr(virt_to_page(start), + size >> PAGE_SHIFT, PAGE_KERNEL_RX); + printk("Write protecting the kernel text: %luk\n", size >> 10); start += size; size = (unsigned long)__end_rodata - start; change_page_attr(virt_to_page(start), diff --git a/trunk/arch/ia64/kernel/cyclone.c b/trunk/arch/ia64/kernel/cyclone.c index 790ef0d87e12..2fd96d9062a1 100644 --- a/trunk/arch/ia64/kernel/cyclone.c +++ b/trunk/arch/ia64/kernel/cyclone.c @@ -38,11 +38,11 @@ static struct clocksource clocksource_cyclone = { int __init init_cyclone_clock(void) { - u64 __iomem *reg; + u64* reg; u64 base; /* saved cyclone base address */ u64 offset; /* offset from pageaddr to cyclone_timer register */ int i; - u32 __iomem *cyclone_timer; /* Cyclone MPMC0 register */ + u32* volatile cyclone_timer; /* Cyclone MPMC0 register */ if (!use_cyclone) return 0; @@ -51,7 +51,7 @@ int __init init_cyclone_clock(void) /* find base address */ offset = (CYCLONE_CBAR_ADDR); - reg = ioremap_nocache(offset, sizeof(u64)); + reg = (u64*)ioremap_nocache(offset, sizeof(u64)); if(!reg){ printk(KERN_ERR "Summit chipset: Could not find valid CBAR" " register.\n"); @@ -69,7 +69,7 @@ int __init init_cyclone_clock(void) /* setup PMCC */ offset = (base + CYCLONE_PMCC_OFFSET); - reg = ioremap_nocache(offset, sizeof(u64)); + reg = (u64*)ioremap_nocache(offset, sizeof(u64)); if(!reg){ printk(KERN_ERR "Summit chipset: Could not find valid PMCC" " register.\n"); @@ -81,7 +81,7 @@ int __init init_cyclone_clock(void) /* setup MPCS */ offset = (base + CYCLONE_MPCS_OFFSET); - reg = ioremap_nocache(offset, sizeof(u64)); + reg = (u64*)ioremap_nocache(offset, sizeof(u64)); if(!reg){ printk(KERN_ERR "Summit chipset: Could not find valid MPCS" " register.\n"); @@ -93,7 +93,7 @@ int __init init_cyclone_clock(void) /* map in cyclone_timer */ offset = (base + CYCLONE_MPMC_OFFSET); - cyclone_timer = ioremap_nocache(offset, sizeof(u32)); + cyclone_timer = (u32*)ioremap_nocache(offset, sizeof(u32)); if(!cyclone_timer){ printk(KERN_ERR "Summit chipset: Could not find valid MPMC" " register.\n"); @@ -110,7 +110,7 @@ int __init init_cyclone_clock(void) printk(KERN_ERR "Summit chipset: Counter not counting!" " DISABLED\n"); iounmap(cyclone_timer); - cyclone_timer = NULL; + cyclone_timer = 0; use_cyclone = 0; return -ENODEV; } diff --git a/trunk/arch/ia64/kernel/time.c b/trunk/arch/ia64/kernel/time.c index 6c0e9e2e1b82..627785c48ea9 100644 --- a/trunk/arch/ia64/kernel/time.c +++ b/trunk/arch/ia64/kernel/time.c @@ -52,7 +52,7 @@ static struct clocksource clocksource_itc = { .name = "itc", .rating = 350, .read = itc_get_cycles, - .mask = CLOCKSOURCE_MASK(64), + .mask = 0xffffffffffffffff, .mult = 0, /*to be caluclated*/ .shift = 16, .flags = CLOCK_SOURCE_IS_CONTINUOUS, @@ -255,7 +255,7 @@ ia64_init_itm (void) } } -static cycle_t itc_get_cycles(void) +static cycle_t itc_get_cycles() { u64 lcycle, now, ret; diff --git a/trunk/arch/m32r/kernel/setup_mappi.c b/trunk/arch/m32r/kernel/setup_mappi.c index fe73c9ec611f..6b2d77da0683 100644 --- a/trunk/arch/m32r/kernel/setup_mappi.c +++ b/trunk/arch/m32r/kernel/setup_mappi.c @@ -45,8 +45,7 @@ static void mask_and_ack_mappi(unsigned int irq) static void end_mappi_irq(unsigned int irq) { - if (!(irq_desc[irq].status & (IRQ_DISABLED | IRQ_INPROGRESS))) - enable_mappi_irq(irq); + enable_mappi_irq(irq); } static unsigned int startup_mappi_irq(unsigned int irq) @@ -89,7 +88,7 @@ void __init init_IRQ(void) irq_desc[M32R_IRQ_INT0].chip = &mappi_irq_type; irq_desc[M32R_IRQ_INT0].action = NULL; irq_desc[M32R_IRQ_INT0].depth = 1; - icu_data[M32R_IRQ_INT0].icucr = M32R_ICUCR_IEN|M32R_ICUCR_ISMOD11; + icu_data[M32R_IRQ_INT0].icucr = M32R_ICUCR_IEN|M32R_ICUCR_ISMOD10; disable_mappi_irq(M32R_IRQ_INT0); #endif /* CONFIG_M32R_NE2000 */ diff --git a/trunk/arch/m68knommu/kernel/setup.c b/trunk/arch/m68knommu/kernel/setup.c index 3f86ade3a22a..a5ac0d40fbec 100644 --- a/trunk/arch/m68knommu/kernel/setup.c +++ b/trunk/arch/m68knommu/kernel/setup.c @@ -42,6 +42,8 @@ EXPORT_SYMBOL(memory_end); char __initdata command_line[COMMAND_LINE_SIZE]; +void (*mach_trap_init)(void); + /* machine dependent timer functions */ void (*mach_sched_init)(irq_handler_t handler); void (*mach_tick)(void); diff --git a/trunk/arch/m68knommu/platform/5206/config.c b/trunk/arch/m68knommu/platform/5206/config.c index d0f2dc5cb5a1..d265ed4e5afc 100644 --- a/trunk/arch/m68knommu/platform/5206/config.c +++ b/trunk/arch/m68knommu/platform/5206/config.c @@ -28,6 +28,7 @@ void coldfire_tick(void); void coldfire_timer_init(irq_handler_t handler); unsigned long coldfire_timer_offset(void); +void coldfire_trap_init(void); void coldfire_reset(void); /***************************************************************************/ @@ -100,6 +101,7 @@ void config_BSP(char *commandp, int size) mach_sched_init = coldfire_timer_init; mach_tick = coldfire_tick; mach_gettimeoffset = coldfire_timer_offset; + mach_trap_init = coldfire_trap_init; mach_reset = coldfire_reset; } diff --git a/trunk/arch/m68knommu/platform/5206e/config.c b/trunk/arch/m68knommu/platform/5206e/config.c index 4ab614f1ecda..7fa5e8254c31 100644 --- a/trunk/arch/m68knommu/platform/5206e/config.c +++ b/trunk/arch/m68knommu/platform/5206e/config.c @@ -27,6 +27,7 @@ void coldfire_tick(void); void coldfire_timer_init(irq_handler_t handler); unsigned long coldfire_timer_offset(void); +void coldfire_trap_init(void); void coldfire_reset(void); /***************************************************************************/ @@ -106,6 +107,7 @@ void config_BSP(char *commandp, int size) mach_sched_init = coldfire_timer_init; mach_tick = coldfire_tick; mach_gettimeoffset = coldfire_timer_offset; + mach_trap_init = coldfire_trap_init; mach_reset = coldfire_reset; } diff --git a/trunk/arch/m68knommu/platform/520x/config.c b/trunk/arch/m68knommu/platform/520x/config.c index a2c95bebd004..85830f9882f3 100644 --- a/trunk/arch/m68knommu/platform/520x/config.c +++ b/trunk/arch/m68knommu/platform/520x/config.c @@ -30,6 +30,7 @@ unsigned int dma_device_address[MAX_M68K_DMA_CHANNELS]; void coldfire_pit_tick(void); void coldfire_pit_init(irq_handler_t handler); unsigned long coldfire_pit_offset(void); +void coldfire_trap_init(void); void coldfire_reset(void); /***************************************************************************/ @@ -50,6 +51,7 @@ void config_BSP(char *commandp, int size) mach_sched_init = coldfire_pit_init; mach_tick = coldfire_pit_tick; mach_gettimeoffset = coldfire_pit_offset; + mach_trap_init = coldfire_trap_init; mach_reset = coldfire_reset; } diff --git a/trunk/arch/m68knommu/platform/523x/config.c b/trunk/arch/m68knommu/platform/523x/config.c index 0a3af05a434b..c0157e110035 100644 --- a/trunk/arch/m68knommu/platform/523x/config.c +++ b/trunk/arch/m68knommu/platform/523x/config.c @@ -29,6 +29,7 @@ void coldfire_pit_tick(void); void coldfire_pit_init(irq_handler_t handler); unsigned long coldfire_pit_offset(void); +void coldfire_trap_init(void); void coldfire_reset(void); /***************************************************************************/ @@ -65,6 +66,7 @@ void config_BSP(char *commandp, int size) mach_sched_init = coldfire_pit_init; mach_tick = coldfire_pit_tick; mach_gettimeoffset = coldfire_pit_offset; + mach_trap_init = coldfire_trap_init; mach_reset = coldfire_reset; } diff --git a/trunk/arch/m68knommu/platform/5249/config.c b/trunk/arch/m68knommu/platform/5249/config.c index dc2c362590c2..4cdeb719512d 100644 --- a/trunk/arch/m68knommu/platform/5249/config.c +++ b/trunk/arch/m68knommu/platform/5249/config.c @@ -27,6 +27,7 @@ void coldfire_tick(void); void coldfire_timer_init(irq_handler_t handler); unsigned long coldfire_timer_offset(void); +void coldfire_trap_init(void); void coldfire_reset(void); /***************************************************************************/ @@ -98,6 +99,7 @@ void config_BSP(char *commandp, int size) mach_sched_init = coldfire_timer_init; mach_tick = coldfire_tick; mach_gettimeoffset = coldfire_timer_offset; + mach_trap_init = coldfire_trap_init; mach_reset = coldfire_reset; } diff --git a/trunk/arch/m68knommu/platform/5272/config.c b/trunk/arch/m68knommu/platform/5272/config.c index 1365a8300d5d..609b10e4b9b9 100644 --- a/trunk/arch/m68knommu/platform/5272/config.c +++ b/trunk/arch/m68knommu/platform/5272/config.c @@ -28,6 +28,7 @@ void coldfire_tick(void); void coldfire_timer_init(irq_handler_t handler); unsigned long coldfire_timer_offset(void); +void coldfire_trap_init(void); void coldfire_reset(void); extern unsigned int mcf_timervector; @@ -131,6 +132,7 @@ void config_BSP(char *commandp, int size) mach_sched_init = coldfire_timer_init; mach_tick = coldfire_tick; mach_gettimeoffset = coldfire_timer_offset; + mach_trap_init = coldfire_trap_init; mach_reset = coldfire_reset; } diff --git a/trunk/arch/m68knommu/platform/527x/config.c b/trunk/arch/m68knommu/platform/527x/config.c index 1b820441419a..126dac066482 100644 --- a/trunk/arch/m68knommu/platform/527x/config.c +++ b/trunk/arch/m68knommu/platform/527x/config.c @@ -29,6 +29,7 @@ void coldfire_pit_tick(void); void coldfire_pit_init(irq_handler_t handler); unsigned long coldfire_pit_offset(void); +void coldfire_trap_init(void); void coldfire_reset(void); /***************************************************************************/ @@ -65,6 +66,7 @@ void config_BSP(char *commandp, int size) mach_sched_init = coldfire_pit_init; mach_tick = coldfire_pit_tick; mach_gettimeoffset = coldfire_pit_offset; + mach_trap_init = coldfire_trap_init; mach_reset = coldfire_reset; } diff --git a/trunk/arch/m68knommu/platform/528x/config.c b/trunk/arch/m68knommu/platform/528x/config.c index a089e9513699..aab1ef0c1f78 100644 --- a/trunk/arch/m68knommu/platform/528x/config.c +++ b/trunk/arch/m68knommu/platform/528x/config.c @@ -29,6 +29,7 @@ void coldfire_pit_tick(void); void coldfire_pit_init(irq_handler_t handler); unsigned long coldfire_pit_offset(void); +void coldfire_trap_init(void); void coldfire_reset(void); /***************************************************************************/ @@ -65,6 +66,7 @@ void config_BSP(char *commandp, int size) mach_sched_init = coldfire_pit_init; mach_tick = coldfire_pit_tick; mach_gettimeoffset = coldfire_pit_offset; + mach_trap_init = coldfire_trap_init; mach_reset = coldfire_reset; } diff --git a/trunk/arch/m68knommu/platform/5307/config.c b/trunk/arch/m68knommu/platform/5307/config.c index e3461619fd65..1f10e941b87c 100644 --- a/trunk/arch/m68knommu/platform/5307/config.c +++ b/trunk/arch/m68knommu/platform/5307/config.c @@ -29,6 +29,7 @@ void coldfire_tick(void); void coldfire_timer_init(irq_handler_t handler); unsigned long coldfire_timer_offset(void); +void coldfire_trap_init(void); void coldfire_reset(void); extern unsigned int mcf_timervector; @@ -125,6 +126,7 @@ void config_BSP(char *commandp, int size) mach_sched_init = coldfire_timer_init; mach_tick = coldfire_tick; mach_gettimeoffset = coldfire_timer_offset; + mach_trap_init = coldfire_trap_init; mach_reset = coldfire_reset; #ifdef MCF_BDM_DISABLE diff --git a/trunk/arch/m68knommu/platform/5307/pit.c b/trunk/arch/m68knommu/platform/5307/pit.c index e53c446d10e4..aa15beeb36ca 100644 --- a/trunk/arch/m68knommu/platform/5307/pit.c +++ b/trunk/arch/m68knommu/platform/5307/pit.c @@ -5,8 +5,9 @@ * hardware timer only exists in the Freescale ColdFire * 5270/5271, 5282 and other CPUs. * - * Copyright (C) 1999-2007, Greg Ungerer (gerg@snapgear.com) + * Copyright (C) 1999-2006, Greg Ungerer (gerg@snapgear.com) * Copyright (C) 2001-2004, SnapGear Inc. (www.snapgear.com) + * */ /***************************************************************************/ @@ -16,8 +17,8 @@ #include #include #include -#include #include +#include #include #include #include @@ -42,18 +43,13 @@ void coldfire_pit_tick(void) /***************************************************************************/ -static struct irqaction coldfire_pit_irq = { - .name = "timer", - .flags = IRQF_DISABLED | IRQF_TIMER, -}; - void coldfire_pit_init(irq_handler_t handler) { volatile unsigned char *icrp; volatile unsigned long *imrp; - coldfire_pit_irq.handler = handler; - setup_irq(MCFINT_VECBASE + MCFINT_PIT1, &coldfire_pit_irq); + request_irq(MCFINT_VECBASE + MCFINT_PIT1, handler, IRQF_DISABLED, + "ColdFire Timer", NULL); icrp = (volatile unsigned char *) (MCF_IPSBAR + MCFICM_INTC0 + MCFINTC_ICR0 + MCFINT_PIT1); diff --git a/trunk/arch/m68knommu/platform/5307/timers.c b/trunk/arch/m68knommu/platform/5307/timers.c index 64bd0ff9029e..fb66eadd5896 100644 --- a/trunk/arch/m68knommu/platform/5307/timers.c +++ b/trunk/arch/m68knommu/platform/5307/timers.c @@ -3,7 +3,7 @@ /* * timers.c -- generic ColdFire hardware timer support. * - * Copyright (C) 1999-2007, Greg Ungerer (gerg@snapgear.com) + * Copyright (C) 1999-2006, Greg Ungerer (gerg@snapgear.com) */ /***************************************************************************/ @@ -13,8 +13,8 @@ #include #include #include -#include #include +#include #include #include #include @@ -62,24 +62,17 @@ void coldfire_tick(void) /***************************************************************************/ -static struct irqaction coldfire_timer_irq = { - .name = "timer", - .flags = IRQF_DISABLED | IRQF_TIMER, -}; - static int ticks_per_intr; void coldfire_timer_init(irq_handler_t handler) { - coldfire_timer_irq.handler = handler; - setup_irq(mcf_timervector, &coldfire_timer_irq); - __raw_writew(MCFTIMER_TMR_DISABLE, TA(MCFTIMER_TMR)); ticks_per_intr = (MCF_BUSCLK / 16) / HZ; __raw_writetrr(ticks_per_intr - 1, TA(MCFTIMER_TRR)); __raw_writew(MCFTIMER_TMR_ENORI | MCFTIMER_TMR_CLK16 | MCFTIMER_TMR_RESTART | MCFTIMER_TMR_ENABLE, TA(MCFTIMER_TMR)); + request_irq(mcf_timervector, handler, IRQF_DISABLED, "timer", NULL); mcf_settimericr(1, mcf_timerlevel); #ifdef CONFIG_HIGHPROFILE diff --git a/trunk/arch/m68knommu/platform/532x/config.c b/trunk/arch/m68knommu/platform/532x/config.c index b32c6425f821..dc39c466e33f 100644 --- a/trunk/arch/m68knommu/platform/532x/config.c +++ b/trunk/arch/m68knommu/platform/532x/config.c @@ -37,6 +37,7 @@ void coldfire_tick(void); void coldfire_timer_init(irq_handler_t handler); unsigned long coldfire_timer_offset(void); +void coldfire_trap_init(void); void coldfire_reset(void); extern unsigned int mcf_timervector; @@ -107,6 +108,7 @@ void config_BSP(char *commandp, int size) mach_sched_init = coldfire_timer_init; mach_tick = coldfire_tick; mach_gettimeoffset = coldfire_timer_offset; + mach_trap_init = coldfire_trap_init; mach_reset = coldfire_reset; #ifdef MCF_BDM_DISABLE diff --git a/trunk/arch/m68knommu/platform/5407/config.c b/trunk/arch/m68knommu/platform/5407/config.c index e692536817d8..fde417fdd650 100644 --- a/trunk/arch/m68knommu/platform/5407/config.c +++ b/trunk/arch/m68knommu/platform/5407/config.c @@ -28,6 +28,7 @@ void coldfire_tick(void); void coldfire_timer_init(irq_handler_t handler); unsigned long coldfire_timer_offset(void); +void coldfire_trap_init(void); void coldfire_reset(void); extern unsigned int mcf_timervector; @@ -111,6 +112,7 @@ void config_BSP(char *commandp, int size) mach_sched_init = coldfire_timer_init; mach_tick = coldfire_tick; mach_gettimeoffset = coldfire_timer_offset; + mach_trap_init = coldfire_trap_init; mach_reset = coldfire_reset; } diff --git a/trunk/arch/m68knommu/platform/68328/timers.c b/trunk/arch/m68knommu/platform/68328/timers.c index 0396476f955d..ef067f4c3cd4 100644 --- a/trunk/arch/m68knommu/platform/68328/timers.c +++ b/trunk/arch/m68knommu/platform/68328/timers.c @@ -18,10 +18,10 @@ #include #include #include -#include #include #include #include +#include #include #include @@ -53,19 +53,14 @@ /***************************************************************************/ -static struct irqaction m68328_timer_irq = { - .name = "timer", - .flags = IRQF_DISABLED | IRQF_TIMER, -}; - void m68328_timer_init(irq_handler_t timer_routine) { /* disable timer 1 */ TCTL = 0; /* set ISR */ - m68328_timer_irq.handler = timer_routine; - setup_irq(TMR_IRQ_NUM, &m68328_timer_irq); + if (request_irq(TMR_IRQ_NUM, timer_routine, IRQ_FLG_LOCK, "timer", NULL)) + panic("Unable to attach timer interrupt\n"); /* Restart mode, Enable int, Set clock source */ TCTL = TCTL_OM | TCTL_IRQEN | CLOCK_SOURCE; diff --git a/trunk/arch/m68knommu/platform/68360/config.c b/trunk/arch/m68knommu/platform/68360/config.c index 155b72fe2607..4ff13bd51ffd 100644 --- a/trunk/arch/m68knommu/platform/68360/config.c +++ b/trunk/arch/m68knommu/platform/68360/config.c @@ -17,11 +17,11 @@ #include #include #include -#include #include #include #include +#include #include #include @@ -51,15 +51,11 @@ extern unsigned long int system_clock; //In kernel setup.c extern void config_M68360_irq(void); -static struct irqaction m68360_timer_irq = { - .name = "timer", - .flags = IRQF_DISABLED | IRQF_TIMER, -}; - void BSP_sched_init(irq_handler_t timer_routine) { unsigned char prescaler; unsigned short tgcr_save; + int return_value; #if 0 /* Restart mode, Enable int, 32KHz, Enable timer */ @@ -90,8 +86,10 @@ void BSP_sched_init(irq_handler_t timer_routine) pquicc->timer_ter1 = 0x0003; /* clear timer events */ /* enable timer 1 interrupt in CIMR */ - m68360_timer_irq.handler = timer_routine; - setup_irq(CPMVEC_TIMER1, &m68360_timer_irq); +// request_irq(IRQ_MACHSPEC | CPMVEC_TIMER1, timer_routine, IRQ_FLG_LOCK, "timer", NULL); + //return_value = request_irq( CPMVEC_TIMER1, timer_routine, IRQ_FLG_LOCK, "timer", NULL); + return_value = request_irq(CPMVEC_TIMER1 , timer_routine, IRQ_FLG_LOCK, + "Timer", NULL); /* Start timer 1: */ tgcr_save = (pquicc->timer_tgcr & 0xfff0) | 0x0001; diff --git a/trunk/arch/sparc64/kernel/viohs.c b/trunk/arch/sparc64/kernel/viohs.c index 708fa1705fbe..09126fc338ba 100644 --- a/trunk/arch/sparc64/kernel/viohs.c +++ b/trunk/arch/sparc64/kernel/viohs.c @@ -702,7 +702,7 @@ u32 vio_send_sid(struct vio_driver_state *vio) } EXPORT_SYMBOL(vio_send_sid); -int vio_ldc_alloc(struct vio_driver_state *vio, +extern int vio_ldc_alloc(struct vio_driver_state *vio, struct ldc_channel_config *base_cfg, void *event_arg) { diff --git a/trunk/arch/x86_64/ia32/ia32_binfmt.c b/trunk/arch/x86_64/ia32/ia32_binfmt.c index dffd2ac72747..b70f3e7cf06c 100644 --- a/trunk/arch/x86_64/ia32/ia32_binfmt.c +++ b/trunk/arch/x86_64/ia32/ia32_binfmt.c @@ -41,9 +41,8 @@ int sysctl_vsyscall32 = 1; #undef ARCH_DLINFO #define ARCH_DLINFO do { \ if (sysctl_vsyscall32) { \ - current->mm->context.vdso = (void *)VSYSCALL32_BASE; \ - NEW_AUX_ENT(AT_SYSINFO, (u32)(u64)VSYSCALL32_VSYSCALL); \ - NEW_AUX_ENT(AT_SYSINFO_EHDR, VSYSCALL32_BASE); \ + NEW_AUX_ENT(AT_SYSINFO, (u32)(u64)VSYSCALL32_VSYSCALL); \ + NEW_AUX_ENT(AT_SYSINFO_EHDR, VSYSCALL32_BASE); \ } \ } while(0) diff --git a/trunk/arch/x86_64/ia32/syscall32.c b/trunk/arch/x86_64/ia32/syscall32.c index 15013bac181c..fc4419ff0355 100644 --- a/trunk/arch/x86_64/ia32/syscall32.c +++ b/trunk/arch/x86_64/ia32/syscall32.c @@ -49,6 +49,14 @@ int syscall32_setup_pages(struct linux_binprm *bprm, int exstack) return ret; } +const char *arch_vma_name(struct vm_area_struct *vma) +{ + if (vma->vm_start == VSYSCALL32_BASE && + vma->vm_mm && vma->vm_mm->task_size == IA32_PAGE_OFFSET) + return "[vdso]"; + return NULL; +} + static int __init init_syscall32(void) { char *syscall32_page = (void *)get_zeroed_page(GFP_KERNEL); diff --git a/trunk/arch/x86_64/kernel/tce.c b/trunk/arch/x86_64/kernel/tce.c index 821527e7faa3..3aeae2fa2e24 100644 --- a/trunk/arch/x86_64/kernel/tce.c +++ b/trunk/arch/x86_64/kernel/tce.c @@ -165,7 +165,7 @@ int build_tce_table(struct pci_dev *dev, void __iomem *bbar) return ret; } -void * __init alloc_tce_table(void) +void* alloc_tce_table(void) { unsigned int size; @@ -175,7 +175,7 @@ void * __init alloc_tce_table(void) return __alloc_bootmem_low(size, size, 0); } -void __init free_tce_table(void *tbl) +void free_tce_table(void *tbl) { unsigned int size; diff --git a/trunk/arch/x86_64/kernel/tsc.c b/trunk/arch/x86_64/kernel/tsc.c index 2a59bde663f2..9b76b03d0600 100644 --- a/trunk/arch/x86_64/kernel/tsc.c +++ b/trunk/arch/x86_64/kernel/tsc.c @@ -118,6 +118,8 @@ core_initcall(cpufreq_tsc); #endif +static int tsc_unstable = 0; + /* * Make an educated guess if the TSC is trustworthy and synchronized * over all CPUs. diff --git a/trunk/arch/x86_64/mm/init.c b/trunk/arch/x86_64/mm/init.c index 458893b376f8..38f5d6368006 100644 --- a/trunk/arch/x86_64/mm/init.c +++ b/trunk/arch/x86_64/mm/init.c @@ -600,16 +600,6 @@ void mark_rodata_ro(void) { unsigned long start = (unsigned long)_stext, end; -#ifdef CONFIG_HOTPLUG_CPU - /* It must still be possible to apply SMP alternatives. */ - if (num_possible_cpus() > 1) - start = (unsigned long)_etext; -#endif - -#ifdef CONFIG_KPROBES - start = (unsigned long)__start_rodata; -#endif - end = (unsigned long)__end_rodata; start = (start + PAGE_SIZE - 1) & PAGE_MASK; end &= PAGE_MASK; diff --git a/trunk/drivers/acpi/Kconfig b/trunk/drivers/acpi/Kconfig index 22b401b2e088..251344cb29ae 100644 --- a/trunk/drivers/acpi/Kconfig +++ b/trunk/drivers/acpi/Kconfig @@ -11,6 +11,9 @@ menuconfig ACPI depends on PCI depends on PM select PNP + # for sleep + select HOTPLUG_CPU if X86 && SMP + select SUSPEND_SMP if X86 && SMP default y ---help--- Advanced Configuration and Power Interface (ACPI) support for diff --git a/trunk/drivers/base/power/shutdown.c b/trunk/drivers/base/power/shutdown.c index 56e8eaaac012..a47ee1b70d20 100644 --- a/trunk/drivers/base/power/shutdown.c +++ b/trunk/drivers/base/power/shutdown.c @@ -44,5 +44,7 @@ void device_shutdown(void) dev->driver->shutdown(dev); } } + + sysdev_shutdown(); } diff --git a/trunk/drivers/block/lguest_blk.c b/trunk/drivers/block/lguest_blk.c index 93e3c4001bf5..5b79d0724171 100644 --- a/trunk/drivers/block/lguest_blk.c +++ b/trunk/drivers/block/lguest_blk.c @@ -1,12 +1,6 @@ -/*D:400 - * The Guest block driver +/* A simple block driver for lguest. * - * This is a simple block driver, which appears as /dev/lgba, lgbb, lgbc etc. - * The mechanism is simple: we place the information about the request in the - * device page, then use SEND_DMA (containing the data for a write, or an empty - * "ping" DMA for a read). - :*/ -/* Copyright 2006 Rusty Russell IBM Corporation + * Copyright 2006 Rusty Russell IBM Corporation * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -31,50 +25,27 @@ static char next_block_index = 'a'; -/*D:420 Here is the structure which holds all the information we need about - * each Guest block device. - * - * I'm sure at this stage, you're wondering "hey, where was the adventure I was - * promised?" and thinking "Rusty sucks, I shall say nasty things about him on - * my blog". I think Real adventures have boring bits, too, and you're in the - * middle of one. But it gets better. Just not quite yet. */ struct blockdev { - /* The block queue infrastructure wants a spinlock: it is held while it - * calls our block request function. We grab it in our interrupt - * handler so the responses don't mess with new requests. */ spinlock_t lock; - /* The disk structure registered with kernel. */ + /* The disk structure for the kernel. */ struct gendisk *disk; - /* The major device number for this disk, and the interrupt. We only - * really keep them here for completeness; we'd need them if we - * supported device unplugging. */ + /* The major number for this disk. */ int major; int irq; - /* The physical address of this device's memory page */ unsigned long phys_addr; - /* The mapped memory page for convenient acces. */ + /* The mapped block page. */ struct lguest_block_page *lb_page; - /* We only have a single request outstanding at a time: this is it. */ + /* We only have a single request outstanding at a time. */ struct lguest_dma dma; struct request *req; }; -/*D:495 We originally used end_request() throughout the driver, but it turns - * out that end_request() is deprecated, and doesn't actually end the request - * (which seems like a good reason to deprecate it!). It simply ends the first - * bio. So if we had 3 bios in a "struct request" we would do all 3, - * end_request(), do 2, end_request(), do 1 and end_request(): twice as much - * work as we needed to do. - * - * This reinforced to me that I do not understand the block layer. - * - * Nonetheless, Jens Axboe gave me this nice helper to end all chunks of a - * request. This improved disk speed by 130%. */ +/* Jens gave me this nice helper to end all chunks of a request. */ static void end_entire_request(struct request *req, int uptodate) { if (end_that_request_first(req, uptodate, req->hard_nr_sectors)) @@ -84,62 +55,30 @@ static void end_entire_request(struct request *req, int uptodate) end_that_request_last(req, uptodate); } -/* I'm told there are only two stories in the world worth telling: love and - * hate. So there used to be a love scene here like this: - * - * Launcher: We could make beautiful I/O together, you and I. - * Guest: My, that's a big disk! - * - * Unfortunately, it was just too raunchy for our otherwise-gentle tale. */ - -/*D:490 This is the interrupt handler, called when a block read or write has - * been completed for us. */ static irqreturn_t lgb_irq(int irq, void *_bd) { - /* We handed our "struct blockdev" as the argument to request_irq(), so - * it is passed through to us here. This tells us which device we're - * dealing with in case we have more than one. */ struct blockdev *bd = _bd; unsigned long flags; - /* We weren't doing anything? Strange, but could happen if we shared - * interrupts (we don't!). */ if (!bd->req) { pr_debug("No work!\n"); return IRQ_NONE; } - /* Not done yet? That's equally strange. */ if (!bd->lb_page->result) { pr_debug("No result!\n"); return IRQ_NONE; } - /* We have to grab the lock before ending the request. */ spin_lock_irqsave(&bd->lock, flags); - /* "result" is 1 for success, 2 for failure: end_entire_request() wants - * to know whether this succeeded or not. */ end_entire_request(bd->req, bd->lb_page->result == 1); - /* Clear out request, it's done. */ bd->req = NULL; - /* Reset incoming DMA for next time. */ bd->dma.used_len = 0; - /* Ready for more reads or writes */ blk_start_queue(bd->disk->queue); spin_unlock_irqrestore(&bd->lock, flags); - - /* The interrupt was for us, we dealt with it. */ return IRQ_HANDLED; } -/*D:480 The block layer's "struct request" contains a number of "struct bio"s, - * each of which contains "struct bio_vec"s, each of which contains a page, an - * offset and a length. - * - * Fortunately there are iterators to help us walk through the "struct - * request". Even more fortunately, there were plenty of places to steal the - * code from. We pack the "struct request" into our "struct lguest_dma" and - * return the total length. */ static unsigned int req_to_dma(struct request *req, struct lguest_dma *dma) { unsigned int i = 0, idx, len = 0; @@ -148,13 +87,8 @@ static unsigned int req_to_dma(struct request *req, struct lguest_dma *dma) rq_for_each_bio(bio, req) { struct bio_vec *bvec; bio_for_each_segment(bvec, bio, idx) { - /* We told the block layer not to give us too many. */ BUG_ON(i == LGUEST_MAX_DMA_SECTIONS); - /* If we had a zero-length segment, it would look like - * the end of the data referred to by the "struct - * lguest_dma", so make sure that doesn't happen. */ BUG_ON(!bvec->bv_len); - /* Convert page & offset to a physical address */ dma->addr[i] = page_to_phys(bvec->bv_page) + bvec->bv_offset; dma->len[i] = bvec->bv_len; @@ -162,39 +96,26 @@ static unsigned int req_to_dma(struct request *req, struct lguest_dma *dma) i++; } } - /* If the array isn't full, we mark the end with a 0 length */ if (i < LGUEST_MAX_DMA_SECTIONS) dma->len[i] = 0; return len; } -/* This creates an empty DMA, useful for prodding the Host without sending data - * (ie. when we want to do a read) */ static void empty_dma(struct lguest_dma *dma) { dma->len[0] = 0; } -/*D:470 Setting up a request is fairly easy: */ static void setup_req(struct blockdev *bd, int type, struct request *req, struct lguest_dma *dma) { - /* The type is 1 (write) or 0 (read). */ bd->lb_page->type = type; - /* The sector on disk where the read or write starts. */ bd->lb_page->sector = req->sector; - /* The result is initialized to 0 (unfinished). */ bd->lb_page->result = 0; - /* The current request (so we can end it in the interrupt handler). */ bd->req = req; - /* The number of bytes: returned as a side-effect of req_to_dma(), - * which packs the block layer's "struct request" into our "struct - * lguest_dma" */ bd->lb_page->bytes = req_to_dma(req, dma); } -/*D:450 Write is pretty straightforward: we pack the request into a "struct - * lguest_dma", then use SEND_DMA to send the request. */ static void do_write(struct blockdev *bd, struct request *req) { struct lguest_dma send; @@ -205,9 +126,6 @@ static void do_write(struct blockdev *bd, struct request *req) lguest_send_dma(bd->phys_addr, &send); } -/* Read is similar to write, except we pack the request into our receive - * "struct lguest_dma" and send through an empty DMA just to tell the Host that - * there's a request pending. */ static void do_read(struct blockdev *bd, struct request *req) { struct lguest_dma ping; @@ -219,30 +137,21 @@ static void do_read(struct blockdev *bd, struct request *req) lguest_send_dma(bd->phys_addr, &ping); } -/*D:440 This where requests come in: we get handed the request queue and are - * expected to pull a "struct request" off it until we've finished them or - * we're waiting for a reply: */ static void do_lgb_request(struct request_queue *q) { struct blockdev *bd; struct request *req; again: - /* This sometimes returns NULL even on the very first time around. I - * wonder if it's something to do with letting elves handle the request - * queue... */ req = elv_next_request(q); if (!req) return; - /* We attached the struct blockdev to the disk: get it back */ bd = req->rq_disk->private_data; - /* Sometimes we get repeated requests after blk_stop_queue(), but we - * can only handle one at a time. */ + /* Sometimes we get repeated requests after blk_stop_queue. */ if (bd->req) return; - /* We only do reads and writes: no tricky business! */ if (!blk_fs_request(req)) { pr_debug("Got non-command 0x%08x\n", req->cmd_type); req->errors++; @@ -255,31 +164,20 @@ static void do_lgb_request(struct request_queue *q) else do_read(bd, req); - /* We've put out the request, so stop any more coming in until we get - * an interrupt, which takes us to lgb_irq() to re-enable the queue. */ + /* Wait for interrupt to tell us it's done. */ blk_stop_queue(q); } -/*D:430 This is the "struct block_device_operations" we attach to the disk at - * the end of lguestblk_probe(). It doesn't seem to want much. */ static struct block_device_operations lguestblk_fops = { .owner = THIS_MODULE, }; -/*D:425 Setting up a disk device seems to involve a lot of code. I'm not sure - * quite why. I do know that the IDE code sent two or three of the maintainers - * insane, perhaps this is the fringe of the same disease? - * - * As in the console code, the probe function gets handed the generic - * lguest_device from lguest_bus.c: */ static int lguestblk_probe(struct lguest_device *lgdev) { struct blockdev *bd; int err; int irqflags = IRQF_SHARED; - /* First we allocate our own "struct blockdev" and initialize the easy - * fields. */ bd = kmalloc(sizeof(*bd), GFP_KERNEL); if (!bd) return -ENOMEM; @@ -289,100 +187,59 @@ static int lguestblk_probe(struct lguest_device *lgdev) bd->req = NULL; bd->dma.used_len = 0; bd->dma.len[0] = 0; - /* The descriptor in the lguest_devices array provided by the Host - * gives the Guest the physical page number of the device's page. */ bd->phys_addr = (lguest_devices[lgdev->index].pfn << PAGE_SHIFT); - /* We use lguest_map() to get a pointer to the device page */ bd->lb_page = lguest_map(bd->phys_addr, 1); if (!bd->lb_page) { err = -ENOMEM; goto out_free_bd; } - /* We need a major device number: 0 means "assign one dynamically". */ bd->major = register_blkdev(0, "lguestblk"); if (bd->major < 0) { err = bd->major; goto out_unmap; } - /* This allocates a "struct gendisk" where we pack all the information - * about the disk which the rest of Linux sees. We ask for one minor - * number; I do wonder if we should be asking for more. */ bd->disk = alloc_disk(1); if (!bd->disk) { err = -ENOMEM; goto out_unregister_blkdev; } - /* Every disk needs a queue for requests to come in: we set up the - * queue with a callback function (the core of our driver) and the lock - * to use. */ bd->disk->queue = blk_init_queue(do_lgb_request, &bd->lock); if (!bd->disk->queue) { err = -ENOMEM; goto out_put_disk; } - /* We can only handle a certain number of pointers in our SEND_DMA - * call, so we set that with blk_queue_max_hw_segments(). This is not - * to be confused with blk_queue_max_phys_segments() of course! I - * know, who could possibly confuse the two? - * - * Well, it's simple to tell them apart: this one seems to work and the - * other one didn't. */ + /* We can only handle a certain number of sg entries */ blk_queue_max_hw_segments(bd->disk->queue, LGUEST_MAX_DMA_SECTIONS); - - /* Due to technical limitations of our Host (and simple coding) we - * can't have a single buffer which crosses a page boundary. Tell it - * here. This means that our maximum request size is 16 - * (LGUEST_MAX_DMA_SECTIONS) pages. */ + /* Buffers must not cross page boundaries */ blk_queue_segment_boundary(bd->disk->queue, PAGE_SIZE-1); - /* We name our disk: this becomes the device name when udev does its - * magic thing and creates the device node, such as /dev/lgba. - * next_block_index is a global which starts at 'a'. Unfortunately - * this simple increment logic means that the 27th disk will be called - * "/dev/lgb{". In that case, I recommend having at least 29 disks, so - * your /dev directory will be balanced. */ sprintf(bd->disk->disk_name, "lgb%c", next_block_index++); - - /* We look to the device descriptor again to see if this device's - * interrupts are expected to be random. If they are, we tell the irq - * subsystem. At the moment this bit is always set. */ if (lguest_devices[lgdev->index].features & LGUEST_DEVICE_F_RANDOMNESS) irqflags |= IRQF_SAMPLE_RANDOM; - - /* Now we have the name and irqflags, we can request the interrupt; we - * give it the "struct blockdev" we have set up to pass to lgb_irq() - * when there is an interrupt. */ err = request_irq(bd->irq, lgb_irq, irqflags, bd->disk->disk_name, bd); if (err) goto out_cleanup_queue; - /* We bind our one-entry DMA pool to the key for this block device so - * the Host can reply to our requests. The key is equal to the - * physical address of the device's page, which is conveniently - * unique. */ err = lguest_bind_dma(bd->phys_addr, &bd->dma, 1, bd->irq); if (err) goto out_free_irq; - /* We finish our disk initialization and add the disk to the system. */ bd->disk->major = bd->major; bd->disk->first_minor = 0; bd->disk->private_data = bd; bd->disk->fops = &lguestblk_fops; - /* This is initialized to the disk size by the Launcher. */ + /* This is initialized to the disk size by the other end. */ set_capacity(bd->disk, bd->lb_page->num_sectors); add_disk(bd->disk); printk(KERN_INFO "%s: device %i at major %d\n", bd->disk->disk_name, lgdev->index, bd->major); - /* We don't need to keep the "struct blockdev" around, but if we ever - * implemented device removal, we'd need this. */ lgdev->private = bd; return 0; @@ -401,8 +258,6 @@ static int lguestblk_probe(struct lguest_device *lgdev) return err; } -/*D:410 The boilerplate code for registering the lguest block driver is just - * like the console: */ static struct lguest_driver lguestblk_drv = { .name = "lguestblk", .owner = THIS_MODULE, diff --git a/trunk/drivers/char/Kconfig b/trunk/drivers/char/Kconfig index b391776e5bf3..acdbcdc3e457 100644 --- a/trunk/drivers/char/Kconfig +++ b/trunk/drivers/char/Kconfig @@ -130,7 +130,6 @@ config ROCKETPORT config CYCLADES tristate "Cyclades async mux support" depends on SERIAL_NONSTANDARD && (PCI || ISA) - select FW_LOADER ---help--- This driver supports Cyclades Z and Y multiserial boards. You would need something like this to connect more than two modems to diff --git a/trunk/drivers/char/hpet.c b/trunk/drivers/char/hpet.c index 77bf4aa217a8..9a2694e5f8b9 100644 --- a/trunk/drivers/char/hpet.c +++ b/trunk/drivers/char/hpet.c @@ -73,7 +73,7 @@ static struct clocksource clocksource_hpet = { .name = "hpet", .rating = 250, .read = read_hpet, - .mask = CLOCKSOURCE_MASK(64), + .mask = 0xffffffffffffffff, .mult = 0, /*to be caluclated*/ .shift = 10, .flags = CLOCK_SOURCE_IS_CONTINUOUS, diff --git a/trunk/drivers/char/hvc_lguest.c b/trunk/drivers/char/hvc_lguest.c index feeccbaec438..e7b889e404a7 100644 --- a/trunk/drivers/char/hvc_lguest.c +++ b/trunk/drivers/char/hvc_lguest.c @@ -1,22 +1,6 @@ -/*D:300 - * The Guest console driver +/* Simple console for lguest. * - * This is a trivial console driver: we use lguest's DMA mechanism to send - * bytes out, and register a DMA buffer to receive bytes in. It is assumed to - * be present and available from the very beginning of boot. - * - * Writing console drivers is one of the few remaining Dark Arts in Linux. - * Fortunately for us, the path of virtual consoles has been well-trodden by - * the PowerPC folks, who wrote "hvc_console.c" to generically support any - * virtual console. We use that infrastructure which only requires us to write - * the basic put_chars and get_chars functions and call the right register - * functions. - :*/ - -/*M:002 The console can be flooded: while the Guest is processing input the - * Host can send more. Buffering in the Host could alleviate this, but it is a - * difficult problem in general. :*/ -/* Copyright (C) 2006 Rusty Russell, IBM Corporation + * Copyright (C) 2006 Rusty Russell, IBM Corporation * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -37,81 +21,49 @@ #include #include "hvc_console.h" -/*D:340 This is our single console input buffer, with associated "struct - * lguest_dma" referring to it. Note the 0-terminated length array, and the - * use of physical address for the buffer itself. */ static char inbuf[256]; static struct lguest_dma cons_input = { .used_len = 0, .addr[0] = __pa(inbuf), .len[0] = sizeof(inbuf), .len[1] = 0 }; -/*D:310 The put_chars() callback is pretty straightforward. - * - * First we put the pointer and length in a "struct lguest_dma": we only have - * one pointer, so we set the second length to 0. Then we use SEND_DMA to send - * the data to (Host) buffers attached to the console key. Usually a device's - * key is a physical address within the device's memory, but because the - * console device doesn't have any associated physical memory, we use the - * LGUEST_CONSOLE_DMA_KEY constant (aka 0). */ static int put_chars(u32 vtermno, const char *buf, int count) { struct lguest_dma dma; - /* FIXME: DMA buffers in a "struct lguest_dma" are not allowed - * to go over page boundaries. This never seems to happen, - * but if it did we'd need to fix this code. */ + /* FIXME: what if it's over a page boundary? */ dma.len[0] = count; dma.len[1] = 0; dma.addr[0] = __pa(buf); lguest_send_dma(LGUEST_CONSOLE_DMA_KEY, &dma); - /* We're expected to return the amount of data we wrote: all of it. */ return count; } -/*D:350 get_chars() is the callback from the hvc_console infrastructure when - * an interrupt is received. - * - * Firstly we see if our buffer has been filled: if not, we return. The rest - * of the code deals with the fact that the hvc_console() infrastructure only - * asks us for 16 bytes at a time. We keep a "cons_offset" variable for - * partially-read buffers. */ static int get_chars(u32 vtermno, char *buf, int count) { static int cons_offset; - /* Nothing left to see here... */ if (!cons_input.used_len) return 0; - /* You want more than we have to give? Well, try wanting less! */ if (cons_input.used_len - cons_offset < count) count = cons_input.used_len - cons_offset; - /* Copy across to their buffer and increment offset. */ memcpy(buf, inbuf + cons_offset, count); cons_offset += count; - - /* Finished? Zero offset, and reset cons_input so Host will use it - * again. */ if (cons_offset == cons_input.used_len) { cons_offset = 0; cons_input.used_len = 0; } return count; } -/*:*/ static struct hv_ops lguest_cons = { .get_chars = get_chars, .put_chars = put_chars, }; -/*D:320 Console drivers are initialized very early so boot messages can go - * out. At this stage, the console is output-only. Our driver checks we're a - * Guest, and if so hands hvc_instantiate() the console number (0), priority - * (0), and the struct hv_ops containing the put_chars() function. */ static int __init cons_init(void) { if (strcmp(paravirt_ops.name, "lguest") != 0) @@ -121,46 +73,21 @@ static int __init cons_init(void) } console_initcall(cons_init); -/*D:370 To set up and manage our virtual console, we call hvc_alloc() and - * stash the result in the private pointer of the "struct lguest_device". - * Since we never remove the console device we never need this pointer again, - * but using ->private is considered good form, and you never know who's going - * to copy your driver. - * - * Once the console is set up, we bind our input buffer ready for input. */ static int lguestcons_probe(struct lguest_device *lgdev) { int err; - /* The first argument of hvc_alloc() is the virtual console number, so - * we use zero. The second argument is the interrupt number. - * - * The third argument is a "struct hv_ops" containing the put_chars() - * and get_chars() pointers. The final argument is the output buffer - * size: we use 256 and expect the Host to have room for us to send - * that much. */ lgdev->private = hvc_alloc(0, lgdev_irq(lgdev), &lguest_cons, 256); if (IS_ERR(lgdev->private)) return PTR_ERR(lgdev->private); - /* We bind a single DMA buffer at key LGUEST_CONSOLE_DMA_KEY. - * "cons_input" is that statically-initialized global DMA buffer we saw - * above, and we also give the interrupt we want. */ err = lguest_bind_dma(LGUEST_CONSOLE_DMA_KEY, &cons_input, 1, lgdev_irq(lgdev)); if (err) printk("lguest console: failed to bind buffer.\n"); return err; } -/* Note the use of lgdev_irq() for the interrupt number. We tell hvc_alloc() - * to expect input when this interrupt is triggered, and then tell - * lguest_bind_dma() that is the interrupt to send us when input comes in. */ -/*D:360 From now on the console driver follows standard Guest driver form: - * register_lguest_driver() registers the device type and probe function, and - * the probe function sets up the device. - * - * The standard "struct lguest_driver": */ static struct lguest_driver lguestcons_drv = { .name = "lguestcons", .owner = THIS_MODULE, @@ -168,7 +95,6 @@ static struct lguest_driver lguestcons_drv = { .probe = lguestcons_probe, }; -/* The standard init function */ static int __init hvc_lguest_init(void) { return register_lguest_driver(&lguestcons_drv); diff --git a/trunk/drivers/edac/Kconfig b/trunk/drivers/edac/Kconfig index 98b6b4fb4257..1724c41d2414 100644 --- a/trunk/drivers/edac/Kconfig +++ b/trunk/drivers/edac/Kconfig @@ -8,7 +8,7 @@ menuconfig EDAC bool "EDAC - error detection and reporting (EXPERIMENTAL)" depends on HAS_IOMEM depends on EXPERIMENTAL - depends on X86 || PPC + depends on X86 || MIPS || PPC help EDAC is designed to report errors in the core system. These are low-level errors that are reported in the CPU or @@ -126,7 +126,7 @@ config EDAC_I5000 config EDAC_PASEMI tristate "PA Semi PWRficient" depends on EDAC_MM_EDAC && PCI - depends on PPC_PASEMI + depends on PPC help Support for error detection and correction on PA Semi PWRficient. diff --git a/trunk/drivers/edac/edac_mc.c b/trunk/drivers/edac/edac_mc.c index 063a1bffe38b..4471be362599 100644 --- a/trunk/drivers/edac/edac_mc.c +++ b/trunk/drivers/edac/edac_mc.c @@ -214,13 +214,6 @@ void edac_mc_free(struct mem_ctl_info *mci) } EXPORT_SYMBOL_GPL(edac_mc_free); - -/* - * find_mci_by_dev - * - * scan list of controllers looking for the one that manages - * the 'dev' device - */ static struct mem_ctl_info *find_mci_by_dev(struct device *dev) { struct mem_ctl_info *mci; @@ -275,6 +268,12 @@ static void edac_mc_workq_function(struct work_struct *work_req) if (edac_mc_assert_error_check_and_clear() && (mci->edac_check != NULL)) mci->edac_check(mci); + /* + * FIXME: temp place holder for PCI checks, + * goes away when we break out PCI + */ + edac_pci_do_parity_check(); + mutex_unlock(&mem_ctls_mutex); /* Reschedule */ @@ -315,55 +314,36 @@ static void edac_mc_workq_teardown(struct mem_ctl_info *mci) { int status; - status = cancel_delayed_work(&mci->work); - if (status == 0) { - debugf0("%s() not canceled, flush the queue\n", - __func__); + /* if not running POLL, leave now */ + if (mci->op_state == OP_RUNNING_POLL) { + status = cancel_delayed_work(&mci->work); + if (status == 0) { + debugf0("%s() not canceled, flush the queue\n", + __func__); - /* workq instance might be running, wait for it */ - flush_workqueue(edac_workqueue); + /* workq instance might be running, wait for it */ + flush_workqueue(edac_workqueue); + } } } /* - * edac_mc_reset_delay_period(unsigned long value) - * - * user space has updated our poll period value, need to - * reset our workq delays + * edac_reset_delay_period */ -void edac_mc_reset_delay_period(int value) +static void edac_reset_delay_period(struct mem_ctl_info *mci, unsigned long value) { - struct mem_ctl_info *mci; - struct list_head *item; - - mutex_lock(&mem_ctls_mutex); - - /* scan the list and turn off all workq timers, doing so under lock - */ - list_for_each(item, &mc_devices) { - mci = list_entry(item, struct mem_ctl_info, link); - - if (mci->op_state == OP_RUNNING_POLL) - cancel_delayed_work(&mci->work); - } - - mutex_unlock(&mem_ctls_mutex); - + /* cancel the current workq request */ + edac_mc_workq_teardown(mci); - /* re-walk the list, and reset the poll delay */ + /* lock the list of devices for the new setup */ mutex_lock(&mem_ctls_mutex); - list_for_each(item, &mc_devices) { - mci = list_entry(item, struct mem_ctl_info, link); - - edac_mc_workq_setup(mci, (unsigned long) value); - } + /* restart the workq request, with new delay value */ + edac_mc_workq_setup(mci, value); mutex_unlock(&mem_ctls_mutex); } - - /* Return 0 on success, 1 on failure. * Before calling this function, caller must * assign a unique value to mci->mc_idx. diff --git a/trunk/drivers/edac/edac_mc_sysfs.c b/trunk/drivers/edac/edac_mc_sysfs.c index 4a0576bd06fc..cd090b0677a7 100644 --- a/trunk/drivers/edac/edac_mc_sysfs.c +++ b/trunk/drivers/edac/edac_mc_sysfs.c @@ -122,23 +122,6 @@ static ssize_t memctrl_int_store(void *ptr, const char *buffer, size_t count) return count; } -/* - * mc poll_msec time value - */ -static ssize_t poll_msec_int_store(void *ptr, const char *buffer, size_t count) -{ - int *value = (int *)ptr; - - if (isdigit(*buffer)) { - *value = simple_strtoul(buffer, NULL, 0); - - /* notify edac_mc engine to reset the poll period */ - edac_mc_reset_delay_period(*value); - } - - return count; -} - /* EDAC sysfs CSROW data structures and methods */ @@ -721,7 +704,7 @@ MEMCTRL_ATTR(edac_mc_log_ce, S_IRUGO | S_IWUSR, memctrl_int_show, memctrl_int_store); MEMCTRL_ATTR(edac_mc_poll_msec, - S_IRUGO | S_IWUSR, memctrl_int_show, poll_msec_int_store); + S_IRUGO | S_IWUSR, memctrl_int_show, memctrl_int_store); /* Base Attributes of the memory ECC object */ static struct memctrl_dev_attribute *memctrl_attr[] = { diff --git a/trunk/drivers/edac/edac_module.h b/trunk/drivers/edac/edac_module.h index cbc419c8ebc1..a2134dfc3cc6 100644 --- a/trunk/drivers/edac/edac_module.h +++ b/trunk/drivers/edac/edac_module.h @@ -52,8 +52,6 @@ extern void edac_device_workq_setup(struct edac_device_ctl_info *edac_dev, extern void edac_device_workq_teardown(struct edac_device_ctl_info *edac_dev); extern void edac_device_reset_delay_period(struct edac_device_ctl_info *edac_dev, unsigned long value); -extern void edac_mc_reset_delay_period(int value); - extern void *edac_align_ptr(void *ptr, unsigned size); /* @@ -66,10 +64,6 @@ extern int edac_sysfs_pci_setup(void); extern void edac_sysfs_pci_teardown(void); extern int edac_pci_get_check_errors(void); extern int edac_pci_get_poll_msec(void); -extern void edac_pci_remove_sysfs(struct edac_pci_ctl_info *pci); -extern void edac_pci_handle_pe(struct edac_pci_ctl_info *pci, const char *msg); -extern void edac_pci_handle_npe(struct edac_pci_ctl_info *pci, - const char *msg); #else /* CONFIG_PCI */ /* pre-process these away */ #define edac_pci_do_parity_check() @@ -78,8 +72,6 @@ extern void edac_pci_handle_npe(struct edac_pci_ctl_info *pci, #define edac_sysfs_pci_teardown() #define edac_pci_get_check_errors() #define edac_pci_get_poll_msec() -#define edac_pci_handle_pe() -#define edac_pci_handle_npe() #endif /* CONFIG_PCI */ #endif /* __EDAC_MODULE_H__ */ diff --git a/trunk/drivers/edac/edac_pci.c b/trunk/drivers/edac/edac_pci.c index 5dee9f50414b..d9cd5e048cee 100644 --- a/trunk/drivers/edac/edac_pci.c +++ b/trunk/drivers/edac/edac_pci.c @@ -31,12 +31,20 @@ static DEFINE_MUTEX(edac_pci_ctls_mutex); static struct list_head edac_pci_list = LIST_HEAD_INIT(edac_pci_list); +static inline void edac_lock_pci_list(void) +{ + mutex_lock(&edac_pci_ctls_mutex); +} + +static inline void edac_unlock_pci_list(void) +{ + mutex_unlock(&edac_pci_ctls_mutex); +} + /* - * edac_pci_alloc_ctl_info - * - * The alloc() function for the 'edac_pci' control info - * structure. The chip driver will allocate one of these for each - * edac_pci it is going to control/register with the EDAC CORE. + * The alloc() and free() functions for the 'edac_pci' control info + * structure. The chip driver will allocate one of these for each + * edac_pci it is going to control/register with the EDAC CORE. */ struct edac_pci_ctl_info *edac_pci_alloc_ctl_info(unsigned int sz_pvt, const char *edac_pci_name) @@ -45,59 +53,47 @@ struct edac_pci_ctl_info *edac_pci_alloc_ctl_info(unsigned int sz_pvt, void *pvt; unsigned int size; - debugf1("%s()\n", __func__); - pci = (struct edac_pci_ctl_info *)0; pvt = edac_align_ptr(&pci[1], sz_pvt); size = ((unsigned long)pvt) + sz_pvt; - /* Alloc the needed control struct memory */ - pci = kzalloc(size, GFP_KERNEL); - if (pci == NULL) + if ((pci = kzalloc(size, GFP_KERNEL)) == NULL) return NULL; - /* Now much private space */ pvt = sz_pvt ? ((char *)pci) + ((unsigned long)pvt) : NULL; pci->pvt_info = pvt; + pci->op_state = OP_ALLOC; snprintf(pci->name, strlen(edac_pci_name) + 1, "%s", edac_pci_name); return pci; } + EXPORT_SYMBOL_GPL(edac_pci_alloc_ctl_info); /* * edac_pci_free_ctl_info() - * - * Last action on the pci control structure. - * - * call the remove sysfs informaton, which will unregister - * this control struct's kobj. When that kobj's ref count - * goes to zero, its release function will be call and then - * kfree() the memory. + * frees the memory allocated by edac_pci_alloc_ctl_info() function */ void edac_pci_free_ctl_info(struct edac_pci_ctl_info *pci) { - debugf1("%s()\n", __func__); - - edac_pci_remove_sysfs(pci); + kfree(pci); } + EXPORT_SYMBOL_GPL(edac_pci_free_ctl_info); /* * find_edac_pci_by_dev() * scans the edac_pci list for a specific 'struct device *' - * - * return NULL if not found, or return control struct pointer */ static struct edac_pci_ctl_info *find_edac_pci_by_dev(struct device *dev) { struct edac_pci_ctl_info *pci; struct list_head *item; - debugf1("%s()\n", __func__); + debugf3("%s()\n", __func__); list_for_each(item, &edac_pci_list) { pci = list_entry(item, struct edac_pci_ctl_info, link); @@ -122,13 +118,10 @@ static int add_edac_pci_to_global_list(struct edac_pci_ctl_info *pci) struct list_head *item, *insert_before; struct edac_pci_ctl_info *rover; - debugf1("%s()\n", __func__); - insert_before = &edac_pci_list; /* Determine if already on the list */ - rover = find_edac_pci_by_dev(pci->dev); - if (unlikely(rover != NULL)) + if (unlikely((rover = find_edac_pci_by_dev(pci->dev)) != NULL)) goto fail0; /* Insert in ascending order by 'pci_idx', so find position */ @@ -164,8 +157,6 @@ static int add_edac_pci_to_global_list(struct edac_pci_ctl_info *pci) /* * complete_edac_pci_list_del - * - * RCU completion callback to indicate item is deleted */ static void complete_edac_pci_list_del(struct rcu_head *head) { @@ -178,8 +169,6 @@ static void complete_edac_pci_list_del(struct rcu_head *head) /* * del_edac_pci_from_global_list - * - * remove the PCI control struct from the global list */ static void del_edac_pci_from_global_list(struct edac_pci_ctl_info *pci) { @@ -218,52 +207,35 @@ struct edac_pci_ctl_info *edac_pci_find(int idx) return NULL; } + EXPORT_SYMBOL_GPL(edac_pci_find); /* * edac_pci_workq_function() - * - * periodic function that performs the operation - * scheduled by a workq request, for a given PCI control struct + * performs the operation scheduled by a workq request */ static void edac_pci_workq_function(struct work_struct *work_req) { struct delayed_work *d_work = (struct delayed_work *)work_req; struct edac_pci_ctl_info *pci = to_edac_pci_ctl_work(d_work); - int msec; - unsigned long delay; - debugf3("%s() checking\n", __func__); + edac_lock_pci_list(); - mutex_lock(&edac_pci_ctls_mutex); + if ((pci->op_state == OP_RUNNING_POLL) && + (pci->edac_check != NULL) && (edac_pci_get_check_errors())) + pci->edac_check(pci); - if (pci->op_state == OP_RUNNING_POLL) { - /* we might be in POLL mode, but there may NOT be a poll func - */ - if ((pci->edac_check != NULL) && edac_pci_get_check_errors()) - pci->edac_check(pci); - - /* if we are on a one second period, then use round */ - msec = edac_pci_get_poll_msec(); - if (msec == 1000) - delay = round_jiffies(msecs_to_jiffies(msec)); - else - delay = msecs_to_jiffies(msec); - - /* Reschedule only if we are in POLL mode */ - queue_delayed_work(edac_workqueue, &pci->work, delay); - } + edac_unlock_pci_list(); - mutex_unlock(&edac_pci_ctls_mutex); + /* Reschedule */ + queue_delayed_work(edac_workqueue, &pci->work, + msecs_to_jiffies(edac_pci_get_poll_msec())); } /* * edac_pci_workq_setup() * initialize a workq item for this edac_pci instance * passing in the new delay period in msec - * - * locking model: - * called when 'edac_pci_ctls_mutex' is locked */ static void edac_pci_workq_setup(struct edac_pci_ctl_info *pci, unsigned int msec) @@ -283,8 +255,6 @@ static void edac_pci_workq_teardown(struct edac_pci_ctl_info *pci) { int status; - debugf0("%s()\n", __func__); - status = cancel_delayed_work(&pci->work); if (status == 0) flush_workqueue(edac_workqueue); @@ -292,25 +262,19 @@ static void edac_pci_workq_teardown(struct edac_pci_ctl_info *pci) /* * edac_pci_reset_delay_period - * - * called with a new period value for the workq period - * a) stop current workq timer - * b) restart workq timer with new value */ void edac_pci_reset_delay_period(struct edac_pci_ctl_info *pci, unsigned long value) { - debugf0("%s()\n", __func__); + edac_lock_pci_list(); edac_pci_workq_teardown(pci); - /* need to lock for the setup */ - mutex_lock(&edac_pci_ctls_mutex); - edac_pci_workq_setup(pci, value); - mutex_unlock(&edac_pci_ctls_mutex); + edac_unlock_pci_list(); } + EXPORT_SYMBOL_GPL(edac_pci_reset_delay_period); /* @@ -330,13 +294,14 @@ int edac_pci_add_device(struct edac_pci_ctl_info *pci, int edac_idx) debugf0("%s()\n", __func__); pci->pci_idx = edac_idx; - pci->start_time = jiffies; - mutex_lock(&edac_pci_ctls_mutex); + edac_lock_pci_list(); if (add_edac_pci_to_global_list(pci)) goto fail0; + pci->start_time = jiffies; + if (edac_pci_create_sysfs(pci)) { edac_pci_printk(pci, KERN_WARNING, "failed to create sysfs pci\n"); @@ -358,16 +323,16 @@ int edac_pci_add_device(struct edac_pci_ctl_info *pci, int edac_idx) pci->ctl_name, dev_name(pci), edac_op_state_to_string(pci->op_state)); - mutex_unlock(&edac_pci_ctls_mutex); + edac_unlock_pci_list(); return 0; - /* error unwind stack */ fail1: del_edac_pci_from_global_list(pci); fail0: - mutex_unlock(&edac_pci_ctls_mutex); + edac_unlock_pci_list(); return 1; } + EXPORT_SYMBOL_GPL(edac_pci_add_device); /* @@ -389,25 +354,22 @@ struct edac_pci_ctl_info *edac_pci_del_device(struct device *dev) debugf0("%s()\n", __func__); - mutex_lock(&edac_pci_ctls_mutex); + edac_lock_pci_list(); - /* ensure the control struct is on the global list - * if not, then leave - */ - pci = find_edac_pci_by_dev(dev); - if (pci == NULL) { - mutex_unlock(&edac_pci_ctls_mutex); + if ((pci = find_edac_pci_by_dev(dev)) == NULL) { + edac_unlock_pci_list(); return NULL; } pci->op_state = OP_OFFLINE; - del_edac_pci_from_global_list(pci); + edac_pci_workq_teardown(pci); - mutex_unlock(&edac_pci_ctls_mutex); + edac_pci_remove_sysfs(pci); - /* stop the workq timer */ - edac_pci_workq_teardown(pci); + del_edac_pci_from_global_list(pci); + + edac_unlock_pci_list(); edac_printk(KERN_INFO, EDAC_PCI, "Removed device %d for %s %s: DEV %s\n", @@ -415,20 +377,14 @@ struct edac_pci_ctl_info *edac_pci_del_device(struct device *dev) return pci; } + EXPORT_SYMBOL_GPL(edac_pci_del_device); -/* - * edac_pci_generic_check - * - * a Generic parity check API - */ void edac_pci_generic_check(struct edac_pci_ctl_info *pci) { - debugf4("%s()\n", __func__); edac_pci_do_parity_check(); } -/* free running instance index counter */ static int edac_pci_idx; #define EDAC_PCI_GENCTL_NAME "EDAC PCI controller" @@ -436,17 +392,6 @@ struct edac_pci_gen_data { int edac_idx; }; -/* - * edac_pci_create_generic_ctl - * - * A generic constructor for a PCI parity polling device - * Some systems have more than one domain of PCI busses. - * For systems with one domain, then this API will - * provide for a generic poller. - * - * This routine calls the edac_pci_alloc_ctl_info() for - * the generic device, with default values - */ struct edac_pci_ctl_info *edac_pci_create_generic_ctl(struct device *dev, const char *mod_name) { @@ -476,18 +421,13 @@ struct edac_pci_ctl_info *edac_pci_create_generic_ctl(struct device *dev, return pci; } + EXPORT_SYMBOL_GPL(edac_pci_create_generic_ctl); -/* - * edac_pci_release_generic_ctl - * - * The release function of a generic EDAC PCI polling device - */ void edac_pci_release_generic_ctl(struct edac_pci_ctl_info *pci) { - debugf0("%s() pci mod=%s\n", __func__, pci->mod_name); - edac_pci_del_device(pci->dev); edac_pci_free_ctl_info(pci); } + EXPORT_SYMBOL_GPL(edac_pci_release_generic_ctl); diff --git a/trunk/drivers/edac/edac_pci_sysfs.c b/trunk/drivers/edac/edac_pci_sysfs.c index 69f5dddabddf..fac94cae2c3d 100644 --- a/trunk/drivers/edac/edac_pci_sysfs.c +++ b/trunk/drivers/edac/edac_pci_sysfs.c @@ -13,25 +13,22 @@ #include "edac_core.h" #include "edac_module.h" -/* Turn off this whole feature if PCI is not configured */ #ifdef CONFIG_PCI #define EDAC_PCI_SYMLINK "device" -/* data variables exported via sysfs */ -static int check_pci_errors; /* default NO check PCI parity */ -static int edac_pci_panic_on_pe; /* default NO panic on PCI Parity */ -static int edac_pci_log_pe = 1; /* log PCI parity errors */ +static int check_pci_errors; /* default YES check PCI parity */ +static int edac_pci_panic_on_pe; /* default no panic on PCI Parity */ +static int edac_pci_log_pe = 1; /* log PCI parity errors */ static int edac_pci_log_npe = 1; /* log PCI non-parity error errors */ -static int edac_pci_poll_msec = 1000; /* one second workq period */ - static atomic_t pci_parity_count = ATOMIC_INIT(0); static atomic_t pci_nonparity_count = ATOMIC_INIT(0); +static int edac_pci_poll_msec = 1000; -static struct kobject edac_pci_top_main_kobj; +static struct kobject edac_pci_kobj; /* /sys/devices/system/edac/pci */ +static struct completion edac_pci_kobj_complete; static atomic_t edac_pci_sysfs_refcount = ATOMIC_INIT(0); -/* getter functions for the data variables */ int edac_pci_get_check_errors(void) { return check_pci_errors; @@ -77,22 +74,17 @@ static void edac_pci_instance_release(struct kobject *kobj) { struct edac_pci_ctl_info *pci; - debugf0("%s()\n", __func__); + debugf1("%s()\n", __func__); - /* Form pointer to containing struct, the pci control struct */ pci = to_instance(kobj); - - /* decrement reference count on top main kobj */ - kobject_put(&edac_pci_top_main_kobj); - - kfree(pci); /* Free the control struct */ + complete(&pci->kobj_complete); } /* instance specific attribute structure */ struct instance_attribute { struct attribute attr; - ssize_t(*show) (struct edac_pci_ctl_info *, char *); - ssize_t(*store) (struct edac_pci_ctl_info *, const char *, size_t); + ssize_t(*show) (struct edac_pci_ctl_info *, char *); + ssize_t(*store) (struct edac_pci_ctl_info *, const char *, size_t); }; /* Function to 'show' fields from the edac_pci 'instance' structure */ @@ -120,7 +112,6 @@ static ssize_t edac_pci_instance_store(struct kobject *kobj, return -EIO; } -/* fs_ops table */ static struct sysfs_ops pci_instance_ops = { .show = edac_pci_instance_show, .store = edac_pci_instance_store @@ -143,82 +134,48 @@ static struct instance_attribute *pci_instance_attr[] = { NULL }; -/* the ktype for a pci instance */ +/* the ktype for pci instance */ static struct kobj_type ktype_pci_instance = { .release = edac_pci_instance_release, .sysfs_ops = &pci_instance_ops, .default_attrs = (struct attribute **)pci_instance_attr, }; -/* - * edac_pci_create_instance_kobj - * - * construct one EDAC PCI instance's kobject for use - */ static int edac_pci_create_instance_kobj(struct edac_pci_ctl_info *pci, int idx) { - struct kobject *main_kobj; int err; - debugf0("%s()\n", __func__); - - /* Set the parent and the instance's ktype */ - pci->kobj.parent = &edac_pci_top_main_kobj; + pci->kobj.parent = &edac_pci_kobj; pci->kobj.ktype = &ktype_pci_instance; err = kobject_set_name(&pci->kobj, "pci%d", idx); if (err) return err; - /* First bump the ref count on the top main kobj, which will - * track the number of PCI instances we have, and thus nest - * properly on keeping the module loaded - */ - main_kobj = kobject_get(&edac_pci_top_main_kobj); - if (!main_kobj) { - err = -ENODEV; - goto error_out; - } - - /* And now register this new kobject under the main kobj */ err = kobject_register(&pci->kobj); if (err != 0) { debugf2("%s() failed to register instance pci%d\n", __func__, idx); - kobject_put(&edac_pci_top_main_kobj); - goto error_out; + return err; } debugf1("%s() Register instance 'pci%d' kobject\n", __func__, idx); return 0; - - /* Error unwind statck */ -error_out: - return err; } -/* - * edac_pci_unregister_sysfs_instance_kobj - * - * unregister the kobj for the EDAC PCI instance - */ -void edac_pci_unregister_sysfs_instance_kobj(struct edac_pci_ctl_info *pci) +static void +edac_pci_delete_instance_kobj(struct edac_pci_ctl_info *pci, int idx) { - debugf0("%s()\n", __func__); - - /* Unregister the instance kobject and allow its release - * function release the main reference count and then - * kfree the memory - */ + init_completion(&pci->kobj_complete); kobject_unregister(&pci->kobj); + wait_for_completion(&pci->kobj_complete); } /***************************** EDAC PCI sysfs root **********************/ #define to_edacpci(k) container_of(k, struct edac_pci_ctl_info, kobj) #define to_edacpci_attr(a) container_of(a, struct edac_pci_attr, attr) -/* simple show/store functions for attributes */ static ssize_t edac_pci_int_show(void *ptr, char *buffer) { int *value = ptr; @@ -310,189 +267,118 @@ static struct edac_pci_dev_attribute *edac_pci_attr[] = { NULL, }; -/* - * edac_pci_release_main_kobj - * - * This release function is called when the reference count to the - * passed kobj goes to zero. - * - * This kobj is the 'main' kobject that EDAC PCI instances - * link to, and thus provide for proper nesting counts - */ -static void edac_pci_release_main_kobj(struct kobject *kobj) +/* No memory to release */ +static void edac_pci_release(struct kobject *kobj) { + struct edac_pci_ctl_info *pci; - debugf0("%s() here to module_put(THIS_MODULE)\n", __func__); + pci = to_edacpci(kobj); - /* last reference to top EDAC PCI kobject has been removed, - * NOW release our ref count on the core module - */ - module_put(THIS_MODULE); + debugf1("%s()\n", __func__); + complete(&pci->kobj_complete); } -/* ktype struct for the EDAC PCI main kobj */ -static struct kobj_type ktype_edac_pci_main_kobj = { - .release = edac_pci_release_main_kobj, +static struct kobj_type ktype_edac_pci = { + .release = edac_pci_release, .sysfs_ops = &edac_pci_sysfs_ops, .default_attrs = (struct attribute **)edac_pci_attr, }; /** - * edac_pci_main_kobj_setup() + * edac_sysfs_pci_setup() * * setup the sysfs for EDAC PCI attributes * assumes edac_class has already been initialized */ -int edac_pci_main_kobj_setup(void) +int edac_pci_register_main_kobj(void) { int err; struct sysdev_class *edac_class; - debugf0("%s()\n", __func__); - - /* check and count if we have already created the main kobject */ - if (atomic_inc_return(&edac_pci_sysfs_refcount) != 1) - return 0; + debugf1("%s()\n", __func__); - /* First time, so create the main kobject and its - * controls and atributes - */ edac_class = edac_get_edac_class(); if (edac_class == NULL) { debugf1("%s() no edac_class\n", __func__); - err = -ENODEV; - goto decrement_count_fail; + return -ENODEV; } - /* Need the kobject hook ups, and name setting */ - edac_pci_top_main_kobj.ktype = &ktype_edac_pci_main_kobj; - edac_pci_top_main_kobj.parent = &edac_class->kset.kobj; + edac_pci_kobj.ktype = &ktype_edac_pci; - err = kobject_set_name(&edac_pci_top_main_kobj, "pci"); - if (err) - goto decrement_count_fail; + edac_pci_kobj.parent = &edac_class->kset.kobj; - /* Bump the reference count on this module to ensure the - * modules isn't unloaded until we deconstruct the top - * level main kobj for EDAC PCI - */ - if (!try_module_get(THIS_MODULE)) { - debugf1("%s() try_module_get() failed\n", __func__); - err = -ENODEV; - goto decrement_count_fail; - } + err = kobject_set_name(&edac_pci_kobj, "pci"); + if (err) + return err; /* Instanstiate the pci object */ /* FIXME: maybe new sysdev_create_subdir() */ - err = kobject_register(&edac_pci_top_main_kobj); + err = kobject_register(&edac_pci_kobj); + if (err) { debugf1("Failed to register '.../edac/pci'\n"); - goto kobject_register_fail; + return err; } - /* At this point, to 'release' the top level kobject - * for EDAC PCI, then edac_pci_main_kobj_teardown() - * must be used, for resources to be cleaned up properly - */ debugf1("Registered '.../edac/pci' kobject\n"); return 0; - - /* Error unwind statck */ -kobject_register_fail: - module_put(THIS_MODULE); - -decrement_count_fail: - /* if are on this error exit, nothing to tear down */ - atomic_dec(&edac_pci_sysfs_refcount); - - return err; } /* - * edac_pci_main_kobj_teardown() + * edac_pci_unregister_main_kobj() * - * if no longer linked (needed) remove the top level EDAC PCI - * kobject with its controls and attributes + * perform the sysfs teardown for the PCI attributes */ -static void edac_pci_main_kobj_teardown(void) +void edac_pci_unregister_main_kobj(void) { debugf0("%s()\n", __func__); - - /* Decrement the count and only if no more controller instances - * are connected perform the unregisteration of the top level - * main kobj - */ - if (atomic_dec_return(&edac_pci_sysfs_refcount) == 0) { - debugf0("%s() called kobject_unregister on main kobj\n", - __func__); - kobject_unregister(&edac_pci_top_main_kobj); - } + init_completion(&edac_pci_kobj_complete); + kobject_unregister(&edac_pci_kobj); + wait_for_completion(&edac_pci_kobj_complete); } -/* - * - * edac_pci_create_sysfs - * - * Create the controls/attributes for the specified EDAC PCI device - */ int edac_pci_create_sysfs(struct edac_pci_ctl_info *pci) { int err; struct kobject *edac_kobj = &pci->kobj; - debugf0("%s() idx=%d\n", __func__, pci->pci_idx); - - /* create the top main EDAC PCI kobject, IF needed */ - err = edac_pci_main_kobj_setup(); - if (err) - return err; + if (atomic_inc_return(&edac_pci_sysfs_refcount) == 1) { + err = edac_pci_register_main_kobj(); + if (err) { + atomic_dec(&edac_pci_sysfs_refcount); + return err; + } + } - /* Create this instance's kobject under the MAIN kobject */ err = edac_pci_create_instance_kobj(pci, pci->pci_idx); - if (err) - goto unregister_cleanup; + if (err) { + if (atomic_dec_return(&edac_pci_sysfs_refcount) == 0) + edac_pci_unregister_main_kobj(); + } + + debugf0("%s() idx=%d\n", __func__, pci->pci_idx); err = sysfs_create_link(edac_kobj, &pci->dev->kobj, EDAC_PCI_SYMLINK); if (err) { debugf0("%s() sysfs_create_link() returned err= %d\n", __func__, err); - goto symlink_fail; + return err; } return 0; - - /* Error unwind stack */ -symlink_fail: - edac_pci_unregister_sysfs_instance_kobj(pci); - -unregister_cleanup: - edac_pci_main_kobj_teardown(); - - return err; } -/* - * edac_pci_remove_sysfs - * - * remove the controls and attributes for this EDAC PCI device - */ void edac_pci_remove_sysfs(struct edac_pci_ctl_info *pci) { - debugf0("%s() index=%d\n", __func__, pci->pci_idx); + debugf0("%s()\n", __func__); - /* Remove the symlink */ - sysfs_remove_link(&pci->kobj, EDAC_PCI_SYMLINK); + edac_pci_delete_instance_kobj(pci, pci->pci_idx); - /* remove this PCI instance's sysfs entries */ - edac_pci_unregister_sysfs_instance_kobj(pci); + sysfs_remove_link(&pci->kobj, EDAC_PCI_SYMLINK); - /* Call the main unregister function, which will determine - * if this 'pci' is the last instance. - * If it is, the main kobject will be unregistered as a result - */ - debugf0("%s() calling edac_pci_main_kobj_teardown()\n", __func__); - edac_pci_main_kobj_teardown(); + if (atomic_dec_return(&edac_pci_sysfs_refcount) == 0) + edac_pci_unregister_main_kobj(); } /************************ PCI error handling *************************/ @@ -528,14 +414,13 @@ static u16 get_pci_parity_status(struct pci_dev *dev, int secondary) return status; } +typedef void (*pci_parity_check_fn_t) (struct pci_dev * dev); /* Clear any PCI parity errors logged by this device. */ static void edac_pci_dev_parity_clear(struct pci_dev *dev) { u8 header_type; - debugf0("%s()\n", __func__); - get_pci_parity_status(dev, 0); /* read the device TYPE, looking for bridges */ @@ -548,28 +433,17 @@ static void edac_pci_dev_parity_clear(struct pci_dev *dev) /* * PCI Parity polling * - * Fucntion to retrieve the current parity status - * and decode it - * */ static void edac_pci_dev_parity_test(struct pci_dev *dev) { - unsigned long flags; u16 status; u8 header_type; - /* stop any interrupts until we can acquire the status */ - local_irq_save(flags); - - /* read the STATUS register on this device */ + /* read the STATUS register on this device + */ status = get_pci_parity_status(dev, 0); - /* read the device TYPE, looking for bridges */ - pci_read_config_byte(dev, PCI_HEADER_TYPE, &header_type); - - local_irq_restore(flags); - - debugf4("PCI STATUS= 0x%04x %s\n", status, dev->dev.bus_id); + debugf2("PCI STATUS= 0x%04x %s\n", status, dev->dev.bus_id); /* check the status reg for errors */ if (status) { @@ -597,14 +471,16 @@ static void edac_pci_dev_parity_test(struct pci_dev *dev) } } + /* read the device TYPE, looking for bridges */ + pci_read_config_byte(dev, PCI_HEADER_TYPE, &header_type); - debugf4("PCI HEADER TYPE= 0x%02x %s\n", header_type, dev->dev.bus_id); + debugf2("PCI HEADER TYPE= 0x%02x %s\n", header_type, dev->dev.bus_id); if ((header_type & 0x7F) == PCI_HEADER_TYPE_BRIDGE) { /* On bridges, need to examine secondary status register */ status = get_pci_parity_status(dev, 1); - debugf4("PCI SEC_STATUS= 0x%04x %s\n", status, dev->dev.bus_id); + debugf2("PCI SEC_STATUS= 0x%04x %s\n", status, dev->dev.bus_id); /* check the secondary status reg for errors */ if (status) { @@ -634,12 +510,9 @@ static void edac_pci_dev_parity_test(struct pci_dev *dev) } } -/* reduce some complexity in definition of the iterator */ -typedef void (*pci_parity_check_fn_t) (struct pci_dev *dev); - /* * pci_dev parity list iterator - * Scan the PCI device list for one pass, looking for SERRORs + * Scan the PCI device list for one iteration, looking for SERRORs * Master Parity ERRORS or Parity ERRORs on primary or secondary devices */ static inline void edac_pci_dev_parity_iterator(pci_parity_check_fn_t fn) @@ -662,22 +535,22 @@ static inline void edac_pci_dev_parity_iterator(pci_parity_check_fn_t fn) */ void edac_pci_do_parity_check(void) { + unsigned long flags; int before_count; debugf3("%s()\n", __func__); - /* if policy has PCI check off, leave now */ if (!check_pci_errors) return; before_count = atomic_read(&pci_parity_count); /* scan all PCI devices looking for a Parity Error on devices and - * bridges. - * The iterator calls pci_get_device() which might sleep, thus - * we cannot disable interrupts in this scan. + * bridges */ + local_irq_save(flags); edac_pci_dev_parity_iterator(edac_pci_dev_parity_test); + local_irq_restore(flags); /* Only if operator has selected panic on PCI Error */ if (edac_pci_get_panic_on_pe()) { @@ -687,12 +560,6 @@ void edac_pci_do_parity_check(void) } } -/* - * edac_pci_clear_parity_errors - * - * function to perform an iteration over the PCI devices - * and clearn their current status - */ void edac_pci_clear_parity_errors(void) { /* Clear any PCI bus parity errors that devices initially have logged @@ -700,12 +567,6 @@ void edac_pci_clear_parity_errors(void) */ edac_pci_dev_parity_iterator(edac_pci_dev_parity_clear); } - -/* - * edac_pci_handle_pe - * - * Called to handle a PARITY ERROR event - */ void edac_pci_handle_pe(struct edac_pci_ctl_info *pci, const char *msg) { @@ -723,14 +584,9 @@ void edac_pci_handle_pe(struct edac_pci_ctl_info *pci, const char *msg) */ edac_pci_do_parity_check(); } -EXPORT_SYMBOL_GPL(edac_pci_handle_pe); +EXPORT_SYMBOL_GPL(edac_pci_handle_pe); -/* - * edac_pci_handle_npe - * - * Called to handle a NON-PARITY ERROR event - */ void edac_pci_handle_npe(struct edac_pci_ctl_info *pci, const char *msg) { @@ -748,6 +604,7 @@ void edac_pci_handle_npe(struct edac_pci_ctl_info *pci, const char *msg) */ edac_pci_do_parity_check(); } + EXPORT_SYMBOL_GPL(edac_pci_handle_npe); /* diff --git a/trunk/drivers/edac/i3000_edac.c b/trunk/drivers/edac/i3000_edac.c index e895f9f887ab..0ecfdc432f87 100644 --- a/trunk/drivers/edac/i3000_edac.c +++ b/trunk/drivers/edac/i3000_edac.c @@ -275,7 +275,7 @@ static int i3000_probe1(struct pci_dev *pdev, int dev_idx) unsigned char *c0dra = dra, *c1dra = &dra[I3000_RANKS_PER_CHANNEL / 2]; unsigned char *c0drb = drb, *c1drb = &drb[I3000_RANKS_PER_CHANNEL]; unsigned long mchbar; - void __iomem *window; + void *window; debugf0("MC: %s()\n", __func__); diff --git a/trunk/drivers/i2c/chips/ds1682.c b/trunk/drivers/i2c/chips/ds1682.c index 9e94542c18a2..5879f0f25495 100644 --- a/trunk/drivers/i2c/chips/ds1682.c +++ b/trunk/drivers/i2c/chips/ds1682.c @@ -75,8 +75,7 @@ static ssize_t ds1682_show(struct device *dev, struct device_attribute *attr, /* Special case: the 32 bit regs are time values with 1/4s * resolution, scale them up to milliseconds */ if (sattr->nr == 4) - return sprintf(buf, "%llu\n", - ((unsigned long long)le32_to_cpu(val)) * 250); + return sprintf(buf, "%llu\n", ((u64) le32_to_cpu(val)) * 250); /* Format the output string and return # of bytes */ return sprintf(buf, "%li\n", (long)le32_to_cpu(val)); diff --git a/trunk/drivers/ide/pci/scc_pata.c b/trunk/drivers/ide/pci/scc_pata.c index bf19ddfa6cda..f668d235e6be 100644 --- a/trunk/drivers/ide/pci/scc_pata.c +++ b/trunk/drivers/ide/pci/scc_pata.c @@ -551,8 +551,8 @@ static int setup_mmio_scc (struct pci_dev *dev, const char *name) unsigned long dma_base = pci_resource_start(dev, 1); unsigned long ctl_size = pci_resource_len(dev, 0); unsigned long dma_size = pci_resource_len(dev, 1); - void __iomem *ctl_addr; - void __iomem *dma_addr; + void *ctl_addr; + void *dma_addr; int i; for (i = 0; i < MAX_HWIFS; i++) { diff --git a/trunk/drivers/ieee1394/raw1394.c b/trunk/drivers/ieee1394/raw1394.c index cadf0479cce5..336e5ff4cfcf 100644 --- a/trunk/drivers/ieee1394/raw1394.c +++ b/trunk/drivers/ieee1394/raw1394.c @@ -2677,7 +2677,7 @@ static long raw1394_iso_xmit_recv_packets32(struct file *file, unsigned int cmd, struct raw1394_iso_packets32 __user *arg) { compat_uptr_t infos32; - void __user *infos; + void *infos; long err = -EFAULT; struct raw1394_iso_packets __user *dst = compat_alloc_user_space(sizeof(struct raw1394_iso_packets)); diff --git a/trunk/drivers/lguest/Makefile b/trunk/drivers/lguest/Makefile index e5047471c334..55382c7d799c 100644 --- a/trunk/drivers/lguest/Makefile +++ b/trunk/drivers/lguest/Makefile @@ -5,15 +5,3 @@ obj-$(CONFIG_LGUEST_GUEST) += lguest.o lguest_asm.o lguest_bus.o obj-$(CONFIG_LGUEST) += lg.o lg-y := core.o hypercalls.o page_tables.o interrupts_and_traps.o \ segments.o io.o lguest_user.o switcher.o - -Preparation Preparation!: PREFIX=P -Guest: PREFIX=G -Drivers: PREFIX=D -Launcher: PREFIX=L -Host: PREFIX=H -Switcher: PREFIX=S -Mastery: PREFIX=M -Beer: - @for f in Preparation Guest Drivers Launcher Host Switcher Mastery; do echo "{==- $$f -==}"; make -s $$f; done; echo "{==-==}" -Preparation Preparation! Guest Drivers Launcher Host Switcher Mastery: - @sh ../../Documentation/lguest/extract $(PREFIX) `find ../../* -name '*.[chS]' -wholename '*lguest*'` diff --git a/trunk/drivers/lguest/README b/trunk/drivers/lguest/README deleted file mode 100644 index b7db39a64c66..000000000000 --- a/trunk/drivers/lguest/README +++ /dev/null @@ -1,47 +0,0 @@ -Welcome, friend reader, to lguest. - -Lguest is an adventure, with you, the reader, as Hero. I can't think of many -5000-line projects which offer both such capability and glimpses of future -potential; it is an exciting time to be delving into the source! - -But be warned; this is an arduous journey of several hours or more! And as we -know, all true Heroes are driven by a Noble Goal. Thus I offer a Beer (or -equivalent) to anyone I meet who has completed this documentation. - -So get comfortable and keep your wits about you (both quick and humorous). -Along your way to the Noble Goal, you will also gain masterly insight into -lguest, and hypervisors and x86 virtualization in general. - -Our Quest is in seven parts: (best read with C highlighting turned on) - -I) Preparation - - In which our potential hero is flown quickly over the landscape for a - taste of its scope. Suitable for the armchair coders and other such - persons of faint constitution. - -II) Guest - - Where we encounter the first tantalising wisps of code, and come to - understand the details of the life of a Guest kernel. - -III) Drivers - - Whereby the Guest finds its voice and become useful, and our - understanding of the Guest is completed. - -IV) Launcher - - Where we trace back to the creation of the Guest, and thus begin our - understanding of the Host. - -V) Host - - Where we master the Host code, through a long and tortuous journey. - Indeed, it is here that our hero is tested in the Bit of Despair. - -VI) Switcher - - Where our understanding of the intertwined nature of Guests and Hosts - is completed. - -VII) Mastery - - Where our fully fledged hero grapples with the Great Question: - "What next?" - -make Preparation! -Rusty Russell. diff --git a/trunk/drivers/lguest/core.c b/trunk/drivers/lguest/core.c index 0a46e8837d9a..ce909ec57499 100644 --- a/trunk/drivers/lguest/core.c +++ b/trunk/drivers/lguest/core.c @@ -1,8 +1,5 @@ -/*P:400 This contains run_guest() which actually calls into the Host<->Guest - * Switcher and analyzes the return, such as determining if the Guest wants the - * Host to do something. This file also contains useful helper routines, and a - * couple of non-obvious setup and teardown pieces which were implemented after - * days of debugging pain. :*/ +/* World's simplest hypervisor, to test paravirt_ops and show + * unbelievers that virtualization is the future. Plus, it's fun! */ #include #include #include @@ -64,33 +61,11 @@ static struct lguest_pages *lguest_pages(unsigned int cpu) (SWITCHER_ADDR + SHARED_SWITCHER_PAGES*PAGE_SIZE))[cpu]); } -/*H:010 We need to set up the Switcher at a high virtual address. Remember the - * Switcher is a few hundred bytes of assembler code which actually changes the - * CPU to run the Guest, and then changes back to the Host when a trap or - * interrupt happens. - * - * The Switcher code must be at the same virtual address in the Guest as the - * Host since it will be running as the switchover occurs. - * - * Trying to map memory at a particular address is an unusual thing to do, so - * it's not a simple one-liner. We also set up the per-cpu parts of the - * Switcher here. - */ static __init int map_switcher(void) { int i, err; struct page **pagep; - /* - * Map the Switcher in to high memory. - * - * It turns out that if we choose the address 0xFFC00000 (4MB under the - * top virtual address), it makes setting up the page tables really - * easy. - */ - - /* We allocate an array of "struct page"s. map_vm_area() wants the - * pages in this form, rather than just an array of pointers. */ switcher_page = kmalloc(sizeof(switcher_page[0])*TOTAL_SWITCHER_PAGES, GFP_KERNEL); if (!switcher_page) { @@ -98,8 +73,6 @@ static __init int map_switcher(void) goto out; } - /* Now we actually allocate the pages. The Guest will see these pages, - * so we make sure they're zeroed. */ for (i = 0; i < TOTAL_SWITCHER_PAGES; i++) { unsigned long addr = get_zeroed_page(GFP_KERNEL); if (!addr) { @@ -109,9 +82,6 @@ static __init int map_switcher(void) switcher_page[i] = virt_to_page(addr); } - /* Now we reserve the "virtual memory area" we want: 0xFFC00000 - * (SWITCHER_ADDR). We might not get it in theory, but in practice - * it's worked so far. */ switcher_vma = __get_vm_area(TOTAL_SWITCHER_PAGES * PAGE_SIZE, VM_ALLOC, SWITCHER_ADDR, VMALLOC_END); if (!switcher_vma) { @@ -120,105 +90,49 @@ static __init int map_switcher(void) goto free_pages; } - /* This code actually sets up the pages we've allocated to appear at - * SWITCHER_ADDR. map_vm_area() takes the vma we allocated above, the - * kind of pages we're mapping (kernel pages), and a pointer to our - * array of struct pages. It increments that pointer, but we don't - * care. */ pagep = switcher_page; err = map_vm_area(switcher_vma, PAGE_KERNEL, &pagep); if (err) { printk("lguest: map_vm_area failed: %i\n", err); goto free_vma; } - - /* Now the switcher is mapped at the right address, we can't fail! - * Copy in the compiled-in Switcher code (from switcher.S). */ memcpy(switcher_vma->addr, start_switcher_text, end_switcher_text - start_switcher_text); - /* Most of the switcher.S doesn't care that it's been moved; on Intel, - * jumps are relative, and it doesn't access any references to external - * code or data. - * - * The only exception is the interrupt handlers in switcher.S: their - * addresses are placed in a table (default_idt_entries), so we need to - * update the table with the new addresses. switcher_offset() is a - * convenience function which returns the distance between the builtin - * switcher code and the high-mapped copy we just made. */ + /* Fix up IDT entries to point into copied text. */ for (i = 0; i < IDT_ENTRIES; i++) default_idt_entries[i] += switcher_offset(); - /* - * Set up the Switcher's per-cpu areas. - * - * Each CPU gets two pages of its own within the high-mapped region - * (aka. "struct lguest_pages"). Much of this can be initialized now, - * but some depends on what Guest we are running (which is set up in - * copy_in_guest_info()). - */ for_each_possible_cpu(i) { - /* lguest_pages() returns this CPU's two pages. */ struct lguest_pages *pages = lguest_pages(i); - /* This is a convenience pointer to make the code fit one - * statement to a line. */ struct lguest_ro_state *state = &pages->state; - /* The Global Descriptor Table: the Host has a different one - * for each CPU. We keep a descriptor for the GDT which says - * where it is and how big it is (the size is actually the last - * byte, not the size, hence the "-1"). */ + /* These fields are static: rest done in copy_in_guest_info */ state->host_gdt_desc.size = GDT_SIZE-1; state->host_gdt_desc.address = (long)get_cpu_gdt_table(i); - - /* All CPUs on the Host use the same Interrupt Descriptor - * Table, so we just use store_idt(), which gets this CPU's IDT - * descriptor. */ store_idt(&state->host_idt_desc); - - /* The descriptors for the Guest's GDT and IDT can be filled - * out now, too. We copy the GDT & IDT into ->guest_gdt and - * ->guest_idt before actually running the Guest. */ state->guest_idt_desc.size = sizeof(state->guest_idt)-1; state->guest_idt_desc.address = (long)&state->guest_idt; state->guest_gdt_desc.size = sizeof(state->guest_gdt)-1; state->guest_gdt_desc.address = (long)&state->guest_gdt; - - /* We know where we want the stack to be when the Guest enters - * the switcher: in pages->regs. The stack grows upwards, so - * we start it at the end of that structure. */ state->guest_tss.esp0 = (long)(&pages->regs + 1); - /* And this is the GDT entry to use for the stack: we keep a - * couple of special LGUEST entries. */ state->guest_tss.ss0 = LGUEST_DS; - - /* x86 can have a finegrained bitmap which indicates what I/O - * ports the process can use. We set it to the end of our - * structure, meaning "none". */ + /* No I/O for you! */ state->guest_tss.io_bitmap_base = sizeof(state->guest_tss); - - /* Some GDT entries are the same across all Guests, so we can - * set them up now. */ setup_default_gdt_entries(state); - /* Most IDT entries are the same for all Guests, too.*/ setup_default_idt_entries(state, default_idt_entries); - /* The Host needs to be able to use the LGUEST segments on this - * CPU, too, so put them in the Host GDT. */ + /* Setup LGUEST segments on all cpus */ get_cpu_gdt_table(i)[GDT_ENTRY_LGUEST_CS] = FULL_EXEC_SEGMENT; get_cpu_gdt_table(i)[GDT_ENTRY_LGUEST_DS] = FULL_SEGMENT; } - /* In the Switcher, we want the %cs segment register to use the - * LGUEST_CS GDT entry: we've put that in the Host and Guest GDTs, so - * it will be undisturbed when we switch. To change %cs and jump we - * need this structure to feed to Intel's "lcall" instruction. */ + /* Initialize entry point into switcher. */ lguest_entry.offset = (long)switch_to_guest + switcher_offset(); lguest_entry.segment = LGUEST_CS; printk(KERN_INFO "lguest: mapped switcher at %p\n", switcher_vma->addr); - /* And we succeeded... */ return 0; free_vma: @@ -232,58 +146,35 @@ static __init int map_switcher(void) out: return err; } -/*:*/ -/* Cleaning up the mapping when the module is unloaded is almost... - * too easy. */ static void unmap_switcher(void) { unsigned int i; - /* vunmap() undoes *both* map_vm_area() and __get_vm_area(). */ vunmap(switcher_vma->addr); - /* Now we just need to free the pages we copied the switcher into */ for (i = 0; i < TOTAL_SWITCHER_PAGES; i++) __free_pages(switcher_page[i], 0); } -/*H:130 Our Guest is usually so well behaved; it never tries to do things it - * isn't allowed to. Unfortunately, "struct paravirt_ops" isn't quite - * complete, because it doesn't contain replacements for the Intel I/O - * instructions. As a result, the Guest sometimes fumbles across one during - * the boot process as it probes for various things which are usually attached - * to a PC. - * - * When the Guest uses one of these instructions, we get trap #13 (General - * Protection Fault) and come here. We see if it's one of those troublesome - * instructions and skip over it. We return true if we did. */ +/* IN/OUT insns: enough to get us past boot-time probing. */ static int emulate_insn(struct lguest *lg) { u8 insn; unsigned int insnlen = 0, in = 0, shift = 0; - /* The eip contains the *virtual* address of the Guest's instruction: - * guest_pa just subtracts the Guest's page_offset. */ unsigned long physaddr = guest_pa(lg, lg->regs->eip); - /* The guest_pa() function only works for Guest kernel addresses, but - * that's all we're trying to do anyway. */ + /* This only works for addresses in linear mapping... */ if (lg->regs->eip < lg->page_offset) return 0; - - /* Decoding x86 instructions is icky. */ lgread(lg, &insn, physaddr, 1); - /* 0x66 is an "operand prefix". It means it's using the upper 16 bits - of the eax register. */ + /* Operand size prefix means it's actually for ax. */ if (insn == 0x66) { shift = 16; - /* The instruction is 1 byte so far, read the next byte. */ insnlen = 1; lgread(lg, &insn, physaddr + insnlen, 1); } - /* We can ignore the lower bit for the moment and decode the 4 opcodes - * we need to emulate. */ switch (insn & 0xFE) { case 0xE4: /* in ,%al */ insnlen += 2; @@ -300,13 +191,9 @@ static int emulate_insn(struct lguest *lg) insnlen += 1; break; default: - /* OK, we don't know what this is, can't emulate. */ return 0; } - /* If it was an "IN" instruction, they expect the result to be read - * into %eax, so we change %eax. We always return all-ones, which - * traditionally means "there's nothing there". */ if (in) { /* Lower bit tells is whether it's a 16 or 32 bit access */ if (insn & 0x1) @@ -314,46 +201,28 @@ static int emulate_insn(struct lguest *lg) else lg->regs->eax |= (0xFFFF << shift); } - /* Finally, we've "done" the instruction, so move past it. */ lg->regs->eip += insnlen; - /* Success! */ return 1; } -/*:*/ - -/*L:305 - * Dealing With Guest Memory. - * - * When the Guest gives us (what it thinks is) a physical address, we can use - * the normal copy_from_user() & copy_to_user() on that address: remember, - * Guest physical == Launcher virtual. - * - * But we can't trust the Guest: it might be trying to access the Launcher - * code. We have to check that the range is below the pfn_limit the Launcher - * gave us. We have to make sure that addr + len doesn't give us a false - * positive by overflowing, too. */ + int lguest_address_ok(const struct lguest *lg, unsigned long addr, unsigned long len) { return (addr+len) / PAGE_SIZE < lg->pfn_limit && (addr+len >= addr); } -/* This is a convenient routine to get a 32-bit value from the Guest (a very - * common operation). Here we can see how useful the kill_lguest() routine we - * met in the Launcher can be: we return a random value (0) instead of needing - * to return an error. */ +/* Just like get_user, but don't let guest access lguest binary. */ u32 lgread_u32(struct lguest *lg, unsigned long addr) { u32 val = 0; - /* Don't let them access lguest binary. */ + /* Don't let them access lguest binary */ if (!lguest_address_ok(lg, addr, sizeof(val)) || get_user(val, (u32 __user *)addr) != 0) kill_guest(lg, "bad read address %#lx", addr); return val; } -/* Same thing for writing a value. */ void lgwrite_u32(struct lguest *lg, unsigned long addr, u32 val) { if (!lguest_address_ok(lg, addr, sizeof(val)) @@ -361,9 +230,6 @@ void lgwrite_u32(struct lguest *lg, unsigned long addr, u32 val) kill_guest(lg, "bad write address %#lx", addr); } -/* This routine is more generic, and copies a range of Guest bytes into a - * buffer. If the copy_from_user() fails, we fill the buffer with zeroes, so - * the caller doesn't end up using uninitialized kernel memory. */ void lgread(struct lguest *lg, void *b, unsigned long addr, unsigned bytes) { if (!lguest_address_ok(lg, addr, bytes) @@ -374,7 +240,6 @@ void lgread(struct lguest *lg, void *b, unsigned long addr, unsigned bytes) } } -/* Similarly, our generic routine to copy into a range of Guest bytes. */ void lgwrite(struct lguest *lg, unsigned long addr, const void *b, unsigned bytes) { @@ -382,7 +247,6 @@ void lgwrite(struct lguest *lg, unsigned long addr, const void *b, || copy_to_user((void __user *)addr, b, bytes) != 0) kill_guest(lg, "bad write address %#lx len %u", addr, bytes); } -/* (end of memory access helper routines) :*/ static void set_ts(void) { @@ -393,108 +257,54 @@ static void set_ts(void) write_cr0(cr0|8); } -/*S:010 - * We are getting close to the Switcher. - * - * Remember that each CPU has two pages which are visible to the Guest when it - * runs on that CPU. This has to contain the state for that Guest: we copy the - * state in just before we run the Guest. - * - * Each Guest has "changed" flags which indicate what has changed in the Guest - * since it last ran. We saw this set in interrupts_and_traps.c and - * segments.c. - */ static void copy_in_guest_info(struct lguest *lg, struct lguest_pages *pages) { - /* Copying all this data can be quite expensive. We usually run the - * same Guest we ran last time (and that Guest hasn't run anywhere else - * meanwhile). If that's not the case, we pretend everything in the - * Guest has changed. */ if (__get_cpu_var(last_guest) != lg || lg->last_pages != pages) { __get_cpu_var(last_guest) = lg; lg->last_pages = pages; lg->changed = CHANGED_ALL; } - /* These copies are pretty cheap, so we do them unconditionally: */ - /* Save the current Host top-level page directory. */ + /* These are pretty cheap, so we do them unconditionally. */ pages->state.host_cr3 = __pa(current->mm->pgd); - /* Set up the Guest's page tables to see this CPU's pages (and no - * other CPU's pages). */ map_switcher_in_guest(lg, pages); - /* Set up the two "TSS" members which tell the CPU what stack to use - * for traps which do directly into the Guest (ie. traps at privilege - * level 1). */ pages->state.guest_tss.esp1 = lg->esp1; pages->state.guest_tss.ss1 = lg->ss1; - /* Copy direct-to-Guest trap entries. */ + /* Copy direct trap entries. */ if (lg->changed & CHANGED_IDT) copy_traps(lg, pages->state.guest_idt, default_idt_entries); - /* Copy all GDT entries which the Guest can change. */ + /* Copy all GDT entries but the TSS. */ if (lg->changed & CHANGED_GDT) copy_gdt(lg, pages->state.guest_gdt); /* If only the TLS entries have changed, copy them. */ else if (lg->changed & CHANGED_GDT_TLS) copy_gdt_tls(lg, pages->state.guest_gdt); - /* Mark the Guest as unchanged for next time. */ lg->changed = 0; } -/* Finally: the code to actually call into the Switcher to run the Guest. */ static void run_guest_once(struct lguest *lg, struct lguest_pages *pages) { - /* This is a dummy value we need for GCC's sake. */ unsigned int clobber; - /* Copy the guest-specific information into this CPU's "struct - * lguest_pages". */ copy_in_guest_info(lg, pages); - /* Now: we push the "eflags" register on the stack, then do an "lcall". - * This is how we change from using the kernel code segment to using - * the dedicated lguest code segment, as well as jumping into the - * Switcher. - * - * The lcall also pushes the old code segment (KERNEL_CS) onto the - * stack, then the address of this call. This stack layout happens to - * exactly match the stack of an interrupt... */ + /* Put eflags on stack, lcall does rest: suitable for iret return. */ asm volatile("pushf; lcall *lguest_entry" - /* This is how we tell GCC that %eax ("a") and %ebx ("b") - * are changed by this routine. The "=" means output. */ : "=a"(clobber), "=b"(clobber) - /* %eax contains the pages pointer. ("0" refers to the - * 0-th argument above, ie "a"). %ebx contains the - * physical address of the Guest's top-level page - * directory. */ : "0"(pages), "1"(__pa(lg->pgdirs[lg->pgdidx].pgdir)) - /* We tell gcc that all these registers could change, - * which means we don't have to save and restore them in - * the Switcher. */ : "memory", "%edx", "%ecx", "%edi", "%esi"); } -/*:*/ -/*H:030 Let's jump straight to the the main loop which runs the Guest. - * Remember, this is called by the Launcher reading /dev/lguest, and we keep - * going around and around until something interesting happens. */ int run_guest(struct lguest *lg, unsigned long __user *user) { - /* We stop running once the Guest is dead. */ while (!lg->dead) { - /* We need to initialize this, otherwise gcc complains. It's - * not (yet) clever enough to see that it's initialized when we - * need it. */ unsigned int cr2 = 0; /* Damn gcc */ - /* First we run any hypercalls the Guest wants done: either in - * the hypercall ring in "struct lguest_data", or directly by - * using int 31 (LGUEST_TRAP_ENTRY). */ + /* Hypercalls first: we might have been out to userspace */ do_hypercalls(lg); - /* It's possible the Guest did a SEND_DMA hypercall to the - * Launcher, in which case we return from the read() now. */ if (lg->dma_is_pending) { if (put_user(lg->pending_dma, user) || put_user(lg->pending_key, user+1)) @@ -502,7 +312,6 @@ int run_guest(struct lguest *lg, unsigned long __user *user) return sizeof(unsigned long)*2; } - /* Check for signals */ if (signal_pending(current)) return -ERESTARTSYS; @@ -510,154 +319,77 @@ int run_guest(struct lguest *lg, unsigned long __user *user) if (lg->break_out) return -EAGAIN; - /* Check if there are any interrupts which can be delivered - * now: if so, this sets up the hander to be executed when we - * next run the Guest. */ maybe_do_interrupt(lg); - /* All long-lived kernel loops need to check with this horrible - * thing called the freezer. If the Host is trying to suspend, - * it stops us. */ try_to_freeze(); - /* Just make absolutely sure the Guest is still alive. One of - * those hypercalls could have been fatal, for example. */ if (lg->dead) break; - /* If the Guest asked to be stopped, we sleep. The Guest's - * clock timer or LHCALL_BREAK from the Waker will wake us. */ if (lg->halted) { set_current_state(TASK_INTERRUPTIBLE); schedule(); continue; } - /* OK, now we're ready to jump into the Guest. First we put up - * the "Do Not Disturb" sign: */ local_irq_disable(); - /* Remember the awfully-named TS bit? If the Guest has asked - * to set it we set it now, so we can trap and pass that trap - * to the Guest if it uses the FPU. */ + /* Even if *we* don't want FPU trap, guest might... */ if (lg->ts) set_ts(); - /* SYSENTER is an optimized way of doing system calls. We - * can't allow it because it always jumps to privilege level 0. - * A normal Guest won't try it because we don't advertise it in - * CPUID, but a malicious Guest (or malicious Guest userspace - * program) could, so we tell the CPU to disable it before - * running the Guest. */ + /* Don't let Guest do SYSENTER: we can't handle it. */ if (boot_cpu_has(X86_FEATURE_SEP)) wrmsr(MSR_IA32_SYSENTER_CS, 0, 0); - /* Now we actually run the Guest. It will pop back out when - * something interesting happens, and we can examine its - * registers to see what it was doing. */ run_guest_once(lg, lguest_pages(raw_smp_processor_id())); - /* The "regs" pointer contains two extra entries which are not - * really registers: a trap number which says what interrupt or - * trap made the switcher code come back, and an error code - * which some traps set. */ - - /* If the Guest page faulted, then the cr2 register will tell - * us the bad virtual address. We have to grab this now, - * because once we re-enable interrupts an interrupt could - * fault and thus overwrite cr2, or we could even move off to a - * different CPU. */ + /* Save cr2 now if we page-faulted. */ if (lg->regs->trapnum == 14) cr2 = read_cr2(); - /* Similarly, if we took a trap because the Guest used the FPU, - * we have to restore the FPU it expects to see. */ else if (lg->regs->trapnum == 7) math_state_restore(); - /* Restore SYSENTER if it's supposed to be on. */ if (boot_cpu_has(X86_FEATURE_SEP)) wrmsr(MSR_IA32_SYSENTER_CS, __KERNEL_CS, 0); - - /* Now we're ready to be interrupted or moved to other CPUs */ local_irq_enable(); - /* OK, so what happened? */ switch (lg->regs->trapnum) { case 13: /* We've intercepted a GPF. */ - /* Check if this was one of those annoying IN or OUT - * instructions which we need to emulate. If so, we - * just go back into the Guest after we've done it. */ if (lg->regs->errcode == 0) { if (emulate_insn(lg)) continue; } break; case 14: /* We've intercepted a page fault. */ - /* The Guest accessed a virtual address that wasn't - * mapped. This happens a lot: we don't actually set - * up most of the page tables for the Guest at all when - * we start: as it runs it asks for more and more, and - * we set them up as required. In this case, we don't - * even tell the Guest that the fault happened. - * - * The errcode tells whether this was a read or a - * write, and whether kernel or userspace code. */ if (demand_page(lg, cr2, lg->regs->errcode)) continue; - /* OK, it's really not there (or not OK): the Guest - * needs to know. We write out the cr2 value so it - * knows where the fault occurred. - * - * Note that if the Guest were really messed up, this - * could happen before it's done the INITIALIZE - * hypercall, so lg->lguest_data will be NULL, so - * &lg->lguest_data->cr2 will be address 8. Writing - * into that address won't hurt the Host at all, - * though. */ + /* If lguest_data is NULL, this won't hurt. */ if (put_user(cr2, &lg->lguest_data->cr2)) kill_guest(lg, "Writing cr2"); break; case 7: /* We've intercepted a Device Not Available fault. */ - /* If the Guest doesn't want to know, we already - * restored the Floating Point Unit, so we just - * continue without telling it. */ + /* If they don't want to know, just absorb it. */ if (!lg->ts) continue; break; - case 32 ... 255: - /* These values mean a real interrupt occurred, in - * which case the Host handler has already been run. - * We just do a friendly check if another process - * should now be run, then fall through to loop - * around: */ + case 32 ... 255: /* Real interrupt, fall thru */ cond_resched(); case LGUEST_TRAP_ENTRY: /* Handled at top of loop */ continue; } - /* If we get here, it's a trap the Guest wants to know - * about. */ if (deliver_trap(lg, lg->regs->trapnum)) continue; - /* If the Guest doesn't have a handler (either it hasn't - * registered any yet, or it's one of the faults we don't let - * it handle), it dies with a cryptic error message. */ kill_guest(lg, "unhandled trap %li at %#lx (%#lx)", lg->regs->trapnum, lg->regs->eip, lg->regs->trapnum == 14 ? cr2 : lg->regs->errcode); } - /* The Guest is dead => "No such file or directory" */ return -ENOENT; } -/* Now we can look at each of the routines this calls, in increasing order of - * complexity: do_hypercalls(), emulate_insn(), maybe_do_interrupt(), - * deliver_trap() and demand_page(). After all those, we'll be ready to - * examine the Switcher, and our philosophical understanding of the Host/Guest - * duality will be complete. :*/ - int find_free_guest(void) { unsigned int i; @@ -675,96 +407,55 @@ static void adjust_pge(void *on) write_cr4(read_cr4() & ~X86_CR4_PGE); } -/*H:000 - * Welcome to the Host! - * - * By this point your brain has been tickled by the Guest code and numbed by - * the Launcher code; prepare for it to be stretched by the Host code. This is - * the heart. Let's begin at the initialization routine for the Host's lg - * module. - */ static int __init init(void) { int err; - /* Lguest can't run under Xen, VMI or itself. It does Tricky Stuff. */ if (paravirt_enabled()) { printk("lguest is afraid of %s\n", paravirt_ops.name); return -EPERM; } - /* First we put the Switcher up in very high virtual memory. */ err = map_switcher(); if (err) return err; - /* Now we set up the pagetable implementation for the Guests. */ err = init_pagetables(switcher_page, SHARED_SWITCHER_PAGES); if (err) { unmap_switcher(); return err; } - - /* The I/O subsystem needs some things initialized. */ lguest_io_init(); - /* /dev/lguest needs to be registered. */ err = lguest_device_init(); if (err) { free_pagetables(); unmap_switcher(); return err; } - - /* Finally, we need to turn off "Page Global Enable". PGE is an - * optimization where page table entries are specially marked to show - * they never change. The Host kernel marks all the kernel pages this - * way because it's always present, even when userspace is running. - * - * Lguest breaks this: unbeknownst to the rest of the Host kernel, we - * switch to the Guest kernel. If you don't disable this on all CPUs, - * you'll get really weird bugs that you'll chase for two days. - * - * I used to turn PGE off every time we switched to the Guest and back - * on when we return, but that slowed the Switcher down noticibly. */ - - /* We don't need the complexity of CPUs coming and going while we're - * doing this. */ lock_cpu_hotplug(); if (cpu_has_pge) { /* We have a broader idea of "global". */ - /* Remember that this was originally set (for cleanup). */ cpu_had_pge = 1; - /* adjust_pge is a helper function which sets or unsets the PGE - * bit on its CPU, depending on the argument (0 == unset). */ on_each_cpu(adjust_pge, (void *)0, 0, 1); - /* Turn off the feature in the global feature set. */ clear_bit(X86_FEATURE_PGE, boot_cpu_data.x86_capability); } unlock_cpu_hotplug(); - - /* All good! */ return 0; } -/* Cleaning up is just the same code, backwards. With a little French. */ static void __exit fini(void) { lguest_device_remove(); free_pagetables(); unmap_switcher(); - - /* If we had PGE before we started, turn it back on now. */ lock_cpu_hotplug(); if (cpu_had_pge) { set_bit(X86_FEATURE_PGE, boot_cpu_data.x86_capability); - /* adjust_pge's argument "1" means set PGE. */ on_each_cpu(adjust_pge, (void *)1, 0, 1); } unlock_cpu_hotplug(); } -/* The Host side of lguest can be a module. This is a nice way for people to - * play with it. */ module_init(init); module_exit(fini); MODULE_LICENSE("GPL"); diff --git a/trunk/drivers/lguest/hypercalls.c b/trunk/drivers/lguest/hypercalls.c index 7a5299f9679d..ea52ca451f74 100644 --- a/trunk/drivers/lguest/hypercalls.c +++ b/trunk/drivers/lguest/hypercalls.c @@ -1,10 +1,5 @@ -/*P:500 Just as userspace programs request kernel operations through a system - * call, the Guest requests Host operations through a "hypercall". You might - * notice this nomenclature doesn't really follow any logic, but the name has - * been around for long enough that we're stuck with it. As you'd expect, this - * code is basically a one big switch statement. :*/ - -/* Copyright (C) 2006 Rusty Russell IBM Corporation +/* Actual hypercalls, which allow guests to actually do something. + Copyright (C) 2006 Rusty Russell IBM Corporation This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -28,63 +23,37 @@ #include #include "lg.h" -/*H:120 This is the core hypercall routine: where the Guest gets what it - * wants. Or gets killed. Or, in the case of LHCALL_CRASH, both. - * - * Remember from the Guest: %eax == which call to make, and the arguments are - * packed into %edx, %ebx and %ecx if needed. */ static void do_hcall(struct lguest *lg, struct lguest_regs *regs) { switch (regs->eax) { case LHCALL_FLUSH_ASYNC: - /* This call does nothing, except by breaking out of the Guest - * it makes us process all the asynchronous hypercalls. */ break; case LHCALL_LGUEST_INIT: - /* You can't get here unless you're already initialized. Don't - * do that. */ kill_guest(lg, "already have lguest_data"); break; case LHCALL_CRASH: { - /* Crash is such a trivial hypercall that we do it in four - * lines right here. */ char msg[128]; - /* If the lgread fails, it will call kill_guest() itself; the - * kill_guest() with the message will be ignored. */ lgread(lg, msg, regs->edx, sizeof(msg)); msg[sizeof(msg)-1] = '\0'; kill_guest(lg, "CRASH: %s", msg); break; } case LHCALL_FLUSH_TLB: - /* FLUSH_TLB comes in two flavors, depending on the - * argument: */ if (regs->edx) guest_pagetable_clear_all(lg); else guest_pagetable_flush_user(lg); break; case LHCALL_GET_WALLCLOCK: { - /* The Guest wants to know the real time in seconds since 1970, - * in good Unix tradition. */ struct timespec ts; ktime_get_real_ts(&ts); regs->eax = ts.tv_sec; break; } case LHCALL_BIND_DMA: - /* BIND_DMA really wants four arguments, but it's the only call - * which does. So the Guest packs the number of buffers and - * the interrupt number into the final argument, and we decode - * it here. This can legitimately fail, since we currently - * place a limit on the number of DMA pools a Guest can have. - * So we return true or false from this call. */ regs->eax = bind_dma(lg, regs->edx, regs->ebx, regs->ecx >> 8, regs->ecx & 0xFF); break; - - /* All these calls simply pass the arguments through to the right - * routines. */ case LHCALL_SEND_DMA: send_dma(lg, regs->edx, regs->ebx); break; @@ -112,13 +81,10 @@ static void do_hcall(struct lguest *lg, struct lguest_regs *regs) case LHCALL_SET_CLOCKEVENT: guest_set_clockevent(lg, regs->edx); break; - case LHCALL_TS: - /* This sets the TS flag, as we saw used in run_guest(). */ lg->ts = regs->edx; break; case LHCALL_HALT: - /* Similarly, this sets the halted flag for run_guest(). */ lg->halted = 1; break; default: @@ -126,42 +92,25 @@ static void do_hcall(struct lguest *lg, struct lguest_regs *regs) } } -/* Asynchronous hypercalls are easy: we just look in the array in the Guest's - * "struct lguest_data" and see if there are any new ones marked "ready". - * - * We are careful to do these in order: obviously we respect the order the - * Guest put them in the ring, but we also promise the Guest that they will - * happen before any normal hypercall (which is why we check this before - * checking for a normal hcall). */ +/* We always do queued calls before actual hypercall. */ static void do_async_hcalls(struct lguest *lg) { unsigned int i; u8 st[LHCALL_RING_SIZE]; - /* For simplicity, we copy the entire call status array in at once. */ if (copy_from_user(&st, &lg->lguest_data->hcall_status, sizeof(st))) return; - - /* We process "struct lguest_data"s hcalls[] ring once. */ for (i = 0; i < ARRAY_SIZE(st); i++) { struct lguest_regs regs; - /* We remember where we were up to from last time. This makes - * sure that the hypercalls are done in the order the Guest - * places them in the ring. */ unsigned int n = lg->next_hcall; - /* 0xFF means there's no call here (yet). */ if (st[n] == 0xFF) break; - /* OK, we have hypercall. Increment the "next_hcall" cursor, - * and wrap back to 0 if we reach the end. */ if (++lg->next_hcall == LHCALL_RING_SIZE) lg->next_hcall = 0; - /* We copy the hypercall arguments into a fake register - * structure. This makes life simple for do_hcall(). */ if (get_user(regs.eax, &lg->lguest_data->hcalls[n].eax) || get_user(regs.edx, &lg->lguest_data->hcalls[n].edx) || get_user(regs.ecx, &lg->lguest_data->hcalls[n].ecx) @@ -170,126 +119,74 @@ static void do_async_hcalls(struct lguest *lg) break; } - /* Do the hypercall, same as a normal one. */ do_hcall(lg, ®s); - - /* Mark the hypercall done. */ if (put_user(0xFF, &lg->lguest_data->hcall_status[n])) { kill_guest(lg, "Writing result for async hypercall"); break; } - /* Stop doing hypercalls if we've just done a DMA to the - * Launcher: it needs to service this first. */ if (lg->dma_is_pending) break; } } -/* Last of all, we look at what happens first of all. The very first time the - * Guest makes a hypercall, we end up here to set things up: */ static void initialize(struct lguest *lg) { u32 tsc_speed; - /* You can't do anything until you're initialized. The Guest knows the - * rules, so we're unforgiving here. */ if (lg->regs->eax != LHCALL_LGUEST_INIT) { kill_guest(lg, "hypercall %li before LGUEST_INIT", lg->regs->eax); return; } - /* We insist that the Time Stamp Counter exist and doesn't change with - * cpu frequency. Some devious chip manufacturers decided that TSC - * changes could be handled in software. I decided that time going - * backwards might be good for benchmarks, but it's bad for users. - * - * We also insist that the TSC be stable: the kernel detects unreliable - * TSCs for its own purposes, and we use that here. */ + /* We only tell the guest to use the TSC if it's reliable. */ if (boot_cpu_has(X86_FEATURE_CONSTANT_TSC) && !check_tsc_unstable()) tsc_speed = tsc_khz; else tsc_speed = 0; - /* The pointer to the Guest's "struct lguest_data" is the only - * argument. */ lg->lguest_data = (struct lguest_data __user *)lg->regs->edx; - /* If we check the address they gave is OK now, we can simply - * copy_to_user/from_user from now on rather than using lgread/lgwrite. - * I put this in to show that I'm not immune to writing stupid - * optimizations. */ + /* We check here so we can simply copy_to_user/from_user */ if (!lguest_address_ok(lg, lg->regs->edx, sizeof(*lg->lguest_data))) { kill_guest(lg, "bad guest page %p", lg->lguest_data); return; } - /* The Guest tells us where we're not to deliver interrupts by putting - * the range of addresses into "struct lguest_data". */ if (get_user(lg->noirq_start, &lg->lguest_data->noirq_start) || get_user(lg->noirq_end, &lg->lguest_data->noirq_end) - /* We tell the Guest that it can't use the top 4MB of virtual - * addresses used by the Switcher. */ + /* We reserve the top pgd entry. */ || put_user(4U*1024*1024, &lg->lguest_data->reserve_mem) || put_user(tsc_speed, &lg->lguest_data->tsc_khz) - /* We also give the Guest a unique id, as used in lguest_net.c. */ || put_user(lg->guestid, &lg->lguest_data->guestid)) kill_guest(lg, "bad guest page %p", lg->lguest_data); - /* This is the one case where the above accesses might have been the - * first write to a Guest page. This may have caused a copy-on-write - * fault, but the Guest might be referring to the old (read-only) - * page. */ + /* This is the one case where the above accesses might have + * been the first write to a Guest page. This may have caused + * a copy-on-write fault, but the Guest might be referring to + * the old (read-only) page. */ guest_pagetable_clear_all(lg); } -/* Now we've examined the hypercall code; our Guest can make requests. There - * is one other way we can do things for the Guest, as we see in - * emulate_insn(). */ -/*H:110 Tricky point: we mark the hypercall as "done" once we've done it. - * Normally we don't need to do this: the Guest will run again and update the - * trap number before we come back around the run_guest() loop to - * do_hypercalls(). - * - * However, if we are signalled or the Guest sends DMA to the Launcher, that - * loop will exit without running the Guest. When it comes back it would try - * to re-run the hypercall. */ +/* Even if we go out to userspace and come back, we don't want to do + * the hypercall again. */ static void clear_hcall(struct lguest *lg) { lg->regs->trapnum = 255; } -/*H:100 - * Hypercalls - * - * Remember from the Guest, hypercalls come in two flavors: normal and - * asynchronous. This file handles both of types. - */ void do_hypercalls(struct lguest *lg) { - /* Not initialized yet? */ if (unlikely(!lg->lguest_data)) { - /* Did the Guest make a hypercall? We might have come back for - * some other reason (an interrupt, a different trap). */ if (lg->regs->trapnum == LGUEST_TRAP_ENTRY) { - /* Set up the "struct lguest_data" */ initialize(lg); - /* The hypercall is done. */ clear_hcall(lg); } return; } - /* The Guest has initialized. - * - * Look in the hypercall ring for the async hypercalls: */ do_async_hcalls(lg); - - /* If we stopped reading the hypercall ring because the Guest did a - * SEND_DMA to the Launcher, we want to return now. Otherwise if the - * Guest asked us to do a hypercall, we do it. */ if (!lg->dma_is_pending && lg->regs->trapnum == LGUEST_TRAP_ENTRY) { do_hcall(lg, lg->regs); - /* The hypercall is done. */ clear_hcall(lg); } } diff --git a/trunk/drivers/lguest/interrupts_and_traps.c b/trunk/drivers/lguest/interrupts_and_traps.c index bd0091bf79ec..bee029bb2c7b 100644 --- a/trunk/drivers/lguest/interrupts_and_traps.c +++ b/trunk/drivers/lguest/interrupts_and_traps.c @@ -1,160 +1,100 @@ -/*P:800 Interrupts (traps) are complicated enough to earn their own file. - * There are three classes of interrupts: - * - * 1) Real hardware interrupts which occur while we're running the Guest, - * 2) Interrupts for virtual devices attached to the Guest, and - * 3) Traps and faults from the Guest. - * - * Real hardware interrupts must be delivered to the Host, not the Guest. - * Virtual interrupts must be delivered to the Guest, but we make them look - * just like real hardware would deliver them. Traps from the Guest can be set - * up to go directly back into the Guest, but sometimes the Host wants to see - * them first, so we also have a way of "reflecting" them into the Guest as if - * they had been delivered to it directly. :*/ #include #include "lg.h" -/* The address of the interrupt handler is split into two bits: */ static unsigned long idt_address(u32 lo, u32 hi) { return (lo & 0x0000FFFF) | (hi & 0xFFFF0000); } -/* The "type" of the interrupt handler is a 4 bit field: we only support a - * couple of types. */ static int idt_type(u32 lo, u32 hi) { return (hi >> 8) & 0xF; } -/* An IDT entry can't be used unless the "present" bit is set. */ static int idt_present(u32 lo, u32 hi) { return (hi & 0x8000); } -/* We need a helper to "push" a value onto the Guest's stack, since that's a - * big part of what delivering an interrupt does. */ static void push_guest_stack(struct lguest *lg, unsigned long *gstack, u32 val) { - /* Stack grows upwards: move stack then write value. */ *gstack -= 4; lgwrite_u32(lg, *gstack, val); } -/*H:210 The set_guest_interrupt() routine actually delivers the interrupt or - * trap. The mechanics of delivering traps and interrupts to the Guest are the - * same, except some traps have an "error code" which gets pushed onto the - * stack as well: the caller tells us if this is one. - * - * "lo" and "hi" are the two parts of the Interrupt Descriptor Table for this - * interrupt or trap. It's split into two parts for traditional reasons: gcc - * on i386 used to be frightened by 64 bit numbers. - * - * We set up the stack just like the CPU does for a real interrupt, so it's - * identical for the Guest (and the standard "iret" instruction will undo - * it). */ static void set_guest_interrupt(struct lguest *lg, u32 lo, u32 hi, int has_err) { unsigned long gstack; u32 eflags, ss, irq_enable; - /* There are two cases for interrupts: one where the Guest is already - * in the kernel, and a more complex one where the Guest is in - * userspace. We check the privilege level to find out. */ + /* If they want a ring change, we use new stack and push old ss/esp */ if ((lg->regs->ss&0x3) != GUEST_PL) { - /* The Guest told us their kernel stack with the SET_STACK - * hypercall: both the virtual address and the segment */ gstack = guest_pa(lg, lg->esp1); ss = lg->ss1; - /* We push the old stack segment and pointer onto the new - * stack: when the Guest does an "iret" back from the interrupt - * handler the CPU will notice they're dropping privilege - * levels and expect these here. */ push_guest_stack(lg, &gstack, lg->regs->ss); push_guest_stack(lg, &gstack, lg->regs->esp); } else { - /* We're staying on the same Guest (kernel) stack. */ gstack = guest_pa(lg, lg->regs->esp); ss = lg->regs->ss; } - /* Remember that we never let the Guest actually disable interrupts, so - * the "Interrupt Flag" bit is always set. We copy that bit from the - * Guest's "irq_enabled" field into the eflags word: the Guest copies - * it back in "lguest_iret". */ + /* We use IF bit in eflags to indicate whether irqs were enabled + (it's always 1, since irqs are enabled when guest is running). */ eflags = lg->regs->eflags; if (get_user(irq_enable, &lg->lguest_data->irq_enabled) == 0 && !(irq_enable & X86_EFLAGS_IF)) eflags &= ~X86_EFLAGS_IF; - /* An interrupt is expected to push three things on the stack: the old - * "eflags" word, the old code segment, and the old instruction - * pointer. */ push_guest_stack(lg, &gstack, eflags); push_guest_stack(lg, &gstack, lg->regs->cs); push_guest_stack(lg, &gstack, lg->regs->eip); - /* For the six traps which supply an error code, we push that, too. */ if (has_err) push_guest_stack(lg, &gstack, lg->regs->errcode); - /* Now we've pushed all the old state, we change the stack, the code - * segment and the address to execute. */ + /* Change the real stack so switcher returns to trap handler */ lg->regs->ss = ss; lg->regs->esp = gstack + lg->page_offset; lg->regs->cs = (__KERNEL_CS|GUEST_PL); lg->regs->eip = idt_address(lo, hi); - /* There are two kinds of interrupt handlers: 0xE is an "interrupt - * gate" which expects interrupts to be disabled on entry. */ + /* Disable interrupts for an interrupt gate. */ if (idt_type(lo, hi) == 0xE) if (put_user(0, &lg->lguest_data->irq_enabled)) kill_guest(lg, "Disabling interrupts"); } -/*H:200 - * Virtual Interrupts. - * - * maybe_do_interrupt() gets called before every entry to the Guest, to see if - * we should divert the Guest to running an interrupt handler. */ void maybe_do_interrupt(struct lguest *lg) { unsigned int irq; DECLARE_BITMAP(blk, LGUEST_IRQS); struct desc_struct *idt; - /* If the Guest hasn't even initialized yet, we can do nothing. */ if (!lg->lguest_data) return; - /* Take our "irqs_pending" array and remove any interrupts the Guest - * wants blocked: the result ends up in "blk". */ + /* Mask out any interrupts they have blocked. */ if (copy_from_user(&blk, lg->lguest_data->blocked_interrupts, sizeof(blk))) return; bitmap_andnot(blk, lg->irqs_pending, blk, LGUEST_IRQS); - /* Find the first interrupt. */ irq = find_first_bit(blk, LGUEST_IRQS); - /* None? Nothing to do */ if (irq >= LGUEST_IRQS) return; - /* They may be in the middle of an iret, where they asked us never to - * deliver interrupts. */ if (lg->regs->eip >= lg->noirq_start && lg->regs->eip < lg->noirq_end) return; - /* If they're halted, interrupts restart them. */ + /* If they're halted, we re-enable interrupts. */ if (lg->halted) { /* Re-enable interrupts. */ if (put_user(X86_EFLAGS_IF, &lg->lguest_data->irq_enabled)) kill_guest(lg, "Re-enabling interrupts"); lg->halted = 0; } else { - /* Otherwise we check if they have interrupts disabled. */ + /* Maybe they have interrupts disabled? */ u32 irq_enabled; if (get_user(irq_enabled, &lg->lguest_data->irq_enabled)) irq_enabled = 0; @@ -162,211 +102,112 @@ void maybe_do_interrupt(struct lguest *lg) return; } - /* Look at the IDT entry the Guest gave us for this interrupt. The - * first 32 (FIRST_EXTERNAL_VECTOR) entries are for traps, so we skip - * over them. */ idt = &lg->idt[FIRST_EXTERNAL_VECTOR+irq]; - /* If they don't have a handler (yet?), we just ignore it */ if (idt_present(idt->a, idt->b)) { - /* OK, mark it no longer pending and deliver it. */ clear_bit(irq, lg->irqs_pending); - /* set_guest_interrupt() takes the interrupt descriptor and a - * flag to say whether this interrupt pushes an error code onto - * the stack as well: virtual interrupts never do. */ set_guest_interrupt(lg, idt->a, idt->b, 0); } } -/*H:220 Now we've got the routines to deliver interrupts, delivering traps - * like page fault is easy. The only trick is that Intel decided that some - * traps should have error codes: */ static int has_err(unsigned int trap) { return (trap == 8 || (trap >= 10 && trap <= 14) || trap == 17); } -/* deliver_trap() returns true if it could deliver the trap. */ int deliver_trap(struct lguest *lg, unsigned int num) { u32 lo = lg->idt[num].a, hi = lg->idt[num].b; - /* Early on the Guest hasn't set the IDT entries (or maybe it put a - * bogus one in): if we fail here, the Guest will be killed. */ if (!idt_present(lo, hi)) return 0; set_guest_interrupt(lg, lo, hi, has_err(num)); return 1; } -/*H:250 Here's the hard part: returning to the Host every time a trap happens - * and then calling deliver_trap() and re-entering the Guest is slow. - * Particularly because Guest userspace system calls are traps (trap 128). - * - * So we'd like to set up the IDT to tell the CPU to deliver traps directly - * into the Guest. This is possible, but the complexities cause the size of - * this file to double! However, 150 lines of code is worth writing for taking - * system calls down from 1750ns to 270ns. Plus, if lguest didn't do it, all - * the other hypervisors would tease it. - * - * This routine determines if a trap can be delivered directly. */ static int direct_trap(const struct lguest *lg, const struct desc_struct *trap, unsigned int num) { - /* Hardware interrupts don't go to the Guest at all (except system - * call). */ + /* Hardware interrupts don't go to guest (except syscall). */ if (num >= FIRST_EXTERNAL_VECTOR && num != SYSCALL_VECTOR) return 0; - /* The Host needs to see page faults (for shadow paging and to save the - * fault address), general protection faults (in/out emulation) and - * device not available (TS handling), and of course, the hypercall - * trap. */ + /* We intercept page fault (demand shadow paging & cr2 saving) + protection fault (in/out emulation) and device not + available (TS handling), and hypercall */ if (num == 14 || num == 13 || num == 7 || num == LGUEST_TRAP_ENTRY) return 0; - /* Only trap gates (type 15) can go direct to the Guest. Interrupt - * gates (type 14) disable interrupts as they are entered, which we - * never let the Guest do. Not present entries (type 0x0) also can't - * go direct, of course 8) */ + /* Interrupt gates (0xE) or not present (0x0) can't go direct. */ return idt_type(trap->a, trap->b) == 0xF; } -/*:*/ - -/*M:005 The Guest has the ability to turn its interrupt gates into trap gates, - * if it is careful. The Host will let trap gates can go directly to the - * Guest, but the Guest needs the interrupts atomically disabled for an - * interrupt gate. It can do this by pointing the trap gate at instructions - * within noirq_start and noirq_end, where it can safely disable interrupts. */ - -/*M:006 The Guests do not use the sysenter (fast system call) instruction, - * because it's hardcoded to enter privilege level 0 and so can't go direct. - * It's about twice as fast as the older "int 0x80" system call, so it might - * still be worthwhile to handle it in the Switcher and lcall down to the - * Guest. The sysenter semantics are hairy tho: search for that keyword in - * entry.S :*/ - -/*H:260 When we make traps go directly into the Guest, we need to make sure - * the kernel stack is valid (ie. mapped in the page tables). Otherwise, the - * CPU trying to deliver the trap will fault while trying to push the interrupt - * words on the stack: this is called a double fault, and it forces us to kill - * the Guest. - * - * Which is deeply unfair, because (literally!) it wasn't the Guests' fault. */ + void pin_stack_pages(struct lguest *lg) { unsigned int i; - /* Depending on the CONFIG_4KSTACKS option, the Guest can have one or - * two pages of stack space. */ for (i = 0; i < lg->stack_pages; i++) - /* The stack grows *upwards*, hence the subtraction */ pin_page(lg, lg->esp1 - i * PAGE_SIZE); } -/* Direct traps also mean that we need to know whenever the Guest wants to use - * a different kernel stack, so we can change the IDT entries to use that - * stack. The IDT entries expect a virtual address, so unlike most addresses - * the Guest gives us, the "esp" (stack pointer) value here is virtual, not - * physical. - * - * In Linux each process has its own kernel stack, so this happens a lot: we - * change stacks on each context switch. */ void guest_set_stack(struct lguest *lg, u32 seg, u32 esp, unsigned int pages) { - /* You are not allowd have a stack segment with privilege level 0: bad - * Guest! */ + /* You cannot have a stack segment with priv level 0. */ if ((seg & 0x3) != GUEST_PL) kill_guest(lg, "bad stack segment %i", seg); - /* We only expect one or two stack pages. */ if (pages > 2) kill_guest(lg, "bad stack pages %u", pages); - /* Save where the stack is, and how many pages */ lg->ss1 = seg; lg->esp1 = esp; lg->stack_pages = pages; - /* Make sure the new stack pages are mapped */ pin_stack_pages(lg); } -/* All this reference to mapping stacks leads us neatly into the other complex - * part of the Host: page table handling. */ - -/*H:235 This is the routine which actually checks the Guest's IDT entry and - * transfers it into our entry in "struct lguest": */ +/* Set up trap in IDT. */ static void set_trap(struct lguest *lg, struct desc_struct *trap, unsigned int num, u32 lo, u32 hi) { u8 type = idt_type(lo, hi); - /* We zero-out a not-present entry */ if (!idt_present(lo, hi)) { trap->a = trap->b = 0; return; } - /* We only support interrupt and trap gates. */ if (type != 0xE && type != 0xF) kill_guest(lg, "bad IDT type %i", type); - /* We only copy the handler address, present bit, privilege level and - * type. The privilege level controls where the trap can be triggered - * manually with an "int" instruction. This is usually GUEST_PL, - * except for system calls which userspace can use. */ trap->a = ((__KERNEL_CS|GUEST_PL)<<16) | (lo&0x0000FFFF); trap->b = (hi&0xFFFFEF00); } -/*H:230 While we're here, dealing with delivering traps and interrupts to the - * Guest, we might as well complete the picture: how the Guest tells us where - * it wants them to go. This would be simple, except making traps fast - * requires some tricks. - * - * We saw the Guest setting Interrupt Descriptor Table (IDT) entries with the - * LHCALL_LOAD_IDT_ENTRY hypercall before: that comes here. */ void load_guest_idt_entry(struct lguest *lg, unsigned int num, u32 lo, u32 hi) { - /* Guest never handles: NMI, doublefault, spurious interrupt or - * hypercall. We ignore when it tries to set them. */ + /* Guest never handles: NMI, doublefault, hypercall, spurious irq. */ if (num == 2 || num == 8 || num == 15 || num == LGUEST_TRAP_ENTRY) return; - /* Mark the IDT as changed: next time the Guest runs we'll know we have - * to copy this again. */ lg->changed |= CHANGED_IDT; - - /* The IDT which we keep in "struct lguest" only contains 32 entries - * for the traps and LGUEST_IRQS (32) entries for interrupts. We - * ignore attempts to set handlers for higher interrupt numbers, except - * for the system call "interrupt" at 128: we have a special IDT entry - * for that. */ if (num < ARRAY_SIZE(lg->idt)) set_trap(lg, &lg->idt[num], num, lo, hi); else if (num == SYSCALL_VECTOR) set_trap(lg, &lg->syscall_idt, num, lo, hi); } -/* The default entry for each interrupt points into the Switcher routines which - * simply return to the Host. The run_guest() loop will then call - * deliver_trap() to bounce it back into the Guest. */ static void default_idt_entry(struct desc_struct *idt, int trap, const unsigned long handler) { - /* A present interrupt gate. */ u32 flags = 0x8e00; - /* Set the privilege level on the entry for the hypercall: this allows - * the Guest to use the "int" instruction to trigger it. */ + /* They can't "int" into any of them except hypercall. */ if (trap == LGUEST_TRAP_ENTRY) flags |= (GUEST_PL << 13); - /* Now pack it into the IDT entry in its weird format. */ idt->a = (LGUEST_CS<<16) | (handler&0x0000FFFF); idt->b = (handler&0xFFFF0000) | flags; } -/* When the Guest first starts, we put default entries into the IDT. */ void setup_default_idt_entries(struct lguest_ro_state *state, const unsigned long *def) { @@ -376,25 +217,19 @@ void setup_default_idt_entries(struct lguest_ro_state *state, default_idt_entry(&state->guest_idt[i], i, def[i]); } -/*H:240 We don't use the IDT entries in the "struct lguest" directly, instead - * we copy them into the IDT which we've set up for Guests on this CPU, just - * before we run the Guest. This routine does that copy. */ void copy_traps(const struct lguest *lg, struct desc_struct *idt, const unsigned long *def) { unsigned int i; - /* We can simply copy the direct traps, otherwise we use the default - * ones in the Switcher: they will return to the Host. */ + /* All hardware interrupts are same whatever the guest: only the + * traps might be different. */ for (i = 0; i < FIRST_EXTERNAL_VECTOR; i++) { if (direct_trap(lg, &lg->idt[i], i)) idt[i] = lg->idt[i]; else default_idt_entry(&idt[i], i, def[i]); } - - /* Don't forget the system call trap! The IDT entries for other - * interupts never change, so no need to copy them. */ i = SYSCALL_VECTOR; if (direct_trap(lg, &lg->syscall_idt, i)) idt[i] = lg->syscall_idt; diff --git a/trunk/drivers/lguest/io.c b/trunk/drivers/lguest/io.c index ea68613b43f6..c8eb79266991 100644 --- a/trunk/drivers/lguest/io.c +++ b/trunk/drivers/lguest/io.c @@ -1,9 +1,5 @@ -/*P:300 The I/O mechanism in lguest is simple yet flexible, allowing the Guest - * to talk to the Launcher or directly to another Guest. It uses familiar - * concepts of DMA and interrupts, plus some neat code stolen from - * futexes... :*/ - -/* Copyright (C) 2006 Rusty Russell IBM Corporation +/* Simple I/O model for guests, based on shared memory. + * Copyright (C) 2006 Rusty Russell IBM Corporation * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -27,36 +23,8 @@ #include #include "lg.h" -/*L:300 - * I/O - * - * Getting data in and out of the Guest is quite an art. There are numerous - * ways to do it, and they all suck differently. We try to keep things fairly - * close to "real" hardware so our Guest's drivers don't look like an alien - * visitation in the middle of the Linux code, and yet make sure that Guests - * can talk directly to other Guests, not just the Launcher. - * - * To do this, the Guest gives us a key when it binds or sends DMA buffers. - * The key corresponds to a "physical" address inside the Guest (ie. a virtual - * address inside the Launcher process). We don't, however, use this key - * directly. - * - * We want Guests which share memory to be able to DMA to each other: two - * Launchers can mmap memory the same file, then the Guests can communicate. - * Fortunately, the futex code provides us with a way to get a "union - * futex_key" corresponding to the memory lying at a virtual address: if the - * two processes share memory, the "union futex_key" for that memory will match - * even if the memory is mapped at different addresses in each. So we always - * convert the keys to "union futex_key"s to compare them. - * - * Before we dive into this though, we need to look at another set of helper - * routines used throughout the Host kernel code to access Guest memory. - :*/ static struct list_head dma_hash[61]; -/* An unfortunate side effect of the Linux double-linked list implementation is - * that there's no good way to statically initialize an array of linked - * lists. */ void lguest_io_init(void) { unsigned int i; @@ -88,19 +56,6 @@ static int check_dma_list(struct lguest *lg, const struct lguest_dma *dma) return 0; } -/*L:330 This is our hash function, using the wonderful Jenkins hash. - * - * The futex key is a union with three parts: an unsigned long word, a pointer, - * and an int "offset". We could use jhash_2words() which takes three u32s. - * (Ok, the hash functions are great: the naming sucks though). - * - * It's nice to be portable to 64-bit platforms, so we use the more generic - * jhash2(), which takes an array of u32, the number of u32s, and an initial - * u32 to roll in. This is uglier, but breaks down to almost the same code on - * 32-bit platforms like this one. - * - * We want a position in the array, so we modulo ARRAY_SIZE(dma_hash) (ie. 61). - */ static unsigned int hash(const union futex_key *key) { return jhash2((u32*)&key->both.word, @@ -109,9 +64,6 @@ static unsigned int hash(const union futex_key *key) % ARRAY_SIZE(dma_hash); } -/* This is a convenience routine to compare two keys. It's a much bemoaned C - * weakness that it doesn't allow '==' on structures or unions, so we have to - * open-code it like this. */ static inline int key_eq(const union futex_key *a, const union futex_key *b) { return (a->both.word == b->both.word @@ -119,36 +71,22 @@ static inline int key_eq(const union futex_key *a, const union futex_key *b) && a->both.offset == b->both.offset); } -/*L:360 OK, when we need to actually free up a Guest's DMA array we do several - * things, so we have a convenient function to do it. - * - * The caller must hold a read lock on dmainfo owner's current->mm->mmap_sem - * for the drop_futex_key_refs(). */ +/* Must hold read lock on dmainfo owner's current->mm->mmap_sem */ static void unlink_dma(struct lguest_dma_info *dmainfo) { - /* You locked this too, right? */ BUG_ON(!mutex_is_locked(&lguest_lock)); - /* This is how we know that the entry is free. */ dmainfo->interrupt = 0; - /* Remove it from the hash table. */ list_del(&dmainfo->list); - /* Drop the references we were holding (to the inode or mm). */ drop_futex_key_refs(&dmainfo->key); } -/*L:350 This is the routine which we call when the Guest asks to unregister a - * DMA array attached to a given key. Returns true if the array was found. */ static int unbind_dma(struct lguest *lg, const union futex_key *key, unsigned long dmas) { int i, ret = 0; - /* We don't bother with the hash table, just look through all this - * Guest's DMA arrays. */ for (i = 0; i < LGUEST_MAX_DMA; i++) { - /* In theory it could have more than one array on the same key, - * or one array on multiple keys, so we check both */ if (key_eq(key, &lg->dma[i].key) && dmas == lg->dma[i].dmas) { unlink_dma(&lg->dma[i]); ret = 1; @@ -158,91 +96,51 @@ static int unbind_dma(struct lguest *lg, return ret; } -/*L:340 BIND_DMA: this is the hypercall which sets up an array of "struct - * lguest_dma" for receiving I/O. - * - * The Guest wants to bind an array of "struct lguest_dma"s to a particular key - * to receive input. This only happens when the Guest is setting up a new - * device, so it doesn't have to be very fast. - * - * It returns 1 on a successful registration (it can fail if we hit the limit - * of registrations for this Guest). - */ int bind_dma(struct lguest *lg, unsigned long ukey, unsigned long dmas, u16 numdmas, u8 interrupt) { unsigned int i; int ret = 0; union futex_key key; - /* Futex code needs the mmap_sem. */ struct rw_semaphore *fshared = ¤t->mm->mmap_sem; - /* Invalid interrupt? (We could kill the guest here). */ if (interrupt >= LGUEST_IRQS) return 0; - /* We need to grab the Big Lguest Lock, because other Guests may be - * trying to look through this Guest's DMAs to send something while - * we're doing this. */ mutex_lock(&lguest_lock); down_read(fshared); if (get_futex_key((u32 __user *)ukey, fshared, &key) != 0) { kill_guest(lg, "bad dma key %#lx", ukey); goto unlock; } - - /* We want to keep this key valid once we drop mmap_sem, so we have to - * hold a reference. */ get_futex_key_refs(&key); - /* If the Guest specified an interrupt of 0, that means they want to - * unregister this array of "struct lguest_dma"s. */ if (interrupt == 0) ret = unbind_dma(lg, &key, dmas); else { - /* Look through this Guest's dma array for an unused entry. */ for (i = 0; i < LGUEST_MAX_DMA; i++) { - /* If the interrupt is non-zero, the entry is already - * used. */ if (lg->dma[i].interrupt) continue; - /* OK, a free one! Fill on our details. */ lg->dma[i].dmas = dmas; lg->dma[i].num_dmas = numdmas; lg->dma[i].next_dma = 0; lg->dma[i].key = key; lg->dma[i].guestid = lg->guestid; lg->dma[i].interrupt = interrupt; - - /* Now we add it to the hash table: the position - * depends on the futex key that we got. */ list_add(&lg->dma[i].list, &dma_hash[hash(&key)]); - /* Success! */ ret = 1; goto unlock; } } - /* If we didn't find a slot to put the key in, drop the reference - * again. */ drop_futex_key_refs(&key); unlock: - /* Unlock and out. */ up_read(fshared); mutex_unlock(&lguest_lock); return ret; } -/*L:385 Note that our routines to access a different Guest's memory are called - * lgread_other() and lgwrite_other(): these names emphasize that they are only - * used when the Guest is *not* the current Guest. - * - * The interface for copying from another process's memory is called - * access_process_vm(), with a final argument of 0 for a read, and 1 for a - * write. - * - * We need lgread_other() to read the destination Guest's "struct lguest_dma" - * array. */ +/* lgread from another guest */ static int lgread_other(struct lguest *lg, void *buf, u32 addr, unsigned bytes) { @@ -255,8 +153,7 @@ static int lgread_other(struct lguest *lg, return 1; } -/* "lgwrite()" to another Guest: used to update the destination "used_len" once - * we've transferred data into the buffer. */ +/* lgwrite to another guest */ static int lgwrite_other(struct lguest *lg, u32 addr, const void *buf, unsigned bytes) { @@ -269,15 +166,6 @@ static int lgwrite_other(struct lguest *lg, u32 addr, return 1; } -/*L:400 This is the generic engine which copies from a source "struct - * lguest_dma" from this Guest into another Guest's "struct lguest_dma". The - * destination Guest's pages have already been mapped, as contained in the - * pages array. - * - * If you're wondering if there's a nice "copy from one process to another" - * routine, so was I. But Linux isn't really set up to copy between two - * unrelated processes, so we have to write it ourselves. - */ static u32 copy_data(struct lguest *srclg, const struct lguest_dma *src, const struct lguest_dma *dst, @@ -286,59 +174,33 @@ static u32 copy_data(struct lguest *srclg, unsigned int totlen, si, di, srcoff, dstoff; void *maddr = NULL; - /* We return the total length transferred. */ totlen = 0; - - /* We keep indexes into the source and destination "struct lguest_dma", - * and an offset within each region. */ si = di = 0; srcoff = dstoff = 0; - - /* We loop until the source or destination is exhausted. */ while (si < LGUEST_MAX_DMA_SECTIONS && src->len[si] && di < LGUEST_MAX_DMA_SECTIONS && dst->len[di]) { - /* We can only transfer the rest of the src buffer, or as much - * as will fit into the destination buffer. */ u32 len = min(src->len[si] - srcoff, dst->len[di] - dstoff); - /* For systems using "highmem" we need to use kmap() to access - * the page we want. We often use the same page over and over, - * so rather than kmap() it on every loop, we set the maddr - * pointer to NULL when we need to move to the next - * destination page. */ if (!maddr) maddr = kmap(pages[di]); - /* Copy directly from (this Guest's) source address to the - * destination Guest's kmap()ed buffer. Note that maddr points - * to the start of the page: we need to add the offset of the - * destination address and offset within the buffer. */ - - /* FIXME: This is not completely portable. I looked at - * copy_to_user_page(), and some arch's seem to need special - * flushes. x86 is fine. */ + /* FIXME: This is not completely portable, since + archs do different things for copy_to_user_page. */ if (copy_from_user(maddr + (dst->addr[di] + dstoff)%PAGE_SIZE, (void __user *)src->addr[si], len) != 0) { - /* If a copy failed, it's the source's fault. */ kill_guest(srclg, "bad address in sending DMA"); totlen = 0; break; } - /* Increment the total and src & dst offsets */ totlen += len; srcoff += len; dstoff += len; - - /* Presumably we reached the end of the src or dest buffers: */ if (srcoff == src->len[si]) { - /* Move to the next buffer at offset 0 */ si++; srcoff = 0; } if (dstoff == dst->len[di]) { - /* We need to unmap that destination page and reset - * maddr ready for the next one. */ kunmap(pages[di]); maddr = NULL; di++; @@ -346,15 +208,13 @@ static u32 copy_data(struct lguest *srclg, } } - /* If we still had a page mapped at the end, unmap now. */ if (maddr) kunmap(pages[di]); return totlen; } -/*L:390 This is how we transfer a "struct lguest_dma" from the source Guest - * (the current Guest which called SEND_DMA) to another Guest. */ +/* Src is us, ie. current. */ static u32 do_dma(struct lguest *srclg, const struct lguest_dma *src, struct lguest *dstlg, const struct lguest_dma *dst) { @@ -362,31 +222,23 @@ static u32 do_dma(struct lguest *srclg, const struct lguest_dma *src, u32 ret; struct page *pages[LGUEST_MAX_DMA_SECTIONS]; - /* We check that both source and destination "struct lguest_dma"s are - * within the bounds of the source and destination Guests */ if (!check_dma_list(dstlg, dst) || !check_dma_list(srclg, src)) return 0; - /* We need to map the pages which correspond to each parts of - * destination buffer. */ + /* First get the destination pages */ for (i = 0; i < LGUEST_MAX_DMA_SECTIONS; i++) { if (dst->len[i] == 0) break; - /* get_user_pages() is a complicated function, especially since - * we only want a single page. But it works, and returns the - * number of pages. Note that we're holding the destination's - * mmap_sem, as get_user_pages() requires. */ if (get_user_pages(dstlg->tsk, dstlg->mm, dst->addr[i], 1, 1, 1, pages+i, NULL) != 1) { - /* This means the destination gave us a bogus buffer */ kill_guest(dstlg, "Error mapping DMA pages"); ret = 0; goto drop_pages; } } - /* Now copy the data until we run out of src or dst. */ + /* Now copy until we run out of src or dst. */ ret = copy_data(srclg, src, dst, pages); drop_pages: @@ -395,11 +247,6 @@ static u32 do_dma(struct lguest *srclg, const struct lguest_dma *src, return ret; } -/*L:380 Transferring data from one Guest to another is not as simple as I'd - * like. We've found the "struct lguest_dma_info" bound to the same address as - * the send, we need to copy into it. - * - * This function returns true if the destination array was empty. */ static int dma_transfer(struct lguest *srclg, unsigned long udma, struct lguest_dma_info *dst) @@ -408,23 +255,15 @@ static int dma_transfer(struct lguest *srclg, struct lguest *dstlg; u32 i, dma = 0; - /* From the "struct lguest_dma_info" we found in the hash, grab the - * Guest. */ dstlg = &lguests[dst->guestid]; - /* Read in the source "struct lguest_dma" handed to SEND_DMA. */ + /* Get our dma list. */ lgread(srclg, &src_dma, udma, sizeof(src_dma)); - /* We need the destination's mmap_sem, and we already hold the source's - * mmap_sem for the futex key lookup. Normally this would suggest that - * we could deadlock if the destination Guest was trying to send to - * this source Guest at the same time, which is another reason that all - * I/O is done under the big lguest_lock. */ + /* We can't deadlock against them dmaing to us, because this + * is all under the lguest_lock. */ down_read(&dstlg->mm->mmap_sem); - /* Look through the destination DMA array for an available buffer. */ for (i = 0; i < dst->num_dmas; i++) { - /* We keep a "next_dma" pointer which often helps us avoid - * looking at lots of previously-filled entries. */ dma = (dst->next_dma + i) % dst->num_dmas; if (!lgread_other(dstlg, &dst_dma, dst->dmas + dma * sizeof(struct lguest_dma), @@ -434,46 +273,30 @@ static int dma_transfer(struct lguest *srclg, if (!dst_dma.used_len) break; } - - /* If we found a buffer, we do the actual data copy. */ if (i != dst->num_dmas) { unsigned long used_lenp; unsigned int ret; ret = do_dma(srclg, &src_dma, dstlg, &dst_dma); - /* Put used length in the source "struct lguest_dma"'s used_len - * field. It's a little tricky to figure out where that is, - * though. */ + /* Put used length in src. */ lgwrite_u32(srclg, udma+offsetof(struct lguest_dma, used_len), ret); - /* Tranferring 0 bytes is OK if the source buffer was empty. */ if (ret == 0 && src_dma.len[0] != 0) goto fail; - /* The destination Guest might be running on a different CPU: - * we have to make sure that it will see the "used_len" field - * change to non-zero *after* it sees the data we copied into - * the buffer. Hence a write memory barrier. */ + /* Make sure destination sees contents before length. */ wmb(); - /* Figuring out where the destination's used_len field for this - * "struct lguest_dma" in the array is also a little ugly. */ used_lenp = dst->dmas + dma * sizeof(struct lguest_dma) + offsetof(struct lguest_dma, used_len); lgwrite_other(dstlg, used_lenp, &ret, sizeof(ret)); - /* Move the cursor for next time. */ dst->next_dma++; } up_read(&dstlg->mm->mmap_sem); - /* We trigger the destination interrupt, even if the destination was - * empty and we didn't transfer anything: this gives them a chance to - * wake up and refill. */ + /* Do this last so dst doesn't simply sleep on lock. */ set_bit(dst->interrupt, dstlg->irqs_pending); - /* Wake up the destination process. */ wake_up_process(dstlg->tsk); - /* If we passed the last "struct lguest_dma", the receive had no - * buffers left. */ return i == dst->num_dmas; fail: @@ -481,8 +304,6 @@ static int dma_transfer(struct lguest *srclg, return 0; } -/*L:370 This is the counter-side to the BIND_DMA hypercall; the SEND_DMA - * hypercall. We find out who's listening, and send to them. */ void send_dma(struct lguest *lg, unsigned long ukey, unsigned long udma) { union futex_key key; @@ -492,43 +313,31 @@ void send_dma(struct lguest *lg, unsigned long ukey, unsigned long udma) again: mutex_lock(&lguest_lock); down_read(fshared); - /* Get the futex key for the key the Guest gave us */ if (get_futex_key((u32 __user *)ukey, fshared, &key) != 0) { kill_guest(lg, "bad sending DMA key"); goto unlock; } - /* Since the key must be a multiple of 4, the futex key uses the lower - * bit of the "offset" field (which would always be 0) to indicate a - * mapping which is shared with other processes (ie. Guests). */ + /* Shared mapping? Look for other guests... */ if (key.shared.offset & 1) { struct lguest_dma_info *i; - /* Look through the hash for other Guests. */ list_for_each_entry(i, &dma_hash[hash(&key)], list) { - /* Don't send to ourselves. */ if (i->guestid == lg->guestid) continue; if (!key_eq(&key, &i->key)) continue; - /* If dma_transfer() tells us the destination has no - * available buffers, we increment "empty". */ empty += dma_transfer(lg, udma, i); break; } - /* If the destination is empty, we release our locks and - * give the destination Guest a brief chance to restock. */ if (empty == 1) { /* Give any recipients one chance to restock. */ up_read(¤t->mm->mmap_sem); mutex_unlock(&lguest_lock); - /* Next time, we won't try again. */ empty++; goto again; } } else { - /* Private mapping: Guest is sending to its Launcher. We set - * the "dma_is_pending" flag so that the main loop will exit - * and the Launcher's read() from /dev/lguest will return. */ + /* Private mapping: tell our userspace. */ lg->dma_is_pending = 1; lg->pending_dma = udma; lg->pending_key = ukey; @@ -537,7 +346,6 @@ void send_dma(struct lguest *lg, unsigned long ukey, unsigned long udma) up_read(fshared); mutex_unlock(&lguest_lock); } -/*:*/ void release_all_dma(struct lguest *lg) { @@ -553,18 +361,7 @@ void release_all_dma(struct lguest *lg) up_read(&lg->mm->mmap_sem); } -/*M:007 We only return a single DMA buffer to the Launcher, but it would be - * more efficient to return a pointer to the entire array of DMA buffers, which - * it can cache and choose one whenever it wants. - * - * Currently the Launcher uses a write to /dev/lguest, and the return value is - * the address of the DMA structure with the interrupt number placed in - * dma->used_len. If we wanted to return the entire array, we need to return - * the address, array size and interrupt number: this seems to require an - * ioctl(). :*/ - -/*L:320 This routine looks for a DMA buffer registered by the Guest on the - * given key (using the BIND_DMA hypercall). */ +/* Userspace wants a dma buffer from this guest. */ unsigned long get_dma_buffer(struct lguest *lg, unsigned long ukey, unsigned long *interrupt) { @@ -573,29 +370,15 @@ unsigned long get_dma_buffer(struct lguest *lg, struct lguest_dma_info *i; struct rw_semaphore *fshared = ¤t->mm->mmap_sem; - /* Take the Big Lguest Lock to stop other Guests sending this Guest DMA - * at the same time. */ mutex_lock(&lguest_lock); - /* To match between Guests sharing the same underlying memory we steal - * code from the futex infrastructure. This requires that we hold the - * "mmap_sem" for our process (the Launcher), and pass it to the futex - * code. */ down_read(fshared); - - /* This can fail if it's not a valid address, or if the address is not - * divisible by 4 (the futex code needs that, we don't really). */ if (get_futex_key((u32 __user *)ukey, fshared, &key) != 0) { kill_guest(lg, "bad registered DMA buffer"); goto unlock; } - /* Search the hash table for matching entries (the Launcher can only - * send to its own Guest for the moment, so the entry must be for this - * Guest) */ list_for_each_entry(i, &dma_hash[hash(&key)], list) { if (key_eq(&key, &i->key) && i->guestid == lg->guestid) { unsigned int j; - /* Look through the registered DMA array for an - * available buffer. */ for (j = 0; j < i->num_dmas; j++) { struct lguest_dma dma; @@ -604,8 +387,6 @@ unsigned long get_dma_buffer(struct lguest *lg, if (dma.used_len == 0) break; } - /* Store the interrupt the Guest wants when the buffer - * is used. */ *interrupt = i->interrupt; break; } @@ -615,12 +396,4 @@ unsigned long get_dma_buffer(struct lguest *lg, mutex_unlock(&lguest_lock); return ret; } -/*:*/ -/*L:410 This really has completed the Launcher. Not only have we now finished - * the longest chapter in our journey, but this also means we are over halfway - * through! - * - * Enough prevaricating around the bush: it is time for us to dive into the - * core of the Host, in "make Host". - */ diff --git a/trunk/drivers/lguest/lg.h b/trunk/drivers/lguest/lg.h index 269116eee85f..3e2ddfbc816e 100644 --- a/trunk/drivers/lguest/lg.h +++ b/trunk/drivers/lguest/lg.h @@ -58,18 +58,9 @@ struct lguest_dma_info u8 interrupt; /* 0 when not registered */ }; -/*H:310 The page-table code owes a great debt of gratitude to Andi Kleen. He - * reviewed the original code which used "u32" for all page table entries, and - * insisted that it would be far clearer with explicit typing. I thought it - * was overkill, but he was right: it is much clearer than it was before. - * - * We have separate types for the Guest's ptes & pgds and the shadow ptes & - * pgds. There's already a Linux type for these (pte_t and pgd_t) but they - * change depending on kernel config options (PAE). */ - -/* Each entry is identical: lower 12 bits of flags and upper 20 bits for the - * "page frame number" (0 == first physical page, etc). They are different - * types so the compiler will warn us if we mix them improperly. */ +/* We have separate types for the guest's ptes & pgds and the shadow ptes & + * pgds. Since this host might use three-level pagetables and the guest and + * shadow pagetables don't, we can't use the normal pte_t/pgd_t. */ typedef union { struct { unsigned flags:12, pfn:20; }; struct { unsigned long val; } raw; @@ -86,12 +77,8 @@ typedef union { struct { unsigned flags:12, pfn:20; }; struct { unsigned long val; } raw; } gpte_t; - -/* We have two convenient macros to convert a "raw" value as handed to us by - * the Guest into the correct Guest PGD or PTE type. */ #define mkgpte(_val) ((gpte_t){.raw.val = _val}) #define mkgpgd(_val) ((gpgd_t){.raw.val = _val}) -/*:*/ struct pgdir { @@ -257,30 +244,6 @@ unsigned long get_dma_buffer(struct lguest *lg, unsigned long key, /* hypercalls.c: */ void do_hypercalls(struct lguest *lg); -/*L:035 - * Let's step aside for the moment, to study one important routine that's used - * widely in the Host code. - * - * There are many cases where the Guest does something invalid, like pass crap - * to a hypercall. Since only the Guest kernel can make hypercalls, it's quite - * acceptable to simply terminate the Guest and give the Launcher a nicely - * formatted reason. It's also simpler for the Guest itself, which doesn't - * need to check most hypercalls for "success"; if you're still running, it - * succeeded. - * - * Once this is called, the Guest will never run again, so most Host code can - * call this then continue as if nothing had happened. This means many - * functions don't have to explicitly return an error code, which keeps the - * code simple. - * - * It also means that this can be called more than once: only the first one is - * remembered. The only trick is that we still need to kill the Guest even if - * we can't allocate memory to store the reason. Linux has a neat way of - * packing error codes into invalid pointers, so we use that here. - * - * Like any macro which uses an "if", it is safely wrapped in a run-once "do { - * } while(0)". - */ #define kill_guest(lg, fmt...) \ do { \ if (!(lg)->dead) { \ @@ -289,7 +252,6 @@ do { \ (lg)->dead = ERR_PTR(-ENOMEM); \ } \ } while(0) -/* (End of aside) :*/ static inline unsigned long guest_pa(struct lguest *lg, unsigned long vaddr) { diff --git a/trunk/drivers/lguest/lguest.c b/trunk/drivers/lguest/lguest.c index 6dfe568523a2..18dade06d4a9 100644 --- a/trunk/drivers/lguest/lguest.c +++ b/trunk/drivers/lguest/lguest.c @@ -1,32 +1,6 @@ -/*P:010 - * A hypervisor allows multiple Operating Systems to run on a single machine. - * To quote David Wheeler: "Any problem in computer science can be solved with - * another layer of indirection." - * - * We keep things simple in two ways. First, we start with a normal Linux - * kernel and insert a module (lg.ko) which allows us to run other Linux - * kernels the same way we'd run processes. We call the first kernel the Host, - * and the others the Guests. The program which sets up and configures Guests - * (such as the example in Documentation/lguest/lguest.c) is called the - * Launcher. - * - * Secondly, we only run specially modified Guests, not normal kernels. When - * you set CONFIG_LGUEST to 'y' or 'm', this automatically sets - * CONFIG_LGUEST_GUEST=y, which compiles this file into the kernel so it knows - * how to be a Guest. This means that you can use the same kernel you boot - * normally (ie. as a Host) as a Guest. - * - * These Guests know that they cannot do privileged operations, such as disable - * interrupts, and that they have to ask the Host to do such things explicitly. - * This file consists of all the replacements for such low-level native - * hardware operations: these special Guest versions call the Host. - * - * So how does the kernel know it's a Guest? The Guest starts at a special - * entry point marked with a magic string, which sets up a few things then - * calls here. We replace the native functions in "struct paravirt_ops" - * with our Guest versions, then boot like normal. :*/ - /* + * Lguest specific paravirt-ops implementation + * * Copyright (C) 2006, Rusty Russell IBM Corporation. * * This program is free software; you can redistribute it and/or modify @@ -66,12 +40,6 @@ #include #include -/*G:010 Welcome to the Guest! - * - * The Guest in our tale is a simple creature: identical to the Host but - * behaving in simplified but equivalent ways. In particular, the Guest is the - * same kernel as the Host (or at least, built from the same source code). :*/ - /* Declarations for definitions in lguest_guest.S */ extern char lguest_noirq_start[], lguest_noirq_end[]; extern const char lgstart_cli[], lgend_cli[]; @@ -90,26 +58,7 @@ struct lguest_data lguest_data = { struct lguest_device_desc *lguest_devices; static cycle_t clock_base; -/*G:035 Notice the lazy_hcall() above, rather than hcall(). This is our first - * real optimization trick! - * - * When lazy_mode is set, it means we're allowed to defer all hypercalls and do - * them as a batch when lazy_mode is eventually turned off. Because hypercalls - * are reasonably expensive, batching them up makes sense. For example, a - * large mmap might update dozens of page table entries: that code calls - * lguest_lazy_mode(PARAVIRT_LAZY_MMU), does the dozen updates, then calls - * lguest_lazy_mode(PARAVIRT_LAZY_NONE). - * - * So, when we're in lazy mode, we call async_hypercall() to store the call for - * future processing. When lazy mode is turned off we issue a hypercall to - * flush the stored calls. - * - * There's also a hack where "mode" is set to "PARAVIRT_LAZY_FLUSH" which - * indicates we're to flush any outstanding calls immediately. This is used - * when an interrupt handler does a kmap_atomic(): the page table changes must - * happen immediately even if we're in the middle of a batch. Usually we're - * not, though, so there's nothing to do. */ -static enum paravirt_lazy_mode lazy_mode; /* Note: not SMP-safe! */ +static enum paravirt_lazy_mode lazy_mode; static void lguest_lazy_mode(enum paravirt_lazy_mode mode) { if (mode == PARAVIRT_LAZY_FLUSH) { @@ -133,16 +82,6 @@ static void lazy_hcall(unsigned long call, async_hcall(call, arg1, arg2, arg3); } -/* async_hcall() is pretty simple: I'm quite proud of it really. We have a - * ring buffer of stored hypercalls which the Host will run though next time we - * do a normal hypercall. Each entry in the ring has 4 slots for the hypercall - * arguments, and a "hcall_status" word which is 0 if the call is ready to go, - * and 255 once the Host has finished with it. - * - * If we come around to a slot which hasn't been finished, then the table is - * full and we just make the hypercall directly. This has the nice side - * effect of causing the Host to run all the stored calls in the ring buffer - * which empties it for next time! */ void async_hcall(unsigned long call, unsigned long arg1, unsigned long arg2, unsigned long arg3) { @@ -150,9 +89,6 @@ void async_hcall(unsigned long call, static unsigned int next_call; unsigned long flags; - /* Disable interrupts if not already disabled: we don't want an - * interrupt handler making a hypercall while we're already doing - * one! */ local_irq_save(flags); if (lguest_data.hcall_status[next_call] != 0xFF) { /* Table full, so do normal hcall which will flush table. */ @@ -162,7 +98,7 @@ void async_hcall(unsigned long call, lguest_data.hcalls[next_call].edx = arg1; lguest_data.hcalls[next_call].ebx = arg2; lguest_data.hcalls[next_call].ecx = arg3; - /* Arguments must all be written before we mark it to go */ + /* Make sure host sees arguments before "valid" flag. */ wmb(); lguest_data.hcall_status[next_call] = 0; if (++next_call == LHCALL_RING_SIZE) @@ -170,14 +106,9 @@ void async_hcall(unsigned long call, } local_irq_restore(flags); } -/*:*/ -/* Wrappers for the SEND_DMA and BIND_DMA hypercalls. This is mainly because - * Jeff Garzik complained that __pa() should never appear in drivers, and this - * helps remove most of them. But also, it wraps some ugliness. */ void lguest_send_dma(unsigned long key, struct lguest_dma *dma) { - /* The hcall might not write this if something goes wrong */ dma->used_len = 0; hcall(LHCALL_SEND_DMA, key, __pa(dma), 0); } @@ -185,16 +116,11 @@ void lguest_send_dma(unsigned long key, struct lguest_dma *dma) int lguest_bind_dma(unsigned long key, struct lguest_dma *dmas, unsigned int num, u8 irq) { - /* This is the only hypercall which actually wants 5 arguments, and we - * only support 4. Fortunately the interrupt number is always less - * than 256, so we can pack it with the number of dmas in the final - * argument. */ if (!hcall(LHCALL_BIND_DMA, key, __pa(dmas), (num << 8) | irq)) return -ENOMEM; return 0; } -/* Unbinding is the same hypercall as binding, but with 0 num & irq. */ void lguest_unbind_dma(unsigned long key, struct lguest_dma *dmas) { hcall(LHCALL_BIND_DMA, key, __pa(dmas), 0); @@ -212,73 +138,35 @@ void lguest_unmap(void *addr) iounmap((__force void __iomem *)addr); } -/*G:033 - * Here are our first native-instruction replacements: four functions for - * interrupt control. - * - * The simplest way of implementing these would be to have "turn interrupts - * off" and "turn interrupts on" hypercalls. Unfortunately, this is too slow: - * these are by far the most commonly called functions of those we override. - * - * So instead we keep an "irq_enabled" field inside our "struct lguest_data", - * which the Guest can update with a single instruction. The Host knows to - * check there when it wants to deliver an interrupt. - */ - -/* save_flags() is expected to return the processor state (ie. "eflags"). The - * eflags word contains all kind of stuff, but in practice Linux only cares - * about the interrupt flag. Our "save_flags()" just returns that. */ static unsigned long save_fl(void) { return lguest_data.irq_enabled; } -/* "restore_flags" just sets the flags back to the value given. */ static void restore_fl(unsigned long flags) { + /* FIXME: Check if interrupt pending... */ lguest_data.irq_enabled = flags; } -/* Interrupts go off... */ static void irq_disable(void) { lguest_data.irq_enabled = 0; } -/* Interrupts go on... */ static void irq_enable(void) { + /* FIXME: Check if interrupt pending... */ lguest_data.irq_enabled = X86_EFLAGS_IF; } -/*:*/ -/*M:003 Note that we don't check for outstanding interrupts when we re-enable - * them (or when we unmask an interrupt). This seems to work for the moment, - * since interrupts are rare and we'll just get the interrupt on the next timer - * tick, but when we turn on CONFIG_NO_HZ, we should revisit this. One way - * would be to put the "irq_enabled" field in a page by itself, and have the - * Host write-protect it when an interrupt comes in when irqs are disabled. - * There will then be a page fault as soon as interrupts are re-enabled. :*/ - -/*G:034 - * The Interrupt Descriptor Table (IDT). - * - * The IDT tells the processor what to do when an interrupt comes in. Each - * entry in the table is a 64-bit descriptor: this holds the privilege level, - * address of the handler, and... well, who cares? The Guest just asks the - * Host to make the change anyway, because the Host controls the real IDT. - */ + static void lguest_write_idt_entry(struct desc_struct *dt, int entrynum, u32 low, u32 high) { - /* Keep the local copy up to date. */ write_dt_entry(dt, entrynum, low, high); - /* Tell Host about this new entry. */ hcall(LHCALL_LOAD_IDT_ENTRY, entrynum, low, high); } -/* Changing to a different IDT is very rare: we keep the IDT up-to-date every - * time it is written, so we can simply loop through all entries and tell the - * Host about them. */ static void lguest_load_idt(const struct Xgt_desc_struct *desc) { unsigned int i; @@ -288,29 +176,12 @@ static void lguest_load_idt(const struct Xgt_desc_struct *desc) hcall(LHCALL_LOAD_IDT_ENTRY, i, idt[i].a, idt[i].b); } -/* - * The Global Descriptor Table. - * - * The Intel architecture defines another table, called the Global Descriptor - * Table (GDT). You tell the CPU where it is (and its size) using the "lgdt" - * instruction, and then several other instructions refer to entries in the - * table. There are three entries which the Switcher needs, so the Host simply - * controls the entire thing and the Guest asks it to make changes using the - * LOAD_GDT hypercall. - * - * This is the opposite of the IDT code where we have a LOAD_IDT_ENTRY - * hypercall and use that repeatedly to load a new IDT. I don't think it - * really matters, but wouldn't it be nice if they were the same? - */ static void lguest_load_gdt(const struct Xgt_desc_struct *desc) { BUG_ON((desc->size+1)/8 != GDT_ENTRIES); hcall(LHCALL_LOAD_GDT, __pa(desc->address), GDT_ENTRIES, 0); } -/* For a single GDT entry which changes, we do the lazy thing: alter our GDT, - * then tell the Host to reload the entire thing. This operation is so rare - * that this naive implementation is reasonable. */ static void lguest_write_gdt_entry(struct desc_struct *dt, int entrynum, u32 low, u32 high) { @@ -318,58 +189,19 @@ static void lguest_write_gdt_entry(struct desc_struct *dt, hcall(LHCALL_LOAD_GDT, __pa(dt), GDT_ENTRIES, 0); } -/* OK, I lied. There are three "thread local storage" GDT entries which change - * on every context switch (these three entries are how glibc implements - * __thread variables). So we have a hypercall specifically for this case. */ static void lguest_load_tls(struct thread_struct *t, unsigned int cpu) { lazy_hcall(LHCALL_LOAD_TLS, __pa(&t->tls_array), cpu, 0); } -/*:*/ -/*G:038 That's enough excitement for now, back to ploughing through each of - * the paravirt_ops (we're about 1/3 of the way through). - * - * This is the Local Descriptor Table, another weird Intel thingy. Linux only - * uses this for some strange applications like Wine. We don't do anything - * here, so they'll get an informative and friendly Segmentation Fault. */ static void lguest_set_ldt(const void *addr, unsigned entries) { } -/* This loads a GDT entry into the "Task Register": that entry points to a - * structure called the Task State Segment. Some comments scattered though the - * kernel code indicate that this used for task switching in ages past, along - * with blood sacrifice and astrology. - * - * Now there's nothing interesting in here that we don't get told elsewhere. - * But the native version uses the "ltr" instruction, which makes the Host - * complain to the Guest about a Segmentation Fault and it'll oops. So we - * override the native version with a do-nothing version. */ static void lguest_load_tr_desc(void) { } -/* The "cpuid" instruction is a way of querying both the CPU identity - * (manufacturer, model, etc) and its features. It was introduced before the - * Pentium in 1993 and keeps getting extended by both Intel and AMD. As you - * might imagine, after a decade and a half this treatment, it is now a giant - * ball of hair. Its entry in the current Intel manual runs to 28 pages. - * - * This instruction even it has its own Wikipedia entry. The Wikipedia entry - * has been translated into 4 languages. I am not making this up! - * - * We could get funky here and identify ourselves as "GenuineLguest", but - * instead we just use the real "cpuid" instruction. Then I pretty much turned - * off feature bits until the Guest booted. (Don't say that: you'll damage - * lguest sales!) Shut up, inner voice! (Hey, just pointing out that this is - * hardly future proof.) Noone's listening! They don't like you anyway, - * parenthetic weirdo! - * - * Replacing the cpuid so we can turn features off is great for the kernel, but - * anyone (including userspace) can just use the raw "cpuid" instruction and - * the Host won't even notice since it isn't privileged. So we try not to get - * too worked up about it. */ static void lguest_cpuid(unsigned int *eax, unsigned int *ebx, unsigned int *ecx, unsigned int *edx) { @@ -382,43 +214,21 @@ static void lguest_cpuid(unsigned int *eax, unsigned int *ebx, *ecx &= 0x00002201; /* SSE, SSE2, FXSR, MMX, CMOV, CMPXCHG8B, FPU. */ *edx &= 0x07808101; - /* The Host can do a nice optimization if it knows that the - * kernel mappings (addresses above 0xC0000000 or whatever - * PAGE_OFFSET is set to) haven't changed. But Linux calls - * flush_tlb_user() for both user and kernel mappings unless - * the Page Global Enable (PGE) feature bit is set. */ + /* Host wants to know when we flush kernel pages: set PGE. */ *edx |= 0x00002000; break; case 0x80000000: /* Futureproof this a little: if they ask how much extended - * processor information there is, limit it to known fields. */ + * processor information, limit it to known fields. */ if (*eax > 0x80000008) *eax = 0x80000008; break; } } -/* Intel has four control registers, imaginatively named cr0, cr2, cr3 and cr4. - * I assume there's a cr1, but it hasn't bothered us yet, so we'll not bother - * it. The Host needs to know when the Guest wants to change them, so we have - * a whole series of functions like read_cr0() and write_cr0(). - * - * We start with CR0. CR0 allows you to turn on and off all kinds of basic - * features, but Linux only really cares about one: the horrifically-named Task - * Switched (TS) bit at bit 3 (ie. 8) - * - * What does the TS bit do? Well, it causes the CPU to trap (interrupt 7) if - * the floating point unit is used. Which allows us to restore FPU state - * lazily after a task switch, and Linux uses that gratefully, but wouldn't a - * name like "FPUTRAP bit" be a little less cryptic? - * - * We store cr0 (and cr3) locally, because the Host never changes it. The - * Guest sometimes wants to read it and we'd prefer not to bother the Host - * unnecessarily. */ static unsigned long current_cr0, current_cr3; static void lguest_write_cr0(unsigned long val) { - /* 8 == TS bit. */ lazy_hcall(LHCALL_TS, val & 8, 0, 0); current_cr0 = val; } @@ -428,25 +238,17 @@ static unsigned long lguest_read_cr0(void) return current_cr0; } -/* Intel provided a special instruction to clear the TS bit for people too cool - * to use write_cr0() to do it. This "clts" instruction is faster, because all - * the vowels have been optimized out. */ static void lguest_clts(void) { lazy_hcall(LHCALL_TS, 0, 0, 0); current_cr0 &= ~8U; } -/* CR2 is the virtual address of the last page fault, which the Guest only ever - * reads. The Host kindly writes this into our "struct lguest_data", so we - * just read it out of there. */ static unsigned long lguest_read_cr2(void) { return lguest_data.cr2; } -/* CR3 is the current toplevel pagetable page: the principle is the same as - * cr0. Keep a local copy, and tell the Host when it changes. */ static void lguest_write_cr3(unsigned long cr3) { lazy_hcall(LHCALL_NEW_PGTABLE, cr3, 0, 0); @@ -458,7 +260,7 @@ static unsigned long lguest_read_cr3(void) return current_cr3; } -/* CR4 is used to enable and disable PGE, but we don't care. */ +/* Used to enable/disable PGE, but we don't care. */ static unsigned long lguest_read_cr4(void) { return 0; @@ -468,59 +270,6 @@ static void lguest_write_cr4(unsigned long val) { } -/* - * Page Table Handling. - * - * Now would be a good time to take a rest and grab a coffee or similarly - * relaxing stimulant. The easy parts are behind us, and the trek gradually - * winds uphill from here. - * - * Quick refresher: memory is divided into "pages" of 4096 bytes each. The CPU - * maps virtual addresses to physical addresses using "page tables". We could - * use one huge index of 1 million entries: each address is 4 bytes, so that's - * 1024 pages just to hold the page tables. But since most virtual addresses - * are unused, we use a two level index which saves space. The CR3 register - * contains the physical address of the top level "page directory" page, which - * contains physical addresses of up to 1024 second-level pages. Each of these - * second level pages contains up to 1024 physical addresses of actual pages, - * or Page Table Entries (PTEs). - * - * Here's a diagram, where arrows indicate physical addresses: - * - * CR3 ---> +---------+ - * | --------->+---------+ - * | | | PADDR1 | - * Top-level | | PADDR2 | - * (PMD) page | | | - * | | Lower-level | - * | | (PTE) page | - * | | | | - * .... .... - * - * So to convert a virtual address to a physical address, we look up the top - * level, which points us to the second level, which gives us the physical - * address of that page. If the top level entry was not present, or the second - * level entry was not present, then the virtual address is invalid (we - * say "the page was not mapped"). - * - * Put another way, a 32-bit virtual address is divided up like so: - * - * 1 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 - * |<---- 10 bits ---->|<---- 10 bits ---->|<------ 12 bits ------>| - * Index into top Index into second Offset within page - * page directory page pagetable page - * - * The kernel spends a lot of time changing both the top-level page directory - * and lower-level pagetable pages. The Guest doesn't know physical addresses, - * so while it maintains these page tables exactly like normal, it also needs - * to keep the Host informed whenever it makes a change: the Host will create - * the real page tables based on the Guests'. - */ - -/* The Guest calls this to set a second-level entry (pte), ie. to map a page - * into a process' address space. We set the entry then tell the Host the - * toplevel and address this corresponds to. The Guest uses one pagetable per - * process, so we need to tell the Host which one we're changing (mm->pgd). */ static void lguest_set_pte_at(struct mm_struct *mm, unsigned long addr, pte_t *ptep, pte_t pteval) { @@ -528,9 +277,7 @@ static void lguest_set_pte_at(struct mm_struct *mm, unsigned long addr, lazy_hcall(LHCALL_SET_PTE, __pa(mm->pgd), addr, pteval.pte_low); } -/* The Guest calls this to set a top-level entry. Again, we set the entry then - * tell the Host which top-level page we changed, and the index of the entry we - * changed. */ +/* We only support two-level pagetables at the moment. */ static void lguest_set_pmd(pmd_t *pmdp, pmd_t pmdval) { *pmdp = pmdval; @@ -538,15 +285,7 @@ static void lguest_set_pmd(pmd_t *pmdp, pmd_t pmdval) (__pa(pmdp)&(PAGE_SIZE-1))/4, 0); } -/* There are a couple of legacy places where the kernel sets a PTE, but we - * don't know the top level any more. This is useless for us, since we don't - * know which pagetable is changing or what address, so we just tell the Host - * to forget all of them. Fortunately, this is very rare. - * - * ... except in early boot when the kernel sets up the initial pagetables, - * which makes booting astonishingly slow. So we don't even tell the Host - * anything changed until we've done the first page table switch. - */ +/* FIXME: Eliminate all callers of this. */ static void lguest_set_pte(pte_t *ptep, pte_t pteval) { *ptep = pteval; @@ -555,51 +294,22 @@ static void lguest_set_pte(pte_t *ptep, pte_t pteval) lazy_hcall(LHCALL_FLUSH_TLB, 1, 0, 0); } -/* Unfortunately for Lguest, the paravirt_ops for page tables were based on - * native page table operations. On native hardware you can set a new page - * table entry whenever you want, but if you want to remove one you have to do - * a TLB flush (a TLB is a little cache of page table entries kept by the CPU). - * - * So the lguest_set_pte_at() and lguest_set_pmd() functions above are only - * called when a valid entry is written, not when it's removed (ie. marked not - * present). Instead, this is where we come when the Guest wants to remove a - * page table entry: we tell the Host to set that entry to 0 (ie. the present - * bit is zero). */ static void lguest_flush_tlb_single(unsigned long addr) { - /* Simply set it to zero: if it was not, it will fault back in. */ + /* Simply set it to zero, and it will fault back in. */ lazy_hcall(LHCALL_SET_PTE, current_cr3, addr, 0); } -/* This is what happens after the Guest has removed a large number of entries. - * This tells the Host that any of the page table entries for userspace might - * have changed, ie. virtual addresses below PAGE_OFFSET. */ static void lguest_flush_tlb_user(void) { lazy_hcall(LHCALL_FLUSH_TLB, 0, 0, 0); } -/* This is called when the kernel page tables have changed. That's not very - * common (unless the Guest is using highmem, which makes the Guest extremely - * slow), so it's worth separating this from the user flushing above. */ static void lguest_flush_tlb_kernel(void) { lazy_hcall(LHCALL_FLUSH_TLB, 1, 0, 0); } -/* - * The Unadvanced Programmable Interrupt Controller. - * - * This is an attempt to implement the simplest possible interrupt controller. - * I spent some time looking though routines like set_irq_chip_and_handler, - * set_irq_chip_and_handler_name, set_irq_chip_data and set_phasers_to_stun and - * I *think* this is as simple as it gets. - * - * We can tell the Host what interrupts we want blocked ready for using the - * lguest_data.interrupts bitmap, so disabling (aka "masking") them is as - * simple as setting a bit. We don't actually "ack" interrupts as such, we - * just mask and unmask them. I wonder if we should be cleverer? - */ static void disable_lguest_irq(unsigned int irq) { set_bit(irq, lguest_data.blocked_interrupts); @@ -608,9 +318,9 @@ static void disable_lguest_irq(unsigned int irq) static void enable_lguest_irq(unsigned int irq) { clear_bit(irq, lguest_data.blocked_interrupts); + /* FIXME: If it's pending? */ } -/* This structure describes the lguest IRQ controller. */ static struct irq_chip lguest_irq_controller = { .name = "lguest", .mask = disable_lguest_irq, @@ -618,10 +328,6 @@ static struct irq_chip lguest_irq_controller = { .unmask = enable_lguest_irq, }; -/* This sets up the Interrupt Descriptor Table (IDT) entry for each hardware - * interrupt (except 128, which is used for system calls), and then tells the - * Linux infrastructure that each interrupt is controlled by our level-based - * lguest interrupt controller. */ static void __init lguest_init_IRQ(void) { unsigned int i; @@ -634,24 +340,14 @@ static void __init lguest_init_IRQ(void) handle_level_irq); } } - /* This call is required to set up for 4k stacks, where we have - * separate stacks for hard and soft interrupts. */ irq_ctx_init(smp_processor_id()); } -/* - * Time. - * - * It would be far better for everyone if the Guest had its own clock, but - * until then it must ask the Host for the time. - */ static unsigned long lguest_get_wallclock(void) { return hcall(LHCALL_GET_WALLCLOCK, 0, 0, 0); } -/* If the Host tells us we can trust the TSC, we use that, otherwise we simply - * use the imprecise but reliable "jiffies" counter. */ static cycle_t lguest_clock_read(void) { if (lguest_data.tsc_khz) @@ -732,19 +428,12 @@ static void lguest_time_irq(unsigned int irq, struct irq_desc *desc) local_irq_restore(flags); } -/* At some point in the boot process, we get asked to set up our timing - * infrastructure. The kernel doesn't expect timer interrupts before this, but - * we cleverly initialized the "blocked_interrupts" field of "struct - * lguest_data" so that timer interrupts were blocked until now. */ static void lguest_time_init(void) { - /* Set up the timer interrupt (0) to go to our simple timer routine */ set_irq_handler(0, lguest_time_irq); - /* Our clock structure look like arch/i386/kernel/tsc.c if we can use - * the TSC, otherwise it looks like kernel/time/jiffies.c. Either way, - * the "rating" is initialized so high that it's always chosen over any - * other clocksource. */ + /* We use the TSC if the Host tells us we can, otherwise a dumb + * jiffies-based clock. */ if (lguest_data.tsc_khz) { lguest_clock.shift = 22; lguest_clock.mult = clocksource_khz2mult(lguest_data.tsc_khz, @@ -760,30 +449,13 @@ static void lguest_time_init(void) clock_base = lguest_clock_read(); clocksource_register(&lguest_clock); - /* We can't set cpumask in the initializer: damn C limitations! Set it - * here and register our timer device. */ + /* We can't set cpumask in the initializer: damn C limitations! */ lguest_clockevent.cpumask = cpumask_of_cpu(0); clockevents_register_device(&lguest_clockevent); - /* Finally, we unblock the timer interrupt. */ enable_lguest_irq(0); } -/* - * Miscellaneous bits and pieces. - * - * Here is an oddball collection of functions which the Guest needs for things - * to work. They're pretty simple. - */ - -/* The Guest needs to tell the host what stack it expects traps to use. For - * native hardware, this is part of the Task State Segment mentioned above in - * lguest_load_tr_desc(), but to help hypervisors there's this special call. - * - * We tell the Host the segment we want to use (__KERNEL_DS is the kernel data - * segment), the privilege level (we're privilege level 1, the Host is 0 and - * will not tolerate us trying to use that), the stack pointer, and the number - * of pages in the stack. */ static void lguest_load_esp0(struct tss_struct *tss, struct thread_struct *thread) { @@ -791,31 +463,15 @@ static void lguest_load_esp0(struct tss_struct *tss, THREAD_SIZE/PAGE_SIZE); } -/* Let's just say, I wouldn't do debugging under a Guest. */ static void lguest_set_debugreg(int regno, unsigned long value) { /* FIXME: Implement */ } -/* There are times when the kernel wants to make sure that no memory writes are - * caught in the cache (that they've all reached real hardware devices). This - * doesn't matter for the Guest which has virtual hardware. - * - * On the Pentium 4 and above, cpuid() indicates that the Cache Line Flush - * (clflush) instruction is available and the kernel uses that. Otherwise, it - * uses the older "Write Back and Invalidate Cache" (wbinvd) instruction. - * Unlike clflush, wbinvd can only be run at privilege level 0. So we can - * ignore clflush, but replace wbinvd. - */ static void lguest_wbinvd(void) { } -/* If the Guest expects to have an Advanced Programmable Interrupt Controller, - * we play dumb by ignoring writes and returning 0 for reads. So it's no - * longer Programmable nor Controlling anything, and I don't think 8 lines of - * code qualifies for Advanced. It will also never interrupt anything. It - * does, however, allow us to get through the Linux boot code. */ #ifdef CONFIG_X86_LOCAL_APIC static void lguest_apic_write(unsigned long reg, unsigned long v) { @@ -827,32 +483,19 @@ static unsigned long lguest_apic_read(unsigned long reg) } #endif -/* STOP! Until an interrupt comes in. */ static void lguest_safe_halt(void) { hcall(LHCALL_HALT, 0, 0, 0); } -/* Perhaps CRASH isn't the best name for this hypercall, but we use it to get a - * message out when we're crashing as well as elegant termination like powering - * off. - * - * Note that the Host always prefers that the Guest speak in physical addresses - * rather than virtual addresses, so we use __pa() here. */ static void lguest_power_off(void) { hcall(LHCALL_CRASH, __pa("Power down"), 0, 0); } -/* - * Panicing. - * - * Don't. But if you did, this is what happens. - */ static int lguest_panic(struct notifier_block *nb, unsigned long l, void *p) { hcall(LHCALL_CRASH, __pa(p), 0, 0); - /* The hcall won't return, but to keep gcc happy, we're "done". */ return NOTIFY_DONE; } @@ -860,45 +503,15 @@ static struct notifier_block paniced = { .notifier_call = lguest_panic }; -/* Setting up memory is fairly easy. */ static __init char *lguest_memory_setup(void) { - /* We do this here and not earlier because lockcheck barfs if we do it - * before start_kernel() */ + /* We do this here because lockcheck barfs if before start_kernel */ atomic_notifier_chain_register(&panic_notifier_list, &paniced); - /* The Linux bootloader header contains an "e820" memory map: the - * Launcher populated the first entry with our memory limit. */ add_memory_region(E820_MAP->addr, E820_MAP->size, E820_MAP->type); - - /* This string is for the boot messages. */ return "LGUEST"; } -/*G:050 - * Patching (Powerfully Placating Performance Pedants) - * - * We have already seen that "struct paravirt_ops" lets us replace simple - * native instructions with calls to the appropriate back end all throughout - * the kernel. This allows the same kernel to run as a Guest and as a native - * kernel, but it's slow because of all the indirect branches. - * - * Remember that David Wheeler quote about "Any problem in computer science can - * be solved with another layer of indirection"? The rest of that quote is - * "... But that usually will create another problem." This is the first of - * those problems. - * - * Our current solution is to allow the paravirt back end to optionally patch - * over the indirect calls to replace them with something more efficient. We - * patch the four most commonly called functions: disable interrupts, enable - * interrupts, restore interrupts and save interrupts. We usually have 10 - * bytes to patch into: the Guest versions of these operations are small enough - * that we can fit comfortably. - * - * First we need assembly templates of each of the patchable Guest operations, - * and these are in lguest_asm.S. */ - -/*G:060 We construct a table from the assembler templates: */ static const struct lguest_insns { const char *start, *end; @@ -908,52 +521,35 @@ static const struct lguest_insns [PARAVIRT_PATCH(restore_fl)] = { lgstart_popf, lgend_popf }, [PARAVIRT_PATCH(save_fl)] = { lgstart_pushf, lgend_pushf }, }; - -/* Now our patch routine is fairly simple (based on the native one in - * paravirt.c). If we have a replacement, we copy it in and return how much of - * the available space we used. */ static unsigned lguest_patch(u8 type, u16 clobber, void *insns, unsigned len) { unsigned int insn_len; - /* Don't do anything special if we don't have a replacement */ + /* Don't touch it if we don't have a replacement */ if (type >= ARRAY_SIZE(lguest_insns) || !lguest_insns[type].start) return paravirt_patch_default(type, clobber, insns, len); insn_len = lguest_insns[type].end - lguest_insns[type].start; - /* Similarly if we can't fit replacement (shouldn't happen, but let's - * be thorough). */ + /* Similarly if we can't fit replacement. */ if (len < insn_len) return paravirt_patch_default(type, clobber, insns, len); - /* Copy in our instructions. */ memcpy(insns, lguest_insns[type].start, insn_len); return insn_len; } -/*G:030 Once we get to lguest_init(), we know we're a Guest. The paravirt_ops - * structure in the kernel provides a single point for (almost) every routine - * we have to override to avoid privileged instructions. */ __init void lguest_init(void *boot) { - /* Copy boot parameters first: the Launcher put the physical location - * in %esi, and head.S converted that to a virtual address and handed - * it to us. */ + /* Copy boot parameters first. */ memcpy(&boot_params, boot, PARAM_SIZE); - /* The boot parameters also tell us where the command-line is: save - * that, too. */ memcpy(boot_command_line, __va(boot_params.hdr.cmd_line_ptr), COMMAND_LINE_SIZE); - /* We're under lguest, paravirt is enabled, and we're running at - * privilege level 1, not 0 as normal. */ paravirt_ops.name = "lguest"; paravirt_ops.paravirt_enabled = 1; paravirt_ops.kernel_rpl = 1; - /* We set up all the lguest overrides for sensitive operations. These - * are detailed with the operations themselves. */ paravirt_ops.save_fl = save_fl; paravirt_ops.restore_fl = restore_fl; paravirt_ops.irq_disable = irq_disable; @@ -997,45 +593,20 @@ __init void lguest_init(void *boot) paravirt_ops.set_lazy_mode = lguest_lazy_mode; paravirt_ops.wbinvd = lguest_wbinvd; paravirt_ops.sched_clock = lguest_sched_clock; - /* Now is a good time to look at the implementations of these functions - * before returning to the rest of lguest_init(). */ - - /*G:070 Now we've seen all the paravirt_ops, we return to - * lguest_init() where the rest of the fairly chaotic boot setup - * occurs. - * - * The Host expects our first hypercall to tell it where our "struct - * lguest_data" is, so we do that first. */ + hcall(LHCALL_LGUEST_INIT, __pa(&lguest_data), 0, 0); - /* The native boot code sets up initial page tables immediately after - * the kernel itself, and sets init_pg_tables_end so they're not - * clobbered. The Launcher places our initial pagetables somewhere at - * the top of our physical memory, so we don't need extra space: set - * init_pg_tables_end to the end of the kernel. */ + /* We use top of mem for initial pagetables. */ init_pg_tables_end = __pa(pg0); - /* Load the %fs segment register (the per-cpu segment register) with - * the normal data segment to get through booting. */ asm volatile ("mov %0, %%fs" : : "r" (__KERNEL_DS) : "memory"); - /* The Host uses the top of the Guest's virtual address space for the - * Host<->Guest Switcher, and it tells us how much it needs in - * lguest_data.reserve_mem, set up on the LGUEST_INIT hypercall. */ reserve_top_address(lguest_data.reserve_mem); - /* If we don't initialize the lock dependency checker now, it crashes - * paravirt_disable_iospace. */ lockdep_init(); - /* The IDE code spends about 3 seconds probing for disks: if we reserve - * all the I/O ports up front it can't get them and so doesn't probe. - * Other device drivers are similar (but less severe). This cuts the - * kernel boot time on my machine from 4.1 seconds to 0.45 seconds. */ paravirt_disable_iospace(); - /* This is messy CPU setup stuff which the native boot code does before - * start_kernel, so we have to do, too: */ cpu_detect(&new_cpu_data); /* head.S usually sets up the first capability word, so do it here. */ new_cpu_data.x86_capability[0] = cpuid_edx(1); @@ -1046,27 +617,14 @@ __init void lguest_init(void *boot) #ifdef CONFIG_X86_MCE mce_disabled = 1; #endif + #ifdef CONFIG_ACPI acpi_disabled = 1; acpi_ht = 0; #endif - /* We set the perferred console to "hvc". This is the "hypervisor - * virtual console" driver written by the PowerPC people, which we also - * adapted for lguest's use. */ add_preferred_console("hvc", 0, NULL); - /* Last of all, we set the power management poweroff hook to point to - * the Guest routine to power off. */ pm_power_off = lguest_power_off; - - /* Now we're set up, call start_kernel() in init/main.c and we proceed - * to boot as normal. It never returns. */ start_kernel(); } -/* - * This marks the end of stage II of our journey, The Guest. - * - * It is now time for us to explore the nooks and crannies of the three Guest - * devices and complete our understanding of the Guest in "make Drivers". - */ diff --git a/trunk/drivers/lguest/lguest_asm.S b/trunk/drivers/lguest/lguest_asm.S index f182c6a36209..a3dbf22ee365 100644 --- a/trunk/drivers/lguest/lguest_asm.S +++ b/trunk/drivers/lguest/lguest_asm.S @@ -4,15 +4,15 @@ #include #include -/*G:020 This is where we begin: we have a magic signature which the launcher - * looks for. The plan is that the Linux boot protocol will be extended with a +/* + * This is where we begin: we have a magic signature which the launcher looks + * for. The plan is that the Linux boot protocol will be extended with a * "platform type" field which will guide us here from the normal entry point, - * but for the moment this suffices. The normal boot code uses %esi for the - * boot header, so we do too. We convert it to a virtual address by adding - * PAGE_OFFSET, and hand it to lguest_init() as its argument (ie. %eax). + * but for the moment this suffices. We pass the virtual address of the boot + * info to lguest_init(). * - * The .section line puts this code in .init.text so it will be discarded after - * boot. */ + * We put it in .init.text will be discarded after boot. + */ .section .init.text, "ax", @progbits .ascii "GenuineLguest" /* Set up initial stack. */ @@ -21,9 +21,7 @@ addl $__PAGE_OFFSET, %eax jmp lguest_init -/*G:055 We create a macro which puts the assembler code between lgstart_ and - * lgend_ markers. These templates end up in the .init.text section, so they - * are discarded after boot. */ +/* The templates for inline patching. */ #define LGUEST_PATCH(name, insns...) \ lgstart_##name: insns; lgend_##name:; \ .globl lgstart_##name; .globl lgend_##name @@ -32,61 +30,24 @@ LGUEST_PATCH(cli, movl $0, lguest_data+LGUEST_DATA_irq_enabled) LGUEST_PATCH(sti, movl $X86_EFLAGS_IF, lguest_data+LGUEST_DATA_irq_enabled) LGUEST_PATCH(popf, movl %eax, lguest_data+LGUEST_DATA_irq_enabled) LGUEST_PATCH(pushf, movl lguest_data+LGUEST_DATA_irq_enabled, %eax) -/*:*/ .text /* These demark the EIP range where host should never deliver interrupts. */ .global lguest_noirq_start .global lguest_noirq_end -/*M:004 When the Host reflects a trap or injects an interrupt into the Guest, - * it sets the eflags interrupt bit on the stack based on - * lguest_data.irq_enabled, so the Guest iret logic does the right thing when - * restoring it. However, when the Host sets the Guest up for direct traps, - * such as system calls, the processor is the one to push eflags onto the - * stack, and the interrupt bit will be 1 (in reality, interrupts are always - * enabled in the Guest). - * - * This turns out to be harmless: the only trap which should happen under Linux - * with interrupts disabled is Page Fault (due to our lazy mapping of vmalloc - * regions), which has to be reflected through the Host anyway. If another - * trap *does* go off when interrupts are disabled, the Guest will panic, and - * we'll never get to this iret! :*/ - -/*G:045 There is one final paravirt_op that the Guest implements, and glancing - * at it you can see why I left it to last. It's *cool*! It's in *assembler*! - * - * The "iret" instruction is used to return from an interrupt or trap. The - * stack looks like this: - * old address - * old code segment & privilege level - * old processor flags ("eflags") - * - * The "iret" instruction pops those values off the stack and restores them all - * at once. The only problem is that eflags includes the Interrupt Flag which - * the Guest can't change: the CPU will simply ignore it when we do an "iret". - * So we have to copy eflags from the stack to lguest_data.irq_enabled before - * we do the "iret". - * - * There are two problems with this: firstly, we need to use a register to do - * the copy and secondly, the whole thing needs to be atomic. The first - * problem is easy to solve: push %eax on the stack so we can use it, and then - * restore it at the end just before the real "iret". - * - * The second is harder: copying eflags to lguest_data.irq_enabled will turn - * interrupts on before we're finished, so we could be interrupted before we - * return to userspace or wherever. Our solution to this is to surround the - * code with lguest_noirq_start: and lguest_noirq_end: labels. We tell the - * Host that it is *never* to interrupt us there, even if interrupts seem to be - * enabled. */ +/* + * We move eflags word to lguest_data.irq_enabled to restore interrupt state. + * For page faults, gpfs and virtual interrupts, the hypervisor has saved + * eflags manually, otherwise it was delivered directly and so eflags reflects + * the real machine IF state, ie. interrupts on. Since the kernel always dies + * if it takes such a trap with interrupts disabled anyway, turning interrupts + * back on unconditionally here is OK. + */ ENTRY(lguest_iret) pushl %eax movl 12(%esp), %eax lguest_noirq_start: - /* Note the %ss: segment prefix here. Normal data accesses use the - * "ds" segment, but that will have already been restored for whatever - * we're returning to (such as userspace): we can't trust it. The %ss: - * prefix makes sure we use the stack segment, which is still valid. */ movl %eax,%ss:lguest_data+LGUEST_DATA_irq_enabled popl %eax iret diff --git a/trunk/drivers/lguest/lguest_bus.c b/trunk/drivers/lguest/lguest_bus.c index 55a7940ca732..18d6ab21a43b 100644 --- a/trunk/drivers/lguest/lguest_bus.c +++ b/trunk/drivers/lguest/lguest_bus.c @@ -1,6 +1,3 @@ -/*P:050 Lguest guests use a very simple bus for devices. It's a simple array - * of device descriptors contained just above the top of normal memory. The - * lguest bus is 80% tedious boilerplate code. :*/ #include #include #include @@ -46,10 +43,6 @@ static struct device_attribute lguest_dev_attrs[] = { __ATTR_NULL }; -/*D:130 The generic bus infrastructure requires a function which says whether a - * device matches a driver. For us, it is simple: "struct lguest_driver" - * contains a "device_type" field which indicates what type of device it can - * handle, so we just cast the args and compare: */ static int lguest_dev_match(struct device *_dev, struct device_driver *_drv) { struct lguest_device *dev = container_of(_dev,struct lguest_device,dev); @@ -57,7 +50,6 @@ static int lguest_dev_match(struct device *_dev, struct device_driver *_drv) return (drv->device_type == lguest_devices[dev->index].type); } -/*:*/ struct lguest_bus { struct bus_type bus; @@ -76,24 +68,11 @@ static struct lguest_bus lguest_bus = { } }; -/*D:140 This is the callback which occurs once the bus infrastructure matches - * up a device and driver, ie. in response to add_lguest_device() calling - * device_register(), or register_lguest_driver() calling driver_register(). - * - * At the moment it's always the latter: the devices are added first, since - * scan_devices() is called from a "core_initcall", and the drivers themselves - * called later as a normal "initcall". But it would work the other way too. - * - * So now we have the happy couple, we add the status bit to indicate that we - * found a driver. If the driver truly loves the device, it will return - * happiness from its probe function (ok, perhaps this wasn't my greatest - * analogy), and we set the final "driver ok" bit so the Host sees it's all - * green. */ static int lguest_dev_probe(struct device *_dev) { int ret; - struct lguest_device*dev = container_of(_dev,struct lguest_device,dev); - struct lguest_driver*drv = container_of(dev->dev.driver, + struct lguest_device *dev = container_of(_dev,struct lguest_device,dev); + struct lguest_driver *drv = container_of(dev->dev.driver, struct lguest_driver, drv); lguest_devices[dev->index].status |= LGUEST_DEVICE_S_DRIVER; @@ -103,10 +82,6 @@ static int lguest_dev_probe(struct device *_dev) return ret; } -/* The last part of the bus infrastructure is the function lguest drivers use - * to register themselves. Firstly, we do nothing if there's no lguest bus - * (ie. this is not a Guest), otherwise we fill in the embedded generic "struct - * driver" fields and call the generic driver_register(). */ int register_lguest_driver(struct lguest_driver *drv) { if (!lguest_devices) @@ -119,36 +94,12 @@ int register_lguest_driver(struct lguest_driver *drv) return driver_register(&drv->drv); } - -/* At the moment we build all the drivers into the kernel because they're so - * simple: 8144 bytes for all three of them as I type this. And as the console - * really needs to be built in, it's actually only 3527 bytes for the network - * and block drivers. - * - * If they get complex it will make sense for them to be modularized, so we - * need to explicitly export the symbol. - * - * I don't think non-GPL modules make sense, so it's a GPL-only export. - */ EXPORT_SYMBOL_GPL(register_lguest_driver); -/*D:120 This is the core of the lguest bus: actually adding a new device. - * It's a separate function because it's neater that way, and because an - * earlier version of the code supported hotplug and unplug. They were removed - * early on because they were never used. - * - * As Andrew Tridgell says, "Untested code is buggy code". - * - * It's worth reading this carefully: we start with an index into the array of - * "struct lguest_device_desc"s indicating the device which is new: */ static void add_lguest_device(unsigned int index) { struct lguest_device *new; - /* Each "struct lguest_device_desc" has a "status" field, which the - * Guest updates as the device is probed. In the worst case, the Host - * can look at these bits to tell what part of device setup failed, - * even if the console isn't available. */ lguest_devices[index].status |= LGUEST_DEVICE_S_ACKNOWLEDGE; new = kmalloc(sizeof(struct lguest_device), GFP_KERNEL); if (!new) { @@ -157,17 +108,12 @@ static void add_lguest_device(unsigned int index) return; } - /* The "struct lguest_device" setup is pretty straight-forward example - * code. */ new->index = index; new->private = NULL; memset(&new->dev, 0, sizeof(new->dev)); new->dev.parent = &lguest_bus.dev; new->dev.bus = &lguest_bus.bus; sprintf(new->dev.bus_id, "%u", index); - - /* device_register() causes the bus infrastructure to look for a - * matching driver. */ if (device_register(&new->dev) != 0) { printk(KERN_EMERG "Cannot register lguest device %u\n", index); lguest_devices[index].status |= LGUEST_DEVICE_S_FAILED; @@ -175,9 +121,6 @@ static void add_lguest_device(unsigned int index) } } -/*D:110 scan_devices() simply iterates through the device array. The type 0 - * is reserved to mean "no device", and anything else means we have found a - * device: add it. */ static void scan_devices(void) { unsigned int i; @@ -187,23 +130,12 @@ static void scan_devices(void) add_lguest_device(i); } -/*D:100 Fairly early in boot, lguest_bus_init() is called to set up the lguest - * bus. We check that we are a Guest by checking paravirt_ops.name: there are - * other ways of checking, but this seems most obvious to me. - * - * So we can access the array of "struct lguest_device_desc"s easily, we map - * that memory and store the pointer in the global "lguest_devices". Then we - * register the bus with the core. Doing two registrations seems clunky to me, - * but it seems to be the correct sysfs incantation. - * - * Finally we call scan_devices() which adds all the devices found in the - * "struct lguest_device_desc" array. */ static int __init lguest_bus_init(void) { if (strcmp(paravirt_ops.name, "lguest") != 0) return 0; - /* Devices are in a single page above top of "normal" mem */ + /* Devices are in page above top of "normal" mem. */ lguest_devices = lguest_map(max_pfn< #include #include #include "lg.h" -/*L:030 setup_regs() doesn't really belong in this file, but it gives us an - * early glimpse deeper into the Host so it's worth having here. - * - * Most of the Guest's registers are left alone: we used get_zeroed_page() to - * allocate the structure, so they will be 0. */ static void setup_regs(struct lguest_regs *regs, unsigned long start) { - /* There are four "segment" registers which the Guest needs to boot: - * The "code segment" register (cs) refers to the kernel code segment - * __KERNEL_CS, and the "data", "extra" and "stack" segment registers - * refer to the kernel data segment __KERNEL_DS. - * - * The privilege level is packed into the lower bits. The Guest runs - * at privilege level 1 (GUEST_PL).*/ + /* Write out stack in format lguest expects, so we can switch to it. */ regs->ds = regs->es = regs->ss = __KERNEL_DS|GUEST_PL; regs->cs = __KERNEL_CS|GUEST_PL; - - /* The "eflags" register contains miscellaneous flags. Bit 1 (0x002) - * is supposed to always be "1". Bit 9 (0x200) controls whether - * interrupts are enabled. We always leave interrupts enabled while - * running the Guest. */ - regs->eflags = 0x202; - - /* The "Extended Instruction Pointer" register says where the Guest is - * running. */ + regs->eflags = 0x202; /* Interrupts enabled. */ regs->eip = start; - - /* %esi points to our boot information, at physical address 0, so don't - * touch it. */ + /* esi points to our boot information (physical address 0) */ } -/*L:310 To send DMA into the Guest, the Launcher needs to be able to ask for a - * DMA buffer. This is done by writing LHREQ_GETDMA and the key to - * /dev/lguest. */ +/* + addr */ static long user_get_dma(struct lguest *lg, const u32 __user *input) { unsigned long key, udma, irq; - /* Fetch the key they wrote to us. */ if (get_user(key, input) != 0) return -EFAULT; - /* Look for a free Guest DMA buffer bound to that key. */ udma = get_dma_buffer(lg, key, &irq); if (!udma) return -ENOENT; - /* We need to tell the Launcher what interrupt the Guest expects after - * the buffer is filled. We stash it in udma->used_len. */ + /* We put irq number in udma->used_len. */ lgwrite_u32(lg, udma + offsetof(struct lguest_dma, used_len), irq); - - /* The (guest-physical) address of the DMA buffer is returned from - * the write(). */ return udma; } -/*L:315 To force the Guest to stop running and return to the Launcher, the +/* To force the Guest to stop running and return to the Launcher, the * Waker sets writes LHREQ_BREAK and the value "1" to /dev/lguest. The * Launcher then writes LHREQ_BREAK and "0" to release the Waker. */ static int break_guest_out(struct lguest *lg, const u32 __user *input) @@ -88,8 +54,7 @@ static int break_guest_out(struct lguest *lg, const u32 __user *input) } } -/*L:050 Sending an interrupt is done by writing LHREQ_IRQ and an interrupt - * number to /dev/lguest. */ +/* + irq */ static int user_send_irq(struct lguest *lg, const u32 __user *input) { u32 irq; @@ -98,19 +63,14 @@ static int user_send_irq(struct lguest *lg, const u32 __user *input) return -EFAULT; if (irq >= LGUEST_IRQS) return -EINVAL; - /* Next time the Guest runs, the core code will see if it can deliver - * this interrupt. */ set_bit(irq, lg->irqs_pending); return 0; } -/*L:040 Once our Guest is initialized, the Launcher makes it run by reading - * from /dev/lguest. */ static ssize_t read(struct file *file, char __user *user, size_t size,loff_t*o) { struct lguest *lg = file->private_data; - /* You must write LHREQ_INITIALIZE first! */ if (!lg) return -EINVAL; @@ -118,52 +78,27 @@ static ssize_t read(struct file *file, char __user *user, size_t size,loff_t*o) if (current != lg->tsk) return -EPERM; - /* If the guest is already dead, we indicate why */ if (lg->dead) { size_t len; - /* lg->dead either contains an error code, or a string. */ if (IS_ERR(lg->dead)) return PTR_ERR(lg->dead); - /* We can only return as much as the buffer they read with. */ len = min(size, strlen(lg->dead)+1); if (copy_to_user(user, lg->dead, len) != 0) return -EFAULT; return len; } - /* If we returned from read() last time because the Guest sent DMA, - * clear the flag. */ if (lg->dma_is_pending) lg->dma_is_pending = 0; - /* Run the Guest until something interesting happens. */ return run_guest(lg, (unsigned long __user *)user); } -/*L:020 The initialization write supplies 4 32-bit values (in addition to the - * 32-bit LHREQ_INITIALIZE value). These are: - * - * pfnlimit: The highest (Guest-physical) page number the Guest should be - * allowed to access. The Launcher has to live in Guest memory, so it sets - * this to ensure the Guest can't reach it. - * - * pgdir: The (Guest-physical) address of the top of the initial Guest - * pagetables (which are set up by the Launcher). - * - * start: The first instruction to execute ("eip" in x86-speak). - * - * page_offset: The PAGE_OFFSET constant in the Guest kernel. We should - * probably wean the code off this, but it's a very useful constant! Any - * address above this is within the Guest kernel, and any kernel address can - * quickly converted from physical to virtual by adding PAGE_OFFSET. It's - * 0xC0000000 (3G) by default, but it's configurable at kernel build time. - */ +/* Take: pfnlimit, pgdir, start, pageoffset. */ static int initialize(struct file *file, const u32 __user *input) { - /* "struct lguest" contains everything we (the Host) know about a - * Guest. */ struct lguest *lg; int err, i; u32 args[4]; @@ -171,7 +106,7 @@ static int initialize(struct file *file, const u32 __user *input) /* We grab the Big Lguest lock, which protects the global array * "lguests" and multiple simultaneous initializations. */ mutex_lock(&lguest_lock); - /* You can't initialize twice! Close the device and start again... */ + if (file->private_data) { err = -EBUSY; goto unlock; @@ -182,70 +117,37 @@ static int initialize(struct file *file, const u32 __user *input) goto unlock; } - /* Find an unused guest. */ i = find_free_guest(); if (i < 0) { err = -ENOSPC; goto unlock; } - /* OK, we have an index into the "lguest" array: "lg" is a convenient - * pointer. */ lg = &lguests[i]; - - /* Populate the easy fields of our "struct lguest" */ lg->guestid = i; lg->pfn_limit = args[0]; lg->page_offset = args[3]; - - /* We need a complete page for the Guest registers: they are accessible - * to the Guest and we can only grant it access to whole pages. */ lg->regs_page = get_zeroed_page(GFP_KERNEL); if (!lg->regs_page) { err = -ENOMEM; goto release_guest; } - /* We actually put the registers at the bottom of the page. */ lg->regs = (void *)lg->regs_page + PAGE_SIZE - sizeof(*lg->regs); - /* Initialize the Guest's shadow page tables, using the toplevel - * address the Launcher gave us. This allocates memory, so can - * fail. */ err = init_guest_pagetable(lg, args[1]); if (err) goto free_regs; - /* Now we initialize the Guest's registers, handing it the start - * address. */ setup_regs(lg->regs, args[2]); - - /* There are a couple of GDT entries the Guest expects when first - * booting. */ setup_guest_gdt(lg); - - /* The timer for lguest's clock needs initialization. */ init_clockdev(lg); - - /* We keep a pointer to the Launcher task (ie. current task) for when - * other Guests want to wake this one (inter-Guest I/O). */ lg->tsk = current; - /* We need to keep a pointer to the Launcher's memory map, because if - * the Launcher dies we need to clean it up. If we don't keep a - * reference, it is destroyed before close() is called. */ lg->mm = get_task_mm(lg->tsk); - - /* Initialize the queue for the waker to wait on */ init_waitqueue_head(&lg->break_wq); - - /* We remember which CPU's pages this Guest used last, for optimization - * when the same Guest runs on the same CPU twice. */ lg->last_pages = NULL; - - /* We keep our "struct lguest" in the file's private_data. */ file->private_data = lg; mutex_unlock(&lguest_lock); - /* And because this is a write() call, we return the length used. */ return sizeof(args); free_regs: @@ -257,15 +159,9 @@ static int initialize(struct file *file, const u32 __user *input) return err; } -/*L:010 The first operation the Launcher does must be a write. All writes - * start with a 32 bit number: for the first write this must be - * LHREQ_INITIALIZE to set up the Guest. After that the Launcher can use - * writes of other values to get DMA buffers and send interrupts. */ static ssize_t write(struct file *file, const char __user *input, size_t size, loff_t *off) { - /* Once the guest is initialized, we hold the "struct lguest" in the - * file private data. */ struct lguest *lg = file->private_data; u32 req; @@ -273,11 +169,8 @@ static ssize_t write(struct file *file, const char __user *input, return -EFAULT; input += sizeof(req); - /* If you haven't initialized, you must do that first. */ if (req != LHREQ_INITIALIZE && !lg) return -EINVAL; - - /* Once the Guest is dead, all you can do is read() why it died. */ if (lg && lg->dead) return -ENOENT; @@ -299,72 +192,33 @@ static ssize_t write(struct file *file, const char __user *input, } } -/*L:060 The final piece of interface code is the close() routine. It reverses - * everything done in initialize(). This is usually called because the - * Launcher exited. - * - * Note that the close routine returns 0 or a negative error number: it can't - * really fail, but it can whine. I blame Sun for this wart, and K&R C for - * letting them do it. :*/ static int close(struct inode *inode, struct file *file) { struct lguest *lg = file->private_data; - /* If we never successfully initialized, there's nothing to clean up */ if (!lg) return 0; - /* We need the big lock, to protect from inter-guest I/O and other - * Launchers initializing guests. */ mutex_lock(&lguest_lock); /* Cancels the hrtimer set via LHCALL_SET_CLOCKEVENT. */ hrtimer_cancel(&lg->hrt); - /* Free any DMA buffers the Guest had bound. */ release_all_dma(lg); - /* Free up the shadow page tables for the Guest. */ free_guest_pagetable(lg); - /* Now all the memory cleanups are done, it's safe to release the - * Launcher's memory management structure. */ mmput(lg->mm); - /* If lg->dead doesn't contain an error code it will be NULL or a - * kmalloc()ed string, either of which is ok to hand to kfree(). */ if (!IS_ERR(lg->dead)) kfree(lg->dead); - /* We can free up the register page we allocated. */ free_page(lg->regs_page); - /* We clear the entire structure, which also marks it as free for the - * next user. */ memset(lg, 0, sizeof(*lg)); - /* Release lock and exit. */ mutex_unlock(&lguest_lock); - return 0; } -/*L:000 - * Welcome to our journey through the Launcher! - * - * The Launcher is the Host userspace program which sets up, runs and services - * the Guest. In fact, many comments in the Drivers which refer to "the Host" - * doing things are inaccurate: the Launcher does all the device handling for - * the Guest. The Guest can't tell what's done by the the Launcher and what by - * the Host. - * - * Just to confuse you: to the Host kernel, the Launcher *is* the Guest and we - * shall see more of that later. - * - * We begin our understanding with the Host kernel interface which the Launcher - * uses: reading and writing a character device called /dev/lguest. All the - * work happens in the read(), write() and close() routines: */ static struct file_operations lguest_fops = { .owner = THIS_MODULE, .release = close, .write = write, .read = read, }; - -/* This is a textbook example of a "misc" character device. Populate a "struct - * miscdevice" and register it with misc_register(). */ static struct miscdevice lguest_dev = { .minor = MISC_DYNAMIC_MINOR, .name = "lguest", diff --git a/trunk/drivers/lguest/page_tables.c b/trunk/drivers/lguest/page_tables.c index b7a924ace684..1b0ba09b1269 100644 --- a/trunk/drivers/lguest/page_tables.c +++ b/trunk/drivers/lguest/page_tables.c @@ -1,11 +1,5 @@ -/*P:700 The pagetable code, on the other hand, still shows the scars of - * previous encounters. It's functional, and as neat as it can be in the - * circumstances, but be wary, for these things are subtle and break easily. - * The Guest provides a virtual to physical mapping, but we can neither trust - * it nor use it: we verify and convert it here to point the hardware to the - * actual Guest pages when running the Guest. :*/ - -/* Copyright (C) Rusty Russell IBM Corporation 2006. +/* Shadow page table operations. + * Copyright (C) Rusty Russell IBM Corporation 2006. * GPL v2 and any later version */ #include #include @@ -15,96 +9,38 @@ #include #include "lg.h" -/*M:008 We hold reference to pages, which prevents them from being swapped. - * It'd be nice to have a callback in the "struct mm_struct" when Linux wants - * to swap out. If we had this, and a shrinker callback to trim PTE pages, we - * could probably consider launching Guests as non-root. :*/ - -/*H:300 - * The Page Table Code - * - * We use two-level page tables for the Guest. If you're not entirely - * comfortable with virtual addresses, physical addresses and page tables then - * I recommend you review lguest.c's "Page Table Handling" (with diagrams!). - * - * The Guest keeps page tables, but we maintain the actual ones here: these are - * called "shadow" page tables. Which is a very Guest-centric name: these are - * the real page tables the CPU uses, although we keep them up to date to - * reflect the Guest's. (See what I mean about weird naming? Since when do - * shadows reflect anything?) - * - * Anyway, this is the most complicated part of the Host code. There are seven - * parts to this: - * (i) Setting up a page table entry for the Guest when it faults, - * (ii) Setting up the page table entry for the Guest stack, - * (iii) Setting up a page table entry when the Guest tells us it has changed, - * (iv) Switching page tables, - * (v) Flushing (thowing away) page tables, - * (vi) Mapping the Switcher when the Guest is about to run, - * (vii) Setting up the page tables initially. - :*/ - -/* Pages a 4k long, and each page table entry is 4 bytes long, giving us 1024 - * (or 2^10) entries per page. */ #define PTES_PER_PAGE_SHIFT 10 #define PTES_PER_PAGE (1 << PTES_PER_PAGE_SHIFT) - -/* 1024 entries in a page table page maps 1024 pages: 4MB. The Switcher is - * conveniently placed at the top 4MB, so it uses a separate, complete PTE - * page. */ #define SWITCHER_PGD_INDEX (PTES_PER_PAGE - 1) -/* We actually need a separate PTE page for each CPU. Remember that after the - * Switcher code itself comes two pages for each CPU, and we don't want this - * CPU's guest to see the pages of any other CPU. */ static DEFINE_PER_CPU(spte_t *, switcher_pte_pages); #define switcher_pte_page(cpu) per_cpu(switcher_pte_pages, cpu) -/*H:320 With our shadow and Guest types established, we need to deal with - * them: the page table code is curly enough to need helper functions to keep - * it clear and clean. - * - * The first helper takes a virtual address, and says which entry in the top - * level page table deals with that address. Since each top level entry deals - * with 4M, this effectively divides by 4M. */ static unsigned vaddr_to_pgd_index(unsigned long vaddr) { return vaddr >> (PAGE_SHIFT + PTES_PER_PAGE_SHIFT); } -/* There are two functions which return pointers to the shadow (aka "real") - * page tables. - * - * spgd_addr() takes the virtual address and returns a pointer to the top-level - * page directory entry for that address. Since we keep track of several page - * tables, the "i" argument tells us which one we're interested in (it's - * usually the current one). */ +/* These access the shadow versions (ie. the ones used by the CPU). */ static spgd_t *spgd_addr(struct lguest *lg, u32 i, unsigned long vaddr) { unsigned int index = vaddr_to_pgd_index(vaddr); - /* We kill any Guest trying to touch the Switcher addresses. */ if (index >= SWITCHER_PGD_INDEX) { kill_guest(lg, "attempt to access switcher pages"); index = 0; } - /* Return a pointer index'th pgd entry for the i'th page table. */ return &lg->pgdirs[i].pgdir[index]; } -/* This routine then takes the PGD entry given above, which contains the - * address of the PTE page. It then returns a pointer to the PTE entry for the - * given address. */ static spte_t *spte_addr(struct lguest *lg, spgd_t spgd, unsigned long vaddr) { spte_t *page = __va(spgd.pfn << PAGE_SHIFT); - /* You should never call this if the PGD entry wasn't valid */ BUG_ON(!(spgd.flags & _PAGE_PRESENT)); return &page[(vaddr >> PAGE_SHIFT) % PTES_PER_PAGE]; } -/* These two functions just like the above two, except they access the Guest - * page tables. Hence they return a Guest address. */ +/* These access the guest versions. */ static unsigned long gpgd_addr(struct lguest *lg, unsigned long vaddr) { unsigned int index = vaddr >> (PAGE_SHIFT + PTES_PER_PAGE_SHIFT); @@ -119,24 +55,12 @@ static unsigned long gpte_addr(struct lguest *lg, return gpage + ((vaddr>>PAGE_SHIFT) % PTES_PER_PAGE) * sizeof(gpte_t); } -/*H:350 This routine takes a page number given by the Guest and converts it to - * an actual, physical page number. It can fail for several reasons: the - * virtual address might not be mapped by the Launcher, the write flag is set - * and the page is read-only, or the write flag was set and the page was - * shared so had to be copied, but we ran out of memory. - * - * This holds a reference to the page, so release_pte() is careful to - * put that back. */ +/* Do a virtual -> physical mapping on a user page. */ static unsigned long get_pfn(unsigned long virtpfn, int write) { struct page *page; - /* This value indicates failure. */ unsigned long ret = -1UL; - /* get_user_pages() is a complex interface: it gets the "struct - * vm_area_struct" and "struct page" assocated with a range of pages. - * It also needs the task's mmap_sem held, and is not very quick. - * It returns the number of pages it got. */ down_read(¤t->mm->mmap_sem); if (get_user_pages(current, current->mm, virtpfn << PAGE_SHIFT, 1, write, 1, &page, NULL) == 1) @@ -145,47 +69,28 @@ static unsigned long get_pfn(unsigned long virtpfn, int write) return ret; } -/*H:340 Converting a Guest page table entry to a shadow (ie. real) page table - * entry can be a little tricky. The flags are (almost) the same, but the - * Guest PTE contains a virtual page number: the CPU needs the real page - * number. */ static spte_t gpte_to_spte(struct lguest *lg, gpte_t gpte, int write) { spte_t spte; unsigned long pfn; - /* The Guest sets the global flag, because it thinks that it is using - * PGE. We only told it to use PGE so it would tell us whether it was - * flushing a kernel mapping or a userspace mapping. We don't actually - * use the global bit, so throw it away. */ + /* We ignore the global flag. */ spte.flags = (gpte.flags & ~_PAGE_GLOBAL); - - /* We need a temporary "unsigned long" variable to hold the answer from - * get_pfn(), because it returns 0xFFFFFFFF on failure, which wouldn't - * fit in spte.pfn. get_pfn() finds the real physical number of the - * page, given the virtual number. */ pfn = get_pfn(gpte.pfn, write); if (pfn == -1UL) { kill_guest(lg, "failed to get page %u", gpte.pfn); - /* When we destroy the Guest, we'll go through the shadow page - * tables and release_pte() them. Make sure we don't think - * this one is valid! */ + /* Must not put_page() bogus page on cleanup. */ spte.flags = 0; } - /* Now we assign the page number, and our shadow PTE is complete. */ spte.pfn = pfn; return spte; } -/*H:460 And to complete the chain, release_pte() looks like this: */ static void release_pte(spte_t pte) { - /* Remember that get_user_pages() took a reference to the page, in - * get_pfn()? We have to put it back now. */ if (pte.flags & _PAGE_PRESENT) put_page(pfn_to_page(pte.pfn)); } -/*:*/ static void check_gpte(struct lguest *lg, gpte_t gpte) { @@ -199,16 +104,11 @@ static void check_gpgd(struct lguest *lg, gpgd_t gpgd) kill_guest(lg, "bad page directory entry"); } -/*H:330 - * (i) Setting up a page table entry for the Guest when it faults - * - * We saw this call in run_guest(): when we see a page fault in the Guest, we - * come here. That's because we only set up the shadow page tables lazily as - * they're needed, so we get page faults all the time and quietly fix them up - * and return to the Guest without it knowing. - * - * If we fixed up the fault (ie. we mapped the address), this routine returns - * true. */ +/* FIXME: We hold reference to pages, which prevents them from being + swapped. It'd be nice to have a callback when Linux wants to swap out. */ + +/* We fault pages in, which allows us to update accessed/dirty bits. + * Return true if we got page. */ int demand_page(struct lguest *lg, unsigned long vaddr, int errcode) { gpgd_t gpgd; @@ -217,161 +117,106 @@ int demand_page(struct lguest *lg, unsigned long vaddr, int errcode) gpte_t gpte; spte_t *spte; - /* First step: get the top-level Guest page table entry. */ gpgd = mkgpgd(lgread_u32(lg, gpgd_addr(lg, vaddr))); - /* Toplevel not present? We can't map it in. */ if (!(gpgd.flags & _PAGE_PRESENT)) return 0; - /* Now look at the matching shadow entry. */ spgd = spgd_addr(lg, lg->pgdidx, vaddr); if (!(spgd->flags & _PAGE_PRESENT)) { - /* No shadow entry: allocate a new shadow PTE page. */ + /* Get a page of PTEs for them. */ unsigned long ptepage = get_zeroed_page(GFP_KERNEL); - /* This is not really the Guest's fault, but killing it is - * simple for this corner case. */ + /* FIXME: Steal from self in this case? */ if (!ptepage) { kill_guest(lg, "out of memory allocating pte page"); return 0; } - /* We check that the Guest pgd is OK. */ check_gpgd(lg, gpgd); - /* And we copy the flags to the shadow PGD entry. The page - * number in the shadow PGD is the page we just allocated. */ spgd->raw.val = (__pa(ptepage) | gpgd.flags); } - /* OK, now we look at the lower level in the Guest page table: keep its - * address, because we might update it later. */ gpte_ptr = gpte_addr(lg, gpgd, vaddr); gpte = mkgpte(lgread_u32(lg, gpte_ptr)); - /* If this page isn't in the Guest page tables, we can't page it in. */ + /* No page? */ if (!(gpte.flags & _PAGE_PRESENT)) return 0; - /* Check they're not trying to write to a page the Guest wants - * read-only (bit 2 of errcode == write). */ + /* Write to read-only page? */ if ((errcode & 2) && !(gpte.flags & _PAGE_RW)) return 0; - /* User access to a kernel page? (bit 3 == user access) */ + /* User access to a non-user page? */ if ((errcode & 4) && !(gpte.flags & _PAGE_USER)) return 0; - /* Check that the Guest PTE flags are OK, and the page number is below - * the pfn_limit (ie. not mapping the Launcher binary). */ check_gpte(lg, gpte); - /* Add the _PAGE_ACCESSED and (for a write) _PAGE_DIRTY flag */ gpte.flags |= _PAGE_ACCESSED; if (errcode & 2) gpte.flags |= _PAGE_DIRTY; - /* Get the pointer to the shadow PTE entry we're going to set. */ + /* We're done with the old pte. */ spte = spte_addr(lg, *spgd, vaddr); - /* If there was a valid shadow PTE entry here before, we release it. - * This can happen with a write to a previously read-only entry. */ release_pte(*spte); - /* If this is a write, we insist that the Guest page is writable (the - * final arg to gpte_to_spte()). */ + /* We don't make it writable if this isn't a write: later + * write will fault so we can set dirty bit in guest. */ if (gpte.flags & _PAGE_DIRTY) *spte = gpte_to_spte(lg, gpte, 1); else { - /* If this is a read, don't set the "writable" bit in the page - * table entry, even if the Guest says it's writable. That way - * we come back here when a write does actually ocur, so we can - * update the Guest's _PAGE_DIRTY flag. */ gpte_t ro_gpte = gpte; ro_gpte.flags &= ~_PAGE_RW; *spte = gpte_to_spte(lg, ro_gpte, 0); } - /* Finally, we write the Guest PTE entry back: we've set the - * _PAGE_ACCESSED and maybe the _PAGE_DIRTY flags. */ + /* Now we update dirty/accessed on guest. */ lgwrite_u32(lg, gpte_ptr, gpte.raw.val); - - /* We succeeded in mapping the page! */ return 1; } -/*H:360 (ii) Setting up the page table entry for the Guest stack. - * - * Remember pin_stack_pages() which makes sure the stack is mapped? It could - * simply call demand_page(), but as we've seen that logic is quite long, and - * usually the stack pages are already mapped anyway, so it's not required. - * - * This is a quick version which answers the question: is this virtual address - * mapped by the shadow page tables, and is it writable? */ +/* This is much faster than the full demand_page logic. */ static int page_writable(struct lguest *lg, unsigned long vaddr) { spgd_t *spgd; unsigned long flags; - /* Look at the top level entry: is it present? */ spgd = spgd_addr(lg, lg->pgdidx, vaddr); if (!(spgd->flags & _PAGE_PRESENT)) return 0; - /* Check the flags on the pte entry itself: it must be present and - * writable. */ flags = spte_addr(lg, *spgd, vaddr)->flags; return (flags & (_PAGE_PRESENT|_PAGE_RW)) == (_PAGE_PRESENT|_PAGE_RW); } -/* So, when pin_stack_pages() asks us to pin a page, we check if it's already - * in the page tables, and if not, we call demand_page() with error code 2 - * (meaning "write"). */ void pin_page(struct lguest *lg, unsigned long vaddr) { if (!page_writable(lg, vaddr) && !demand_page(lg, vaddr, 2)) kill_guest(lg, "bad stack page %#lx", vaddr); } -/*H:450 If we chase down the release_pgd() code, it looks like this: */ static void release_pgd(struct lguest *lg, spgd_t *spgd) { - /* If the entry's not present, there's nothing to release. */ if (spgd->flags & _PAGE_PRESENT) { unsigned int i; - /* Converting the pfn to find the actual PTE page is easy: turn - * the page number into a physical address, then convert to a - * virtual address (easy for kernel pages like this one). */ spte_t *ptepage = __va(spgd->pfn << PAGE_SHIFT); - /* For each entry in the page, we might need to release it. */ for (i = 0; i < PTES_PER_PAGE; i++) release_pte(ptepage[i]); - /* Now we can free the page of PTEs */ free_page((long)ptepage); - /* And zero out the PGD entry we we never release it twice. */ spgd->raw.val = 0; } } -/*H:440 (v) Flushing (thowing away) page tables, - * - * We saw flush_user_mappings() called when we re-used a top-level pgdir page. - * It simply releases every PTE page from 0 up to the kernel address. */ static void flush_user_mappings(struct lguest *lg, int idx) { unsigned int i; - /* Release every pgd entry up to the kernel's address. */ for (i = 0; i < vaddr_to_pgd_index(lg->page_offset); i++) release_pgd(lg, lg->pgdirs[idx].pgdir + i); } -/* The Guest also has a hypercall to do this manually: it's used when a large - * number of mappings have been changed. */ void guest_pagetable_flush_user(struct lguest *lg) { - /* Drop the userspace part of the current page table. */ flush_user_mappings(lg, lg->pgdidx); } -/*:*/ -/* We keep several page tables. This is a simple routine to find the page - * table (if any) corresponding to this top-level address the Guest has given - * us. */ static unsigned int find_pgdir(struct lguest *lg, unsigned long pgtable) { unsigned int i; @@ -381,30 +226,21 @@ static unsigned int find_pgdir(struct lguest *lg, unsigned long pgtable) return i; } -/*H:435 And this is us, creating the new page directory. If we really do - * allocate a new one (and so the kernel parts are not there), we set - * blank_pgdir. */ static unsigned int new_pgdir(struct lguest *lg, unsigned long cr3, int *blank_pgdir) { unsigned int next; - /* We pick one entry at random to throw out. Choosing the Least - * Recently Used might be better, but this is easy. */ next = random32() % ARRAY_SIZE(lg->pgdirs); - /* If it's never been allocated at all before, try now. */ if (!lg->pgdirs[next].pgdir) { lg->pgdirs[next].pgdir = (spgd_t *)get_zeroed_page(GFP_KERNEL); - /* If the allocation fails, just keep using the one we have */ if (!lg->pgdirs[next].pgdir) next = lg->pgdidx; else - /* This is a blank page, so there are no kernel - * mappings: caller must map the stack! */ + /* There are no mappings: you'll need to re-pin */ *blank_pgdir = 1; } - /* Record which Guest toplevel this shadows. */ lg->pgdirs[next].cr3 = cr3; /* Release all the non-kernel mappings. */ flush_user_mappings(lg, next); @@ -412,161 +248,82 @@ static unsigned int new_pgdir(struct lguest *lg, return next; } -/*H:430 (iv) Switching page tables - * - * This is what happens when the Guest changes page tables (ie. changes the - * top-level pgdir). This happens on almost every context switch. */ void guest_new_pagetable(struct lguest *lg, unsigned long pgtable) { int newpgdir, repin = 0; - /* Look to see if we have this one already. */ newpgdir = find_pgdir(lg, pgtable); - /* If not, we allocate or mug an existing one: if it's a fresh one, - * repin gets set to 1. */ if (newpgdir == ARRAY_SIZE(lg->pgdirs)) newpgdir = new_pgdir(lg, pgtable, &repin); - /* Change the current pgd index to the new one. */ lg->pgdidx = newpgdir; - /* If it was completely blank, we map in the Guest kernel stack */ if (repin) pin_stack_pages(lg); } -/*H:470 Finally, a routine which throws away everything: all PGD entries in all - * the shadow page tables. This is used when we destroy the Guest. */ static void release_all_pagetables(struct lguest *lg) { unsigned int i, j; - /* Every shadow pagetable this Guest has */ for (i = 0; i < ARRAY_SIZE(lg->pgdirs); i++) if (lg->pgdirs[i].pgdir) - /* Every PGD entry except the Switcher at the top */ for (j = 0; j < SWITCHER_PGD_INDEX; j++) release_pgd(lg, lg->pgdirs[i].pgdir + j); } -/* We also throw away everything when a Guest tells us it's changed a kernel - * mapping. Since kernel mappings are in every page table, it's easiest to - * throw them all away. This is amazingly slow, but thankfully rare. */ void guest_pagetable_clear_all(struct lguest *lg) { release_all_pagetables(lg); - /* We need the Guest kernel stack mapped again. */ pin_stack_pages(lg); } -/*H:420 This is the routine which actually sets the page table entry for then - * "idx"'th shadow page table. - * - * Normally, we can just throw out the old entry and replace it with 0: if they - * use it demand_page() will put the new entry in. We need to do this anyway: - * The Guest expects _PAGE_ACCESSED to be set on its PTE the first time a page - * is read from, and _PAGE_DIRTY when it's written to. - * - * But Avi Kivity pointed out that most Operating Systems (Linux included) set - * these bits on PTEs immediately anyway. This is done to save the CPU from - * having to update them, but it helps us the same way: if they set - * _PAGE_ACCESSED then we can put a read-only PTE entry in immediately, and if - * they set _PAGE_DIRTY then we can put a writable PTE entry in immediately. - */ static void do_set_pte(struct lguest *lg, int idx, unsigned long vaddr, gpte_t gpte) { - /* Look up the matching shadow page directot entry. */ spgd_t *spgd = spgd_addr(lg, idx, vaddr); - - /* If the top level isn't present, there's no entry to update. */ if (spgd->flags & _PAGE_PRESENT) { - /* Otherwise, we start by releasing the existing entry. */ spte_t *spte = spte_addr(lg, *spgd, vaddr); release_pte(*spte); - - /* If they're setting this entry as dirty or accessed, we might - * as well put that entry they've given us in now. This shaves - * 10% off a copy-on-write micro-benchmark. */ if (gpte.flags & (_PAGE_DIRTY | _PAGE_ACCESSED)) { check_gpte(lg, gpte); *spte = gpte_to_spte(lg, gpte, gpte.flags&_PAGE_DIRTY); } else - /* Otherwise we can demand_page() it in later. */ spte->raw.val = 0; } } -/*H:410 Updating a PTE entry is a little trickier. - * - * We keep track of several different page tables (the Guest uses one for each - * process, so it makes sense to cache at least a few). Each of these have - * identical kernel parts: ie. every mapping above PAGE_OFFSET is the same for - * all processes. So when the page table above that address changes, we update - * all the page tables, not just the current one. This is rare. - * - * The benefit is that when we have to track a new page table, we can copy keep - * all the kernel mappings. This speeds up context switch immensely. */ void guest_set_pte(struct lguest *lg, unsigned long cr3, unsigned long vaddr, gpte_t gpte) { - /* Kernel mappings must be changed on all top levels. Slow, but - * doesn't happen often. */ + /* Kernel mappings must be changed on all top levels. */ if (vaddr >= lg->page_offset) { unsigned int i; for (i = 0; i < ARRAY_SIZE(lg->pgdirs); i++) if (lg->pgdirs[i].pgdir) do_set_pte(lg, i, vaddr, gpte); } else { - /* Is this page table one we have a shadow for? */ int pgdir = find_pgdir(lg, cr3); if (pgdir != ARRAY_SIZE(lg->pgdirs)) - /* If so, do the update. */ do_set_pte(lg, pgdir, vaddr, gpte); } } -/*H:400 - * (iii) Setting up a page table entry when the Guest tells us it has changed. - * - * Just like we did in interrupts_and_traps.c, it makes sense for us to deal - * with the other side of page tables while we're here: what happens when the - * Guest asks for a page table to be updated? - * - * We already saw that demand_page() will fill in the shadow page tables when - * needed, so we can simply remove shadow page table entries whenever the Guest - * tells us they've changed. When the Guest tries to use the new entry it will - * fault and demand_page() will fix it up. - * - * So with that in mind here's our code to to update a (top-level) PGD entry: - */ void guest_set_pmd(struct lguest *lg, unsigned long cr3, u32 idx) { int pgdir; - /* The kernel seems to try to initialize this early on: we ignore its - * attempts to map over the Switcher. */ if (idx >= SWITCHER_PGD_INDEX) return; - /* If they're talking about a page table we have a shadow for... */ pgdir = find_pgdir(lg, cr3); if (pgdir < ARRAY_SIZE(lg->pgdirs)) - /* ... throw it away. */ release_pgd(lg, lg->pgdirs[pgdir].pgdir + idx); } -/*H:500 (vii) Setting up the page tables initially. - * - * When a Guest is first created, the Launcher tells us where the toplevel of - * its first page table is. We set some things up here: */ int init_guest_pagetable(struct lguest *lg, unsigned long pgtable) { - /* In flush_user_mappings() we loop from 0 to - * "vaddr_to_pgd_index(lg->page_offset)". This assumes it won't hit - * the Switcher mappings, so check that now. */ + /* We assume this in flush_user_mappings, so check now */ if (vaddr_to_pgd_index(lg->page_offset) >= SWITCHER_PGD_INDEX) return -EINVAL; - /* We start on the first shadow page table, and give it a blank PGD - * page. */ lg->pgdidx = 0; lg->pgdirs[lg->pgdidx].cr3 = pgtable; lg->pgdirs[lg->pgdidx].pgdir = (spgd_t*)get_zeroed_page(GFP_KERNEL); @@ -575,48 +332,33 @@ int init_guest_pagetable(struct lguest *lg, unsigned long pgtable) return 0; } -/* When a Guest dies, our cleanup is fairly simple. */ void free_guest_pagetable(struct lguest *lg) { unsigned int i; - /* Throw away all page table pages. */ release_all_pagetables(lg); - /* Now free the top levels: free_page() can handle 0 just fine. */ for (i = 0; i < ARRAY_SIZE(lg->pgdirs); i++) free_page((long)lg->pgdirs[i].pgdir); } -/*H:480 (vi) Mapping the Switcher when the Guest is about to run. - * - * The Switcher and the two pages for this CPU need to be available to the - * Guest (and not the pages for other CPUs). We have the appropriate PTE pages - * for each CPU already set up, we just need to hook them in. */ +/* Caller must be preempt-safe */ void map_switcher_in_guest(struct lguest *lg, struct lguest_pages *pages) { spte_t *switcher_pte_page = __get_cpu_var(switcher_pte_pages); spgd_t switcher_pgd; spte_t regs_pte; - /* Make the last PGD entry for this Guest point to the Switcher's PTE - * page for this CPU (with appropriate flags). */ + /* Since switcher less that 4MB, we simply mug top pte page. */ switcher_pgd.pfn = __pa(switcher_pte_page) >> PAGE_SHIFT; switcher_pgd.flags = _PAGE_KERNEL; lg->pgdirs[lg->pgdidx].pgdir[SWITCHER_PGD_INDEX] = switcher_pgd; - /* We also change the Switcher PTE page. When we're running the Guest, - * we want the Guest's "regs" page to appear where the first Switcher - * page for this CPU is. This is an optimization: when the Switcher - * saves the Guest registers, it saves them into the first page of this - * CPU's "struct lguest_pages": if we make sure the Guest's register - * page is already mapped there, we don't have to copy them out - * again. */ + /* Map our regs page over stack page. */ regs_pte.pfn = __pa(lg->regs_page) >> PAGE_SHIFT; regs_pte.flags = _PAGE_KERNEL; switcher_pte_page[(unsigned long)pages/PAGE_SIZE%PTES_PER_PAGE] = regs_pte; } -/*:*/ static void free_switcher_pte_pages(void) { @@ -626,10 +368,6 @@ static void free_switcher_pte_pages(void) free_page((long)switcher_pte_page(i)); } -/*H:520 Setting up the Switcher PTE page for given CPU is fairly easy, given - * the CPU number and the "struct page"s for the Switcher code itself. - * - * Currently the Switcher is less than a page long, so "pages" is always 1. */ static __init void populate_switcher_pte_page(unsigned int cpu, struct page *switcher_page[], unsigned int pages) @@ -637,26 +375,21 @@ static __init void populate_switcher_pte_page(unsigned int cpu, unsigned int i; spte_t *pte = switcher_pte_page(cpu); - /* The first entries are easy: they map the Switcher code. */ for (i = 0; i < pages; i++) { pte[i].pfn = page_to_pfn(switcher_page[i]); pte[i].flags = _PAGE_PRESENT|_PAGE_ACCESSED; } - /* The only other thing we map is this CPU's pair of pages. */ + /* We only map this CPU's pages, so guest can't see others. */ i = pages + cpu*2; - /* First page (Guest registers) is writable from the Guest */ + /* First page (regs) is rw, second (state) is ro. */ pte[i].pfn = page_to_pfn(switcher_page[i]); pte[i].flags = _PAGE_PRESENT|_PAGE_ACCESSED|_PAGE_RW; - /* The second page contains the "struct lguest_ro_state", and is - * read-only. */ pte[i+1].pfn = page_to_pfn(switcher_page[i+1]); pte[i+1].flags = _PAGE_PRESENT|_PAGE_ACCESSED; } -/*H:510 At boot or module load time, init_pagetables() allocates and populates - * the Switcher PTE page for each CPU. */ __init int init_pagetables(struct page **switcher_page, unsigned int pages) { unsigned int i; @@ -671,9 +404,7 @@ __init int init_pagetables(struct page **switcher_page, unsigned int pages) } return 0; } -/*:*/ -/* Cleaning up simply involves freeing the PTE page for each CPU. */ void free_pagetables(void) { free_switcher_pte_pages(); diff --git a/trunk/drivers/lguest/segments.c b/trunk/drivers/lguest/segments.c index f675a41a80da..1b2cfe89dcd5 100644 --- a/trunk/drivers/lguest/segments.c +++ b/trunk/drivers/lguest/segments.c @@ -1,68 +1,16 @@ -/*P:600 The x86 architecture has segments, which involve a table of descriptors - * which can be used to do funky things with virtual address interpretation. - * We originally used to use segments so the Guest couldn't alter the - * Guest<->Host Switcher, and then we had to trim Guest segments, and restore - * for userspace per-thread segments, but trim again for on userspace->kernel - * transitions... This nightmarish creation was contained within this file, - * where we knew not to tread without heavy armament and a change of underwear. - * - * In these modern times, the segment handling code consists of simple sanity - * checks, and the worst you'll experience reading this code is butterfly-rash - * from frolicking through its parklike serenity. :*/ #include "lg.h" -/*H:600 - * We've almost completed the Host; there's just one file to go! - * - * Segments & The Global Descriptor Table - * - * (That title sounds like a bad Nerdcore group. Not to suggest that there are - * any good Nerdcore groups, but in high school a friend of mine had a band - * called Joe Fish and the Chips, so there are definitely worse band names). - * - * To refresh: the GDT is a table of 8-byte values describing segments. Once - * set up, these segments can be loaded into one of the 6 "segment registers". - * - * GDT entries are passed around as "struct desc_struct"s, which like IDT - * entries are split into two 32-bit members, "a" and "b". One day, someone - * will clean that up, and be declared a Hero. (No pressure, I'm just saying). - * - * Anyway, the GDT entry contains a base (the start address of the segment), a - * limit (the size of the segment - 1), and some flags. Sounds simple, and it - * would be, except those zany Intel engineers decided that it was too boring - * to put the base at one end, the limit at the other, and the flags in - * between. They decided to shotgun the bits at random throughout the 8 bytes, - * like so: - * - * 0 16 40 48 52 56 63 - * [ limit part 1 ][ base part 1 ][ flags ][li][fl][base ] - * mit ags part 2 - * part 2 - * - * As a result, this file contains a certain amount of magic numeracy. Let's - * begin. - */ - -/* Is the descriptor the Guest wants us to put in OK? - * - * The flag which Intel says must be zero: must be zero. The descriptor must - * be present, (this is actually checked earlier but is here for thorougness), - * and the descriptor type must be 1 (a memory segment). */ static int desc_ok(const struct desc_struct *gdt) { + /* MBZ=0, P=1, DT=1 */ return ((gdt->b & 0x00209000) == 0x00009000); } -/* Is the segment present? (Otherwise it can't be used by the Guest). */ static int segment_present(const struct desc_struct *gdt) { return gdt->b & 0x8000; } -/* There are several entries we don't let the Guest set. The TSS entry is the - * "Task State Segment" which controls all kinds of delicate things. The - * LGUEST_CS and LGUEST_DS entries are reserved for the Switcher, and the - * the Guest can't be trusted to deal with double faults. */ static int ignored_gdt(unsigned int num) { return (num == GDT_ENTRY_TSS @@ -71,18 +19,9 @@ static int ignored_gdt(unsigned int num) || num == GDT_ENTRY_DOUBLEFAULT_TSS); } -/* If the Guest asks us to remove an entry from the GDT, we have to be careful. - * If one of the segment registers is pointing at that entry the Switcher will - * crash when it tries to reload the segment registers for the Guest. - * - * It doesn't make much sense for the Guest to try to remove its own code, data - * or stack segments while they're in use: assume that's a Guest bug. If it's - * one of the lesser segment registers using the removed entry, we simply set - * that register to 0 (unusable). */ +/* We don't allow removal of CS, DS or SS; it doesn't make sense. */ static void check_segment_use(struct lguest *lg, unsigned int desc) { - /* GDT entries are 8 bytes long, so we divide to get the index and - * ignore the bottom bits. */ if (lg->regs->gs / 8 == desc) lg->regs->gs = 0; if (lg->regs->fs / 8 == desc) @@ -94,21 +33,13 @@ static void check_segment_use(struct lguest *lg, unsigned int desc) || lg->regs->ss / 8 == desc) kill_guest(lg, "Removed live GDT entry %u", desc); } -/*:*/ -/*M:009 We wouldn't need to check for removal of in-use segments if we handled - * faults in the Switcher. However, it's probably not a worthwhile - * optimization. :*/ - -/*H:610 Once the GDT has been changed, we look through the changed entries and - * see if they're OK. If not, we'll call kill_guest() and the Guest will never - * get to use the invalid entries. */ + static void fixup_gdt_table(struct lguest *lg, unsigned start, unsigned end) { unsigned int i; for (i = start; i < end; i++) { - /* We never copy these ones to real GDT, so we don't care what - * they say */ + /* We never copy these ones to real gdt */ if (ignored_gdt(i)) continue; @@ -122,57 +53,41 @@ static void fixup_gdt_table(struct lguest *lg, unsigned start, unsigned end) if (!desc_ok(&lg->gdt[i])) kill_guest(lg, "Bad GDT descriptor %i", i); - /* Segment descriptors contain a privilege level: the Guest is - * sometimes careless and leaves this as 0, even though it's - * running at privilege level 1. If so, we fix it here. */ + /* DPL 0 presumably means "for use by guest". */ if ((lg->gdt[i].b & 0x00006000) == 0) lg->gdt[i].b |= (GUEST_PL << 13); - /* Each descriptor has an "accessed" bit. If we don't set it - * now, the CPU will try to set it when the Guest first loads - * that entry into a segment register. But the GDT isn't - * writable by the Guest, so bad things can happen. */ + /* Set accessed bit, since gdt isn't writable. */ lg->gdt[i].b |= 0x00000100; } } -/* This routine is called at boot or modprobe time for each CPU to set up the - * "constant" GDT entries for Guests running on that CPU. */ void setup_default_gdt_entries(struct lguest_ro_state *state) { struct desc_struct *gdt = state->guest_gdt; unsigned long tss = (unsigned long)&state->guest_tss; - /* The hypervisor segments are full 0-4G segments, privilege level 0 */ + /* Hypervisor segments. */ gdt[GDT_ENTRY_LGUEST_CS] = FULL_EXEC_SEGMENT; gdt[GDT_ENTRY_LGUEST_DS] = FULL_SEGMENT; - /* The TSS segment refers to the TSS entry for this CPU, so we cannot - * copy it from the Guest. Forgive the magic flags */ + /* This is the one which we *cannot* copy from guest, since tss + is depended on this lguest_ro_state, ie. this cpu. */ gdt[GDT_ENTRY_TSS].a = 0x00000067 | (tss << 16); gdt[GDT_ENTRY_TSS].b = 0x00008900 | (tss & 0xFF000000) | ((tss >> 16) & 0x000000FF); } -/* This routine is called before the Guest is run for the first time. */ void setup_guest_gdt(struct lguest *lg) { - /* Start with full 0-4G segments... */ lg->gdt[GDT_ENTRY_KERNEL_CS] = FULL_EXEC_SEGMENT; lg->gdt[GDT_ENTRY_KERNEL_DS] = FULL_SEGMENT; - /* ...except the Guest is allowed to use them, so set the privilege - * level appropriately in the flags. */ lg->gdt[GDT_ENTRY_KERNEL_CS].b |= (GUEST_PL << 13); lg->gdt[GDT_ENTRY_KERNEL_DS].b |= (GUEST_PL << 13); } -/* Like the IDT, we never simply use the GDT the Guest gives us. We set up the - * GDTs for each CPU, then we copy across the entries each time we want to run - * a different Guest on that CPU. */ - -/* A partial GDT load, for the three "thead-local storage" entries. Otherwise - * it's just like load_guest_gdt(). So much, in fact, it would probably be - * neater to have a single hypercall to cover both. */ +/* This is a fast version for the common case where only the three TLS entries + * have changed. */ void copy_gdt_tls(const struct lguest *lg, struct desc_struct *gdt) { unsigned int i; @@ -181,31 +96,22 @@ void copy_gdt_tls(const struct lguest *lg, struct desc_struct *gdt) gdt[i] = lg->gdt[i]; } -/* This is the full version */ void copy_gdt(const struct lguest *lg, struct desc_struct *gdt) { unsigned int i; - /* The default entries from setup_default_gdt_entries() are not - * replaced. See ignored_gdt() above. */ for (i = 0; i < GDT_ENTRIES; i++) if (!ignored_gdt(i)) gdt[i] = lg->gdt[i]; } -/* This is where the Guest asks us to load a new GDT (LHCALL_LOAD_GDT). */ void load_guest_gdt(struct lguest *lg, unsigned long table, u32 num) { - /* We assume the Guest has the same number of GDT entries as the - * Host, otherwise we'd have to dynamically allocate the Guest GDT. */ if (num > ARRAY_SIZE(lg->gdt)) kill_guest(lg, "too many gdt entries %i", num); - /* We read the whole thing in, then fix it up. */ lgread(lg, lg->gdt, table, num * sizeof(lg->gdt[0])); fixup_gdt_table(lg, 0, ARRAY_SIZE(lg->gdt)); - /* Mark that the GDT changed so the core knows it has to copy it again, - * even if the Guest is run on the same CPU. */ lg->changed |= CHANGED_GDT; } @@ -217,13 +123,3 @@ void guest_load_tls(struct lguest *lg, unsigned long gtls) fixup_gdt_table(lg, GDT_ENTRY_TLS_MIN, GDT_ENTRY_TLS_MAX+1); lg->changed |= CHANGED_GDT_TLS; } - -/* - * With this, we have finished the Host. - * - * Five of the seven parts of our task are complete. You have made it through - * the Bit of Despair (I think that's somewhere in the page table code, - * myself). - * - * Next, we examine "make Switcher". It's short, but intense. - */ diff --git a/trunk/drivers/lguest/switcher.S b/trunk/drivers/lguest/switcher.S index d418179ea6b5..eadd4cc299d2 100644 --- a/trunk/drivers/lguest/switcher.S +++ b/trunk/drivers/lguest/switcher.S @@ -1,136 +1,45 @@ -/*P:900 This is the Switcher: code which sits at 0xFFC00000 to do the low-level - * Guest<->Host switch. It is as simple as it can be made, but it's naturally - * very specific to x86. - * - * You have now completed Preparation. If this has whet your appetite; if you - * are feeling invigorated and refreshed then the next, more challenging stage - * can be found in "make Guest". :*/ +/* This code sits at 0xFFC00000 to do the low-level guest<->host switch. -/*S:100 - * Welcome to the Switcher itself! - * - * This file contains the low-level code which changes the CPU to run the Guest - * code, and returns to the Host when something happens. Understand this, and - * you understand the heart of our journey. - * - * Because this is in assembler rather than C, our tale switches from prose to - * verse. First I tried limericks: - * - * There once was an eax reg, - * To which our pointer was fed, - * It needed an add, - * Which asm-offsets.h had - * But this limerick is hurting my head. - * - * Next I tried haikus, but fitting the required reference to the seasons in - * every stanza was quickly becoming tiresome: - * - * The %eax reg - * Holds "struct lguest_pages" now: - * Cherry blossoms fall. - * - * Then I started with Heroic Verse, but the rhyming requirement leeched away - * the content density and led to some uniquely awful oblique rhymes: - * - * These constants are coming from struct offsets - * For use within the asm switcher text. - * - * Finally, I settled for something between heroic hexameter, and normal prose - * with inappropriate linebreaks. Anyway, it aint no Shakespeare. - */ - -// Not all kernel headers work from assembler -// But these ones are needed: the ENTRY() define -// And constants extracted from struct offsets -// To avoid magic numbers and breakage: -// Should they change the compiler can't save us -// Down here in the depths of assembler code. + There is are two pages above us for this CPU (struct lguest_pages). + The second page (struct lguest_ro_state) becomes read-only after the + context switch. The first page (the stack for traps) remains writable, + but while we're in here, the guest cannot be running. +*/ #include #include #include "lg.h" -// We mark the start of the code to copy -// It's placed in .text tho it's never run here -// You'll see the trick macro at the end -// Which interleaves data and text to effect. .text ENTRY(start_switcher_text) -// When we reach switch_to_guest we have just left -// The safe and comforting shores of C code -// %eax has the "struct lguest_pages" to use -// Where we save state and still see it from the Guest -// And %ebx holds the Guest shadow pagetable: -// Once set we have truly left Host behind. +/* %eax points to lguest pages for this CPU. %ebx contains cr3 value. + All normal registers can be clobbered! */ ENTRY(switch_to_guest) - // We told gcc all its regs could fade, - // Clobbered by our journey into the Guest - // We could have saved them, if we tried - // But time is our master and cycles count. - - // Segment registers must be saved for the Host - // We push them on the Host stack for later + /* Save host segments on host stack. */ pushl %es pushl %ds pushl %gs pushl %fs - // But the compiler is fickle, and heeds - // No warning of %ebp clobbers - // When frame pointers are used. That register - // Must be saved and restored or chaos strikes. + /* With CONFIG_FRAME_POINTER, gcc doesn't let us clobber this! */ pushl %ebp - // The Host's stack is done, now save it away - // In our "struct lguest_pages" at offset - // Distilled into asm-offsets.h + /* Save host stack. */ movl %esp, LGUEST_PAGES_host_sp(%eax) - - // All saved and there's now five steps before us: - // Stack, GDT, IDT, TSS - // And last of all the page tables are flipped. - - // Yet beware that our stack pointer must be - // Always valid lest an NMI hits - // %edx does the duty here as we juggle - // %eax is lguest_pages: our stack lies within. + /* Switch to guest stack: if we get NMI we expect to be there. */ movl %eax, %edx addl $LGUEST_PAGES_regs, %edx movl %edx, %esp - - // The Guest's GDT we so carefully - // Placed in the "struct lguest_pages" before + /* Switch to guest's GDT, IDT. */ lgdt LGUEST_PAGES_guest_gdt_desc(%eax) - - // The Guest's IDT we did partially - // Move to the "struct lguest_pages" as well. lidt LGUEST_PAGES_guest_idt_desc(%eax) - - // The TSS entry which controls traps - // Must be loaded up with "ltr" now: - // For after we switch over our page tables - // It (as the rest) will be writable no more. - // (The GDT entry TSS needs - // Changes type when we load it: damn Intel!) + /* Switch to guest's TSS while GDT still writable. */ movl $(GDT_ENTRY_TSS*8), %edx ltr %dx - - // Look back now, before we take this last step! - // The Host's TSS entry was also marked used; - // Let's clear it again, ere we return. - // The GDT descriptor of the Host - // Points to the table after two "size" bytes + /* Set host's TSS GDT entry to available (clear byte 5 bit 2). */ movl (LGUEST_PAGES_host_gdt_desc+2)(%eax), %edx - // Clear the type field of "used" (byte 5, bit 2) andb $0xFD, (GDT_ENTRY_TSS*8 + 5)(%edx) - - // Once our page table's switched, the Guest is live! - // The Host fades as we run this final step. - // Our "struct lguest_pages" is now read-only. + /* Switch to guest page tables: lguest_pages->state now read-only. */ movl %ebx, %cr3 - - // The page table change did one tricky thing: - // The Guest's register page has been mapped - // Writable onto our %esp (stack) -- - // We can simply pop off all Guest regs. + /* Restore guest regs */ popl %ebx popl %ecx popl %edx @@ -142,27 +51,12 @@ ENTRY(switch_to_guest) popl %fs popl %ds popl %es - - // Near the base of the stack lurk two strange fields - // Which we fill as we exit the Guest - // These are the trap number and its error - // We can simply step past them on our way. + /* Skip error code and trap number */ addl $8, %esp - - // The last five stack slots hold return address - // And everything needed to change privilege - // Into the Guest privilege level of 1, - // And the stack where the Guest had last left it. - // Interrupts are turned back on: we are Guest. iret -// There are two paths where we switch to the Host -// So we put the routine in a macro. -// We are on our way home, back to the Host -// Interrupted out of the Guest, we come here. #define SWITCH_TO_HOST \ - /* We save the Guest state: all registers first \ - * Laid out just as "struct lguest_regs" defines */ \ + /* Save guest state */ \ pushl %es; \ pushl %ds; \ pushl %fs; \ @@ -174,119 +68,58 @@ ENTRY(switch_to_guest) pushl %edx; \ pushl %ecx; \ pushl %ebx; \ - /* Our stack and our code are using segments \ - * Set in the TSS and IDT \ - * Yet if we were to touch data we'd use \ - * Whatever data segment the Guest had. \ - * Load the lguest ds segment for now. */ \ + /* Load lguest ds segment for convenience. */ \ movl $(LGUEST_DS), %eax; \ movl %eax, %ds; \ - /* So where are we? Which CPU, which struct? \ - * The stack is our clue: our TSS sets \ - * It at the end of "struct lguest_pages" \ - * And we then pushed and pushed and pushed Guest regs: \ - * Now stack points atop the "struct lguest_regs". \ - * Subtract that offset, and we find our struct. */ \ + /* Figure out where we are, based on stack (at top of regs). */ \ movl %esp, %eax; \ subl $LGUEST_PAGES_regs, %eax; \ - /* Save our trap number: the switch will obscure it \ - * (The Guest regs are not mapped here in the Host) \ - * %ebx holds it safe for deliver_to_host */ \ + /* Put trap number in %ebx before we switch cr3 and lose it. */ \ movl LGUEST_PAGES_regs_trapnum(%eax), %ebx; \ - /* The Host GDT, IDT and stack! \ - * All these lie safely hidden from the Guest: \ - * We must return to the Host page tables \ - * (Hence that was saved in struct lguest_pages) */ \ + /* Switch to host page tables (host GDT, IDT and stack are in host \ + mem, so need this first) */ \ movl LGUEST_PAGES_host_cr3(%eax), %edx; \ movl %edx, %cr3; \ - /* As before, when we looked back at the Host \ - * As we left and marked TSS unused \ - * So must we now for the Guest left behind. */ \ + /* Set guest's TSS to available (clear byte 5 bit 2). */ \ andb $0xFD, (LGUEST_PAGES_guest_gdt+GDT_ENTRY_TSS*8+5)(%eax); \ - /* Switch to Host's GDT, IDT. */ \ + /* Switch to host's GDT & IDT. */ \ lgdt LGUEST_PAGES_host_gdt_desc(%eax); \ lidt LGUEST_PAGES_host_idt_desc(%eax); \ - /* Restore the Host's stack where it's saved regs lie */ \ + /* Switch to host's stack. */ \ movl LGUEST_PAGES_host_sp(%eax), %esp; \ - /* Last the TSS: our Host is complete */ \ + /* Switch to host's TSS */ \ movl $(GDT_ENTRY_TSS*8), %edx; \ ltr %dx; \ - /* Restore now the regs saved right at the first. */ \ popl %ebp; \ popl %fs; \ popl %gs; \ popl %ds; \ popl %es -// Here's where we come when the Guest has just trapped: -// (Which trap we'll see has been pushed on the stack). -// We need only switch back, and the Host will decode -// Why we came home, and what needs to be done. +/* Return to run_guest_once. */ return_to_host: SWITCH_TO_HOST iret -// An interrupt, with some cause external -// Has ajerked us rudely from the Guest's code -// Again we must return home to the Host deliver_to_host: SWITCH_TO_HOST - // But now we must go home via that place - // Where that interrupt was supposed to go - // Had we not been ensconced, running the Guest. - // Here we see the cleverness of our stack: - // The Host stack is formed like an interrupt - // With EIP, CS and EFLAGS layered. - // Interrupt handlers end with "iret" - // And that will take us home at long long last. - - // But first we must find the handler to call! - // The IDT descriptor for the Host - // Has two bytes for size, and four for address: - // %edx will hold it for us for now. + /* Decode IDT and jump to hosts' irq handler. When that does iret, it + * will return to run_guest_once. This is a feature. */ movl (LGUEST_PAGES_host_idt_desc+2)(%eax), %edx - // We now know the table address we need, - // And saved the trap's number inside %ebx. - // Yet the pointer to the handler is smeared - // Across the bits of the table entry. - // What oracle can tell us how to extract - // From such a convoluted encoding? - // I consulted gcc, and it gave - // These instructions, which I gladly credit: leal (%edx,%ebx,8), %eax movzwl (%eax),%edx movl 4(%eax), %eax xorw %ax, %ax orl %eax, %edx - // Now the address of the handler's in %edx - // We call it now: its "iret" takes us home. jmp *%edx -// Every interrupt can come to us here -// But we must truly tell each apart. -// They number two hundred and fifty six -// And each must land in a different spot, -// Push its number on stack, and join the stream. - -// And worse, a mere six of the traps stand apart -// And push on their stack an addition: -// An error number, thirty two bits long -// So we punish the other two fifty -// And make them push a zero so they match. - -// Yet two fifty six entries is long -// And all will look most the same as the last -// So we create a macro which can make -// As many entries as we need to fill. - -// Note the change to .data then .text: -// We plant the address of each entry -// Into a (data) table for the Host -// To know where each Guest interrupt should go. +/* Real hardware interrupts are delivered straight to the host. Others + cause us to return to run_guest_once so it can decide what to do. Note + that some of these are overridden by the guest to deliver directly, and + never enter here (see load_guest_idt_entry). */ .macro IRQ_STUB N TARGET .data; .long 1f; .text; 1: - // Trap eight, ten through fourteen and seventeen - // Supply an error number. Else zero. + /* Make an error number for most traps, which don't have one. */ .if (\N <> 8) && (\N < 10 || \N > 14) && (\N <> 17) pushl $0 .endif @@ -295,8 +128,6 @@ deliver_to_host: ALIGN .endm -// This macro creates numerous entries -// Using GAS macros which out-power C's. .macro IRQ_STUBS FIRST LAST TARGET irq=\FIRST .rept \LAST-\FIRST+1 @@ -305,43 +136,24 @@ deliver_to_host: .endr .endm -// Here's the marker for our pointer table -// Laid in the data section just before -// Each macro places the address of code -// Forming an array: each one points to text -// Which handles interrupt in its turn. +/* We intercept every interrupt, because we may need to switch back to + * host. Unfortunately we can't tell them apart except by entry + * point, so we need 256 entry points. + */ .data .global default_idt_entries default_idt_entries: .text - // The first two traps go straight back to the Host - IRQ_STUBS 0 1 return_to_host - // We'll say nothing, yet, about NMI - IRQ_STUB 2 handle_nmi - // Other traps also return to the Host - IRQ_STUBS 3 31 return_to_host - // All interrupts go via their handlers - IRQ_STUBS 32 127 deliver_to_host - // 'Cept system calls coming from userspace - // Are to go to the Guest, never the Host. - IRQ_STUB 128 return_to_host - IRQ_STUBS 129 255 deliver_to_host - -// The NMI, what a fabulous beast -// Which swoops in and stops us no matter that -// We're suspended between heaven and hell, -// (Or more likely between the Host and Guest) -// When in it comes! We are dazed and confused -// So we do the simplest thing which one can. -// Though we've pushed the trap number and zero -// We discard them, return, and hope we live. + IRQ_STUBS 0 1 return_to_host /* First two traps */ + IRQ_STUB 2 handle_nmi /* NMI */ + IRQ_STUBS 3 31 return_to_host /* Rest of traps */ + IRQ_STUBS 32 127 deliver_to_host /* Real interrupts */ + IRQ_STUB 128 return_to_host /* System call (overridden) */ + IRQ_STUBS 129 255 deliver_to_host /* Other real interrupts */ + +/* We ignore NMI and return. */ handle_nmi: addl $8, %esp iret -// We are done; all that's left is Mastery -// And "make Mastery" is a journey long -// Designed to make your fingers itch to code. - -// Here ends the text, the file and poem. ENTRY(end_switcher_text) diff --git a/trunk/drivers/media/video/Kconfig b/trunk/drivers/media/video/Kconfig index e204e7b4028a..9dcbffd0aa15 100644 --- a/trunk/drivers/media/video/Kconfig +++ b/trunk/drivers/media/video/Kconfig @@ -509,7 +509,7 @@ config VIDEO_VINO config VIDEO_STRADIS tristate "Stradis 4:2:2 MPEG-2 video driver (EXPERIMENTAL)" - depends on EXPERIMENTAL && PCI && VIDEO_V4L1 && VIRT_TO_BUS + depends on EXPERIMENTAL && PCI && VIDEO_V4L1 && !PPC64 help Say Y here to enable support for the Stradis 4:2:2 MPEG-2 video driver for PCI. There is a product page at @@ -520,7 +520,7 @@ config VIDEO_ZORAN_ZR36060 config VIDEO_ZORAN tristate "Zoran ZR36057/36067 Video For Linux" - depends on PCI && I2C_ALGOBIT && VIDEO_V4L1 && VIRT_TO_BUS + depends on PCI && I2C_ALGOBIT && VIDEO_V4L1 && !PPC64 help Say Y for support for MJPEG capture cards based on the Zoran 36057/36067 PCI controller chipset. This includes the Iomega diff --git a/trunk/drivers/mtd/maps/Kconfig b/trunk/drivers/mtd/maps/Kconfig index cc6c73442435..f88ebc5b685e 100644 --- a/trunk/drivers/mtd/maps/Kconfig +++ b/trunk/drivers/mtd/maps/Kconfig @@ -103,7 +103,7 @@ config MTD_PMC_MSP_RAMROOT config MTD_SUN_UFLASH tristate "Sun Microsystems userflash support" - depends on SPARC && MTD_CFI && PCI + depends on SPARC && MTD_CFI help This provides a 'mapping' driver which supports the way in which user-programmable flash chips are connected on various diff --git a/trunk/drivers/net/ax88796.c b/trunk/drivers/net/ax88796.c index e43e8047b90e..1d882360b34d 100644 --- a/trunk/drivers/net/ax88796.c +++ b/trunk/drivers/net/ax88796.c @@ -819,7 +819,7 @@ static int ax_probe(struct platform_device *pdev) } ei_status.mem = ioremap(res->start, size); - dev->base_addr = (unsigned long)ei_status.mem; + dev->base_addr = (long)ei_status.mem; if (ei_status.mem == NULL) { dev_err(&pdev->dev, "Cannot ioremap area (%08zx,%08zx)\n", diff --git a/trunk/drivers/net/cxgb3/cxgb3_offload.c b/trunk/drivers/net/cxgb3/cxgb3_offload.c index e620ed4c3ff0..ebcf35e4cf5b 100644 --- a/trunk/drivers/net/cxgb3/cxgb3_offload.c +++ b/trunk/drivers/net/cxgb3/cxgb3_offload.c @@ -699,7 +699,7 @@ static int do_cr(struct t3cdev *dev, struct sk_buff *skb) * the buffer. */ static struct sk_buff *cxgb3_get_cpl_reply_skb(struct sk_buff *skb, size_t len, - gfp_t gfp) + int gfp) { if (likely(!skb_cloned(skb))) { BUG_ON(skb->len < len); diff --git a/trunk/drivers/net/lguest_net.c b/trunk/drivers/net/lguest_net.c index cab57911a80e..112778652f7d 100644 --- a/trunk/drivers/net/lguest_net.c +++ b/trunk/drivers/net/lguest_net.c @@ -1,13 +1,6 @@ -/*D:500 - * The Guest network driver. +/* A simple network driver for lguest. * - * This is very simple a virtual network driver, and our last Guest driver. - * The only trick is that it can talk directly to multiple other recipients - * (ie. other Guests on the same network). It can also be used with only the - * Host on the network. - :*/ - -/* Copyright 2006 Rusty Russell IBM Corporation + * Copyright 2006 Rusty Russell IBM Corporation * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -35,47 +28,23 @@ #define MAX_LANS 4 #define NUM_SKBS 8 -/*M:011 Network code master Jeff Garzik points out numerous shortcomings in - * this driver if it aspires to greatness. - * - * Firstly, it doesn't use "NAPI": the networking's New API, and is poorer for - * it. As he says "NAPI means system-wide load leveling, across multiple - * network interfaces. Lack of NAPI can mean competition at higher loads." - * - * He also points out that we don't implement set_mac_address, so users cannot - * change the devices hardware address. When I asked why one would want to: - * "Bonding, and situations where you /do/ want the MAC address to "leak" out - * of the host onto the wider net." - * - * Finally, he would like module unloading: "It is not unrealistic to think of - * [un|re|]loading the net support module in an lguest guest. And, adding - * module support makes the programmer more responsible, because they now have - * to learn to clean up after themselves. Any driver that cannot clean up - * after itself is an incomplete driver in my book." - :*/ - -/*D:530 The "struct lguestnet_info" contains all the information we need to - * know about the network device. */ struct lguestnet_info { - /* The mapped device page(s) (an array of "struct lguest_net"). */ + /* The shared page(s). */ struct lguest_net *peer; - /* The physical address of the device page(s) */ unsigned long peer_phys; - /* The size of the device page(s). */ unsigned long mapsize; /* The lguest_device I come from */ struct lguest_device *lgdev; - /* My peerid (ie. my slot in the array). */ + /* My peerid. */ unsigned int me; - /* Receive queue: the network packets waiting to be filled. */ + /* Receive queue. */ struct sk_buff *skb[NUM_SKBS]; struct lguest_dma dma[NUM_SKBS]; }; -/*:*/ /* How many bytes left in this page. */ static unsigned int rest_of_page(void *data) @@ -83,82 +52,39 @@ static unsigned int rest_of_page(void *data) return PAGE_SIZE - ((unsigned long)data % PAGE_SIZE); } -/*D:570 Each peer (ie. Guest or Host) on the network binds their receive - * buffers to a different key: we simply use the physical address of the - * device's memory page plus the peer number. The Host insists that all keys - * be a multiple of 4, so we multiply the peer number by 4. */ +/* Simple convention: offset 4 * peernum. */ static unsigned long peer_key(struct lguestnet_info *info, unsigned peernum) { return info->peer_phys + 4 * peernum; } -/* This is the routine which sets up a "struct lguest_dma" to point to a - * network packet, similar to req_to_dma() in lguest_blk.c. The structure of a - * "struct sk_buff" has grown complex over the years: it consists of a "head" - * linear section pointed to by "skb->data", and possibly an array of - * "fragments" in the case of a non-linear packet. - * - * Our receive buffers don't use fragments at all but outgoing skbs might, so - * we handle it. */ static void skb_to_dma(const struct sk_buff *skb, unsigned int headlen, struct lguest_dma *dma) { unsigned int i, seg; - /* First, we put the linear region into the "struct lguest_dma". Each - * entry can't go over a page boundary, so even though all our packets - * are 1514 bytes or less, we might need to use two entries here: */ for (i = seg = 0; i < headlen; seg++, i += rest_of_page(skb->data+i)) { dma->addr[seg] = virt_to_phys(skb->data + i); dma->len[seg] = min((unsigned)(headlen - i), rest_of_page(skb->data + i)); } - - /* Now we handle the fragments: at least they're guaranteed not to go - * over a page. skb_shinfo(skb) returns a pointer to the structure - * which tells us about the number of fragments and the fragment - * array. */ for (i = 0; i < skb_shinfo(skb)->nr_frags; i++, seg++) { const skb_frag_t *f = &skb_shinfo(skb)->frags[i]; /* Should not happen with MTU less than 64k - 2 * PAGE_SIZE. */ if (seg == LGUEST_MAX_DMA_SECTIONS) { - /* We will end up sending a truncated packet should - * this ever happen. Plus, a cool log message! */ printk("Woah dude! Megapacket!\n"); break; } dma->addr[seg] = page_to_phys(f->page) + f->page_offset; dma->len[seg] = f->size; } - - /* If after all that we didn't use the entire "struct lguest_dma" - * array, we terminate it with a 0 length. */ if (seg < LGUEST_MAX_DMA_SECTIONS) dma->len[seg] = 0; } -/* - * Packet transmission. - * - * Our packet transmission is a little unusual. A real network card would just - * send out the packet and leave the receivers to decide if they're interested. - * Instead, we look through the network device memory page and see if any of - * the ethernet addresses match the packet destination, and if so we send it to - * that Guest. - * - * This is made a little more complicated in two cases. The first case is - * broadcast packets: for that we send the packet to all Guests on the network, - * one at a time. The second case is "promiscuous" mode, where a Guest wants - * to see all the packets on the network. We need a way for the Guest to tell - * us it wants to see all packets, so it sets the "multicast" bit on its - * published MAC address, which is never valid in a real ethernet address. - */ +/* We overload multicast bit to show promiscuous mode. */ #define PROMISC_BIT 0x01 -/* This is the callback which is summoned whenever the network device's - * multicast or promiscuous state changes. If the card is in promiscuous mode, - * we advertise that in our ethernet address in the device's memory. We do the - * same if Linux wants any or all multicast traffic. */ static void lguestnet_set_multicast(struct net_device *dev) { struct lguestnet_info *info = netdev_priv(dev); @@ -169,14 +95,11 @@ static void lguestnet_set_multicast(struct net_device *dev) info->peer[info->me].mac[0] &= ~PROMISC_BIT; } -/* A simple test function to see if a peer wants to see all packets.*/ static int promisc(struct lguestnet_info *info, unsigned int peer) { return info->peer[peer].mac[0] & PROMISC_BIT; } -/* Another simple function to see if a peer's advertised ethernet address - * matches a packet's destination ethernet address. */ static int mac_eq(const unsigned char mac[ETH_ALEN], struct lguestnet_info *info, unsigned int peer) { @@ -186,8 +109,6 @@ static int mac_eq(const unsigned char mac[ETH_ALEN], return memcmp(mac+1, info->peer[peer].mac+1, ETH_ALEN-1) == 0; } -/* This is the function which actually sends a packet once we've decided a - * peer wants it: */ static void transfer_packet(struct net_device *dev, struct sk_buff *skb, unsigned int peernum) @@ -195,134 +116,76 @@ static void transfer_packet(struct net_device *dev, struct lguestnet_info *info = netdev_priv(dev); struct lguest_dma dma; - /* We use our handy "struct lguest_dma" packing function to prepare - * the skb for sending. */ skb_to_dma(skb, skb_headlen(skb), &dma); pr_debug("xfer length %04x (%u)\n", htons(skb->len), skb->len); - /* This is the actual send call which copies the packet. */ lguest_send_dma(peer_key(info, peernum), &dma); - - /* Check that the entire packet was transmitted. If not, it could mean - * that the other Guest registered a short receive buffer, but this - * driver should never do that. More likely, the peer is dead. */ if (dma.used_len != skb->len) { dev->stats.tx_carrier_errors++; pr_debug("Bad xfer to peer %i: %i of %i (dma %p/%i)\n", peernum, dma.used_len, skb->len, (void *)dma.addr[0], dma.len[0]); } else { - /* On success we update the stats. */ dev->stats.tx_bytes += skb->len; dev->stats.tx_packets++; } } -/* Another helper function to tell is if a slot in the device memory is unused. - * Since we always set the Local Assignment bit in the ethernet address, the - * first byte can never be 0. */ static int unused_peer(const struct lguest_net peer[], unsigned int num) { return peer[num].mac[0] == 0; } -/* Finally, here is the routine which handles an outgoing packet. It's called - * "start_xmit" for traditional reasons. */ static int lguestnet_start_xmit(struct sk_buff *skb, struct net_device *dev) { unsigned int i; int broadcast; struct lguestnet_info *info = netdev_priv(dev); - /* Extract the destination ethernet address from the packet. */ const unsigned char *dest = ((struct ethhdr *)skb->data)->h_dest; pr_debug("%s: xmit %02x:%02x:%02x:%02x:%02x:%02x\n", dev->name, dest[0],dest[1],dest[2],dest[3],dest[4],dest[5]); - /* If it's a multicast packet, we broadcast to everyone. That's not - * very efficient, but there are very few applications which actually - * use multicast, which is a shame really. - * - * As etherdevice.h points out: "By definition the broadcast address is - * also a multicast address." So we don't have to test for broadcast - * packets separately. */ broadcast = is_multicast_ether_addr(dest); - - /* Look through all the published ethernet addresses to see if we - * should send this packet. */ for (i = 0; i < info->mapsize/sizeof(struct lguest_net); i++) { - /* We don't send to ourselves (we actually can't SEND_DMA to - * ourselves anyway), and don't send to unused slots.*/ if (i == info->me || unused_peer(info->peer, i)) continue; - /* If it's broadcast we send it. If they want every packet we - * send it. If the destination matches their address we send - * it. Otherwise we go to the next peer. */ if (!broadcast && !promisc(info, i) && !mac_eq(dest, info, i)) continue; pr_debug("lguestnet %s: sending from %i to %i\n", dev->name, info->me, i); - /* Our routine which actually does the transfer. */ transfer_packet(dev, skb, i); } - - /* An xmit routine is expected to dispose of the packet, so we do. */ dev_kfree_skb(skb); - - /* As per kernel convention, 0 means success. This is why I love - * networking: even if we never sent to anyone, that's still - * success! */ return 0; } -/*D:560 - * Packet receiving. - * - * First, here's a helper routine which fills one of our array of receive - * buffers: */ +/* Find a new skb to put in this slot in shared mem. */ static int fill_slot(struct net_device *dev, unsigned int slot) { struct lguestnet_info *info = netdev_priv(dev); - - /* We can receive ETH_DATA_LEN (1500) byte packets, plus a standard - * ethernet header of ETH_HLEN (14) bytes. */ + /* Try to create and register a new one. */ info->skb[slot] = netdev_alloc_skb(dev, ETH_HLEN + ETH_DATA_LEN); if (!info->skb[slot]) { printk("%s: could not fill slot %i\n", dev->name, slot); return -ENOMEM; } - /* skb_to_dma() is a helper which sets up the "struct lguest_dma" to - * point to the data in the skb: we also use it for sending out a - * packet. */ skb_to_dma(info->skb[slot], ETH_HLEN + ETH_DATA_LEN, &info->dma[slot]); - - /* This is a Write Memory Barrier: it ensures that the entry in the - * receive buffer array is written *before* we set the "used_len" entry - * to 0. If the Host were looking at the receive buffer array from a - * different CPU, it could potentially see "used_len = 0" and not see - * the updated receive buffer information. This would be a horribly - * nasty bug, so make sure the compiler and CPU know this has to happen - * first. */ wmb(); - /* Writing 0 to "used_len" tells the Host it can use this receive - * buffer now. */ + /* Now we tell hypervisor it can use the slot. */ info->dma[slot].used_len = 0; return 0; } -/* This is the actual receive routine. When we receive an interrupt from the - * Host to tell us a packet has been delivered, we arrive here: */ static irqreturn_t lguestnet_rcv(int irq, void *dev_id) { struct net_device *dev = dev_id; struct lguestnet_info *info = netdev_priv(dev); unsigned int i, done = 0; - /* Look through our entire receive array for an entry which has data - * in it. */ for (i = 0; i < ARRAY_SIZE(info->dma); i++) { unsigned int length; struct sk_buff *skb; @@ -331,16 +194,10 @@ static irqreturn_t lguestnet_rcv(int irq, void *dev_id) if (length == 0) continue; - /* We've found one! Remember the skb (we grabbed the length - * above), and immediately refill the slot we've taken it - * from. */ done++; skb = info->skb[i]; fill_slot(dev, i); - /* This shouldn't happen: micropackets could be sent by a - * badly-behaved Guest on the network, but the Host will never - * stuff more data in the buffer than the buffer length. */ if (length < ETH_HLEN || length > ETH_HLEN + ETH_DATA_LEN) { pr_debug(KERN_WARNING "%s: unbelievable skb len: %i\n", dev->name, length); @@ -348,72 +205,36 @@ static irqreturn_t lguestnet_rcv(int irq, void *dev_id) continue; } - /* skb_put(), what a great function! I've ranted about this - * function before (http://lkml.org/lkml/1999/9/26/24). You - * call it after you've added data to the end of an skb (in - * this case, it was the Host which wrote the data). */ skb_put(skb, length); - - /* The ethernet header contains a protocol field: we use the - * standard helper to extract it, and place the result in - * skb->protocol. The helper also sets up skb->pkt_type and - * eats up the ethernet header from the front of the packet. */ skb->protocol = eth_type_trans(skb, dev); - - /* If this device doesn't need checksums for sending, we also - * don't need to check the packets when they come in. */ + /* This is a reliable transport. */ if (dev->features & NETIF_F_NO_CSUM) skb->ip_summed = CHECKSUM_UNNECESSARY; - - /* As a last resort for debugging the driver or the lguest I/O - * subsystem, you can uncomment the "#define DEBUG" at the top - * of this file, which turns all the pr_debug() into printk() - * and floods the logs. */ pr_debug("Receiving skb proto 0x%04x len %i type %i\n", ntohs(skb->protocol), skb->len, skb->pkt_type); - /* Update the packet and byte counts (visible from ifconfig, - * and good for debugging). */ dev->stats.rx_bytes += skb->len; dev->stats.rx_packets++; - - /* Hand our fresh network packet into the stack's "network - * interface receive" routine. That will free the packet - * itself when it's finished. */ netif_rx(skb); } - - /* If we found any packets, we assume the interrupt was for us. */ return done ? IRQ_HANDLED : IRQ_NONE; } -/*D:550 This is where we start: when the device is brought up by dhcpd or - * ifconfig. At this point we advertise our MAC address to the rest of the - * network, and register receive buffers ready for incoming packets. */ static int lguestnet_open(struct net_device *dev) { int i; struct lguestnet_info *info = netdev_priv(dev); - /* Copy our MAC address into the device page, so others on the network - * can find us. */ + /* Set up our MAC address */ memcpy(info->peer[info->me].mac, dev->dev_addr, ETH_ALEN); - /* We might already be in promisc mode (dev->flags & IFF_PROMISC). Our - * set_multicast callback handles this already, so we call it now. */ + /* Turn on promisc mode if needed */ lguestnet_set_multicast(dev); - /* Allocate packets and put them into our "struct lguest_dma" array. - * If we fail to allocate all the packets we could still limp along, - * but it's a sign of real stress so we should probably give up now. */ for (i = 0; i < ARRAY_SIZE(info->dma); i++) { if (fill_slot(dev, i) != 0) goto cleanup; } - - /* Finally we tell the Host where our array of "struct lguest_dma" - * receive buffers is, binding it to the key corresponding to the - * device's physical memory plus our peerid. */ if (lguest_bind_dma(peer_key(info,info->me), info->dma, NUM_SKBS, lgdev_irq(info->lgdev)) != 0) goto cleanup; @@ -424,29 +245,22 @@ static int lguestnet_open(struct net_device *dev) dev_kfree_skb(info->skb[i]); return -ENOMEM; } -/*:*/ -/* The close routine is called when the device is no longer in use: we clean up - * elegantly. */ static int lguestnet_close(struct net_device *dev) { unsigned int i; struct lguestnet_info *info = netdev_priv(dev); - /* Clear all trace of our existence out of the device memory by setting - * the slot which held our MAC address to 0 (unused). */ + /* Clear all trace: others might deliver packets, we'll ignore it. */ memset(&info->peer[info->me], 0, sizeof(info->peer[info->me])); - /* Unregister our array of receive buffers */ + /* Deregister sg lists. */ lguest_unbind_dma(peer_key(info, info->me), info->dma); for (i = 0; i < ARRAY_SIZE(info->dma); i++) dev_kfree_skb(info->skb[i]); return 0; } -/*D:510 The network device probe function is basically a standard ethernet - * device setup. It reads the "struct lguest_device_desc" and sets the "struct - * net_device". Oh, the line-by-line excitement! Let's skip over it. :*/ static int lguestnet_probe(struct lguest_device *lgdev) { int err, irqf = IRQF_SHARED; @@ -476,16 +290,10 @@ static int lguestnet_probe(struct lguest_device *lgdev) dev->stop = lguestnet_close; dev->hard_start_xmit = lguestnet_start_xmit; - /* We don't actually support multicast yet, but turning on/off - * promisc also calls dev->set_multicast_list. */ + /* Turning on/off promisc will call dev->set_multicast_list. + * We don't actually support multicast yet */ dev->set_multicast_list = lguestnet_set_multicast; SET_NETDEV_DEV(dev, &lgdev->dev); - - /* The network code complains if you have "scatter-gather" capability - * if you don't also handle checksums (it seem that would be - * "illogical"). So we use a lie of omission and don't tell it that we - * can handle scattered packets unless we also don't want checksums, - * even though to us they're completely independent. */ if (desc->features & LGUEST_NET_F_NOCSUM) dev->features = NETIF_F_SG|NETIF_F_NO_CSUM; @@ -517,9 +325,6 @@ static int lguestnet_probe(struct lguest_device *lgdev) } pr_debug("lguestnet: registered device %s\n", dev->name); - /* Finally, we put the "struct net_device" in the generic "struct - * lguest_device"s private pointer. Again, it's not necessary, but - * makes sure the cool kernel kids don't tease us. */ lgdev->private = dev; return 0; @@ -547,11 +352,3 @@ module_init(lguestnet_init); MODULE_DESCRIPTION("Lguest network driver"); MODULE_LICENSE("GPL"); - -/*D:580 - * This is the last of the Drivers, and with this we have covered the many and - * wonderous and fine (and boring) details of the Guest. - * - * "make Launcher" beckons, where we answer questions like "Where do Guests - * come from?", and "What do you do when someone asks for optimization?" - */ diff --git a/trunk/drivers/net/lib8390.c b/trunk/drivers/net/lib8390.c index 721ee38d2241..5c86e737f954 100644 --- a/trunk/drivers/net/lib8390.c +++ b/trunk/drivers/net/lib8390.c @@ -219,6 +219,15 @@ static void ei_tx_timeout(struct net_device *dev) int txsr, isr, tickssofar = jiffies - dev->trans_start; unsigned long flags; +#if defined(CONFIG_M32R) && defined(CONFIG_SMP) + unsigned long icucr; + + local_irq_save(flags); + icucr = inl(M32R_ICU_CR1_PORTL); + icucr |= M32R_ICUCR_ISMOD11; + outl(icucr, M32R_ICU_CR1_PORTL); + local_irq_restore(flags); +#endif ei_local->stat.tx_errors++; spin_lock_irqsave(&ei_local->page_lock, flags); diff --git a/trunk/drivers/net/pppol2tp.c b/trunk/drivers/net/pppol2tp.c index 266e8b38fe10..f87176055d0e 100644 --- a/trunk/drivers/net/pppol2tp.c +++ b/trunk/drivers/net/pppol2tp.c @@ -2054,7 +2054,7 @@ static int pppol2tp_setsockopt(struct socket *sock, int level, int optname, */ static int pppol2tp_tunnel_getsockopt(struct sock *sk, struct pppol2tp_tunnel *tunnel, - int optname, int *val) + int optname, int __user *val) { int err = 0; @@ -2077,7 +2077,7 @@ static int pppol2tp_tunnel_getsockopt(struct sock *sk, */ static int pppol2tp_session_getsockopt(struct sock *sk, struct pppol2tp_session *session, - int optname, int *val) + int optname, int __user *val) { int err = 0; diff --git a/trunk/drivers/pnp/card.c b/trunk/drivers/pnp/card.c index b6a4f02b01d1..dd6384b1efce 100644 --- a/trunk/drivers/pnp/card.c +++ b/trunk/drivers/pnp/card.c @@ -2,6 +2,7 @@ * card.c - contains functions for managing groups of PnP devices * * Copyright 2002 Adam Belay + * */ #include @@ -12,31 +13,26 @@ LIST_HEAD(pnp_cards); static LIST_HEAD(pnp_card_drivers); -static const struct pnp_card_device_id *match_card(struct pnp_card_driver *drv, - struct pnp_card *card) -{ - const struct pnp_card_device_id *drv_id = drv->id_table; - while (*drv_id->id) { - if (compare_pnp_id(card->id, drv_id->id)) { +static const struct pnp_card_device_id * match_card(struct pnp_card_driver * drv, struct pnp_card * card) +{ + const struct pnp_card_device_id * drv_id = drv->id_table; + while (*drv_id->id){ + if (compare_pnp_id(card->id,drv_id->id)) { int i = 0; - for (;;) { int found; struct pnp_dev *dev; - - if (i == PNP_MAX_DEVICES - || !*drv_id->devs[i].id) + if (i == PNP_MAX_DEVICES || ! *drv_id->devs[i].id) return drv_id; found = 0; card_for_each_dev(card, dev) { - if (compare_pnp_id - (dev->id, drv_id->devs[i].id)) { + if (compare_pnp_id(dev->id, drv_id->devs[i].id)) { found = 1; break; } } - if (!found) + if (! found) break; i++; } @@ -46,15 +42,14 @@ static const struct pnp_card_device_id *match_card(struct pnp_card_driver *drv, return NULL; } -static void card_remove(struct pnp_dev *dev) +static void card_remove(struct pnp_dev * dev) { dev->card_link = NULL; } -static void card_remove_first(struct pnp_dev *dev) +static void card_remove_first(struct pnp_dev * dev) { - struct pnp_card_driver *drv = to_pnp_card_driver(dev->driver); - + struct pnp_card_driver * drv = to_pnp_card_driver(dev->driver); if (!dev->card || !drv) return; if (drv->remove) @@ -72,7 +67,7 @@ static int card_probe(struct pnp_card *card, struct pnp_card_driver *drv) if (!drv->probe) return 0; - id = match_card(drv, card); + id = match_card(drv,card); if (!id) return 0; @@ -99,11 +94,12 @@ static int card_probe(struct pnp_card *card, struct pnp_card_driver *drv) * pnp_add_card_id - adds an EISA id to the specified card * @id: pointer to a pnp_id structure * @card: pointer to the desired card + * */ -int pnp_add_card_id(struct pnp_id *id, struct pnp_card *card) -{ - struct pnp_id *ptr; +int pnp_add_card_id(struct pnp_id *id, struct pnp_card * card) +{ + struct pnp_id * ptr; if (!id) return -EINVAL; if (!card) @@ -119,11 +115,10 @@ int pnp_add_card_id(struct pnp_id *id, struct pnp_card *card) return 0; } -static void pnp_free_card_ids(struct pnp_card *card) +static void pnp_free_card_ids(struct pnp_card * card) { - struct pnp_id *id; + struct pnp_id * id; struct pnp_id *next; - if (!card) return; id = card->id; @@ -136,55 +131,49 @@ static void pnp_free_card_ids(struct pnp_card *card) static void pnp_release_card(struct device *dmdev) { - struct pnp_card *card = to_pnp_card(dmdev); - + struct pnp_card * card = to_pnp_card(dmdev); pnp_free_card_ids(card); kfree(card); } -static ssize_t pnp_show_card_name(struct device *dmdev, - struct device_attribute *attr, char *buf) + +static ssize_t pnp_show_card_name(struct device *dmdev, struct device_attribute *attr, char *buf) { char *str = buf; struct pnp_card *card = to_pnp_card(dmdev); - - str += sprintf(str, "%s\n", card->name); + str += sprintf(str,"%s\n", card->name); return (str - buf); } -static DEVICE_ATTR(name, S_IRUGO, pnp_show_card_name, NULL); +static DEVICE_ATTR(name,S_IRUGO,pnp_show_card_name,NULL); -static ssize_t pnp_show_card_ids(struct device *dmdev, - struct device_attribute *attr, char *buf) +static ssize_t pnp_show_card_ids(struct device *dmdev, struct device_attribute *attr, char *buf) { char *str = buf; struct pnp_card *card = to_pnp_card(dmdev); - struct pnp_id *pos = card->id; + struct pnp_id * pos = card->id; while (pos) { - str += sprintf(str, "%s\n", pos->id); + str += sprintf(str,"%s\n", pos->id); pos = pos->next; } return (str - buf); } -static DEVICE_ATTR(card_id, S_IRUGO, pnp_show_card_ids, NULL); +static DEVICE_ATTR(card_id,S_IRUGO,pnp_show_card_ids,NULL); static int pnp_interface_attach_card(struct pnp_card *card) { - int rc = device_create_file(&card->dev, &dev_attr_name); + int rc = device_create_file(&card->dev,&dev_attr_name); + if (rc) return rc; - if (rc) - return rc; - - rc = device_create_file(&card->dev, &dev_attr_card_id); - if (rc) - goto err_name; + rc = device_create_file(&card->dev,&dev_attr_card_id); + if (rc) goto err_name; return 0; - err_name: - device_remove_file(&card->dev, &dev_attr_name); +err_name: + device_remove_file(&card->dev,&dev_attr_name); return rc; } @@ -192,16 +181,15 @@ static int pnp_interface_attach_card(struct pnp_card *card) * pnp_add_card - adds a PnP card to the PnP Layer * @card: pointer to the card to add */ -int pnp_add_card(struct pnp_card *card) + +int pnp_add_card(struct pnp_card * card) { int error; - struct list_head *pos, *temp; - + struct list_head * pos, * temp; if (!card || !card->protocol) return -EINVAL; - sprintf(card->dev.bus_id, "%02x:%02x", card->protocol->number, - card->number); + sprintf(card->dev.bus_id, "%02x:%02x", card->protocol->number, card->number); card->dev.parent = &card->protocol->dev; card->dev.bus = NULL; card->dev.release = &pnp_release_card; @@ -217,21 +205,18 @@ int pnp_add_card(struct pnp_card *card) /* we wait until now to add devices in order to ensure the drivers * will be able to use all of the related devices on the card * without waiting any unresonable length of time */ - list_for_each(pos, &card->devices) { + list_for_each(pos,&card->devices){ struct pnp_dev *dev = card_to_pnp_dev(pos); __pnp_add_device(dev); } /* match with card drivers */ - list_for_each_safe(pos, temp, &pnp_card_drivers) { - struct pnp_card_driver *drv = - list_entry(pos, struct pnp_card_driver, - global_list); - card_probe(card, drv); + list_for_each_safe(pos,temp,&pnp_card_drivers){ + struct pnp_card_driver * drv = list_entry(pos, struct pnp_card_driver, global_list); + card_probe(card,drv); } } else - pnp_err("sysfs failure, card '%s' will be unavailable", - card->dev.bus_id); + pnp_err("sysfs failure, card '%s' will be unavailable", card->dev.bus_id); return error; } @@ -239,10 +224,10 @@ int pnp_add_card(struct pnp_card *card) * pnp_remove_card - removes a PnP card from the PnP Layer * @card: pointer to the card to remove */ -void pnp_remove_card(struct pnp_card *card) + +void pnp_remove_card(struct pnp_card * card) { struct list_head *pos, *temp; - if (!card) return; device_unregister(&card->dev); @@ -250,7 +235,7 @@ void pnp_remove_card(struct pnp_card *card) list_del(&card->global_list); list_del(&card->protocol_list); spin_unlock(&pnp_lock); - list_for_each_safe(pos, temp, &card->devices) { + list_for_each_safe(pos,temp,&card->devices){ struct pnp_dev *dev = card_to_pnp_dev(pos); pnp_remove_card_device(dev); } @@ -261,14 +246,15 @@ void pnp_remove_card(struct pnp_card *card) * @card: pointer to the card to add to * @dev: pointer to the device to add */ -int pnp_add_card_device(struct pnp_card *card, struct pnp_dev *dev) + +int pnp_add_card_device(struct pnp_card * card, struct pnp_dev * dev) { if (!card || !dev || !dev->protocol) return -EINVAL; dev->dev.parent = &card->dev; dev->card_link = NULL; - snprintf(dev->dev.bus_id, BUS_ID_SIZE, "%02x:%02x.%02x", - dev->protocol->number, card->number, dev->number); + snprintf(dev->dev.bus_id, BUS_ID_SIZE, "%02x:%02x.%02x", dev->protocol->number, + card->number,dev->number); spin_lock(&pnp_lock); dev->card = card; list_add_tail(&dev->card_list, &card->devices); @@ -280,7 +266,8 @@ int pnp_add_card_device(struct pnp_card *card, struct pnp_dev *dev) * pnp_remove_card_device- removes a device from the specified card * @dev: pointer to the device to remove */ -void pnp_remove_card_device(struct pnp_dev *dev) + +void pnp_remove_card_device(struct pnp_dev * dev) { spin_lock(&pnp_lock); dev->card = NULL; @@ -295,14 +282,13 @@ void pnp_remove_card_device(struct pnp_dev *dev) * @id: pointer to a PnP ID structure that explains the rules for finding the device * @from: Starting place to search from. If NULL it will start from the begining. */ -struct pnp_dev *pnp_request_card_device(struct pnp_card_link *clink, - const char *id, struct pnp_dev *from) -{ - struct list_head *pos; - struct pnp_dev *dev; - struct pnp_card_driver *drv; - struct pnp_card *card; +struct pnp_dev * pnp_request_card_device(struct pnp_card_link *clink, const char * id, struct pnp_dev * from) +{ + struct list_head * pos; + struct pnp_dev * dev; + struct pnp_card_driver * drv; + struct pnp_card * card; if (!clink || !id) goto done; card = clink->card; @@ -316,15 +302,15 @@ struct pnp_dev *pnp_request_card_device(struct pnp_card_link *clink, } while (pos != &card->devices) { dev = card_to_pnp_dev(pos); - if ((!dev->card_link) && compare_pnp_id(dev->id, id)) + if ((!dev->card_link) && compare_pnp_id(dev->id,id)) goto found; pos = pos->next; } - done: +done: return NULL; - found: +found: dev->card_link = clink; dev->dev.driver = &drv->link.driver; if (pnp_bus_type.probe(&dev->dev)) @@ -334,7 +320,7 @@ struct pnp_dev *pnp_request_card_device(struct pnp_card_link *clink, return dev; - err_out: +err_out: dev->dev.driver = NULL; dev->card_link = NULL; return NULL; @@ -344,10 +330,10 @@ struct pnp_dev *pnp_request_card_device(struct pnp_card_link *clink, * pnp_release_card_device - call this when the driver no longer needs the device * @dev: pointer to the PnP device stucture */ -void pnp_release_card_device(struct pnp_dev *dev) -{ - struct pnp_card_driver *drv = dev->card_link->driver; +void pnp_release_card_device(struct pnp_dev * dev) +{ + struct pnp_card_driver * drv = dev->card_link->driver; if (!drv) return; drv->link.remove = &card_remove; @@ -361,7 +347,6 @@ void pnp_release_card_device(struct pnp_dev *dev) static int card_suspend(struct pnp_dev *dev, pm_message_t state) { struct pnp_card_link *link = dev->card_link; - if (link->pm_state.event == state.event) return 0; link->pm_state = state; @@ -371,7 +356,6 @@ static int card_suspend(struct pnp_dev *dev, pm_message_t state) static int card_resume(struct pnp_dev *dev) { struct pnp_card_link *link = dev->card_link; - if (link->pm_state.event == PM_EVENT_ON) return 0; link->pm_state = PMSG_ON; @@ -383,7 +367,8 @@ static int card_resume(struct pnp_dev *dev) * pnp_register_card_driver - registers a PnP card driver with the PnP Layer * @drv: pointer to the driver to register */ -int pnp_register_card_driver(struct pnp_card_driver *drv) + +int pnp_register_card_driver(struct pnp_card_driver * drv) { int error; struct list_head *pos, *temp; @@ -404,10 +389,9 @@ int pnp_register_card_driver(struct pnp_card_driver *drv) list_add_tail(&drv->global_list, &pnp_card_drivers); spin_unlock(&pnp_lock); - list_for_each_safe(pos, temp, &pnp_cards) { - struct pnp_card *card = - list_entry(pos, struct pnp_card, global_list); - card_probe(card, drv); + list_for_each_safe(pos,temp,&pnp_cards){ + struct pnp_card *card = list_entry(pos, struct pnp_card, global_list); + card_probe(card,drv); } return 0; } @@ -416,7 +400,8 @@ int pnp_register_card_driver(struct pnp_card_driver *drv) * pnp_unregister_card_driver - unregisters a PnP card driver from the PnP Layer * @drv: pointer to the driver to unregister */ -void pnp_unregister_card_driver(struct pnp_card_driver *drv) + +void pnp_unregister_card_driver(struct pnp_card_driver * drv) { spin_lock(&pnp_lock); list_del(&drv->global_list); @@ -424,6 +409,13 @@ void pnp_unregister_card_driver(struct pnp_card_driver *drv) pnp_unregister_driver(&drv->link); } +#if 0 +EXPORT_SYMBOL(pnp_add_card); +EXPORT_SYMBOL(pnp_remove_card); +EXPORT_SYMBOL(pnp_add_card_device); +EXPORT_SYMBOL(pnp_remove_card_device); +EXPORT_SYMBOL(pnp_add_card_id); +#endif /* 0 */ EXPORT_SYMBOL(pnp_request_card_device); EXPORT_SYMBOL(pnp_release_card_device); EXPORT_SYMBOL(pnp_register_card_driver); diff --git a/trunk/drivers/pnp/core.c b/trunk/drivers/pnp/core.c index 61066fdb9e6d..8e7b2dd38810 100644 --- a/trunk/drivers/pnp/core.c +++ b/trunk/drivers/pnp/core.c @@ -2,6 +2,7 @@ * core.c - contains all core device and protocol registration functions * * Copyright 2002 Adam Belay + * */ #include @@ -17,6 +18,7 @@ #include "base.h" + static LIST_HEAD(pnp_protocols); LIST_HEAD(pnp_global); DEFINE_SPINLOCK(pnp_lock); @@ -34,7 +36,7 @@ void *pnp_alloc(long size) void *result; result = kzalloc(size, GFP_KERNEL); - if (!result) { + if (!result){ printk(KERN_ERR "pnp: Out of Memory\n"); return NULL; } @@ -47,10 +49,11 @@ void *pnp_alloc(long size) * * Ex protocols: ISAPNP, PNPBIOS, etc */ + int pnp_register_protocol(struct pnp_protocol *protocol) { int nodenum; - struct list_head *pos; + struct list_head * pos; if (!protocol) return -EINVAL; @@ -61,9 +64,9 @@ int pnp_register_protocol(struct pnp_protocol *protocol) spin_lock(&pnp_lock); /* assign the lowest unused number */ - list_for_each(pos, &pnp_protocols) { - struct pnp_protocol *cur = to_pnp_protocol(pos); - if (cur->number == nodenum) { + list_for_each(pos,&pnp_protocols) { + struct pnp_protocol * cur = to_pnp_protocol(pos); + if (cur->number == nodenum){ pos = &pnp_protocols; nodenum++; } @@ -80,6 +83,7 @@ int pnp_register_protocol(struct pnp_protocol *protocol) /** * pnp_protocol_unregister - removes a pnp protocol from the pnp layer * @protocol: pointer to the corresponding pnp_protocol structure + * */ void pnp_unregister_protocol(struct pnp_protocol *protocol) { @@ -89,11 +93,11 @@ void pnp_unregister_protocol(struct pnp_protocol *protocol) device_unregister(&protocol->dev); } + static void pnp_free_ids(struct pnp_dev *dev) { - struct pnp_id *id; - struct pnp_id *next; - + struct pnp_id * id; + struct pnp_id * next; if (!dev) return; id = dev->id; @@ -106,8 +110,7 @@ static void pnp_free_ids(struct pnp_dev *dev) static void pnp_release_device(struct device *dmdev) { - struct pnp_dev *dev = to_pnp_dev(dmdev); - + struct pnp_dev * dev = to_pnp_dev(dmdev); pnp_free_option(dev->independent); pnp_free_option(dev->dependent); pnp_free_ids(dev); @@ -117,7 +120,6 @@ static void pnp_release_device(struct device *dmdev) int __pnp_add_device(struct pnp_dev *dev) { int ret; - pnp_fixup_device(dev); dev->dev.bus = &pnp_bus_type; dev->dev.dma_mask = &dev->dma_mask; @@ -141,13 +143,13 @@ int __pnp_add_device(struct pnp_dev *dev) * * adds to driver model, name database, fixups, interface, etc. */ + int pnp_add_device(struct pnp_dev *dev) { if (!dev || !dev->protocol || dev->card) return -EINVAL; dev->dev.parent = &dev->protocol->dev; - sprintf(dev->dev.bus_id, "%02x:%02x", dev->protocol->number, - dev->number); + sprintf(dev->dev.bus_id, "%02x:%02x", dev->protocol->number, dev->number); return __pnp_add_device(dev); } @@ -160,6 +162,21 @@ void __pnp_remove_device(struct pnp_dev *dev) device_unregister(&dev->dev); } +/** + * pnp_remove_device - removes a pnp device from the pnp layer + * @dev: pointer to dev to add + * + * this function will free all mem used by dev + */ +#if 0 +void pnp_remove_device(struct pnp_dev *dev) +{ + if (!dev || dev->card) + return; + __pnp_remove_device(dev); +} +#endif /* 0 */ + static int __init pnp_init(void) { printk(KERN_INFO "Linux Plug and Play Support v0.97 (c) Adam Belay\n"); @@ -167,3 +184,10 @@ static int __init pnp_init(void) } subsys_initcall(pnp_init); + +#if 0 +EXPORT_SYMBOL(pnp_register_protocol); +EXPORT_SYMBOL(pnp_unregister_protocol); +EXPORT_SYMBOL(pnp_add_device); +EXPORT_SYMBOL(pnp_remove_device); +#endif /* 0 */ diff --git a/trunk/drivers/pnp/driver.c b/trunk/drivers/pnp/driver.c index 30b8f6f3258a..1432806451cd 100644 --- a/trunk/drivers/pnp/driver.c +++ b/trunk/drivers/pnp/driver.c @@ -2,6 +2,7 @@ * driver.c - device id matching, driver model, etc. * * Copyright 2002 Adam Belay + * */ #include @@ -15,11 +16,12 @@ static int compare_func(const char *ida, const char *idb) { int i; - /* we only need to compare the last 4 chars */ - for (i = 3; i < 7; i++) { + for (i=3; i<7; i++) + { if (ida[i] != 'X' && - idb[i] != 'X' && toupper(ida[i]) != toupper(idb[i])) + idb[i] != 'X' && + toupper(ida[i]) != toupper(idb[i])) return 0; } return 1; @@ -29,22 +31,20 @@ int compare_pnp_id(struct pnp_id *pos, const char *id) { if (!pos || !id || (strlen(id) != 7)) return 0; - if (memcmp(id, "ANYDEVS", 7) == 0) + if (memcmp(id,"ANYDEVS",7)==0) return 1; - while (pos) { - if (memcmp(pos->id, id, 3) == 0) - if (compare_func(pos->id, id) == 1) + while (pos){ + if (memcmp(pos->id,id,3)==0) + if (compare_func(pos->id,id)==1) return 1; pos = pos->next; } return 0; } -static const struct pnp_device_id *match_device(struct pnp_driver *drv, - struct pnp_dev *dev) +static const struct pnp_device_id * match_device(struct pnp_driver *drv, struct pnp_dev *dev) { const struct pnp_device_id *drv_id = drv->id_table; - if (!drv_id) return NULL; @@ -59,7 +59,7 @@ static const struct pnp_device_id *match_device(struct pnp_driver *drv, int pnp_device_attach(struct pnp_dev *pnp_dev) { spin_lock(&pnp_lock); - if (pnp_dev->status != PNP_READY) { + if(pnp_dev->status != PNP_READY){ spin_unlock(&pnp_lock); return -EBUSY; } @@ -86,8 +86,7 @@ static int pnp_device_probe(struct device *dev) pnp_dev = to_pnp_dev(dev); pnp_drv = to_pnp_driver(dev->driver); - pnp_dbg("match found with the PnP device '%s' and the driver '%s'", - dev->bus_id, pnp_drv->name); + pnp_dbg("match found with the PnP device '%s' and the driver '%s'", dev->bus_id,pnp_drv->name); error = pnp_device_attach(pnp_dev); if (error < 0) @@ -100,7 +99,7 @@ static int pnp_device_probe(struct device *dev) return error; } } else if ((pnp_drv->flags & PNP_DRIVER_RES_DISABLE) - == PNP_DRIVER_RES_DISABLE) { + == PNP_DRIVER_RES_DISABLE) { error = pnp_disable_dev(pnp_dev); if (error < 0) return error; @@ -111,22 +110,22 @@ static int pnp_device_probe(struct device *dev) if (dev_id != NULL) error = pnp_drv->probe(pnp_dev, dev_id); } - if (error >= 0) { + if (error >= 0){ pnp_dev->driver = pnp_drv; error = 0; } else goto fail; return error; - fail: +fail: pnp_device_detach(pnp_dev); return error; } static int pnp_device_remove(struct device *dev) { - struct pnp_dev *pnp_dev = to_pnp_dev(dev); - struct pnp_driver *drv = pnp_dev->driver; + struct pnp_dev * pnp_dev = to_pnp_dev(dev); + struct pnp_driver * drv = pnp_dev->driver; if (drv) { if (drv->remove) @@ -139,9 +138,8 @@ static int pnp_device_remove(struct device *dev) static int pnp_bus_match(struct device *dev, struct device_driver *drv) { - struct pnp_dev *pnp_dev = to_pnp_dev(dev); - struct pnp_driver *pnp_drv = to_pnp_driver(drv); - + struct pnp_dev * pnp_dev = to_pnp_dev(dev); + struct pnp_driver * pnp_drv = to_pnp_driver(drv); if (match_device(pnp_drv, pnp_dev) == NULL) return 0; return 1; @@ -149,8 +147,8 @@ static int pnp_bus_match(struct device *dev, struct device_driver *drv) static int pnp_bus_suspend(struct device *dev, pm_message_t state) { - struct pnp_dev *pnp_dev = to_pnp_dev(dev); - struct pnp_driver *pnp_drv = pnp_dev->driver; + struct pnp_dev * pnp_dev = to_pnp_dev(dev); + struct pnp_driver * pnp_drv = pnp_dev->driver; int error; if (!pnp_drv) @@ -164,9 +162,9 @@ static int pnp_bus_suspend(struct device *dev, pm_message_t state) if (!(pnp_drv->flags & PNP_DRIVER_RES_DO_NOT_CHANGE) && pnp_can_disable(pnp_dev)) { - error = pnp_stop_dev(pnp_dev); - if (error) - return error; + error = pnp_stop_dev(pnp_dev); + if (error) + return error; } if (pnp_dev->protocol && pnp_dev->protocol->suspend) @@ -176,8 +174,8 @@ static int pnp_bus_suspend(struct device *dev, pm_message_t state) static int pnp_bus_resume(struct device *dev) { - struct pnp_dev *pnp_dev = to_pnp_dev(dev); - struct pnp_driver *pnp_drv = pnp_dev->driver; + struct pnp_dev * pnp_dev = to_pnp_dev(dev); + struct pnp_driver * pnp_drv = pnp_dev->driver; int error; if (!pnp_drv) @@ -199,12 +197,12 @@ static int pnp_bus_resume(struct device *dev) } struct bus_type pnp_bus_type = { - .name = "pnp", - .match = pnp_bus_match, - .probe = pnp_device_probe, - .remove = pnp_device_remove, + .name = "pnp", + .match = pnp_bus_match, + .probe = pnp_device_probe, + .remove = pnp_device_remove, .suspend = pnp_bus_suspend, - .resume = pnp_bus_resume, + .resume = pnp_bus_resume, }; int pnp_register_driver(struct pnp_driver *drv) @@ -227,11 +225,12 @@ void pnp_unregister_driver(struct pnp_driver *drv) * pnp_add_id - adds an EISA id to the specified device * @id: pointer to a pnp_id structure * @dev: pointer to the desired device + * */ + int pnp_add_id(struct pnp_id *id, struct pnp_dev *dev) { struct pnp_id *ptr; - if (!id) return -EINVAL; if (!dev) @@ -249,5 +248,8 @@ int pnp_add_id(struct pnp_id *id, struct pnp_dev *dev) EXPORT_SYMBOL(pnp_register_driver); EXPORT_SYMBOL(pnp_unregister_driver); +#if 0 +EXPORT_SYMBOL(pnp_add_id); +#endif EXPORT_SYMBOL(pnp_device_attach); EXPORT_SYMBOL(pnp_device_detach); diff --git a/trunk/drivers/pnp/interface.c b/trunk/drivers/pnp/interface.c index fe6684e13e82..ac9fcd499f3f 100644 --- a/trunk/drivers/pnp/interface.c +++ b/trunk/drivers/pnp/interface.c @@ -3,6 +3,7 @@ * * Some code, especially possible resource dumping is based on isapnp_proc.c (c) Jaroslav Kysela * Copyright 2002 Adam Belay + * */ #include @@ -28,7 +29,7 @@ struct pnp_info_buffer { typedef struct pnp_info_buffer pnp_info_buffer_t; -static int pnp_printf(pnp_info_buffer_t * buffer, char *fmt, ...) +static int pnp_printf(pnp_info_buffer_t * buffer, char *fmt,...) { va_list args; int res; @@ -47,18 +48,14 @@ static int pnp_printf(pnp_info_buffer_t * buffer, char *fmt, ...) return res; } -static void pnp_print_port(pnp_info_buffer_t * buffer, char *space, - struct pnp_port *port) +static void pnp_print_port(pnp_info_buffer_t *buffer, char *space, struct pnp_port *port) { - pnp_printf(buffer, - "%sport 0x%x-0x%x, align 0x%x, size 0x%x, %i-bit address decoding\n", - space, port->min, port->max, - port->align ? (port->align - 1) : 0, port->size, - port->flags & PNP_PORT_FLAG_16BITADDR ? 16 : 10); + pnp_printf(buffer, "%sport 0x%x-0x%x, align 0x%x, size 0x%x, %i-bit address decoding\n", + space, port->min, port->max, port->align ? (port->align-1) : 0, port->size, + port->flags & PNP_PORT_FLAG_16BITADDR ? 16 : 10); } -static void pnp_print_irq(pnp_info_buffer_t * buffer, char *space, - struct pnp_irq *irq) +static void pnp_print_irq(pnp_info_buffer_t *buffer, char *space, struct pnp_irq *irq) { int first = 1, i; @@ -88,15 +85,14 @@ static void pnp_print_irq(pnp_info_buffer_t * buffer, char *space, pnp_printf(buffer, "\n"); } -static void pnp_print_dma(pnp_info_buffer_t * buffer, char *space, - struct pnp_dma *dma) +static void pnp_print_dma(pnp_info_buffer_t *buffer, char *space, struct pnp_dma *dma) { int first = 1, i; char *s; pnp_printf(buffer, "%sdma ", space); for (i = 0; i < 8; i++) - if (dma->map & (1 << i)) { + if (dma->map & (1<min, mem->max, mem->align, mem->size); + space, mem->min, mem->max, mem->align, mem->size); if (mem->flags & IORESOURCE_MEM_WRITEABLE) pnp_printf(buffer, ", writeable"); if (mem->flags & IORESOURCE_MEM_CACHEABLE) @@ -173,7 +168,7 @@ static void pnp_print_mem(pnp_info_buffer_t * buffer, char *space, pnp_printf(buffer, ", %s\n", s); } -static void pnp_print_option(pnp_info_buffer_t * buffer, char *space, +static void pnp_print_option(pnp_info_buffer_t *buffer, char *space, struct pnp_option *option, int dep) { char *s; @@ -184,19 +179,19 @@ static void pnp_print_option(pnp_info_buffer_t * buffer, char *space, if (dep) { switch (option->priority) { - case PNP_RES_PRIORITY_PREFERRED: + case PNP_RES_PRIORITY_PREFERRED: s = "preferred"; break; - case PNP_RES_PRIORITY_ACCEPTABLE: + case PNP_RES_PRIORITY_ACCEPTABLE: s = "acceptable"; break; - case PNP_RES_PRIORITY_FUNCTIONAL: + case PNP_RES_PRIORITY_FUNCTIONAL: s = "functional"; break; - default: + default: s = "invalid"; } - pnp_printf(buffer, "Dependent: %02i - Priority %s\n", dep, s); + pnp_printf(buffer, "Dependent: %02i - Priority %s\n",dep, s); } for (port = option->port; port; port = port->next) @@ -209,16 +204,16 @@ static void pnp_print_option(pnp_info_buffer_t * buffer, char *space, pnp_print_mem(buffer, space, mem); } -static ssize_t pnp_show_options(struct device *dmdev, - struct device_attribute *attr, char *buf) + +static ssize_t pnp_show_options(struct device *dmdev, struct device_attribute *attr, char *buf) { struct pnp_dev *dev = to_pnp_dev(dmdev); - struct pnp_option *independent = dev->independent; - struct pnp_option *dependent = dev->dependent; + struct pnp_option * independent = dev->independent; + struct pnp_option * dependent = dev->dependent; int ret, dep = 1; pnp_info_buffer_t *buffer = (pnp_info_buffer_t *) - pnp_alloc(sizeof(pnp_info_buffer_t)); + pnp_alloc(sizeof(pnp_info_buffer_t)); if (!buffer) return -ENOMEM; @@ -228,7 +223,7 @@ static ssize_t pnp_show_options(struct device *dmdev, if (independent) pnp_print_option(buffer, "", independent, 0); - while (dependent) { + while (dependent){ pnp_print_option(buffer, " ", dependent, dep); dependent = dependent->next; dep++; @@ -238,11 +233,10 @@ static ssize_t pnp_show_options(struct device *dmdev, return ret; } -static DEVICE_ATTR(options, S_IRUGO, pnp_show_options, NULL); +static DEVICE_ATTR(options,S_IRUGO,pnp_show_options,NULL); -static ssize_t pnp_show_current_resources(struct device *dmdev, - struct device_attribute *attr, - char *buf) + +static ssize_t pnp_show_current_resources(struct device *dmdev, struct device_attribute *attr, char *buf) { struct pnp_dev *dev = to_pnp_dev(dmdev); int i, ret; @@ -258,56 +252,52 @@ static ssize_t pnp_show_current_resources(struct device *dmdev, buffer->buffer = buf; buffer->curr = buffer->buffer; - pnp_printf(buffer, "state = "); + pnp_printf(buffer,"state = "); if (dev->active) - pnp_printf(buffer, "active\n"); + pnp_printf(buffer,"active\n"); else - pnp_printf(buffer, "disabled\n"); + pnp_printf(buffer,"disabled\n"); for (i = 0; i < PNP_MAX_PORT; i++) { if (pnp_port_valid(dev, i)) { - pnp_printf(buffer, "io"); + pnp_printf(buffer,"io"); if (pnp_port_flags(dev, i) & IORESOURCE_DISABLED) - pnp_printf(buffer, " disabled\n"); + pnp_printf(buffer," disabled\n"); else - pnp_printf(buffer, " 0x%llx-0x%llx\n", - (unsigned long long) - pnp_port_start(dev, i), - (unsigned long long)pnp_port_end(dev, - i)); + pnp_printf(buffer," 0x%llx-0x%llx\n", + (unsigned long long)pnp_port_start(dev, i), + (unsigned long long)pnp_port_end(dev, i)); } } for (i = 0; i < PNP_MAX_MEM; i++) { if (pnp_mem_valid(dev, i)) { - pnp_printf(buffer, "mem"); + pnp_printf(buffer,"mem"); if (pnp_mem_flags(dev, i) & IORESOURCE_DISABLED) - pnp_printf(buffer, " disabled\n"); + pnp_printf(buffer," disabled\n"); else - pnp_printf(buffer, " 0x%llx-0x%llx\n", - (unsigned long long) - pnp_mem_start(dev, i), - (unsigned long long)pnp_mem_end(dev, - i)); + pnp_printf(buffer," 0x%llx-0x%llx\n", + (unsigned long long)pnp_mem_start(dev, i), + (unsigned long long)pnp_mem_end(dev, i)); } } for (i = 0; i < PNP_MAX_IRQ; i++) { if (pnp_irq_valid(dev, i)) { - pnp_printf(buffer, "irq"); + pnp_printf(buffer,"irq"); if (pnp_irq_flags(dev, i) & IORESOURCE_DISABLED) - pnp_printf(buffer, " disabled\n"); + pnp_printf(buffer," disabled\n"); else - pnp_printf(buffer, " %lld\n", - (unsigned long long)pnp_irq(dev, i)); + pnp_printf(buffer," %lld\n", + (unsigned long long)pnp_irq(dev, i)); } } for (i = 0; i < PNP_MAX_DMA; i++) { if (pnp_dma_valid(dev, i)) { - pnp_printf(buffer, "dma"); + pnp_printf(buffer,"dma"); if (pnp_dma_flags(dev, i) & IORESOURCE_DISABLED) - pnp_printf(buffer, " disabled\n"); + pnp_printf(buffer," disabled\n"); else - pnp_printf(buffer, " %lld\n", - (unsigned long long)pnp_dma(dev, i)); + pnp_printf(buffer," %lld\n", + (unsigned long long)pnp_dma(dev, i)); } } ret = (buffer->curr - buf); @@ -318,57 +308,55 @@ static ssize_t pnp_show_current_resources(struct device *dmdev, extern struct semaphore pnp_res_mutex; static ssize_t -pnp_set_current_resources(struct device *dmdev, struct device_attribute *attr, - const char *ubuf, size_t count) +pnp_set_current_resources(struct device * dmdev, struct device_attribute *attr, const char * ubuf, size_t count) { struct pnp_dev *dev = to_pnp_dev(dmdev); - char *buf = (void *)ubuf; - int retval = 0; + char *buf = (void *)ubuf; + int retval = 0; if (dev->status & PNP_ATTACHED) { retval = -EBUSY; - pnp_info("Device %s cannot be configured because it is in use.", - dev->dev.bus_id); + pnp_info("Device %s cannot be configured because it is in use.", dev->dev.bus_id); goto done; } while (isspace(*buf)) ++buf; - if (!strnicmp(buf, "disable", 7)) { + if (!strnicmp(buf,"disable",7)) { retval = pnp_disable_dev(dev); goto done; } - if (!strnicmp(buf, "activate", 8)) { + if (!strnicmp(buf,"activate",8)) { retval = pnp_activate_dev(dev); goto done; } - if (!strnicmp(buf, "fill", 4)) { + if (!strnicmp(buf,"fill",4)) { if (dev->active) goto done; retval = pnp_auto_config_dev(dev); goto done; } - if (!strnicmp(buf, "auto", 4)) { + if (!strnicmp(buf,"auto",4)) { if (dev->active) goto done; pnp_init_resource_table(&dev->res); retval = pnp_auto_config_dev(dev); goto done; } - if (!strnicmp(buf, "clear", 5)) { + if (!strnicmp(buf,"clear",5)) { if (dev->active) goto done; pnp_init_resource_table(&dev->res); goto done; } - if (!strnicmp(buf, "get", 3)) { + if (!strnicmp(buf,"get",3)) { down(&pnp_res_mutex); if (pnp_can_read(dev)) dev->protocol->get(dev, &dev->res); up(&pnp_res_mutex); goto done; } - if (!strnicmp(buf, "set", 3)) { + if (!strnicmp(buf,"set",3)) { int nport = 0, nmem = 0, nirq = 0, ndma = 0; if (dev->active) goto done; @@ -378,77 +366,65 @@ pnp_set_current_resources(struct device *dmdev, struct device_attribute *attr, while (1) { while (isspace(*buf)) ++buf; - if (!strnicmp(buf, "io", 2)) { + if (!strnicmp(buf,"io",2)) { buf += 2; while (isspace(*buf)) ++buf; - dev->res.port_resource[nport].start = - simple_strtoul(buf, &buf, 0); + dev->res.port_resource[nport].start = simple_strtoul(buf,&buf,0); while (isspace(*buf)) ++buf; - if (*buf == '-') { + if(*buf == '-') { buf += 1; while (isspace(*buf)) ++buf; - dev->res.port_resource[nport].end = - simple_strtoul(buf, &buf, 0); + dev->res.port_resource[nport].end = simple_strtoul(buf,&buf,0); } else - dev->res.port_resource[nport].end = - dev->res.port_resource[nport].start; - dev->res.port_resource[nport].flags = - IORESOURCE_IO; + dev->res.port_resource[nport].end = dev->res.port_resource[nport].start; + dev->res.port_resource[nport].flags = IORESOURCE_IO; nport++; if (nport >= PNP_MAX_PORT) break; continue; } - if (!strnicmp(buf, "mem", 3)) { + if (!strnicmp(buf,"mem",3)) { buf += 3; while (isspace(*buf)) ++buf; - dev->res.mem_resource[nmem].start = - simple_strtoul(buf, &buf, 0); + dev->res.mem_resource[nmem].start = simple_strtoul(buf,&buf,0); while (isspace(*buf)) ++buf; - if (*buf == '-') { + if(*buf == '-') { buf += 1; while (isspace(*buf)) ++buf; - dev->res.mem_resource[nmem].end = - simple_strtoul(buf, &buf, 0); + dev->res.mem_resource[nmem].end = simple_strtoul(buf,&buf,0); } else - dev->res.mem_resource[nmem].end = - dev->res.mem_resource[nmem].start; - dev->res.mem_resource[nmem].flags = - IORESOURCE_MEM; + dev->res.mem_resource[nmem].end = dev->res.mem_resource[nmem].start; + dev->res.mem_resource[nmem].flags = IORESOURCE_MEM; nmem++; if (nmem >= PNP_MAX_MEM) break; continue; } - if (!strnicmp(buf, "irq", 3)) { + if (!strnicmp(buf,"irq",3)) { buf += 3; while (isspace(*buf)) ++buf; dev->res.irq_resource[nirq].start = - dev->res.irq_resource[nirq].end = - simple_strtoul(buf, &buf, 0); - dev->res.irq_resource[nirq].flags = - IORESOURCE_IRQ; + dev->res.irq_resource[nirq].end = simple_strtoul(buf,&buf,0); + dev->res.irq_resource[nirq].flags = IORESOURCE_IRQ; nirq++; if (nirq >= PNP_MAX_IRQ) break; continue; } - if (!strnicmp(buf, "dma", 3)) { + if (!strnicmp(buf,"dma",3)) { buf += 3; while (isspace(*buf)) ++buf; dev->res.dma_resource[ndma].start = - dev->res.dma_resource[ndma].end = - simple_strtoul(buf, &buf, 0); - dev->res.dma_resource[ndma].flags = - IORESOURCE_DMA; + dev->res.dma_resource[ndma].end = simple_strtoul(buf,&buf,0); + dev->res.dma_resource[ndma].flags = IORESOURCE_DMA; ndma++; if (ndma >= PNP_MAX_DMA) break; @@ -459,50 +435,45 @@ pnp_set_current_resources(struct device *dmdev, struct device_attribute *attr, up(&pnp_res_mutex); goto done; } - done: + done: if (retval < 0) return retval; return count; } -static DEVICE_ATTR(resources, S_IRUGO | S_IWUSR, - pnp_show_current_resources, pnp_set_current_resources); +static DEVICE_ATTR(resources,S_IRUGO | S_IWUSR, + pnp_show_current_resources,pnp_set_current_resources); -static ssize_t pnp_show_current_ids(struct device *dmdev, - struct device_attribute *attr, char *buf) +static ssize_t pnp_show_current_ids(struct device *dmdev, struct device_attribute *attr, char *buf) { char *str = buf; struct pnp_dev *dev = to_pnp_dev(dmdev); - struct pnp_id *pos = dev->id; + struct pnp_id * pos = dev->id; while (pos) { - str += sprintf(str, "%s\n", pos->id); + str += sprintf(str,"%s\n", pos->id); pos = pos->next; } return (str - buf); } -static DEVICE_ATTR(id, S_IRUGO, pnp_show_current_ids, NULL); +static DEVICE_ATTR(id,S_IRUGO,pnp_show_current_ids,NULL); int pnp_interface_attach_device(struct pnp_dev *dev) { - int rc = device_create_file(&dev->dev, &dev_attr_options); - - if (rc) - goto err; - rc = device_create_file(&dev->dev, &dev_attr_resources); - if (rc) - goto err_opt; - rc = device_create_file(&dev->dev, &dev_attr_id); - if (rc) - goto err_res; + int rc = device_create_file(&dev->dev,&dev_attr_options); + if (rc) goto err; + rc = device_create_file(&dev->dev,&dev_attr_resources); + if (rc) goto err_opt; + rc = device_create_file(&dev->dev,&dev_attr_id); + if (rc) goto err_res; return 0; - err_res: - device_remove_file(&dev->dev, &dev_attr_resources); - err_opt: - device_remove_file(&dev->dev, &dev_attr_options); - err: +err_res: + device_remove_file(&dev->dev,&dev_attr_resources); +err_opt: + device_remove_file(&dev->dev,&dev_attr_options); +err: return rc; } diff --git a/trunk/drivers/pnp/isapnp/compat.c b/trunk/drivers/pnp/isapnp/compat.c index 10bdcc4d4f7b..0697ab88a9ac 100644 --- a/trunk/drivers/pnp/isapnp/compat.c +++ b/trunk/drivers/pnp/isapnp/compat.c @@ -3,30 +3,34 @@ * the old isapnp APIs. If possible use the new APIs instead. * * Copyright 2002 Adam Belay + * */ + +/* TODO: see if more isapnp functions are needed here */ #include #include #include -static void pnp_convert_id(char *buf, unsigned short vendor, - unsigned short device) +static void pnp_convert_id(char *buf, unsigned short vendor, unsigned short device) { sprintf(buf, "%c%c%c%x%x%x%x", - 'A' + ((vendor >> 2) & 0x3f) - 1, - 'A' + (((vendor & 3) << 3) | ((vendor >> 13) & 7)) - 1, - 'A' + ((vendor >> 8) & 0x1f) - 1, - (device >> 4) & 0x0f, device & 0x0f, - (device >> 12) & 0x0f, (device >> 8) & 0x0f); + 'A' + ((vendor >> 2) & 0x3f) - 1, + 'A' + (((vendor & 3) << 3) | ((vendor >> 13) & 7)) - 1, + 'A' + ((vendor >> 8) & 0x1f) - 1, + (device >> 4) & 0x0f, + device & 0x0f, + (device >> 12) & 0x0f, + (device >> 8) & 0x0f); } -struct pnp_card *pnp_find_card(unsigned short vendor, unsigned short device, +struct pnp_card *pnp_find_card(unsigned short vendor, + unsigned short device, struct pnp_card *from) { char id[8]; char any[8]; struct list_head *list; - pnp_convert_id(id, vendor, device); pnp_convert_id(any, ISAPNP_ANY_ID, ISAPNP_ANY_ID); @@ -34,20 +38,20 @@ struct pnp_card *pnp_find_card(unsigned short vendor, unsigned short device, while (list != &pnp_cards) { struct pnp_card *card = global_to_pnp_card(list); - - if (compare_pnp_id(card->id, id) || (memcmp(id, any, 7) == 0)) + if (compare_pnp_id(card->id,id) || (memcmp(id,any,7)==0)) return card; list = list->next; } return NULL; } -struct pnp_dev *pnp_find_dev(struct pnp_card *card, unsigned short vendor, - unsigned short function, struct pnp_dev *from) +struct pnp_dev *pnp_find_dev(struct pnp_card *card, + unsigned short vendor, + unsigned short function, + struct pnp_dev *from) { char id[8]; char any[8]; - pnp_convert_id(id, vendor, function); pnp_convert_id(any, ISAPNP_ANY_ID, ISAPNP_ANY_ID); if (card == NULL) { /* look for a logical device from all cards */ @@ -59,9 +63,7 @@ struct pnp_dev *pnp_find_dev(struct pnp_card *card, unsigned short vendor, while (list != &pnp_global) { struct pnp_dev *dev = global_to_pnp_dev(list); - - if (compare_pnp_id(dev->id, id) || - (memcmp(id, any, 7) == 0)) + if (compare_pnp_id(dev->id,id) || (memcmp(id,any,7)==0)) return dev; list = list->next; } @@ -76,8 +78,7 @@ struct pnp_dev *pnp_find_dev(struct pnp_card *card, unsigned short vendor, } while (list != &card->devices) { struct pnp_dev *dev = card_to_pnp_dev(list); - - if (compare_pnp_id(dev->id, id)) + if (compare_pnp_id(dev->id,id)) return dev; list = list->next; } diff --git a/trunk/drivers/pnp/isapnp/core.c b/trunk/drivers/pnp/isapnp/core.c index b4e2aa995b53..914d00c423ad 100644 --- a/trunk/drivers/pnp/isapnp/core.c +++ b/trunk/drivers/pnp/isapnp/core.c @@ -51,10 +51,10 @@ #define ISAPNP_DEBUG #endif -int isapnp_disable; /* Disable ISA PnP */ -static int isapnp_rdp; /* Read Data Port */ -static int isapnp_reset = 1; /* reset all PnP cards (deactivate) */ -static int isapnp_verbose = 1; /* verbose mode */ +int isapnp_disable; /* Disable ISA PnP */ +static int isapnp_rdp; /* Read Data Port */ +static int isapnp_reset = 1; /* reset all PnP cards (deactivate) */ +static int isapnp_verbose = 1; /* verbose mode */ MODULE_AUTHOR("Jaroslav Kysela "); MODULE_DESCRIPTION("Generic ISA Plug & Play support"); @@ -126,7 +126,7 @@ static unsigned short isapnp_read_word(unsigned char idx) unsigned short val; val = isapnp_read_byte(idx); - val = (val << 8) + isapnp_read_byte(idx + 1); + val = (val << 8) + isapnp_read_byte(idx+1); return val; } @@ -139,7 +139,7 @@ void isapnp_write_byte(unsigned char idx, unsigned char val) static void isapnp_write_word(unsigned char idx, unsigned short val) { isapnp_write_byte(idx, val >> 8); - isapnp_write_byte(idx + 1, val); + isapnp_write_byte(idx+1, val); } static void isapnp_key(void) @@ -193,7 +193,7 @@ static void isapnp_deactivate(unsigned char logdev) static void __init isapnp_peek(unsigned char *data, int bytes) { int i, j; - unsigned char d = 0; + unsigned char d=0; for (i = 1; i <= bytes; i++) { for (j = 0; j < 20; j++) { @@ -220,18 +220,19 @@ static int isapnp_next_rdp(void) { int rdp = isapnp_rdp; static int old_rdp = 0; - - if (old_rdp) { + + if(old_rdp) + { release_region(old_rdp, 1); old_rdp = 0; } while (rdp <= 0x3ff) { /* - * We cannot use NE2000 probe spaces for ISAPnP or we - * will lock up machines. + * We cannot use NE2000 probe spaces for ISAPnP or we + * will lock up machines. */ - if ((rdp < 0x280 || rdp > 0x380) - && request_region(rdp, 1, "ISAPnP")) { + if ((rdp < 0x280 || rdp > 0x380) && request_region(rdp, 1, "ISAPnP")) + { isapnp_rdp = rdp; old_rdp = rdp; return 0; @@ -252,6 +253,7 @@ static inline void isapnp_set_rdp(void) * Perform an isolation. The port selection code now tries to avoid * "dangerous to read" ports. */ + static int __init isapnp_isolate_rdp_select(void) { isapnp_wait(); @@ -280,6 +282,7 @@ static int __init isapnp_isolate_rdp_select(void) /* * Isolate (assign uniqued CSN) to all ISA PnP devices. */ + static int __init isapnp_isolate(void) { unsigned char checksum = 0x6a; @@ -302,9 +305,7 @@ static int __init isapnp_isolate(void) udelay(250); if (data == 0x55aa) bit = 0x01; - checksum = - ((((checksum ^ (checksum >> 1)) & 0x01) ^ bit) << 7) - | (checksum >> 1); + checksum = ((((checksum ^ (checksum >> 1)) & 0x01) ^ bit) << 7) | (checksum >> 1); bit = 0x00; } for (i = 65; i <= 72; i++) { @@ -350,12 +351,13 @@ static int __init isapnp_isolate(void) /* * Read one tag from stream. */ + static int __init isapnp_read_tag(unsigned char *type, unsigned short *size) { unsigned char tag, tmp[2]; isapnp_peek(&tag, 1); - if (tag == 0) /* invalid tag */ + if (tag == 0) /* invalid tag */ return -1; if (tag & 0x80) { /* large item */ *type = tag; @@ -366,8 +368,7 @@ static int __init isapnp_read_tag(unsigned char *type, unsigned short *size) *size = tag & 0x07; } #if 0 - printk(KERN_DEBUG "tag = 0x%x, type = 0x%x, size = %i\n", tag, *type, - *size); + printk(KERN_DEBUG "tag = 0x%x, type = 0x%x, size = %i\n", tag, *type, *size); #endif if (*type == 0xff && *size == 0xffff) /* probably invalid data */ return -1; @@ -377,6 +378,7 @@ static int __init isapnp_read_tag(unsigned char *type, unsigned short *size) /* * Skip specified number of bytes from stream. */ + static void __init isapnp_skip_bytes(int count) { isapnp_peek(NULL, count); @@ -385,30 +387,31 @@ static void __init isapnp_skip_bytes(int count) /* * Parse EISA id. */ -static void isapnp_parse_id(struct pnp_dev *dev, unsigned short vendor, - unsigned short device) -{ - struct pnp_id *id; +static void isapnp_parse_id(struct pnp_dev * dev, unsigned short vendor, unsigned short device) +{ + struct pnp_id * id; if (!dev) return; id = kzalloc(sizeof(struct pnp_id), GFP_KERNEL); if (!id) return; sprintf(id->id, "%c%c%c%x%x%x%x", - 'A' + ((vendor >> 2) & 0x3f) - 1, - 'A' + (((vendor & 3) << 3) | ((vendor >> 13) & 7)) - 1, - 'A' + ((vendor >> 8) & 0x1f) - 1, - (device >> 4) & 0x0f, - device & 0x0f, (device >> 12) & 0x0f, (device >> 8) & 0x0f); + 'A' + ((vendor >> 2) & 0x3f) - 1, + 'A' + (((vendor & 3) << 3) | ((vendor >> 13) & 7)) - 1, + 'A' + ((vendor >> 8) & 0x1f) - 1, + (device >> 4) & 0x0f, + device & 0x0f, + (device >> 12) & 0x0f, + (device >> 8) & 0x0f); pnp_add_id(id, dev); } /* * Parse logical device tag. */ -static struct pnp_dev *__init isapnp_parse_device(struct pnp_card *card, - int size, int number) + +static struct pnp_dev * __init isapnp_parse_device(struct pnp_card *card, int size, int number) { unsigned char tmp[6]; struct pnp_dev *dev; @@ -432,11 +435,13 @@ static struct pnp_dev *__init isapnp_parse_device(struct pnp_card *card, return dev; } + /* * Add IRQ resource to resources list. */ + static void __init isapnp_parse_irq_resource(struct pnp_option *option, - int size) + int size) { unsigned char tmp[3]; struct pnp_irq *irq; @@ -453,13 +458,15 @@ static void __init isapnp_parse_irq_resource(struct pnp_option *option, else irq->flags = IORESOURCE_IRQ_HIGHEDGE; pnp_register_irq_resource(option, irq); + return; } /* * Add DMA resource to resources list. */ + static void __init isapnp_parse_dma_resource(struct pnp_option *option, - int size) + int size) { unsigned char tmp[2]; struct pnp_dma *dma; @@ -471,13 +478,15 @@ static void __init isapnp_parse_dma_resource(struct pnp_option *option, dma->map = tmp[0]; dma->flags = tmp[1]; pnp_register_dma_resource(option, dma); + return; } /* * Add port resource to resources list. */ + static void __init isapnp_parse_port_resource(struct pnp_option *option, - int size) + int size) { unsigned char tmp[7]; struct pnp_port *port; @@ -491,14 +500,16 @@ static void __init isapnp_parse_port_resource(struct pnp_option *option, port->align = tmp[5]; port->size = tmp[6]; port->flags = tmp[0] ? PNP_PORT_FLAG_16BITADDR : 0; - pnp_register_port_resource(option, port); + pnp_register_port_resource(option,port); + return; } /* * Add fixed port resource to resources list. */ + static void __init isapnp_parse_fixed_port_resource(struct pnp_option *option, - int size) + int size) { unsigned char tmp[3]; struct pnp_port *port; @@ -511,14 +522,16 @@ static void __init isapnp_parse_fixed_port_resource(struct pnp_option *option, port->size = tmp[2]; port->align = 0; port->flags = PNP_PORT_FLAG_FIXED; - pnp_register_port_resource(option, port); + pnp_register_port_resource(option,port); + return; } /* * Add memory resource to resources list. */ + static void __init isapnp_parse_mem_resource(struct pnp_option *option, - int size) + int size) { unsigned char tmp[9]; struct pnp_mem *mem; @@ -532,14 +545,16 @@ static void __init isapnp_parse_mem_resource(struct pnp_option *option, mem->align = (tmp[6] << 8) | tmp[5]; mem->size = ((tmp[8] << 8) | tmp[7]) << 8; mem->flags = tmp[0]; - pnp_register_mem_resource(option, mem); + pnp_register_mem_resource(option,mem); + return; } /* * Add 32-bit memory resource to resources list. */ + static void __init isapnp_parse_mem32_resource(struct pnp_option *option, - int size) + int size) { unsigned char tmp[17]; struct pnp_mem *mem; @@ -550,19 +565,18 @@ static void __init isapnp_parse_mem32_resource(struct pnp_option *option, return; mem->min = (tmp[4] << 24) | (tmp[3] << 16) | (tmp[2] << 8) | tmp[1]; mem->max = (tmp[8] << 24) | (tmp[7] << 16) | (tmp[6] << 8) | tmp[5]; - mem->align = - (tmp[12] << 24) | (tmp[11] << 16) | (tmp[10] << 8) | tmp[9]; - mem->size = - (tmp[16] << 24) | (tmp[15] << 16) | (tmp[14] << 8) | tmp[13]; + mem->align = (tmp[12] << 24) | (tmp[11] << 16) | (tmp[10] << 8) | tmp[9]; + mem->size = (tmp[16] << 24) | (tmp[15] << 16) | (tmp[14] << 8) | tmp[13]; mem->flags = tmp[0]; - pnp_register_mem_resource(option, mem); + pnp_register_mem_resource(option,mem); } /* * Add 32-bit fixed memory resource to resources list. */ + static void __init isapnp_parse_fixed_mem32_resource(struct pnp_option *option, - int size) + int size) { unsigned char tmp[9]; struct pnp_mem *mem; @@ -571,29 +585,28 @@ static void __init isapnp_parse_fixed_mem32_resource(struct pnp_option *option, mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL); if (!mem) return; - mem->min = mem->max = - (tmp[4] << 24) | (tmp[3] << 16) | (tmp[2] << 8) | tmp[1]; + mem->min = mem->max = (tmp[4] << 24) | (tmp[3] << 16) | (tmp[2] << 8) | tmp[1]; mem->size = (tmp[8] << 24) | (tmp[7] << 16) | (tmp[6] << 8) | tmp[5]; mem->align = 0; mem->flags = tmp[0]; - pnp_register_mem_resource(option, mem); + pnp_register_mem_resource(option,mem); } /* * Parse card name for ISA PnP device. - */ + */ + static void __init isapnp_parse_name(char *name, unsigned int name_max, unsigned short *size) { if (name[0] == '\0') { - unsigned short size1 = - *size >= name_max ? (name_max - 1) : *size; + unsigned short size1 = *size >= name_max ? (name_max - 1) : *size; isapnp_peek(name, size1); name[size1] = '\0'; *size -= size1; /* clean whitespace from end of string */ - while (size1 > 0 && name[--size1] == ' ') + while (size1 > 0 && name[--size1] == ' ') name[size1] = '\0'; } } @@ -601,6 +614,7 @@ isapnp_parse_name(char *name, unsigned int name_max, unsigned short *size) /* * Parse resource map for logical device. */ + static int __init isapnp_create_device(struct pnp_card *card, unsigned short size) { @@ -608,7 +622,6 @@ static int __init isapnp_create_device(struct pnp_card *card, unsigned char type, tmp[17]; struct pnp_option *option; struct pnp_dev *dev; - if ((dev = isapnp_parse_device(card, size, number++)) == NULL) return 1; option = pnp_register_independent_option(dev); @@ -616,19 +629,17 @@ static int __init isapnp_create_device(struct pnp_card *card, kfree(dev); return 1; } - pnp_add_card_device(card, dev); + pnp_add_card_device(card,dev); while (1) { - if (isapnp_read_tag(&type, &size) < 0) + if (isapnp_read_tag(&type, &size)<0) return 1; if (skip && type != _STAG_LOGDEVID && type != _STAG_END) goto __skip; switch (type) { case _STAG_LOGDEVID: if (size >= 5 && size <= 6) { - if ((dev = - isapnp_parse_device(card, size, - number++)) == NULL) + if ((dev = isapnp_parse_device(card, size, number++)) == NULL) return 1; size = 0; skip = 0; @@ -637,7 +648,7 @@ static int __init isapnp_create_device(struct pnp_card *card, kfree(dev); return 1; } - pnp_add_card_device(card, dev); + pnp_add_card_device(card,dev); } else { skip = 1; } @@ -647,8 +658,7 @@ static int __init isapnp_create_device(struct pnp_card *card, case _STAG_COMPATDEVID: if (size == 4 && compat < DEVICE_COUNT_COMPATIBLE) { isapnp_peek(tmp, 4); - isapnp_parse_id(dev, (tmp[1] << 8) | tmp[0], - (tmp[3] << 8) | tmp[2]); + isapnp_parse_id(dev,(tmp[1] << 8) | tmp[0], (tmp[3] << 8) | tmp[2]); compat++; size = 0; } @@ -674,7 +684,7 @@ static int __init isapnp_create_device(struct pnp_card *card, priority = 0x100 | tmp[0]; size = 0; } - option = pnp_register_dependent_option(dev, priority); + option = pnp_register_dependent_option(dev,priority); if (!option) return 1; break; @@ -729,13 +739,11 @@ static int __init isapnp_create_device(struct pnp_card *card, isapnp_skip_bytes(size); return 1; default: - printk(KERN_ERR - "isapnp: unexpected or unknown tag type 0x%x for logical device %i (device %i), ignored\n", - type, dev->number, card->number); + printk(KERN_ERR "isapnp: unexpected or unknown tag type 0x%x for logical device %i (device %i), ignored\n", type, dev->number, card->number); } __skip: - if (size > 0) - isapnp_skip_bytes(size); + if (size > 0) + isapnp_skip_bytes(size); } return 0; } @@ -743,13 +751,14 @@ static int __init isapnp_create_device(struct pnp_card *card, /* * Parse resource map for ISA PnP card. */ + static void __init isapnp_parse_resource_map(struct pnp_card *card) { unsigned char type, tmp[17]; unsigned short size; while (1) { - if (isapnp_read_tag(&type, &size) < 0) + if (isapnp_read_tag(&type, &size)<0) return; switch (type) { case _STAG_PNPVERNO: @@ -762,7 +771,7 @@ static void __init isapnp_parse_resource_map(struct pnp_card *card) break; case _STAG_LOGDEVID: if (size >= 5 && size <= 6) { - if (isapnp_create_device(card, size) == 1) + if (isapnp_create_device(card, size)==1) return; size = 0; } @@ -770,8 +779,7 @@ static void __init isapnp_parse_resource_map(struct pnp_card *card) case _STAG_VENDOR: break; case _LTAG_ANSISTR: - isapnp_parse_name(card->name, sizeof(card->name), - &size); + isapnp_parse_name(card->name, sizeof(card->name), &size); break; case _LTAG_UNICODESTR: /* silently ignore */ @@ -784,19 +792,18 @@ static void __init isapnp_parse_resource_map(struct pnp_card *card) isapnp_skip_bytes(size); return; default: - printk(KERN_ERR - "isapnp: unexpected or unknown tag type 0x%x for device %i, ignored\n", - type, card->number); + printk(KERN_ERR "isapnp: unexpected or unknown tag type 0x%x for device %i, ignored\n", type, card->number); } __skip: - if (size > 0) - isapnp_skip_bytes(size); + if (size > 0) + isapnp_skip_bytes(size); } } /* * Compute ISA PnP checksum for first eight bytes. */ + static unsigned char __init isapnp_checksum(unsigned char *data) { int i, j; @@ -808,9 +815,7 @@ static unsigned char __init isapnp_checksum(unsigned char *data) bit = 0; if (b & (1 << j)) bit = 1; - checksum = - ((((checksum ^ (checksum >> 1)) & 0x01) ^ bit) << 7) - | (checksum >> 1); + checksum = ((((checksum ^ (checksum >> 1)) & 0x01) ^ bit) << 7) | (checksum >> 1); } } return checksum; @@ -819,25 +824,27 @@ static unsigned char __init isapnp_checksum(unsigned char *data) /* * Parse EISA id for ISA PnP card. */ -static void isapnp_parse_card_id(struct pnp_card *card, unsigned short vendor, - unsigned short device) -{ - struct pnp_id *id = kzalloc(sizeof(struct pnp_id), GFP_KERNEL); +static void isapnp_parse_card_id(struct pnp_card * card, unsigned short vendor, unsigned short device) +{ + struct pnp_id * id = kzalloc(sizeof(struct pnp_id), GFP_KERNEL); if (!id) return; sprintf(id->id, "%c%c%c%x%x%x%x", - 'A' + ((vendor >> 2) & 0x3f) - 1, - 'A' + (((vendor & 3) << 3) | ((vendor >> 13) & 7)) - 1, - 'A' + ((vendor >> 8) & 0x1f) - 1, - (device >> 4) & 0x0f, - device & 0x0f, (device >> 12) & 0x0f, (device >> 8) & 0x0f); - pnp_add_card_id(id, card); + 'A' + ((vendor >> 2) & 0x3f) - 1, + 'A' + (((vendor & 3) << 3) | ((vendor >> 13) & 7)) - 1, + 'A' + ((vendor >> 8) & 0x1f) - 1, + (device >> 4) & 0x0f, + device & 0x0f, + (device >> 12) & 0x0f, + (device >> 8) & 0x0f); + pnp_add_card_id(id,card); } /* * Build device list for all present ISA PnP devices. */ + static int __init isapnp_build_device_list(void) { int csn; @@ -851,29 +858,22 @@ static int __init isapnp_build_device_list(void) isapnp_peek(header, 9); checksum = isapnp_checksum(header); #if 0 - printk(KERN_DEBUG - "vendor: %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n", - header[0], header[1], header[2], header[3], header[4], - header[5], header[6], header[7], header[8]); + printk(KERN_DEBUG "vendor: %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n", + header[0], header[1], header[2], header[3], + header[4], header[5], header[6], header[7], header[8]); printk(KERN_DEBUG "checksum = 0x%x\n", checksum); #endif - if ((card = - kzalloc(sizeof(struct pnp_card), GFP_KERNEL)) == NULL) + if ((card = kzalloc(sizeof(struct pnp_card), GFP_KERNEL)) == NULL) continue; card->number = csn; INIT_LIST_HEAD(&card->devices); - isapnp_parse_card_id(card, (header[1] << 8) | header[0], - (header[3] << 8) | header[2]); - card->serial = - (header[7] << 24) | (header[6] << 16) | (header[5] << 8) | - header[4]; + isapnp_parse_card_id(card, (header[1] << 8) | header[0], (header[3] << 8) | header[2]); + card->serial = (header[7] << 24) | (header[6] << 16) | (header[5] << 8) | header[4]; isapnp_checksum_value = 0x00; isapnp_parse_resource_map(card); if (isapnp_checksum_value != 0x00) - printk(KERN_ERR - "isapnp: checksum for device %i is not valid (0x%x)\n", - csn, isapnp_checksum_value); + printk(KERN_ERR "isapnp: checksum for device %i is not valid (0x%x)\n", csn, isapnp_checksum_value); card->checksum = isapnp_checksum_value; card->protocol = &isapnp_protocol; @@ -890,7 +890,6 @@ static int __init isapnp_build_device_list(void) int isapnp_present(void) { struct pnp_card *card; - pnp_for_each_card(card) { if (card->protocol == &isapnp_protocol) return 1; @@ -912,13 +911,13 @@ int isapnp_cfg_begin(int csn, int logdev) /* it is possible to set RDP only in the isolation phase */ /* Jens Thoms Toerring */ isapnp_write_byte(0x02, 0x04); /* clear CSN of card */ - mdelay(2); /* is this necessary? */ - isapnp_wake(csn); /* bring card into sleep state */ - isapnp_wake(0); /* bring card into isolation state */ - isapnp_set_rdp(); /* reset the RDP port */ - udelay(1000); /* delay 1000us */ + mdelay(2); /* is this necessary? */ + isapnp_wake(csn); /* bring card into sleep state */ + isapnp_wake(0); /* bring card into isolation state */ + isapnp_set_rdp(); /* reset the RDP port */ + udelay(1000); /* delay 1000us */ isapnp_write_byte(0x06, csn); /* reset CSN to previous value */ - udelay(250); /* is this necessary? */ + udelay(250); /* is this necessary? */ #endif if (logdev >= 0) isapnp_device(logdev); @@ -932,10 +931,12 @@ int isapnp_cfg_end(void) return 0; } + /* - * Initialization. + * Inititialization. */ + EXPORT_SYMBOL(isapnp_protocol); EXPORT_SYMBOL(isapnp_present); EXPORT_SYMBOL(isapnp_cfg_begin); @@ -945,8 +946,7 @@ EXPORT_SYMBOL(isapnp_read_byte); #endif EXPORT_SYMBOL(isapnp_write_byte); -static int isapnp_read_resources(struct pnp_dev *dev, - struct pnp_resource_table *res) +static int isapnp_read_resources(struct pnp_dev *dev, struct pnp_resource_table *res) { int tmp, ret; @@ -960,37 +960,31 @@ static int isapnp_read_resources(struct pnp_dev *dev, res->port_resource[tmp].flags = IORESOURCE_IO; } for (tmp = 0; tmp < PNP_MAX_MEM; tmp++) { - ret = - isapnp_read_word(ISAPNP_CFG_MEM + (tmp << 3)) << 8; + ret = isapnp_read_word(ISAPNP_CFG_MEM + (tmp << 3)) << 8; if (!ret) continue; res->mem_resource[tmp].start = ret; res->mem_resource[tmp].flags = IORESOURCE_MEM; } for (tmp = 0; tmp < PNP_MAX_IRQ; tmp++) { - ret = - (isapnp_read_word(ISAPNP_CFG_IRQ + (tmp << 1)) >> - 8); + ret = (isapnp_read_word(ISAPNP_CFG_IRQ + (tmp << 1)) >> 8); if (!ret) continue; - res->irq_resource[tmp].start = - res->irq_resource[tmp].end = ret; + res->irq_resource[tmp].start = res->irq_resource[tmp].end = ret; res->irq_resource[tmp].flags = IORESOURCE_IRQ; } for (tmp = 0; tmp < PNP_MAX_DMA; tmp++) { ret = isapnp_read_byte(ISAPNP_CFG_DMA + tmp); if (ret == 4) continue; - res->dma_resource[tmp].start = - res->dma_resource[tmp].end = ret; + res->dma_resource[tmp].start = res->dma_resource[tmp].end = ret; res->dma_resource[tmp].flags = IORESOURCE_DMA; } } return 0; } -static int isapnp_get_resources(struct pnp_dev *dev, - struct pnp_resource_table *res) +static int isapnp_get_resources(struct pnp_dev *dev, struct pnp_resource_table * res) { int ret; pnp_init_resource_table(res); @@ -1000,44 +994,24 @@ static int isapnp_get_resources(struct pnp_dev *dev, return ret; } -static int isapnp_set_resources(struct pnp_dev *dev, - struct pnp_resource_table *res) +static int isapnp_set_resources(struct pnp_dev *dev, struct pnp_resource_table * res) { int tmp; isapnp_cfg_begin(dev->card->number, dev->number); dev->active = 1; - for (tmp = 0; - tmp < PNP_MAX_PORT - && (res->port_resource[tmp]. - flags & (IORESOURCE_IO | IORESOURCE_UNSET)) == IORESOURCE_IO; - tmp++) - isapnp_write_word(ISAPNP_CFG_PORT + (tmp << 1), - res->port_resource[tmp].start); - for (tmp = 0; - tmp < PNP_MAX_IRQ - && (res->irq_resource[tmp]. - flags & (IORESOURCE_IRQ | IORESOURCE_UNSET)) == IORESOURCE_IRQ; - tmp++) { + for (tmp = 0; tmp < PNP_MAX_PORT && (res->port_resource[tmp].flags & (IORESOURCE_IO | IORESOURCE_UNSET)) == IORESOURCE_IO; tmp++) + isapnp_write_word(ISAPNP_CFG_PORT+(tmp<<1), res->port_resource[tmp].start); + for (tmp = 0; tmp < PNP_MAX_IRQ && (res->irq_resource[tmp].flags & (IORESOURCE_IRQ | IORESOURCE_UNSET)) == IORESOURCE_IRQ; tmp++) { int irq = res->irq_resource[tmp].start; if (irq == 2) irq = 9; - isapnp_write_byte(ISAPNP_CFG_IRQ + (tmp << 1), irq); + isapnp_write_byte(ISAPNP_CFG_IRQ+(tmp<<1), irq); } - for (tmp = 0; - tmp < PNP_MAX_DMA - && (res->dma_resource[tmp]. - flags & (IORESOURCE_DMA | IORESOURCE_UNSET)) == IORESOURCE_DMA; - tmp++) - isapnp_write_byte(ISAPNP_CFG_DMA + tmp, - res->dma_resource[tmp].start); - for (tmp = 0; - tmp < PNP_MAX_MEM - && (res->mem_resource[tmp]. - flags & (IORESOURCE_MEM | IORESOURCE_UNSET)) == IORESOURCE_MEM; - tmp++) - isapnp_write_word(ISAPNP_CFG_MEM + (tmp << 3), - (res->mem_resource[tmp].start >> 8) & 0xffff); + for (tmp = 0; tmp < PNP_MAX_DMA && (res->dma_resource[tmp].flags & (IORESOURCE_DMA | IORESOURCE_UNSET)) == IORESOURCE_DMA; tmp++) + isapnp_write_byte(ISAPNP_CFG_DMA+tmp, res->dma_resource[tmp].start); + for (tmp = 0; tmp < PNP_MAX_MEM && (res->mem_resource[tmp].flags & (IORESOURCE_MEM | IORESOURCE_UNSET)) == IORESOURCE_MEM; tmp++) + isapnp_write_word(ISAPNP_CFG_MEM+(tmp<<3), (res->mem_resource[tmp].start >> 8) & 0xffff); /* FIXME: We aren't handling 32bit mems properly here */ isapnp_activate(dev->number); isapnp_cfg_end(); @@ -1056,9 +1030,9 @@ static int isapnp_disable_resources(struct pnp_dev *dev) } struct pnp_protocol isapnp_protocol = { - .name = "ISA Plug and Play", - .get = isapnp_get_resources, - .set = isapnp_set_resources, + .name = "ISA Plug and Play", + .get = isapnp_get_resources, + .set = isapnp_set_resources, .disable = isapnp_disable_resources, }; @@ -1079,36 +1053,31 @@ static int __init isapnp_init(void) #endif #ifdef ISAPNP_REGION_OK if (!request_region(_PIDXR, 1, "isapnp index")) { - printk(KERN_ERR "isapnp: Index Register 0x%x already used\n", - _PIDXR); + printk(KERN_ERR "isapnp: Index Register 0x%x already used\n", _PIDXR); return -EBUSY; } #endif if (!request_region(_PNPWRP, 1, "isapnp write")) { - printk(KERN_ERR - "isapnp: Write Data Register 0x%x already used\n", - _PNPWRP); + printk(KERN_ERR "isapnp: Write Data Register 0x%x already used\n", _PNPWRP); #ifdef ISAPNP_REGION_OK release_region(_PIDXR, 1); #endif return -EBUSY; } - if (pnp_register_protocol(&isapnp_protocol) < 0) + if(pnp_register_protocol(&isapnp_protocol)<0) return -EBUSY; /* - * Print a message. The existing ISAPnP code is hanging machines - * so let the user know where. + * Print a message. The existing ISAPnP code is hanging machines + * so let the user know where. */ - + printk(KERN_INFO "isapnp: Scanning for PnP cards...\n"); if (isapnp_rdp >= 0x203 && isapnp_rdp <= 0x3ff) { isapnp_rdp |= 3; if (!request_region(isapnp_rdp, 1, "isapnp read")) { - printk(KERN_ERR - "isapnp: Read Data Register 0x%x already used\n", - isapnp_rdp); + printk(KERN_ERR "isapnp: Read Data Register 0x%x already used\n", isapnp_rdp); #ifdef ISAPNP_REGION_OK release_region(_PIDXR, 1); #endif @@ -1120,14 +1089,14 @@ static int __init isapnp_init(void) isapnp_detected = 1; if (isapnp_rdp < 0x203 || isapnp_rdp > 0x3ff) { cards = isapnp_isolate(); - if (cards < 0 || (isapnp_rdp < 0x203 || isapnp_rdp > 0x3ff)) { + if (cards < 0 || + (isapnp_rdp < 0x203 || isapnp_rdp > 0x3ff)) { #ifdef ISAPNP_REGION_OK release_region(_PIDXR, 1); #endif release_region(_PNPWRP, 1); isapnp_detected = 0; - printk(KERN_INFO - "isapnp: No Plug & Play device found\n"); + printk(KERN_INFO "isapnp: No Plug & Play device found\n"); return 0; } request_region(isapnp_rdp, 1, "isapnp read"); @@ -1135,23 +1104,19 @@ static int __init isapnp_init(void) isapnp_build_device_list(); cards = 0; - protocol_for_each_card(&isapnp_protocol, card) { + protocol_for_each_card(&isapnp_protocol,card) { cards++; if (isapnp_verbose) { - printk(KERN_INFO "isapnp: Card '%s'\n", - card->name[0] ? card->name : "Unknown"); + printk(KERN_INFO "isapnp: Card '%s'\n", card->name[0]?card->name:"Unknown"); if (isapnp_verbose < 2) continue; - card_for_each_dev(card, dev) { - printk(KERN_INFO "isapnp: Device '%s'\n", - dev->name[0] ? dev->name : "Unknown"); + card_for_each_dev(card,dev) { + printk(KERN_INFO "isapnp: Device '%s'\n", dev->name[0]?dev->name:"Unknown"); } } } if (cards) { - printk(KERN_INFO - "isapnp: %i Plug & Play card%s detected total\n", cards, - cards > 1 ? "s" : ""); + printk(KERN_INFO "isapnp: %i Plug & Play card%s detected total\n", cards, cards>1?"s":""); } else { printk(KERN_INFO "isapnp: No Plug & Play card found\n"); } @@ -1176,10 +1141,11 @@ __setup("noisapnp", isapnp_setup_disable); static int __init isapnp_setup_isapnp(char *str) { - (void)((get_option(&str, &isapnp_rdp) == 2) && - (get_option(&str, &isapnp_reset) == 2) && - (get_option(&str, &isapnp_verbose) == 2)); + (void)((get_option(&str,&isapnp_rdp) == 2) && + (get_option(&str,&isapnp_reset) == 2) && + (get_option(&str,&isapnp_verbose) == 2)); return 1; } __setup("isapnp=", isapnp_setup_isapnp); + diff --git a/trunk/drivers/pnp/isapnp/proc.c b/trunk/drivers/pnp/isapnp/proc.c index 3fbc0f9ffc26..40b724ebe23b 100644 --- a/trunk/drivers/pnp/isapnp/proc.c +++ b/trunk/drivers/pnp/isapnp/proc.c @@ -2,6 +2,7 @@ * ISA Plug & Play support * Copyright (c) by Jaroslav Kysela * + * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or @@ -15,6 +16,7 @@ * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * */ #include @@ -52,8 +54,7 @@ static loff_t isapnp_proc_bus_lseek(struct file *file, loff_t off, int whence) return (file->f_pos = new); } -static ssize_t isapnp_proc_bus_read(struct file *file, char __user * buf, - size_t nbytes, loff_t * ppos) +static ssize_t isapnp_proc_bus_read(struct file *file, char __user *buf, size_t nbytes, loff_t *ppos) { struct inode *ino = file->f_path.dentry->d_inode; struct proc_dir_entry *dp = PDE(ino); @@ -73,7 +74,7 @@ static ssize_t isapnp_proc_bus_read(struct file *file, char __user * buf, return -EINVAL; isapnp_cfg_begin(dev->card->number, dev->number); - for (; pos < 256 && cnt > 0; pos++, buf++, cnt--) { + for ( ; pos < 256 && cnt > 0; pos++, buf++, cnt--) { unsigned char val; val = isapnp_read_byte(pos); __put_user(val, buf); @@ -84,9 +85,10 @@ static ssize_t isapnp_proc_bus_read(struct file *file, char __user * buf, return nbytes; } -static const struct file_operations isapnp_proc_bus_file_operations = { - .llseek = isapnp_proc_bus_lseek, - .read = isapnp_proc_bus_read, +static const struct file_operations isapnp_proc_bus_file_operations = +{ + .llseek = isapnp_proc_bus_lseek, + .read = isapnp_proc_bus_read, }; static int isapnp_proc_attach_device(struct pnp_dev *dev) @@ -137,14 +139,13 @@ static int __exit isapnp_proc_detach_bus(struct pnp_card *bus) remove_proc_entry(name, isapnp_proc_bus_dir); return 0; } -#endif /* MODULE */ +#endif /* MODULE */ int __init isapnp_proc_init(void) { struct pnp_dev *dev; - isapnp_proc_bus_dir = proc_mkdir("isapnp", proc_bus); - protocol_for_each_dev(&isapnp_protocol, dev) { + protocol_for_each_dev(&isapnp_protocol,dev) { isapnp_proc_attach_device(dev); } return 0; @@ -166,4 +167,4 @@ int __exit isapnp_proc_done(void) remove_proc_entry("isapnp", proc_bus); return 0; } -#endif /* MODULE */ +#endif /* MODULE */ diff --git a/trunk/drivers/pnp/manager.c b/trunk/drivers/pnp/manager.c index 3bda513a6bd3..57e6ab1004d0 100644 --- a/trunk/drivers/pnp/manager.c +++ b/trunk/drivers/pnp/manager.c @@ -3,6 +3,7 @@ * * based on isapnp.c resource management (c) Jaroslav Kysela * Copyright 2003 Adam Belay + * */ #include @@ -25,8 +26,7 @@ static int pnp_assign_port(struct pnp_dev *dev, struct pnp_port *rule, int idx) return -EINVAL; if (idx >= PNP_MAX_PORT) { - pnp_err - ("More than 4 ports is incompatible with pnp specifications."); + pnp_err("More than 4 ports is incompatible with pnp specifications."); /* pretend we were successful so at least the manager won't try again */ return 1; } @@ -41,11 +41,11 @@ static int pnp_assign_port(struct pnp_dev *dev, struct pnp_port *rule, int idx) /* set the initial values */ *flags |= rule->flags | IORESOURCE_IO; - *flags &= ~IORESOURCE_UNSET; + *flags &= ~IORESOURCE_UNSET; if (!rule->size) { *flags |= IORESOURCE_DISABLED; - return 1; /* skip disabled resource requests */ + return 1; /* skip disabled resource requests */ } *start = rule->min; @@ -70,8 +70,7 @@ static int pnp_assign_mem(struct pnp_dev *dev, struct pnp_mem *rule, int idx) return -EINVAL; if (idx >= PNP_MAX_MEM) { - pnp_err - ("More than 8 mems is incompatible with pnp specifications."); + pnp_err("More than 8 mems is incompatible with pnp specifications."); /* pretend we were successful so at least the manager won't try again */ return 1; } @@ -86,7 +85,7 @@ static int pnp_assign_mem(struct pnp_dev *dev, struct pnp_mem *rule, int idx) /* set the initial values */ *flags |= rule->flags | IORESOURCE_MEM; - *flags &= ~IORESOURCE_UNSET; + *flags &= ~IORESOURCE_UNSET; /* convert pnp flags to standard Linux flags */ if (!(rule->flags & IORESOURCE_MEM_WRITEABLE)) @@ -100,11 +99,11 @@ static int pnp_assign_mem(struct pnp_dev *dev, struct pnp_mem *rule, int idx) if (!rule->size) { *flags |= IORESOURCE_DISABLED; - return 1; /* skip disabled resource requests */ + return 1; /* skip disabled resource requests */ } *start = rule->min; - *end = *start + rule->size - 1; + *end = *start + rule->size -1; /* run through until pnp_check_mem is happy */ while (!pnp_check_mem(dev, idx)) { @@ -116,7 +115,7 @@ static int pnp_assign_mem(struct pnp_dev *dev, struct pnp_mem *rule, int idx) return 1; } -static int pnp_assign_irq(struct pnp_dev *dev, struct pnp_irq *rule, int idx) +static int pnp_assign_irq(struct pnp_dev * dev, struct pnp_irq *rule, int idx) { resource_size_t *start, *end; unsigned long *flags; @@ -131,8 +130,7 @@ static int pnp_assign_irq(struct pnp_dev *dev, struct pnp_irq *rule, int idx) return -EINVAL; if (idx >= PNP_MAX_IRQ) { - pnp_err - ("More than 2 irqs is incompatible with pnp specifications."); + pnp_err("More than 2 irqs is incompatible with pnp specifications."); /* pretend we were successful so at least the manager won't try again */ return 1; } @@ -147,11 +145,11 @@ static int pnp_assign_irq(struct pnp_dev *dev, struct pnp_irq *rule, int idx) /* set the initial values */ *flags |= rule->flags | IORESOURCE_IRQ; - *flags &= ~IORESOURCE_UNSET; + *flags &= ~IORESOURCE_UNSET; if (bitmap_empty(rule->map, PNP_IRQ_NR)) { *flags |= IORESOURCE_DISABLED; - return 1; /* skip disabled resource requests */ + return 1; /* skip disabled resource requests */ } /* TBD: need check for >16 IRQ */ @@ -161,9 +159,9 @@ static int pnp_assign_irq(struct pnp_dev *dev, struct pnp_irq *rule, int idx) return 1; } for (i = 0; i < 16; i++) { - if (test_bit(xtab[i], rule->map)) { + if(test_bit(xtab[i], rule->map)) { *start = *end = xtab[i]; - if (pnp_check_irq(dev, idx)) + if(pnp_check_irq(dev, idx)) return 1; } } @@ -185,8 +183,7 @@ static int pnp_assign_dma(struct pnp_dev *dev, struct pnp_dma *rule, int idx) return -EINVAL; if (idx >= PNP_MAX_DMA) { - pnp_err - ("More than 2 dmas is incompatible with pnp specifications."); + pnp_err("More than 2 dmas is incompatible with pnp specifications."); /* pretend we were successful so at least the manager won't try again */ return 1; } @@ -201,17 +198,17 @@ static int pnp_assign_dma(struct pnp_dev *dev, struct pnp_dma *rule, int idx) /* set the initial values */ *flags |= rule->flags | IORESOURCE_DMA; - *flags &= ~IORESOURCE_UNSET; + *flags &= ~IORESOURCE_UNSET; if (!rule->map) { *flags |= IORESOURCE_DISABLED; - return 1; /* skip disabled resource requests */ + return 1; /* skip disabled resource requests */ } for (i = 0; i < 8; i++) { - if (rule->map & (1 << xtab[i])) { + if(rule->map & (1<irq_resource[idx].name = NULL; table->irq_resource[idx].start = -1; table->irq_resource[idx].end = -1; - table->irq_resource[idx].flags = - IORESOURCE_IRQ | IORESOURCE_AUTO | IORESOURCE_UNSET; + table->irq_resource[idx].flags = IORESOURCE_IRQ | IORESOURCE_AUTO | IORESOURCE_UNSET; } for (idx = 0; idx < PNP_MAX_DMA; idx++) { table->dma_resource[idx].name = NULL; table->dma_resource[idx].start = -1; table->dma_resource[idx].end = -1; - table->dma_resource[idx].flags = - IORESOURCE_DMA | IORESOURCE_AUTO | IORESOURCE_UNSET; + table->dma_resource[idx].flags = IORESOURCE_DMA | IORESOURCE_AUTO | IORESOURCE_UNSET; } for (idx = 0; idx < PNP_MAX_PORT; idx++) { table->port_resource[idx].name = NULL; table->port_resource[idx].start = 0; table->port_resource[idx].end = 0; - table->port_resource[idx].flags = - IORESOURCE_IO | IORESOURCE_AUTO | IORESOURCE_UNSET; + table->port_resource[idx].flags = IORESOURCE_IO | IORESOURCE_AUTO | IORESOURCE_UNSET; } for (idx = 0; idx < PNP_MAX_MEM; idx++) { table->mem_resource[idx].name = NULL; table->mem_resource[idx].start = 0; table->mem_resource[idx].end = 0; - table->mem_resource[idx].flags = - IORESOURCE_MEM | IORESOURCE_AUTO | IORESOURCE_UNSET; + table->mem_resource[idx].flags = IORESOURCE_MEM | IORESOURCE_AUTO | IORESOURCE_UNSET; } } /** * pnp_clean_resources - clears resources that were not manually set * @res: the resources to clean + * */ -static void pnp_clean_resource_table(struct pnp_resource_table *res) +static void pnp_clean_resource_table(struct pnp_resource_table * res) { int idx; - for (idx = 0; idx < PNP_MAX_IRQ; idx++) { if (!(res->irq_resource[idx].flags & IORESOURCE_AUTO)) continue; res->irq_resource[idx].start = -1; res->irq_resource[idx].end = -1; - res->irq_resource[idx].flags = - IORESOURCE_IRQ | IORESOURCE_AUTO | IORESOURCE_UNSET; + res->irq_resource[idx].flags = IORESOURCE_IRQ | IORESOURCE_AUTO | IORESOURCE_UNSET; } for (idx = 0; idx < PNP_MAX_DMA; idx++) { if (!(res->dma_resource[idx].flags & IORESOURCE_AUTO)) continue; res->dma_resource[idx].start = -1; res->dma_resource[idx].end = -1; - res->dma_resource[idx].flags = - IORESOURCE_DMA | IORESOURCE_AUTO | IORESOURCE_UNSET; + res->dma_resource[idx].flags = IORESOURCE_DMA | IORESOURCE_AUTO | IORESOURCE_UNSET; } for (idx = 0; idx < PNP_MAX_PORT; idx++) { if (!(res->port_resource[idx].flags & IORESOURCE_AUTO)) continue; res->port_resource[idx].start = 0; res->port_resource[idx].end = 0; - res->port_resource[idx].flags = - IORESOURCE_IO | IORESOURCE_AUTO | IORESOURCE_UNSET; + res->port_resource[idx].flags = IORESOURCE_IO | IORESOURCE_AUTO | IORESOURCE_UNSET; } for (idx = 0; idx < PNP_MAX_MEM; idx++) { if (!(res->mem_resource[idx].flags & IORESOURCE_AUTO)) continue; res->mem_resource[idx].start = 0; res->mem_resource[idx].end = 0; - res->mem_resource[idx].flags = - IORESOURCE_MEM | IORESOURCE_AUTO | IORESOURCE_UNSET; + res->mem_resource[idx].flags = IORESOURCE_MEM | IORESOURCE_AUTO | IORESOURCE_UNSET; } } @@ -317,7 +306,7 @@ static int pnp_assign_resources(struct pnp_dev *dev, int depnum) return -ENODEV; down(&pnp_res_mutex); - pnp_clean_resource_table(&dev->res); /* start with a fresh slate */ + pnp_clean_resource_table(&dev->res); /* start with a fresh slate */ if (dev->independent) { port = dev->independent->port; mem = dev->independent->mem; @@ -352,11 +341,10 @@ static int pnp_assign_resources(struct pnp_dev *dev, int depnum) if (depnum) { struct pnp_option *dep; int i; - for (i = 1, dep = dev->dependent; i < depnum; - i++, dep = dep->next) - if (!dep) + for (i=1,dep=dev->dependent; inext) + if(!dep) goto fail; - port = dep->port; + port =dep->port; mem = dep->mem; irq = dep->irq; dma = dep->dma; @@ -390,7 +378,7 @@ static int pnp_assign_resources(struct pnp_dev *dev, int depnum) up(&pnp_res_mutex); return 1; - fail: +fail: pnp_clean_resource_table(&dev->res); up(&pnp_res_mutex); return 0; @@ -404,12 +392,10 @@ static int pnp_assign_resources(struct pnp_dev *dev, int depnum) * * This function can be used by drivers that want to manually set thier resources. */ -int pnp_manual_config_dev(struct pnp_dev *dev, struct pnp_resource_table *res, - int mode) +int pnp_manual_config_dev(struct pnp_dev *dev, struct pnp_resource_table * res, int mode) { int i; - struct pnp_resource_table *bak; - + struct pnp_resource_table * bak; if (!dev || !res) return -EINVAL; if (!pnp_can_configure(dev)) @@ -423,19 +409,19 @@ int pnp_manual_config_dev(struct pnp_dev *dev, struct pnp_resource_table *res, dev->res = *res; if (!(mode & PNP_CONFIG_FORCE)) { for (i = 0; i < PNP_MAX_PORT; i++) { - if (!pnp_check_port(dev, i)) + if(!pnp_check_port(dev,i)) goto fail; } for (i = 0; i < PNP_MAX_MEM; i++) { - if (!pnp_check_mem(dev, i)) + if(!pnp_check_mem(dev,i)) goto fail; } for (i = 0; i < PNP_MAX_IRQ; i++) { - if (!pnp_check_irq(dev, i)) + if(!pnp_check_irq(dev,i)) goto fail; } for (i = 0; i < PNP_MAX_DMA; i++) { - if (!pnp_check_dma(dev, i)) + if(!pnp_check_dma(dev,i)) goto fail; } } @@ -444,7 +430,7 @@ int pnp_manual_config_dev(struct pnp_dev *dev, struct pnp_resource_table *res, kfree(bak); return 0; - fail: +fail: dev->res = *bak; up(&pnp_res_mutex); kfree(bak); @@ -454,18 +440,18 @@ int pnp_manual_config_dev(struct pnp_dev *dev, struct pnp_resource_table *res, /** * pnp_auto_config_dev - automatically assigns resources to a device * @dev: pointer to the desired device + * */ int pnp_auto_config_dev(struct pnp_dev *dev) { struct pnp_option *dep; int i = 1; - if (!dev) + if(!dev) return -EINVAL; - if (!pnp_can_configure(dev)) { - pnp_dbg("Device %s does not support resource configuration.", - dev->dev.bus_id); + if(!pnp_can_configure(dev)) { + pnp_dbg("Device %s does not support resource configuration.", dev->dev.bus_id); return -ENODEV; } @@ -490,22 +476,23 @@ int pnp_auto_config_dev(struct pnp_dev *dev) * pnp_start_dev - low-level start of the PnP device * @dev: pointer to the desired device * - * assumes that resources have already been allocated + * assumes that resources have alread been allocated */ + int pnp_start_dev(struct pnp_dev *dev) { if (!pnp_can_write(dev)) { - pnp_dbg("Device %s does not support activation.", - dev->dev.bus_id); + pnp_dbg("Device %s does not support activation.", dev->dev.bus_id); return -EINVAL; } - if (dev->protocol->set(dev, &dev->res) < 0) { + if (dev->protocol->set(dev, &dev->res)<0) { pnp_err("Failed to activate device %s.", dev->dev.bus_id); return -EIO; } pnp_info("Device %s activated.", dev->dev.bus_id); + return 0; } @@ -515,19 +502,20 @@ int pnp_start_dev(struct pnp_dev *dev) * * does not free resources */ + int pnp_stop_dev(struct pnp_dev *dev) { if (!pnp_can_disable(dev)) { - pnp_dbg("Device %s does not support disabling.", - dev->dev.bus_id); + pnp_dbg("Device %s does not support disabling.", dev->dev.bus_id); return -EINVAL; } - if (dev->protocol->disable(dev) < 0) { + if (dev->protocol->disable(dev)<0) { pnp_err("Failed to disable device %s.", dev->dev.bus_id); return -EIO; } pnp_info("Device %s disabled.", dev->dev.bus_id); + return 0; } @@ -543,8 +531,9 @@ int pnp_activate_dev(struct pnp_dev *dev) if (!dev) return -EINVAL; - if (dev->active) - return 0; /* the device is already active */ + if (dev->active) { + return 0; /* the device is already active */ + } /* ensure resources are allocated */ if (pnp_auto_config_dev(dev)) @@ -555,6 +544,7 @@ int pnp_activate_dev(struct pnp_dev *dev) return error; dev->active = 1; + return 1; } @@ -568,10 +558,11 @@ int pnp_disable_dev(struct pnp_dev *dev) { int error; - if (!dev) - return -EINVAL; - if (!dev->active) - return 0; /* the device is already disabled */ + if (!dev) + return -EINVAL; + if (!dev->active) { + return 0; /* the device is already disabled */ + } error = pnp_stop_dev(dev); if (error) @@ -592,9 +583,10 @@ int pnp_disable_dev(struct pnp_dev *dev) * @resource: pointer to resource to be changed * @start: start of region * @size: size of region + * */ void pnp_resource_change(struct resource *resource, resource_size_t start, - resource_size_t size) + resource_size_t size) { if (resource == NULL) return; @@ -603,7 +595,11 @@ void pnp_resource_change(struct resource *resource, resource_size_t start, resource->end = start + size - 1; } + EXPORT_SYMBOL(pnp_manual_config_dev); +#if 0 +EXPORT_SYMBOL(pnp_auto_config_dev); +#endif EXPORT_SYMBOL(pnp_start_dev); EXPORT_SYMBOL(pnp_stop_dev); EXPORT_SYMBOL(pnp_activate_dev); diff --git a/trunk/drivers/pnp/pnpacpi/core.c b/trunk/drivers/pnp/pnpacpi/core.c index 6a2a3c2f4d5e..fcd32ac575c3 100644 --- a/trunk/drivers/pnp/pnpacpi/core.c +++ b/trunk/drivers/pnp/pnpacpi/core.c @@ -34,13 +34,13 @@ static int num = 0; * used by the kernel (PCI root, ...), as it is harmless and there were * already present in pnpbios. But there is an exception for devices that * have irqs (PIC, Timer) because we call acpi_register_gsi. - * Finally, only devices that have a CRS method need to be in this list. + * Finaly only devices that have a CRS method need to be in this list. */ -static struct __initdata acpi_device_id excluded_id_list[] = { - {"PNP0C09", 0}, /* EC */ - {"PNP0C0F", 0}, /* Link device */ - {"PNP0000", 0}, /* PIC */ - {"PNP0100", 0}, /* Timer */ +static __initdata struct acpi_device_id excluded_id_list[] ={ + {"PNP0C09", 0}, /* EC */ + {"PNP0C0F", 0}, /* Link device */ + {"PNP0000", 0}, /* PIC */ + {"PNP0100", 0}, /* Timer */ {"", 0}, }; @@ -84,18 +84,15 @@ static void __init pnpidacpi_to_pnpid(char *id, char *str) str[7] = '\0'; } -static int pnpacpi_get_resources(struct pnp_dev *dev, - struct pnp_resource_table *res) +static int pnpacpi_get_resources(struct pnp_dev * dev, struct pnp_resource_table * res) { acpi_status status; - - status = pnpacpi_parse_allocated_resource((acpi_handle) dev->data, - &dev->res); + status = pnpacpi_parse_allocated_resource((acpi_handle)dev->data, + &dev->res); return ACPI_FAILURE(status) ? -ENODEV : 0; } -static int pnpacpi_set_resources(struct pnp_dev *dev, - struct pnp_resource_table *res) +static int pnpacpi_set_resources(struct pnp_dev * dev, struct pnp_resource_table * res) { acpi_handle handle = dev->data; struct acpi_buffer buffer; @@ -122,29 +119,27 @@ static int pnpacpi_disable_resources(struct pnp_dev *dev) acpi_status status; /* acpi_unregister_gsi(pnp_irq(dev, 0)); */ - status = acpi_evaluate_object((acpi_handle) dev->data, - "_DIS", NULL, NULL); + status = acpi_evaluate_object((acpi_handle)dev->data, + "_DIS", NULL, NULL); return ACPI_FAILURE(status) ? -ENODEV : 0; } static int pnpacpi_suspend(struct pnp_dev *dev, pm_message_t state) { - return acpi_bus_set_power((acpi_handle) dev->data, - acpi_pm_device_sleep_state(&dev->dev, - device_may_wakeup - (&dev->dev), - NULL)); + return acpi_bus_set_power((acpi_handle)dev->data, + acpi_pm_device_sleep_state(&dev->dev, + device_may_wakeup(&dev->dev), NULL)); } static int pnpacpi_resume(struct pnp_dev *dev) { - return acpi_bus_set_power((acpi_handle) dev->data, ACPI_STATE_D0); + return acpi_bus_set_power((acpi_handle)dev->data, ACPI_STATE_D0); } static struct pnp_protocol pnpacpi_protocol = { - .name = "Plug and Play ACPI", - .get = pnpacpi_get_resources, - .set = pnpacpi_set_resources, + .name = "Plug and Play ACPI", + .get = pnpacpi_get_resources, + .set = pnpacpi_set_resources, .disable = pnpacpi_disable_resources, .suspend = pnpacpi_suspend, .resume = pnpacpi_resume, @@ -159,17 +154,17 @@ static int __init pnpacpi_add_device(struct acpi_device *device) status = acpi_get_handle(device->handle, "_CRS", &temp); if (ACPI_FAILURE(status) || !ispnpidacpi(acpi_device_hid(device)) || - is_exclusive_device(device)) + is_exclusive_device(device)) return 0; pnp_dbg("ACPI device : hid %s", acpi_device_hid(device)); - dev = kzalloc(sizeof(struct pnp_dev), GFP_KERNEL); + dev = kzalloc(sizeof(struct pnp_dev), GFP_KERNEL); if (!dev) { pnp_err("Out of memory"); return -ENOMEM; } dev->data = device->handle; - /* .enabled means the device can decode the resources */ + /* .enabled means if the device can decode the resources */ dev->active = device->status.enabled; status = acpi_get_handle(device->handle, "_SRS", &temp); if (ACPI_SUCCESS(status)) @@ -199,23 +194,20 @@ static int __init pnpacpi_add_device(struct acpi_device *device) pnpidacpi_to_pnpid(acpi_device_hid(device), dev_id->id); pnp_add_id(dev_id, dev); - if (dev->active) { + if(dev->active) { /* parse allocated resource */ - status = pnpacpi_parse_allocated_resource(device->handle, - &dev->res); + status = pnpacpi_parse_allocated_resource(device->handle, &dev->res); if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) { - pnp_err("PnPACPI: METHOD_NAME__CRS failure for %s", - dev_id->id); + pnp_err("PnPACPI: METHOD_NAME__CRS failure for %s", dev_id->id); goto err1; } } - if (dev->capabilities & PNP_CONFIGURABLE) { + if(dev->capabilities & PNP_CONFIGURABLE) { status = pnpacpi_parse_resource_option_data(device->handle, - dev); + dev); if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) { - pnp_err("PnPACPI: METHOD_NAME__PRS failure for %s", - dev_id->id); + pnp_err("PnPACPI: METHOD_NAME__PRS failure for %s", dev_id->id); goto err1; } } @@ -241,19 +233,18 @@ static int __init pnpacpi_add_device(struct acpi_device *device) if (!dev->active) pnp_init_resource_table(&dev->res); pnp_add_device(dev); - num++; + num ++; return AE_OK; - err1: +err1: kfree(dev_id); - err: +err: kfree(dev); return -EINVAL; } static acpi_status __init pnpacpi_add_device_handler(acpi_handle handle, - u32 lvl, void *context, - void **rv) + u32 lvl, void *context, void **rv) { struct acpi_device *device; @@ -266,22 +257,23 @@ static acpi_status __init pnpacpi_add_device_handler(acpi_handle handle, static int __init acpi_pnp_match(struct device *dev, void *_pnp) { - struct acpi_device *acpi = to_acpi_device(dev); - struct pnp_dev *pnp = _pnp; + struct acpi_device *acpi = to_acpi_device(dev); + struct pnp_dev *pnp = _pnp; /* true means it matched */ return acpi->flags.hardware_id - && !acpi_get_physical_device(acpi->handle) - && compare_pnp_id(pnp->id, acpi->pnp.hardware_id); + && !acpi_get_physical_device(acpi->handle) + && compare_pnp_id(pnp->id, acpi->pnp.hardware_id); } -static int __init acpi_pnp_find_device(struct device *dev, acpi_handle * handle) +static int __init acpi_pnp_find_device(struct device *dev, acpi_handle *handle) { - struct device *adev; - struct acpi_device *acpi; + struct device *adev; + struct acpi_device *acpi; adev = bus_find_device(&acpi_bus_type, NULL, - to_pnp_dev(dev), acpi_pnp_match); + to_pnp_dev(dev), + acpi_pnp_match); if (!adev) return -ENODEV; @@ -295,7 +287,7 @@ static int __init acpi_pnp_find_device(struct device *dev, acpi_handle * handle) * pnpdev->dev.archdata.acpi_handle point to its ACPI sibling. */ static struct acpi_bus_type __initdata acpi_pnp_bus = { - .bus = &pnp_bus_type, + .bus = &pnp_bus_type, .find_device = acpi_pnp_find_device, }; @@ -315,7 +307,6 @@ static int __init pnpacpi_init(void) pnp_platform_devices = 1; return 0; } - subsys_initcall(pnpacpi_init); static int __init pnpacpi_setup(char *str) @@ -326,5 +317,8 @@ static int __init pnpacpi_setup(char *str) pnpacpi_disabled = 1; return 1; } - __setup("pnpacpi=", pnpacpi_setup); + +#if 0 +EXPORT_SYMBOL(pnpacpi_protocol); +#endif diff --git a/trunk/drivers/pnp/pnpacpi/rsparser.c b/trunk/drivers/pnp/pnpacpi/rsparser.c index ce5027feb3da..118ac9779b3c 100644 --- a/trunk/drivers/pnp/pnpacpi/rsparser.c +++ b/trunk/drivers/pnp/pnpacpi/rsparser.c @@ -40,7 +40,8 @@ static int irq_flags(int triggering, int polarity) flag = IORESOURCE_IRQ_LOWLEVEL; else flag = IORESOURCE_IRQ_HIGHLEVEL; - } else { + } + else { if (polarity == ACPI_ACTIVE_LOW) flag = IORESOURCE_IRQ_LOWEDGE; else @@ -71,9 +72,9 @@ static void decode_irq_flags(int flag, int *triggering, int *polarity) } } -static void pnpacpi_parse_allocated_irqresource(struct pnp_resource_table *res, - u32 gsi, int triggering, - int polarity, int shareable) +static void +pnpacpi_parse_allocated_irqresource(struct pnp_resource_table *res, u32 gsi, + int triggering, int polarity, int shareable) { int i = 0; int irq; @@ -82,12 +83,12 @@ static void pnpacpi_parse_allocated_irqresource(struct pnp_resource_table *res, return; while (!(res->irq_resource[i].flags & IORESOURCE_UNSET) && - i < PNP_MAX_IRQ) + i < PNP_MAX_IRQ) i++; if (i >= PNP_MAX_IRQ) return; - res->irq_resource[i].flags = IORESOURCE_IRQ; // Also clears _UNSET flag + res->irq_resource[i].flags = IORESOURCE_IRQ; // Also clears _UNSET flag res->irq_resource[i].flags |= irq_flags(triggering, polarity); irq = acpi_register_gsi(gsi, triggering, polarity); if (irq < 0) { @@ -146,19 +147,17 @@ static int dma_flags(int type, int bus_master, int transfer) return flags; } -static void pnpacpi_parse_allocated_dmaresource(struct pnp_resource_table *res, - u32 dma, int type, - int bus_master, int transfer) +static void +pnpacpi_parse_allocated_dmaresource(struct pnp_resource_table *res, u32 dma, + int type, int bus_master, int transfer) { int i = 0; - while (i < PNP_MAX_DMA && - !(res->dma_resource[i].flags & IORESOURCE_UNSET)) + !(res->dma_resource[i].flags & IORESOURCE_UNSET)) i++; if (i < PNP_MAX_DMA) { - res->dma_resource[i].flags = IORESOURCE_DMA; // Also clears _UNSET flag - res->dma_resource[i].flags |= - dma_flags(type, bus_master, transfer); + res->dma_resource[i].flags = IORESOURCE_DMA; // Also clears _UNSET flag + res->dma_resource[i].flags |= dma_flags(type, bus_master, transfer); if (dma == -1) { res->dma_resource[i].flags |= IORESOURCE_DISABLED; return; @@ -168,19 +167,19 @@ static void pnpacpi_parse_allocated_dmaresource(struct pnp_resource_table *res, } } -static void pnpacpi_parse_allocated_ioresource(struct pnp_resource_table *res, - u64 io, u64 len, int io_decode) +static void +pnpacpi_parse_allocated_ioresource(struct pnp_resource_table *res, + u64 io, u64 len, int io_decode) { int i = 0; - while (!(res->port_resource[i].flags & IORESOURCE_UNSET) && - i < PNP_MAX_PORT) + i < PNP_MAX_PORT) i++; if (i < PNP_MAX_PORT) { - res->port_resource[i].flags = IORESOURCE_IO; // Also clears _UNSET flag + res->port_resource[i].flags = IORESOURCE_IO; // Also clears _UNSET flag if (io_decode == ACPI_DECODE_16) res->port_resource[i].flags |= PNP_PORT_FLAG_16BITADDR; - if (len <= 0 || (io + len - 1) >= 0x10003) { + if (len <= 0 || (io + len -1) >= 0x10003) { res->port_resource[i].flags |= IORESOURCE_DISABLED; return; } @@ -189,22 +188,21 @@ static void pnpacpi_parse_allocated_ioresource(struct pnp_resource_table *res, } } -static void pnpacpi_parse_allocated_memresource(struct pnp_resource_table *res, - u64 mem, u64 len, - int write_protect) +static void +pnpacpi_parse_allocated_memresource(struct pnp_resource_table *res, + u64 mem, u64 len, int write_protect) { int i = 0; - while (!(res->mem_resource[i].flags & IORESOURCE_UNSET) && - (i < PNP_MAX_MEM)) + (i < PNP_MAX_MEM)) i++; if (i < PNP_MAX_MEM) { - res->mem_resource[i].flags = IORESOURCE_MEM; // Also clears _UNSET flag + res->mem_resource[i].flags = IORESOURCE_MEM; // Also clears _UNSET flag if (len <= 0) { res->mem_resource[i].flags |= IORESOURCE_DISABLED; return; } - if (write_protect == ACPI_READ_WRITE_MEMORY) + if(write_protect == ACPI_READ_WRITE_MEMORY) res->mem_resource[i].flags |= IORESOURCE_MEM_WRITEABLE; res->mem_resource[i].start = mem; @@ -212,8 +210,9 @@ static void pnpacpi_parse_allocated_memresource(struct pnp_resource_table *res, } } -static void pnpacpi_parse_allocated_address_space(struct pnp_resource_table *res_table, - struct acpi_resource *res) +static void +pnpacpi_parse_allocated_address_space(struct pnp_resource_table *res_table, + struct acpi_resource *res) { struct acpi_resource_address64 addr, *p = &addr; acpi_status status; @@ -221,7 +220,7 @@ static void pnpacpi_parse_allocated_address_space(struct pnp_resource_table *res status = acpi_resource_to_address64(res, p); if (!ACPI_SUCCESS(status)) { pnp_warn("PnPACPI: failed to convert resource type %d", - res->type); + res->type); return; } @@ -230,20 +229,17 @@ static void pnpacpi_parse_allocated_address_space(struct pnp_resource_table *res if (p->resource_type == ACPI_MEMORY_RANGE) pnpacpi_parse_allocated_memresource(res_table, - p->minimum, p->address_length, - p->info.mem.write_protect); + p->minimum, p->address_length, p->info.mem.write_protect); else if (p->resource_type == ACPI_IO_RANGE) pnpacpi_parse_allocated_ioresource(res_table, - p->minimum, p->address_length, - p->granularity == 0xfff ? ACPI_DECODE_10 : - ACPI_DECODE_16); + p->minimum, p->address_length, + p->granularity == 0xfff ? ACPI_DECODE_10 : ACPI_DECODE_16); } static acpi_status pnpacpi_allocated_resource(struct acpi_resource *res, - void *data) + void *data) { - struct pnp_resource_table *res_table = - (struct pnp_resource_table *)data; + struct pnp_resource_table *res_table = (struct pnp_resource_table *)data; int i; switch (res->type) { @@ -264,17 +260,17 @@ static acpi_status pnpacpi_allocated_resource(struct acpi_resource *res, case ACPI_RESOURCE_TYPE_DMA: if (res->data.dma.channel_count > 0) pnpacpi_parse_allocated_dmaresource(res_table, - res->data.dma.channels[0], - res->data.dma.type, - res->data.dma.bus_master, - res->data.dma.transfer); + res->data.dma.channels[0], + res->data.dma.type, + res->data.dma.bus_master, + res->data.dma.transfer); break; case ACPI_RESOURCE_TYPE_IO: pnpacpi_parse_allocated_ioresource(res_table, - res->data.io.minimum, - res->data.io.address_length, - res->data.io.io_decode); + res->data.io.minimum, + res->data.io.address_length, + res->data.io.io_decode); break; case ACPI_RESOURCE_TYPE_START_DEPENDENT: @@ -283,9 +279,9 @@ static acpi_status pnpacpi_allocated_resource(struct acpi_resource *res, case ACPI_RESOURCE_TYPE_FIXED_IO: pnpacpi_parse_allocated_ioresource(res_table, - res->data.fixed_io.address, - res->data.fixed_io.address_length, - ACPI_DECODE_10); + res->data.fixed_io.address, + res->data.fixed_io.address_length, + ACPI_DECODE_10); break; case ACPI_RESOURCE_TYPE_VENDOR: @@ -296,21 +292,21 @@ static acpi_status pnpacpi_allocated_resource(struct acpi_resource *res, case ACPI_RESOURCE_TYPE_MEMORY24: pnpacpi_parse_allocated_memresource(res_table, - res->data.memory24.minimum, - res->data.memory24.address_length, - res->data.memory24.write_protect); + res->data.memory24.minimum, + res->data.memory24.address_length, + res->data.memory24.write_protect); break; case ACPI_RESOURCE_TYPE_MEMORY32: pnpacpi_parse_allocated_memresource(res_table, - res->data.memory32.minimum, - res->data.memory32.address_length, - res->data.memory32.write_protect); + res->data.memory32.minimum, + res->data.memory32.address_length, + res->data.memory32.write_protect); break; case ACPI_RESOURCE_TYPE_FIXED_MEMORY32: pnpacpi_parse_allocated_memresource(res_table, - res->data.fixed_memory32.address, - res->data.fixed_memory32.address_length, - res->data.fixed_memory32.write_protect); + res->data.fixed_memory32.address, + res->data.fixed_memory32.address_length, + res->data.fixed_memory32.write_protect); break; case ACPI_RESOURCE_TYPE_ADDRESS16: case ACPI_RESOURCE_TYPE_ADDRESS32: @@ -347,21 +343,18 @@ static acpi_status pnpacpi_allocated_resource(struct acpi_resource *res, return AE_OK; } -acpi_status pnpacpi_parse_allocated_resource(acpi_handle handle, - struct pnp_resource_table * res) +acpi_status pnpacpi_parse_allocated_resource(acpi_handle handle, struct pnp_resource_table *res) { /* Blank the resource table values */ pnp_init_resource_table(res); - return acpi_walk_resources(handle, METHOD_NAME__CRS, - pnpacpi_allocated_resource, res); + return acpi_walk_resources(handle, METHOD_NAME__CRS, pnpacpi_allocated_resource, res); } -static void pnpacpi_parse_dma_option(struct pnp_option *option, - struct acpi_resource_dma *p) +static void pnpacpi_parse_dma_option(struct pnp_option *option, struct acpi_resource_dma *p) { int i; - struct pnp_dma *dma; + struct pnp_dma * dma; if (p->channel_count == 0) return; @@ -369,16 +362,18 @@ static void pnpacpi_parse_dma_option(struct pnp_option *option, if (!dma) return; - for (i = 0; i < p->channel_count; i++) + for(i = 0; i < p->channel_count; i++) dma->map |= 1 << p->channels[i]; dma->flags = dma_flags(p->type, p->bus_master, p->transfer); pnp_register_dma_resource(option, dma); + return; } + static void pnpacpi_parse_irq_option(struct pnp_option *option, - struct acpi_resource_irq *p) + struct acpi_resource_irq *p) { int i; struct pnp_irq *irq; @@ -389,16 +384,17 @@ static void pnpacpi_parse_irq_option(struct pnp_option *option, if (!irq) return; - for (i = 0; i < p->interrupt_count; i++) + for(i = 0; i < p->interrupt_count; i++) if (p->interrupts[i]) __set_bit(p->interrupts[i], irq->map); irq->flags = irq_flags(p->triggering, p->polarity); pnp_register_irq_resource(option, irq); + return; } static void pnpacpi_parse_ext_irq_option(struct pnp_option *option, - struct acpi_resource_extended_irq *p) + struct acpi_resource_extended_irq *p) { int i; struct pnp_irq *irq; @@ -409,16 +405,18 @@ static void pnpacpi_parse_ext_irq_option(struct pnp_option *option, if (!irq) return; - for (i = 0; i < p->interrupt_count; i++) + for(i = 0; i < p->interrupt_count; i++) if (p->interrupts[i]) __set_bit(p->interrupts[i], irq->map); irq->flags = irq_flags(p->triggering, p->polarity); pnp_register_irq_resource(option, irq); + return; } -static void pnpacpi_parse_port_option(struct pnp_option *option, - struct acpi_resource_io *io) +static void +pnpacpi_parse_port_option(struct pnp_option *option, + struct acpi_resource_io *io) { struct pnp_port *port; @@ -432,12 +430,14 @@ static void pnpacpi_parse_port_option(struct pnp_option *option, port->align = io->alignment; port->size = io->address_length; port->flags = ACPI_DECODE_16 == io->io_decode ? - PNP_PORT_FLAG_16BITADDR : 0; + PNP_PORT_FLAG_16BITADDR : 0; pnp_register_port_resource(option, port); + return; } -static void pnpacpi_parse_fixed_port_option(struct pnp_option *option, - struct acpi_resource_fixed_io *io) +static void +pnpacpi_parse_fixed_port_option(struct pnp_option *option, + struct acpi_resource_fixed_io *io) { struct pnp_port *port; @@ -451,10 +451,12 @@ static void pnpacpi_parse_fixed_port_option(struct pnp_option *option, port->align = 0; port->flags = PNP_PORT_FLAG_FIXED; pnp_register_port_resource(option, port); + return; } -static void pnpacpi_parse_mem24_option(struct pnp_option *option, - struct acpi_resource_memory24 *p) +static void +pnpacpi_parse_mem24_option(struct pnp_option *option, + struct acpi_resource_memory24 *p) { struct pnp_mem *mem; @@ -469,13 +471,15 @@ static void pnpacpi_parse_mem24_option(struct pnp_option *option, mem->size = p->address_length; mem->flags = (ACPI_READ_WRITE_MEMORY == p->write_protect) ? - IORESOURCE_MEM_WRITEABLE : 0; + IORESOURCE_MEM_WRITEABLE : 0; pnp_register_mem_resource(option, mem); + return; } -static void pnpacpi_parse_mem32_option(struct pnp_option *option, - struct acpi_resource_memory32 *p) +static void +pnpacpi_parse_mem32_option(struct pnp_option *option, + struct acpi_resource_memory32 *p) { struct pnp_mem *mem; @@ -490,13 +494,15 @@ static void pnpacpi_parse_mem32_option(struct pnp_option *option, mem->size = p->address_length; mem->flags = (ACPI_READ_WRITE_MEMORY == p->write_protect) ? - IORESOURCE_MEM_WRITEABLE : 0; + IORESOURCE_MEM_WRITEABLE : 0; pnp_register_mem_resource(option, mem); + return; } -static void pnpacpi_parse_fixed_mem32_option(struct pnp_option *option, - struct acpi_resource_fixed_memory32 *p) +static void +pnpacpi_parse_fixed_mem32_option(struct pnp_option *option, + struct acpi_resource_fixed_memory32 *p) { struct pnp_mem *mem; @@ -510,13 +516,14 @@ static void pnpacpi_parse_fixed_mem32_option(struct pnp_option *option, mem->align = 0; mem->flags = (ACPI_READ_WRITE_MEMORY == p->write_protect) ? - IORESOURCE_MEM_WRITEABLE : 0; + IORESOURCE_MEM_WRITEABLE : 0; pnp_register_mem_resource(option, mem); + return; } -static void pnpacpi_parse_address_option(struct pnp_option *option, - struct acpi_resource *r) +static void +pnpacpi_parse_address_option(struct pnp_option *option, struct acpi_resource *r) { struct acpi_resource_address64 addr, *p = &addr; acpi_status status; @@ -525,8 +532,7 @@ static void pnpacpi_parse_address_option(struct pnp_option *option, status = acpi_resource_to_address64(r, p); if (!ACPI_SUCCESS(status)) { - pnp_warn("PnPACPI: failed to convert resource type %d", - r->type); + pnp_warn("PnPACPI: failed to convert resource type %d", r->type); return; } @@ -541,8 +547,7 @@ static void pnpacpi_parse_address_option(struct pnp_option *option, mem->size = p->address_length; mem->align = 0; mem->flags = (p->info.mem.write_protect == - ACPI_READ_WRITE_MEMORY) ? IORESOURCE_MEM_WRITEABLE - : 0; + ACPI_READ_WRITE_MEMORY) ? IORESOURCE_MEM_WRITEABLE : 0; pnp_register_mem_resource(option, mem); } else if (p->resource_type == ACPI_IO_RANGE) { port = kzalloc(sizeof(struct pnp_port), GFP_KERNEL); @@ -563,108 +568,109 @@ struct acpipnp_parse_option_s { }; static acpi_status pnpacpi_option_resource(struct acpi_resource *res, - void *data) + void *data) { int priority = 0; - struct acpipnp_parse_option_s *parse_data = - (struct acpipnp_parse_option_s *)data; + struct acpipnp_parse_option_s *parse_data = (struct acpipnp_parse_option_s *)data; struct pnp_dev *dev = parse_data->dev; struct pnp_option *option = parse_data->option; switch (res->type) { - case ACPI_RESOURCE_TYPE_IRQ: - pnpacpi_parse_irq_option(option, &res->data.irq); - break; - - case ACPI_RESOURCE_TYPE_DMA: - pnpacpi_parse_dma_option(option, &res->data.dma); - break; - - case ACPI_RESOURCE_TYPE_START_DEPENDENT: - switch (res->data.start_dpf.compatibility_priority) { - case ACPI_GOOD_CONFIGURATION: - priority = PNP_RES_PRIORITY_PREFERRED; + case ACPI_RESOURCE_TYPE_IRQ: + pnpacpi_parse_irq_option(option, &res->data.irq); break; - case ACPI_ACCEPTABLE_CONFIGURATION: - priority = PNP_RES_PRIORITY_ACCEPTABLE; + case ACPI_RESOURCE_TYPE_DMA: + pnpacpi_parse_dma_option(option, &res->data.dma); break; - case ACPI_SUB_OPTIMAL_CONFIGURATION: - priority = PNP_RES_PRIORITY_FUNCTIONAL; - break; - default: - priority = PNP_RES_PRIORITY_INVALID; + case ACPI_RESOURCE_TYPE_START_DEPENDENT: + switch (res->data.start_dpf.compatibility_priority) { + case ACPI_GOOD_CONFIGURATION: + priority = PNP_RES_PRIORITY_PREFERRED; + break; + + case ACPI_ACCEPTABLE_CONFIGURATION: + priority = PNP_RES_PRIORITY_ACCEPTABLE; + break; + + case ACPI_SUB_OPTIMAL_CONFIGURATION: + priority = PNP_RES_PRIORITY_FUNCTIONAL; + break; + default: + priority = PNP_RES_PRIORITY_INVALID; + break; + } + /* TBD: Considering performace/robustness bits */ + option = pnp_register_dependent_option(dev, priority); + if (!option) + return AE_ERROR; + parse_data->option = option; break; - } - /* TBD: Consider performance/robustness bits */ - option = pnp_register_dependent_option(dev, priority); - if (!option) - return AE_ERROR; - parse_data->option = option; - break; - case ACPI_RESOURCE_TYPE_END_DEPENDENT: - /*only one EndDependentFn is allowed */ - if (!parse_data->option_independent) { - pnp_warn("PnPACPI: more than one EndDependentFn"); - return AE_ERROR; - } - parse_data->option = parse_data->option_independent; - parse_data->option_independent = NULL; - break; + case ACPI_RESOURCE_TYPE_END_DEPENDENT: + /*only one EndDependentFn is allowed*/ + if (!parse_data->option_independent) { + pnp_warn("PnPACPI: more than one EndDependentFn"); + return AE_ERROR; + } + parse_data->option = parse_data->option_independent; + parse_data->option_independent = NULL; + break; - case ACPI_RESOURCE_TYPE_IO: - pnpacpi_parse_port_option(option, &res->data.io); - break; + case ACPI_RESOURCE_TYPE_IO: + pnpacpi_parse_port_option(option, &res->data.io); + break; - case ACPI_RESOURCE_TYPE_FIXED_IO: - pnpacpi_parse_fixed_port_option(option, &res->data.fixed_io); - break; + case ACPI_RESOURCE_TYPE_FIXED_IO: + pnpacpi_parse_fixed_port_option(option, + &res->data.fixed_io); + break; - case ACPI_RESOURCE_TYPE_VENDOR: - case ACPI_RESOURCE_TYPE_END_TAG: - break; + case ACPI_RESOURCE_TYPE_VENDOR: + case ACPI_RESOURCE_TYPE_END_TAG: + break; - case ACPI_RESOURCE_TYPE_MEMORY24: - pnpacpi_parse_mem24_option(option, &res->data.memory24); - break; + case ACPI_RESOURCE_TYPE_MEMORY24: + pnpacpi_parse_mem24_option(option, &res->data.memory24); + break; - case ACPI_RESOURCE_TYPE_MEMORY32: - pnpacpi_parse_mem32_option(option, &res->data.memory32); - break; + case ACPI_RESOURCE_TYPE_MEMORY32: + pnpacpi_parse_mem32_option(option, &res->data.memory32); + break; - case ACPI_RESOURCE_TYPE_FIXED_MEMORY32: - pnpacpi_parse_fixed_mem32_option(option, - &res->data.fixed_memory32); - break; + case ACPI_RESOURCE_TYPE_FIXED_MEMORY32: + pnpacpi_parse_fixed_mem32_option(option, + &res->data.fixed_memory32); + break; - case ACPI_RESOURCE_TYPE_ADDRESS16: - case ACPI_RESOURCE_TYPE_ADDRESS32: - case ACPI_RESOURCE_TYPE_ADDRESS64: - pnpacpi_parse_address_option(option, res); - break; + case ACPI_RESOURCE_TYPE_ADDRESS16: + case ACPI_RESOURCE_TYPE_ADDRESS32: + case ACPI_RESOURCE_TYPE_ADDRESS64: + pnpacpi_parse_address_option(option, res); + break; - case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64: - break; + case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64: + break; - case ACPI_RESOURCE_TYPE_EXTENDED_IRQ: - pnpacpi_parse_ext_irq_option(option, &res->data.extended_irq); - break; + case ACPI_RESOURCE_TYPE_EXTENDED_IRQ: + pnpacpi_parse_ext_irq_option(option, + &res->data.extended_irq); + break; - case ACPI_RESOURCE_TYPE_GENERIC_REGISTER: - break; + case ACPI_RESOURCE_TYPE_GENERIC_REGISTER: + break; - default: - pnp_warn("PnPACPI: unknown resource type %d", res->type); - return AE_ERROR; + default: + pnp_warn("PnPACPI: unknown resource type %d", res->type); + return AE_ERROR; } return AE_OK; } acpi_status pnpacpi_parse_resource_option_data(acpi_handle handle, - struct pnp_dev * dev) + struct pnp_dev *dev) { acpi_status status; struct acpipnp_parse_option_s parse_data; @@ -675,7 +681,7 @@ acpi_status pnpacpi_parse_resource_option_data(acpi_handle handle, parse_data.option_independent = parse_data.option; parse_data.dev = dev; status = acpi_walk_resources(handle, METHOD_NAME__PRS, - pnpacpi_option_resource, &parse_data); + pnpacpi_option_resource, &parse_data); return status; } @@ -703,7 +709,7 @@ static int pnpacpi_supported_resource(struct acpi_resource *res) * Set resource */ static acpi_status pnpacpi_count_resources(struct acpi_resource *res, - void *data) + void *data) { int *res_cnt = (int *)data; @@ -726,14 +732,14 @@ static acpi_status pnpacpi_type_resources(struct acpi_resource *res, void *data) } int pnpacpi_build_resource_template(acpi_handle handle, - struct acpi_buffer *buffer) + struct acpi_buffer *buffer) { struct acpi_resource *resource; int res_cnt = 0; acpi_status status; status = acpi_walk_resources(handle, METHOD_NAME__CRS, - pnpacpi_count_resources, &res_cnt); + pnpacpi_count_resources, &res_cnt); if (ACPI_FAILURE(status)) { pnp_err("Evaluate _CRS failed"); return -EINVAL; @@ -747,7 +753,7 @@ int pnpacpi_build_resource_template(acpi_handle handle, pnp_dbg("Res cnt %d", res_cnt); resource = (struct acpi_resource *)buffer->pointer; status = acpi_walk_resources(handle, METHOD_NAME__CRS, - pnpacpi_type_resources, &resource); + pnpacpi_type_resources, &resource); if (ACPI_FAILURE(status)) { kfree(buffer->pointer); pnp_err("Evaluate _CRS failed"); @@ -760,7 +766,7 @@ int pnpacpi_build_resource_template(acpi_handle handle, } static void pnpacpi_encode_irq(struct acpi_resource *resource, - struct resource *p) + struct resource *p) { int triggering, polarity; @@ -776,7 +782,7 @@ static void pnpacpi_encode_irq(struct acpi_resource *resource, } static void pnpacpi_encode_ext_irq(struct acpi_resource *resource, - struct resource *p) + struct resource *p) { int triggering, polarity; @@ -793,32 +799,32 @@ static void pnpacpi_encode_ext_irq(struct acpi_resource *resource, } static void pnpacpi_encode_dma(struct acpi_resource *resource, - struct resource *p) + struct resource *p) { /* Note: pnp_assign_dma will copy pnp_dma->flags into p->flags */ switch (p->flags & IORESOURCE_DMA_SPEED_MASK) { - case IORESOURCE_DMA_TYPEA: - resource->data.dma.type = ACPI_TYPE_A; - break; - case IORESOURCE_DMA_TYPEB: - resource->data.dma.type = ACPI_TYPE_B; - break; - case IORESOURCE_DMA_TYPEF: - resource->data.dma.type = ACPI_TYPE_F; - break; - default: - resource->data.dma.type = ACPI_COMPATIBILITY; + case IORESOURCE_DMA_TYPEA: + resource->data.dma.type = ACPI_TYPE_A; + break; + case IORESOURCE_DMA_TYPEB: + resource->data.dma.type = ACPI_TYPE_B; + break; + case IORESOURCE_DMA_TYPEF: + resource->data.dma.type = ACPI_TYPE_F; + break; + default: + resource->data.dma.type = ACPI_COMPATIBILITY; } switch (p->flags & IORESOURCE_DMA_TYPE_MASK) { - case IORESOURCE_DMA_8BIT: - resource->data.dma.transfer = ACPI_TRANSFER_8; - break; - case IORESOURCE_DMA_8AND16BIT: - resource->data.dma.transfer = ACPI_TRANSFER_8_16; - break; - default: - resource->data.dma.transfer = ACPI_TRANSFER_16; + case IORESOURCE_DMA_8BIT: + resource->data.dma.transfer = ACPI_TRANSFER_8; + break; + case IORESOURCE_DMA_8AND16BIT: + resource->data.dma.transfer = ACPI_TRANSFER_8_16; + break; + default: + resource->data.dma.transfer = ACPI_TRANSFER_16; } resource->data.dma.bus_master = !!(p->flags & IORESOURCE_DMA_MASTER); @@ -827,31 +833,31 @@ static void pnpacpi_encode_dma(struct acpi_resource *resource, } static void pnpacpi_encode_io(struct acpi_resource *resource, - struct resource *p) + struct resource *p) { /* Note: pnp_assign_port will copy pnp_port->flags into p->flags */ - resource->data.io.io_decode = (p->flags & PNP_PORT_FLAG_16BITADDR) ? - ACPI_DECODE_16 : ACPI_DECODE_10; + resource->data.io.io_decode = (p->flags & PNP_PORT_FLAG_16BITADDR)? + ACPI_DECODE_16 : ACPI_DECODE_10; resource->data.io.minimum = p->start; resource->data.io.maximum = p->end; - resource->data.io.alignment = 0; /* Correct? */ + resource->data.io.alignment = 0; /* Correct? */ resource->data.io.address_length = p->end - p->start + 1; } static void pnpacpi_encode_fixed_io(struct acpi_resource *resource, - struct resource *p) + struct resource *p) { resource->data.fixed_io.address = p->start; resource->data.fixed_io.address_length = p->end - p->start + 1; } static void pnpacpi_encode_mem24(struct acpi_resource *resource, - struct resource *p) + struct resource *p) { /* Note: pnp_assign_mem will copy pnp_mem->flags into p->flags */ resource->data.memory24.write_protect = - (p->flags & IORESOURCE_MEM_WRITEABLE) ? - ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY; + (p->flags & IORESOURCE_MEM_WRITEABLE) ? + ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY; resource->data.memory24.minimum = p->start; resource->data.memory24.maximum = p->end; resource->data.memory24.alignment = 0; @@ -859,11 +865,11 @@ static void pnpacpi_encode_mem24(struct acpi_resource *resource, } static void pnpacpi_encode_mem32(struct acpi_resource *resource, - struct resource *p) + struct resource *p) { resource->data.memory32.write_protect = - (p->flags & IORESOURCE_MEM_WRITEABLE) ? - ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY; + (p->flags & IORESOURCE_MEM_WRITEABLE) ? + ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY; resource->data.memory32.minimum = p->start; resource->data.memory32.maximum = p->end; resource->data.memory32.alignment = 0; @@ -871,77 +877,74 @@ static void pnpacpi_encode_mem32(struct acpi_resource *resource, } static void pnpacpi_encode_fixed_mem32(struct acpi_resource *resource, - struct resource *p) + struct resource *p) { resource->data.fixed_memory32.write_protect = - (p->flags & IORESOURCE_MEM_WRITEABLE) ? - ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY; + (p->flags & IORESOURCE_MEM_WRITEABLE) ? + ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY; resource->data.fixed_memory32.address = p->start; resource->data.fixed_memory32.address_length = p->end - p->start + 1; } int pnpacpi_encode_resources(struct pnp_resource_table *res_table, - struct acpi_buffer *buffer) + struct acpi_buffer *buffer) { int i = 0; /* pnpacpi_build_resource_template allocates extra mem */ - int res_cnt = (buffer->length - 1) / sizeof(struct acpi_resource) - 1; - struct acpi_resource *resource = - (struct acpi_resource *)buffer->pointer; + int res_cnt = (buffer->length - 1)/sizeof(struct acpi_resource) - 1; + struct acpi_resource *resource = (struct acpi_resource*)buffer->pointer; int port = 0, irq = 0, dma = 0, mem = 0; pnp_dbg("res cnt %d", res_cnt); while (i < res_cnt) { - switch (resource->type) { + switch(resource->type) { case ACPI_RESOURCE_TYPE_IRQ: pnp_dbg("Encode irq"); pnpacpi_encode_irq(resource, - &res_table->irq_resource[irq]); + &res_table->irq_resource[irq]); irq++; break; case ACPI_RESOURCE_TYPE_DMA: pnp_dbg("Encode dma"); pnpacpi_encode_dma(resource, - &res_table->dma_resource[dma]); + &res_table->dma_resource[dma]); dma++; break; case ACPI_RESOURCE_TYPE_IO: pnp_dbg("Encode io"); pnpacpi_encode_io(resource, - &res_table->port_resource[port]); + &res_table->port_resource[port]); port++; break; case ACPI_RESOURCE_TYPE_FIXED_IO: pnp_dbg("Encode fixed io"); pnpacpi_encode_fixed_io(resource, - &res_table-> - port_resource[port]); + &res_table->port_resource[port]); port++; break; case ACPI_RESOURCE_TYPE_MEMORY24: pnp_dbg("Encode mem24"); pnpacpi_encode_mem24(resource, - &res_table->mem_resource[mem]); + &res_table->mem_resource[mem]); mem++; break; case ACPI_RESOURCE_TYPE_MEMORY32: pnp_dbg("Encode mem32"); pnpacpi_encode_mem32(resource, - &res_table->mem_resource[mem]); + &res_table->mem_resource[mem]); mem++; break; case ACPI_RESOURCE_TYPE_FIXED_MEMORY32: pnp_dbg("Encode fixed mem32"); pnpacpi_encode_fixed_mem32(resource, - &res_table-> - mem_resource[mem]); + &res_table->mem_resource[mem]); mem++; break; case ACPI_RESOURCE_TYPE_EXTENDED_IRQ: pnp_dbg("Encode ext irq"); pnpacpi_encode_ext_irq(resource, - &res_table->irq_resource[irq]); + &res_table->irq_resource[irq]); irq++; break; case ACPI_RESOURCE_TYPE_START_DEPENDENT: @@ -953,7 +956,7 @@ int pnpacpi_encode_resources(struct pnp_resource_table *res_table, case ACPI_RESOURCE_TYPE_ADDRESS64: case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64: case ACPI_RESOURCE_TYPE_GENERIC_REGISTER: - default: /* other type */ + default: /* other type */ pnp_warn("unknown resource type %d", resource->type); return -EINVAL; } diff --git a/trunk/drivers/pnp/pnpbios/bioscalls.c b/trunk/drivers/pnp/pnpbios/bioscalls.c index 5dba68fe33f5..a1f0b0ba2bfe 100644 --- a/trunk/drivers/pnp/pnpbios/bioscalls.c +++ b/trunk/drivers/pnp/pnpbios/bioscalls.c @@ -1,5 +1,6 @@ /* * bioscalls.c - the lowlevel layer of the PnPBIOS driver + * */ #include @@ -25,10 +26,11 @@ #include "pnpbios.h" static struct { - u16 offset; - u16 segment; + u16 offset; + u16 segment; } pnp_bios_callpoint; + /* * These are some opcodes for a "static asmlinkage" * As this code is *not* executed inside the linux kernel segment, but in a @@ -42,7 +44,8 @@ static struct { asmlinkage void pnp_bios_callfunc(void); -__asm__(".text \n" +__asm__( + ".text \n" __ALIGN_STR "\n" "pnp_bios_callfunc:\n" " pushl %edx \n" @@ -52,7 +55,8 @@ __asm__(".text \n" " lcallw *pnp_bios_callpoint\n" " addl $16, %esp \n" " lret \n" - ".previous \n"); + ".previous \n" +); #define Q2_SET_SEL(cpu, selname, address, size) \ do { \ @@ -74,6 +78,7 @@ u32 pnp_bios_is_utter_crap = 0; static spinlock_t pnp_bios_lock; + /* * Support Functions */ @@ -92,7 +97,7 @@ static inline u16 call_pnp_bios(u16 func, u16 arg1, u16 arg2, u16 arg3, * PnP BIOSes are generally not terribly re-entrant. * Also, don't rely on them to save everything correctly. */ - if (pnp_bios_is_utter_crap) + if(pnp_bios_is_utter_crap) return PNP_FUNCTION_NOT_SUPPORTED; cpu = get_cpu(); @@ -108,128 +113,112 @@ static inline u16 call_pnp_bios(u16 func, u16 arg1, u16 arg2, u16 arg3, if (ts2_size) Q2_SET_SEL(smp_processor_id(), PNP_TS2, ts2_base, ts2_size); - __asm__ __volatile__("pushl %%ebp\n\t" - "pushl %%edi\n\t" - "pushl %%esi\n\t" - "pushl %%ds\n\t" - "pushl %%es\n\t" - "pushl %%fs\n\t" - "pushl %%gs\n\t" - "pushfl\n\t" - "movl %%esp, pnp_bios_fault_esp\n\t" - "movl $1f, pnp_bios_fault_eip\n\t" - "lcall %5,%6\n\t" - "1:popfl\n\t" - "popl %%gs\n\t" - "popl %%fs\n\t" - "popl %%es\n\t" - "popl %%ds\n\t" - "popl %%esi\n\t" - "popl %%edi\n\t" - "popl %%ebp\n\t":"=a"(status) - :"0"((func) | (((u32) arg1) << 16)), - "b"((arg2) | (((u32) arg3) << 16)), - "c"((arg4) | (((u32) arg5) << 16)), - "d"((arg6) | (((u32) arg7) << 16)), - "i"(PNP_CS32), "i"(0) - :"memory"); + __asm__ __volatile__( + "pushl %%ebp\n\t" + "pushl %%edi\n\t" + "pushl %%esi\n\t" + "pushl %%ds\n\t" + "pushl %%es\n\t" + "pushl %%fs\n\t" + "pushl %%gs\n\t" + "pushfl\n\t" + "movl %%esp, pnp_bios_fault_esp\n\t" + "movl $1f, pnp_bios_fault_eip\n\t" + "lcall %5,%6\n\t" + "1:popfl\n\t" + "popl %%gs\n\t" + "popl %%fs\n\t" + "popl %%es\n\t" + "popl %%ds\n\t" + "popl %%esi\n\t" + "popl %%edi\n\t" + "popl %%ebp\n\t" + : "=a" (status) + : "0" ((func) | (((u32)arg1) << 16)), + "b" ((arg2) | (((u32)arg3) << 16)), + "c" ((arg4) | (((u32)arg5) << 16)), + "d" ((arg6) | (((u32)arg7) << 16)), + "i" (PNP_CS32), + "i" (0) + : "memory" + ); spin_unlock_irqrestore(&pnp_bios_lock, flags); get_cpu_gdt_table(cpu)[0x40 / 8] = save_desc_40; put_cpu(); /* If we get here and this is set then the PnP BIOS faulted on us. */ - if (pnp_bios_is_utter_crap) { - printk(KERN_ERR - "PnPBIOS: Warning! Your PnP BIOS caused a fatal error. Attempting to continue\n"); - printk(KERN_ERR - "PnPBIOS: You may need to reboot with the \"pnpbios=off\" option to operate stably\n"); - printk(KERN_ERR - "PnPBIOS: Check with your vendor for an updated BIOS\n"); + if(pnp_bios_is_utter_crap) + { + printk(KERN_ERR "PnPBIOS: Warning! Your PnP BIOS caused a fatal error. Attempting to continue\n"); + printk(KERN_ERR "PnPBIOS: You may need to reboot with the \"pnpbios=off\" option to operate stably\n"); + printk(KERN_ERR "PnPBIOS: Check with your vendor for an updated BIOS\n"); } return status; } -void pnpbios_print_status(const char *module, u16 status) +void pnpbios_print_status(const char * module, u16 status) { - switch (status) { + switch(status) { case PNP_SUCCESS: printk(KERN_ERR "PnPBIOS: %s: function successful\n", module); break; case PNP_NOT_SET_STATICALLY: - printk(KERN_ERR "PnPBIOS: %s: unable to set static resources\n", - module); + printk(KERN_ERR "PnPBIOS: %s: unable to set static resources\n", module); break; case PNP_UNKNOWN_FUNCTION: - printk(KERN_ERR "PnPBIOS: %s: invalid function number passed\n", - module); + printk(KERN_ERR "PnPBIOS: %s: invalid function number passed\n", module); break; case PNP_FUNCTION_NOT_SUPPORTED: - printk(KERN_ERR - "PnPBIOS: %s: function not supported on this system\n", - module); + printk(KERN_ERR "PnPBIOS: %s: function not supported on this system\n", module); break; case PNP_INVALID_HANDLE: printk(KERN_ERR "PnPBIOS: %s: invalid handle\n", module); break; case PNP_BAD_PARAMETER: - printk(KERN_ERR "PnPBIOS: %s: invalid parameters were passed\n", - module); + printk(KERN_ERR "PnPBIOS: %s: invalid parameters were passed\n", module); break; case PNP_SET_FAILED: - printk(KERN_ERR "PnPBIOS: %s: unable to set resources\n", - module); + printk(KERN_ERR "PnPBIOS: %s: unable to set resources\n", module); break; case PNP_EVENTS_NOT_PENDING: printk(KERN_ERR "PnPBIOS: %s: no events are pending\n", module); break; case PNP_SYSTEM_NOT_DOCKED: - printk(KERN_ERR "PnPBIOS: %s: the system is not docked\n", - module); + printk(KERN_ERR "PnPBIOS: %s: the system is not docked\n", module); break; case PNP_NO_ISA_PNP_CARDS: - printk(KERN_ERR - "PnPBIOS: %s: no isapnp cards are installed on this system\n", - module); + printk(KERN_ERR "PnPBIOS: %s: no isapnp cards are installed on this system\n", module); break; case PNP_UNABLE_TO_DETERMINE_DOCK_CAPABILITIES: - printk(KERN_ERR - "PnPBIOS: %s: cannot determine the capabilities of the docking station\n", - module); + printk(KERN_ERR "PnPBIOS: %s: cannot determine the capabilities of the docking station\n", module); break; case PNP_CONFIG_CHANGE_FAILED_NO_BATTERY: - printk(KERN_ERR - "PnPBIOS: %s: unable to undock, the system does not have a battery\n", - module); + printk(KERN_ERR "PnPBIOS: %s: unable to undock, the system does not have a battery\n", module); break; case PNP_CONFIG_CHANGE_FAILED_RESOURCE_CONFLICT: - printk(KERN_ERR - "PnPBIOS: %s: could not dock due to resource conflicts\n", - module); + printk(KERN_ERR "PnPBIOS: %s: could not dock due to resource conflicts\n", module); break; case PNP_BUFFER_TOO_SMALL: - printk(KERN_ERR "PnPBIOS: %s: the buffer passed is too small\n", - module); + printk(KERN_ERR "PnPBIOS: %s: the buffer passed is too small\n", module); break; case PNP_USE_ESCD_SUPPORT: printk(KERN_ERR "PnPBIOS: %s: use ESCD instead\n", module); break; case PNP_MESSAGE_NOT_SUPPORTED: - printk(KERN_ERR "PnPBIOS: %s: the message is unsupported\n", - module); + printk(KERN_ERR "PnPBIOS: %s: the message is unsupported\n", module); break; case PNP_HARDWARE_ERROR: - printk(KERN_ERR "PnPBIOS: %s: a hardware failure has occured\n", - module); + printk(KERN_ERR "PnPBIOS: %s: a hardware failure has occured\n", module); break; default: - printk(KERN_ERR "PnPBIOS: %s: unexpected status 0x%x\n", module, - status); + printk(KERN_ERR "PnPBIOS: %s: unexpected status 0x%x\n", module, status); break; } } + /* * PnP BIOS Low Level Calls */ @@ -254,22 +243,19 @@ void pnpbios_print_status(const char *module, u16 status) static int __pnp_bios_dev_node_info(struct pnp_dev_node_info *data) { u16 status; - if (!pnp_bios_present()) return PNP_FUNCTION_NOT_SUPPORTED; - status = call_pnp_bios(PNP_GET_NUM_SYS_DEV_NODES, 0, PNP_TS1, 2, - PNP_TS1, PNP_DS, 0, 0, data, - sizeof(struct pnp_dev_node_info), NULL, 0); + status = call_pnp_bios(PNP_GET_NUM_SYS_DEV_NODES, 0, PNP_TS1, 2, PNP_TS1, PNP_DS, 0, 0, + data, sizeof(struct pnp_dev_node_info), NULL, 0); data->no_nodes &= 0xff; return status; } int pnp_bios_dev_node_info(struct pnp_dev_node_info *data) { - int status = __pnp_bios_dev_node_info(data); - - if (status) - pnpbios_print_status("dev_node_info", status); + int status = __pnp_bios_dev_node_info( data ); + if ( status ) + pnpbios_print_status( "dev_node_info", status ); return status; } @@ -287,20 +273,17 @@ int pnp_bios_dev_node_info(struct pnp_dev_node_info *data) * or volatile current (0) config * Output: *nodenum=next node or 0xff if no more nodes */ -static int __pnp_bios_get_dev_node(u8 *nodenum, char boot, - struct pnp_bios_node *data) +static int __pnp_bios_get_dev_node(u8 *nodenum, char boot, struct pnp_bios_node *data) { u16 status; u16 tmp_nodenum; - if (!pnp_bios_present()) return PNP_FUNCTION_NOT_SUPPORTED; - if (!boot && pnpbios_dont_use_current_config) + if ( !boot && pnpbios_dont_use_current_config ) return PNP_FUNCTION_NOT_SUPPORTED; tmp_nodenum = *nodenum; - status = call_pnp_bios(PNP_GET_SYS_DEV_NODE, 0, PNP_TS1, 0, PNP_TS2, - boot ? 2 : 1, PNP_DS, 0, &tmp_nodenum, - sizeof(tmp_nodenum), data, 65536); + status = call_pnp_bios(PNP_GET_SYS_DEV_NODE, 0, PNP_TS1, 0, PNP_TS2, boot ? 2 : 1, PNP_DS, 0, + &tmp_nodenum, sizeof(tmp_nodenum), data, 65536); *nodenum = tmp_nodenum; return status; } @@ -308,66 +291,104 @@ static int __pnp_bios_get_dev_node(u8 *nodenum, char boot, int pnp_bios_get_dev_node(u8 *nodenum, char boot, struct pnp_bios_node *data) { int status; - - status = __pnp_bios_get_dev_node(nodenum, boot, data); - if (status) - pnpbios_print_status("get_dev_node", status); + status = __pnp_bios_get_dev_node( nodenum, boot, data ); + if ( status ) + pnpbios_print_status( "get_dev_node", status ); return status; } + /* * Call PnP BIOS with function 0x02, "set system device node" * Input: *nodenum = desired node, * boot = whether to set nonvolatile boot (!=0) * or volatile current (0) config */ -static int __pnp_bios_set_dev_node(u8 nodenum, char boot, - struct pnp_bios_node *data) +static int __pnp_bios_set_dev_node(u8 nodenum, char boot, struct pnp_bios_node *data) { u16 status; - if (!pnp_bios_present()) return PNP_FUNCTION_NOT_SUPPORTED; - if (!boot && pnpbios_dont_use_current_config) + if ( !boot && pnpbios_dont_use_current_config ) return PNP_FUNCTION_NOT_SUPPORTED; - status = call_pnp_bios(PNP_SET_SYS_DEV_NODE, nodenum, 0, PNP_TS1, - boot ? 2 : 1, PNP_DS, 0, 0, data, 65536, NULL, - 0); + status = call_pnp_bios(PNP_SET_SYS_DEV_NODE, nodenum, 0, PNP_TS1, boot ? 2 : 1, PNP_DS, 0, 0, + data, 65536, NULL, 0); return status; } int pnp_bios_set_dev_node(u8 nodenum, char boot, struct pnp_bios_node *data) { int status; - - status = __pnp_bios_set_dev_node(nodenum, boot, data); - if (status) { - pnpbios_print_status("set_dev_node", status); + status = __pnp_bios_set_dev_node( nodenum, boot, data ); + if ( status ) { + pnpbios_print_status( "set_dev_node", status ); return status; } - if (!boot) { /* Update devlist */ - status = pnp_bios_get_dev_node(&nodenum, boot, data); - if (status) + if ( !boot ) { /* Update devlist */ + status = pnp_bios_get_dev_node( &nodenum, boot, data ); + if ( status ) return status; } return status; } +#if needed +/* + * Call PnP BIOS with function 0x03, "get event" + */ +static int pnp_bios_get_event(u16 *event) +{ + u16 status; + if (!pnp_bios_present()) + return PNP_FUNCTION_NOT_SUPPORTED; + status = call_pnp_bios(PNP_GET_EVENT, 0, PNP_TS1, PNP_DS, 0, 0 ,0 ,0, + event, sizeof(u16), NULL, 0); + return status; +} +#endif + +#if needed +/* + * Call PnP BIOS with function 0x04, "send message" + */ +static int pnp_bios_send_message(u16 message) +{ + u16 status; + if (!pnp_bios_present()) + return PNP_FUNCTION_NOT_SUPPORTED; + status = call_pnp_bios(PNP_SEND_MESSAGE, message, PNP_DS, 0, 0, 0, 0, 0, 0, 0, 0, 0); + return status; +} +#endif + /* * Call PnP BIOS with function 0x05, "get docking station information" */ int pnp_bios_dock_station_info(struct pnp_docking_station_info *data) { u16 status; + if (!pnp_bios_present()) + return PNP_FUNCTION_NOT_SUPPORTED; + status = call_pnp_bios(PNP_GET_DOCKING_STATION_INFORMATION, 0, PNP_TS1, PNP_DS, 0, 0, 0, 0, + data, sizeof(struct pnp_docking_station_info), NULL, 0); + return status; +} +#if needed +/* + * Call PnP BIOS with function 0x09, "set statically allocated resource + * information" + */ +static int pnp_bios_set_stat_res(char *info) +{ + u16 status; if (!pnp_bios_present()) return PNP_FUNCTION_NOT_SUPPORTED; - status = call_pnp_bios(PNP_GET_DOCKING_STATION_INFORMATION, 0, PNP_TS1, - PNP_DS, 0, 0, 0, 0, data, - sizeof(struct pnp_docking_station_info), NULL, - 0); + status = call_pnp_bios(PNP_SET_STATIC_ALLOCED_RES_INFO, 0, PNP_TS1, PNP_DS, 0, 0, 0, 0, + info, *((u16 *) info), 0, 0); return status; } +#endif /* * Call PnP BIOS with function 0x0a, "get statically allocated resource @@ -376,23 +397,36 @@ int pnp_bios_dock_station_info(struct pnp_docking_station_info *data) static int __pnp_bios_get_stat_res(char *info) { u16 status; - if (!pnp_bios_present()) return PNP_FUNCTION_NOT_SUPPORTED; - status = call_pnp_bios(PNP_GET_STATIC_ALLOCED_RES_INFO, 0, PNP_TS1, - PNP_DS, 0, 0, 0, 0, info, 65536, NULL, 0); + status = call_pnp_bios(PNP_GET_STATIC_ALLOCED_RES_INFO, 0, PNP_TS1, PNP_DS, 0, 0, 0, 0, + info, 65536, NULL, 0); return status; } int pnp_bios_get_stat_res(char *info) { int status; + status = __pnp_bios_get_stat_res( info ); + if ( status ) + pnpbios_print_status( "get_stat_res", status ); + return status; +} - status = __pnp_bios_get_stat_res(info); - if (status) - pnpbios_print_status("get_stat_res", status); +#if needed +/* + * Call PnP BIOS with function 0x0b, "get APM id table" + */ +static int pnp_bios_apm_id_table(char *table, u16 *size) +{ + u16 status; + if (!pnp_bios_present()) + return PNP_FUNCTION_NOT_SUPPORTED; + status = call_pnp_bios(PNP_GET_APM_ID_TABLE, 0, PNP_TS2, 0, PNP_TS1, PNP_DS, 0, 0, + table, *size, size, sizeof(u16)); return status; } +#endif /* * Call PnP BIOS with function 0x40, "get isa pnp configuration structure" @@ -400,22 +434,19 @@ int pnp_bios_get_stat_res(char *info) static int __pnp_bios_isapnp_config(struct pnp_isa_config_struc *data) { u16 status; - if (!pnp_bios_present()) return PNP_FUNCTION_NOT_SUPPORTED; - status = call_pnp_bios(PNP_GET_PNP_ISA_CONFIG_STRUC, 0, PNP_TS1, PNP_DS, - 0, 0, 0, 0, data, - sizeof(struct pnp_isa_config_struc), NULL, 0); + status = call_pnp_bios(PNP_GET_PNP_ISA_CONFIG_STRUC, 0, PNP_TS1, PNP_DS, 0, 0, 0, 0, + data, sizeof(struct pnp_isa_config_struc), NULL, 0); return status; } int pnp_bios_isapnp_config(struct pnp_isa_config_struc *data) { int status; - - status = __pnp_bios_isapnp_config(data); - if (status) - pnpbios_print_status("isapnp_config", status); + status = __pnp_bios_isapnp_config( data ); + if ( status ) + pnpbios_print_status( "isapnp_config", status ); return status; } @@ -425,22 +456,19 @@ int pnp_bios_isapnp_config(struct pnp_isa_config_struc *data) static int __pnp_bios_escd_info(struct escd_info_struc *data) { u16 status; - if (!pnp_bios_present()) return ESCD_FUNCTION_NOT_SUPPORTED; - status = call_pnp_bios(PNP_GET_ESCD_INFO, 0, PNP_TS1, 2, PNP_TS1, 4, - PNP_TS1, PNP_DS, data, - sizeof(struct escd_info_struc), NULL, 0); + status = call_pnp_bios(PNP_GET_ESCD_INFO, 0, PNP_TS1, 2, PNP_TS1, 4, PNP_TS1, PNP_DS, + data, sizeof(struct escd_info_struc), NULL, 0); return status; } int pnp_bios_escd_info(struct escd_info_struc *data) { int status; - - status = __pnp_bios_escd_info(data); - if (status) - pnpbios_print_status("escd_info", status); + status = __pnp_bios_escd_info( data ); + if ( status ) + pnpbios_print_status( "escd_info", status ); return status; } @@ -451,42 +479,57 @@ int pnp_bios_escd_info(struct escd_info_struc *data) static int __pnp_bios_read_escd(char *data, u32 nvram_base) { u16 status; - if (!pnp_bios_present()) return ESCD_FUNCTION_NOT_SUPPORTED; - status = call_pnp_bios(PNP_READ_ESCD, 0, PNP_TS1, PNP_TS2, PNP_DS, 0, 0, - 0, data, 65536, __va(nvram_base), 65536); + status = call_pnp_bios(PNP_READ_ESCD, 0, PNP_TS1, PNP_TS2, PNP_DS, 0, 0, 0, + data, 65536, __va(nvram_base), 65536); return status; } int pnp_bios_read_escd(char *data, u32 nvram_base) { int status; + status = __pnp_bios_read_escd( data, nvram_base ); + if ( status ) + pnpbios_print_status( "read_escd", status ); + return status; +} - status = __pnp_bios_read_escd(data, nvram_base); - if (status) - pnpbios_print_status("read_escd", status); +#if needed +/* + * Call PnP BIOS function 0x43, "write ESCD" + */ +static int pnp_bios_write_escd(char *data, u32 nvram_base) +{ + u16 status; + if (!pnp_bios_present()) + return ESCD_FUNCTION_NOT_SUPPORTED; + status = call_pnp_bios(PNP_WRITE_ESCD, 0, PNP_TS1, PNP_TS2, PNP_DS, 0, 0, 0, + data, 65536, __va(nvram_base), 65536); return status; } +#endif + + +/* + * Initialization + */ void pnpbios_calls_init(union pnp_bios_install_struct *header) { int i; - spin_lock_init(&pnp_bios_lock); pnp_bios_callpoint.offset = header->fields.pm16offset; pnp_bios_callpoint.segment = PNP_CS16; set_base(bad_bios_desc, __va((unsigned long)0x40 << 4)); _set_limit((char *)&bad_bios_desc, 4095 - (0x40 << 4)); - for (i = 0; i < NR_CPUS; i++) { - struct desc_struct *gdt = get_cpu_gdt_table(i); - if (!gdt) - continue; - set_base(gdt[GDT_ENTRY_PNPBIOS_CS32], &pnp_bios_callfunc); - set_base(gdt[GDT_ENTRY_PNPBIOS_CS16], - __va(header->fields.pm16cseg)); - set_base(gdt[GDT_ENTRY_PNPBIOS_DS], - __va(header->fields.pm16dseg)); - } + for (i = 0; i < NR_CPUS; i++) { + struct desc_struct *gdt = get_cpu_gdt_table(i); + if (!gdt) + continue; + set_base(gdt[GDT_ENTRY_PNPBIOS_CS32], &pnp_bios_callfunc); + set_base(gdt[GDT_ENTRY_PNPBIOS_CS16], __va(header->fields.pm16cseg)); + set_base(gdt[GDT_ENTRY_PNPBIOS_DS], __va(header->fields.pm16dseg)); + } } diff --git a/trunk/drivers/pnp/pnpbios/core.c b/trunk/drivers/pnp/pnpbios/core.c index 3692a099b45f..ed112ee16012 100644 --- a/trunk/drivers/pnp/pnpbios/core.c +++ b/trunk/drivers/pnp/pnpbios/core.c @@ -32,7 +32,7 @@ * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ - + /* Change Log * * Adam Belay - - March 16, 2003 @@ -71,13 +71,14 @@ #include "pnpbios.h" + /* * * PnP BIOS INTERFACE * */ -static union pnp_bios_install_struct *pnp_bios_install = NULL; +static union pnp_bios_install_struct * pnp_bios_install = NULL; int pnp_bios_present(void) { @@ -100,35 +101,36 @@ static struct completion unload_sem; /* * (Much of this belongs in a shared routine somewhere) */ + static int pnp_dock_event(int dock, struct pnp_docking_station_info *info) { - char *argv[3], **envp, *buf, *scratch; + char *argv [3], **envp, *buf, *scratch; int i = 0, value; - if (!current->fs->root) + if (!current->fs->root) { return -EAGAIN; - if (!(envp = kcalloc(20, sizeof(char *), GFP_KERNEL))) + } + if (!(envp = kcalloc(20, sizeof (char *), GFP_KERNEL))) { return -ENOMEM; + } if (!(buf = kzalloc(256, GFP_KERNEL))) { - kfree(envp); + kfree (envp); return -ENOMEM; } - /* FIXME: if there are actual users of this, it should be - * integrated into the driver core and use the usual infrastructure - * like sysfs and uevents - */ - argv[0] = "/sbin/pnpbios"; - argv[1] = "dock"; - argv[2] = NULL; + /* FIXME: if there are actual users of this, it should be integrated into + * the driver core and use the usual infrastructure like sysfs and uevents */ + argv [0] = "/sbin/pnpbios"; + argv [1] = "dock"; + argv [2] = NULL; /* minimal command environment */ - envp[i++] = "HOME=/"; - envp[i++] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin"; + envp [i++] = "HOME=/"; + envp [i++] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin"; #ifdef DEBUG /* hint that policy agent should enter no-stdout debug mode */ - envp[i++] = "DEBUG=kernel"; + envp [i++] = "DEBUG=kernel"; #endif /* extensible set of named bus-specific parameters, * supporting multiple driver selection algorithms. @@ -136,33 +138,33 @@ static int pnp_dock_event(int dock, struct pnp_docking_station_info *info) scratch = buf; /* action: add, remove */ - envp[i++] = scratch; - scratch += sprintf(scratch, "ACTION=%s", dock ? "add" : "remove") + 1; + envp [i++] = scratch; + scratch += sprintf (scratch, "ACTION=%s", dock?"add":"remove") + 1; /* Report the ident for the dock */ - envp[i++] = scratch; - scratch += sprintf(scratch, "DOCK=%x/%x/%x", - info->location_id, info->serial, info->capabilities); + envp [i++] = scratch; + scratch += sprintf (scratch, "DOCK=%x/%x/%x", + info->location_id, info->serial, info->capabilities); envp[i] = NULL; - - value = call_usermodehelper(argv [0], argv, envp, UMH_WAIT_EXEC); - kfree(buf); - kfree(envp); + + value = call_usermodehelper (argv [0], argv, envp, UMH_WAIT_EXEC); + kfree (buf); + kfree (envp); return 0; } /* * Poll the PnP docking at regular intervals */ -static int pnp_dock_thread(void *unused) +static int pnp_dock_thread(void * unused) { static struct pnp_docking_station_info now; int docked = -1, d = 0; - set_freezable(); - while (!unloading) { + while (!unloading) + { int status; - + /* * Poll every 2 seconds */ @@ -173,29 +175,30 @@ static int pnp_dock_thread(void *unused) status = pnp_bios_dock_station_info(&now); - switch (status) { + switch(status) + { /* * No dock to manage */ - case PNP_FUNCTION_NOT_SUPPORTED: - complete_and_exit(&unload_sem, 0); - case PNP_SYSTEM_NOT_DOCKED: - d = 0; - break; - case PNP_SUCCESS: - d = 1; - break; - default: - pnpbios_print_status("pnp_dock_thread", status); - continue; + case PNP_FUNCTION_NOT_SUPPORTED: + complete_and_exit(&unload_sem, 0); + case PNP_SYSTEM_NOT_DOCKED: + d = 0; + break; + case PNP_SUCCESS: + d = 1; + break; + default: + pnpbios_print_status( "pnp_dock_thread", status ); + continue; } - if (d != docked) { - if (pnp_dock_event(d, &now) == 0) { + if(d != docked) + { + if(pnp_dock_event(d, &now)==0) + { docked = d; #if 0 - printk(KERN_INFO - "PnPBIOS: Docking station %stached\n", - docked ? "at" : "de"); + printk(KERN_INFO "PnPBIOS: Docking station %stached\n", docked?"at":"de"); #endif } } @@ -203,21 +206,21 @@ static int pnp_dock_thread(void *unused) complete_and_exit(&unload_sem, 0); } -#endif /* CONFIG_HOTPLUG */ +#endif /* CONFIG_HOTPLUG */ -static int pnpbios_get_resources(struct pnp_dev *dev, - struct pnp_resource_table *res) +static int pnpbios_get_resources(struct pnp_dev * dev, struct pnp_resource_table * res) { u8 nodenum = dev->number; - struct pnp_bios_node *node; + struct pnp_bios_node * node; - if (!pnpbios_is_dynamic(dev)) + /* just in case */ + if(!pnpbios_is_dynamic(dev)) return -EPERM; node = kzalloc(node_info.max_node_size, GFP_KERNEL); if (!node) return -1; - if (pnp_bios_get_dev_node(&nodenum, (char)PNPMODE_DYNAMIC, node)) { + if (pnp_bios_get_dev_node(&nodenum, (char )PNPMODE_DYNAMIC, node)) { kfree(node); return -ENODEV; } @@ -227,24 +230,24 @@ static int pnpbios_get_resources(struct pnp_dev *dev, return 0; } -static int pnpbios_set_resources(struct pnp_dev *dev, - struct pnp_resource_table *res) +static int pnpbios_set_resources(struct pnp_dev * dev, struct pnp_resource_table * res) { u8 nodenum = dev->number; - struct pnp_bios_node *node; + struct pnp_bios_node * node; int ret; + /* just in case */ if (!pnpbios_is_dynamic(dev)) return -EPERM; node = kzalloc(node_info.max_node_size, GFP_KERNEL); if (!node) return -1; - if (pnp_bios_get_dev_node(&nodenum, (char)PNPMODE_DYNAMIC, node)) { + if (pnp_bios_get_dev_node(&nodenum, (char )PNPMODE_DYNAMIC, node)) { kfree(node); return -ENODEV; } - if (pnpbios_write_resources_to_node(res, node) < 0) { + if(pnpbios_write_resources_to_node(res, node)<0) { kfree(node); return -1; } @@ -255,19 +258,18 @@ static int pnpbios_set_resources(struct pnp_dev *dev, return ret; } -static void pnpbios_zero_data_stream(struct pnp_bios_node *node) +static void pnpbios_zero_data_stream(struct pnp_bios_node * node) { - unsigned char *p = (char *)node->data; - unsigned char *end = (char *)(node->data + node->size); + unsigned char * p = (char *)node->data; + unsigned char * end = (char *)(node->data + node->size); unsigned int len; int i; - while ((char *)p < (char *)end) { - if (p[0] & 0x80) { /* large tag */ + if(p[0] & 0x80) { /* large tag */ len = (p[2] << 8) | p[1]; p += 3; } else { - if (((p[0] >> 3) & 0x0f) == 0x0f) + if (((p[0]>>3) & 0x0f) == 0x0f) return; len = p[0] & 0x07; p += 1; @@ -276,24 +278,24 @@ static void pnpbios_zero_data_stream(struct pnp_bios_node *node) p[i] = 0; p += len; } - printk(KERN_ERR - "PnPBIOS: Resource structure did not contain an end tag.\n"); + printk(KERN_ERR "PnPBIOS: Resource structure did not contain an end tag.\n"); } static int pnpbios_disable_resources(struct pnp_dev *dev) { - struct pnp_bios_node *node; + struct pnp_bios_node * node; u8 nodenum = dev->number; int ret; - if (dev->flags & PNPBIOS_NO_DISABLE || !pnpbios_is_dynamic(dev)) + /* just in case */ + if(dev->flags & PNPBIOS_NO_DISABLE || !pnpbios_is_dynamic(dev)) return -EPERM; node = kzalloc(node_info.max_node_size, GFP_KERNEL); if (!node) return -ENOMEM; - if (pnp_bios_get_dev_node(&nodenum, (char)PNPMODE_DYNAMIC, node)) { + if (pnp_bios_get_dev_node(&nodenum, (char )PNPMODE_DYNAMIC, node)) { kfree(node); return -ENODEV; } @@ -309,22 +311,22 @@ static int pnpbios_disable_resources(struct pnp_dev *dev) /* PnP Layer support */ struct pnp_protocol pnpbios_protocol = { - .name = "Plug and Play BIOS", - .get = pnpbios_get_resources, - .set = pnpbios_set_resources, + .name = "Plug and Play BIOS", + .get = pnpbios_get_resources, + .set = pnpbios_set_resources, .disable = pnpbios_disable_resources, }; -static int insert_device(struct pnp_dev *dev, struct pnp_bios_node *node) +static int insert_device(struct pnp_dev *dev, struct pnp_bios_node * node) { - struct list_head *pos; - struct pnp_dev *pnp_dev; + struct list_head * pos; + struct pnp_dev * pnp_dev; struct pnp_id *dev_id; char id[8]; /* check if the device is already added */ dev->number = node->handle; - list_for_each(pos, &pnpbios_protocol.devices) { + list_for_each (pos, &pnpbios_protocol.devices){ pnp_dev = list_entry(pos, struct pnp_dev, protocol_list); if (dev->number == pnp_dev->number) return -1; @@ -334,8 +336,8 @@ static int insert_device(struct pnp_dev *dev, struct pnp_bios_node *node) dev_id = kzalloc(sizeof(struct pnp_id), GFP_KERNEL); if (!dev_id) return -1; - pnpid32_to_pnpid(node->eisa_id, id); - memcpy(dev_id->id, id, 7); + pnpid32_to_pnpid(node->eisa_id,id); + memcpy(dev_id->id,id,7); pnp_add_id(dev_id, dev); pnpbios_parse_data_stream(dev, node); dev->active = pnp_is_active(dev); @@ -373,41 +375,35 @@ static void __init build_devlist(void) if (!node) return; - for (nodenum = 0; nodenum < 0xff;) { + for(nodenum=0; nodenum<0xff; ) { u8 thisnodenum = nodenum; /* eventually we will want to use PNPMODE_STATIC here but for now * dynamic will help us catch buggy bioses to add to the blacklist. */ if (!pnpbios_dont_use_current_config) { - if (pnp_bios_get_dev_node - (&nodenum, (char)PNPMODE_DYNAMIC, node)) + if (pnp_bios_get_dev_node(&nodenum, (char )PNPMODE_DYNAMIC, node)) break; } else { - if (pnp_bios_get_dev_node - (&nodenum, (char)PNPMODE_STATIC, node)) + if (pnp_bios_get_dev_node(&nodenum, (char )PNPMODE_STATIC, node)) break; } nodes_got++; - dev = kzalloc(sizeof(struct pnp_dev), GFP_KERNEL); + dev = kzalloc(sizeof (struct pnp_dev), GFP_KERNEL); if (!dev) break; - if (insert_device(dev, node) < 0) + if(insert_device(dev,node)<0) kfree(dev); else devs++; if (nodenum <= thisnodenum) { - printk(KERN_ERR - "PnPBIOS: build_devlist: Node number 0x%x is out of sequence following node 0x%x. Aborting.\n", - (unsigned int)nodenum, - (unsigned int)thisnodenum); + printk(KERN_ERR "PnPBIOS: build_devlist: Node number 0x%x is out of sequence following node 0x%x. Aborting.\n", (unsigned int)nodenum, (unsigned int)thisnodenum); break; } } kfree(node); - printk(KERN_INFO - "PnPBIOS: %i node%s reported by PnP BIOS; %i recorded by driver\n", - nodes_got, nodes_got != 1 ? "s" : "", devs); + printk(KERN_INFO "PnPBIOS: %i node%s reported by PnP BIOS; %i recorded by driver\n", + nodes_got, nodes_got != 1 ? "s" : "", devs); } /* @@ -416,8 +412,8 @@ static void __init build_devlist(void) * */ -static int pnpbios_disabled; -int pnpbios_dont_use_current_config; +static int pnpbios_disabled; /* = 0 */ +int pnpbios_dont_use_current_config; /* = 0 */ #ifndef MODULE static int __init pnpbios_setup(char *str) @@ -426,9 +422,9 @@ static int __init pnpbios_setup(char *str) while ((str != NULL) && (*str != '\0')) { if (strncmp(str, "off", 3) == 0) - pnpbios_disabled = 1; + pnpbios_disabled=1; if (strncmp(str, "on", 2) == 0) - pnpbios_disabled = 0; + pnpbios_disabled=0; invert = (strncmp(str, "no-", 3) == 0); if (invert) str += 3; @@ -457,41 +453,35 @@ static int __init pnpbios_probe_system(void) printk(KERN_INFO "PnPBIOS: Scanning system for PnP BIOS support...\n"); /* - * Search the defined area (0xf0000-0xffff0) for a valid PnP BIOS + * Search the defined area (0xf0000-0xffff0) for a valid PnP BIOS * structure and, if one is found, sets up the selectors and * entry points */ - for (check = (union pnp_bios_install_struct *)__va(0xf0000); - check < (union pnp_bios_install_struct *)__va(0xffff0); + for (check = (union pnp_bios_install_struct *) __va(0xf0000); + check < (union pnp_bios_install_struct *) __va(0xffff0); check = (void *)check + 16) { if (check->fields.signature != PNP_SIGNATURE) continue; - printk(KERN_INFO - "PnPBIOS: Found PnP BIOS installation structure at 0x%p\n", - check); + printk(KERN_INFO "PnPBIOS: Found PnP BIOS installation structure at 0x%p\n", check); length = check->fields.length; if (!length) { - printk(KERN_ERR - "PnPBIOS: installation structure is invalid, skipping\n"); + printk(KERN_ERR "PnPBIOS: installation structure is invalid, skipping\n"); continue; } for (sum = 0, i = 0; i < length; i++) sum += check->chars[i]; if (sum) { - printk(KERN_ERR - "PnPBIOS: installation structure is corrupted, skipping\n"); + printk(KERN_ERR "PnPBIOS: installation structure is corrupted, skipping\n"); continue; } if (check->fields.version < 0x10) { - printk(KERN_WARNING - "PnPBIOS: PnP BIOS version %d.%d is not supported\n", + printk(KERN_WARNING "PnPBIOS: PnP BIOS version %d.%d is not supported\n", check->fields.version >> 4, check->fields.version & 15); continue; } - printk(KERN_INFO - "PnPBIOS: PnP BIOS version %d.%d, entry 0x%x:0x%x, dseg 0x%x\n", - check->fields.version >> 4, check->fields.version & 15, + printk(KERN_INFO "PnPBIOS: PnP BIOS version %d.%d, entry 0x%x:0x%x, dseg 0x%x\n", + check->fields.version >> 4, check->fields.version & 15, check->fields.pm16cseg, check->fields.pm16offset, check->fields.pm16dseg); pnp_bios_install = check; @@ -509,25 +499,25 @@ static int __init exploding_pnp_bios(struct dmi_system_id *d) } static struct dmi_system_id pnpbios_dmi_table[] __initdata = { - { /* PnPBIOS GPF on boot */ - .callback = exploding_pnp_bios, - .ident = "Higraded P14H", - .matches = { - DMI_MATCH(DMI_BIOS_VENDOR, "American Megatrends Inc."), - DMI_MATCH(DMI_BIOS_VERSION, "07.00T"), - DMI_MATCH(DMI_SYS_VENDOR, "Higraded"), - DMI_MATCH(DMI_PRODUCT_NAME, "P14H"), - }, - }, - { /* PnPBIOS GPF on boot */ - .callback = exploding_pnp_bios, - .ident = "ASUS P4P800", - .matches = { - DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer Inc."), - DMI_MATCH(DMI_BOARD_NAME, "P4P800"), - }, - }, - {} + { /* PnPBIOS GPF on boot */ + .callback = exploding_pnp_bios, + .ident = "Higraded P14H", + .matches = { + DMI_MATCH(DMI_BIOS_VENDOR, "American Megatrends Inc."), + DMI_MATCH(DMI_BIOS_VERSION, "07.00T"), + DMI_MATCH(DMI_SYS_VENDOR, "Higraded"), + DMI_MATCH(DMI_PRODUCT_NAME, "P14H"), + }, + }, + { /* PnPBIOS GPF on boot */ + .callback = exploding_pnp_bios, + .ident = "ASUS P4P800", + .matches = { + DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer Inc."), + DMI_MATCH(DMI_BOARD_NAME, "P4P800"), + }, + }, + { } }; static int __init pnpbios_init(void) @@ -543,13 +533,14 @@ static int __init pnpbios_init(void) printk(KERN_INFO "PnPBIOS: Disabled\n"); return -ENODEV; } + #ifdef CONFIG_PNPACPI if (!acpi_disabled && !pnpacpi_disabled) { pnpbios_disabled = 1; printk(KERN_INFO "PnPBIOS: Disabled by ACPI PNP\n"); return -ENODEV; } -#endif /* CONFIG_ACPI */ +#endif /* CONFIG_ACPI */ /* scan the system for pnpbios support */ if (!pnpbios_probe_system()) @@ -561,16 +552,14 @@ static int __init pnpbios_init(void) /* read the node info */ ret = pnp_bios_dev_node_info(&node_info); if (ret) { - printk(KERN_ERR - "PnPBIOS: Unable to get node info. Aborting.\n"); + printk(KERN_ERR "PnPBIOS: Unable to get node info. Aborting.\n"); return ret; } /* register with the pnp layer */ ret = pnp_register_protocol(&pnpbios_protocol); if (ret) { - printk(KERN_ERR - "PnPBIOS: Unable to register driver. Aborting.\n"); + printk(KERN_ERR "PnPBIOS: Unable to register driver. Aborting.\n"); return ret; } diff --git a/trunk/drivers/pnp/pnpbios/proc.c b/trunk/drivers/pnp/pnpbios/proc.c index 9c8c07701b65..8027073f7919 100644 --- a/trunk/drivers/pnp/pnpbios/proc.c +++ b/trunk/drivers/pnp/pnpbios/proc.c @@ -18,6 +18,9 @@ * The other files are human-readable. */ +//#include +//#include + #include #include #include @@ -34,37 +37,42 @@ static struct proc_dir_entry *proc_pnp = NULL; static struct proc_dir_entry *proc_pnp_boot = NULL; static int proc_read_pnpconfig(char *buf, char **start, off_t pos, - int count, int *eof, void *data) + int count, int *eof, void *data) { struct pnp_isa_config_struc pnps; if (pnp_bios_isapnp_config(&pnps)) return -EIO; return snprintf(buf, count, - "structure_revision %d\n" - "number_of_CSNs %d\n" - "ISA_read_data_port 0x%x\n", - pnps.revision, pnps.no_csns, pnps.isa_rd_data_port); + "structure_revision %d\n" + "number_of_CSNs %d\n" + "ISA_read_data_port 0x%x\n", + pnps.revision, + pnps.no_csns, + pnps.isa_rd_data_port + ); } static int proc_read_escdinfo(char *buf, char **start, off_t pos, - int count, int *eof, void *data) + int count, int *eof, void *data) { struct escd_info_struc escd; if (pnp_bios_escd_info(&escd)) return -EIO; return snprintf(buf, count, - "min_ESCD_write_size %d\n" - "ESCD_size %d\n" - "NVRAM_base 0x%x\n", - escd.min_escd_write_size, - escd.escd_size, escd.nv_storage_base); + "min_ESCD_write_size %d\n" + "ESCD_size %d\n" + "NVRAM_base 0x%x\n", + escd.min_escd_write_size, + escd.escd_size, + escd.nv_storage_base + ); } #define MAX_SANE_ESCD_SIZE (32*1024) static int proc_read_escd(char *buf, char **start, off_t pos, - int count, int *eof, void *data) + int count, int *eof, void *data) { struct escd_info_struc escd; char *tmpbuf; @@ -75,36 +83,30 @@ static int proc_read_escd(char *buf, char **start, off_t pos, /* sanity check */ if (escd.escd_size > MAX_SANE_ESCD_SIZE) { - printk(KERN_ERR - "PnPBIOS: proc_read_escd: ESCD size reported by BIOS escd_info call is too great\n"); + printk(KERN_ERR "PnPBIOS: proc_read_escd: ESCD size reported by BIOS escd_info call is too great\n"); return -EFBIG; } tmpbuf = kzalloc(escd.escd_size, GFP_KERNEL); - if (!tmpbuf) - return -ENOMEM; + if (!tmpbuf) return -ENOMEM; if (pnp_bios_read_escd(tmpbuf, escd.nv_storage_base)) { kfree(tmpbuf); return -EIO; } - escd_size = - (unsigned char)(tmpbuf[0]) + (unsigned char)(tmpbuf[1]) * 256; + escd_size = (unsigned char)(tmpbuf[0]) + (unsigned char)(tmpbuf[1])*256; /* sanity check */ if (escd_size > MAX_SANE_ESCD_SIZE) { - printk(KERN_ERR - "PnPBIOS: proc_read_escd: ESCD size reported by BIOS read_escd call is too great\n"); + printk(KERN_ERR "PnPBIOS: proc_read_escd: ESCD size reported by BIOS read_escd call is too great\n"); return -EFBIG; } escd_left_to_read = escd_size - pos; - if (escd_left_to_read < 0) - escd_left_to_read = 0; - if (escd_left_to_read == 0) - *eof = 1; - n = min(count, escd_left_to_read); + if (escd_left_to_read < 0) escd_left_to_read = 0; + if (escd_left_to_read == 0) *eof = 1; + n = min(count,escd_left_to_read); memcpy(buf, tmpbuf + pos, n); kfree(tmpbuf); *start = buf; @@ -112,17 +114,17 @@ static int proc_read_escd(char *buf, char **start, off_t pos, } static int proc_read_legacyres(char *buf, char **start, off_t pos, - int count, int *eof, void *data) + int count, int *eof, void *data) { /* Assume that the following won't overflow the buffer */ - if (pnp_bios_get_stat_res(buf)) + if (pnp_bios_get_stat_res(buf)) return -EIO; - return count; // FIXME: Return actual length + return count; // FIXME: Return actual length } static int proc_read_devices(char *buf, char **start, off_t pos, - int count, int *eof, void *data) + int count, int *eof, void *data) { struct pnp_bios_node *node; u8 nodenum; @@ -132,10 +134,9 @@ static int proc_read_devices(char *buf, char **start, off_t pos, return 0; node = kzalloc(node_info.max_node_size, GFP_KERNEL); - if (!node) - return -ENOMEM; + if (!node) return -ENOMEM; - for (nodenum = pos; nodenum < 0xff;) { + for (nodenum=pos; nodenum<0xff; ) { u8 thisnodenum = nodenum; /* 26 = the number of characters per line sprintf'ed */ if ((p - buf + 26) > count) @@ -147,11 +148,7 @@ static int proc_read_devices(char *buf, char **start, off_t pos, node->type_code[0], node->type_code[1], node->type_code[2], node->flags); if (nodenum <= thisnodenum) { - printk(KERN_ERR - "%s Node number 0x%x is out of sequence following node 0x%x. Aborting.\n", - "PnPBIOS: proc_read_devices:", - (unsigned int)nodenum, - (unsigned int)thisnodenum); + printk(KERN_ERR "%s Node number 0x%x is out of sequence following node 0x%x. Aborting.\n", "PnPBIOS: proc_read_devices:", (unsigned int)nodenum, (unsigned int)thisnodenum); *eof = 1; break; } @@ -159,12 +156,12 @@ static int proc_read_devices(char *buf, char **start, off_t pos, kfree(node); if (nodenum == 0xff) *eof = 1; - *start = (char *)((off_t) nodenum - pos); + *start = (char *)((off_t)nodenum - pos); return p - buf; } static int proc_read_node(char *buf, char **start, off_t pos, - int count, int *eof, void *data) + int count, int *eof, void *data) { struct pnp_bios_node *node; int boot = (long)data >> 8; @@ -172,8 +169,7 @@ static int proc_read_node(char *buf, char **start, off_t pos, int len; node = kzalloc(node_info.max_node_size, GFP_KERNEL); - if (!node) - return -ENOMEM; + if (!node) return -ENOMEM; if (pnp_bios_get_dev_node(&nodenum, boot, node)) { kfree(node); return -EIO; @@ -184,8 +180,8 @@ static int proc_read_node(char *buf, char **start, off_t pos, return len; } -static int proc_write_node(struct file *file, const char __user * buf, - unsigned long count, void *data) +static int proc_write_node(struct file *file, const char __user *buf, + unsigned long count, void *data) { struct pnp_bios_node *node; int boot = (long)data >> 8; @@ -212,12 +208,12 @@ static int proc_write_node(struct file *file, const char __user * buf, goto out; } ret = count; - out: +out: kfree(node); return ret; } -int pnpbios_interface_attach_device(struct pnp_bios_node *node) +int pnpbios_interface_attach_device(struct pnp_bios_node * node) { char name[3]; struct proc_dir_entry *ent; @@ -226,7 +222,7 @@ int pnpbios_interface_attach_device(struct pnp_bios_node *node) if (!proc_pnp) return -EIO; - if (!pnpbios_dont_use_current_config) { + if ( !pnpbios_dont_use_current_config ) { ent = create_proc_entry(name, 0, proc_pnp); if (ent) { ent->read_proc = proc_read_node; @@ -241,7 +237,7 @@ int pnpbios_interface_attach_device(struct pnp_bios_node *node) if (ent) { ent->read_proc = proc_read_node; ent->write_proc = proc_write_node; - ent->data = (void *)(long)(node->handle + 0x100); + ent->data = (void *)(long)(node->handle+0x100); return 0; } @@ -253,7 +249,7 @@ int pnpbios_interface_attach_device(struct pnp_bios_node *node) * work and the pnpbios_dont_use_current_config flag * should already have been set to the appropriate value */ -int __init pnpbios_proc_init(void) +int __init pnpbios_proc_init( void ) { proc_pnp = proc_mkdir("pnp", proc_bus); if (!proc_pnp) @@ -262,13 +258,10 @@ int __init pnpbios_proc_init(void) if (!proc_pnp_boot) return -EIO; create_proc_read_entry("devices", 0, proc_pnp, proc_read_devices, NULL); - create_proc_read_entry("configuration_info", 0, proc_pnp, - proc_read_pnpconfig, NULL); - create_proc_read_entry("escd_info", 0, proc_pnp, proc_read_escdinfo, - NULL); + create_proc_read_entry("configuration_info", 0, proc_pnp, proc_read_pnpconfig, NULL); + create_proc_read_entry("escd_info", 0, proc_pnp, proc_read_escdinfo, NULL); create_proc_read_entry("escd", S_IRUSR, proc_pnp, proc_read_escd, NULL); - create_proc_read_entry("legacy_device_resources", 0, proc_pnp, - proc_read_legacyres, NULL); + create_proc_read_entry("legacy_device_resources", 0, proc_pnp, proc_read_legacyres, NULL); return 0; } @@ -281,9 +274,9 @@ void __exit pnpbios_proc_exit(void) if (!proc_pnp) return; - for (i = 0; i < 0xff; i++) { + for (i=0; i<0xff; i++) { sprintf(name, "%02x", i); - if (!pnpbios_dont_use_current_config) + if ( !pnpbios_dont_use_current_config ) remove_proc_entry(name, proc_pnp); remove_proc_entry(name, proc_pnp_boot); } @@ -294,4 +287,6 @@ void __exit pnpbios_proc_exit(void) remove_proc_entry("devices", proc_pnp); remove_proc_entry("boot", proc_pnp); remove_proc_entry("pnp", proc_bus); + + return; } diff --git a/trunk/drivers/pnp/pnpbios/rsparser.c b/trunk/drivers/pnp/pnpbios/rsparser.c index 04ecd7b67230..3c2ab8394e3f 100644 --- a/trunk/drivers/pnp/pnpbios/rsparser.c +++ b/trunk/drivers/pnp/pnpbios/rsparser.c @@ -1,5 +1,6 @@ /* * rsparser.c - parses and encodes pnpbios resource data streams + * */ #include @@ -11,10 +12,8 @@ #ifdef CONFIG_PCI #include #else -inline void pcibios_penalize_isa_irq(int irq, int active) -{ -} -#endif /* CONFIG_PCI */ +inline void pcibios_penalize_isa_irq(int irq, int active) {} +#endif /* CONFIG_PCI */ #include "pnpbios.h" @@ -53,88 +52,75 @@ inline void pcibios_penalize_isa_irq(int irq, int active) * Allocated Resources */ -static void pnpbios_parse_allocated_irqresource(struct pnp_resource_table *res, - int irq) +static void +pnpbios_parse_allocated_irqresource(struct pnp_resource_table * res, int irq) { int i = 0; - - while (!(res->irq_resource[i].flags & IORESOURCE_UNSET) - && i < PNP_MAX_IRQ) - i++; + while (!(res->irq_resource[i].flags & IORESOURCE_UNSET) && i < PNP_MAX_IRQ) i++; if (i < PNP_MAX_IRQ) { - res->irq_resource[i].flags = IORESOURCE_IRQ; // Also clears _UNSET flag + res->irq_resource[i].flags = IORESOURCE_IRQ; // Also clears _UNSET flag if (irq == -1) { res->irq_resource[i].flags |= IORESOURCE_DISABLED; return; } res->irq_resource[i].start = - res->irq_resource[i].end = (unsigned long)irq; + res->irq_resource[i].end = (unsigned long) irq; pcibios_penalize_isa_irq(irq, 1); } } -static void pnpbios_parse_allocated_dmaresource(struct pnp_resource_table *res, - int dma) +static void +pnpbios_parse_allocated_dmaresource(struct pnp_resource_table * res, int dma) { int i = 0; - while (i < PNP_MAX_DMA && - !(res->dma_resource[i].flags & IORESOURCE_UNSET)) + !(res->dma_resource[i].flags & IORESOURCE_UNSET)) i++; if (i < PNP_MAX_DMA) { - res->dma_resource[i].flags = IORESOURCE_DMA; // Also clears _UNSET flag + res->dma_resource[i].flags = IORESOURCE_DMA; // Also clears _UNSET flag if (dma == -1) { res->dma_resource[i].flags |= IORESOURCE_DISABLED; return; } res->dma_resource[i].start = - res->dma_resource[i].end = (unsigned long)dma; + res->dma_resource[i].end = (unsigned long) dma; } } -static void pnpbios_parse_allocated_ioresource(struct pnp_resource_table *res, - int io, int len) +static void +pnpbios_parse_allocated_ioresource(struct pnp_resource_table * res, int io, int len) { int i = 0; - - while (!(res->port_resource[i].flags & IORESOURCE_UNSET) - && i < PNP_MAX_PORT) - i++; + while (!(res->port_resource[i].flags & IORESOURCE_UNSET) && i < PNP_MAX_PORT) i++; if (i < PNP_MAX_PORT) { - res->port_resource[i].flags = IORESOURCE_IO; // Also clears _UNSET flag - if (len <= 0 || (io + len - 1) >= 0x10003) { + res->port_resource[i].flags = IORESOURCE_IO; // Also clears _UNSET flag + if (len <= 0 || (io + len -1) >= 0x10003) { res->port_resource[i].flags |= IORESOURCE_DISABLED; return; } - res->port_resource[i].start = (unsigned long)io; + res->port_resource[i].start = (unsigned long) io; res->port_resource[i].end = (unsigned long)(io + len - 1); } } -static void pnpbios_parse_allocated_memresource(struct pnp_resource_table *res, - int mem, int len) +static void +pnpbios_parse_allocated_memresource(struct pnp_resource_table * res, int mem, int len) { int i = 0; - - while (!(res->mem_resource[i].flags & IORESOURCE_UNSET) - && i < PNP_MAX_MEM) - i++; + while (!(res->mem_resource[i].flags & IORESOURCE_UNSET) && i < PNP_MAX_MEM) i++; if (i < PNP_MAX_MEM) { - res->mem_resource[i].flags = IORESOURCE_MEM; // Also clears _UNSET flag + res->mem_resource[i].flags = IORESOURCE_MEM; // Also clears _UNSET flag if (len <= 0) { res->mem_resource[i].flags |= IORESOURCE_DISABLED; return; } - res->mem_resource[i].start = (unsigned long)mem; + res->mem_resource[i].start = (unsigned long) mem; res->mem_resource[i].end = (unsigned long)(mem + len - 1); } } -static unsigned char *pnpbios_parse_allocated_resource_data(unsigned char *p, - unsigned char *end, - struct - pnp_resource_table - *res) +static unsigned char * +pnpbios_parse_allocated_resource_data(unsigned char * p, unsigned char * end, struct pnp_resource_table * res) { unsigned int len, tag; int io, size, mask, i; @@ -148,12 +134,12 @@ static unsigned char *pnpbios_parse_allocated_resource_data(unsigned char *p, while ((char *)p < (char *)end) { /* determine the type of tag */ - if (p[0] & LARGE_TAG) { /* large tag */ + if (p[0] & LARGE_TAG) { /* large tag */ len = (p[2] << 8) | p[1]; tag = p[0]; - } else { /* small tag */ + } else { /* small tag */ len = p[0] & 0x07; - tag = ((p[0] >> 3) & 0x0f); + tag = ((p[0]>>3) & 0x0f); } switch (tag) { @@ -161,8 +147,8 @@ static unsigned char *pnpbios_parse_allocated_resource_data(unsigned char *p, case LARGE_TAG_MEM: if (len != 9) goto len_err; - io = *(short *)&p[4]; - size = *(short *)&p[10]; + io = *(short *) &p[4]; + size = *(short *) &p[10]; pnpbios_parse_allocated_memresource(res, io, size); break; @@ -177,16 +163,16 @@ static unsigned char *pnpbios_parse_allocated_resource_data(unsigned char *p, case LARGE_TAG_MEM32: if (len != 17) goto len_err; - io = *(int *)&p[4]; - size = *(int *)&p[16]; + io = *(int *) &p[4]; + size = *(int *) &p[16]; pnpbios_parse_allocated_memresource(res, io, size); break; case LARGE_TAG_FIXEDMEM32: if (len != 9) goto len_err; - io = *(int *)&p[4]; - size = *(int *)&p[8]; + io = *(int *) &p[4]; + size = *(int *) &p[8]; pnpbios_parse_allocated_memresource(res, io, size); break; @@ -194,10 +180,9 @@ static unsigned char *pnpbios_parse_allocated_resource_data(unsigned char *p, if (len < 2 || len > 3) goto len_err; io = -1; - mask = p[1] + p[2] * 256; - for (i = 0; i < 16; i++, mask = mask >> 1) - if (mask & 0x01) - io = i; + mask= p[1] + p[2]*256; + for (i=0;i<16;i++, mask=mask>>1) + if(mask & 0x01) io=i; pnpbios_parse_allocated_irqresource(res, io); break; @@ -206,16 +191,15 @@ static unsigned char *pnpbios_parse_allocated_resource_data(unsigned char *p, goto len_err; io = -1; mask = p[1]; - for (i = 0; i < 8; i++, mask = mask >> 1) - if (mask & 0x01) - io = i; + for (i=0;i<8;i++, mask = mask>>1) + if(mask & 0x01) io=i; pnpbios_parse_allocated_dmaresource(res, io); break; case SMALL_TAG_PORT: if (len != 7) goto len_err; - io = p[2] + p[3] * 256; + io = p[2] + p[3] *256; size = p[7]; pnpbios_parse_allocated_ioresource(res, io, size); break; @@ -234,14 +218,12 @@ static unsigned char *pnpbios_parse_allocated_resource_data(unsigned char *p, case SMALL_TAG_END: p = p + 2; - return (unsigned char *)p; + return (unsigned char *)p; break; - default: /* an unkown tag */ - len_err: - printk(KERN_ERR - "PnPBIOS: Unknown tag '0x%x', length '%d'.\n", - tag, len); + default: /* an unkown tag */ + len_err: + printk(KERN_ERR "PnPBIOS: Unknown tag '0x%x', length '%d'.\n", tag, len); break; } @@ -252,21 +234,20 @@ static unsigned char *pnpbios_parse_allocated_resource_data(unsigned char *p, p += len + 1; } - printk(KERN_ERR - "PnPBIOS: Resource structure does not contain an end tag.\n"); + printk(KERN_ERR "PnPBIOS: Resource structure does not contain an end tag.\n"); return NULL; } + /* * Resource Configuration Options */ -static void pnpbios_parse_mem_option(unsigned char *p, int size, - struct pnp_option *option) +static void +pnpbios_parse_mem_option(unsigned char *p, int size, struct pnp_option *option) { - struct pnp_mem *mem; - + struct pnp_mem * mem; mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL); if (!mem) return; @@ -275,14 +256,14 @@ static void pnpbios_parse_mem_option(unsigned char *p, int size, mem->align = (p[9] << 8) | p[8]; mem->size = ((p[11] << 8) | p[10]) << 8; mem->flags = p[3]; - pnp_register_mem_resource(option, mem); + pnp_register_mem_resource(option,mem); + return; } -static void pnpbios_parse_mem32_option(unsigned char *p, int size, - struct pnp_option *option) +static void +pnpbios_parse_mem32_option(unsigned char *p, int size, struct pnp_option *option) { - struct pnp_mem *mem; - + struct pnp_mem * mem; mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL); if (!mem) return; @@ -291,13 +272,14 @@ static void pnpbios_parse_mem32_option(unsigned char *p, int size, mem->align = (p[15] << 24) | (p[14] << 16) | (p[13] << 8) | p[12]; mem->size = (p[19] << 24) | (p[18] << 16) | (p[17] << 8) | p[16]; mem->flags = p[3]; - pnp_register_mem_resource(option, mem); + pnp_register_mem_resource(option,mem); + return; } -static void pnpbios_parse_fixed_mem32_option(unsigned char *p, int size, - struct pnp_option *option) +static void +pnpbios_parse_fixed_mem32_option(unsigned char *p, int size, struct pnp_option *option) { - struct pnp_mem *mem; + struct pnp_mem * mem; mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL); if (!mem) return; @@ -305,13 +287,14 @@ static void pnpbios_parse_fixed_mem32_option(unsigned char *p, int size, mem->size = (p[11] << 24) | (p[10] << 16) | (p[9] << 8) | p[8]; mem->align = 0; mem->flags = p[3]; - pnp_register_mem_resource(option, mem); + pnp_register_mem_resource(option,mem); + return; } -static void pnpbios_parse_irq_option(unsigned char *p, int size, - struct pnp_option *option) +static void +pnpbios_parse_irq_option(unsigned char *p, int size, struct pnp_option *option) { - struct pnp_irq *irq; + struct pnp_irq * irq; unsigned long bits; irq = kzalloc(sizeof(struct pnp_irq), GFP_KERNEL); @@ -323,27 +306,27 @@ static void pnpbios_parse_irq_option(unsigned char *p, int size, irq->flags = p[3]; else irq->flags = IORESOURCE_IRQ_HIGHEDGE; - pnp_register_irq_resource(option, irq); + pnp_register_irq_resource(option,irq); + return; } -static void pnpbios_parse_dma_option(unsigned char *p, int size, - struct pnp_option *option) +static void +pnpbios_parse_dma_option(unsigned char *p, int size, struct pnp_option *option) { - struct pnp_dma *dma; - + struct pnp_dma * dma; dma = kzalloc(sizeof(struct pnp_dma), GFP_KERNEL); if (!dma) return; dma->map = p[1]; dma->flags = p[2]; - pnp_register_dma_resource(option, dma); + pnp_register_dma_resource(option,dma); + return; } -static void pnpbios_parse_port_option(unsigned char *p, int size, - struct pnp_option *option) +static void +pnpbios_parse_port_option(unsigned char *p, int size, struct pnp_option *option) { - struct pnp_port *port; - + struct pnp_port * port; port = kzalloc(sizeof(struct pnp_port), GFP_KERNEL); if (!port) return; @@ -352,14 +335,14 @@ static void pnpbios_parse_port_option(unsigned char *p, int size, port->align = p[6]; port->size = p[7]; port->flags = p[1] ? PNP_PORT_FLAG_16BITADDR : 0; - pnp_register_port_resource(option, port); + pnp_register_port_resource(option,port); + return; } -static void pnpbios_parse_fixed_port_option(unsigned char *p, int size, - struct pnp_option *option) +static void +pnpbios_parse_fixed_port_option(unsigned char *p, int size, struct pnp_option *option) { - struct pnp_port *port; - + struct pnp_port * port; port = kzalloc(sizeof(struct pnp_port), GFP_KERNEL); if (!port) return; @@ -367,12 +350,12 @@ static void pnpbios_parse_fixed_port_option(unsigned char *p, int size, port->size = p[3]; port->align = 0; port->flags = PNP_PORT_FLAG_FIXED; - pnp_register_port_resource(option, port); + pnp_register_port_resource(option,port); + return; } -static unsigned char *pnpbios_parse_resource_option_data(unsigned char *p, - unsigned char *end, - struct pnp_dev *dev) +static unsigned char * +pnpbios_parse_resource_option_data(unsigned char * p, unsigned char * end, struct pnp_dev *dev) { unsigned int len, tag; int priority = 0; @@ -388,12 +371,12 @@ static unsigned char *pnpbios_parse_resource_option_data(unsigned char *p, while ((char *)p < (char *)end) { /* determine the type of tag */ - if (p[0] & LARGE_TAG) { /* large tag */ + if (p[0] & LARGE_TAG) { /* large tag */ len = (p[2] << 8) | p[1]; tag = p[0]; - } else { /* small tag */ + } else { /* small tag */ len = p[0] & 0x07; - tag = ((p[0] >> 3) & 0x0f); + tag = ((p[0]>>3) & 0x0f); } switch (tag) { @@ -459,19 +442,16 @@ static unsigned char *pnpbios_parse_resource_option_data(unsigned char *p, if (len != 0) goto len_err; if (option_independent == option) - printk(KERN_WARNING - "PnPBIOS: Missing SMALL_TAG_STARTDEP tag\n"); + printk(KERN_WARNING "PnPBIOS: Missing SMALL_TAG_STARTDEP tag\n"); option = option_independent; break; case SMALL_TAG_END: - return p + 2; + return p + 2; - default: /* an unkown tag */ - len_err: - printk(KERN_ERR - "PnPBIOS: Unknown tag '0x%x', length '%d'.\n", - tag, len); + default: /* an unkown tag */ + len_err: + printk(KERN_ERR "PnPBIOS: Unknown tag '0x%x', length '%d'.\n", tag, len); break; } @@ -482,18 +462,19 @@ static unsigned char *pnpbios_parse_resource_option_data(unsigned char *p, p += len + 1; } - printk(KERN_ERR - "PnPBIOS: Resource structure does not contain an end tag.\n"); + printk(KERN_ERR "PnPBIOS: Resource structure does not contain an end tag.\n"); return NULL; } + /* * Compatible Device IDs */ #define HEX(id,a) hex[((id)>>a) & 15] #define CHAR(id,a) (0x40 + (((id)>>a) & 31)) +// void pnpid32_to_pnpid(u32 id, char *str) { @@ -502,20 +483,21 @@ void pnpid32_to_pnpid(u32 id, char *str) id = be32_to_cpu(id); str[0] = CHAR(id, 26); str[1] = CHAR(id, 21); - str[2] = CHAR(id, 16); + str[2] = CHAR(id,16); str[3] = HEX(id, 12); str[4] = HEX(id, 8); str[5] = HEX(id, 4); str[6] = HEX(id, 0); str[7] = '\0'; -} + return; +} +// #undef CHAR #undef HEX -static unsigned char *pnpbios_parse_compatible_ids(unsigned char *p, - unsigned char *end, - struct pnp_dev *dev) +static unsigned char * +pnpbios_parse_compatible_ids(unsigned char *p, unsigned char *end, struct pnp_dev *dev) { int len, tag; char id[8]; @@ -527,45 +509,40 @@ static unsigned char *pnpbios_parse_compatible_ids(unsigned char *p, while ((char *)p < (char *)end) { /* determine the type of tag */ - if (p[0] & LARGE_TAG) { /* large tag */ + if (p[0] & LARGE_TAG) { /* large tag */ len = (p[2] << 8) | p[1]; tag = p[0]; - } else { /* small tag */ + } else { /* small tag */ len = p[0] & 0x07; - tag = ((p[0] >> 3) & 0x0f); + tag = ((p[0]>>3) & 0x0f); } switch (tag) { case LARGE_TAG_ANSISTR: - strncpy(dev->name, p + 3, - len >= PNP_NAME_LEN ? PNP_NAME_LEN - 2 : len); - dev->name[len >= - PNP_NAME_LEN ? PNP_NAME_LEN - 1 : len] = '\0'; + strncpy(dev->name, p + 3, len >= PNP_NAME_LEN ? PNP_NAME_LEN - 2 : len); + dev->name[len >= PNP_NAME_LEN ? PNP_NAME_LEN - 1 : len] = '\0'; break; - case SMALL_TAG_COMPATDEVID: /* compatible ID */ + case SMALL_TAG_COMPATDEVID: /* compatible ID */ if (len != 4) goto len_err; - dev_id = kzalloc(sizeof(struct pnp_id), GFP_KERNEL); + dev_id = kzalloc(sizeof (struct pnp_id), GFP_KERNEL); if (!dev_id) return NULL; - pnpid32_to_pnpid(p[1] | p[2] << 8 | p[3] << 16 | p[4] << - 24, id); + pnpid32_to_pnpid(p[1] | p[2] << 8 | p[3] << 16 | p[4] << 24,id); memcpy(&dev_id->id, id, 7); pnp_add_id(dev_id, dev); break; case SMALL_TAG_END: p = p + 2; - return (unsigned char *)p; + return (unsigned char *)p; break; - default: /* an unkown tag */ - len_err: - printk(KERN_ERR - "PnPBIOS: Unknown tag '0x%x', length '%d'.\n", - tag, len); + default: /* an unkown tag */ + len_err: + printk(KERN_ERR "PnPBIOS: Unknown tag '0x%x', length '%d'.\n", tag, len); break; } @@ -576,34 +553,33 @@ static unsigned char *pnpbios_parse_compatible_ids(unsigned char *p, p += len + 1; } - printk(KERN_ERR - "PnPBIOS: Resource structure does not contain an end tag.\n"); + printk(KERN_ERR "PnPBIOS: Resource structure does not contain an end tag.\n"); return NULL; } + /* * Allocated Resource Encoding */ -static void pnpbios_encode_mem(unsigned char *p, struct resource *res) +static void pnpbios_encode_mem(unsigned char *p, struct resource * res) { unsigned long base = res->start; unsigned long len = res->end - res->start + 1; - p[4] = (base >> 8) & 0xff; p[5] = ((base >> 8) >> 8) & 0xff; p[6] = (base >> 8) & 0xff; p[7] = ((base >> 8) >> 8) & 0xff; p[10] = (len >> 8) & 0xff; p[11] = ((len >> 8) >> 8) & 0xff; + return; } -static void pnpbios_encode_mem32(unsigned char *p, struct resource *res) +static void pnpbios_encode_mem32(unsigned char *p, struct resource * res) { unsigned long base = res->start; unsigned long len = res->end - res->start + 1; - p[4] = base & 0xff; p[5] = (base >> 8) & 0xff; p[6] = (base >> 16) & 0xff; @@ -616,13 +592,12 @@ static void pnpbios_encode_mem32(unsigned char *p, struct resource *res) p[17] = (len >> 8) & 0xff; p[18] = (len >> 16) & 0xff; p[19] = (len >> 24) & 0xff; + return; } -static void pnpbios_encode_fixed_mem32(unsigned char *p, struct resource *res) -{ - unsigned long base = res->start; +static void pnpbios_encode_fixed_mem32(unsigned char *p, struct resource * res) +{ unsigned long base = res->start; unsigned long len = res->end - res->start + 1; - p[4] = base & 0xff; p[5] = (base >> 8) & 0xff; p[6] = (base >> 16) & 0xff; @@ -631,52 +606,50 @@ static void pnpbios_encode_fixed_mem32(unsigned char *p, struct resource *res) p[9] = (len >> 8) & 0xff; p[10] = (len >> 16) & 0xff; p[11] = (len >> 24) & 0xff; + return; } -static void pnpbios_encode_irq(unsigned char *p, struct resource *res) +static void pnpbios_encode_irq(unsigned char *p, struct resource * res) { unsigned long map = 0; - map = 1 << res->start; p[1] = map & 0xff; p[2] = (map >> 8) & 0xff; + return; } -static void pnpbios_encode_dma(unsigned char *p, struct resource *res) +static void pnpbios_encode_dma(unsigned char *p, struct resource * res) { unsigned long map = 0; - map = 1 << res->start; p[1] = map & 0xff; + return; } -static void pnpbios_encode_port(unsigned char *p, struct resource *res) +static void pnpbios_encode_port(unsigned char *p, struct resource * res) { unsigned long base = res->start; unsigned long len = res->end - res->start + 1; - p[2] = base & 0xff; p[3] = (base >> 8) & 0xff; p[4] = base & 0xff; p[5] = (base >> 8) & 0xff; p[7] = len & 0xff; + return; } -static void pnpbios_encode_fixed_port(unsigned char *p, struct resource *res) +static void pnpbios_encode_fixed_port(unsigned char *p, struct resource * res) { unsigned long base = res->start; unsigned long len = res->end - res->start + 1; - p[1] = base & 0xff; p[2] = (base >> 8) & 0xff; p[3] = len & 0xff; + return; } -static unsigned char *pnpbios_encode_allocated_resource_data(unsigned char *p, - unsigned char *end, - struct - pnp_resource_table - *res) +static unsigned char * +pnpbios_encode_allocated_resource_data(unsigned char * p, unsigned char * end, struct pnp_resource_table * res) { unsigned int len, tag; int port = 0, irq = 0, dma = 0, mem = 0; @@ -687,12 +660,12 @@ static unsigned char *pnpbios_encode_allocated_resource_data(unsigned char *p, while ((char *)p < (char *)end) { /* determine the type of tag */ - if (p[0] & LARGE_TAG) { /* large tag */ + if (p[0] & LARGE_TAG) { /* large tag */ len = (p[2] << 8) | p[1]; tag = p[0]; - } else { /* small tag */ + } else { /* small tag */ len = p[0] & 0x07; - tag = ((p[0] >> 3) & 0x0f); + tag = ((p[0]>>3) & 0x0f); } switch (tag) { @@ -752,14 +725,12 @@ static unsigned char *pnpbios_encode_allocated_resource_data(unsigned char *p, case SMALL_TAG_END: p = p + 2; - return (unsigned char *)p; + return (unsigned char *)p; break; - default: /* an unkown tag */ - len_err: - printk(KERN_ERR - "PnPBIOS: Unknown tag '0x%x', length '%d'.\n", - tag, len); + default: /* an unkown tag */ + len_err: + printk(KERN_ERR "PnPBIOS: Unknown tag '0x%x', length '%d'.\n", tag, len); break; } @@ -770,52 +741,52 @@ static unsigned char *pnpbios_encode_allocated_resource_data(unsigned char *p, p += len + 1; } - printk(KERN_ERR - "PnPBIOS: Resource structure does not contain an end tag.\n"); + printk(KERN_ERR "PnPBIOS: Resource structure does not contain an end tag.\n"); return NULL; } + /* * Core Parsing Functions */ -int pnpbios_parse_data_stream(struct pnp_dev *dev, struct pnp_bios_node *node) +int +pnpbios_parse_data_stream(struct pnp_dev *dev, struct pnp_bios_node * node) { - unsigned char *p = (char *)node->data; - unsigned char *end = (char *)(node->data + node->size); - - p = pnpbios_parse_allocated_resource_data(p, end, &dev->res); + unsigned char * p = (char *)node->data; + unsigned char * end = (char *)(node->data + node->size); + p = pnpbios_parse_allocated_resource_data(p,end,&dev->res); if (!p) return -EIO; - p = pnpbios_parse_resource_option_data(p, end, dev); + p = pnpbios_parse_resource_option_data(p,end,dev); if (!p) return -EIO; - p = pnpbios_parse_compatible_ids(p, end, dev); + p = pnpbios_parse_compatible_ids(p,end,dev); if (!p) return -EIO; return 0; } -int pnpbios_read_resources_from_node(struct pnp_resource_table *res, - struct pnp_bios_node *node) +int +pnpbios_read_resources_from_node(struct pnp_resource_table *res, + struct pnp_bios_node * node) { - unsigned char *p = (char *)node->data; - unsigned char *end = (char *)(node->data + node->size); - - p = pnpbios_parse_allocated_resource_data(p, end, res); + unsigned char * p = (char *)node->data; + unsigned char * end = (char *)(node->data + node->size); + p = pnpbios_parse_allocated_resource_data(p,end,res); if (!p) return -EIO; return 0; } -int pnpbios_write_resources_to_node(struct pnp_resource_table *res, - struct pnp_bios_node *node) +int +pnpbios_write_resources_to_node(struct pnp_resource_table *res, + struct pnp_bios_node * node) { - unsigned char *p = (char *)node->data; - unsigned char *end = (char *)(node->data + node->size); - - p = pnpbios_encode_allocated_resource_data(p, end, res); + unsigned char * p = (char *)node->data; + unsigned char * end = (char *)(node->data + node->size); + p = pnpbios_encode_allocated_resource_data(p,end,res); if (!p) return -EIO; return 0; diff --git a/trunk/drivers/pnp/quirks.c b/trunk/drivers/pnp/quirks.c index 90755d4cdb9f..7c3236690cc3 100644 --- a/trunk/drivers/pnp/quirks.c +++ b/trunk/drivers/pnp/quirks.c @@ -19,6 +19,7 @@ #include #include "base.h" + static void quirk_awe32_resources(struct pnp_dev *dev) { struct pnp_port *port, *port2, *port3; @@ -30,7 +31,7 @@ static void quirk_awe32_resources(struct pnp_dev *dev) * two extra ports (at offset 0x400 and 0x800 from the one given) by * hand. */ - for (; res; res = res->next) { + for ( ; res ; res = res->next ) { port2 = pnp_alloc(sizeof(struct pnp_port)); if (!port2) return; @@ -57,19 +58,18 @@ static void quirk_cmi8330_resources(struct pnp_dev *dev) struct pnp_option *res = dev->dependent; unsigned long tmp; - for (; res; res = res->next) { + for ( ; res ; res = res->next ) { struct pnp_irq *irq; struct pnp_dma *dma; - for (irq = res->irq; irq; irq = irq->next) { // Valid irqs are 5, 7, 10 + for( irq = res->irq; irq; irq = irq->next ) { // Valid irqs are 5, 7, 10 tmp = 0x04A0; bitmap_copy(irq->map, &tmp, 16); // 0000 0100 1010 0000 } - for (dma = res->dma; dma; dma = dma->next) // Valid 8bit dma channels are 1,3 - if ((dma->flags & IORESOURCE_DMA_TYPE_MASK) == - IORESOURCE_DMA_8BIT) + for( dma = res->dma; dma; dma = dma->next ) // Valid 8bit dma channels are 1,3 + if( ( dma->flags & IORESOURCE_DMA_TYPE_MASK ) == IORESOURCE_DMA_8BIT ) dma->map = 0x000A; } printk(KERN_INFO "pnp: CMI8330 quirk - fixing interrupts and dma\n"); @@ -79,7 +79,7 @@ static void quirk_sb16audio_resources(struct pnp_dev *dev) { struct pnp_port *port; struct pnp_option *res = dev->dependent; - int changed = 0; + int changed = 0; /* * The default range on the mpu port for these devices is 0x388-0x388. @@ -87,24 +87,24 @@ static void quirk_sb16audio_resources(struct pnp_dev *dev) * auto-configured. */ - for (; res; res = res->next) { + for( ; res ; res = res->next ) { port = res->port; - if (!port) + if(!port) continue; port = port->next; - if (!port) + if(!port) continue; port = port->next; - if (!port) + if(!port) continue; - if (port->min != port->max) + if(port->min != port->max) continue; port->max += 0x70; changed = 1; } - if (changed) - printk(KERN_INFO - "pnp: SB audio device quirk - increasing port range\n"); + if(changed) + printk(KERN_INFO "pnp: SB audio device quirk - increasing port range\n"); + return; } static int quirk_smc_fir_enabled(struct pnp_dev *dev) @@ -124,7 +124,7 @@ static int quirk_smc_fir_enabled(struct pnp_dev *dev) outb(bank, firbase + 7); high = inb(firbase + 0); - low = inb(firbase + 1); + low = inb(firbase + 1); chip = inb(firbase + 2); /* This corresponds to the check in smsc_ircc_present() */ @@ -153,8 +153,8 @@ static void quirk_smc_enable(struct pnp_dev *dev) */ dev_err(&dev->dev, "%s not responding at SIR 0x%lx, FIR 0x%lx; " "auto-configuring\n", dev->id->id, - (unsigned long)pnp_port_start(dev, 0), - (unsigned long)pnp_port_start(dev, 1)); + (unsigned long) pnp_port_start(dev, 0), + (unsigned long) pnp_port_start(dev, 1)); pnp_disable_dev(dev); pnp_init_resource_table(&dev->res); @@ -162,8 +162,8 @@ static void quirk_smc_enable(struct pnp_dev *dev) pnp_activate_dev(dev); if (quirk_smc_fir_enabled(dev)) { dev_err(&dev->dev, "responds at SIR 0x%lx, FIR 0x%lx\n", - (unsigned long)pnp_port_start(dev, 0), - (unsigned long)pnp_port_start(dev, 1)); + (unsigned long) pnp_port_start(dev, 0), + (unsigned long) pnp_port_start(dev, 1)); return; } @@ -175,8 +175,8 @@ static void quirk_smc_enable(struct pnp_dev *dev) */ dev_err(&dev->dev, "not responding at SIR 0x%lx, FIR 0x%lx; " "swapping SIR/FIR and reconfiguring\n", - (unsigned long)pnp_port_start(dev, 0), - (unsigned long)pnp_port_start(dev, 1)); + (unsigned long) pnp_port_start(dev, 0), + (unsigned long) pnp_port_start(dev, 1)); /* * Clear IORESOURCE_AUTO so pnp_activate_dev() doesn't reassign @@ -200,8 +200,8 @@ static void quirk_smc_enable(struct pnp_dev *dev) if (quirk_smc_fir_enabled(dev)) { dev_err(&dev->dev, "responds at SIR 0x%lx, FIR 0x%lx\n", - (unsigned long)pnp_port_start(dev, 0), - (unsigned long)pnp_port_start(dev, 1)); + (unsigned long) pnp_port_start(dev, 0), + (unsigned long) pnp_port_start(dev, 1)); return; } @@ -209,6 +209,7 @@ static void quirk_smc_enable(struct pnp_dev *dev) "email bjorn.helgaas@hp.com\n"); } + /* * PnP Quirks * Cards or devices that need some tweaking due to incomplete resource info @@ -216,21 +217,21 @@ static void quirk_smc_enable(struct pnp_dev *dev) static struct pnp_fixup pnp_fixups[] = { /* Soundblaster awe io port quirk */ - {"CTL0021", quirk_awe32_resources}, - {"CTL0022", quirk_awe32_resources}, - {"CTL0023", quirk_awe32_resources}, + { "CTL0021", quirk_awe32_resources }, + { "CTL0022", quirk_awe32_resources }, + { "CTL0023", quirk_awe32_resources }, /* CMI 8330 interrupt and dma fix */ - {"@X@0001", quirk_cmi8330_resources}, + { "@X@0001", quirk_cmi8330_resources }, /* Soundblaster audio device io port range quirk */ - {"CTL0001", quirk_sb16audio_resources}, - {"CTL0031", quirk_sb16audio_resources}, - {"CTL0041", quirk_sb16audio_resources}, - {"CTL0042", quirk_sb16audio_resources}, - {"CTL0043", quirk_sb16audio_resources}, - {"CTL0044", quirk_sb16audio_resources}, - {"CTL0045", quirk_sb16audio_resources}, - {"SMCf010", quirk_smc_enable}, - {""} + { "CTL0001", quirk_sb16audio_resources }, + { "CTL0031", quirk_sb16audio_resources }, + { "CTL0041", quirk_sb16audio_resources }, + { "CTL0042", quirk_sb16audio_resources }, + { "CTL0043", quirk_sb16audio_resources }, + { "CTL0044", quirk_sb16audio_resources }, + { "CTL0045", quirk_sb16audio_resources }, + { "SMCf010", quirk_smc_enable }, + { "" } }; void pnp_fixup_device(struct pnp_dev *dev) @@ -238,8 +239,9 @@ void pnp_fixup_device(struct pnp_dev *dev) int i = 0; while (*pnp_fixups[i].id) { - if (compare_pnp_id(dev->id, pnp_fixups[i].id)) { - pnp_dbg("Calling quirk for %s", dev->dev.bus_id); + if (compare_pnp_id(dev->id,pnp_fixups[i].id)) { + pnp_dbg("Calling quirk for %s", + dev->dev.bus_id); pnp_fixups[i].quirk_function(dev); } i++; diff --git a/trunk/drivers/pnp/resource.c b/trunk/drivers/pnp/resource.c index ea6ec14a0559..a685fbec4604 100644 --- a/trunk/drivers/pnp/resource.c +++ b/trunk/drivers/pnp/resource.c @@ -3,6 +3,7 @@ * * based on isapnp.c resource management (c) Jaroslav Kysela * Copyright 2003 Adam Belay + * */ #include @@ -19,19 +20,21 @@ #include #include "base.h" -static int pnp_reserve_irq[16] = {[0 ... 15] = -1 }; /* reserve (don't use) some IRQ */ -static int pnp_reserve_dma[8] = {[0 ... 7] = -1 }; /* reserve (don't use) some DMA */ -static int pnp_reserve_io[16] = {[0 ... 15] = -1 }; /* reserve (don't use) some I/O region */ -static int pnp_reserve_mem[16] = {[0 ... 15] = -1 }; /* reserve (don't use) some memory region */ +static int pnp_reserve_irq[16] = { [0 ... 15] = -1 }; /* reserve (don't use) some IRQ */ +static int pnp_reserve_dma[8] = { [0 ... 7] = -1 }; /* reserve (don't use) some DMA */ +static int pnp_reserve_io[16] = { [0 ... 15] = -1 }; /* reserve (don't use) some I/O region */ +static int pnp_reserve_mem[16] = { [0 ... 15] = -1 }; /* reserve (don't use) some memory region */ + /* * option registration */ -static struct pnp_option *pnp_build_option(int priority) +static struct pnp_option * pnp_build_option(int priority) { struct pnp_option *option = pnp_alloc(sizeof(struct pnp_option)); + /* check if pnp_alloc ran out of memory */ if (!option) return NULL; @@ -43,10 +46,9 @@ static struct pnp_option *pnp_build_option(int priority) return option; } -struct pnp_option *pnp_register_independent_option(struct pnp_dev *dev) +struct pnp_option * pnp_register_independent_option(struct pnp_dev *dev) { struct pnp_option *option; - if (!dev) return NULL; @@ -59,11 +61,9 @@ struct pnp_option *pnp_register_independent_option(struct pnp_dev *dev) return option; } -struct pnp_option *pnp_register_dependent_option(struct pnp_dev *dev, - int priority) +struct pnp_option * pnp_register_dependent_option(struct pnp_dev *dev, int priority) { struct pnp_option *option; - if (!dev) return NULL; @@ -82,7 +82,6 @@ struct pnp_option *pnp_register_dependent_option(struct pnp_dev *dev, int pnp_register_irq_resource(struct pnp_option *option, struct pnp_irq *data) { struct pnp_irq *ptr; - if (!option) return -EINVAL; if (!data) @@ -111,7 +110,6 @@ int pnp_register_irq_resource(struct pnp_option *option, struct pnp_irq *data) int pnp_register_dma_resource(struct pnp_option *option, struct pnp_dma *data) { struct pnp_dma *ptr; - if (!option) return -EINVAL; if (!data) @@ -131,7 +129,6 @@ int pnp_register_dma_resource(struct pnp_option *option, struct pnp_dma *data) int pnp_register_port_resource(struct pnp_option *option, struct pnp_port *data) { struct pnp_port *ptr; - if (!option) return -EINVAL; if (!data) @@ -151,7 +148,6 @@ int pnp_register_port_resource(struct pnp_option *option, struct pnp_port *data) int pnp_register_mem_resource(struct pnp_option *option, struct pnp_mem *data) { struct pnp_mem *ptr; - if (!option) return -EINVAL; if (!data) @@ -226,6 +222,7 @@ void pnp_free_option(struct pnp_option *option) } } + /* * resource validity checking */ @@ -239,12 +236,11 @@ void pnp_free_option(struct pnp_option *option) #define cannot_compare(flags) \ ((flags) & (IORESOURCE_UNSET | IORESOURCE_DISABLED)) -int pnp_check_port(struct pnp_dev *dev, int idx) +int pnp_check_port(struct pnp_dev * dev, int idx) { int tmp; struct pnp_dev *tdev; resource_size_t *port, *end, *tport, *tend; - port = &dev->res.port_resource[idx].start; end = &dev->res.port_resource[idx].end; @@ -254,8 +250,8 @@ int pnp_check_port(struct pnp_dev *dev, int idx) /* check if the resource is already in use, skip if the * device is active because it itself may be in use */ - if (!dev->active) { - if (__check_region(&ioport_resource, *port, length(port, end))) + if(!dev->active) { + if (__check_region(&ioport_resource, *port, length(port,end))) return 0; } @@ -263,7 +259,7 @@ int pnp_check_port(struct pnp_dev *dev, int idx) for (tmp = 0; tmp < 8; tmp++) { int rport = pnp_reserve_io[tmp << 1]; int rend = pnp_reserve_io[(tmp << 1) + 1] + rport - 1; - if (ranged_conflict(port, end, &rport, &rend)) + if (ranged_conflict(port,end,&rport,&rend)) return 0; } @@ -272,7 +268,7 @@ int pnp_check_port(struct pnp_dev *dev, int idx) if (dev->res.port_resource[tmp].flags & IORESOURCE_IO) { tport = &dev->res.port_resource[tmp].start; tend = &dev->res.port_resource[tmp].end; - if (ranged_conflict(port, end, tport, tend)) + if (ranged_conflict(port,end,tport,tend)) return 0; } } @@ -283,12 +279,11 @@ int pnp_check_port(struct pnp_dev *dev, int idx) continue; for (tmp = 0; tmp < PNP_MAX_PORT; tmp++) { if (tdev->res.port_resource[tmp].flags & IORESOURCE_IO) { - if (cannot_compare - (tdev->res.port_resource[tmp].flags)) + if (cannot_compare(tdev->res.port_resource[tmp].flags)) continue; tport = &tdev->res.port_resource[tmp].start; tend = &tdev->res.port_resource[tmp].end; - if (ranged_conflict(port, end, tport, tend)) + if (ranged_conflict(port,end,tport,tend)) return 0; } } @@ -297,12 +292,11 @@ int pnp_check_port(struct pnp_dev *dev, int idx) return 1; } -int pnp_check_mem(struct pnp_dev *dev, int idx) +int pnp_check_mem(struct pnp_dev * dev, int idx) { int tmp; struct pnp_dev *tdev; resource_size_t *addr, *end, *taddr, *tend; - addr = &dev->res.mem_resource[idx].start; end = &dev->res.mem_resource[idx].end; @@ -312,8 +306,8 @@ int pnp_check_mem(struct pnp_dev *dev, int idx) /* check if the resource is already in use, skip if the * device is active because it itself may be in use */ - if (!dev->active) { - if (check_mem_region(*addr, length(addr, end))) + if(!dev->active) { + if (check_mem_region(*addr, length(addr,end))) return 0; } @@ -321,7 +315,7 @@ int pnp_check_mem(struct pnp_dev *dev, int idx) for (tmp = 0; tmp < 8; tmp++) { int raddr = pnp_reserve_mem[tmp << 1]; int rend = pnp_reserve_mem[(tmp << 1) + 1] + raddr - 1; - if (ranged_conflict(addr, end, &raddr, &rend)) + if (ranged_conflict(addr,end,&raddr,&rend)) return 0; } @@ -330,7 +324,7 @@ int pnp_check_mem(struct pnp_dev *dev, int idx) if (dev->res.mem_resource[tmp].flags & IORESOURCE_MEM) { taddr = &dev->res.mem_resource[tmp].start; tend = &dev->res.mem_resource[tmp].end; - if (ranged_conflict(addr, end, taddr, tend)) + if (ranged_conflict(addr,end,taddr,tend)) return 0; } } @@ -341,12 +335,11 @@ int pnp_check_mem(struct pnp_dev *dev, int idx) continue; for (tmp = 0; tmp < PNP_MAX_MEM; tmp++) { if (tdev->res.mem_resource[tmp].flags & IORESOURCE_MEM) { - if (cannot_compare - (tdev->res.mem_resource[tmp].flags)) + if (cannot_compare(tdev->res.mem_resource[tmp].flags)) continue; taddr = &tdev->res.mem_resource[tmp].start; tend = &tdev->res.mem_resource[tmp].end; - if (ranged_conflict(addr, end, taddr, tend)) + if (ranged_conflict(addr,end,taddr,tend)) return 0; } } @@ -360,11 +353,11 @@ static irqreturn_t pnp_test_handler(int irq, void *dev_id) return IRQ_HANDLED; } -int pnp_check_irq(struct pnp_dev *dev, int idx) +int pnp_check_irq(struct pnp_dev * dev, int idx) { int tmp; struct pnp_dev *tdev; - resource_size_t *irq = &dev->res.irq_resource[idx].start; + resource_size_t * irq = &dev->res.irq_resource[idx].start; /* if the resource doesn't exist, don't complain about it */ if (cannot_compare(dev->res.irq_resource[idx].flags)) @@ -401,9 +394,9 @@ int pnp_check_irq(struct pnp_dev *dev, int idx) /* check if the resource is already in use, skip if the * device is active because it itself may be in use */ - if (!dev->active) { + if(!dev->active) { if (request_irq(*irq, pnp_test_handler, - IRQF_DISABLED | IRQF_PROBE_SHARED, "pnp", NULL)) + IRQF_DISABLED|IRQF_PROBE_SHARED, "pnp", NULL)) return 0; free_irq(*irq, NULL); } @@ -414,8 +407,7 @@ int pnp_check_irq(struct pnp_dev *dev, int idx) continue; for (tmp = 0; tmp < PNP_MAX_IRQ; tmp++) { if (tdev->res.irq_resource[tmp].flags & IORESOURCE_IRQ) { - if (cannot_compare - (tdev->res.irq_resource[tmp].flags)) + if (cannot_compare(tdev->res.irq_resource[tmp].flags)) continue; if ((tdev->res.irq_resource[tmp].start == *irq)) return 0; @@ -426,12 +418,12 @@ int pnp_check_irq(struct pnp_dev *dev, int idx) return 1; } -int pnp_check_dma(struct pnp_dev *dev, int idx) +int pnp_check_dma(struct pnp_dev * dev, int idx) { #ifndef CONFIG_IA64 int tmp; struct pnp_dev *tdev; - resource_size_t *dma = &dev->res.dma_resource[idx].start; + resource_size_t * dma = &dev->res.dma_resource[idx].start; /* if the resource doesn't exist, don't complain about it */ if (cannot_compare(dev->res.dma_resource[idx].flags)) @@ -457,7 +449,7 @@ int pnp_check_dma(struct pnp_dev *dev, int idx) /* check if the resource is already in use, skip if the * device is active because it itself may be in use */ - if (!dev->active) { + if(!dev->active) { if (request_dma(*dma, "pnp")) return 0; free_dma(*dma); @@ -469,8 +461,7 @@ int pnp_check_dma(struct pnp_dev *dev, int idx) continue; for (tmp = 0; tmp < PNP_MAX_DMA; tmp++) { if (tdev->res.dma_resource[tmp].flags & IORESOURCE_DMA) { - if (cannot_compare - (tdev->res.dma_resource[tmp].flags)) + if (cannot_compare(tdev->res.dma_resource[tmp].flags)) continue; if ((tdev->res.dma_resource[tmp].start == *dma)) return 0; @@ -480,18 +471,30 @@ int pnp_check_dma(struct pnp_dev *dev, int idx) return 1; #else - /* IA64 does not have legacy DMA */ + /* IA64 hasn't legacy DMA */ return 0; #endif } + +#if 0 +EXPORT_SYMBOL(pnp_register_dependent_option); +EXPORT_SYMBOL(pnp_register_independent_option); +EXPORT_SYMBOL(pnp_register_irq_resource); +EXPORT_SYMBOL(pnp_register_dma_resource); +EXPORT_SYMBOL(pnp_register_port_resource); +EXPORT_SYMBOL(pnp_register_mem_resource); +#endif /* 0 */ + + /* format is: pnp_reserve_irq=irq1[,irq2] .... */ + static int __init pnp_setup_reserve_irq(char *str) { int i; for (i = 0; i < 16; i++) - if (get_option(&str, &pnp_reserve_irq[i]) != 2) + if (get_option(&str,&pnp_reserve_irq[i]) != 2) break; return 1; } @@ -499,12 +502,13 @@ static int __init pnp_setup_reserve_irq(char *str) __setup("pnp_reserve_irq=", pnp_setup_reserve_irq); /* format is: pnp_reserve_dma=dma1[,dma2] .... */ + static int __init pnp_setup_reserve_dma(char *str) { int i; for (i = 0; i < 8; i++) - if (get_option(&str, &pnp_reserve_dma[i]) != 2) + if (get_option(&str,&pnp_reserve_dma[i]) != 2) break; return 1; } @@ -512,12 +516,13 @@ static int __init pnp_setup_reserve_dma(char *str) __setup("pnp_reserve_dma=", pnp_setup_reserve_dma); /* format is: pnp_reserve_io=io1,size1[,io2,size2] .... */ + static int __init pnp_setup_reserve_io(char *str) { int i; for (i = 0; i < 16; i++) - if (get_option(&str, &pnp_reserve_io[i]) != 2) + if (get_option(&str,&pnp_reserve_io[i]) != 2) break; return 1; } @@ -525,12 +530,13 @@ static int __init pnp_setup_reserve_io(char *str) __setup("pnp_reserve_io=", pnp_setup_reserve_io); /* format is: pnp_reserve_mem=mem1,size1[,mem2,size2] .... */ + static int __init pnp_setup_reserve_mem(char *str) { int i; for (i = 0; i < 16; i++) - if (get_option(&str, &pnp_reserve_mem[i]) != 2) + if (get_option(&str,&pnp_reserve_mem[i]) != 2) break; return 1; } diff --git a/trunk/drivers/pnp/support.c b/trunk/drivers/pnp/support.c index 13c608f5fb30..946a0dcd627d 100644 --- a/trunk/drivers/pnp/support.c +++ b/trunk/drivers/pnp/support.c @@ -1,7 +1,8 @@ /* - * support.c - standard functions for the use of pnp protocol drivers + * support.c - provides standard pnp functions for the use of pnp protocol drivers, * * Copyright 2003 Adam Belay + * */ #include @@ -10,18 +11,22 @@ #include "base.h" /** - * pnp_is_active - Determines if a device is active based on its current - * resources + * pnp_is_active - Determines if a device is active based on its current resources * @dev: pointer to the desired PnP device + * */ -int pnp_is_active(struct pnp_dev *dev) + +int pnp_is_active(struct pnp_dev * dev) { if (!pnp_port_start(dev, 0) && pnp_port_len(dev, 0) <= 1 && !pnp_mem_start(dev, 0) && pnp_mem_len(dev, 0) <= 1 && - pnp_irq(dev, 0) == -1 && pnp_dma(dev, 0) == -1) - return 0; + pnp_irq(dev, 0) == -1 && + pnp_dma(dev, 0) == -1) + return 0; else return 1; } + + EXPORT_SYMBOL(pnp_is_active); diff --git a/trunk/drivers/pnp/system.c b/trunk/drivers/pnp/system.c index a06f980b3ac9..a8a95540b1ef 100644 --- a/trunk/drivers/pnp/system.c +++ b/trunk/drivers/pnp/system.c @@ -16,14 +16,13 @@ static const struct pnp_device_id pnp_dev_table[] = { /* General ID for reserving resources */ - {"PNP0c02", 0}, + { "PNP0c02", 0 }, /* memory controller */ - {"PNP0c01", 0}, - {"", 0} + { "PNP0c01", 0 }, + { "", 0 } }; -static void reserve_range(const char *pnpid, resource_size_t start, - resource_size_t end, int port) +static void reserve_range(const char *pnpid, resource_size_t start, resource_size_t end, int port) { struct resource *res; char *regionid; @@ -33,9 +32,9 @@ static void reserve_range(const char *pnpid, resource_size_t start, return; snprintf(regionid, 16, "pnp %s", pnpid); if (port) - res = request_region(start, end - start + 1, regionid); + res = request_region(start, end-start+1, regionid); else - res = request_mem_region(start, end - start + 1, regionid); + res = request_mem_region(start, end-start+1, regionid); if (res == NULL) kfree(regionid); else @@ -45,10 +44,11 @@ static void reserve_range(const char *pnpid, resource_size_t start, * example do reserve stuff they know about too, so we may well * have double reservations. */ - printk(KERN_INFO "pnp: %s: %s range 0x%llx-0x%llx %s reserved\n", - pnpid, port ? "ioport" : "iomem", - (unsigned long long)start, (unsigned long long)end, - NULL != res ? "has been" : "could not be"); + printk(KERN_INFO + "pnp: %s: %s range 0x%llx-0x%llx %s reserved\n", + pnpid, port ? "ioport" : "iomem", + (unsigned long long)start, (unsigned long long)end, + NULL != res ? "has been" : "could not be"); } static void reserve_resources_of_dev(const struct pnp_dev *dev) @@ -74,7 +74,7 @@ static void reserve_resources_of_dev(const struct pnp_dev *dev) continue; /* invalid */ reserve_range(dev->dev.bus_id, pnp_port_start(dev, i), - pnp_port_end(dev, i), 1); + pnp_port_end(dev, i), 1); } for (i = 0; i < PNP_MAX_MEM; i++) { @@ -82,22 +82,24 @@ static void reserve_resources_of_dev(const struct pnp_dev *dev) continue; reserve_range(dev->dev.bus_id, pnp_mem_start(dev, i), - pnp_mem_end(dev, i), 0); + pnp_mem_end(dev, i), 0); } + + return; } -static int system_pnp_probe(struct pnp_dev *dev, - const struct pnp_device_id *dev_id) +static int system_pnp_probe(struct pnp_dev * dev, const struct pnp_device_id *dev_id) { reserve_resources_of_dev(dev); return 0; } static struct pnp_driver system_pnp_driver = { - .name = "system", - .id_table = pnp_dev_table, - .flags = PNP_DRIVER_RES_DO_NOT_CHANGE, - .probe = system_pnp_probe, + .name = "system", + .id_table = pnp_dev_table, + .flags = PNP_DRIVER_RES_DO_NOT_CHANGE, + .probe = system_pnp_probe, + .remove = NULL, }; static int __init pnp_system_init(void) diff --git a/trunk/drivers/rtc/Makefile b/trunk/drivers/rtc/Makefile index d3a33aa2696f..7ede9e725360 100644 --- a/trunk/drivers/rtc/Makefile +++ b/trunk/drivers/rtc/Makefile @@ -15,36 +15,34 @@ rtc-core-$(CONFIG_RTC_INTF_DEV) += rtc-dev.o rtc-core-$(CONFIG_RTC_INTF_PROC) += rtc-proc.o rtc-core-$(CONFIG_RTC_INTF_SYSFS) += rtc-sysfs.o -# Keep the list ordered. - -obj-$(CONFIG_RTC_DRV_AT32AP700X)+= rtc-at32ap700x.o -obj-$(CONFIG_RTC_DRV_AT91RM9200)+= rtc-at91rm9200.o -obj-$(CONFIG_RTC_DRV_BFIN) += rtc-bfin.o obj-$(CONFIG_RTC_DRV_CMOS) += rtc-cmos.o -obj-$(CONFIG_RTC_DRV_DS1216) += rtc-ds1216.o +obj-$(CONFIG_RTC_DRV_X1205) += rtc-x1205.o +obj-$(CONFIG_RTC_DRV_ISL1208) += rtc-isl1208.o +obj-$(CONFIG_RTC_DRV_TEST) += rtc-test.o +obj-$(CONFIG_RTC_DRV_AT32AP700X) += rtc-at32ap700x.o obj-$(CONFIG_RTC_DRV_DS1307) += rtc-ds1307.o -obj-$(CONFIG_RTC_DRV_DS1553) += rtc-ds1553.o obj-$(CONFIG_RTC_DRV_DS1672) += rtc-ds1672.o obj-$(CONFIG_RTC_DRV_DS1742) += rtc-ds1742.o -obj-$(CONFIG_RTC_DRV_EP93XX) += rtc-ep93xx.o -obj-$(CONFIG_RTC_DRV_ISL1208) += rtc-isl1208.o -obj-$(CONFIG_RTC_DRV_M41T80) += rtc-m41t80.o -obj-$(CONFIG_RTC_DRV_M48T59) += rtc-m48t59.o -obj-$(CONFIG_RTC_DRV_M48T86) += rtc-m48t86.o -obj-$(CONFIG_RTC_DRV_MAX6900) += rtc-max6900.o -obj-$(CONFIG_RTC_DRV_MAX6902) += rtc-max6902.o obj-$(CONFIG_RTC_DRV_OMAP) += rtc-omap.o obj-$(CONFIG_RTC_DRV_PCF8563) += rtc-pcf8563.o obj-$(CONFIG_RTC_DRV_PCF8583) += rtc-pcf8583.o -obj-$(CONFIG_RTC_DRV_PL031) += rtc-pl031.o -obj-$(CONFIG_RTC_DRV_RS5C313) += rtc-rs5c313.o -obj-$(CONFIG_RTC_DRV_RS5C348) += rtc-rs5c348.o obj-$(CONFIG_RTC_DRV_RS5C372) += rtc-rs5c372.o obj-$(CONFIG_RTC_DRV_S3C) += rtc-s3c.o -obj-$(CONFIG_RTC_DRV_SA1100) += rtc-sa1100.o -obj-$(CONFIG_RTC_DRV_SH) += rtc-sh.o +obj-$(CONFIG_RTC_DRV_RS5C348) += rtc-rs5c348.o +obj-$(CONFIG_RTC_DRV_M41T80) += rtc-m41t80.o +obj-$(CONFIG_RTC_DRV_M48T86) += rtc-m48t86.o +obj-$(CONFIG_RTC_DRV_DS1553) += rtc-ds1553.o obj-$(CONFIG_RTC_DRV_STK17TA8) += rtc-stk17ta8.o -obj-$(CONFIG_RTC_DRV_TEST) += rtc-test.o -obj-$(CONFIG_RTC_DRV_V3020) += rtc-v3020.o +obj-$(CONFIG_RTC_DRV_RS5C313) += rtc-rs5c313.o +obj-$(CONFIG_RTC_DRV_EP93XX) += rtc-ep93xx.o +obj-$(CONFIG_RTC_DRV_SA1100) += rtc-sa1100.o obj-$(CONFIG_RTC_DRV_VR41XX) += rtc-vr41xx.o -obj-$(CONFIG_RTC_DRV_X1205) += rtc-x1205.o +obj-$(CONFIG_RTC_DRV_PL031) += rtc-pl031.o +obj-$(CONFIG_RTC_DRV_MAX6900) += rtc-max6900.o +obj-$(CONFIG_RTC_DRV_MAX6902) += rtc-max6902.o +obj-$(CONFIG_RTC_DRV_V3020) += rtc-v3020.o +obj-$(CONFIG_RTC_DRV_AT91RM9200)+= rtc-at91rm9200.o +obj-$(CONFIG_RTC_DRV_SH) += rtc-sh.o +obj-$(CONFIG_RTC_DRV_BFIN) += rtc-bfin.o +obj-$(CONFIG_RTC_DRV_M48T59) += rtc-m48t59.o +obj-$(CONFIG_RTC_DRV_DS1216) += rtc-ds1216.o diff --git a/trunk/drivers/rtc/rtc-ds1307.c b/trunk/drivers/rtc/rtc-ds1307.c index db6f3f0d8982..5158a625671f 100644 --- a/trunk/drivers/rtc/rtc-ds1307.c +++ b/trunk/drivers/rtc/rtc-ds1307.c @@ -352,7 +352,7 @@ static int __devinit ds1307_probe(struct i2c_client *client) /* oscillator fault? clear flag, and warn */ if (ds1307->regs[DS1307_REG_CONTROL] & DS1338_BIT_OSF) { i2c_smbus_write_byte_data(client, DS1307_REG_CONTROL, - ds1307->regs[DS1307_REG_CONTROL] + ds1307->regs[DS1337_REG_CONTROL] & ~DS1338_BIT_OSF); dev_warn(&client->dev, "SET TIME!\n"); goto read_rtc; diff --git a/trunk/drivers/rtc/rtc-stk17ta8.c b/trunk/drivers/rtc/rtc-stk17ta8.c index 8288b6b2bf2b..f10d3facecbe 100644 --- a/trunk/drivers/rtc/rtc-stk17ta8.c +++ b/trunk/drivers/rtc/rtc-stk17ta8.c @@ -258,8 +258,7 @@ static const struct rtc_class_ops stk17ta8_rtc_ops = { .ioctl = stk17ta8_rtc_ioctl, }; -static ssize_t stk17ta8_nvram_read(struct kobject *kobj, - struct bin_attribute *attr, char *buf, +static ssize_t stk17ta8_nvram_read(struct kobject *kobj, char *buf, loff_t pos, size_t size) { struct platform_device *pdev = @@ -273,8 +272,7 @@ static ssize_t stk17ta8_nvram_read(struct kobject *kobj, return count; } -static ssize_t stk17ta8_nvram_write(struct kobject *kobj, - struct bin_attribute *attr, char *buf, +static ssize_t stk17ta8_nvram_write(struct kobject *kobj, char *buf, loff_t pos, size_t size) { struct platform_device *pdev = diff --git a/trunk/drivers/spi/spi_s3c24xx.c b/trunk/drivers/spi/spi_s3c24xx.c index 5cf48123e0ef..7071ff8da63e 100644 --- a/trunk/drivers/spi/spi_s3c24xx.c +++ b/trunk/drivers/spi/spi_s3c24xx.c @@ -28,7 +28,7 @@ #include #include -#include +#include #include struct s3c24xx_spi { diff --git a/trunk/drivers/video/chipsfb.c b/trunk/drivers/video/chipsfb.c index 6796ba62c3c6..f48e8c534c87 100644 --- a/trunk/drivers/video/chipsfb.c +++ b/trunk/drivers/video/chipsfb.c @@ -24,7 +24,6 @@ #include #include #include -#include #include #include #include @@ -459,7 +458,7 @@ static int chipsfb_pci_suspend(struct pci_dev *pdev, pm_message_t state) if (state.event == pdev->dev.power.power_state.event) return 0; - if (state.event != PM_EVENT_SUSPEND) + if (state.event != PM_SUSPEND_MEM) goto done; acquire_console_sem(); diff --git a/trunk/drivers/video/tgafb.c b/trunk/drivers/video/tgafb.c index d292a37ec7d6..89facb73edfc 100644 --- a/trunk/drivers/video/tgafb.c +++ b/trunk/drivers/video/tgafb.c @@ -849,7 +849,7 @@ tgafb_clut_imageblit(struct fb_info *info, const struct fb_image *image) u32 *palette = ((u32 *)info->pseudo_palette); unsigned long pos, line_length, i, j; const unsigned char *data; - void __iomem *regs_base, *fb_base; + void *regs_base, *fb_base; dx = image->dx; dy = image->dy; diff --git a/trunk/drivers/w1/masters/ds1wm.c b/trunk/drivers/w1/masters/ds1wm.c index 4b696641ce33..763bc73e5070 100644 --- a/trunk/drivers/w1/masters/ds1wm.c +++ b/trunk/drivers/w1/masters/ds1wm.c @@ -85,7 +85,7 @@ static struct { }; struct ds1wm_data { - void __iomem *map; + void *map; int bus_shift; /* # of shifts to calc register offsets */ struct platform_device *pdev; struct ds1wm_platform_data *pdata; diff --git a/trunk/drivers/xen/xenbus/xenbus_xs.c b/trunk/drivers/xen/xenbus/xenbus_xs.c index 227d53b12a5c..9e943fbce81b 100644 --- a/trunk/drivers/xen/xenbus/xenbus_xs.c +++ b/trunk/drivers/xen/xenbus/xenbus_xs.c @@ -782,8 +782,8 @@ static int process_msg(void) msg->u.watch.vec = split(body, msg->hdr.len, &msg->u.watch.vec_size); if (IS_ERR(msg->u.watch.vec)) { - err = PTR_ERR(msg->u.watch.vec); kfree(msg); + err = PTR_ERR(msg->u.watch.vec); goto out; } diff --git a/trunk/fs/ext2/super.c b/trunk/fs/ext2/super.c index 639a32c3c9c1..68579a0ed3f0 100644 --- a/trunk/fs/ext2/super.c +++ b/trunk/fs/ext2/super.c @@ -580,7 +580,7 @@ static int ext2_check_descriptors (struct super_block * sb) return 0; } if (le32_to_cpu(gdp->bg_inode_table) < first_block || - le32_to_cpu(gdp->bg_inode_table) + sbi->s_itb_per_group - 1 > + le32_to_cpu(gdp->bg_inode_table) + sbi->s_itb_per_group > last_block) { ext2_error (sb, "ext2_check_descriptors", diff --git a/trunk/fs/ext3/super.c b/trunk/fs/ext3/super.c index 22cfdd61c060..f0614e3f1fe8 100644 --- a/trunk/fs/ext3/super.c +++ b/trunk/fs/ext3/super.c @@ -1221,7 +1221,7 @@ static int ext3_check_descriptors (struct super_block * sb) return 0; } if (le32_to_cpu(gdp->bg_inode_table) < first_block || - le32_to_cpu(gdp->bg_inode_table) + sbi->s_itb_per_group - 1 > + le32_to_cpu(gdp->bg_inode_table) + sbi->s_itb_per_group > last_block) { ext3_error (sb, "ext3_check_descriptors", diff --git a/trunk/fs/ext4/super.c b/trunk/fs/ext4/super.c index 4550b83ab1c9..75adbb64e028 100644 --- a/trunk/fs/ext4/super.c +++ b/trunk/fs/ext4/super.c @@ -1283,7 +1283,7 @@ static int ext4_check_descriptors (struct super_block * sb) } inode_table = ext4_inode_table(sb, gdp); if (inode_table < first_block || - inode_table + sbi->s_itb_per_group - 1 > last_block) + inode_table + sbi->s_itb_per_group > last_block) { ext4_error (sb, "ext4_check_descriptors", "Inode table for group %d" diff --git a/trunk/fs/lockd/svclock.c b/trunk/fs/lockd/svclock.c index a21e4bc5444b..b3efa4536cc5 100644 --- a/trunk/fs/lockd/svclock.c +++ b/trunk/fs/lockd/svclock.c @@ -335,10 +335,10 @@ static void nlmsvc_freegrantargs(struct nlm_rqst *call) /* * Deferred lock request handling for non-blocking lock */ -static __be32 +static u32 nlmsvc_defer_lock_rqst(struct svc_rqst *rqstp, struct nlm_block *block) { - __be32 status = nlm_lck_denied_nolocks; + u32 status = nlm_lck_denied_nolocks; block->b_flags |= B_QUEUED; @@ -352,7 +352,7 @@ nlmsvc_defer_lock_rqst(struct svc_rqst *rqstp, struct nlm_block *block) status = nlm_drop_reply; } dprintk("lockd: nlmsvc_defer_lock_rqst block %p flags %d status %d\n", - block, block->b_flags, ntohl(status)); + block, block->b_flags, status); return status; } diff --git a/trunk/fs/nfsd/nfs4xdr.c b/trunk/fs/nfsd/nfs4xdr.c index 8ef0964179bc..b3d55c6747fd 100644 --- a/trunk/fs/nfsd/nfs4xdr.c +++ b/trunk/fs/nfsd/nfs4xdr.c @@ -2450,7 +2450,7 @@ nfsd4_encode_rename(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_ } static void -nfsd4_encode_secinfo(struct nfsd4_compoundres *resp, __be32 nfserr, +nfsd4_encode_secinfo(struct nfsd4_compoundres *resp, int nfserr, struct nfsd4_secinfo *secinfo) { int i = 0; diff --git a/trunk/fs/reiserfs/stree.c b/trunk/fs/reiserfs/stree.c index 981027d1187b..b6f12593c39d 100644 --- a/trunk/fs/reiserfs/stree.c +++ b/trunk/fs/reiserfs/stree.c @@ -1042,8 +1042,7 @@ static char prepare_for_delete_or_cut(struct reiserfs_transaction_handle *th, st pos = I_UNFM_NUM(&s_ih); while (le_ih_k_offset (&s_ih) + (pos - 1) * blk_size > n_new_file_length) { - __le32 *unfm; - __u32 block; + __u32 *unfm, block; /* Each unformatted block deletion may involve one additional * bitmap block into the transaction, thereby the initial @@ -1053,7 +1052,7 @@ static char prepare_for_delete_or_cut(struct reiserfs_transaction_handle *th, st break; } - unfm = (__le32 *)B_I_PITEM(p_s_bh, &s_ih) + pos - 1; + unfm = (__u32 *)B_I_PITEM(p_s_bh, &s_ih) + pos - 1; block = get_block_num(unfm, 0); if (block != 0) { diff --git a/trunk/fs/signalfd.c b/trunk/fs/signalfd.c index 7b941abbcde0..3b07f26d984d 100644 --- a/trunk/fs/signalfd.c +++ b/trunk/fs/signalfd.c @@ -320,7 +320,7 @@ asmlinkage long sys_signalfd(int ufd, sigset_t __user *user_mask, size_t sizemas if (sizemask != sizeof(sigset_t) || copy_from_user(&sigmask, user_mask, sizeof(sigmask))) - return -EINVAL; + return error = -EINVAL; sigdelsetmask(&sigmask, sigmask(SIGKILL) | sigmask(SIGSTOP)); signotset(&sigmask); diff --git a/trunk/fs/timerfd.c b/trunk/fs/timerfd.c index 61983f3b107c..af9eca5c0230 100644 --- a/trunk/fs/timerfd.c +++ b/trunk/fs/timerfd.c @@ -95,7 +95,7 @@ static ssize_t timerfd_read(struct file *file, char __user *buf, size_t count, { struct timerfd_ctx *ctx = file->private_data; ssize_t res; - u64 ticks = 0; + u32 ticks = 0; DECLARE_WAITQUEUE(wait, current); if (count < sizeof(ticks)) @@ -130,7 +130,7 @@ static ssize_t timerfd_read(struct file *file, char __user *buf, size_t count, * callback to avoid DoS attacks specifying a very * short timer period. */ - ticks = (u64) + ticks = (u32) hrtimer_forward(&ctx->tmr, hrtimer_cb_get_time(&ctx->tmr), ctx->tintv); @@ -140,7 +140,7 @@ static ssize_t timerfd_read(struct file *file, char __user *buf, size_t count, } spin_unlock_irq(&ctx->wqh.lock); if (ticks) - res = put_user(ticks, (u64 __user *) buf) ? -EFAULT: sizeof(ticks); + res = put_user(ticks, buf) ? -EFAULT: sizeof(ticks); return res; } diff --git a/trunk/fs/xfs/linux-2.6/xfs_ioctl32.c b/trunk/fs/xfs/linux-2.6/xfs_ioctl32.c index 42319d75aaab..141cf15067c2 100644 --- a/trunk/fs/xfs/linux-2.6/xfs_ioctl32.c +++ b/trunk/fs/xfs/linux-2.6/xfs_ioctl32.c @@ -139,7 +139,7 @@ STATIC int xfs_inumbers_fmt_compat( long count, long *written) { - compat_xfs_inogrp_t __user *p32 = ubuffer; + compat_xfs_inogrp_t *p32 = ubuffer; long i; for (i = 0; i < count; i++) { @@ -444,7 +444,7 @@ xfs_compat_ioctl( case XFS_IOC_FSINUMBERS_32: cmd = _NATIVE_IOC(cmd, struct xfs_fsop_bulkreq); return xfs_ioc_bulkstat_compat(XFS_BHVTOI(VNHEAD(vp))->i_mount, - cmd, (void __user*)arg); + cmd, (void*)arg); case XFS_IOC_FD_TO_HANDLE_32: case XFS_IOC_PATH_TO_HANDLE_32: case XFS_IOC_PATH_TO_FSHANDLE_32: diff --git a/trunk/include/asm-alpha/bitops.h b/trunk/include/asm-alpha/bitops.h index 9e71201000d5..3a0cbeb03fa1 100644 --- a/trunk/include/asm-alpha/bitops.h +++ b/trunk/include/asm-alpha/bitops.h @@ -324,7 +324,7 @@ static inline int fls64(unsigned long x) { unsigned long t, a, r; - t = __kernel_cmpbge (x, 0x0101010101010101UL); + t = __kernel_cmpbge (x, 0x0101010101010101); a = __flsm1_tab[t]; t = __kernel_extbl (x, a); r = a*8 + __flsm1_tab[t] + (x != 0); diff --git a/trunk/include/asm-arm/unaligned.h b/trunk/include/asm-arm/unaligned.h index 8431f6eed5c6..795b9e5b9e6a 100644 --- a/trunk/include/asm-arm/unaligned.h +++ b/trunk/include/asm-arm/unaligned.h @@ -60,24 +60,24 @@ extern int __bug_unaligned_x(const void *ptr); __get_unaligned_4_be((__p+4))) #define __get_unaligned_le(ptr) \ - ((__force typeof(*(ptr)))({ \ + ({ \ const __u8 *__p = (const __u8 *)(ptr); \ __builtin_choose_expr(sizeof(*(ptr)) == 1, *__p, \ __builtin_choose_expr(sizeof(*(ptr)) == 2, __get_unaligned_2_le(__p), \ __builtin_choose_expr(sizeof(*(ptr)) == 4, __get_unaligned_4_le(__p), \ __builtin_choose_expr(sizeof(*(ptr)) == 8, __get_unaligned_8_le(__p), \ (void)__bug_unaligned_x(__p))))); \ - })) + }) #define __get_unaligned_be(ptr) \ - ((__force typeof(*(ptr)))({ \ + ({ \ const __u8 *__p = (const __u8 *)(ptr); \ __builtin_choose_expr(sizeof(*(ptr)) == 1, *__p, \ __builtin_choose_expr(sizeof(*(ptr)) == 2, __get_unaligned_2_be(__p), \ __builtin_choose_expr(sizeof(*(ptr)) == 4, __get_unaligned_4_be(__p), \ __builtin_choose_expr(sizeof(*(ptr)) == 8, __get_unaligned_8_be(__p), \ (void)__bug_unaligned_x(__p))))); \ - })) + }) static inline void __put_unaligned_2_le(__u32 __v, register __u8 *__p) @@ -131,16 +131,15 @@ static inline void __put_unaligned_8_be(const unsigned long long __v, register _ */ #define __put_unaligned_le(val,ptr) \ ({ \ - (void)sizeof(*(ptr) = (val)); \ switch (sizeof(*(ptr))) { \ case 1: \ *(ptr) = (val); \ break; \ - case 2: __put_unaligned_2_le((__force u16)(val),(__u8 *)(ptr)); \ + case 2: __put_unaligned_2_le((val),(__u8 *)(ptr)); \ break; \ - case 4: __put_unaligned_4_le((__force u32)(val),(__u8 *)(ptr)); \ + case 4: __put_unaligned_4_le((val),(__u8 *)(ptr)); \ break; \ - case 8: __put_unaligned_8_le((__force u64)(val),(__u8 *)(ptr)); \ + case 8: __put_unaligned_8_le((val),(__u8 *)(ptr)); \ break; \ default: __bug_unaligned_x(ptr); \ break; \ @@ -150,16 +149,15 @@ static inline void __put_unaligned_8_be(const unsigned long long __v, register _ #define __put_unaligned_be(val,ptr) \ ({ \ - (void)sizeof(*(ptr) = (val)); \ switch (sizeof(*(ptr))) { \ case 1: \ *(ptr) = (val); \ break; \ - case 2: __put_unaligned_2_be((__force u16)(val),(__u8 *)(ptr)); \ + case 2: __put_unaligned_2_be((val),(__u8 *)(ptr)); \ break; \ - case 4: __put_unaligned_4_be((__force u32)(val),(__u8 *)(ptr)); \ + case 4: __put_unaligned_4_be((val),(__u8 *)(ptr)); \ break; \ - case 8: __put_unaligned_8_be((__force u64)(val),(__u8 *)(ptr)); \ + case 8: __put_unaligned_8_be((val),(__u8 *)(ptr)); \ break; \ default: __bug_unaligned_x(ptr); \ break; \ diff --git a/trunk/include/asm-m68k/raw_io.h b/trunk/include/asm-m68k/raw_io.h index d9eb9834ccc8..91c623f0994c 100644 --- a/trunk/include/asm-m68k/raw_io.h +++ b/trunk/include/asm-m68k/raw_io.h @@ -36,15 +36,15 @@ extern void __iounmap(void *addr, unsigned long size); #define in_be32(addr) \ ({ u32 __v = (*(__force volatile u32 *) (addr)); __v; }) #define in_le16(addr) \ - ({ u16 __v = le16_to_cpu(*(__force volatile __le16 *) (addr)); __v; }) + ({ u16 __v = le16_to_cpu(*(__force volatile u16 *) (addr)); __v; }) #define in_le32(addr) \ - ({ u32 __v = le32_to_cpu(*(__force volatile __le32 *) (addr)); __v; }) + ({ u32 __v = le32_to_cpu(*(__force volatile u32 *) (addr)); __v; }) #define out_8(addr,b) (void)((*(__force volatile u8 *) (addr)) = (b)) #define out_be16(addr,w) (void)((*(__force volatile u16 *) (addr)) = (w)) #define out_be32(addr,l) (void)((*(__force volatile u32 *) (addr)) = (l)) -#define out_le16(addr,w) (void)((*(__force volatile __le16 *) (addr)) = cpu_to_le16(w)) -#define out_le32(addr,l) (void)((*(__force volatile __le32 *) (addr)) = cpu_to_le32(l)) +#define out_le16(addr,w) (void)((*(__force volatile u16 *) (addr)) = cpu_to_le16(w)) +#define out_le32(addr,l) (void)((*(__force volatile u32 *) (addr)) = cpu_to_le32(l)) #define raw_inb in_8 #define raw_inw in_be16 diff --git a/trunk/include/asm-m68knommu/hardirq.h b/trunk/include/asm-m68knommu/hardirq.h index bfad28149a49..980075bab792 100644 --- a/trunk/include/asm-m68knommu/hardirq.h +++ b/trunk/include/asm-m68knommu/hardirq.h @@ -22,6 +22,4 @@ typedef struct { # error HARDIRQ_BITS is too low! #endif -void ack_bad_irq(unsigned int irq); - #endif /* __M68K_HARDIRQ_H */ diff --git a/trunk/include/asm-m68knommu/machdep.h b/trunk/include/asm-m68knommu/machdep.h index 2b75a300df4f..6ce28f8e0ead 100644 --- a/trunk/include/asm-m68knommu/machdep.h +++ b/trunk/include/asm-m68knommu/machdep.h @@ -48,5 +48,6 @@ extern char *mach_sysrq_xlate; extern void config_BSP(char *command, int len); extern void (*mach_tick)(void); +extern void (*mach_trap_init)(void); #endif /* _M68KNOMMU_MACHDEP_H */ diff --git a/trunk/include/asm-mips/edac.h b/trunk/include/asm-mips/edac.h deleted file mode 100644 index 83719eee2d13..000000000000 --- a/trunk/include/asm-mips/edac.h +++ /dev/null @@ -1,35 +0,0 @@ -#ifndef ASM_EDAC_H -#define ASM_EDAC_H - -/* ECC atomic, DMA, SMP and interrupt safe scrub function */ - -static inline void atomic_scrub(void *va, u32 size) -{ - unsigned long *virt_addr = va; - unsigned long temp; - u32 i; - - for (i = 0; i < size / sizeof(unsigned long); i++, virt_addr++) { - - /* - * Very carefully read and write to memory atomically - * so we are interrupt, DMA and SMP safe. - * - * Intel: asm("lock; addl $0, %0"::"m"(*virt_addr)); - */ - - __asm__ __volatile__ ( - " .set mips3 \n" - "1: ll %0, %1 # atomic_add \n" - " ll %0, %1 # atomic_add \n" - " addu %0, $0 \n" - " sc %0, %1 \n" - " beqz %0, 1b \n" - " .set mips0 \n" - : "=&r" (temp), "=m" (*virt_addr) - : "m" (*virt_addr)); - - } -} - -#endif diff --git a/trunk/include/asm-powerpc/bug.h b/trunk/include/asm-powerpc/bug.h index a248b8bd4d7c..f6fa39474846 100644 --- a/trunk/include/asm-powerpc/bug.h +++ b/trunk/include/asm-powerpc/bug.h @@ -79,7 +79,7 @@ _EMIT_BUG_ENTRY \ : : "i" (__FILE__), "i" (__LINE__), "i" (0), \ "i" (sizeof(struct bug_entry)), \ - "r" ((__force long)(x))); \ + "r" ((long)(x))); \ } \ } while (0) diff --git a/trunk/include/asm-powerpc/page.h b/trunk/include/asm-powerpc/page.h index 236a9210e5fc..10c51f457d48 100644 --- a/trunk/include/asm-powerpc/page.h +++ b/trunk/include/asm-powerpc/page.h @@ -190,6 +190,7 @@ extern void copy_user_page(void *to, void *from, unsigned long vaddr, extern int page_is_ram(unsigned long pfn); struct vm_area_struct; +extern const char *arch_vma_name(struct vm_area_struct *vma); #include #endif /* __ASSEMBLY__ */ diff --git a/trunk/include/asm-x86_64/uaccess.h b/trunk/include/asm-x86_64/uaccess.h index f4ce8768ad44..9df30b939c4e 100644 --- a/trunk/include/asm-x86_64/uaccess.h +++ b/trunk/include/asm-x86_64/uaccess.h @@ -100,7 +100,7 @@ struct exception_table_entry case 8: __get_user_x(8,__ret_gu,__val_gu,ptr); break; \ default: __get_user_bad(); break; \ } \ - (x) = (__force typeof(*(ptr)))__val_gu; \ + (x) = (typeof(*(ptr)))__val_gu; \ __ret_gu; \ }) @@ -192,7 +192,7 @@ struct __large_struct { unsigned long buf[100]; }; int __gu_err; \ unsigned long __gu_val; \ __get_user_size(__gu_val,(ptr),(size),__gu_err); \ - (x) = (__force typeof(*(ptr)))__gu_val; \ + (x) = (typeof(*(ptr)))__gu_val; \ __gu_err; \ }) diff --git a/trunk/include/linux/compiler.h b/trunk/include/linux/compiler.h index 86f9a3a6137d..12a1291855e2 100644 --- a/trunk/include/linux/compiler.h +++ b/trunk/include/linux/compiler.h @@ -15,8 +15,8 @@ # define __acquire(x) __context__(x,1) # define __release(x) __context__(x,-1) # define __cond_lock(x,c) ((c) ? ({ __acquire(x); 1; }) : 0) -extern void __chk_user_ptr(const volatile void __user *); -extern void __chk_io_ptr(const volatile void __iomem *); +extern void __chk_user_ptr(const void __user *); +extern void __chk_io_ptr(const void __iomem *); #else # define __user # define __kernel diff --git a/trunk/include/linux/device.h b/trunk/include/linux/device.h index 3a38d1f70cb7..d9f0a57f5a2f 100644 --- a/trunk/include/linux/device.h +++ b/trunk/include/linux/device.h @@ -551,9 +551,6 @@ extern void put_device(struct device * dev); /* drivers/base/power/shutdown.c */ extern void device_shutdown(void); -/* drivers/base/sys.c */ -extern void sysdev_shutdown(void); - /* drivers/base/firmware.c */ extern int __must_check firmware_register(struct kset *); diff --git a/trunk/include/linux/lguest.h b/trunk/include/linux/lguest.h index e76c151c7129..500aace21ca7 100644 --- a/trunk/include/linux/lguest.h +++ b/trunk/include/linux/lguest.h @@ -27,38 +27,18 @@ #define LG_CLOCK_MIN_DELTA 100UL #define LG_CLOCK_MAX_DELTA ULONG_MAX -/*G:031 First, how does our Guest contact the Host to ask for privileged - * operations? There are two ways: the direct way is to make a "hypercall", - * to make requests of the Host Itself. - * - * Our hypercall mechanism uses the highest unused trap code (traps 32 and - * above are used by real hardware interrupts). Seventeen hypercalls are - * available: the hypercall number is put in the %eax register, and the - * arguments (when required) are placed in %edx, %ebx and %ecx. If a return - * value makes sense, it's returned in %eax. - * - * Grossly invalid calls result in Sudden Death at the hands of the vengeful - * Host, rather than returning failure. This reflects Winston Churchill's - * definition of a gentleman: "someone who is only rude intentionally". */ #define LGUEST_TRAP_ENTRY 0x1F static inline unsigned long hcall(unsigned long call, unsigned long arg1, unsigned long arg2, unsigned long arg3) { - /* "int" is the Intel instruction to trigger a trap. */ asm volatile("int $" __stringify(LGUEST_TRAP_ENTRY) - /* The call is in %eax (aka "a"), and can be replaced */ : "=a"(call) - /* The other arguments are in %eax, %edx, %ebx & %ecx */ : "a"(call), "d"(arg1), "b"(arg2), "c"(arg3) - /* "memory" means this might write somewhere in memory. - * This isn't true for all calls, but it's safe to tell - * gcc that it might happen so it doesn't get clever. */ : "memory"); return call; } -/*:*/ void async_hcall(unsigned long call, unsigned long arg1, unsigned long arg2, unsigned long arg3); @@ -72,40 +52,31 @@ struct hcall_ring u32 eax, edx, ebx, ecx; }; -/*G:032 The second method of communicating with the Host is to via "struct - * lguest_data". The Guest's very first hypercall is to tell the Host where - * this is, and then the Guest and Host both publish information in it. :*/ +/* All the good stuff happens here: guest registers it with LGUEST_INIT */ struct lguest_data { - /* 512 == enabled (same as eflags in normal hardware). The Guest - * changes interrupts so often that a hypercall is too slow. */ +/* Fields which change during running: */ + /* 512 == enabled (same as eflags) */ unsigned int irq_enabled; - /* Fine-grained interrupt disabling by the Guest */ + /* Interrupts blocked by guest. */ DECLARE_BITMAP(blocked_interrupts, LGUEST_IRQS); - /* The Host writes the virtual address of the last page fault here, - * which saves the Guest a hypercall. CR2 is the native register where - * this address would normally be found. */ + /* Virtual address of page fault. */ unsigned long cr2; - /* Async hypercall ring. Instead of directly making hypercalls, we can - * place them in here for processing the next time the Host wants. - * This batching can be quite efficient. */ - - /* 0xFF == done (set by Host), 0 == pending (set by Guest). */ + /* Async hypercall ring. 0xFF == done, 0 == pending. */ u8 hcall_status[LHCALL_RING_SIZE]; - /* The actual registers for the hypercalls. */ struct hcall_ring hcalls[LHCALL_RING_SIZE]; -/* Fields initialized by the Host at boot: */ +/* Fields initialized by the hypervisor at boot: */ /* Memory not to try to access */ unsigned long reserve_mem; - /* ID of this Guest (used by network driver to set ethernet address) */ + /* ID of this guest (used by network driver to set ethernet address) */ u16 guestid; /* KHz for the TSC clock. */ u32 tsc_khz; -/* Fields initialized by the Guest at boot: */ +/* Fields initialized by the guest at boot: */ /* Instruction range to suppress interrupts even if enabled */ unsigned long noirq_start, noirq_end; }; diff --git a/trunk/include/linux/lguest_bus.h b/trunk/include/linux/lguest_bus.h index d27853ddc644..c9b4e05fee49 100644 --- a/trunk/include/linux/lguest_bus.h +++ b/trunk/include/linux/lguest_bus.h @@ -15,14 +15,11 @@ struct lguest_device { void *private; }; -/*D:380 Since interrupt numbers are arbitrary, we use a convention: each device - * can use the interrupt number corresponding to its index. The +1 is because - * interrupt 0 is not usable (it's actually the timer interrupt). */ +/* By convention, each device can use irq index+1 if it wants to. */ static inline int lgdev_irq(const struct lguest_device *dev) { return dev->index + 1; } -/*:*/ /* dma args must not be vmalloced! */ void lguest_send_dma(unsigned long key, struct lguest_dma *dma); diff --git a/trunk/include/linux/lguest_launcher.h b/trunk/include/linux/lguest_launcher.h index 641670579446..0ba414a40c80 100644 --- a/trunk/include/linux/lguest_launcher.h +++ b/trunk/include/linux/lguest_launcher.h @@ -9,45 +9,14 @@ /* How many devices? Assume each one wants up to two dma arrays per device. */ #define LGUEST_MAX_DEVICES (LGUEST_MAX_DMA/2) -/*D:200 - * Lguest I/O - * - * The lguest I/O mechanism is the only way Guests can talk to devices. There - * are two hypercalls involved: SEND_DMA for output and BIND_DMA for input. In - * each case, "struct lguest_dma" describes the buffer: this contains 16 - * addr/len pairs, and if there are fewer buffer elements the len array is - * terminated with a 0. - * - * I/O is organized by keys: BIND_DMA attaches buffers to a particular key, and - * SEND_DMA transfers to buffers bound to particular key. By convention, keys - * correspond to a physical address within the device's page. This means that - * devices will never accidentally end up with the same keys, and allows the - * Host use The Futex Trick (as we'll see later in our journey). - * - * SEND_DMA simply indicates a key to send to, and the physical address of the - * "struct lguest_dma" to send. The Host will write the number of bytes - * transferred into the "struct lguest_dma"'s used_len member. - * - * BIND_DMA indicates a key to bind to, a pointer to an array of "struct - * lguest_dma"s ready for receiving, the size of that array, and an interrupt - * to trigger when data is received. The Host will only allow transfers into - * buffers with a used_len of zero: it then sets used_len to the number of - * bytes transferred and triggers the interrupt for the Guest to process the - * new input. */ struct lguest_dma { - /* 0 if free to be used, filled by the Host. */ + /* 0 if free to be used, filled by hypervisor. */ u32 used_len; unsigned long addr[LGUEST_MAX_DMA_SECTIONS]; u16 len[LGUEST_MAX_DMA_SECTIONS]; }; -/*:*/ -/*D:460 This is the layout of a block device memory page. The Launcher sets up - * the num_sectors initially to tell the Guest the size of the disk. The Guest - * puts the type, sector and length of the request in the first three fields, - * then DMAs to the Host. The Host processes the request, sets up the result, - * then DMAs back to the Guest. */ struct lguest_block_page { /* 0 is a read, 1 is a write. */ @@ -59,47 +28,27 @@ struct lguest_block_page u32 num_sectors; /* Disk length = num_sectors * 512 */ }; -/*D:520 The network device is basically a memory page where all the Guests on - * the network publish their MAC (ethernet) addresses: it's an array of "struct - * lguest_net": */ +/* There is a shared page of these. */ struct lguest_net { /* Simply the mac address (with multicast bit meaning promisc). */ unsigned char mac[6]; }; -/*:*/ /* Where the Host expects the Guest to SEND_DMA console output to. */ #define LGUEST_CONSOLE_DMA_KEY 0 -/*D:010 - * Drivers - * - * The Guest needs devices to do anything useful. Since we don't let it touch - * real devices (think of the damage it could do!) we provide virtual devices. - * We could emulate a PCI bus with various devices on it, but that is a fairly - * complex burden for the Host and suboptimal for the Guest, so we have our own - * "lguest" bus and simple drivers. - * - * Devices are described by an array of LGUEST_MAX_DEVICES of these structs, - * placed by the Launcher just above the top of physical memory: - */ +/* We have a page of these descriptors in the lguest_device page. */ struct lguest_device_desc { - /* The device type: console, network, disk etc. */ u16 type; #define LGUEST_DEVICE_T_CONSOLE 1 #define LGUEST_DEVICE_T_NET 2 #define LGUEST_DEVICE_T_BLOCK 3 - /* The specific features of this device: these depends on device type - * except for LGUEST_DEVICE_F_RANDOMNESS. */ u16 features; #define LGUEST_NET_F_NOCSUM 0x4000 /* Don't bother checksumming */ #define LGUEST_DEVICE_F_RANDOMNESS 0x8000 /* IRQ is fairly random */ - /* This is how the Guest reports status of the device: the Host can set - * LGUEST_DEVICE_S_REMOVED to indicate removal, but the rest are only - * ever manipulated by the Guest, and only ever set. */ u16 status; /* 256 and above are device specific. */ #define LGUEST_DEVICE_S_ACKNOWLEDGE 1 /* We have seen device. */ @@ -109,12 +58,9 @@ struct lguest_device_desc { #define LGUEST_DEVICE_S_REMOVED_ACK 16 /* Driver has been told. */ #define LGUEST_DEVICE_S_FAILED 128 /* Something actually failed */ - /* Each device exists somewhere in Guest physical memory, over some - * number of pages. */ u16 num_pages; u32 pfn; }; -/*:*/ /* Write command first word is a request. */ enum lguest_req diff --git a/trunk/include/linux/mm.h b/trunk/include/linux/mm.h index 3e9e8fec5a41..c456c3a1c28e 100644 --- a/trunk/include/linux/mm.h +++ b/trunk/include/linux/mm.h @@ -1246,7 +1246,7 @@ void drop_slab(void); extern int randomize_va_space; #endif -const char * arch_vma_name(struct vm_area_struct *vma); +__attribute__((weak)) const char *arch_vma_name(struct vm_area_struct *vma); #endif /* __KERNEL__ */ #endif /* _LINUX_MM_H */ diff --git a/trunk/include/linux/netfilter/xt_connlimit.h b/trunk/include/linux/netfilter/xt_connlimit.h index 37e933c9987d..90ae8b474cb8 100644 --- a/trunk/include/linux/netfilter/xt_connlimit.h +++ b/trunk/include/linux/netfilter/xt_connlimit.h @@ -5,8 +5,8 @@ struct xt_connlimit_data; struct xt_connlimit_info { union { - __be32 v4_mask; - __be32 v6_mask[4]; + u_int32_t v4_mask; + u_int32_t v6_mask[4]; }; unsigned int limit, inverse; diff --git a/trunk/include/linux/pnp.h b/trunk/include/linux/pnp.h index 16b46aace349..66edb2293184 100644 --- a/trunk/include/linux/pnp.h +++ b/trunk/include/linux/pnp.h @@ -1,6 +1,7 @@ /* * Linux Plug and Play Support * Copyright by Adam Belay + * */ #ifndef _LINUX_PNP_H @@ -22,6 +23,7 @@ struct pnp_protocol; struct pnp_dev; + /* * Resource Management */ @@ -71,37 +73,37 @@ struct pnp_dev; #define PNP_PORT_FLAG_FIXED (1<<1) struct pnp_port { - unsigned short min; /* min base number */ - unsigned short max; /* max base number */ - unsigned char align; /* align boundary */ - unsigned char size; /* size of range */ - unsigned char flags; /* port flags */ - unsigned char pad; /* pad */ - struct pnp_port *next; /* next port */ + unsigned short min; /* min base number */ + unsigned short max; /* max base number */ + unsigned char align; /* align boundary */ + unsigned char size; /* size of range */ + unsigned char flags; /* port flags */ + unsigned char pad; /* pad */ + struct pnp_port *next; /* next port */ }; #define PNP_IRQ_NR 256 struct pnp_irq { - DECLARE_BITMAP(map, PNP_IRQ_NR); /* bitmask for IRQ lines */ - unsigned char flags; /* IRQ flags */ - unsigned char pad; /* pad */ - struct pnp_irq *next; /* next IRQ */ + DECLARE_BITMAP(map, PNP_IRQ_NR); /* bitmaks for IRQ lines */ + unsigned char flags; /* IRQ flags */ + unsigned char pad; /* pad */ + struct pnp_irq *next; /* next IRQ */ }; struct pnp_dma { - unsigned char map; /* bitmask for DMA channels */ - unsigned char flags; /* DMA flags */ - struct pnp_dma *next; /* next port */ + unsigned char map; /* bitmask for DMA channels */ + unsigned char flags; /* DMA flags */ + struct pnp_dma *next; /* next port */ }; struct pnp_mem { - unsigned int min; /* min base number */ - unsigned int max; /* max base number */ - unsigned int align; /* align boundary */ - unsigned int size; /* size of range */ - unsigned char flags; /* memory flags */ - unsigned char pad; /* pad */ - struct pnp_mem *next; /* next memory resource */ + unsigned int min; /* min base number */ + unsigned int max; /* max base number */ + unsigned int align; /* align boundary */ + unsigned int size; /* size of range */ + unsigned char flags; /* memory flags */ + unsigned char pad; /* pad */ + struct pnp_mem *next; /* next memory resource */ }; #define PNP_RES_PRIORITY_PREFERRED 0 @@ -125,6 +127,7 @@ struct pnp_resource_table { struct resource irq_resource[PNP_MAX_IRQ]; }; + /* * Device Managemnt */ @@ -136,14 +139,14 @@ struct pnp_card { struct list_head protocol_list; /* node in protocol's list of cards */ struct list_head devices; /* devices attached to the card */ - struct pnp_protocol *protocol; - struct pnp_id *id; /* contains supported EISA IDs */ + struct pnp_protocol * protocol; + struct pnp_id * id; /* contains supported EISA IDs*/ char name[PNP_NAME_LEN]; /* contains a human-readable name */ - unsigned char pnpver; /* Plug & Play version */ - unsigned char productver; /* product version */ - unsigned int serial; /* serial number */ - unsigned char checksum; /* if zero - checksum passed */ + unsigned char pnpver; /* Plug & Play version */ + unsigned char productver; /* product version */ + unsigned int serial; /* serial number */ + unsigned char checksum; /* if zero - checksum passed */ struct proc_dir_entry *procdir; /* directory entry in /proc/bus/isapnp */ }; @@ -156,18 +159,18 @@ struct pnp_card { (card) = global_to_pnp_card((card)->global_list.next)) struct pnp_card_link { - struct pnp_card *card; - struct pnp_card_driver *driver; - void *driver_data; + struct pnp_card * card; + struct pnp_card_driver * driver; + void * driver_data; pm_message_t pm_state; }; -static inline void *pnp_get_card_drvdata(struct pnp_card_link *pcard) +static inline void *pnp_get_card_drvdata (struct pnp_card_link *pcard) { return pcard->driver_data; } -static inline void pnp_set_card_drvdata(struct pnp_card_link *pcard, void *data) +static inline void pnp_set_card_drvdata (struct pnp_card_link *pcard, void *data) { pcard->driver_data = data; } @@ -183,22 +186,22 @@ struct pnp_dev { struct list_head card_list; /* node in card's list of devices */ struct list_head rdev_list; /* node in cards list of requested devices */ - struct pnp_protocol *protocol; - struct pnp_card *card; /* card the device is attached to, none if NULL */ - struct pnp_driver *driver; - struct pnp_card_link *card_link; + struct pnp_protocol * protocol; + struct pnp_card * card; /* card the device is attached to, none if NULL */ + struct pnp_driver * driver; + struct pnp_card_link * card_link; - struct pnp_id *id; /* supported EISA IDs */ + struct pnp_id * id; /* supported EISA IDs*/ int active; int capabilities; - struct pnp_option *independent; - struct pnp_option *dependent; + struct pnp_option * independent; + struct pnp_option * dependent; struct pnp_resource_table res; char name[PNP_NAME_LEN]; /* contains a human-readable name */ - unsigned short regs; /* ISAPnP: supported registers */ - int flags; /* used by protocols */ + unsigned short regs; /* ISAPnP: supported registers */ + int flags; /* used by protocols */ struct proc_dir_entry *procent; /* device entry in /proc/bus/isapnp */ void *data; }; @@ -217,19 +220,19 @@ struct pnp_dev { (dev) = card_to_pnp_dev((dev)->card_list.next)) #define pnp_dev_name(dev) (dev)->name -static inline void *pnp_get_drvdata(struct pnp_dev *pdev) +static inline void *pnp_get_drvdata (struct pnp_dev *pdev) { return dev_get_drvdata(&pdev->dev); } -static inline void pnp_set_drvdata(struct pnp_dev *pdev, void *data) +static inline void pnp_set_drvdata (struct pnp_dev *pdev, void *data) { dev_set_drvdata(&pdev->dev, data); } struct pnp_fixup { char id[7]; - void (*quirk_function) (struct pnp_dev * dev); /* fixup function */ + void (*quirk_function)(struct pnp_dev *dev); /* fixup function */ }; /* config parameters */ @@ -266,6 +269,7 @@ extern struct pnp_protocol pnpbios_protocol; #define pnp_device_is_pnpbios(dev) 0 #endif + /* status */ #define PNP_READY 0x0000 #define PNP_ATTACHED 0x0001 @@ -283,17 +287,17 @@ extern struct pnp_protocol pnpbios_protocol; struct pnp_id { char id[PNP_ID_LEN]; - struct pnp_id *next; + struct pnp_id * next; }; struct pnp_driver { - char *name; + char * name; const struct pnp_device_id *id_table; unsigned int flags; - int (*probe) (struct pnp_dev *dev, const struct pnp_device_id *dev_id); + int (*probe) (struct pnp_dev *dev, const struct pnp_device_id *dev_id); void (*remove) (struct pnp_dev *dev); - int (*suspend) (struct pnp_dev *dev, pm_message_t state); - int (*resume) (struct pnp_dev *dev); + int (*suspend) (struct pnp_dev *dev, pm_message_t state); + int (*resume) (struct pnp_dev *dev); struct device_driver driver; }; @@ -301,14 +305,13 @@ struct pnp_driver { struct pnp_card_driver { struct list_head global_list; - char *name; + char * name; const struct pnp_card_device_id *id_table; unsigned int flags; - int (*probe) (struct pnp_card_link *card, - const struct pnp_card_device_id *card_id); + int (*probe) (struct pnp_card_link *card, const struct pnp_card_device_id *card_id); void (*remove) (struct pnp_card_link *card); - int (*suspend) (struct pnp_card_link *card, pm_message_t state); - int (*resume) (struct pnp_card_link *card); + int (*suspend) (struct pnp_card_link *card, pm_message_t state); + int (*resume) (struct pnp_card_link *card); struct pnp_driver link; }; @@ -318,28 +321,29 @@ struct pnp_card_driver { #define PNP_DRIVER_RES_DO_NOT_CHANGE 0x0001 /* do not change the state of the device */ #define PNP_DRIVER_RES_DISABLE 0x0003 /* ensure the device is disabled */ + /* * Protocol Management */ struct pnp_protocol { - struct list_head protocol_list; - char *name; + struct list_head protocol_list; + char * name; /* resource control functions */ - int (*get) (struct pnp_dev *dev, struct pnp_resource_table *res); - int (*set) (struct pnp_dev *dev, struct pnp_resource_table *res); - int (*disable) (struct pnp_dev *dev); + int (*get)(struct pnp_dev *dev, struct pnp_resource_table *res); + int (*set)(struct pnp_dev *dev, struct pnp_resource_table *res); + int (*disable)(struct pnp_dev *dev); /* protocol specific suspend/resume */ - int (*suspend) (struct pnp_dev * dev, pm_message_t state); - int (*resume) (struct pnp_dev * dev); + int (*suspend)(struct pnp_dev *dev, pm_message_t state); + int (*resume)(struct pnp_dev *dev); /* used by pnp layer only (look but don't touch) */ - unsigned char number; /* protocol number */ - struct device dev; /* link to driver model */ - struct list_head cards; - struct list_head devices; + unsigned char number; /* protocol number*/ + struct device dev; /* link to driver model */ + struct list_head cards; + struct list_head devices; }; #define to_pnp_protocol(n) list_entry(n, struct pnp_protocol, protocol_list) @@ -352,6 +356,7 @@ struct pnp_protocol { (dev) != protocol_to_pnp_dev(&(protocol)->devices); \ (dev) = protocol_to_pnp_dev((dev)->protocol_list.next)) + extern struct bus_type pnp_bus_type; #if defined(CONFIG_PNP) @@ -371,25 +376,21 @@ void pnp_remove_card(struct pnp_card *card); int pnp_add_card_device(struct pnp_card *card, struct pnp_dev *dev); void pnp_remove_card_device(struct pnp_dev *dev); int pnp_add_card_id(struct pnp_id *id, struct pnp_card *card); -struct pnp_dev *pnp_request_card_device(struct pnp_card_link *clink, - const char *id, struct pnp_dev *from); -void pnp_release_card_device(struct pnp_dev *dev); -int pnp_register_card_driver(struct pnp_card_driver *drv); -void pnp_unregister_card_driver(struct pnp_card_driver *drv); +struct pnp_dev * pnp_request_card_device(struct pnp_card_link *clink, const char * id, struct pnp_dev * from); +void pnp_release_card_device(struct pnp_dev * dev); +int pnp_register_card_driver(struct pnp_card_driver * drv); +void pnp_unregister_card_driver(struct pnp_card_driver * drv); extern struct list_head pnp_cards; /* resource management */ -struct pnp_option *pnp_register_independent_option(struct pnp_dev *dev); -struct pnp_option *pnp_register_dependent_option(struct pnp_dev *dev, - int priority); +struct pnp_option * pnp_register_independent_option(struct pnp_dev *dev); +struct pnp_option * pnp_register_dependent_option(struct pnp_dev *dev, int priority); int pnp_register_irq_resource(struct pnp_option *option, struct pnp_irq *data); int pnp_register_dma_resource(struct pnp_option *option, struct pnp_dma *data); -int pnp_register_port_resource(struct pnp_option *option, - struct pnp_port *data); +int pnp_register_port_resource(struct pnp_option *option, struct pnp_port *data); int pnp_register_mem_resource(struct pnp_option *option, struct pnp_mem *data); void pnp_init_resource_table(struct pnp_resource_table *table); -int pnp_manual_config_dev(struct pnp_dev *dev, struct pnp_resource_table *res, - int mode); +int pnp_manual_config_dev(struct pnp_dev *dev, struct pnp_resource_table *res, int mode); int pnp_auto_config_dev(struct pnp_dev *dev); int pnp_validate_config(struct pnp_dev *dev); int pnp_start_dev(struct pnp_dev *dev); @@ -397,11 +398,11 @@ int pnp_stop_dev(struct pnp_dev *dev); int pnp_activate_dev(struct pnp_dev *dev); int pnp_disable_dev(struct pnp_dev *dev); void pnp_resource_change(struct resource *resource, resource_size_t start, - resource_size_t size); + resource_size_t size); /* protocol helpers */ -int pnp_is_active(struct pnp_dev *dev); -int compare_pnp_id(struct pnp_id *pos, const char *id); +int pnp_is_active(struct pnp_dev * dev); +int compare_pnp_id(struct pnp_id * pos, const char * id); int pnp_add_id(struct pnp_id *id, struct pnp_dev *dev); int pnp_register_driver(struct pnp_driver *drv); void pnp_unregister_driver(struct pnp_driver *drv); @@ -414,24 +415,23 @@ static inline void pnp_unregister_protocol(struct pnp_protocol *protocol) { } static inline int pnp_init_device(struct pnp_dev *dev) { return -ENODEV; } static inline int pnp_add_device(struct pnp_dev *dev) { return -ENODEV; } static inline int pnp_device_attach(struct pnp_dev *pnp_dev) { return -ENODEV; } -static inline void pnp_device_detach(struct pnp_dev *pnp_dev) { } - +static inline void pnp_device_detach(struct pnp_dev *pnp_dev) { ; } #define pnp_platform_devices 0 /* multidevice card support */ static inline int pnp_add_card(struct pnp_card *card) { return -ENODEV; } -static inline void pnp_remove_card(struct pnp_card *card) { } +static inline void pnp_remove_card(struct pnp_card *card) { ; } static inline int pnp_add_card_device(struct pnp_card *card, struct pnp_dev *dev) { return -ENODEV; } -static inline void pnp_remove_card_device(struct pnp_dev *dev) { } +static inline void pnp_remove_card_device(struct pnp_dev *dev) { ; } static inline int pnp_add_card_id(struct pnp_id *id, struct pnp_card *card) { return -ENODEV; } -static inline struct pnp_dev *pnp_request_card_device(struct pnp_card_link *clink, const char *id, struct pnp_dev *from) { return NULL; } -static inline void pnp_release_card_device(struct pnp_dev *dev) { } -static inline int pnp_register_card_driver(struct pnp_card_driver *drv) { return -ENODEV; } -static inline void pnp_unregister_card_driver(struct pnp_card_driver *drv) { } +static inline struct pnp_dev * pnp_request_card_device(struct pnp_card_link *clink, const char * id, struct pnp_dev * from) { return NULL; } +static inline void pnp_release_card_device(struct pnp_dev * dev) { ; } +static inline int pnp_register_card_driver(struct pnp_card_driver * drv) { return -ENODEV; } +static inline void pnp_unregister_card_driver(struct pnp_card_driver * drv) { ; } /* resource management */ -static inline struct pnp_option *pnp_register_independent_option(struct pnp_dev *dev) { return NULL; } -static inline struct pnp_option *pnp_register_dependent_option(struct pnp_dev *dev, int priority) { return NULL; } +static inline struct pnp_option * pnp_register_independent_option(struct pnp_dev *dev) { return NULL; } +static inline struct pnp_option * pnp_register_dependent_option(struct pnp_dev *dev, int priority) { return NULL; } static inline int pnp_register_irq_resource(struct pnp_option *option, struct pnp_irq *data) { return -ENODEV; } static inline int pnp_register_dma_resource(struct pnp_option *option, struct pnp_dma *data) { return -ENODEV; } static inline int pnp_register_port_resource(struct pnp_option *option, struct pnp_port *data) { return -ENODEV; } @@ -444,17 +444,20 @@ static inline int pnp_start_dev(struct pnp_dev *dev) { return -ENODEV; } static inline int pnp_stop_dev(struct pnp_dev *dev) { return -ENODEV; } static inline int pnp_activate_dev(struct pnp_dev *dev) { return -ENODEV; } static inline int pnp_disable_dev(struct pnp_dev *dev) { return -ENODEV; } -static inline void pnp_resource_change(struct resource *resource, resource_size_t start, resource_size_t size) { } +static inline void pnp_resource_change(struct resource *resource, + resource_size_t start, + resource_size_t size) { } /* protocol helpers */ -static inline int pnp_is_active(struct pnp_dev *dev) { return 0; } -static inline int compare_pnp_id(struct pnp_id *pos, const char *id) { return -ENODEV; } +static inline int pnp_is_active(struct pnp_dev * dev) { return 0; } +static inline int compare_pnp_id(struct pnp_id * pos, const char * id) { return -ENODEV; } static inline int pnp_add_id(struct pnp_id *id, struct pnp_dev *dev) { return -ENODEV; } static inline int pnp_register_driver(struct pnp_driver *drv) { return -ENODEV; } -static inline void pnp_unregister_driver(struct pnp_driver *drv) { } +static inline void pnp_unregister_driver(struct pnp_driver *drv) { ; } #endif /* CONFIG_PNP */ + #define pnp_err(format, arg...) printk(KERN_ERR "pnp: " format "\n" , ## arg) #define pnp_info(format, arg...) printk(KERN_INFO "pnp: " format "\n" , ## arg) #define pnp_warn(format, arg...) printk(KERN_WARNING "pnp: " format "\n" , ## arg) diff --git a/trunk/include/linux/pnpbios.h b/trunk/include/linux/pnpbios.h index 329192adc9dd..0a282ac1f6b2 100644 --- a/trunk/include/linux/pnpbios.h +++ b/trunk/include/linux/pnpbios.h @@ -99,32 +99,32 @@ #pragma pack(1) struct pnp_dev_node_info { - __u16 no_nodes; - __u16 max_node_size; + __u16 no_nodes; + __u16 max_node_size; }; struct pnp_docking_station_info { - __u32 location_id; - __u32 serial; - __u16 capabilities; + __u32 location_id; + __u32 serial; + __u16 capabilities; }; struct pnp_isa_config_struc { - __u8 revision; - __u8 no_csns; - __u16 isa_rd_data_port; - __u16 reserved; + __u8 revision; + __u8 no_csns; + __u16 isa_rd_data_port; + __u16 reserved; }; struct escd_info_struc { - __u16 min_escd_write_size; - __u16 escd_size; - __u32 nv_storage_base; + __u16 min_escd_write_size; + __u16 escd_size; + __u32 nv_storage_base; }; struct pnp_bios_node { - __u16 size; - __u8 handle; - __u32 eisa_id; - __u8 type_code[3]; - __u16 flags; - __u8 data[0]; + __u16 size; + __u8 handle; + __u32 eisa_id; + __u8 type_code[3]; + __u16 flags; + __u8 data[0]; }; #pragma pack() @@ -133,16 +133,22 @@ struct pnp_bios_node { /* non-exported */ extern struct pnp_dev_node_info node_info; -extern int pnp_bios_dev_node_info(struct pnp_dev_node_info *data); -extern int pnp_bios_get_dev_node(u8 *nodenum, char config, - struct pnp_bios_node *data); -extern int pnp_bios_set_dev_node(u8 nodenum, char config, - struct pnp_bios_node *data); -extern int pnp_bios_get_stat_res(char *info); -extern int pnp_bios_isapnp_config(struct pnp_isa_config_struc *data); -extern int pnp_bios_escd_info(struct escd_info_struc *data); -extern int pnp_bios_read_escd(char *data, u32 nvram_base); +extern int pnp_bios_dev_node_info (struct pnp_dev_node_info *data); +extern int pnp_bios_get_dev_node (u8 *nodenum, char config, struct pnp_bios_node *data); +extern int pnp_bios_set_dev_node (u8 nodenum, char config, struct pnp_bios_node *data); +extern int pnp_bios_get_stat_res (char *info); +extern int pnp_bios_isapnp_config (struct pnp_isa_config_struc *data); +extern int pnp_bios_escd_info (struct escd_info_struc *data); +extern int pnp_bios_read_escd (char *data, u32 nvram_base); extern int pnp_bios_dock_station_info(struct pnp_docking_station_info *data); +#define needed 0 +#if needed +extern int pnp_bios_get_event (u16 *message); +extern int pnp_bios_send_message (u16 message); +extern int pnp_bios_set_stat_res (char *info); +extern int pnp_bios_apm_id_table (char *table, u16 *size); +extern int pnp_bios_write_escd (char *data, u32 nvram_base); +#endif #endif /* CONFIG_PNPBIOS */ diff --git a/trunk/include/linux/sched.h b/trunk/include/linux/sched.h index 33b9b4841ee7..7c61b50823fa 100644 --- a/trunk/include/linux/sched.h +++ b/trunk/include/linux/sched.h @@ -681,7 +681,7 @@ enum cpu_idle_type { #define SCHED_LOAD_SHIFT 10 #define SCHED_LOAD_SCALE (1L << SCHED_LOAD_SHIFT) -#define SCHED_LOAD_SCALE_FUZZ (SCHED_LOAD_SCALE >> 5) +#define SCHED_LOAD_SCALE_FUZZ (SCHED_LOAD_SCALE >> 1) #ifdef CONFIG_SMP #define SD_LOAD_BALANCE 1 /* Do load balancing on this domain. */ diff --git a/trunk/include/linux/suspend.h b/trunk/include/linux/suspend.h index 618f93c32b7f..e8e6da394c92 100644 --- a/trunk/include/linux/suspend.h +++ b/trunk/include/linux/suspend.h @@ -125,9 +125,6 @@ static inline int unregister_pm_notifier(struct notifier_block *nb) static inline void register_nosave_region(unsigned long b, unsigned long e) { } -static inline void register_nosave_region_late(unsigned long b, unsigned long e) -{ -} #endif #endif /* _LINUX_SWSUSP_H */ diff --git a/trunk/include/net/netfilter/nf_conntrack_tuple.h b/trunk/include/net/netfilter/nf_conntrack_tuple.h index c48e390f4b0f..040dae5f0c9e 100644 --- a/trunk/include/net/netfilter/nf_conntrack_tuple.h +++ b/trunk/include/net/netfilter/nf_conntrack_tuple.h @@ -35,7 +35,7 @@ union nf_conntrack_address { union nf_conntrack_man_proto { /* Add other protocols here. */ - __be16 all; + u_int16_t all; struct { __be16 port; @@ -73,7 +73,7 @@ struct nf_conntrack_tuple union nf_conntrack_address u3; union { /* Add other protocols here. */ - __be16 all; + u_int16_t all; struct { __be16 port; diff --git a/trunk/include/xen/page.h b/trunk/include/xen/page.h index c0c8fcb27899..1df6c1930578 100644 --- a/trunk/include/xen/page.h +++ b/trunk/include/xen/page.h @@ -4,7 +4,6 @@ #include #include -#include #include diff --git a/trunk/init/initramfs.c b/trunk/init/initramfs.c index 1db02a0025db..00eff7a11085 100644 --- a/trunk/init/initramfs.c +++ b/trunk/init/initramfs.c @@ -133,7 +133,7 @@ static __initdata loff_t this_header, next_header; static __initdata int dry_run; -static inline void __init eat(unsigned n) +static inline void eat(unsigned n) { victim += n; this_header += n; diff --git a/trunk/kernel/kmod.c b/trunk/kernel/kmod.c index 9809cc1f33d6..beedbdc64608 100644 --- a/trunk/kernel/kmod.c +++ b/trunk/kernel/kmod.c @@ -351,11 +351,11 @@ static inline void register_pm_notifier_callback(void) {} /** * call_usermodehelper_setup - prepare to call a usermode helper - * @path: path to usermode executable - * @argv: arg vector for process - * @envp: environment for process + * @path - path to usermode executable + * @argv - arg vector for process + * @envp - environment for process * - * Returns either %NULL on allocation failure, or a subprocess_info + * Returns either NULL on allocation failure, or a subprocess_info * structure. This should be passed to call_usermodehelper_exec to * exec the process and free the structure. */ diff --git a/trunk/kernel/power/disk.c b/trunk/kernel/power/disk.c index eb72255b5c86..324ac0188ce1 100644 --- a/trunk/kernel/power/disk.c +++ b/trunk/kernel/power/disk.c @@ -216,7 +216,6 @@ int hibernation_platform_enter(void) * sleep state after all */ error = hibernation_ops->prepare(); - sysdev_shutdown(); if (!error) error = hibernation_ops->enter(); } else { diff --git a/trunk/kernel/sys.c b/trunk/kernel/sys.c index 14f8adcfffd9..08562f419768 100644 --- a/trunk/kernel/sys.c +++ b/trunk/kernel/sys.c @@ -804,7 +804,6 @@ static void kernel_restart_prepare(char *cmd) blocking_notifier_call_chain(&reboot_notifier_list, SYS_RESTART, cmd); system_state = SYSTEM_RESTART; device_shutdown(); - sysdev_shutdown(); } /** @@ -861,7 +860,6 @@ void kernel_shutdown_prepare(enum system_states state) void kernel_halt(void) { kernel_shutdown_prepare(SYSTEM_HALT); - sysdev_shutdown(); printk(KERN_EMERG "System halted.\n"); machine_halt(); } @@ -878,7 +876,6 @@ void kernel_power_off(void) kernel_shutdown_prepare(SYSTEM_POWER_OFF); if (pm_power_off_prepare) pm_power_off_prepare(); - sysdev_shutdown(); printk(KERN_EMERG "Power down.\n"); machine_power_off(); } diff --git a/trunk/mm/migrate.c b/trunk/mm/migrate.c index 37c73b902008..34d8ada053e4 100644 --- a/trunk/mm/migrate.c +++ b/trunk/mm/migrate.c @@ -49,8 +49,9 @@ int isolate_lru_page(struct page *page, struct list_head *pagelist) struct zone *zone = page_zone(page); spin_lock_irq(&zone->lru_lock); - if (PageLRU(page) && get_page_unless_zero(page)) { + if (PageLRU(page)) { ret = 0; + get_page(page); ClearPageLRU(page); if (PageActive(page)) del_page_from_active_list(zone, page); @@ -631,35 +632,18 @@ static int unmap_and_move(new_page_t get_new_page, unsigned long private, goto unlock; wait_on_page_writeback(page); } + /* - * By try_to_unmap(), page->mapcount goes down to 0 here. In this case, - * we cannot notice that anon_vma is freed while we migrates a page. - * This rcu_read_lock() delays freeing anon_vma pointer until the end - * of migration. File cache pages are no problem because of page_lock() - */ - rcu_read_lock(); - /* - * This is a corner case handling. - * When a new swap-cache is read into, it is linked to LRU - * and treated as swapcache but has no rmap yet. - * Calling try_to_unmap() against a page->mapping==NULL page is - * BUG. So handle it here. + * Establish migration ptes or remove ptes */ - if (!page->mapping) - goto rcu_unlock; - /* Establish migration ptes or remove ptes */ try_to_unmap(page, 1); - if (!page_mapped(page)) rc = move_to_new_page(newpage, page); if (rc) remove_migration_ptes(page, page); -rcu_unlock: - rcu_read_unlock(); unlock: - unlock_page(page); if (rc != -EAGAIN) { diff --git a/trunk/mm/page_alloc.c b/trunk/mm/page_alloc.c index 6d3550ca0282..40954fb81598 100644 --- a/trunk/mm/page_alloc.c +++ b/trunk/mm/page_alloc.c @@ -2775,11 +2775,11 @@ unsigned long __meminit __absent_pages_in_range(int nid, if (i == -1) return 0; - prev_end_pfn = min(early_node_map[i].start_pfn, range_end_pfn); - /* Account for ranges before physical memory on this node */ if (early_node_map[i].start_pfn > range_start_pfn) - hole_pages = prev_end_pfn - range_start_pfn; + hole_pages = early_node_map[i].start_pfn - range_start_pfn; + + prev_end_pfn = early_node_map[i].start_pfn; /* Find all holes for the zone within the node */ for (; i != -1; i = next_active_region_index_in_nid(i, nid)) { diff --git a/trunk/net/bridge/br_input.c b/trunk/net/bridge/br_input.c index 5c18595b7616..420bbb9955e9 100644 --- a/trunk/net/bridge/br_input.c +++ b/trunk/net/bridge/br_input.c @@ -112,9 +112,9 @@ static int br_handle_local_finish(struct sk_buff *skb) */ static inline int is_link_local(const unsigned char *dest) { - __be16 *a = (__be16 *)dest; - static const __be16 *b = (const __be16 *)br_group_address; - static const __be16 m = __constant_cpu_to_be16(0xfff0); + const u16 *a = (const u16 *) dest; + static const u16 *const b = (const u16 *const ) br_group_address; + static const u16 m = __constant_cpu_to_be16(0xfff0); return ((a[0] ^ b[0]) | (a[1] ^ b[1]) | ((a[2] ^ b[2]) & m)) == 0; } diff --git a/trunk/net/ipv4/netfilter/nf_nat_core.c b/trunk/net/ipv4/netfilter/nf_nat_core.c index deab27facbad..e848d8d6292f 100644 --- a/trunk/net/ipv4/netfilter/nf_nat_core.c +++ b/trunk/net/ipv4/netfilter/nf_nat_core.c @@ -77,8 +77,7 @@ static inline unsigned int hash_by_src(const struct nf_conntrack_tuple *tuple) { /* Original src, to ensure we map it consistently if poss. */ - return jhash_3words((__force u32)tuple->src.u3.ip, - (__force u32)tuple->src.u.all, + return jhash_3words((__force u32)tuple->src.u3.ip, tuple->src.u.all, tuple->dst.protonum, 0) % nf_nat_htable_size; } diff --git a/trunk/net/ipv4/netfilter/nf_nat_rule.c b/trunk/net/ipv4/netfilter/nf_nat_rule.c index 76ec59ae524d..0f45427e5fdc 100644 --- a/trunk/net/ipv4/netfilter/nf_nat_rule.c +++ b/trunk/net/ipv4/netfilter/nf_nat_rule.c @@ -192,7 +192,7 @@ alloc_null_binding_confirmed(struct nf_conn *ct, unsigned int hooknum) = (HOOK2MANIP(hooknum) == IP_NAT_MANIP_SRC ? ct->tuplehash[IP_CT_DIR_REPLY].tuple.dst.u3.ip : ct->tuplehash[IP_CT_DIR_REPLY].tuple.src.u3.ip); - __be16 all + u_int16_t all = (HOOK2MANIP(hooknum) == IP_NAT_MANIP_SRC ? ct->tuplehash[IP_CT_DIR_REPLY].tuple.dst.u.all : ct->tuplehash[IP_CT_DIR_REPLY].tuple.src.u.all); diff --git a/trunk/net/ipv6/ip6_tunnel.c b/trunk/net/ipv6/ip6_tunnel.c index ca774d8e3be3..df30976f6dfd 100644 --- a/trunk/net/ipv6/ip6_tunnel.c +++ b/trunk/net/ipv6/ip6_tunnel.c @@ -385,7 +385,7 @@ parse_tlv_tnl_enc_lim(struct sk_buff *skb, __u8 * raw) static int ip6_tnl_err(struct sk_buff *skb, __u8 ipproto, struct inet6_skb_parm *opt, - int *type, int *code, int *msg, __u32 *info, int offset) + int *type, int *code, int *msg, __be32 *info, int offset) { struct ipv6hdr *ipv6h = (struct ipv6hdr *) skb->data; struct ip6_tnl *t; @@ -435,7 +435,7 @@ ip6_tnl_err(struct sk_buff *skb, __u8 ipproto, struct inet6_skb_parm *opt, if ((*code) == ICMPV6_HDR_FIELD) teli = parse_tlv_tnl_enc_lim(skb, skb->data); - if (teli && teli == *info - 2) { + if (teli && teli == ntohl(*info) - 2) { tel = (struct ipv6_tlv_tnl_enc_lim *) &skb->data[teli]; if (tel->encap_limit == 0) { if (net_ratelimit()) @@ -452,7 +452,7 @@ ip6_tnl_err(struct sk_buff *skb, __u8 ipproto, struct inet6_skb_parm *opt, } break; case ICMPV6_PKT_TOOBIG: - mtu = *info - offset; + mtu = ntohl(*info) - offset; if (mtu < IPV6_MIN_MTU) mtu = IPV6_MIN_MTU; t->dev->mtu = mtu; @@ -478,12 +478,12 @@ ip6_tnl_err(struct sk_buff *skb, __u8 ipproto, struct inet6_skb_parm *opt, static int ip4ip6_err(struct sk_buff *skb, struct inet6_skb_parm *opt, - int type, int code, int offset, __be32 info) + int type, int code, int offset, __u32 info) { int rel_msg = 0; int rel_type = type; int rel_code = code; - __u32 rel_info = ntohl(info); + __u32 rel_info = info; int err; struct sk_buff *skb2; struct iphdr *eiph; @@ -564,9 +564,10 @@ ip4ip6_err(struct sk_buff *skb, struct inet6_skb_parm *opt, goto out; skb2->dst->ops->update_pmtu(skb2->dst, rel_info); + rel_info = htonl(rel_info); } - icmp_send(skb2, rel_type, rel_code, htonl(rel_info)); + icmp_send(skb2, rel_type, rel_code, rel_info); out: kfree_skb(skb2); @@ -575,12 +576,12 @@ ip4ip6_err(struct sk_buff *skb, struct inet6_skb_parm *opt, static int ip6ip6_err(struct sk_buff *skb, struct inet6_skb_parm *opt, - int type, int code, int offset, __be32 info) + int type, int code, int offset, __u32 info) { int rel_msg = 0; int rel_type = type; int rel_code = code; - __u32 rel_info = ntohl(info); + __u32 rel_info = info; int err; err = ip6_tnl_err(skb, IPPROTO_IPV6, opt, &rel_type, &rel_code, diff --git a/trunk/net/key/af_key.c b/trunk/net/key/af_key.c index 7b0a95abe934..0f8304b0246b 100644 --- a/trunk/net/key/af_key.c +++ b/trunk/net/key/af_key.c @@ -2540,7 +2540,7 @@ static int pfkey_migrate(struct sock *sk, struct sk_buff *skb, sel.proto = pfkey_proto_to_xfrm(sa->sadb_address_proto); sel.sport = ((struct sockaddr_in *)(sa + 1))->sin_port; if (sel.sport) - sel.sport_mask = htons(0xffff); + sel.sport_mask = ~0; /* set destination address info of selector */ sa = ext_hdrs[SADB_EXT_ADDRESS_DST - 1], @@ -2549,7 +2549,7 @@ static int pfkey_migrate(struct sock *sk, struct sk_buff *skb, sel.proto = pfkey_proto_to_xfrm(sa->sadb_address_proto); sel.dport = ((struct sockaddr_in *)(sa + 1))->sin_port; if (sel.dport) - sel.dport_mask = htons(0xffff); + sel.dport_mask = ~0; rq = (struct sadb_x_ipsecrequest *)(pol + 1); diff --git a/trunk/net/netfilter/nf_conntrack_core.c b/trunk/net/netfilter/nf_conntrack_core.c index 0fe11889ce14..aa086c83af80 100644 --- a/trunk/net/netfilter/nf_conntrack_core.c +++ b/trunk/net/netfilter/nf_conntrack_core.c @@ -79,8 +79,7 @@ static u_int32_t __hash_conntrack(const struct nf_conntrack_tuple *tuple, a = jhash2(tuple->src.u3.all, ARRAY_SIZE(tuple->src.u3.all), (tuple->src.l3num << 16) | tuple->dst.protonum); b = jhash2(tuple->dst.u3.all, ARRAY_SIZE(tuple->dst.u3.all), - ((__force __u16)tuple->src.u.all << 16) | - (__force __u16)tuple->dst.u.all); + (tuple->src.u.all << 16) | tuple->dst.u.all); return jhash_2words(a, b, rnd) % size; } diff --git a/trunk/net/netfilter/nf_conntrack_expect.c b/trunk/net/netfilter/nf_conntrack_expect.c index eb6695dcd73b..1aa6229ca99f 100644 --- a/trunk/net/netfilter/nf_conntrack_expect.c +++ b/trunk/net/netfilter/nf_conntrack_expect.c @@ -80,7 +80,7 @@ static unsigned int nf_ct_expect_dst_hash(const struct nf_conntrack_tuple *tuple return jhash2(tuple->dst.u3.all, ARRAY_SIZE(tuple->dst.u3.all), (((tuple->dst.protonum ^ tuple->src.l3num) << 16) | - (__force __u16)tuple->dst.u.all) ^ nf_ct_expect_hash_rnd) % + tuple->dst.u.all) ^ nf_ct_expect_hash_rnd) % nf_ct_expect_hsize; } @@ -259,8 +259,8 @@ void nf_ct_expect_init(struct nf_conntrack_expect *exp, int family, } if (src) { - exp->tuple.src.u.all = *src; - exp->mask.src.u.all = htons(0xFFFF); + exp->tuple.src.u.all = (__force u16)*src; + exp->mask.src.u.all = 0xFFFF; } else { exp->tuple.src.u.all = 0; exp->mask.src.u.all = 0; @@ -272,7 +272,7 @@ void nf_ct_expect_init(struct nf_conntrack_expect *exp, int family, memset((void *)&exp->tuple.dst.u3 + len, 0x00, sizeof(exp->tuple.dst.u3) - len); - exp->tuple.dst.u.all = *dst; + exp->tuple.dst.u.all = (__force u16)*dst; } EXPORT_SYMBOL_GPL(nf_ct_expect_init); diff --git a/trunk/net/netfilter/nf_conntrack_helper.c b/trunk/net/netfilter/nf_conntrack_helper.c index 96aa637c0932..ca10df40784f 100644 --- a/trunk/net/netfilter/nf_conntrack_helper.c +++ b/trunk/net/netfilter/nf_conntrack_helper.c @@ -39,7 +39,7 @@ static int nf_ct_helper_vmalloc; static unsigned int helper_hash(const struct nf_conntrack_tuple *tuple) { return (((tuple->src.l3num << 8) | tuple->dst.protonum) ^ - (__force __u16)tuple->src.u.all) % nf_ct_helper_hsize; + tuple->src.u.all) % nf_ct_helper_hsize; } struct nf_conntrack_helper * diff --git a/trunk/net/netfilter/xt_connlimit.c b/trunk/net/netfilter/xt_connlimit.c index 06cff1d13690..3335dd5be962 100644 --- a/trunk/net/netfilter/xt_connlimit.c +++ b/trunk/net/netfilter/xt_connlimit.c @@ -42,13 +42,13 @@ struct xt_connlimit_data { static u_int32_t connlimit_rnd; static bool connlimit_rnd_inited; -static inline unsigned int connlimit_iphash(__be32 addr) +static inline unsigned int connlimit_iphash(u_int32_t addr) { if (unlikely(!connlimit_rnd_inited)) { get_random_bytes(&connlimit_rnd, sizeof(connlimit_rnd)); connlimit_rnd_inited = true; } - return jhash_1word((__force __u32)addr, connlimit_rnd) & 0xFF; + return jhash_1word(addr, connlimit_rnd) & 0xFF; } static inline unsigned int @@ -66,7 +66,7 @@ connlimit_iphash6(const union nf_conntrack_address *addr, for (i = 0; i < ARRAY_SIZE(addr->ip6); ++i) res.ip6[i] = addr->ip6[i] & mask->ip6[i]; - return jhash2((u32 *)res.ip6, ARRAY_SIZE(res.ip6), connlimit_rnd) & 0xFF; + return jhash2(res.ip6, ARRAY_SIZE(res.ip6), connlimit_rnd) & 0xFF; } static inline bool already_closed(const struct nf_conn *conn) diff --git a/trunk/net/netfilter/xt_u32.c b/trunk/net/netfilter/xt_u32.c index 74f9b14c012f..04b677ae8dae 100644 --- a/trunk/net/netfilter/xt_u32.c +++ b/trunk/net/netfilter/xt_u32.c @@ -21,7 +21,6 @@ static bool u32_match_it(const struct xt_u32 *data, unsigned int nnums; unsigned int nvals; unsigned int i; - __be32 n; u_int32_t pos; u_int32_t val; u_int32_t at; @@ -39,9 +38,9 @@ static bool u32_match_it(const struct xt_u32 *data, if (skb->len < 4 || pos > skb->len - 4); return false; - ret = skb_copy_bits(skb, pos, &n, sizeof(n)); + ret = skb_copy_bits(skb, pos, &val, sizeof(val)); BUG_ON(ret < 0); - val = ntohl(n); + val = ntohl(val); nnums = ct->nnums; /* Inner loop runs over "&", "<<", ">>" and "@" operands */ @@ -66,10 +65,10 @@ static bool u32_match_it(const struct xt_u32 *data, pos > skb->len - at - 4) return false; - ret = skb_copy_bits(skb, at + pos, &n, - sizeof(n)); + ret = skb_copy_bits(skb, at + pos, &val, + sizeof(val)); BUG_ON(ret < 0); - val = ntohl(n); + val = ntohl(val); break; } } diff --git a/trunk/net/rxrpc/ar-connection.c b/trunk/net/rxrpc/ar-connection.c index d6667f7bc85e..372b24466dc7 100644 --- a/trunk/net/rxrpc/ar-connection.c +++ b/trunk/net/rxrpc/ar-connection.c @@ -71,7 +71,7 @@ struct rxrpc_conn_bundle *rxrpc_get_bundle(struct rxrpc_sock *rx, struct rb_node *p, *parent, **pp; _enter("%p{%x},%x,%hx,", - rx, key_serial(key), trans->debug_id, ntohs(service_id)); + rx, key_serial(key), trans->debug_id, ntohl(service_id)); if (rx->trans == trans && rx->bundle) { atomic_inc(&rx->bundle->usage); diff --git a/trunk/net/sunrpc/svcsock.c b/trunk/net/sunrpc/svcsock.c index 12ff5da8160e..64b9b8c743c4 100644 --- a/trunk/net/sunrpc/svcsock.c +++ b/trunk/net/sunrpc/svcsock.c @@ -131,13 +131,13 @@ static char *__svc_print_addr(struct sockaddr *addr, char *buf, size_t len) case AF_INET: snprintf(buf, len, "%u.%u.%u.%u, port=%u", NIPQUAD(((struct sockaddr_in *) addr)->sin_addr), - ntohs(((struct sockaddr_in *) addr)->sin_port)); + htons(((struct sockaddr_in *) addr)->sin_port)); break; case AF_INET6: snprintf(buf, len, "%x:%x:%x:%x:%x:%x:%x:%x, port=%u", NIP6(((struct sockaddr_in6 *) addr)->sin6_addr), - ntohs(((struct sockaddr_in6 *) addr)->sin6_port)); + htons(((struct sockaddr_in6 *) addr)->sin6_port)); break; default: diff --git a/trunk/net/tipc/msg.h b/trunk/net/tipc/msg.h index ce2659836374..35d5ba1d4f42 100644 --- a/trunk/net/tipc/msg.h +++ b/trunk/net/tipc/msg.h @@ -72,8 +72,10 @@ static inline void msg_set_bits(struct tipc_msg *m, u32 w, u32 pos, u32 mask, u32 val) { val = (val & mask) << pos; - m->hdr[w] &= ~htonl(mask << pos); - m->hdr[w] |= htonl(val); + val = htonl(val); + mask = htonl(mask << pos); + m->hdr[w] &= ~mask; + m->hdr[w] |= val; } /*