Linux-2.6.12-rc2v2.6.12-rc2

Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.

Let it rip!

5 files changed, 576 insertions, 0 deletions

diff --git a/arch/x86_64/boot/compressed/Makefile b/arch/x86_64/boot/compressed/Makefile
new file mode 100644
index 000000000000..f89d96f11a9f
--- /dev/null
+++ b/arch/x86_64/boot/compressed/Makefile
@@ -0,0 +1,32 @@
+#
+# linux/arch/x86_64/boot/compressed/Makefile
+#
+# create a compressed vmlinux image from the original vmlinux
+#
+# Note all the files here are compiled/linked as 32bit executables.
+#
+
+targets         := vmlinux vmlinux.bin vmlinux.bin.gz head.o misc.o piggy.o
+EXTRA_AFLAGS    := -traditional -m32
+
+# cannot use EXTRA_CFLAGS because base CFLAGS contains -mkernel which conflicts with
+# -m32
+CFLAGS := -m32 -D__KERNEL__ -Iinclude -O2  -fno-strict-aliasing
+LDFLAGS := -m elf_i386
+
+LDFLAGS_vmlinux := -Ttext $(IMAGE_OFFSET) -e startup_32 -m elf_i386
+
+$(obj)/vmlinux: $(obj)/head.o $(obj)/misc.o $(obj)/piggy.o FORCE
+        $(call if_changed,ld)
+        @:
+
+$(obj)/vmlinux.bin: vmlinux FORCE
+        $(call if_changed,objcopy)
+
+$(obj)/vmlinux.bin.gz: $(obj)/vmlinux.bin FORCE
+        $(call if_changed,gzip)
+
+LDFLAGS_piggy.o := -r --format binary --oformat elf32-i386 -T
+
+$(obj)/piggy.o: $(obj)/vmlinux.scr $(obj)/vmlinux.bin.gz FORCE
+        $(call if_changed,ld)
diff --git a/arch/x86_64/boot/compressed/head.S b/arch/x86_64/boot/compressed/head.S
new file mode 100644
index 000000000000..27264dbd575c
--- /dev/null
+++ b/arch/x86_64/boot/compressed/head.S
@@ -0,0 +1,142 @@
+/*
+ *  linux/boot/head.S
+ *
+ *  Copyright (C) 1991, 1992, 1993  Linus Torvalds
+ *
+ *  $Id: head.S,v 1.3 2001/04/20 00:59:28 ak Exp $                      
+ */
+
+/*
+ *  head.S contains the 32-bit startup code.
+ *
+ * NOTE!!! Startup happens at absolute address 0x00001000, which is also where
+ * the page directory will exist. The startup code will be overwritten by
+ * the page directory. [According to comments etc elsewhere on a compressed
+ * kernel it will end up at 0x1000 + 1Mb I hope so as I assume this. - AC]
+ *
+ * Page 0 is deliberately kept safe, since System Management Mode code in 
+ * laptops may need to access the BIOS data stored there.  This is also
+ * useful for future device drivers that either access the BIOS via VM86 
+ * mode.
+ */
+
+/*
+ * High loaded stuff by Hans Lermen & Werner Almesberger, Feb. 1996     
+ */
+.code32
+.text
+
+#include <linux/linkage.h>
+#include <asm/segment.h>
+
+        .code32
+        .globl startup_32
+        
+startup_32:
+        cld
+        cli
+        movl $(__KERNEL_DS),%eax
+        movl %eax,%ds
+        movl %eax,%es
+        movl %eax,%fs
+        movl %eax,%gs
+
+        lss stack_start,%esp
+        xorl %eax,%eax
+1:      incl %eax               # check that A20 really IS enabled
+        movl %eax,0x000000      # loop forever if it isn't
+        cmpl %eax,0x100000
+        je 1b
+
+/*
+ * Initialize eflags.  Some BIOS's leave bits like NT set.  This would
+ * confuse the debugger if this code is traced.
+ * XXX - best to initialize before switching to protected mode.
+ */
+        pushl $0
+        popfl
+/*
+ * Clear BSS
+ */
+        xorl %eax,%eax
+        movl $_edata,%edi
+        movl $_end,%ecx
+        subl %edi,%ecx
+        cld
+        rep
+        stosb
+/*
+ * Do the decompression, and jump to the new kernel..
+ */
+        subl $16,%esp   # place for structure on the stack
+        movl %esp,%eax
+        pushl %esi      # real mode pointer as second arg
+        pushl %eax      # address of structure as first arg
+        call decompress_kernel
+        orl  %eax,%eax 
+        jnz  3f
+        addl $8,%esp
+        xorl %ebx,%ebx
+        ljmp $(__KERNEL_CS), $0x100000
+
+/*
+ * We come here, if we were loaded high.
+ * We need to move the move-in-place routine down to 0x1000
+ * and then start it with the buffer addresses in registers,
+ * which we got from the stack.
+ */
+3:
+        movl %esi,%ebx  
+        movl $move_routine_start,%esi
+        movl $0x1000,%edi
+        movl $move_routine_end,%ecx
+        subl %esi,%ecx
+        addl $3,%ecx
+        shrl $2,%ecx
+        cld
+        rep
+        movsl
+
+        popl %esi       # discard the address
+        addl $4,%esp    # real mode pointer
+        popl %esi       # low_buffer_start
+        popl %ecx       # lcount
+        popl %edx       # high_buffer_start
+        popl %eax       # hcount
+        movl $0x100000,%edi
+        cli             # make sure we don't get interrupted
+        ljmp $(__KERNEL_CS), $0x1000 # and jump to the move routine
+
+/*
+ * Routine (template) for moving the decompressed kernel in place,
+ * if we were high loaded. This _must_ PIC-code !
+ */
+move_routine_start:
+        movl %ecx,%ebp
+        shrl $2,%ecx
+        rep
+        movsl
+        movl %ebp,%ecx
+        andl $3,%ecx
+        rep
+        movsb
+        movl %edx,%esi
+        movl %eax,%ecx  # NOTE: rep movsb won't move if %ecx == 0
+        addl $3,%ecx
+        shrl $2,%ecx
+        rep
+        movsl
+        movl %ebx,%esi  # Restore setup pointer
+        xorl %ebx,%ebx
+        ljmp $(__KERNEL_CS), $0x100000
+move_routine_end:
+
+
+/* Stack for uncompression */   
+        .align 32
+user_stack:             
+        .fill 4096,4,0
+stack_start:    
+        .long user_stack+4096
+        .word __KERNEL_DS
+
diff --git a/arch/x86_64/boot/compressed/misc.c b/arch/x86_64/boot/compressed/misc.c
new file mode 100644
index 000000000000..c8b9216f9e63
--- /dev/null
+++ b/arch/x86_64/boot/compressed/misc.c
@@ -0,0 +1,354 @@
+/*
+ * misc.c
+ * 
+ * This is a collection of several routines from gzip-1.0.3 
+ * adapted for Linux.
+ *
+ * malloc by Hannu Savolainen 1993 and Matthias Urlichs 1994
+ * puts by Nick Holloway 1993, better puts by Martin Mares 1995
+ * High loaded stuff by Hans Lermen & Werner Almesberger, Feb. 1996
+ */
+
+#include "miscsetup.h"
+#include <asm/io.h>
+
+/*
+ * gzip declarations
+ */
+
+#define OF(args)  args
+#define STATIC static
+
+#undef memset
+#undef memcpy
+#define memzero(s, n)     memset ((s), 0, (n))
+
+typedef unsigned char  uch;
+typedef unsigned short ush;
+typedef unsigned long  ulg;
+
+#define WSIZE 0x8000            /* Window size must be at least 32k, */
+                                /* and a power of two */
+
+static uch *inbuf;           /* input buffer */
+static uch window[WSIZE];    /* Sliding window buffer */
+
+static unsigned insize = 0;  /* valid bytes in inbuf */
+static unsigned inptr = 0;   /* index of next byte to be processed in inbuf */
+static unsigned outcnt = 0;  /* bytes in output buffer */
+
+/* gzip flag byte */
+#define ASCII_FLAG   0x01 /* bit 0 set: file probably ASCII text */
+#define CONTINUATION 0x02 /* bit 1 set: continuation of multi-part gzip file */
+#define EXTRA_FIELD  0x04 /* bit 2 set: extra field present */
+#define ORIG_NAME    0x08 /* bit 3 set: original file name present */
+#define COMMENT      0x10 /* bit 4 set: file comment present */
+#define ENCRYPTED    0x20 /* bit 5 set: file is encrypted */
+#define RESERVED     0xC0 /* bit 6,7:   reserved */
+
+#define get_byte()  (inptr < insize ? inbuf[inptr++] : fill_inbuf())
+                
+/* Diagnostic functions */
+#ifdef DEBUG
+#  define Assert(cond,msg) {if(!(cond)) error(msg);}
+#  define Trace(x) fprintf x
+#  define Tracev(x) {if (verbose) fprintf x ;}
+#  define Tracevv(x) {if (verbose>1) fprintf x ;}
+#  define Tracec(c,x) {if (verbose && (c)) fprintf x ;}
+#  define Tracecv(c,x) {if (verbose>1 && (c)) fprintf x ;}
+#else
+#  define Assert(cond,msg)
+#  define Trace(x)
+#  define Tracev(x)
+#  define Tracevv(x)
+#  define Tracec(c,x)
+#  define Tracecv(c,x)
+#endif
+
+static int  fill_inbuf(void);
+static void flush_window(void);
+static void error(char *m);
+static void gzip_mark(void **);
+static void gzip_release(void **);
+  
+/*
+ * This is set up by the setup-routine at boot-time
+ */
+static unsigned char *real_mode; /* Pointer to real-mode data */
+
+#define EXT_MEM_K   (*(unsigned short *)(real_mode + 0x2))
+#ifndef STANDARD_MEMORY_BIOS_CALL
+#define ALT_MEM_K   (*(unsigned long *)(real_mode + 0x1e0))
+#endif
+#define SCREEN_INFO (*(struct screen_info *)(real_mode+0))
+
+extern char input_data[];
+extern int input_len;
+
+static long bytes_out = 0;
+static uch *output_data;
+static unsigned long output_ptr = 0;
+
+static void *malloc(int size);
+static void free(void *where);
+ 
+static void putstr(const char *);
+  
+extern int end;
+static long free_mem_ptr = (long)&end;
+static long free_mem_end_ptr;
+
+#define INPLACE_MOVE_ROUTINE  0x1000
+#define LOW_BUFFER_START      0x2000
+#define LOW_BUFFER_MAX       0x90000
+#define HEAP_SIZE             0x3000
+static unsigned int low_buffer_end, low_buffer_size;
+static int high_loaded =0;
+static uch *high_buffer_start /* = (uch *)(((ulg)&end) + HEAP_SIZE)*/;
+
+static char *vidmem = (char *)0xb8000;
+static int vidport;
+static int lines, cols;
+
+#include "../../../../lib/inflate.c"
+
+static void *malloc(int size)
+{
+        void *p;
+
+        if (size <0) error("Malloc error");
+        if (free_mem_ptr <= 0) error("Memory error");
+
+        free_mem_ptr = (free_mem_ptr + 3) & ~3; /* Align */
+
+        p = (void *)free_mem_ptr;
+        free_mem_ptr += size;
+
+        if (free_mem_ptr >= free_mem_end_ptr)
+                error("Out of memory");
+
+        return p;
+}
+
+static void free(void *where)
+{       /* Don't care */
+}
+
+static void gzip_mark(void **ptr)
+{
+        *ptr = (void *) free_mem_ptr;
+}
+
+static void gzip_release(void **ptr)
+{
+        free_mem_ptr = (long) *ptr;
+}
+ 
+static void scroll(void)
+{
+        int i;
+
+        memcpy ( vidmem, vidmem + cols * 2, ( lines - 1 ) * cols * 2 );
+        for ( i = ( lines - 1 ) * cols * 2; i < lines * cols * 2; i += 2 )
+                vidmem[i] = ' ';
+}
+
+static void putstr(const char *s)
+{
+        int x,y,pos;
+        char c;
+
+        x = SCREEN_INFO.orig_x;
+        y = SCREEN_INFO.orig_y;
+
+        while ( ( c = *s++ ) != '\0' ) {
+                if ( c == '\n' ) {
+                        x = 0;
+                        if ( ++y >= lines ) {
+                                scroll();
+                                y--;
+                        }
+                } else {
+                        vidmem [ ( x + cols * y ) * 2 ] = c; 
+                        if ( ++x >= cols ) {
+                                x = 0;
+                                if ( ++y >= lines ) {
+                                        scroll();
+                                        y--;
+                                }
+                        }
+                }
+        }
+
+        SCREEN_INFO.orig_x = x;
+        SCREEN_INFO.orig_y = y;
+
+        pos = (x + cols * y) * 2;       /* Update cursor position */
+        outb_p(14, vidport);
+        outb_p(0xff & (pos >> 9), vidport+1);
+        outb_p(15, vidport);
+        outb_p(0xff & (pos >> 1), vidport+1);
+}
+
+void* memset(void* s, int c, unsigned n)
+{
+        int i;
+        char *ss = (char*)s;
+
+        for (i=0;i<n;i++) ss[i] = c;
+        return s;
+}
+
+void* memcpy(void* dest, const void* src, unsigned n)
+{
+        int i;
+        char *d = (char *)dest, *s = (char *)src;
+
+        for (i=0;i<n;i++) d[i] = s[i];
+        return dest;
+}
+
+/* ===========================================================================
+ * Fill the input buffer. This is called only when the buffer is empty
+ * and at least one byte is really needed.
+ */
+static int fill_inbuf(void)
+{
+        if (insize != 0) {
+                error("ran out of input data");
+        }
+
+        inbuf = input_data;
+        insize = input_len;
+        inptr = 1;
+        return inbuf[0];
+}
+
+/* ===========================================================================
+ * Write the output window window[0..outcnt-1] and update crc and bytes_out.
+ * (Used for the decompressed data only.)
+ */
+static void flush_window_low(void)
+{
+    ulg c = crc;         /* temporary variable */
+    unsigned n;
+    uch *in, *out, ch;
+    
+    in = window;
+    out = &output_data[output_ptr]; 
+    for (n = 0; n < outcnt; n++) {
+            ch = *out++ = *in++;
+            c = crc_32_tab[((int)c ^ ch) & 0xff] ^ (c >> 8);
+    }
+    crc = c;
+    bytes_out += (ulg)outcnt;
+    output_ptr += (ulg)outcnt;
+    outcnt = 0;
+}
+
+static void flush_window_high(void)
+{
+    ulg c = crc;         /* temporary variable */
+    unsigned n;
+    uch *in,  ch;
+    in = window;
+    for (n = 0; n < outcnt; n++) {
+        ch = *output_data++ = *in++;
+        if ((ulg)output_data == low_buffer_end) output_data=high_buffer_start;
+        c = crc_32_tab[((int)c ^ ch) & 0xff] ^ (c >> 8);
+    }
+    crc = c;
+    bytes_out += (ulg)outcnt;
+    outcnt = 0;
+}
+
+static void flush_window(void)
+{
+        if (high_loaded) flush_window_high();
+        else flush_window_low();
+}
+
+static void error(char *x)
+{
+        putstr("\n\n");
+        putstr(x);
+        putstr("\n\n -- System halted");
+
+        while(1);
+}
+
+void setup_normal_output_buffer(void)
+{
+#ifdef STANDARD_MEMORY_BIOS_CALL
+        if (EXT_MEM_K < 1024) error("Less than 2MB of memory");
+#else
+        if ((ALT_MEM_K > EXT_MEM_K ? ALT_MEM_K : EXT_MEM_K) < 1024) error("Less than 2MB of memory");
+#endif
+        output_data = (char *)0x100000; /* Points to 1M */
+        free_mem_end_ptr = (long)real_mode;
+}
+
+struct moveparams {
+        uch *low_buffer_start;  int lcount;
+        uch *high_buffer_start; int hcount;
+};
+
+void setup_output_buffer_if_we_run_high(struct moveparams *mv)
+{
+        high_buffer_start = (uch *)(((ulg)&end) + HEAP_SIZE);
+#ifdef STANDARD_MEMORY_BIOS_CALL
+        if (EXT_MEM_K < (3*1024)) error("Less than 4MB of memory");
+#else
+        if ((ALT_MEM_K > EXT_MEM_K ? ALT_MEM_K : EXT_MEM_K) < (3*1024)) error("Less than 4MB of memory");
+#endif  
+        mv->low_buffer_start = output_data = (char *)LOW_BUFFER_START;
+        low_buffer_end = ((unsigned int)real_mode > LOW_BUFFER_MAX
+          ? LOW_BUFFER_MAX : (unsigned int)real_mode) & ~0xfff;
+        low_buffer_size = low_buffer_end - LOW_BUFFER_START;
+        high_loaded = 1;
+        free_mem_end_ptr = (long)high_buffer_start;
+        if ( (0x100000 + low_buffer_size) > ((ulg)high_buffer_start)) {
+                high_buffer_start = (uch *)(0x100000 + low_buffer_size);
+                mv->hcount = 0; /* say: we need not to move high_buffer */
+        }
+        else mv->hcount = -1;
+        mv->high_buffer_start = high_buffer_start;
+}
+
+void close_output_buffer_if_we_run_high(struct moveparams *mv)
+{
+        if (bytes_out > low_buffer_size) {
+                mv->lcount = low_buffer_size;
+                if (mv->hcount)
+                        mv->hcount = bytes_out - low_buffer_size;
+        } else {
+                mv->lcount = bytes_out;
+                mv->hcount = 0;
+        }
+}
+
+int decompress_kernel(struct moveparams *mv, void *rmode)
+{
+        real_mode = rmode;
+
+        if (SCREEN_INFO.orig_video_mode == 7) {
+                vidmem = (char *) 0xb0000;
+                vidport = 0x3b4;
+        } else {
+                vidmem = (char *) 0xb8000;
+                vidport = 0x3d4;
+        }
+
+        lines = SCREEN_INFO.orig_video_lines;
+        cols = SCREEN_INFO.orig_video_cols;
+
+        if (free_mem_ptr < 0x100000) setup_normal_output_buffer();
+        else setup_output_buffer_if_we_run_high(mv);
+
+        makecrc();
+        putstr(".\nDecompressing Linux...");
+        gunzip();
+        putstr("done.\nBooting the kernel.\n");
+        if (high_loaded) close_output_buffer_if_we_run_high(mv);
+        return high_loaded;
+}
diff --git a/arch/x86_64/boot/compressed/miscsetup.h b/arch/x86_64/boot/compressed/miscsetup.h
new file mode 100644
index 000000000000..bb1620531703
--- /dev/null
+++ b/arch/x86_64/boot/compressed/miscsetup.h
@@ -0,0 +1,39 @@
+#define NULL 0
+//typedef unsigned int size_t; 
+
+
+struct screen_info {
+        unsigned char  orig_x;                  /* 0x00 */
+        unsigned char  orig_y;                  /* 0x01 */
+        unsigned short dontuse1;                /* 0x02 -- EXT_MEM_K sits here */
+        unsigned short orig_video_page;         /* 0x04 */
+        unsigned char  orig_video_mode;         /* 0x06 */
+        unsigned char  orig_video_cols;         /* 0x07 */
+        unsigned short unused2;                 /* 0x08 */
+        unsigned short orig_video_ega_bx;       /* 0x0a */
+        unsigned short unused3;                 /* 0x0c */
+        unsigned char  orig_video_lines;        /* 0x0e */
+        unsigned char  orig_video_isVGA;        /* 0x0f */
+        unsigned short orig_video_points;       /* 0x10 */
+
+        /* VESA graphic mode -- linear frame buffer */
+        unsigned short lfb_width;               /* 0x12 */
+        unsigned short lfb_height;              /* 0x14 */
+        unsigned short lfb_depth;               /* 0x16 */
+        unsigned long  lfb_base;                /* 0x18 */
+        unsigned long  lfb_size;                /* 0x1c */
+        unsigned short dontuse2, dontuse3;      /* 0x20 -- CL_MAGIC and CL_OFFSET here */
+        unsigned short lfb_linelength;          /* 0x24 */
+        unsigned char  red_size;                /* 0x26 */
+        unsigned char  red_pos;                 /* 0x27 */
+        unsigned char  green_size;              /* 0x28 */
+        unsigned char  green_pos;               /* 0x29 */
+        unsigned char  blue_size;               /* 0x2a */
+        unsigned char  blue_pos;                /* 0x2b */
+        unsigned char  rsvd_size;               /* 0x2c */
+        unsigned char  rsvd_pos;                /* 0x2d */
+        unsigned short vesapm_seg;              /* 0x2e */
+        unsigned short vesapm_off;              /* 0x30 */
+        unsigned short pages;                   /* 0x32 */
+                                                /* 0x34 -- 0x3f reserved for future expansion */
+};
diff --git a/arch/x86_64/boot/compressed/vmlinux.scr b/arch/x86_64/boot/compressed/vmlinux.scr
new file mode 100644
index 000000000000..1ed9d791f863
--- /dev/null
+++ b/arch/x86_64/boot/compressed/vmlinux.scr
@@ -0,0 +1,9 @@
+SECTIONS
+{
+  .data : { 
+        input_len = .;
+        LONG(input_data_end - input_data) input_data = .; 
+        *(.data) 
+        input_data_end = .; 
+        }
+}