diff -u --recursive --new-file linux-1.1.55+new_quota+alpha/.version linux/.version --- linux-1.1.55+new_quota+alpha/.version Wed Dec 31 18:00:00 1969 +++ linux/.version Thu Oct 20 18:27:07 1994 @@ -0,0 +1 @@ +1 diff -u --recursive --new-file linux-1.1.55+new_quota+alpha/drivers/block/ramdisk.c linux/drivers/block/ramdisk.c --- linux-1.1.55+new_quota+alpha/drivers/block/ramdisk.c Thu Oct 13 21:31:06 1994 +++ linux/drivers/block/ramdisk.c Thu Oct 20 18:22:55 1994 @@ -186,7 +186,12 @@ return; /* for Slackware install disks */ - printk(KERN_NOTICE "VFS: Insert ramdisk floppy and press ENTER\n"); + /* Pat's ugly hack */ + printk(KERN_NOTICE "\n\nPlease remove the boot kernel disk from your floppy drive, insert a\n"); + printk(KERN_NOTICE "root/install disk (such as one of the Slackware color144, colrlite,\n"); + printk(KERN_NOTICE "tty144, or tty12 disks) or some other disk you wish to load into a\n"); + printk(KERN_NOTICE "ramdisk and boot, and then press ENTER to continue.\n\n"); +/* printk(KERN_NOTICE "VFS: Insert ramdisk floppy and press ENTER\n"); */ wait_for_keypress(); memset(&filp, 0, sizeof(filp)); diff -u --recursive --new-file linux-1.1.55+new_quota+alpha/fs/binfmt_elf.c linux/fs/binfmt_elf.c --- linux-1.1.55+new_quota+alpha/fs/binfmt_elf.c Thu Oct 20 17:01:16 1994 +++ linux/fs/binfmt_elf.c Thu Oct 20 18:48:18 1994 @@ -497,8 +497,6 @@ current->mm->end_code = 0; current->mm->start_mmap = ELF_START_MMAP; current->mm->mmap = NULL; - current->flags &= ~PF_FORKNOEXEC; /* accounting flags */ - current->io_usage = 0; elf_entry = (unsigned int) elf_ex.e_entry; /* Do this so that we can load the interpreter, if need be. We will @@ -791,639 +789,3 @@ unregister_binfmt(&elf_format); } #endif -/* - * linux/fs/binfmt_elf.c - */ -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include - -asmlinkage int sys_exit(int exit_code); -asmlinkage int sys_close(unsigned fd); -asmlinkage int sys_open(const char *, int, int); -asmlinkage int sys_brk(unsigned long); - -#define DLINFO_ITEMS 8 - -#include - -/* We need to explicitly zero any fractional pages - after the data section (i.e. bss). This would - contain the junk from the file that should not - be in memory */ - -static void padzero(int elf_bss){ - unsigned int fpnt, nbyte; - - if(elf_bss & 0xfff) { - - nbyte = (PAGE_SIZE - (elf_bss & 0xfff)) & 0xfff; - if(nbyte){ - verify_area(VERIFY_WRITE, (void *) elf_bss, nbyte); - - fpnt = elf_bss; - while(fpnt & 0xfff) put_fs_byte(0, fpnt++); - }; - }; -} - -unsigned long * create_elf_tables(char * p,int argc,int envc,struct elfhdr * exec, unsigned int load_addr, int ibcs) -{ - unsigned long *argv,*envp, *dlinfo; - unsigned long * sp; - struct vm_area_struct *mpnt; - - mpnt = (struct vm_area_struct *)kmalloc(sizeof(*mpnt), GFP_KERNEL); - if (mpnt) { - mpnt->vm_task = current; - mpnt->vm_start = PAGE_MASK & (unsigned long) p; - mpnt->vm_end = TASK_SIZE; - mpnt->vm_page_prot = PAGE_PRIVATE|PAGE_DIRTY; - mpnt->vm_share = NULL; - mpnt->vm_inode = NULL; - mpnt->vm_offset = 0; - mpnt->vm_ops = NULL; - insert_vm_struct(current, mpnt); - current->mm->stk_vma = mpnt; - } - sp = (unsigned long *) (0xfffffffc & (unsigned long) p); - if(exec) sp -= DLINFO_ITEMS*2; - dlinfo = sp; - sp -= envc+1; - envp = sp; - sp -= argc+1; - argv = sp; - if (!ibcs) { - put_fs_long((unsigned long)envp,--sp); - put_fs_long((unsigned long)argv,--sp); - } - - /* The constant numbers (0-9) that we are writing here are - described in the header file sys/auxv.h on at least - some versions of SVr4 */ - if(exec) { /* Put this here for an ELF program interpreter */ - struct elf_phdr * eppnt; - eppnt = (struct elf_phdr *) exec->e_phoff; - put_fs_long(3,dlinfo++); put_fs_long(load_addr + exec->e_phoff,dlinfo++); - put_fs_long(4,dlinfo++); put_fs_long(sizeof(struct elf_phdr),dlinfo++); - put_fs_long(5,dlinfo++); put_fs_long(exec->e_phnum,dlinfo++); - put_fs_long(9,dlinfo++); put_fs_long((unsigned long) exec->e_entry,dlinfo++); - put_fs_long(7,dlinfo++); put_fs_long(SHM_RANGE_START,dlinfo++); - put_fs_long(8,dlinfo++); put_fs_long(0,dlinfo++); - put_fs_long(6,dlinfo++); put_fs_long(PAGE_SIZE,dlinfo++); - put_fs_long(0,dlinfo++); put_fs_long(0,dlinfo++); - }; - - put_fs_long((unsigned long)argc,--sp); - current->mm->arg_start = (unsigned long) p; - while (argc-->0) { - put_fs_long((unsigned long) p,argv++); - while (get_fs_byte(p++)) /* nothing */ ; - } - put_fs_long(0,argv); - current->mm->arg_end = current->mm->env_start = (unsigned long) p; - while (envc-->0) { - put_fs_long((unsigned long) p,envp++); - while (get_fs_byte(p++)) /* nothing */ ; - } - put_fs_long(0,envp); - current->mm->env_end = (unsigned long) p; - return sp; -} - - -/* This is much more generalized than the library routine read function, - so we keep this separate. Techincally the library read function - is only provided so that we can read a.out libraries that have - an ELF header */ - -static unsigned int load_elf_interp(struct elfhdr * interp_elf_ex, - struct inode * interpreter_inode) -{ - struct file * file; - struct elf_phdr *elf_phdata = NULL; - struct elf_phdr *eppnt; - unsigned int len; - unsigned int load_addr; - int elf_exec_fileno; - int elf_bss; - int old_fs, retval; - unsigned int last_bss; - int error; - int i, k; - - elf_bss = 0; - last_bss = 0; - error = load_addr = 0; - - /* First of all, some simple consistency checks */ - if((interp_elf_ex->e_type != ET_EXEC && - interp_elf_ex->e_type != ET_DYN) || - (interp_elf_ex->e_machine != EM_386 && interp_elf_ex->e_machine != EM_486) || - (!interpreter_inode->i_op || !interpreter_inode->i_op->bmap || - !interpreter_inode->i_op->default_file_ops->mmap)){ - return 0xffffffff; - }; - - /* Now read in all of the header information */ - - if(sizeof(struct elf_phdr) * interp_elf_ex->e_phnum > PAGE_SIZE) - return 0xffffffff; - - elf_phdata = (struct elf_phdr *) - kmalloc(sizeof(struct elf_phdr) * interp_elf_ex->e_phnum, GFP_KERNEL); - if(!elf_phdata) return 0xffffffff; - - old_fs = get_fs(); - set_fs(get_ds()); - retval = read_exec(interpreter_inode, interp_elf_ex->e_phoff, (char *) elf_phdata, - sizeof(struct elf_phdr) * interp_elf_ex->e_phnum); - set_fs(old_fs); - - elf_exec_fileno = open_inode(interpreter_inode, O_RDONLY); - if (elf_exec_fileno < 0) return 0xffffffff; - file = current->files->fd[elf_exec_fileno]; - - eppnt = elf_phdata; - for(i=0; ie_phnum; i++, eppnt++) - if(eppnt->p_type == PT_LOAD) { - error = do_mmap(file, - eppnt->p_vaddr & 0xfffff000, - eppnt->p_filesz + (eppnt->p_vaddr & 0xfff), - PROT_READ | PROT_WRITE | PROT_EXEC, - MAP_PRIVATE | (interp_elf_ex->e_type == ET_EXEC ? MAP_FIXED : 0), - eppnt->p_offset & 0xfffff000); - - if(!load_addr && interp_elf_ex->e_type == ET_DYN) - load_addr = error; - k = load_addr + eppnt->p_vaddr + eppnt->p_filesz; - if(k > elf_bss) elf_bss = k; - if(error < 0 && error > -1024) break; /* Real error */ - k = load_addr + eppnt->p_memsz + eppnt->p_vaddr; - if(k > last_bss) last_bss = k; - } - - /* Now use mmap to map the library into memory. */ - - - sys_close(elf_exec_fileno); - if(error < 0 && error > -1024) { - kfree(elf_phdata); - return 0xffffffff; - } - - padzero(elf_bss); - len = (elf_bss + 0xfff) & 0xfffff000; /* What we have mapped so far */ - - /* Map the last of the bss segment */ - if (last_bss > len) - do_mmap(NULL, len, last_bss-len, - PROT_READ|PROT_WRITE|PROT_EXEC, - MAP_FIXED|MAP_PRIVATE, 0); - kfree(elf_phdata); - - return ((unsigned int) interp_elf_ex->e_entry) + load_addr; -} - -static unsigned int load_aout_interp(struct exec * interp_ex, - struct inode * interpreter_inode) -{ - int retval; - unsigned int elf_entry; - - current->mm->brk = interp_ex->a_bss + - (current->mm->end_data = interp_ex->a_data + - (current->mm->end_code = interp_ex->a_text)); - elf_entry = interp_ex->a_entry; - - - if (N_MAGIC(*interp_ex) == OMAGIC) { - do_mmap(NULL, 0, interp_ex->a_text+interp_ex->a_data, - PROT_READ|PROT_WRITE|PROT_EXEC, - MAP_FIXED|MAP_PRIVATE, 0); - retval = read_exec(interpreter_inode, 32, (char *) 0, - interp_ex->a_text+interp_ex->a_data); - } else if (N_MAGIC(*interp_ex) == ZMAGIC || N_MAGIC(*interp_ex) == QMAGIC) { - do_mmap(NULL, 0, interp_ex->a_text+interp_ex->a_data, - PROT_READ|PROT_WRITE|PROT_EXEC, - MAP_FIXED|MAP_PRIVATE, 0); - retval = read_exec(interpreter_inode, - N_TXTOFF(*interp_ex) , - (char *) N_TXTADDR(*interp_ex), - interp_ex->a_text+interp_ex->a_data); - } else - retval = -1; - - if(retval >= 0) - do_mmap(NULL, (interp_ex->a_text + interp_ex->a_data + 0xfff) & - 0xfffff000, interp_ex->a_bss, - PROT_READ|PROT_WRITE|PROT_EXEC, - MAP_FIXED|MAP_PRIVATE, 0); - if(retval < 0) return 0xffffffff; - return elf_entry; -} - -/* - * These are the functions used to load ELF style executables and shared - * libraries. There is no binary dependent code anywhere else. - */ - -#define INTERPRETER_NONE 0 -#define INTERPRETER_AOUT 1 -#define INTERPRETER_ELF 2 - -int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs) -{ - struct elfhdr elf_ex; - struct elfhdr interp_elf_ex; - struct file * file; - struct exec interp_ex; - struct inode *interpreter_inode; - unsigned int load_addr; - unsigned int interpreter_type = INTERPRETER_NONE; - int i; - int old_fs; - int error; - struct elf_phdr * elf_ppnt, *elf_phdata; - int elf_exec_fileno; - unsigned int elf_bss, k, elf_brk; - int retval; - char * elf_interpreter; - unsigned int elf_entry; - int status; - unsigned int start_code, end_code, end_data; - unsigned int elf_stack; - char passed_fileno[6]; - - status = 0; - load_addr = 0; - elf_ex = *((struct elfhdr *) bprm->buf); /* exec-header */ - - if (elf_ex.e_ident[0] != 0x7f || - strncmp(&elf_ex.e_ident[1], "ELF",3) != 0) - return -ENOEXEC; - - - /* First of all, some simple consistency checks */ - if(elf_ex.e_type != ET_EXEC || - (elf_ex.e_machine != EM_386 && elf_ex.e_machine != EM_486) || - (!bprm->inode->i_op || !bprm->inode->i_op->default_file_ops || - !bprm->inode->i_op->default_file_ops->mmap)){ - return -ENOEXEC; - }; - - /* Now read in all of the header information */ - - elf_phdata = (struct elf_phdr *) kmalloc(elf_ex.e_phentsize * - elf_ex.e_phnum, GFP_KERNEL); - - old_fs = get_fs(); - set_fs(get_ds()); - retval = read_exec(bprm->inode, elf_ex.e_phoff, (char *) elf_phdata, - elf_ex.e_phentsize * elf_ex.e_phnum); - set_fs(old_fs); - if (retval < 0) { - kfree (elf_phdata); - return retval; - } - - elf_ppnt = elf_phdata; - - elf_bss = 0; - elf_brk = 0; - - elf_exec_fileno = open_inode(bprm->inode, O_RDONLY); - - if (elf_exec_fileno < 0) { - kfree (elf_phdata); - return elf_exec_fileno; - } - - file = current->files->fd[elf_exec_fileno]; - - elf_stack = 0xffffffff; - elf_interpreter = NULL; - start_code = 0; - end_code = 0; - end_data = 0; - - old_fs = get_fs(); - set_fs(get_ds()); - - for(i=0;i < elf_ex.e_phnum; i++){ - if(elf_ppnt->p_type == PT_INTERP) { - /* This is the program interpreter used for shared libraries - - for now assume that this is an a.out format binary */ - - elf_interpreter = (char *) kmalloc(elf_ppnt->p_filesz, - GFP_KERNEL); - - retval = read_exec(bprm->inode,elf_ppnt->p_offset,elf_interpreter, - elf_ppnt->p_filesz); -#if 0 - printk("Using ELF interpreter %s\n", elf_interpreter); -#endif - if(retval >= 0) - retval = namei(elf_interpreter, &interpreter_inode); - if(retval >= 0) - retval = read_exec(interpreter_inode,0,bprm->buf,128); - - if(retval >= 0){ - interp_ex = *((struct exec *) bprm->buf); /* exec-header */ - interp_elf_ex = *((struct elfhdr *) bprm->buf); /* exec-header */ - - }; - if(retval < 0) { - kfree (elf_phdata); - kfree(elf_interpreter); - return retval; - }; - }; - elf_ppnt++; - }; - - set_fs(old_fs); - - /* Some simple consistency checks for the interpreter */ - if(elf_interpreter){ - interpreter_type = INTERPRETER_ELF | INTERPRETER_AOUT; - if(retval < 0) { - kfree(elf_interpreter); - kfree(elf_phdata); - return -ELIBACC; - }; - /* Now figure out which format our binary is */ - if((N_MAGIC(interp_ex) != OMAGIC) && - (N_MAGIC(interp_ex) != ZMAGIC) && - (N_MAGIC(interp_ex) != QMAGIC)) - interpreter_type = INTERPRETER_ELF; - - if (interp_elf_ex.e_ident[0] != 0x7f || - strncmp(&interp_elf_ex.e_ident[1], "ELF",3) != 0) - interpreter_type &= ~INTERPRETER_ELF; - - if(!interpreter_type) - { - kfree(elf_interpreter); - kfree(elf_phdata); - return -ELIBBAD; - }; - } - - /* OK, we are done with that, now set up the arg stuff, - and then start this sucker up */ - - if (!bprm->sh_bang) { - char * passed_p; - - if(interpreter_type == INTERPRETER_AOUT) { - sprintf(passed_fileno, "%d", elf_exec_fileno); - passed_p = passed_fileno; - - if(elf_interpreter) { - bprm->p = copy_strings(1,&passed_p,bprm->page,bprm->p,2); - bprm->argc++; - }; - }; - if (!bprm->p) { - if(elf_interpreter) { - kfree(elf_interpreter); - } - kfree (elf_phdata); - return -E2BIG; - } - } - - /* OK, This is the point of no return */ - flush_old_exec(bprm); - - current->mm->end_data = 0; - current->mm->end_code = 0; - current->mm->start_mmap = ELF_START_MMAP; - current->mm->mmap = NULL; - elf_entry = (unsigned int) elf_ex.e_entry; - - /* Do this so that we can load the interpreter, if need be. We will - change some of these later */ - current->mm->rss = 0; - bprm->p += change_ldt(0, bprm->page); - current->mm->start_stack = bprm->p; - - /* Now we do a little grungy work by mmaping the ELF image into - the correct location in memory. At this point, we assume that - the image should be loaded at fixed address, not at a variable - address. */ - - old_fs = get_fs(); - set_fs(get_ds()); - - elf_ppnt = elf_phdata; - for(i=0;i < elf_ex.e_phnum; i++){ - - if(elf_ppnt->p_type == PT_INTERP) { - /* Set these up so that we are able to load the interpreter */ - /* Now load the interpreter into user address space */ - set_fs(old_fs); - - if(interpreter_type & 1) elf_entry = - load_aout_interp(&interp_ex, interpreter_inode); - - if(interpreter_type & 2) elf_entry = - load_elf_interp(&interp_elf_ex, interpreter_inode); - - old_fs = get_fs(); - set_fs(get_ds()); - - iput(interpreter_inode); - kfree(elf_interpreter); - - if(elf_entry == 0xffffffff) { - printk("Unable to load interpreter\n"); - kfree(elf_phdata); - send_sig(SIGSEGV, current, 0); - return 0; - }; - }; - - - if(elf_ppnt->p_type == PT_LOAD) { - error = do_mmap(file, - elf_ppnt->p_vaddr & 0xfffff000, - elf_ppnt->p_filesz + (elf_ppnt->p_vaddr & 0xfff), - PROT_READ | PROT_WRITE | PROT_EXEC, - MAP_FIXED | MAP_PRIVATE, - elf_ppnt->p_offset & 0xfffff000); - -#ifdef LOW_ELF_STACK - if(elf_ppnt->p_vaddr & 0xfffff000 < elf_stack) - elf_stack = elf_ppnt->p_vaddr & 0xfffff000; -#endif - - if(!load_addr) - load_addr = elf_ppnt->p_vaddr - elf_ppnt->p_offset; - k = elf_ppnt->p_vaddr; - if(k > start_code) start_code = k; - k = elf_ppnt->p_vaddr + elf_ppnt->p_filesz; - if(k > elf_bss) elf_bss = k; - if((elf_ppnt->p_flags | PROT_WRITE) && end_code < k) - end_code = k; - if(end_data < k) end_data = k; - k = elf_ppnt->p_vaddr + elf_ppnt->p_memsz; - if(k > elf_brk) elf_brk = k; - }; - elf_ppnt++; - }; - set_fs(old_fs); - - kfree(elf_phdata); - - if(!elf_interpreter) sys_close(elf_exec_fileno); - current->elf_executable = 1; - current->executable = bprm->inode; - bprm->inode->i_count++; -#ifdef LOW_ELF_STACK - current->start_stack = p = elf_stack - 4; -#endif - bprm->p -= MAX_ARG_PAGES*PAGE_SIZE; - bprm->p = (unsigned long) - create_elf_tables((char *)bprm->p, - bprm->argc, - bprm->envc, - (interpreter_type == INTERPRETER_ELF ? &elf_ex : NULL), - load_addr, - (interpreter_type == INTERPRETER_AOUT ? 0 : 1)); - if(interpreter_type == INTERPRETER_AOUT) - current->mm->arg_start += strlen(passed_fileno) + 1; - current->mm->start_brk = current->mm->brk = elf_brk; - current->mm->end_code = end_code; - current->mm->start_code = start_code; - current->mm->end_data = end_data; - current->mm->start_stack = bprm->p; - current->suid = current->euid = bprm->e_uid; - current->sgid = current->egid = bprm->e_gid; - - /* Calling sys_brk effectively mmaps the pages that we need for the bss and break - sections */ - current->mm->brk = (elf_bss + 0xfff) & 0xfffff000; - sys_brk((elf_brk + 0xfff) & 0xfffff000); - - padzero(elf_bss); - - /* Why this, you ask??? Well SVr4 maps page 0 as read-only, - and some applications "depend" upon this behavior. - Since we do not have the power to recompile these, we - emulate the SVr4 behavior. Sigh. */ - error = do_mmap(NULL, 0, 4096, PROT_READ | PROT_EXEC, - MAP_FIXED | MAP_PRIVATE, 0); - - regs->eip = elf_entry; /* eip, magic happens :-) */ - regs->esp = bprm->p; /* stack pointer */ - if (current->flags & PF_PTRACED) - send_sig(SIGTRAP, current, 0); - return 0; -} - -/* This is really simpleminded and specialized - we are loading an - a.out library that is given an ELF header. */ - -int load_elf_library(int fd){ - struct file * file; - struct elfhdr elf_ex; - struct elf_phdr *elf_phdata = NULL; - struct inode * inode; - unsigned int len; - int elf_bss; - int old_fs, retval; - unsigned int bss; - int error; - int i,j, k; - - len = 0; - file = current->files->fd[fd]; - inode = file->f_inode; - elf_bss = 0; - - set_fs(KERNEL_DS); - if (file->f_op->read(inode, file, (char *) &elf_ex, sizeof(elf_ex)) != sizeof(elf_ex)) { - sys_close(fd); - return -EACCES; - } - set_fs(USER_DS); - - if (elf_ex.e_ident[0] != 0x7f || - strncmp(&elf_ex.e_ident[1], "ELF",3) != 0) - return -ENOEXEC; - - /* First of all, some simple consistency checks */ - if(elf_ex.e_type != ET_EXEC || elf_ex.e_phnum > 2 || - (elf_ex.e_machine != EM_386 && elf_ex.e_machine != EM_486) || - (!inode->i_op || !inode->i_op->bmap || - !inode->i_op->default_file_ops->mmap)){ - return -ENOEXEC; - }; - - /* Now read in all of the header information */ - - if(sizeof(struct elf_phdr) * elf_ex.e_phnum > PAGE_SIZE) - return -ENOEXEC; - - elf_phdata = (struct elf_phdr *) - kmalloc(sizeof(struct elf_phdr) * elf_ex.e_phnum, GFP_KERNEL); - - old_fs = get_fs(); - set_fs(get_ds()); - retval = read_exec(inode, elf_ex.e_phoff, (char *) elf_phdata, - sizeof(struct elf_phdr) * elf_ex.e_phnum); - set_fs(old_fs); - - j = 0; - for(i=0; ip_type == PT_LOAD) j++; - - if(j != 1) { - kfree(elf_phdata); - return -ENOEXEC; - }; - - while(elf_phdata->p_type != PT_LOAD) elf_phdata++; - - /* Now use mmap to map the library into memory. */ - error = do_mmap(file, - elf_phdata->p_vaddr & 0xfffff000, - elf_phdata->p_filesz + (elf_phdata->p_vaddr & 0xfff), - PROT_READ | PROT_WRITE | PROT_EXEC, - MAP_FIXED | MAP_PRIVATE, - elf_phdata->p_offset & 0xfffff000); - - k = elf_phdata->p_vaddr + elf_phdata->p_filesz; - if(k > elf_bss) elf_bss = k; - - sys_close(fd); - if (error != elf_phdata->p_vaddr & 0xfffff000) { - kfree(elf_phdata); - return error; - } - - padzero(elf_bss); - - len = (elf_phdata->p_filesz + elf_phdata->p_vaddr+ 0xfff) & 0xfffff000; - bss = elf_phdata->p_memsz + elf_phdata->p_vaddr; - if (bss > len) - do_mmap(NULL, len, bss-len, - PROT_READ|PROT_WRITE|PROT_EXEC, - MAP_FIXED|MAP_PRIVATE, 0); - kfree(elf_phdata); - return 0; -} diff -u --recursive --new-file linux-1.1.55+new_quota+alpha/include/linux/autoconf.h linux/include/linux/autoconf.h --- linux-1.1.55+new_quota+alpha/include/linux/autoconf.h Thu Oct 20 17:09:32 1994 +++ linux/include/linux/autoconf.h Thu Oct 20 18:24:19 1994 @@ -12,8 +12,9 @@ #undef CONFIG_QUOTA #undef CONFIG_MAX_16M #define CONFIG_SYSVIPC 1 -#define CONFIG_BINFMT_ELF 1 #define CONFIG_M486 1 +#define CONFIG_BINFMT_ELF 1 +#define ALPHA_SLACK 1 /* * Networking options @@ -49,6 +50,9 @@ #define CONFIG_SCSI_AHA152X 1 #define CONFIG_SCSI_AHA1542 1 #define CONFIG_SCSI_AHA1740 1 +#define CONFIG_SCSI_AHA274X 1 +#undef CONFIG_SCSI_IN2000 +#undef CONFIG_SCSI_EATA #define CONFIG_SCSI_BUSLOGIC 1 #define CONFIG_SCSI_FUTURE_DOMAIN 1 #define CONFIG_SCSI_GENERIC_NCR5380 1 @@ -103,6 +107,8 @@ * CD-ROM drivers */ #undef CONFIG_CDU31A +#undef CONFIG_CDU535 +#undef CONFIG_NEC260 #undef CONFIG_MCD #undef CONFIG_SBPCD diff -u --recursive --new-file linux-1.1.55+new_quota+alpha/tools/version.h linux/tools/version.h --- linux-1.1.55+new_quota+alpha/tools/version.h Thu Oct 20 18:15:38 1994 +++ linux/tools/version.h Thu Oct 20 18:27:09 1994 @@ -1,6 +1,6 @@ -#define UTS_RELEASE "1.1.53" -#define UTS_VERSION "#8 Wed Oct 12 21:48:39 CDT 1994" -#define LINUX_COMPILE_TIME "21:48:39" +#define UTS_RELEASE "1.1.55" +#define UTS_VERSION "#1 Thu Oct 20 18:27:08 CDT 1994" +#define LINUX_COMPILE_TIME "18:27:08" #define LINUX_COMPILE_BY "root" #define LINUX_COMPILE_HOST "fuzzy" #define LINUX_COMPILE_DOMAIN "is.a.good.cat"