lostecho/oldlinux-files
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add directory Linux-0.95

Browse Source
This commit is contained in:
gohigh
2024-02-19 00:21:03 -05:00
parent 059f8848b1
commit b6d98600bf
139 changed files with 25302 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

856
Linux-0.95/patchs/cdiffs for 0.95a Normal file
View File

@@ -0,0 +1,856 @@
From: hedrick@dartagnan.rutgers.edu (Charles Hedrick)
Newsgroups: alt.os.linux
Subject: cdiffs for 0.95a from Linus for alpha testing
Message-ID: <Mar.21.19.15.22.1992.4251@dartagnan.rutgers.edu>
Date: 22 Mar 92 00:15:22 GMT
Organization: Rutgers Univ., New Brunswick, N.J.
Lines: 845
The following cdiffs come from Linus. He's had trouble getting
postings out. They are alpha -- only for people who like to test
things. They appear to fix some of the problems with multiple disks,
and some problems with serial lines. I can't be sure about that.
They do fix my problem with gdb getting "bad things happen".
If the posting from Linus shows up, the diffs in that posting
should be identical to these.
*** OLD/linux/kernel/chr_drv/console.c Fri Mar 13 00:37:07 1992
--- linux/kernel/chr_drv/console.c Thu Mar 19 21:15:03 1992
***************
*** 456,462 ****
p++;
}
sti();
! copy_to_cooked(tty);
}
static void insert_char(int currcons)
--- 456,462 ----
p++;
}
sti();
! TTY_READ_FLUSH(tty);
}
static void insert_char(int currcons)
***************
*** 823,829 ****
void do_keyboard_interrupt(void)
{
! copy_to_cooked(TTY_TABLE(0));
timer_active &= ~(1<<BLANK_TIMER);
if (console_blanked) {
timer_table[BLANK_TIMER].expires = 0;
--- 823,829 ----
void do_keyboard_interrupt(void)
{
! TTY_READ_FLUSH(TTY_TABLE(0));
timer_active &= ~(1<<BLANK_TIMER);
if (console_blanked) {
timer_table[BLANK_TIMER].expires = 0;
*** OLD/linux/kernel/chr_drv/tty_ioctl.c Thu Mar 12 23:51:41 1992
--- linux/kernel/chr_drv/tty_ioctl.c Thu Mar 19 21:27:07 1992
***************
*** 260,270 ****
switch (arg) {
case TCOOFF:
tty->stopped = 1;
! TTY_WRITE(tty);
return 0;
case TCOON:
tty->stopped = 0;
! TTY_WRITE(tty);
return 0;
case TCIOFF:
if (STOP_CHAR(tty))
--- 260,270 ----
switch (arg) {
case TCOOFF:
tty->stopped = 1;
! TTY_WRITE_FLUSH(tty);
return 0;
case TCOON:
tty->stopped = 0;
! TTY_WRITE_FLUSH(tty);
return 0;
case TCIOFF:
if (STOP_CHAR(tty))
*** OLD/linux/kernel/chr_drv/tty_io.c Tue Mar 17 22:46:46 1992
--- linux/kernel/chr_drv/tty_io.c Thu Mar 19 21:27:07 1992
***************
*** 129,141 ****
printk("copy_to_cooked: missing queues\n\r");
return;
}
- cli();
- if (tty->busy) {
- sti();
- return;
- }
- tty->busy = 1;
- sti();
while (1) {
if (EMPTY(tty->read_q))
break;
--- 129,134 ----
***************
*** 232,242 ****
PUTCH(c,tty->write_q);
}
PUTCH(c,tty->secondary);
}
- tty->write(tty);
- tty->busy = 0;
if (!EMPTY(tty->secondary))
wake_up(&tty->secondary->proc_list);
}
/*
--- 225,236 ----
PUTCH(c,tty->write_q);
}
PUTCH(c,tty->secondary);
+ TTY_WRITE_FLUSH(tty);
}
if (!EMPTY(tty->secondary))
wake_up(&tty->secondary->proc_list);
+ if (LEFT(tty->write_q) > TTY_BUF_SIZE/2)
+ wake_up(&tty->write_q->proc_list);
}
/*
***************
*** 305,314 ****
time = current->timeout = 0;
if (minimum>nr)
minimum = nr;
! copy_to_cooked(tty);
while (nr>0) {
if (other_tty && other_tty->write)
! TTY_WRITE(other_tty);
cli();
if (EMPTY(tty->secondary) || (L_CANON(tty) &&
!FULL(tty->read_q) && !tty->secondary->data)) {
--- 299,308 ----
time = current->timeout = 0;
if (minimum>nr)
minimum = nr;
! TTY_READ_FLUSH(tty);
while (nr>0) {
if (other_tty && other_tty->write)
! TTY_WRITE_FLUSH(other_tty);
cli();
if (EMPTY(tty->secondary) || (L_CANON(tty) &&
!FULL(tty->read_q) && !tty->secondary->data)) {
***************
*** 320,326 ****
break;
interruptible_sleep_on(&tty->secondary->proc_list);
sti();
! copy_to_cooked(tty);
continue;
}
sti();
--- 314,320 ----
break;
interruptible_sleep_on(&tty->secondary->proc_list);
sti();
! TTY_READ_FLUSH(tty);
continue;
}
sti();
***************
*** 398,404 ****
cr_flag = 0;
PUTCH(c,tty->write_q);
}
! TTY_WRITE(tty);
if (nr>0)
schedule();
}
--- 392,398 ----
cr_flag = 0;
PUTCH(c,tty->write_q);
}
! TTY_WRITE_FLUSH(tty);
if (nr>0)
schedule();
}
*** OLD/linux/kernel/chr_drv/serial.c Sat Mar 14 20:16:21 1992
--- linux/kernel/chr_drv/serial.c Thu Mar 19 21:15:03 1992
***************
*** 26,47 ****
static void com1_timer(void)
{
! copy_to_cooked(tty_table+64);
}
static void com2_timer(void)
{
! copy_to_cooked(tty_table+65);
}
static void com3_timer(void)
{
! copy_to_cooked(tty_table+66);
}
static void com4_timer(void)
{
! copy_to_cooked(tty_table+67);
}
static inline void do_rs_write(unsigned int port)
--- 26,47 ----
static void com1_timer(void)
{
! TTY_READ_FLUSH(tty_table+64);
}
static void com2_timer(void)
{
! TTY_READ_FLUSH(tty_table+65);
}
static void com3_timer(void)
{
! TTY_READ_FLUSH(tty_table+66);
}
static void com4_timer(void)
{
! TTY_READ_FLUSH(tty_table+67);
}
static inline void do_rs_write(unsigned int port)
*** OLD/linux/kernel/chr_drv/pty.c Sat Jan 11 01:56:45 1992
--- linux/kernel/chr_drv/pty.c Thu Mar 19 21:15:03 1992
***************
*** 25,31 ****
if (FULL(to->read_q)) {
if (FULL(to->secondary))
break;
! copy_to_cooked(to);
continue;
}
GETCH(from->write_q,c);
--- 25,31 ----
if (FULL(to->read_q)) {
if (FULL(to->secondary))
break;
! TTY_READ_FLUSH(to);
continue;
}
GETCH(from->write_q,c);
***************
*** 33,39 ****
if (current->signal & ~current->blocked)
break;
}
! copy_to_cooked(to);
wake_up(&from->write_q->proc_list);
}
--- 33,39 ----
if (current->signal & ~current->blocked)
break;
}
! TTY_READ_FLUSH(to);
wake_up(&from->write_q->proc_list);
}
*** OLD/linux/kernel/blk_drv/hd.c Sun Mar 15 20:46:53 1992
--- linux/kernel/blk_drv/hd.c Fri Mar 20 00:20:49 1992
***************
*** 82,88 ****
--- 82,90 ----
int minor, i;
struct buffer_head *bh;
struct partition *p;
+ unsigned long first_sector;
+ first_sector = hd[MINOR(dev)].start_sect;
if (!(bh = bread(dev,0))) {
printk("Unable to read partition table of device %04x\n",dev);
return;
***************
*** 93,99 ****
for (i=0 ; i<4 ; i++,p++) {
if (!(hd[i+minor].nr_sects = p->nr_sects))
continue;
! hd[i+minor].start_sect = p->start_sect;
if ((current_minor & 0x3f) >= 60)
continue;
if (p->sys_ind == EXTENDED_PARTITION) {
--- 95,101 ----
for (i=0 ; i<4 ; i++,p++) {
if (!(hd[i+minor].nr_sects = p->nr_sects))
continue;
! hd[i+minor].start_sect = first_sector + p->start_sect;
if ((current_minor & 0x3f) >= 60)
continue;
if (p->sys_ind == EXTENDED_PARTITION) {
***************
*** 141,156 ****
hd_info[drive].sect = *(unsigned char *) (14+BIOS);
BIOS += 16;
}
- if (hd_info[1].cyl)
- NR_HD=2;
- else
- NR_HD=1;
- #endif
- for (i=0 ; i<NR_HD ; i++) {
- hd[i<<6].start_sect = 0;
- hd[i<<6].nr_sects = hd_info[i].head*
- hd_info[i].sect*hd_info[i].cyl;
- }
/*
We querry CMOS about hard disks : it could be that
--- 143,148 ----
***************
*** 181,190 ****
NR_HD = 1;
else
NR_HD = 0;
! for (i = NR_HD ; i < 2 ; i++) {
! hd[i<<6].start_sect = 0;
! hd[i<<6].nr_sects = 0;
}
for (drive=0 ; drive<NR_HD ; drive++) {
current_minor = 1+(drive<<6);
check_partition(0x0300+(drive<<6));
--- 173,186 ----
NR_HD = 1;
else
NR_HD = 0;
! #endif
! for (i = 0 ; i < (MAX_HD<<6) ; i++) {
! hd[i].start_sect = 0;
! hd[i].nr_sects = 0;
}
+ for (i = 0 ; i < NR_HD ; i++)
+ hd[i<<6].nr_sects = hd_info[i].head*
+ hd_info[i].sect*hd_info[i].cyl;
for (drive=0 ; drive<NR_HD ; drive++) {
current_minor = 1+(drive<<6);
check_partition(0x0300+(drive<<6));
*** OLD/linux/kernel/ptrace.c Tue Mar 17 23:38:37 1992
--- linux/kernel/ptrace.c Thu Mar 19 23:49:42 1992
***************
*** 22,30 ****
/* set's the trap flag. */
#define TRAP_FLAG 0x100
- /* check's for granularity. */
- #define GRANULARITY 0x00800000
-
/*
* this is the number to subtract from the top of the stack. To find
* the local frame.
--- 22,27 ----
***************
*** 51,58 ****
* the offset is how far from the base addr as stored in the TSS.
* this routine assumes that all the priviledged stacks are in our
* data space.
! */
!
static inline int get_stack_long(struct task_struct *task, int offset)
{
unsigned char *stack;
--- 48,54 ----
* the offset is how far from the base addr as stored in the TSS.
* this routine assumes that all the priviledged stacks are in our
* data space.
! */
static inline int get_stack_long(struct task_struct *task, int offset)
{
unsigned char *stack;
***************
*** 69,213 ****
* data space.
*/
static inline int put_stack_long(struct task_struct *task, int offset,
! unsigned short data)
{
unsigned char * stack;
stack = (unsigned char *) task->tss.esp0;
stack += offset;
! *(int *) stack = data;
return 0;
}
/*
! * this routine will get a word out of an arbitrary
! * tasks data space. It likes to have the task number
! * rather than the task pointer. Perhaps the number
! * should be included in the pointer.
*/
! /* seg = 0 if I space */
! static inline int get_long(int tsk, long addr, unsigned seg, int *data)
{
- int i;
- int limit;
- int cur;
- unsigned long address;
unsigned long page;
- unsigned oldfs;
! /* find the task number of the current task. */
! for (i = 0; i < NR_TASKS ; i ++) {
! if (task[i] == current) break;
}
- if (i == NR_TASKS) {
- printk("PTRACE: Can't find current task\n");
- do_exit(SIGSEGV);
- }
- cur = i;
-
- /* we will need to check the readability of the segment
- and then the byte in order to avoid segment violations. */
- seg++;
- limit = (task[tsk]->ldt[seg].a) & 0xffff;
- /* this should be constant amound all of our segments, but we
- had better check anyway. */
- if (task[tsk]->ldt[seg].b & GRANULARITY)
- limit = limit << 12;
-
- if (limit <= addr+4)
- return -EIO;
-
- /* Now compute the address, and make sure that it is present. */
- address = task[tsk]->start_code + addr;
-
- page = *((unsigned long*) ((address >> 20) & 0xffc));
- /* see if it is present. */
if (!(page & PAGE_PRESENT)) {
! do_no_page(0, address, task[tsk]);
}
!
! oldfs = get_fs();
! /* now convert seg to the right format. */
! seg = (seg << 3) | 0x4;
!
! cli(); /* we are about to change our ldt, we better do it
! with interrupts off. Perhaps we should call schedule
! first so that we won't be taking too much extra time. */
! lldt(tsk);
! set_fs(seg);
! *data = get_fs_long((void *)addr); /* we are assuming kernel space
! is in the gdt here. */
! lldt(cur);
! set_fs(oldfs);
! sti();
! return 0;
}
/*
! * this routine will get a word out of an arbitrary
! * tasks data space. It likes to have the task number
! * rather than the task pointer. Perhaps the number
! * should be included in the pointer.
*/
! /* seg = 0 if I space */
! static inline int put_long(int tsk, long addr, int data, unsigned seg)
{
- int i;
- int limit;
- unsigned oldfs;
- unsigned long address;
unsigned long page;
- int cur;
! /* find the task number of the current task. */
! for (i = 0; i < NR_TASKS ; i++) {
! if (task[i] == current) break;
}
! if (i == NR_TASKS) {
! printk("PTRACE: Can't find current task\n");
! do_exit(SIGSEGV);
}
! cur = i;
! /* we will need to check the readability of the segment
! and then the byte in order to avoid segment violations. */
! seg++;
! limit = (task[tsk]->ldt[seg].a) & 0xffff;
! /* this should be constant amound all of our segments, but we
! had better check anyway. */
! if (task[tsk]->ldt[seg].b & GRANULARITY)
! limit = limit << 12;
! if (limit <= addr+4)
return -EIO;
! /* Now compute the address, and make sure that it is present. */
! address = task[tsk]->start_code + addr;
! page = *((unsigned long*) ((address >> 20) & 0xffc));
! /* see if it is present. */
! if (!(page & PAGE_PRESENT)) {
! do_no_page(0, address, task[tsk]);
! }
! write_verify(address);
!
! oldfs=get_fs();
! /* now convert seg to the right format. */
! seg = (seg << 3) | 0x4;
!
! cli(); /* we are about to change our ldt, we better do it
! with interrupts off. Perhaps we should call schedule
! first so that we won't be taking too much extra time. */
! lldt(tsk);
! set_fs(seg);
! put_fs_long(data,(void *)addr);
! lldt(cur);
! set_fs(oldfs);
! sti();
return 0;
}
-
/* Perform ptrace(request, pid, addr, data) syscall */
int sys_ptrace(unsigned long *buffer)
{
--- 65,223 ----
* data space.
*/
static inline int put_stack_long(struct task_struct *task, int offset,
! unsigned long data)
{
unsigned char * stack;
stack = (unsigned char *) task->tss.esp0;
stack += offset;
! *(unsigned long *) stack = data;
return 0;
}
/*
! * This routine gets a long from any process space by following the page
! * tables. NOTE! You should check that the long isn't on a page boundary,
! * and that it is in the task area before calling this: this routine does
! * no checking.
! *
! * NOTE2! This uses "tsk->tss.cr3" even though we know it's currently always
! * zero. This routine shouldn't have to change when we make a better mm.
*/
! static unsigned long get_long(struct task_struct * tsk,
! unsigned long addr)
{
unsigned long page;
! addr += tsk->start_code;
! repeat:
! page = tsk->tss.cr3 + ((addr >> 20) & 0xffc);
! page = *(unsigned long *) page;
! if (page & PAGE_PRESENT) {
! page &= 0xfffff000;
! page += (addr >> 10) & 0xffc;
! page = *((unsigned long *) page);
}
if (!(page & PAGE_PRESENT)) {
! do_no_page(0,addr,tsk);
! goto repeat;
}
! page &= 0xfffff000;
! page += addr & 0xfff;
! return *(unsigned long *) page;
}
/*
! * This routine puts a long into any process space by following the page
! * tables. NOTE! You should check that the long isn't on a page boundary,
! * and that it is in the task area before calling this: this routine does
! * no checking.
*/
! static void put_long(struct task_struct * tsk, unsigned long addr,
! unsigned long data)
{
unsigned long page;
! addr += tsk->start_code;
! repeat:
! page = tsk->tss.cr3 + ((addr >> 20) & 0xffc);
! page = *(unsigned long *) page;
! if (page & PAGE_PRESENT) {
! page &= 0xfffff000;
! page += (addr >> 10) & 0xffc;
! page = *((unsigned long *) page);
}
! if (!(page & PAGE_PRESENT)) {
! do_no_page(0,addr,tsk);
! goto repeat;
}
! if (!(page & PAGE_RW)) {
! write_verify(addr);
! goto repeat;
! }
! page &= 0xfffff000;
! page += addr & 0xfff;
! *(unsigned long *) page = data;
! }
! /*
! * This routine checks the page boundaries, and that the offset is
! * within the task area. It then calls get_long() to read a long.
! */
! static int read_long(struct task_struct * tsk, unsigned long addr,
! unsigned long * result)
! {
! unsigned long low,high;
! if (addr > TASK_SIZE-4)
return -EIO;
+ if ((addr & 0xfff) > PAGE_SIZE-4) {
+ low = get_long(tsk,addr & 0xfffffffc);
+ high = get_long(tsk,(addr+4) & 0xfffffffc);
+ switch (addr & 3) {
+ case 1:
+ low >>= 8;
+ low |= high << 24;
+ break;
+ case 2:
+ low >>= 16;
+ low |= high << 16;
+ break;
+ case 3:
+ low >>= 16;
+ low |= high << 16;
+ break;
+ }
+ *result = low;
+ } else
+ *result = get_long(tsk,addr);
+ return 0;
+ }
! /*
! * This routine checks the page boundaries, and that the offset is
! * within the task area. It then calls put_long() to write a long.
! */
! static int write_long(struct task_struct * tsk, unsigned long addr,
! unsigned long data)
! {
! unsigned long low,high;
! if (addr > TASK_SIZE-4)
! return -EIO;
! if ((addr & 0xfff) > PAGE_SIZE-4) {
! low = get_long(tsk,addr & 0xfffffffc);
! high = get_long(tsk,(addr+4) & 0xfffffffc);
! switch (addr & 3) {
! case 0: /* shouldn't happen, but safety first */
! low = data;
! break;
! case 1:
! low &= 0x000000ff;
! low |= data << 8;
! high &= 0xff000000;
! high |= data >> 8;
! break;
! case 2:
! low &= 0x0000ffff;
! low |= data << 16;
! high &= 0xffff0000;
! high |= data >> 16;
! break;
! case 3:
! low &= 0x00ffffff;
! low |= data << 24;
! high &= 0xffffff00;
! high |= data >> 24;
! break;
! }
! put_long(tsk,addr & 0xfffffffc,low);
! put_long(tsk,(addr+4) & 0xfffffffc,high);
! } else
! put_long(tsk,addr,data);
return 0;
}
/* Perform ptrace(request, pid, addr, data) syscall */
int sys_ptrace(unsigned long *buffer)
{
***************
*** 244,250 ****
case 2: {
int tmp,res;
! res = get_long(childno, addr, 1, &tmp);
if (res < 0)
return res;
verify_area((void *) data, 4);
--- 254,260 ----
case 2: {
int tmp,res;
! res = read_long(task[childno], addr, &tmp);
if (res < 0)
return res;
verify_area((void *) data, 4);
***************
*** 267,280 ****
/* when I and D space are seperate, this will have to be fixed. */
case 4: /* write the word at location addr. */
case 5:
! if (put_long(childno, addr, data, 1))
! return -EIO;
! return 0;
case 6: /* write the word at location addr in the USER area */
addr = addr >> 2; /* temproary hack. */
if (addr < 0 || addr >= 17)
! return -EIO;
if (addr == ORIG_EAX)
return -EIO;
if (addr == EFL) { /* flags. */
--- 277,288 ----
/* when I and D space are seperate, this will have to be fixed. */
case 4: /* write the word at location addr. */
case 5:
! return write_long(task[childno],addr,data);
case 6: /* write the word at location addr in the USER area */
addr = addr >> 2; /* temproary hack. */
if (addr < 0 || addr >= 17)
! return -EIO;
if (addr == ORIG_EAX)
return -EIO;
if (addr == EFL) { /* flags. */
***************
*** 281,287 ****
data &= FLAG_MASK;
data |= get_stack_long(child, EFL*4-MAGICNUMBER) & ~FLAG_MASK;
}
-
if (put_stack_long(child, 4*addr-MAGICNUMBER, data))
return -EIO;
return 0;
--- 289,294 ----
*** OLD/linux/mm/memory.c Tue Mar 17 22:35:13 1992
--- linux/mm/memory.c Thu Mar 19 23:19:03 1992
***************
*** 429,436 ****
return 0;
}
! void do_no_page(unsigned long error_code,
! unsigned long address, struct task_struct *tsk)
{
static unsigned int last_checked = 0;
int nr[4];
--- 429,436 ----
return 0;
}
! void do_no_page(unsigned long error_code, unsigned long address,
! struct task_struct *tsk)
{
static unsigned int last_checked = 0;
int nr[4];
***************
*** 439,445 ****
int block,i;
struct inode * inode;
! /* Trashing ? Make it interruptible, but don't penalize otherwise */
for (i = 0; i < CHECK_LAST_NR; i++)
if ((address & 0xfffff000) == last_pages[i]) {
current->counter = 0;
--- 439,445 ----
int block,i;
struct inode * inode;
! /* Thrashing ? Make it interruptible, but don't penalize otherwise */
for (i = 0; i < CHECK_LAST_NR; i++)
if ((address & 0xfffff000) == last_pages[i]) {
current->counter = 0;
***************
*** 492,499 ****
return;
}
if (tsk == current)
! if (share_page(inode,tmp))
! return;
if (!(page = get_free_page()))
oom();
/* remember that 1 block is used for header */
--- 492,499 ----
return;
}
if (tsk == current)
! if (share_page(inode,tmp))
! return;
if (!(page = get_free_page()))
oom();
/* remember that 1 block is used for header */
*** OLD/linux/include/linux/tty.h Sun Mar 15 02:43:54 1992
--- linux/include/linux/tty.h Thu Mar 19 21:16:26 1992
***************
*** 68,83 ****
struct tty_queue *secondary;
};
! #define TTY_WRITE(tty) \
do { \
cli(); \
! if (!(tty)->busy) { \
! (tty)->busy = 1; \
sti(); \
(tty)->write((tty)); \
! (tty)->busy = 0; \
! } else \
sti(); \
} while (0)
extern struct tty_struct tty_table[];
--- 68,105 ----
struct tty_queue *secondary;
};
! /*
! * so that interrupts won't be able to mess up the
! * queues, copy_to_cooked must be atomic with repect
! * to itself, as must tty->write.
! */
! #define TTY_WRITE_BUSY 1
! #define TTY_READ_BUSY 2
!
! #define TTY_WRITE_FLUSH(tty) \
do { \
cli(); \
! if (!EMPTY((tty)->write_q) && !(TTY_WRITE_BUSY & (tty)->busy)) { \
! (tty)->busy |= TTY_WRITE_BUSY; \
sti(); \
(tty)->write((tty)); \
! cli(); \
! (tty)->busy &= ~TTY_WRITE_BUSY; \
! } \
! sti(); \
! } while (0)
!
! #define TTY_READ_FLUSH(tty) \
! do { \
! cli(); \
! if (!EMPTY((tty)->read_q) && !(TTY_READ_BUSY & (tty)->busy)) { \
! (tty)->busy |= TTY_READ_BUSY; \
sti(); \
+ copy_to_cooked((tty)); \
+ cli(); \
+ (tty)->busy &= ~TTY_READ_BUSY; \
+ } \
+ sti(); \
} while (0)
extern struct tty_struct tty_table[];