home *** CD-ROM | disk | FTP | other *** search
/ DP Tool Club 26 / CD_ASCQ_26_1295.iso / vrac / ptch1331.zip / PTCH1331.GZ / PTCH1331
Text File  |  1995-10-04  |  219KB  |  7,552 lines
  1. diff -u --recursive --new-file v1.3.30/linux/CREDITS linux/CREDITS
  2. --- v1.3.30/linux/CREDITS    Sat Sep  9 15:26:50 1995
  3. +++ linux/CREDITS    Wed Sep 27 15:57:55 1995
  4. @@ -648,7 +648,7 @@
  5.  S: USA
  6.  
  7.  N: Rick Miller
  8. -E: rick@discus.mil.wi.us
  9. +E: rick@digalogsys.com
  10.  D: Linux Device Registrar (Major/minor numbers), "au-play", "bwBASIC"
  11.  S: S78 W16203 Woods Road
  12.  S: Muskego, Wisconsin 53150
  13. @@ -753,7 +753,6 @@
  14.  N: Ken Pizzini
  15.  E: ken@halcyon.com
  16.  D: CDROM driver "sonycd535" (Sony CDU-535/531)
  17. -S: 
  18.  
  19.  N: Frederic Potter 
  20.  E: Frederic.Potter@masi.ibp.fr 
  21. diff -u --recursive --new-file v1.3.30/linux/Documentation/SMP.txt linux/Documentation/SMP.txt
  22. --- v1.3.30/linux/Documentation/SMP.txt    Thu Jan  1 02:00:00 1970
  23. +++ linux/Documentation/SMP.txt    Mon Oct  2 14:25:09 1995
  24. @@ -0,0 +1,38 @@
  25. +
  26. +SMP support for Linux with up to 32 processors using the Intel MP
  27. +specification. 
  28. +
  29. +WARNING:
  30. +    This is experimental. Back up your disks first. Build only
  31. +with gcc2.5.8.
  32. +
  33. +
  34. +To fix:
  35. +
  36. +o    Fix sys_idle to exit/enter kernel state and do hlt's.
  37. +o    Fix scheduler decisions to reschedule. Per cpu reschedule ?
  38. +o    Scheduler ignores stick to CPU advantage. Critical for P6!
  39. +o    FPU state save/restore - fault any process on FPU and do a
  40. +    restore on the fault each context switch, do a save if we
  41. +    faulted that run of the task when we switch away. [DONE]
  42. +o    Clean up message pass.
  43. +o    Test for B stepping processors.
  44. +o    Clean up processor specific/independant split.
  45. +o    Document it all.    [PARTLY DONE]
  46. +o    Find the exception/crash bug.
  47. +o    Halt other CPU's on reset/panic doesn't always work.
  48. +o    Dont waste page at 4K - dont need it now.(watch the GDT code).
  49. +o    Dump bootup pages once booted somehow.
  50. +o    Verify message pass safe for >2 CPU's - should be now it
  51. +    is atomic lock based.
  52. +o    Dont schedule switches between idle tasks (if current->pid==0 &&
  53. +    next->pid==0 && next!=current)    [IN]
  54. +o    Clean up warnings/volatiles.
  55. +o    Send CTRL-ALT-DEL to pid 1 not task[1]!    [IN]
  56. +o    Fix load_TR() for non contiguous processor ids
  57. +o    Iterate over the slave timer requests if one is lost (keep a count per cpu)
  58. +o    Distribute irq's (locking present just needs the 82489 to be asked
  59. +    nicely).
  60. +o    486 startup code.
  61. +o    How to handle mixed FPU/non FPU processors.
  62. +o    Support 4Mb page mode again
  63. diff -u --recursive --new-file v1.3.30/linux/Makefile linux/Makefile
  64. --- v1.3.30/linux/Makefile    Wed Sep 27 15:59:56 1995
  65. +++ linux/Makefile    Wed Sep 27 15:57:12 1995
  66. @@ -1,6 +1,6 @@
  67.  VERSION = 1
  68.  PATCHLEVEL = 3
  69. -SUBLEVEL = 30
  70. +SUBLEVEL = 31
  71.  
  72.  ARCH = i386
  73.  
  74. diff -u --recursive --new-file v1.3.30/linux/arch/alpha/kernel/entry.S linux/arch/alpha/kernel/entry.S
  75. --- v1.3.30/linux/arch/alpha/kernel/entry.S    Wed Sep 13 12:45:29 1995
  76. +++ linux/arch/alpha/kernel/entry.S    Sat Sep 30 10:59:41 1995
  77. @@ -590,7 +590,7 @@
  78.      .quad sys_setsockopt, sys_listen, do_entSys, do_entSys, do_entSys
  79.      .quad do_entSys, sys_sigsuspend, do_entSys, do_entSys, do_entSys
  80.      .quad do_entSys, sys_gettimeofday, sys_getrusage, sys_getsockopt, do_entSys
  81. -    .quad do_entSys, do_entSys, sys_settimeofday, sys_fchown, sys_fchmod
  82. +    .quad sys_readv, sys_writev, sys_settimeofday, sys_fchown, sys_fchmod
  83.      .quad sys_recvfrom, sys_setreuid, sys_setregid, sys_rename, sys_truncate
  84.      .quad sys_ftruncate, do_entSys, sys_setgid, sys_sendto, sys_shutdown
  85.      .quad sys_socketpair, sys_mkdir, sys_rmdir, sys_utimes, do_entSys
  86. @@ -629,6 +629,6 @@
  87.  /* linux-specific system calls start at 300 */
  88.  /*300*/    .quad sys_bdflush, sys_sethae, sys_mount, sys_adjtimex, sys_swapoff
  89.      .quad sys_getdents, sys_create_module, sys_init_module, sys_delete_module, sys_get_kernel_syms
  90. -    .quad sys_syslog, sys_reboot, sys_clone, do_entSys, do_entSys
  91. +    .quad sys_syslog, sys_reboot, sys_clone, sys_uselib, do_entSys
  92.      .quad do_entSys, do_entSys, do_entSys, do_entSys, do_entSys
  93.  
  94. diff -u --recursive --new-file v1.3.30/linux/arch/alpha/kernel/irq.c linux/arch/alpha/kernel/irq.c
  95. --- v1.3.30/linux/arch/alpha/kernel/irq.c    Wed Sep 27 15:59:56 1995
  96. +++ linux/arch/alpha/kernel/irq.c    Wed Oct  4 07:44:44 1995
  97. @@ -24,6 +24,8 @@
  98.  #include <asm/bitops.h>
  99.  #include <asm/dma.h>
  100.  
  101. +extern void timer_interrupt(struct pt_regs * regs);
  102. +
  103.  static unsigned char cache_21 = 0xff;
  104.  static unsigned char cache_A1 = 0xff;
  105.  
  106. @@ -223,6 +225,9 @@
  107.  
  108.      if (irq >= NR_IRQS)
  109.          return -EINVAL;
  110. +    /* don't accept requests for irq #0 */
  111. +    if (!irq)
  112. +        return -EINVAL;
  113.      action = irq + irq_action;
  114.      if (action->handler)
  115.          return -EBUSY;
  116. @@ -282,12 +287,16 @@
  117.          if (irq_action[i].handler)
  118.              printk("[%s:%d] ", irq_action[i].name, i);
  119.      printk("\n");
  120. +#if defined(CONFIG_ALPHA_JENSEN)
  121.      printk("64=%02x, 60=%02x, 3fa=%02x 2fa=%02x\n",
  122.          inb(0x64), inb(0x60), inb(0x3fa), inb(0x2fa));
  123.      outb(0x0c, 0x3fc);
  124.      outb(0x0c, 0x2fc);
  125.      outb(0,0x61);
  126.      outb(0,0x461);
  127. +#elif defined(CONFIG_ALPHA_NONAME)
  128. +    printk("61=%02x, 64=%02x, 60=%02x\n", inb(0x61), inb(0x64), inb(0x60));
  129. +#endif
  130.  }
  131.  
  132.  static inline void handle_irq(int irq, struct pt_regs * regs)
  133. @@ -563,8 +572,7 @@
  134.              printk("Interprocessor interrupt? You must be kidding\n");
  135.              break;
  136.          case 1:
  137. -            /* timer interrupt.. */
  138. -            handle_irq(0, ®s);
  139. +            timer_interrupt(®s);
  140.              return;
  141.          case 2:
  142.              machine_check(vector, la_ptr, ®s);
  143. diff -u --recursive --new-file v1.3.30/linux/arch/alpha/kernel/lca.c linux/arch/alpha/kernel/lca.c
  144. --- v1.3.30/linux/arch/alpha/kernel/lca.c    Sun Sep  3 12:26:48 1995
  145. +++ linux/arch/alpha/kernel/lca.c    Mon Oct  2 08:21:06 1995
  146. @@ -290,6 +290,9 @@
  147.      printk("esr=%lx, ear=%lx, ioc_stat0=%lx, ioc_stat1=%lx\n",
  148.             *(unsigned long*)LCA_MEM_ESR, *(unsigned long*)LCA_MEM_EAR,
  149.             *(unsigned long*)LCA_IOC_STAT0, *(unsigned long*)LCA_IOC_STAT1);
  150. +#ifdef CONFIG_ALPHA_NONAME
  151. +    printk("NMMI status & control (0x61)=%02x\n", inb(0x61));
  152. +#endif
  153.  }
  154.  
  155.  #endif /* CONFIG_ALPHA_LCA */
  156. diff -u --recursive --new-file v1.3.30/linux/arch/alpha/kernel/time.c linux/arch/alpha/kernel/time.c
  157. --- v1.3.30/linux/arch/alpha/kernel/time.c    Wed Sep 27 15:59:56 1995
  158. +++ linux/arch/alpha/kernel/time.c    Wed Oct  4 07:43:36 1995
  159. @@ -32,7 +32,7 @@
  160.   * timer_interrupt() needs to keep up the real-time clock,
  161.   * as well as call the "do_timer()" routine every clocktick
  162.   */
  163. -static void timer_interrupt(int irq, struct pt_regs * regs)
  164. +void timer_interrupt(struct pt_regs * regs)
  165.  {
  166.      /* last time the cmos clock got updated */
  167.      static long last_rtc_update=0;
  168. @@ -130,8 +130,6 @@
  169.          year += 100;
  170.      xtime.tv_sec = mktime(year, mon, day, hour, min, sec);
  171.      xtime.tv_usec = 0;
  172. -    if (request_irq(TIMER_IRQ, timer_interrupt, 0, "timer") != 0)
  173. -        panic("Could not allocate timer IRQ!");
  174.  }
  175.  
  176.  /*
  177. diff -u --recursive --new-file v1.3.30/linux/arch/i386/Makefile linux/arch/i386/Makefile
  178. --- v1.3.30/linux/arch/i386/Makefile    Fri Jul  7 08:54:44 1995
  179. +++ linux/arch/i386/Makefile    Mon Oct  2 15:12:14 1995
  180. @@ -91,6 +91,7 @@
  181.  
  182.  archclean:
  183.      @$(MAKEBOOT) clean
  184. +    $(MAKE) -C arch/$(ARCH)/kernel clean
  185.  
  186.  archdep:
  187.      @$(MAKEBOOT) dep
  188. diff -u --recursive --new-file v1.3.30/linux/arch/i386/boot/compressed/head.S linux/arch/i386/boot/compressed/head.S
  189. --- v1.3.30/linux/arch/i386/boot/compressed/head.S    Thu Jun 29 19:02:39 1995
  190. +++ linux/arch/i386/boot/compressed/head.S    Mon Oct  2 14:25:09 1995
  191. @@ -9,7 +9,12 @@
  192.   *
  193.   * NOTE!!! Startup happens at absolute address 0x00001000, which is also where
  194.   * the page directory will exist. The startup code will be overwritten by
  195. - * the page directory.
  196. + * the page directory. [According to comments etc elsewhere on a compressed
  197. + * kernel it will end up at 0x1000 + 1Mb I hope so as I assume this. - AC]
  198. + *
  199. + * In SMP mode we keep this page safe. Really we ought to shuffle things and
  200. + * put the trampoline here. - AC. An SMP trampoline enters with %cx holding
  201. + * the stack base.
  202.   *
  203.   * Page 0 is deliberately kept safe, since System Management Mode code in 
  204.   * laptops may need to access the BIOS data stored there.  This is also
  205. @@ -19,10 +24,12 @@
  206.  .text
  207.  
  208.  #define __ASSEMBLY__
  209. +#include <linux/config.h>
  210.  #include <linux/linkage.h>
  211.  #include <asm/segment.h>
  212.  
  213.      .globl startup_32
  214. +    
  215.  startup_32:
  216.      cld
  217.      cli
  218. @@ -31,6 +38,24 @@
  219.      mov %ax,%es
  220.      mov %ax,%fs
  221.      mov %ax,%gs
  222. +#ifdef CONFIG_SMP
  223. +    orw %bx,%bx            # What state are we in BX=1 for SMP
  224. +                    # 0 for boot
  225. +    jz  2f                # Initial boot
  226. +
  227. +/*
  228. + *    We are trampolining an SMP processor
  229. + */
  230. +    mov %ax,%ss
  231. +    xorl %eax,%eax            # Back to 0
  232. +    mov  %cx,%ax            # SP low 16 bits
  233. +    movl %eax,%esp
  234. +    pushl 0                # Clear NT
  235. +    popfl
  236. +    ljmp $(KERNEL_CS), $0x100000    # Into C and sanity
  237. +
  238. +2:
  239. +#endif
  240.      lss SYMBOL_NAME(stack_start),%esp
  241.      xorl %eax,%eax
  242.  1:    incl %eax        # check that A20 really IS enabled
  243. @@ -58,4 +83,6 @@
  244.   * Do the decompression, and jump to the new kernel..
  245.   */
  246.      call SYMBOL_NAME(decompress_kernel)
  247. +    xorl %ebx,%ebx
  248.      ljmp $(KERNEL_CS), $0x100000
  249. +
  250. diff -u --recursive --new-file v1.3.30/linux/arch/i386/boot/setup.S linux/arch/i386/boot/setup.S
  251. --- v1.3.30/linux/arch/i386/boot/setup.S    Tue Jun 20 09:10:31 1995
  252. +++ linux/arch/i386/boot/setup.S    Mon Oct  2 14:25:09 1995
  253. @@ -344,6 +344,7 @@
  254.      lmsw    ax        ! This is it!
  255.      jmp    flush_instr
  256.  flush_instr:
  257. +    mov    bx,#0        ! Flag to indicate a boot
  258.      jmpi    0x1000,KERNEL_CS    ! jmp offset 1000 of segment 0x10 (cs)
  259.  
  260.  ! This routine checks that the keyboard command queue is empty
  261. diff -u --recursive --new-file v1.3.30/linux/arch/i386/config.in linux/arch/i386/config.in
  262. --- v1.3.30/linux/arch/i386/config.in    Wed Sep 27 15:59:56 1995
  263. +++ linux/arch/i386/config.in    Tue Oct  3 12:43:53 1995
  264. @@ -40,6 +40,7 @@
  265.  #if [ "$CONFIG_M586" = "n" ]; then
  266.  bool 'Use -m486 flag for 486-specific optimizations' CONFIG_M486 y
  267.  #fi
  268. +bool 'SMP Kernel (experimental - gcc2.5.8 only: see Documentation/SMP.txt)' CONFIG_SMP n
  269.  
  270.  comment 'Loadable module support'
  271.  bool 'Set version information on all symbols for modules' CONFIG_MODVERSIONS n
  272. @@ -74,6 +75,7 @@
  273.  if [ "$CONFIG_AX25" = "y" ]; then
  274.    bool 'Amateur Radio NET/ROM' CONFIG_NETROM n
  275.  fi
  276. +bool 'Kernel/User network link driver(ALPHA)' CONFIG_NETLINK n
  277.  fi
  278.  
  279.  comment 'SCSI support'
  280. diff -u --recursive --new-file v1.3.30/linux/arch/i386/kernel/Makefile linux/arch/i386/kernel/Makefile
  281. --- v1.3.30/linux/arch/i386/kernel/Makefile    Wed Sep 27 15:59:56 1995
  282. +++ linux/arch/i386/kernel/Makefile    Mon Oct  2 15:13:57 1995
  283. @@ -7,21 +7,51 @@
  284.  #
  285.  # Note 2! The CFLAGS definitions are now in the main makefile...
  286.  
  287. +AS86    =as86 -0 -a
  288. +AS386    =as86 -3
  289. +LD86    =ld86 -0
  290. +
  291. +
  292.  #.S.s:
  293.  #    $(CPP) -D__ASSEMBLY__ -traditional $< -o $*.s
  294.  .S.o:
  295.      $(CC) -D__ASSEMBLY__ -traditional -c $< -o $*.o
  296.  
  297.  all: kernel.o head.o
  298. +
  299.  O_TARGET := kernel.o
  300.  O_OBJS   := process.o signal.o entry.o traps.o irq.o vm86.o bios32.o \
  301.              ptrace.o ioport.o ldt.o setup.o time.o sys_i386.o
  302.  
  303. -
  304. -#head.o: head.s
  305. +ifdef CONFIG_SMP
  306. +O_OBJS += smp.o
  307. +endif
  308.  
  309.  head.o: head.S $(TOPDIR)/include/linux/tasks.h
  310.      $(CC) -D__ASSEMBLY__ -traditional -c $*.S -o $*.o
  311. -#    $(CPP) -traditional -o $*.s $<
  312. +
  313. +hexify:
  314. +    $(HOSTCC) hexify.c -o hexify
  315. +
  316. +trampoline.hex: trampoline hexify
  317. +    (dd if=trampoline bs=1 skip=32 | ./hexify >trampoline.hex )
  318. +
  319. +trampoline: trampoline.o trampoline32.o
  320. +    $(LD86) -s -o $@ trampoline.o trampoline32.o
  321. +
  322. +trampoline.o: trampoline.s
  323. +    $(AS86) -o $@ $<
  324. +
  325. +trampoline32.o: trampoline32.s
  326. +    $(AS386) -o $@ $<
  327. +
  328. +trampoline.s: trampoline.S $(CONFIGURE) $(TOPDIR)/include/linux/config.h Makefile
  329. +    $(CPP) -traditional $< -o $@
  330. +
  331. +trampoline32.s: trampoline32.S $(CONFIGURE) $(TOPDIR)/include/linux/config.h Makefile
  332. +    $(CPP) -traditional $< -o $@
  333. +
  334. +clean:
  335. +    rm -f trampoline hexify
  336.  
  337.  include $(TOPDIR)/Rules.make
  338. diff -u --recursive --new-file v1.3.30/linux/arch/i386/kernel/entry.S linux/arch/i386/kernel/entry.S
  339. --- v1.3.30/linux/arch/i386/kernel/entry.S    Mon Aug 28 14:52:18 1995
  340. +++ linux/arch/i386/kernel/entry.S    Tue Oct  3 12:10:12 1995
  341. @@ -41,8 +41,11 @@
  342.   */
  343.  
  344.  #include <linux/sys.h>
  345. +#include <linux/config.h>
  346.  #include <linux/linkage.h>
  347.  #include <asm/segment.h>
  348. +#define ASSEMBLY
  349. +#include <asm/smp.h>
  350.  
  351.  EBX        = 0x00
  352.  ECX        = 0x04
  353. @@ -102,13 +105,112 @@
  354.      movl $(USER_DS),%edx; \
  355.      mov %dx,%fs;
  356.  
  357. +#ifdef    CONFIG_SMP
  358. +
  359. +#define GET_PROCESSOR_ID \
  360. +    movl SYMBOL_NAME(apic_reg), %edx; \
  361. +    movl 32(%edx), %eax;\
  362. +    movl %eax,SYMBOL_NAME(apic_retval); \
  363. +    shrl $24,%eax; \
  364. +    andb $0x0F,%al;
  365. +
  366. +/*
  367. + *    Get the processor ID multiplied by 4
  368. + */
  369. +
  370. +#define GET_PROCESSOR_OFFSET(x) \
  371. +    movl SYMBOL_NAME(apic_reg), x ; \
  372. +    movl 32( x ), x ; \
  373. +    shrl $22, x ; \
  374. +    andl $0x3C, x ;
  375. +
  376. +/* macro LEAVE_KERNEL decrements kernel_counter and resets kernel_flag and
  377. +   saves processor variables if zero */
  378. +#define    LEAVE_KERNEL \
  379. +    pushfl; \
  380. +    cli; \
  381. +    decl SYMBOL_NAME(syscall_count); \
  382. +    decl SYMBOL_NAME(kernel_counter); \
  383. +    jnz 1f;    \
  384. +    movb $(NO_PROC_ID), SYMBOL_NAME(active_kernel_processor); \
  385. +    lock; \
  386. +    btrl $0, SYMBOL_NAME(kernel_flag); \
  387. +1:    popfl;
  388. +
  389. +/* macro ENTER_KERNEL waits for entering the kernel, increments
  390. +   kernel_counter, and reloads the processor variables if necessary
  391. +   uses : %eax, %edx (pushed and popped) 
  392. +
  393. +   Note: We go to great pains to minimise the number of locked operations.
  394. +   We want to spin without locking, and lock when we attempt an update.
  395. +   The pentium has a MESI cache so the spin without lock will exit when
  396. +   another CPU write invalidates our cache, and the lock is avoided when
  397. +   possible so we don't play ping-pong games with the cache line.
  398. +
  399. +*/
  400. +
  401. +#define    ENTER_KERNEL \
  402. +    pushl %eax; \
  403. +    pushl %edx; \
  404. +    pushfl; \
  405. +    cli; \
  406. +    GET_PROCESSOR_ID \
  407. +1:    lock; \
  408. +    btsl $0, SYMBOL_NAME(kernel_flag); \
  409. +    jnc 3f; \
  410. +    cmpb SYMBOL_NAME(active_kernel_processor), %al; \
  411. +    je 4f; \
  412. +2:    incl SYMBOL_NAME(smp_spins); \
  413. +    btl %al, SYMBOL_NAME(smp_invalidate_needed); \
  414. +    jnc 5f; \
  415. +    lock; \
  416. +    btrl %al, SYMBOL_NAME(smp_invalidate_needed); \
  417. +    jnc 5f; \
  418. +    movl %cr3,%edx; \
  419. +    movl %edx,%cr3; \
  420. +5:    btl $0, SYMBOL_NAME(kernel_flag); \
  421. +    jc 2b; \
  422. +    jmp 1b; \
  423. +3:    movb %al, SYMBOL_NAME(active_kernel_processor); \
  424. +4:    incl SYMBOL_NAME(kernel_counter); \
  425. +    incl SYMBOL_NAME(syscall_count); \
  426. +    popfl; \
  427. +    popl %edx; \
  428. +    popl %eax;
  429. +
  430. +
  431. +#define RESTORE_ALL \
  432. +    cmpw $(KERNEL_CS),CS(%esp); \
  433. +    je 1f;   \
  434. +    GET_PROCESSOR_OFFSET(%edx) \
  435. +    movl SYMBOL_NAME(current_set)(,%edx), %eax ; ; \
  436. +    movl dbgreg7(%eax),%ebx; \
  437. +    movl %ebx,%db7;    \
  438. +1:    LEAVE_KERNEL \
  439. +    popl %ebx; \
  440. +    popl %ecx; \
  441. +    popl %edx; \
  442. +    popl %esi; \
  443. +    popl %edi; \
  444. +    popl %ebp; \
  445. +    popl %eax; \
  446. +    pop %ds; \
  447. +    pop %es; \
  448. +    pop %fs; \
  449. +    pop %gs; \
  450. +    addl $4,%esp; \
  451. +    iret
  452. +
  453. +#else
  454. +
  455.  #define RESTORE_ALL \
  456.      cmpw $(KERNEL_CS),CS(%esp); \
  457.      je 1f;   \
  458. -    movl SYMBOL_NAME(current),%eax; \
  459. +    movl SYMBOL_NAME(current_set),%eax; \
  460.      movl dbgreg7(%eax),%ebx; \
  461.      movl %ebx,%db7;    \
  462. -1:    popl %ebx; \
  463. +1:    \
  464. +    popl %ebx; \
  465.      popl %ecx; \
  466.      popl %edx; \
  467.      popl %esi; \
  468. @@ -121,11 +223,16 @@
  469.      pop %gs; \
  470.      addl $4,%esp; \
  471.      iret
  472. +#endif
  473. +
  474.  
  475.  ENTRY(lcall7)
  476.      pushfl            # We get a different stack layout with call gates,
  477.      pushl %eax        # which has to be cleaned up later..
  478.      SAVE_ALL
  479. +#ifdef CONFIG_SMP
  480. +    ENTER_KERNEL
  481. +#endif
  482.      movl EIP(%esp),%eax    # due to call gates, this is eflags, not eip..
  483.      movl CS(%esp),%edx    # this is eip..
  484.      movl EFLAGS(%esp),%ecx    # and this is cs..
  485. @@ -133,7 +240,12 @@
  486.      movl %edx,EIP(%esp)    # Now we move them to their "normal" places
  487.      movl %ecx,CS(%esp)    #
  488.      movl %esp,%eax
  489. -    movl SYMBOL_NAME(current),%edx
  490. +#ifdef CONFIG_SMP
  491. +    GET_PROCESSOR_OFFSET(%edx)    # Processor offset into edx
  492. +    movl SYMBOL_NAME(current_set)(,%edx),%edx
  493. +#else
  494. +    movl SYMBOL_NAME(current_set),%edx
  495. +#endif
  496.      pushl %eax
  497.      movl exec_domain(%edx),%edx    # Get the execution domain
  498.      movl 4(%edx),%edx    # Get the lcall7 handler for the domain
  499. @@ -153,18 +265,26 @@
  500.      ALIGN
  501.  reschedule:
  502.      pushl $ret_from_sys_call
  503. -    jmp SYMBOL_NAME(schedule)
  504. +    jmp SYMBOL_NAME(schedule)    # test
  505.  
  506.  ENTRY(system_call)
  507.      pushl %eax            # save orig_eax
  508.      SAVE_ALL
  509. +#ifdef CONFIG_SMP
  510. +    ENTER_KERNEL
  511. +#endif
  512.      movl $-ENOSYS,EAX(%esp)
  513.      cmpl $(NR_syscalls),%eax
  514.      jae ret_from_sys_call
  515.      movl SYMBOL_NAME(sys_call_table)(,%eax,4),%eax
  516.      testl %eax,%eax
  517.      je ret_from_sys_call
  518. -    movl SYMBOL_NAME(current),%ebx
  519. +#ifdef CONFIG_SMP
  520. +    GET_PROCESSOR_OFFSET(%edx)
  521. +    movl SYMBOL_NAME(current_set)(,%edx),%ebx
  522. +#else
  523. +    movl SYMBOL_NAME(current_set),%ebx
  524. +#endif
  525.      andl $~CF_MASK,EFLAGS(%esp)    # clear carry - assume no errors
  526.      movl $0,errno(%ebx)
  527.      movl %db6,%edx
  528. @@ -184,7 +304,12 @@
  529.      movl ORIG_EAX(%esp),%eax
  530.      call SYMBOL_NAME(sys_call_table)(,%eax,4)
  531.      movl %eax,EAX(%esp)        # save the return value
  532. -    movl SYMBOL_NAME(current),%eax
  533. +#ifdef CONFIG_SMP
  534. +    GET_PROCESSOR_OFFSET(%eax)
  535. +    movl SYMBOL_NAME(current_set)(,%eax),%eax
  536. +#else
  537. +    movl SYMBOL_NAME(current_set),%eax
  538. +#endif
  539.      movl errno(%eax),%edx
  540.      negl %edx
  541.      je 1f
  542. @@ -211,7 +336,12 @@
  543.      movl %eax,EFLAGS(%esp)        # stupid
  544.      cmpl $0,SYMBOL_NAME(need_resched)
  545.      jne reschedule
  546. -    movl SYMBOL_NAME(current),%eax
  547. +#ifdef CONFIG_SMP
  548. +    GET_PROCESSOR_OFFSET(%eax)
  549. +    movl SYMBOL_NAME(current_set)(,%eax), %eax
  550. +#else
  551. +    movl SYMBOL_NAME(current_set),%eax
  552. +#endif
  553.      cmpl SYMBOL_NAME(task),%eax    # task[0] cannot have signals
  554.      je 2f
  555.      cmpl $0,state(%eax)        # state
  556. @@ -277,8 +407,16 @@
  557.      mov %dx,%es
  558.      movl $(USER_DS),%edx
  559.      mov %dx,%fs
  560. +#ifdef CONFIG_SMP
  561. +    ENTER_KERNEL
  562. +#endif
  563.      pushl %eax
  564. -    movl SYMBOL_NAME(current),%eax
  565. +#ifdef CONFIG_SMP
  566. +    GET_PROCESSOR_OFFSET(%eax)
  567. +    movl SYMBOL_NAME(current_set)(,%eax), %eax
  568. +#else
  569. +    movl SYMBOL_NAME(current_set),%eax
  570. +#endif
  571.      movl %db6,%edx
  572.      movl %edx,dbgreg6(%eax)  # save current hardware debugging status
  573.      popl %eax
  574. @@ -294,6 +432,9 @@
  575.  ENTRY(device_not_available)
  576.      pushl $-1        # mark this as an int
  577.      SAVE_ALL
  578. +#ifdef CONFIG_SMP
  579. +    ENTER_KERNEL
  580. +#endif
  581.      pushl $ret_from_sys_call
  582.      movl %cr0,%eax
  583.      testl $0x4,%eax            # EM (math emulation bit)
  584. @@ -518,4 +659,6 @@
  585.      .long SYMBOL_NAME(sys_select)
  586.      .long SYMBOL_NAME(sys_flock)
  587.      .long SYMBOL_NAME(sys_msync)
  588. -    .space (NR_syscalls-144)*4
  589. +    .long SYMBOL_NAME(sys_readv)        /* 145 */
  590. +    .long SYMBOL_NAME(sys_writev)
  591. +    .space (NR_syscalls-146)*4
  592. diff -u --recursive --new-file v1.3.30/linux/arch/i386/kernel/head.S linux/arch/i386/kernel/head.S
  593. --- v1.3.30/linux/arch/i386/kernel/head.S    Thu Jun 29 19:02:39 1995
  594. +++ linux/arch/i386/kernel/head.S    Mon Oct  2 14:25:09 1995
  595. @@ -9,6 +9,7 @@
  596.   */
  597.  
  598.  .text
  599. +#include <linux/config.h>
  600.  #include <linux/tasks.h>
  601.  #include <linux/fd.h>
  602.  #include <linux/linkage.h>
  603. @@ -32,7 +33,22 @@
  604.      mov %ax,%es
  605.      mov %ax,%fs
  606.      mov %ax,%gs
  607. +#ifdef CONFIG_SMP
  608. +    orw  %bx,%bx
  609. +    jz  1f                /* Initial CPU cleans BSS */
  610. +/*
  611. + *    Set up the stack
  612. + */
  613. +    mov %ax,%ss
  614. +    xorl %eax,%eax
  615. +    movw %cx, %ax
  616. +    movl %eax,%esp
  617. +    pushl $0
  618. +    popfl
  619. +    jmp checkCPUtype
  620. +1:
  621.      lss stack_start,%esp
  622. +#endif CONFIG_SMP
  623.  /*
  624.   * Clear BSS first so that there are no surprises...
  625.   */
  626. @@ -84,6 +100,10 @@
  627.      rep
  628.      movsb
  629.  1:
  630. +#ifdef CONFIG_SMP
  631. +checkCPUtype:
  632. +#endif
  633. +
  634.  /* check if it is 486 or 386. */
  635.  /*
  636.   * XXX - this does a lot of unnecessary setup.  Alignment checks don't
  637. @@ -150,7 +170,32 @@
  638.      orl $2,%eax        # set MP
  639.  2:    movl %eax,%cr0
  640.      call check_x87
  641. +#ifdef CONFIG_SMP
  642. +    movb ready,%eax
  643. +    orb %eax,%eax
  644. +    jz 3f    
  645. +    movl $ SYMBOL_NAME(swapper_pg_dir), %eax
  646. +    movl %eax, %cr3
  647. +#ifdef GAS_KNOWS_CR4
  648. +    movl %cr4,%eax
  649. +    orl $16,%eax
  650. +    movl %eax,%cr4
  651. +#else
  652. +    .byte 0x0f,0x20,0xe0
  653. +    orl $16,%eax
  654. +    .byte 0x0f,0x22,0xe0
  655. +#endif
  656. +    movl %cr0, %eax
  657. +    orl $0x80000000, %eax
  658. +    movl %eax, %cr0
  659. +    jmp 4f
  660. +#endif
  661. +3:
  662.      call setup_paging
  663. +#ifdef CONFIG_SMP
  664. +    incb ready
  665. +#endif
  666. +4:
  667.      lgdt gdt_descr
  668.      lidt idt_descr
  669.      ljmp $(KERNEL_CS),$1f
  670. @@ -159,7 +204,12 @@
  671.      mov %ax,%es
  672.      mov %ax,%fs
  673.      mov %ax,%gs
  674. -    lss stack_start,%esp
  675. +#ifdef CONFIG_SMP
  676. +    movl $(KERNEL_DS), %eax
  677. +    mov  %ax,%ss        # Reload the stack pointer (segment only)
  678. +#else
  679. +    lss stack_start,%esp    # Load processor stack
  680. +#endif
  681.      xorl %eax,%eax
  682.      lldt %ax
  683.      pushl %eax        # These are the parameters to main :-)
  684. @@ -170,6 +220,10 @@
  685.  L6:
  686.      jmp L6            # main should never return here, but
  687.                  # just in case, we know what happens.
  688. +
  689. +#ifdef CONFIG_SMP
  690. +ready:    .byte 0
  691. +#endif
  692.  
  693.  /*
  694.   * We depend on ET to be correct. This checks for 287/387.
  695. diff -u --recursive --new-file v1.3.30/linux/arch/i386/kernel/hexify.c linux/arch/i386/kernel/hexify.c
  696. --- v1.3.30/linux/arch/i386/kernel/hexify.c    Thu Jan  1 02:00:00 1970
  697. +++ linux/arch/i386/kernel/hexify.c    Mon Oct  2 14:25:10 1995
  698. @@ -0,0 +1,31 @@
  699. +#include <stdio.h>
  700. +
  701. +
  702. +void main()
  703. +{
  704. +    int c;
  705. +    int comma=0;
  706. +    int count=0;
  707. +    while((c=getchar())!=EOF)
  708. +    {
  709. +        unsigned char x=c;
  710. +        if(comma)
  711. +            printf(",");
  712. +        else
  713. +            comma=1;
  714. +        if(count==8)
  715. +        {
  716. +            count=0;
  717. +            printf("\n");
  718. +        }
  719. +        if(count==0)
  720. +            printf("\t");
  721. +        printf("0x%02X",c);
  722. +        count++;
  723. +    }
  724. +    if(count)
  725. +        printf("\n");
  726. +    exit(0);
  727. +}
  728. +
  729. +        
  730. diff -u --recursive --new-file v1.3.30/linux/arch/i386/kernel/irq.c linux/arch/i386/kernel/irq.c
  731. --- v1.3.30/linux/arch/i386/kernel/irq.c    Wed Sep 27 15:59:56 1995
  732. +++ linux/arch/i386/kernel/irq.c    Mon Oct  2 14:25:09 1995
  733. @@ -15,6 +15,7 @@
  734.   * Naturally it's not a 1:1 relation, but there are similarities.
  735.   */
  736.  
  737. +#include <linux/config.h>
  738.  #include <linux/ptrace.h>
  739.  #include <linux/errno.h>
  740.  #include <linux/kernel_stat.h>
  741. @@ -29,6 +30,7 @@
  742.  #include <asm/io.h>
  743.  #include <asm/irq.h>
  744.  #include <asm/bitops.h>
  745. +#include <asm/smp.h>
  746.  
  747.  #define CR0_NE 32
  748.  
  749. @@ -103,19 +105,29 @@
  750.  BUILD_IRQ(SECOND,10,0x04)
  751.  BUILD_IRQ(SECOND,11,0x08)
  752.  BUILD_IRQ(SECOND,12,0x10)
  753. +#ifdef CONFIG_SMP
  754. +BUILD_MSGIRQ(SECOND,13,0x20)
  755. +#else
  756.  BUILD_IRQ(SECOND,13,0x20)
  757. +#endif
  758.  BUILD_IRQ(SECOND,14,0x40)
  759.  BUILD_IRQ(SECOND,15,0x80)
  760. +#ifdef CONFIG_SMP
  761. +BUILD_RESCHEDIRQ(16)
  762. +#endif
  763.  
  764.  /*
  765.   * Pointers to the low-level handlers: first the general ones, then the
  766.   * fast ones, then the bad ones.
  767.   */
  768. -static void (*interrupt[16])(void) = {
  769. +static void (*interrupt[17])(void) = {
  770.      IRQ0_interrupt, IRQ1_interrupt, IRQ2_interrupt, IRQ3_interrupt,
  771.      IRQ4_interrupt, IRQ5_interrupt, IRQ6_interrupt, IRQ7_interrupt,
  772.      IRQ8_interrupt, IRQ9_interrupt, IRQ10_interrupt, IRQ11_interrupt,
  773. -    IRQ12_interrupt, IRQ13_interrupt, IRQ14_interrupt, IRQ15_interrupt
  774. +    IRQ12_interrupt, IRQ13_interrupt, IRQ14_interrupt, IRQ15_interrupt    
  775. +#ifdef CONFIG_SMP    
  776. +    ,IRQ16_interrupt
  777. +#endif
  778.  };
  779.  
  780.  static void (*fast_interrupt[16])(void) = {
  781. @@ -169,11 +181,20 @@
  782.      for (i = 0 ; i < 16 ; i++, action++) {
  783.          if (!action->handler)
  784.              continue;
  785. -        len += sprintf(buf+len, "%2d: %8d %c %s\n",
  786. +        len += sprintf(buf+len, "%3d: %8d %c %s\n",
  787.              i, kstat.interrupts[i],
  788.              (action->flags & SA_INTERRUPT) ? '+' : ' ',
  789.              action->name);
  790.      }
  791. +/*
  792. + *    Linus - should you add NMI counts here ?????
  793. + */
  794. +#ifdef CONFIG_SMP
  795. +    len+=sprintf(buf+len, "IPI: %8lu received\n",
  796. +        ipi_count);
  797. +    len+=sprintf(buf+len, "LCK: %8lu spins\n",
  798. +        smp_spins);
  799. +#endif        
  800.      return len;
  801.  }
  802.  
  803. @@ -187,6 +208,10 @@
  804.  asmlinkage void do_IRQ(int irq, struct pt_regs * regs)
  805.  {
  806.      struct irqaction * action = irq + irq_action;
  807. +#ifdef CONFIG_SMP
  808. +    if(smp_threads_ready && active_kernel_processor!=smp_processor_id())
  809. +        panic("IRQ %d: active processor set wrongly(%d not %d).\n", irq, active_kernel_processor, smp_processor_id());
  810. +#endif
  811.  
  812.      kstat.interrupts[irq]++;
  813.  #ifdef CONFIG_RANDOM
  814. @@ -204,6 +229,11 @@
  815.  asmlinkage void do_fast_IRQ(int irq)
  816.  {
  817.      struct irqaction * action = irq + irq_action;
  818. +#ifdef CONFIG_SMP
  819. +    /* IRQ 13 is allowed - thats an invalidate */
  820. +    if(smp_threads_ready && active_kernel_processor!=smp_processor_id() && irq!=13)
  821. +        panic("fast_IRQ %d: active processor set wrongly(%d not %d).\n", irq, active_kernel_processor, smp_processor_id());
  822. +#endif
  823.  
  824.      kstat.interrupts[irq]++;
  825.  #ifdef CONFIG_RANDOM
  826. @@ -283,6 +313,8 @@
  827.      restore_flags(flags);
  828.  }
  829.  
  830. +#ifndef CONFIG_SMP
  831. +
  832.  /*
  833.   * Note that on a 486, we don't want to do a SIGFPE on a irq13
  834.   * as the irq is unreliable, and exception 16 works correctly
  835. @@ -294,6 +326,8 @@
  836.   * leads to races. IBM designers who came up with it should
  837.   * be shot.
  838.   */
  839. + 
  840. +
  841.  static void math_error_irq(int cpl, struct pt_regs *regs)
  842.  {
  843.      outb(0,0xF0);
  844. @@ -302,6 +336,8 @@
  845.      math_error();
  846.  }
  847.  
  848. +#endif
  849. +
  850.  static void no_action(int cpl, struct pt_regs * regs) { }
  851.  
  852.  unsigned long probe_irq_on (void)
  853. @@ -359,6 +395,10 @@
  854.  void init_IRQ(void)
  855.  {
  856.      int i;
  857. +    static unsigned char smptrap=0;
  858. +    if(smptrap)
  859. +        return;
  860. +    smptrap=1;
  861.  
  862.      /* set the clock to 100 Hz */
  863.      outb_p(0x34,0x43);        /* binary, mode 2, LSB/MSB, ch 0 */
  864. @@ -366,10 +406,20 @@
  865.      outb(LATCH >> 8 , 0x40);    /* MSB */
  866.      for (i = 0; i < 16 ; i++)
  867.          set_intr_gate(0x20+i,bad_interrupt[i]);
  868. +    /* This bit is a hack because we don't send timer messages to all processors yet */
  869. +    /* It has to here .. it doesnt work if you put it down the bottom - assembler explodes 8) */
  870. +#ifdef CONFIG_SMP    
  871. +    set_intr_gate(0x20+i, interrupt[i]);    /* IRQ '16' - IPI for rescheduling */
  872. +#endif    
  873.      if (request_irq(2, no_action, SA_INTERRUPT, "cascade"))
  874. -        printk("Unable to get IRQ2 for cascade\n");
  875. +        printk("Unable to get IRQ2 for cascade.\n");
  876. +#ifndef CONFIG_SMP        
  877.      if (request_irq(13,math_error_irq, 0, "math error"))
  878. -        printk("Unable to get IRQ13 for math-error handler\n");
  879. +        printk("Unable to get IRQ13 for math-error handler.\n");
  880. +#else
  881. +    if (request_irq(13, smp_message_irq, SA_INTERRUPT, "IPI"))
  882. +        printk("Unable to get IRQ13 for IPI.\n");
  883. +#endif                
  884.      request_region(0x20,0x20,"pic1");
  885.      request_region(0xa0,0x20,"pic2");
  886.  } 
  887. diff -u --recursive --new-file v1.3.30/linux/arch/i386/kernel/process.c linux/arch/i386/kernel/process.c
  888. --- v1.3.30/linux/arch/i386/kernel/process.c    Wed Sep 13 12:45:29 1995
  889. +++ linux/arch/i386/kernel/process.c    Mon Oct  2 14:25:09 1995
  890. @@ -8,6 +8,7 @@
  891.   * This file handles the architecture-dependent parts of process handling..
  892.   */
  893.  
  894. +#include <linux/config.h>
  895.  #include <linux/errno.h>
  896.  #include <linux/sched.h>
  897.  #include <linux/kernel.h>
  898. @@ -24,6 +25,8 @@
  899.  #include <asm/pgtable.h>
  900.  #include <asm/system.h>
  901.  #include <asm/io.h>
  902. +#include <linux/smp.h>
  903. +
  904.  
  905.  asmlinkage void ret_from_sys_call(void) __asm__("ret_from_sys_call");
  906.  
  907. @@ -45,12 +48,40 @@
  908.  asmlinkage int sys_idle(void)
  909.  {
  910.      if (current->pid != 0)
  911. +    {
  912. +    /*    printk("Wrong process idled\n");    SMP bug check */
  913.          return -EPERM;
  914. -
  915. +    }
  916. +#ifdef CONFIG_SMP
  917. +    /*
  918. +     *    SMP locking sanity checker
  919. +     */
  920. +    if(smp_processor_id()!=active_kernel_processor)
  921. +        panic("CPU is %d, kernel CPU is %d in sys_idle!\n",
  922. +            smp_processor_id(), active_kernel_processor);
  923. +    if(syscall_count!=1)
  924. +        printk("sys_idle: syscall count is not 1 (%ld)\n", syscall_count);
  925. +    if(kernel_counter!=1)
  926. +    {
  927. +        printk("CPU %d, sys_idle, kernel_counter is %ld\n", smp_processor_id(), kernel_counter);
  928. +        if(!kernel_counter)
  929. +            panic("kernel locking botch");
  930. +    }
  931. +    /*
  932. +     *    Until we have C unlocking done
  933. +     */
  934. +    current->counter = -100;
  935. +    schedule();
  936. +    return 0;
  937. +#endif    
  938.      /* endless idle loop with no priority at all */
  939.      current->counter = -100;
  940.      for (;;) {
  941. +#ifdef CONFIG_SMP
  942. +        if (cpu_data[smp_processor_id()].hlt_works_ok && !hlt_counter && !need_resched)
  943. +#else    
  944.          if (hlt_works_ok && !hlt_counter && !need_resched)
  945. +#endif        
  946.              __asm__("hlt");
  947.          schedule();
  948.      }
  949. diff -u --recursive --new-file v1.3.30/linux/arch/i386/kernel/setup.c linux/arch/i386/kernel/setup.c
  950. --- v1.3.30/linux/arch/i386/kernel/setup.c    Mon Sep 25 12:26:21 1995
  951. +++ linux/arch/i386/kernel/setup.c    Mon Oct  2 14:25:09 1995
  952. @@ -26,6 +26,7 @@
  953.  
  954.  #include <asm/segment.h>
  955.  #include <asm/system.h>
  956. +#include <asm/smp.h>
  957.  
  958.  /*
  959.   * Tell us the machine setup..
  960. @@ -83,6 +84,13 @@
  961.      unsigned long memory_start, memory_end;
  962.      char c = ' ', *to = command_line, *from = COMMAND_LINE;
  963.      int len = 0;
  964. +    static unsigned char smptrap=0;
  965. +
  966. +    if(smptrap==1)
  967. +    {
  968. +        return;
  969. +    }
  970. +    smptrap=1;
  971.  
  972.       ROOT_DEV = to_kdev_t(ORIG_ROOT_DEV);
  973.       drive_info = DRIVE_INFO;
  974. @@ -148,9 +156,10 @@
  975.  {
  976.      static const char *model[2][9]={{"DX","SX","DX/2","4","SX/2","6",
  977.                  "DX/2-WB","DX/4"},
  978. -            {"Pentium 60/66","Pentium 90/100","3",
  979. +            {"Pentium 60/66","Pentium 75+","3",
  980.                  "4","5","6","7","8"}};
  981.      char mask[2];
  982. +#ifndef CONFIG_SMP    
  983.      mask[0] = x86_mask+'@';
  984.      mask[1] = '\0';
  985.      return sprintf(buffer,"cpu\t\t: %c86\n"
  986. @@ -188,4 +197,90 @@
  987.                    x86_capability & 256 ? "yes" : "no",
  988.                        loops_per_sec/500000, (loops_per_sec/5000) % 100
  989.                    );
  990. +#else
  991. +    char *bp=buffer;
  992. +    int i;    
  993. +    bp+=sprintf(bp,"cpu\t\t: ");
  994. +    for(i=0;i<32;i++)
  995. +        if(cpu_present_map&(1<<i))
  996. +            bp+=sprintf(bp,"%c86             ",cpu_data[i].x86+'0');
  997. +    bp+=sprintf(bp,"\nmodel\t\t: ");
  998. +    for(i=0;i<32;i++)
  999. +        if(cpu_present_map&(1<<i))
  1000. +            bp+=sprintf(bp,"%-16s",cpu_data[i].x86_model?
  1001. +                    model[cpu_data[i].x86-4][cpu_data[i].x86_model-1]:"Unknown");
  1002. +    bp+=sprintf(bp,"\nmask\t\t: ");
  1003. +    for(i=0;i<32;i++)
  1004. +        if(cpu_present_map&(1<<i))
  1005. +        {
  1006. +            mask[0] = cpu_data[i].x86_mask+'@';
  1007. +            mask[1] = '\0';        
  1008. +            bp+=sprintf(bp,"%-16s", cpu_data[i].x86_mask ? mask : "Unknown");
  1009. +        }
  1010. +    bp+=sprintf(bp,"\nvid\t\t: ");
  1011. +    for(i=0;i<32;i++)
  1012. +        if(cpu_present_map&(1<<i))
  1013. +            bp+=sprintf(bp,"%-16s", cpu_data[i].x86_vendor_id);
  1014. +    bp+=sprintf(bp,"\nfdiv_bug\t: ");
  1015. +    for(i=0;i<32;i++)
  1016. +        if(cpu_present_map&(1<<i))
  1017. +            bp+=sprintf(bp,"%-16s", cpu_data[i].fdiv_bug?"yes":"no");
  1018. +    bp+=sprintf(bp,"\nmath\t\t: ");
  1019. +    for(i=0;i<32;i++)
  1020. +        if(cpu_present_map&(1<<i))
  1021. +            bp+=sprintf(bp,"%-16s", cpu_data[i].hard_math?"yes":"no");
  1022. +    bp+=sprintf(bp,"\nhlt\t\t: ");
  1023. +    for(i=0;i<32;i++)
  1024. +        if(cpu_present_map&(1<<i))
  1025. +            bp+=sprintf(bp,"%-16s", cpu_data[i].hlt_works_ok?"yes":"no");
  1026. +    bp+=sprintf(bp,"\nwp\t\t: ");
  1027. +    for(i=0;i<32;i++)
  1028. +        if(cpu_present_map&(1<<i))
  1029. +            bp+=sprintf(bp,"%-16s", cpu_data[i].wp_works_ok?"yes":"no");
  1030. +    bp+=sprintf(bp,"\nIntegrated NPU\t: ");
  1031. +    for(i=0;i<32;i++)
  1032. +        if(cpu_present_map&(1<<i))
  1033. +            bp+=sprintf(bp,"%-16s", cpu_data[i].x86_capability&1?"yes":"no");
  1034. +    bp+=sprintf(bp,"\nEnhanced VM86\t: ");
  1035. +    for(i=0;i<32;i++)
  1036. +        if(cpu_present_map&(1<<i))
  1037. +            bp+=sprintf(bp,"%-16s", cpu_data[i].x86_capability&2?"yes":"no");
  1038. +    bp+=sprintf(bp,"\nIO Breakpoints\t: ");
  1039. +    for(i=0;i<32;i++)
  1040. +        if(cpu_present_map&(1<<i))
  1041. +            bp+=sprintf(bp,"%-16s", (cpu_data[i].x86_capability&4)?"yes":"no");
  1042. +    bp+=sprintf(bp,"\n4MB Pages\t: ");
  1043. +    for(i=0;i<32;i++)
  1044. +        if(cpu_present_map&(1<<i))
  1045. +            bp+=sprintf(bp,"%-16s", (cpu_data[i].x86_capability)&8?"yes":"no");
  1046. +    bp+=sprintf(bp,"\nTS Counters\t: ");
  1047. +    for(i=0;i<32;i++)
  1048. +        if(cpu_present_map&(1<<i))
  1049. +            bp+=sprintf(bp,"%-16s", (cpu_data[i].x86_capability&16)?"yes":"no");
  1050. +    bp+=sprintf(bp,"\nPentium MSR\t: ");
  1051. +    for(i=0;i<32;i++)
  1052. +        if(cpu_present_map&(1<<i))
  1053. +            bp+=sprintf(bp,"%-16s", (cpu_data[i].x86_capability&32)?"yes":"no");
  1054. +    bp+=sprintf(bp,"\nMach. Ch. Exep.\t: ");
  1055. +    for(i=0;i<32;i++)
  1056. +        if(cpu_present_map&(1<<i))
  1057. +            bp+=sprintf(bp,"%-16s", (cpu_data[i].x86_capability&128)?"yes":"no");
  1058. +    bp+=sprintf(bp,"\nCMPXCHG8B\t: ");
  1059. +    for(i=0;i<32;i++)
  1060. +        if(cpu_present_map&(1<<i))
  1061. +            bp+=sprintf(bp,"%-16s", (cpu_data[i].x86_capability&256)?"yes":"no");
  1062. +    bp+=sprintf(bp,"\nBogoMips\t: ");
  1063. +    for(i=0;i<32;i++)
  1064. +    {
  1065. +        char tmp[17];
  1066. +        if(cpu_present_map&(1<<i))
  1067. +        {
  1068. +            sprintf(tmp,"%lu.%02lu",cpu_data[i].udelay_val/500000L,
  1069. +                           (cpu_data[i].udelay_val/5000L)%100);
  1070. +            bp+=sprintf(bp,"%-16s",tmp);
  1071. +        }
  1072. +    }
  1073. +    *bp++='\n';
  1074. +    return bp-buffer;
  1075. +#endif                  
  1076.  }
  1077. diff -u --recursive --new-file v1.3.30/linux/arch/i386/kernel/smp.c linux/arch/i386/kernel/smp.c
  1078. --- v1.3.30/linux/arch/i386/kernel/smp.c    Thu Jan  1 02:00:00 1970
  1079. +++ linux/arch/i386/kernel/smp.c    Mon Oct  2 15:07:01 1995
  1080. @@ -0,0 +1,918 @@
  1081. +/*
  1082. + *    Intel MP v1.1 specification support routines for multi-pentium 
  1083. + *    hosts.
  1084. + *
  1085. + *    (c) 1995 Alan Cox, CymruNET Ltd  <alan@cymru.net>
  1086. + *    Supported by Caldera http://www.caldera.com.
  1087. + *    Much of the core SMP work is based on previous work by Thomas Radke, to
  1088. + *    whom a great many thanks are extended.
  1089. + *
  1090. + *    This code is released under the GNU public license version 2 or
  1091. + *    later.
  1092. + *
  1093. + *    Fixes
  1094. + *        Felix Koop:    NR_CPUS used properly
  1095. + *
  1096. + */
  1097. +
  1098. +#include <linux/kernel.h>
  1099. +#include <linux/string.h>
  1100. +#include <linux/config.h>
  1101. +#include <linux/timer.h>
  1102. +#include <linux/sched.h>
  1103. +#include <linux/mm.h>
  1104. +#include <linux/kernel_stat.h>
  1105. +#include <linux/delay.h>
  1106. +#include <asm/i82489.h>
  1107. +#include <linux/smp.h>
  1108. +#include <asm/bitops.h>
  1109. +#include <asm/smp.h>
  1110. +
  1111. +extern void *vremap(unsigned long offset, unsigned long size);    /* Linus hasnt put this in the headers yet */
  1112. +
  1113. +static int smp_found_config=0;                /* Have we found an SMP box                 */
  1114. +
  1115. +unsigned long cpu_present_map = 0;            /* Bitmask of existing CPU's                 */
  1116. +int smp_num_cpus;                    /* Total count of live CPU's                 */
  1117. +int smp_threads_ready=0;                /* Set when the idlers are all forked             */
  1118. +volatile unsigned long cpu_callin_map[NR_CPUS] = {0,};    /* We always use 0 the rest is ready for parallel delivery */
  1119. +volatile unsigned long smp_invalidate_needed;        /* Used for the invalidate map thats also checked in the spinlock */
  1120. +struct cpuinfo_x86 cpu_data[NR_CPUS];            /* Per cpu bogomips and other parameters         */
  1121. +static unsigned int num_processors = 0;            /* Internal processor count                */
  1122. +static unsigned long io_apic_addr = 0;            /* Address of the I/O apic (not yet used)         */
  1123. +unsigned char boot_cpu_id = 0;                /* Processor that is doing the boot up             */
  1124. +static unsigned char *kstack_base,*kstack_end;        /* Kernel stack list pointers                 */
  1125. +static int smp_activated = 0;                /* Tripped once we need to start cross invalidating     */
  1126. +static volatile int smp_commenced=0;            /* Tripped when we start scheduling                 */
  1127. +static unsigned char nlong=0;                /* Apparent value for boot CPU                 */
  1128. +unsigned char *apic_reg=((unsigned char *)&nlong)-0x20;    /* Later set to the vremap() of the APIC         */
  1129. +unsigned long apic_retval;                /* Just debugging the assembler..             */
  1130. +unsigned char *kernel_stacks[NR_CPUS];            /* Kernel stack pointers for CPU's (debugging)        */
  1131. +
  1132. +static volatile unsigned char smp_cpu_in_msg[NR_CPUS];    /* True if this processor is sending an IPI        */
  1133. +static volatile unsigned long smp_msg_data;        /* IPI data pointer                    */
  1134. +static volatile int smp_src_cpu;            /* IPI sender processor                    */
  1135. +static volatile int smp_msg_id;                /* Message being sent                    */
  1136. +
  1137. +volatile unsigned long kernel_flag=0;            /* Kernel spinlock                     */
  1138. +volatile unsigned char active_kernel_processor = NO_PROC_ID;    /* Processor holding kernel spinlock        */
  1139. +volatile unsigned long kernel_counter=0;        /* Number of times the processor holds the lock        */
  1140. +volatile unsigned long syscall_count=0;        /* Number of times the processor holds the syscall lock    */
  1141. +volatile unsigned long smp_spins=0;            /* Count of cycles wasted to spinning            */
  1142. +
  1143. +volatile unsigned long ipi_count;            /* Number of IPI's delivered                */
  1144. +
  1145. +/* 
  1146. + *    Checksum an MP configuration block.
  1147. + */
  1148. + 
  1149. +static int mpf_checksum(unsigned char *mp, int len)
  1150. +{
  1151. +    int sum=0;
  1152. +    while(len--)
  1153. +        sum+=*mp++;
  1154. +    return sum&0xFF;
  1155. +}
  1156. +
  1157. +/*
  1158. + *    Processor encoding in an MP configuration block
  1159. + */
  1160. + 
  1161. +static char *mpc_family(int family,int model)
  1162. +{
  1163. +    static char n[32];
  1164. +    static char *model_defs[]=
  1165. +    {
  1166. +        "80486DX","80486DX",
  1167. +        "80486SX","80486DX/2 or 80487",
  1168. +        "80486SL","Intel5X2(tm)",
  1169. +        "Unknown","Unknown",
  1170. +        "80486DX/4"
  1171. +    };
  1172. +    if(family==0x5)
  1173. +        return("Pentium(tm)");
  1174. +    if(family==0x0F && model==0x0F)
  1175. +        return("Special controller");
  1176. +    if(family==0x04 && model<9)
  1177. +        return model_defs[model];
  1178. +    sprintf(n,"Unknown CPU [%d:%d]",family, model);
  1179. +    return n;
  1180. +}
  1181. +
  1182. +/*
  1183. + *    Read the MPC
  1184. + */
  1185. +
  1186. +static int smp_read_mpc(struct mp_config_table *mpc)
  1187. +{
  1188. +    char str[16];
  1189. +    int count=sizeof(*mpc);
  1190. +    int apics=0;
  1191. +    unsigned char *mpt=((unsigned char *)mpc)+count;
  1192. +
  1193. +    if(memcmp(mpc->mpc_signature,MPC_SIGNATURE,4))
  1194. +    {
  1195. +        printk("Bad signature [%c%c%c%c].\n",
  1196. +            mpc->mpc_signature[0],
  1197. +            mpc->mpc_signature[1],
  1198. +            mpc->mpc_signature[2],
  1199. +            mpc->mpc_signature[3]);
  1200. +        return 1;
  1201. +    }
  1202. +    if(mpf_checksum((unsigned char *)mpc,mpc->mpc_length))
  1203. +    {
  1204. +        printk("Checksum error.\n");
  1205. +        return 1;
  1206. +    }
  1207. +    if(mpc->mpc_spec!=0x01)
  1208. +    {
  1209. +        printk("Unsupported version (%d)\n",mpc->mpc_spec);
  1210. +        return 1;
  1211. +    }
  1212. +    memcpy(str,mpc->mpc_oem,8);
  1213. +    str[8]=0;
  1214. +    printk("OEM ID: %s ",str);
  1215. +    memcpy(str,mpc->mpc_productid,12);
  1216. +    str[12]=0;
  1217. +    printk("Product ID: %s ",str);
  1218. +    printk("APIC at: 0x%lX\n",mpc->mpc_lapic);
  1219. +    
  1220. +    /*
  1221. +     *    Now process the configuration blocks.
  1222. +     */
  1223. +     
  1224. +    while(count<mpc->mpc_length)
  1225. +    {
  1226. +        switch(*mpt)
  1227. +        {
  1228. +            case MP_PROCESSOR:
  1229. +            {
  1230. +                struct mpc_config_processor *m=
  1231. +                    (struct mpc_config_processor *)mpt;
  1232. +                if(m->mpc_cpuflag&CPU_ENABLED)
  1233. +                {
  1234. +                    printk("Processor #%d %s APIC version %d\n",
  1235. +                        m->mpc_apicid, 
  1236. +                        mpc_family((m->mpc_cpufeature&
  1237. +                            CPU_FAMILY_MASK)>>8,
  1238. +                            (m->mpc_cpufeature&
  1239. +                                CPU_MODEL_MASK)>>4),
  1240. +                        m->mpc_apicver);
  1241. +                    if(m->mpc_featureflag&(1<<0))
  1242. +                        printk("    Floating point unit present.\n");
  1243. +                    if(m->mpc_featureflag&(1<<7))
  1244. +                        printk("    Machine Exception supported.\n");
  1245. +                    if(m->mpc_featureflag&(1<<8))
  1246. +                        printk("    64 bit compare & exchange supported.\n");
  1247. +                    if(m->mpc_featureflag&(1<<9))
  1248. +                        printk("    Internal APIC present.\n");
  1249. +                    if(m->mpc_cpuflag&CPU_BOOTPROCESSOR)
  1250. +                    {
  1251. +                        printk("    Bootup CPU\n");
  1252. +                        boot_cpu_id=m->mpc_apicid;
  1253. +                        nlong = boot_cpu_id<<24;    /* Dummy 'self' for bootup */
  1254. +                    }
  1255. +                    else    /* Boot CPU already counted */
  1256. +                        num_processors++;
  1257. +                        
  1258. +                    if(m->mpc_apicid>NR_CPUS)
  1259. +                        printk("Processor #%d unused. (Max %d processors).\n",m->mpc_apicid, NR_CPUS);
  1260. +                    else                        
  1261. +                        cpu_present_map|=(1<<m->mpc_apicid);
  1262. +                }
  1263. +                mpt+=sizeof(*m);
  1264. +                count+=sizeof(*m);
  1265. +                break;
  1266. +            }
  1267. +            case MP_BUS:
  1268. +            {
  1269. +                struct mpc_config_bus *m=
  1270. +                    (struct mpc_config_bus *)mpt;
  1271. +                memcpy(str,m->mpc_bustype,6);
  1272. +                str[6]=0;
  1273. +                printk("Bus #%d is %s\n",
  1274. +                    m->mpc_busid,
  1275. +                    str);
  1276. +                mpt+=sizeof(*m);
  1277. +                count+=sizeof(*m);
  1278. +                break; 
  1279. +            }
  1280. +            case MP_IOAPIC:
  1281. +            {
  1282. +                struct mpc_config_ioapic *m=
  1283. +                    (struct mpc_config_ioapic *)mpt;
  1284. +                if(m->mpc_flags&MPC_APIC_USABLE)
  1285. +                {
  1286. +                    apics++;
  1287. +                                    printk("I/O APIC #%d Version %d at 0x%lX.\n",
  1288. +                                        m->mpc_apicid,m->mpc_apicver,
  1289. +                                        m->mpc_apicaddr);
  1290. +                                    io_apic_addr = m->mpc_apicaddr;
  1291. +                            }
  1292. +                                mpt+=sizeof(*m);
  1293. +                                count+=sizeof(*m); 
  1294. +                                break;
  1295. +            }
  1296. +            case MP_INTSRC:
  1297. +            {
  1298. +                struct mpc_config_intsrc *m=
  1299. +                    (struct mpc_config_intsrc *)mpt;
  1300. +                
  1301. +                mpt+=sizeof(*m);
  1302. +                count+=sizeof(*m);
  1303. +                break;
  1304. +            }
  1305. +            case MP_LINTSRC:
  1306. +            {
  1307. +                struct mpc_config_intlocal *m=
  1308. +                    (struct mpc_config_intlocal *)mpt;
  1309. +                mpt+=sizeof(*m);
  1310. +                count+=sizeof(*m);
  1311. +                break;
  1312. +            }
  1313. +        }
  1314. +    }
  1315. +    if(apics>1)
  1316. +        printk("Warning: Multiple APIC's not supported.\n");
  1317. +    return num_processors;                
  1318. +}
  1319. +
  1320. +/*
  1321. + *    Scan the memory blocks for an SMP configuration block.
  1322. + */
  1323. + 
  1324. +void smp_scan_config(unsigned long base, unsigned long length)
  1325. +{
  1326. +    unsigned long *bp=(unsigned long *)base;
  1327. +    struct intel_mp_floating *mpf;
  1328. +    num_processors = 1;        /* The boot processor */
  1329. +    
  1330. +/*    printk("Scan SMP from %p for %ld bytes.\n",
  1331. +        bp,length);*/
  1332. +    if(sizeof(*mpf)!=16)
  1333. +        printk("Error: MPF size\n");
  1334. +    
  1335. +    while(length>0)
  1336. +    {
  1337. +        if(*bp==SMP_MAGIC_IDENT)
  1338. +        {
  1339. +            mpf=(struct intel_mp_floating *)bp;
  1340. +            if(mpf->mpf_length==1 && 
  1341. +                !mpf_checksum((unsigned char *)bp,16) &&
  1342. +                mpf->mpf_specification==1)
  1343. +            {
  1344. +                printk("Intel multiprocessing (MPv1.1) available.\n");
  1345. +                if(mpf->mpf_feature2&(1<<7))
  1346. +                    printk("    IMCR and PIC mode supported.\n");
  1347. +                smp_found_config=1;
  1348. +                /*
  1349. +                 *    Now see if we need to read further.
  1350. +                 */
  1351. +                if(mpf->mpf_feature1!=0)
  1352. +                {
  1353. +                    num_processors=2;
  1354. +                    printk("I/O APIC at 0xFEC00000.\n");
  1355. +                    printk("Bus#0 is ");
  1356. +                }
  1357. +                switch(mpf->mpf_feature1)
  1358. +                {
  1359. +                    case 1:
  1360. +                        printk("ISA");
  1361. +                        break;
  1362. +                    case 2:
  1363. +                        printk("EISA with no IRQ8 chaining");
  1364. +                        break;
  1365. +                    case 3:
  1366. +                        printk("EISA");
  1367. +                        break;
  1368. +                    case 4:
  1369. +                        printk("MCA");
  1370. +                        break;
  1371. +                    case 5:
  1372. +                        printk("ISA\nBus#1 is PCI");
  1373. +                        break;
  1374. +                    case 6:
  1375. +                        printk("EISA\nBus #1 is PCI");
  1376. +                        break;
  1377. +                    case 7:
  1378. +                        printk("MCA\nBus #1 is PCI");
  1379. +                        break;
  1380. +                    case 0:
  1381. +                        break;
  1382. +                    default:
  1383. +                        printk("???\nUnknown standard configuration %d\n",
  1384. +                            mpf->mpf_feature1);
  1385. +                        return;
  1386. +                }
  1387. +                if(mpf->mpf_physptr)
  1388. +                    smp_read_mpc((void *)mpf->mpf_physptr);
  1389. +                printk("Processors: %d\n", num_processors);
  1390. +            }
  1391. +        }
  1392. +        bp+=4;
  1393. +        length-=16;
  1394. +    }
  1395. +}
  1396. +
  1397. +/*
  1398. + *    Trampoline 80x86 program as an array.
  1399. + */
  1400. +
  1401. +static unsigned char trampoline_data[]={ 
  1402. +#include  "trampoline.hex"
  1403. +};
  1404. +
  1405. +/*
  1406. + *    Currently trivial. Write the real->protected mode
  1407. + *    bootstrap into the page concerned. The caller
  1408. + *    has made sure its suitably aligned.
  1409. + */
  1410. + 
  1411. +static void install_trampoline(unsigned char *mp)
  1412. +{
  1413. +    memcpy(mp,trampoline_data,sizeof(trampoline_data));
  1414. +}
  1415. +
  1416. +/*
  1417. + *    We are called very early to get the low memory for the trampoline/kernel stacks
  1418. + *    This has to be done by mm/init.c to parcel us out nice low memory. We allocate
  1419. + *    the kernel stacks at 4K, 8K, 12K... currently (0-03FF is preserved for SMM and
  1420. + *    other things).
  1421. + */
  1422. + 
  1423. +unsigned long smp_alloc_memory(unsigned long mem_base)
  1424. +{
  1425. +    int size=(num_processors-1)*PAGE_SIZE;        /* Number of stacks needed */
  1426. +    /*
  1427. +     *    Our stacks have to be below the 1Mb line, and mem_base on entry
  1428. +     *    is 4K aligned.
  1429. +     */
  1430. +     
  1431. +    if(mem_base+size>=0x9F000)
  1432. +        panic("smp_alloc_memory: Insufficient low memory for kernel stacks.\n");
  1433. +    kstack_base=(void *)mem_base;
  1434. +    mem_base+=size;
  1435. +    kstack_end=(void *)mem_base;
  1436. +    return mem_base;
  1437. +}
  1438. +    
  1439. +/*
  1440. + *    Hand out stacks one at a time.
  1441. + */
  1442. + 
  1443. +static void *get_kernel_stack(void)
  1444. +{
  1445. +    void *stack=kstack_base;
  1446. +    if(kstack_base>=kstack_end)
  1447. +        return NULL;
  1448. +    kstack_base+=PAGE_SIZE;
  1449. +    return stack;
  1450. +}
  1451. +
  1452. +
  1453. +/*
  1454. + *    The bootstrap kernel entry code has set these up. Save them for
  1455. + *    a given CPU
  1456. + */
  1457. + 
  1458. +void smp_store_cpu_info(int id)
  1459. +{
  1460. +    struct cpuinfo_x86 *c=&cpu_data[id];
  1461. +    c->hard_math=hard_math;            /* Always assumed same currently */
  1462. +    c->x86=x86;
  1463. +    c->x86_model=x86_model;
  1464. +    c->x86_mask=x86_mask;
  1465. +    c->x86_capability=x86_capability;
  1466. +    c->fdiv_bug=fdiv_bug;
  1467. +    c->wp_works_ok=wp_works_ok;        /* Always assumed the same currently */
  1468. +    c->hlt_works_ok=hlt_works_ok;
  1469. +    c->udelay_val=loops_per_sec;
  1470. +    strcpy(c->x86_vendor_id, x86_vendor_id);
  1471. +}
  1472. +
  1473. +/*
  1474. + *    Architecture specific routine called by the kernel just before init is
  1475. + *    fired off. This allows the BP to have everything in order [we hope].
  1476. + *    At the end of this all the AP's will hit the system scheduling and off
  1477. + *    we go. Each AP will load the system gdt's and jump through the kernel
  1478. + *    init into idle(). At this point the scheduler will one day take over 
  1479. + *     and give them jobs to do. smp_callin is a standard routine
  1480. + *    we use to track CPU's as they power up.
  1481. + */
  1482. +
  1483. +void smp_commence(void)
  1484. +{
  1485. +    /*
  1486. +     *    Lets the callin's below out of their loop.
  1487. +     */
  1488. +    smp_commenced=1;
  1489. +}
  1490. + 
  1491. +void smp_callin(void)
  1492. +{
  1493. +    int cpuid=GET_APIC_ID(apic_read(APIC_ID));
  1494. +    unsigned long l;
  1495. +    /*
  1496. +     *    Activate our APIC
  1497. +     */
  1498. +     
  1499. +/*    printk("CALLIN %d\n",smp_processor_id());*/
  1500. +     l=apic_read(APIC_SPIV);
  1501. +     l|=(1<<8);        /* Enable */
  1502. +     apic_write(APIC_SPIV,l);
  1503. +     sti();
  1504. +    /*
  1505. +     *    Get our bogomips.
  1506. +     */    
  1507. +    calibrate_delay();
  1508. +    /*
  1509. +     *    Save our processor parameters
  1510. +     */
  1511. +     smp_store_cpu_info(cpuid);
  1512. +    /*
  1513. +     *    Allow the master to continue.
  1514. +     */    
  1515. +    set_bit(cpuid, &cpu_callin_map[0]);
  1516. +    /*
  1517. +     *    Until we are ready for SMP scheduling
  1518. +     */
  1519. +    load_ldt(0);
  1520. +/*    printk("Testing faulting...\n");
  1521. +    *(long *)0=1;         OOPS... */
  1522. +    local_invalidate();
  1523. +    while(!smp_commenced);
  1524. +    local_invalidate();
  1525. +/*    printk("Commenced..\n");*/
  1526. +    
  1527. +    /* This assumes the processor id's are consecutive 0..n-1 -  FIXME */
  1528. +    load_TR(cpuid);
  1529. +/*    while(1);*/
  1530. +}
  1531. +
  1532. +/*
  1533. + *    Cycle through the processors sending pentium IPI's to boot each.
  1534. + */
  1535. + 
  1536. +void smp_boot_cpus(void)
  1537. +{
  1538. +    int i=0;
  1539. +    int cpucount=0;
  1540. +    void *stack;
  1541. +    extern unsigned long init_user_stack[];
  1542. +    
  1543. +    /*
  1544. +     *    Map the local APIC into kernel space
  1545. +     */
  1546. +    
  1547. +    apic_reg = vremap(0xFEE00000,4096);
  1548. +    
  1549. +    
  1550. +    if(apic_reg == NULL)
  1551. +        panic("Unable to map local apic.\n");
  1552. +        
  1553. +    /*
  1554. +     *    Now scan the cpu present map and fire up anything we find.
  1555. +     */
  1556. +     
  1557. +     
  1558. +    kernel_stacks[boot_cpu_id]=(void *)init_user_stack;    /* Set up for boot processor first */
  1559. +
  1560. +    smp_store_cpu_info(boot_cpu_id);            /* Final full version of the data */
  1561. +    
  1562. +    active_kernel_processor=boot_cpu_id;
  1563. +        
  1564. +    for(i=0;i<NR_CPUS;i++)
  1565. +    {
  1566. +        if((cpu_present_map&(1<<i)) && i!=boot_cpu_id)        /* Rebooting yourself is a bad move */
  1567. +        {
  1568. +            unsigned long cfg;
  1569. +            int timeout;
  1570. +            
  1571. +            /*
  1572. +             *    We need a kernel stack for each processor.
  1573. +             */
  1574. +            
  1575. +            stack=get_kernel_stack();    /* We allocated these earlier */
  1576. +            if(stack==NULL)
  1577. +                panic("No memory for processor stacks.\n");
  1578. +            kernel_stacks[i]=stack;
  1579. +            install_trampoline(stack);
  1580. +            
  1581. +            printk("Booting processor %d stack %p: ",i,stack);            /* So we set whats up   */
  1582. +                
  1583. +            /*
  1584. +             *    Enable the local APIC
  1585. +             */
  1586. +             
  1587. +            cfg=apic_read(APIC_SPIV);
  1588. +            cfg|=(1<<8);        /* Enable APIC */
  1589. +            apic_write(APIC_SPIV,cfg);
  1590. +            
  1591. +            /*
  1592. +             *    This gunge sends an IPI (Inter Processor Interrupt) to the
  1593. +             *    processor we wish to wake. When the startup IPI is received
  1594. +             *    the target CPU does a real mode jump to the stack base.
  1595. +             */
  1596. +            
  1597. +            cfg=apic_read(APIC_ICR2);
  1598. +            cfg&=0x00FFFFFF;
  1599. +            apic_write(APIC_ICR2, cfg|SET_APIC_DEST_FIELD(i));            /* Target chip         */
  1600. +            cfg=apic_read(APIC_ICR);
  1601. +            cfg&=~0xFDFFF    ;                            /* Clear bits         */
  1602. +            cfg|=APIC_DEST_FIELD|APIC_DEST_DM_STARTUP|(((unsigned long)stack)>>12);    /* Boot on the stack     */        
  1603. +            apic_write(APIC_ICR, cfg);                        /* Kick the second     */
  1604. +            udelay(10);                                /* Masses of time     */
  1605. +            cfg=apic_read(APIC_ESR);
  1606. +            if(cfg&4)        /* Send accept error */
  1607. +                printk("Processor refused startup request.\n");
  1608. +            else
  1609. +            {
  1610. +                for(timeout=0;timeout<50000;timeout++)
  1611. +                {
  1612. +                    if(cpu_callin_map[0]&(1<<i))
  1613. +                        break;                /* It has booted */
  1614. +                    udelay(100);                /* Wait 5s total for a response */
  1615. +                }
  1616. +                if(cpu_callin_map[0]&(1<<i))
  1617. +                    cpucount++;
  1618. +                else
  1619. +                {
  1620. +                    /*
  1621. +                     *    At this point we should set up a BIOS warm start and try
  1622. +                     *    a RESTART IPI. The 486+82489 MP pair don't support STARTUP IPI's
  1623. +                     */
  1624. +                    if(*((unsigned char *)8192)==0xA5)
  1625. +                        printk("Stuck ??\n");
  1626. +                    else
  1627. +                        printk("Not responding.\n");
  1628. +                    cpu_present_map&=~(1<<i);
  1629. +                }
  1630. +            }
  1631. +        }
  1632. +    }
  1633. +    /*
  1634. +     *    Allow the user to impress friends.
  1635. +     */
  1636. +    if(cpucount==0)
  1637. +        printk("Error: only one processor found.\n");
  1638. +    else
  1639. +    {
  1640. +        printk("Total of %d processors activated.\n", cpucount+1);
  1641. +        smp_activated=1;
  1642. +        smp_num_cpus=cpucount+1;
  1643. +    }
  1644. +}
  1645. +
  1646. +
  1647. +/*
  1648. + *    A non wait message cannot pass data or cpu source info. This current setup
  1649. + *    is only safe because the kernel lock owner is the only person who can send a message.
  1650. + *
  1651. + *    Wrapping this whole block in a spinlock is not the safe answer either. A processor may
  1652. + *    get stuck with irq's off waiting to send a message and thus not replying to the person
  1653. + *    spinning for a reply....
  1654. + *
  1655. + *    In the end invalidate ought to be the NMI and a very very short function (to avoid the old
  1656. + *    IDE disk problems), and other messages sent with IRQ's enabled in a civilised fashion. That
  1657. + *    will also boost performance.
  1658. + */
  1659. + 
  1660. +void smp_message_pass(int target, int msg, unsigned long data, int wait)
  1661. +{
  1662. +    unsigned long cfg;
  1663. +    unsigned long target_map;
  1664. +    int p=smp_processor_id();
  1665. +    int irq=0x2d;                                /* IRQ 13 */
  1666. +    int ct=0;
  1667. +    static volatile int message_cpu = NO_PROC_ID;
  1668. +
  1669. +    /*
  1670. +     *    During boot up send no messages
  1671. +     */
  1672. +     
  1673. +    if(!smp_activated)
  1674. +        return;
  1675. +        
  1676. +    
  1677. +    /*
  1678. +     *    Skip the reschedule if we are waiting to clear a
  1679. +     *    message at this time. The reschedule cannot wait
  1680. +     *    but is not critical.
  1681. +     */
  1682. +    
  1683. +    if(msg==MSG_RESCHEDULE)                            /* Reschedules we do via trap 0x30 */
  1684. +    {
  1685. +        irq=0x30;
  1686. +        if(smp_cpu_in_msg[p])
  1687. +            return;
  1688. +    }
  1689. +
  1690. +    /*
  1691. +     *    Sanity check we don't re-enter this across CPU's. Only the kernel
  1692. +     *    lock holder may send messages. For a STOP_CPU we are bringing the
  1693. +     *    entire box to the fastest halt we can.. 
  1694. +     */
  1695. +     
  1696. +    if(message_cpu!=NO_PROC_ID && msg!=MSG_STOP_CPU)
  1697. +    {
  1698. +        panic("CPU #%d: Message pass %d but pass in progress by %d of %d\n",
  1699. +            smp_processor_id(),msg,message_cpu, smp_msg_id);
  1700. +    }
  1701. +    message_cpu=smp_processor_id();
  1702. +    
  1703. +
  1704. +    /*
  1705. +     *    We are busy
  1706. +     */
  1707. +         
  1708. +    smp_cpu_in_msg[p]++;
  1709. +    
  1710. +    /*
  1711. +     *    Reschedule is currently special
  1712. +     */
  1713. +     
  1714. +    if(msg!=MSG_RESCHEDULE)
  1715. +    {
  1716. +        smp_src_cpu=p;
  1717. +        smp_msg_id=msg;
  1718. +        smp_msg_data=data;
  1719. +    }
  1720. +    
  1721. +/*    printk("SMP message pass #%d to %d of %d\n",
  1722. +        p, msg, target);*/
  1723. +    
  1724. +    /*
  1725. +     *    Wait for the APIC to become ready - this should never occur. Its
  1726. +     *    a debugging check really.
  1727. +     */
  1728. +     
  1729. +    while(ct<1000)
  1730. +    {
  1731. +        cfg=apic_read(APIC_ICR);
  1732. +        if(!(cfg&(1<<12)))
  1733. +            break;
  1734. +        ct++;
  1735. +        udelay(10);
  1736. +    }
  1737. +    
  1738. +    /*
  1739. +     *    Just pray... there is nothing more we can do
  1740. +     */
  1741. +     
  1742. +    if(ct==1000)
  1743. +        printk("CPU #%d: previous IPI still not cleared after 10mS", smp_processor_id());
  1744. +        
  1745. +    /*
  1746. +     *    Program the APIC to deliver the IPI
  1747. +     */
  1748. +     
  1749. +    cfg=apic_read(APIC_ICR2);
  1750. +    cfg&=0x00FFFFFF;
  1751. +    apic_write(APIC_ICR2, cfg|SET_APIC_DEST_FIELD(target));            /* Target chip             */
  1752. +    cfg=apic_read(APIC_ICR);
  1753. +    cfg&=~0xFDFFF;                                /* Clear bits             */
  1754. +    cfg|=APIC_DEST_FIELD|APIC_DEST_DM_FIXED|irq;                /* Send an IRQ 13        */        
  1755. +
  1756. +    /*
  1757. +     *    Set the target requirement
  1758. +     */
  1759. +     
  1760. +    if(target==MSG_ALL_BUT_SELF)
  1761. +    {
  1762. +        cfg|=APIC_DEST_ALLBUT;
  1763. +        target_map=cpu_present_map;
  1764. +        cpu_callin_map[0]=(1<<smp_src_cpu);
  1765. +    }
  1766. +    else if(target==MSG_ALL)
  1767. +    {
  1768. +        cfg|=APIC_DEST_ALLINC;
  1769. +        target_map=cpu_present_map;
  1770. +        cpu_callin_map[0]=0;
  1771. +    }
  1772. +    else
  1773. +    {
  1774. +        target_map=(1<<target);
  1775. +        cpu_callin_map[0]=0;
  1776. +    }
  1777. +        
  1778. +    /*
  1779. +     *    Send the IPI. The write to APIC_ICR fires this off.
  1780. +     */
  1781. +     
  1782. +    apic_write(APIC_ICR, cfg);    
  1783. +    
  1784. +    /*
  1785. +     *    Spin waiting for completion
  1786. +     */
  1787. +     
  1788. +    switch(wait)
  1789. +    {
  1790. +        case 1:
  1791. +            while(cpu_callin_map[0]!=target_map);        /* Spin on the pass        */
  1792. +            break;
  1793. +        case 2:
  1794. +            while(smp_invalidate_needed);            /* Wait for invalidate map to clear */
  1795. +            break;
  1796. +    }
  1797. +    
  1798. +    /*
  1799. +     *    Record our completion
  1800. +     */
  1801. +     
  1802. +    smp_cpu_in_msg[p]--;
  1803. +    message_cpu=NO_PROC_ID;
  1804. +}
  1805. +
  1806. +/*
  1807. + *    This is fraught with deadlocks. Linus does an invalidate at a whim
  1808. + *    even with IRQ's off. We have to avoid a pair of crossing invalidates
  1809. + *    or we are doomed.  See the notes about smp_message_pass.
  1810. + */
  1811. + 
  1812. +void smp_invalidate(void)
  1813. +{
  1814. +    unsigned long flags;
  1815. +    if(smp_activated && smp_processor_id()!=active_kernel_processor)
  1816. +        panic("CPU #%d:Attempted invalidate IPI when not AKP(=%d)\n",smp_processor_id(),active_kernel_processor);
  1817. +/*    printk("SMI-");*/
  1818. +    
  1819. +    /*
  1820. +     *    The assignment is safe because its volatile so the compiler cannot reorder it,
  1821. +     *    because the i586 has strict memory ordering and because only the kernel lock holder
  1822. +     *    may issue an invalidate. If you break any one of those three change this to an atomic
  1823. +     *    bus locked or.
  1824. +     */
  1825. +    
  1826. +    smp_invalidate_needed=cpu_present_map&~(1<<smp_processor_id());
  1827. +    
  1828. +    /*
  1829. +     *    Processors spinning on the lock will see this IRQ late. The smp_invalidate_needed map will
  1830. +     *    ensure they dont do a spurious invalidate or miss one.
  1831. +     */
  1832. +     
  1833. +    save_flags(flags);
  1834. +    cli();
  1835. +    smp_message_pass(MSG_ALL_BUT_SELF, MSG_INVALIDATE_TLB, 0L, 2);
  1836. +    
  1837. +    /*
  1838. +     *    Flush the local TLB
  1839. +     */
  1840. +     
  1841. +    local_invalidate();
  1842. +    
  1843. +    restore_flags(flags);
  1844. +    
  1845. +    /*
  1846. +     *    Completed.
  1847. +     */
  1848. +     
  1849. +/*    printk("SMID\n");*/
  1850. +}
  1851. +
  1852. +/*    
  1853. + *    Reschedule call back
  1854. + */
  1855. +
  1856. +void smp_reschedule_irq(int cpl, struct pt_regs *regs)
  1857. +{
  1858. +    static int ct=0;
  1859. +    if(ct==0)
  1860. +    {
  1861. +        printk("Beginning scheduling on CPU#%d\n",smp_processor_id());
  1862. +        ct=1;
  1863. +    }
  1864. +    
  1865. +    if(smp_processor_id()!=active_kernel_processor)
  1866. +        panic("SMP Reschedule on CPU #%d, but #%d is active.\n",
  1867. +            smp_processor_id(), active_kernel_processor);
  1868. +    /*
  1869. +     *    Update resource usage on the slave timer tick.
  1870. +     */
  1871. +            
  1872. +    if (user_mode(regs)) 
  1873. +    {
  1874. +        current->utime++;
  1875. +        if (current->pid) 
  1876. +        {
  1877. +            if (current->priority < 15)
  1878. +                kstat.cpu_nice++;
  1879. +            else
  1880. +                kstat.cpu_user++;
  1881. +        }
  1882. +        /* Update ITIMER_VIRT for current task if not in a system call */
  1883. +        if (current->it_virt_value && !(--current->it_virt_value)) {
  1884. +            current->it_virt_value = current->it_virt_incr;
  1885. +            send_sig(SIGVTALRM,current,1);
  1886. +        }
  1887. +    } else {
  1888. +        current->stime++;
  1889. +        if(current->pid)
  1890. +            kstat.cpu_system++;
  1891. +#ifdef CONFIG_PROFILE
  1892. +        if (prof_buffer && current->pid) {
  1893. +            extern int _stext;
  1894. +            unsigned long eip = regs->eip - (unsigned long) &_stext;
  1895. +            eip >>= CONFIG_PROFILE_SHIFT;
  1896. +            if (eip < prof_len)
  1897. +                prof_buffer[eip]++;
  1898. +        }
  1899. +#endif
  1900. +    }
  1901. +    /*
  1902. +     * check the cpu time limit on the process.
  1903. +     */
  1904. +    if ((current->rlim[RLIMIT_CPU].rlim_max != RLIM_INFINITY) &&
  1905. +        (((current->stime + current->utime) / HZ) >= current->rlim[RLIMIT_CPU].rlim_max))
  1906. +        send_sig(SIGKILL, current, 1);
  1907. +    if ((current->rlim[RLIMIT_CPU].rlim_cur != RLIM_INFINITY) &&
  1908. +        (((current->stime + current->utime) % HZ) == 0)) {
  1909. +        unsigned long psecs = (current->stime + current->utime) / HZ;
  1910. +        /* send when equal */
  1911. +        if (psecs == current->rlim[RLIMIT_CPU].rlim_cur)
  1912. +            send_sig(SIGXCPU, current, 1);
  1913. +        /* and every five seconds thereafter. */
  1914. +        else if ((psecs > current->rlim[RLIMIT_CPU].rlim_cur) &&
  1915. +                ((psecs - current->rlim[RLIMIT_CPU].rlim_cur) % 5) == 0)
  1916. +            send_sig(SIGXCPU, current, 1);
  1917. +    }
  1918. +
  1919. +    /* Update ITIMER_PROF for the current task */
  1920. +    if (current->it_prof_value && !(--current->it_prof_value)) {
  1921. +        current->it_prof_value = current->it_prof_incr;
  1922. +        send_sig(SIGPROF,current,1);
  1923. +    }
  1924. +
  1925. +
  1926. +    /*
  1927. +     *    Don't reschedule if we are in an interrupt...
  1928. +     *    [This is test code and not needed in the end]
  1929. +     */
  1930. +     
  1931. +/*    if(intr_count==1)
  1932. +    {*/
  1933. +
  1934. +        /*
  1935. +         *    See if the slave processors need a schedule.
  1936. +         */
  1937. +
  1938. +        if ( 0 > --current->counter || current->pid == 0) 
  1939. +        {
  1940. +            current->counter = 0;
  1941. +            need_resched=1;
  1942. +        }
  1943. +/*    }*/
  1944. +
  1945. +    /*
  1946. +     *    Clear the IPI
  1947. +     */
  1948. +    apic_read(APIC_SPIV);        /* Dummy read */
  1949. +    apic_write(APIC_EOI, 0);    /* Docs say use 0 for future compatibility */
  1950. +}    
  1951. +
  1952. +/*
  1953. + *    Message call back.
  1954. + */
  1955. + 
  1956. +void smp_message_irq(int cpl, struct pt_regs *regs)
  1957. +{
  1958. +    static int n=0;
  1959. +    int i=smp_processor_id();
  1960. +/*    if(n++<NR_CPUS)
  1961. +        printk("IPI %d->%d(%d,%ld)\n",smp_src_cpu,i,smp_msg_id,smp_msg_data);*/
  1962. +    switch(smp_msg_id)
  1963. +    {
  1964. +        case 0:    /* IRQ 13 testing - boring */
  1965. +            return;
  1966. +            
  1967. +        /*
  1968. +         *    A TLB flush is needed.
  1969. +         */
  1970. +         
  1971. +        case MSG_INVALIDATE_TLB:
  1972. +            if(clear_bit(i,&smp_invalidate_needed))
  1973. +                local_invalidate();
  1974. +            set_bit(i, &cpu_callin_map[0]);
  1975. +            cpu_callin_map[0]|=1<<smp_processor_id();
  1976. +            break;
  1977. +            
  1978. +        /*
  1979. +         *    Halt other CPU's for a panic or reboot
  1980. +         */
  1981. +        case MSG_STOP_CPU:
  1982. +            while(1)
  1983. +            {
  1984. +                if(cpu_data[smp_processor_id()].hlt_works_ok)
  1985. +                    __asm__("hlt");
  1986. +            }
  1987. +        default:
  1988. +            printk("CPU #%d sent invalid cross CPU message to CPU #%d: %X(%lX).\n",
  1989. +                smp_src_cpu,smp_processor_id(),smp_msg_id,smp_msg_data);
  1990. +            break;
  1991. +    }
  1992. +    /*
  1993. +     *    Clear the IPI, so we can receive future IPI's
  1994. +     */
  1995. +     
  1996. +    apic_read(APIC_SPIV);        /* Dummy read */
  1997. +    apic_write(APIC_EOI, 0);    /* Docs say use 0 for future compatibility */
  1998. +}
  1999. diff -u --recursive --new-file v1.3.30/linux/arch/i386/kernel/time.c linux/arch/i386/kernel/time.c
  2000. --- v1.3.30/linux/arch/i386/kernel/time.c    Wed Sep 27 15:59:56 1995
  2001. +++ linux/arch/i386/kernel/time.c    Mon Oct  2 17:41:24 1995
  2002. @@ -26,104 +26,58 @@
  2003.  
  2004.  #define TIMER_IRQ 0
  2005.  
  2006. -static int set_rtc_mmss(unsigned long);
  2007. +/* Cycle counter value at the previous timer interrupt.. */
  2008. +static unsigned long long last_timer_cc = 0;
  2009. +static unsigned long long init_timer_cc = 0;
  2010.  
  2011. -/*
  2012. - * timer_interrupt() needs to keep up the real-time clock,
  2013. - * as well as call the "do_timer()" routine every clocktick
  2014. - */
  2015. -static void timer_interrupt(int irq, struct pt_regs * regs)
  2016. +static unsigned long do_fast_gettimeoffset(void)
  2017.  {
  2018. -    /* last time the cmos clock got updated */
  2019. -    static long last_rtc_update=0;
  2020. -
  2021. -    do_timer(regs);
  2022. +    unsigned long time_low, time_high;
  2023. +    unsigned long quotient, remainder;
  2024.  
  2025. +    /* Get last timer tick in absolute kernel time */
  2026. +    __asm__("subl %2,%0\n\t"
  2027. +        "sbbl %3,%1"
  2028. +        :"=r" (time_low), "=r" (time_high)
  2029. +        :"m" (*(0+(long *)&init_timer_cc)),
  2030. +         "m" (*(1+(long *)&init_timer_cc)),
  2031. +         "0" (*(0+(long *)&last_timer_cc)),
  2032. +         "1" (*(1+(long *)&last_timer_cc)));
  2033.      /*
  2034. -     * If we have an externally synchronized Linux clock, then update
  2035. -     * CMOS clock accordingly every ~11 minutes. Set_rtc_mmss() has to be
  2036. -     * called as close as possible to 500 ms before the new second starts.
  2037. +     * Divide the 64-bit time with the 32-bit jiffy counter,
  2038. +     * getting the quotient in clocks.
  2039. +     *
  2040. +     * Giving quotient = "average internal clocks per jiffy"
  2041.       */
  2042. -    if (time_state != TIME_BAD && xtime.tv_sec > last_rtc_update + 660 &&
  2043. -        xtime.tv_usec > 500000 - (tick >> 1) &&
  2044. -        xtime.tv_usec < 500000 + (tick >> 1))
  2045. -      if (set_rtc_mmss(xtime.tv_sec) == 0)
  2046. -        last_rtc_update = xtime.tv_sec;
  2047. -      else
  2048. -        last_rtc_update = xtime.tv_sec - 600; /* do it again in 60 s */
  2049. -}
  2050. +    __asm__("divl %2"
  2051. +        :"=a" (quotient), "=d" (remainder)
  2052. +        :"r" (jiffies),
  2053. +         "0" (time_low), "1" (time_high));
  2054. +
  2055. +    /* Read the time counter */
  2056. +    __asm__(".byte 0x0f,0x31"
  2057. +        :"=a" (time_low), "=d" (time_high));
  2058.  
  2059. -/* Converts Gregorian date to seconds since 1970-01-01 00:00:00.
  2060. - * Assumes input in normal date format, i.e. 1980-12-31 23:59:59
  2061. - * => year=1980, mon=12, day=31, hour=23, min=59, sec=59.
  2062. - *
  2063. - * [For the Julian calendar (which was used in Russia before 1917,
  2064. - * Britain & colonies before 1752, anywhere else before 1582,
  2065. - * and is still in use by some communities) leave out the
  2066. - * -year/100+year/400 terms, and add 10.]
  2067. - *
  2068. - * This algorithm was first published by Gauss (I think).
  2069. - *
  2070. - * WARNING: this function will overflow on 2106-02-07 06:28:16 on
  2071. - * machines were long is 32-bit! (However, as time_t is signed, we
  2072. - * will already get problems at other places on 2038-01-19 03:14:08)
  2073. - */
  2074. -static inline unsigned long mktime(unsigned int year, unsigned int mon,
  2075. -    unsigned int day, unsigned int hour,
  2076. -    unsigned int min, unsigned int sec)
  2077. -{
  2078. -    if (0 >= (int) (mon -= 2)) {    /* 1..12 -> 11,12,1..10 */
  2079. -        mon += 12;    /* Puts Feb last since it has leap day */
  2080. -        year -= 1;
  2081. -    }
  2082. -    return (((
  2083. -        (unsigned long)(year/4 - year/100 + year/400 + 367*mon/12 + day) +
  2084. -          year*365 - 719499
  2085. -        )*24 + hour /* now have hours */
  2086. -       )*60 + min /* now have minutes */
  2087. -      )*60 + sec; /* finally seconds */
  2088. -}
  2089. +    /* .. relative to previous jiffy (32 bits is enough) */
  2090. +    time_low -= (unsigned long) last_timer_cc;
  2091.  
  2092. -void time_init(void)
  2093. -{
  2094. -    unsigned int year, mon, day, hour, min, sec;
  2095. -    int i;
  2096. +    /*
  2097. +     * Time offset = (1000000/HZ * remainder) / quotient.
  2098. +     */
  2099. +    __asm__("mull %1\n\t"
  2100. +        "divl %2"
  2101. +        :"=a" (quotient), "=d" (remainder)
  2102. +        :"r" (quotient),
  2103. +         "0" (time_low), "1" (1000000/HZ));
  2104.  
  2105. -    /* The Linux interpretation of the CMOS clock register contents:
  2106. -     * When the Update-In-Progress (UIP) flag goes from 1 to 0, the
  2107. -     * RTC registers show the second which has precisely just started.
  2108. -     * Let's hope other operating systems interpret the RTC the same way.
  2109. +    /*
  2110. +     * Due to rounding errors (and jiffies inconsistencies),
  2111. +     * we need to check the result so that we'll get a timer
  2112. +     * that is monotonous.
  2113.       */
  2114. -    /* read RTC exactly on falling edge of update flag */
  2115. -    for (i = 0 ; i < 1000000 ; i++)    /* may take up to 1 second... */
  2116. -        if (CMOS_READ(RTC_FREQ_SELECT) & RTC_UIP)
  2117. -            break;
  2118. -    for (i = 0 ; i < 1000000 ; i++)    /* must try at least 2.228 ms */
  2119. -        if (!(CMOS_READ(RTC_FREQ_SELECT) & RTC_UIP))
  2120. -            break;
  2121. -    do { /* Isn't this overkill ? UIP above should guarantee consistency */
  2122. -        sec = CMOS_READ(RTC_SECONDS);
  2123. -        min = CMOS_READ(RTC_MINUTES);
  2124. -        hour = CMOS_READ(RTC_HOURS);
  2125. -        day = CMOS_READ(RTC_DAY_OF_MONTH);
  2126. -        mon = CMOS_READ(RTC_MONTH);
  2127. -        year = CMOS_READ(RTC_YEAR);
  2128. -    } while (sec != CMOS_READ(RTC_SECONDS));
  2129. -    if (!(CMOS_READ(RTC_CONTROL) & RTC_DM_BINARY) || RTC_ALWAYS_BCD)
  2130. -      {
  2131. -        BCD_TO_BIN(sec);
  2132. -        BCD_TO_BIN(min);
  2133. -        BCD_TO_BIN(hour);
  2134. -        BCD_TO_BIN(day);
  2135. -        BCD_TO_BIN(mon);
  2136. -        BCD_TO_BIN(year);
  2137. -      }
  2138. -    if ((year += 1900) < 1970)
  2139. -        year += 100;
  2140. -    xtime.tv_sec = mktime(year, mon, day, hour, min, sec);
  2141. -    xtime.tv_usec = 0;
  2142. -    if (request_irq(TIMER_IRQ, timer_interrupt, 0, "timer") != 0)
  2143. -        panic("Could not allocate timer IRQ!");
  2144. +    if (quotient >= 1000000/HZ)
  2145. +        quotient = 1000000/HZ-1;
  2146. +    return quotient;
  2147.  }
  2148.  
  2149.  /* This function must be called with interrupts disabled 
  2150. @@ -160,7 +114,7 @@
  2151.  
  2152.  #define TICK_SIZE tick
  2153.  
  2154. -static inline unsigned long do_gettimeoffset(void)
  2155. +static unsigned long do_slow_gettimeoffset(void)
  2156.  {
  2157.      int count;
  2158.      unsigned long offset = 0;
  2159. @@ -181,6 +135,8 @@
  2160.      return offset + count;
  2161.  }
  2162.  
  2163. +static unsigned long (*do_gettimeoffset)(void) = do_slow_gettimeoffset;
  2164. +
  2165.  /*
  2166.   * This version of gettimeofday has near microsecond resolution.
  2167.   */
  2168. @@ -279,4 +235,134 @@
  2169.      CMOS_WRITE(save_freq_select, RTC_FREQ_SELECT);
  2170.  
  2171.      return retval;
  2172. +}
  2173. +
  2174. +/* last time the cmos clock got updated */
  2175. +static long last_rtc_update = 0;
  2176. +
  2177. +/*
  2178. + * timer_interrupt() needs to keep up the real-time clock,
  2179. + * as well as call the "do_timer()" routine every clocktick
  2180. + */
  2181. +static inline void timer_interrupt(int irq, struct pt_regs * regs)
  2182. +{
  2183. +    do_timer(regs);
  2184. +
  2185. +    /*
  2186. +     * If we have an externally synchronized Linux clock, then update
  2187. +     * CMOS clock accordingly every ~11 minutes. Set_rtc_mmss() has to be
  2188. +     * called as close as possible to 500 ms before the new second starts.
  2189. +     */
  2190. +    if (time_state != TIME_BAD && xtime.tv_sec > last_rtc_update + 660 &&
  2191. +        xtime.tv_usec > 500000 - (tick >> 1) &&
  2192. +        xtime.tv_usec < 500000 + (tick >> 1))
  2193. +      if (set_rtc_mmss(xtime.tv_sec) == 0)
  2194. +        last_rtc_update = xtime.tv_sec;
  2195. +      else
  2196. +        last_rtc_update = xtime.tv_sec - 600; /* do it again in 60 s */
  2197. +    /* As we return to user mode fire off the other CPU schedulers.. this is 
  2198. +       basically because we don't yet share IRQ's around. This message is
  2199. +       rigged to be safe on the 386 - basically its a hack, so don't look
  2200. +       closely for now.. */
  2201. +    smp_message_pass(MSG_ALL_BUT_SELF, MSG_RESCHEDULE, 0L, 0); 
  2202. +        
  2203. +}
  2204. +
  2205. +/*
  2206. + * This is the same as the above, except we _also_ save the current
  2207. + * cycle counter value at the time of the timer interrupt, so that
  2208. + * we later on can estimate the time of day more exactly.
  2209. + */
  2210. +static void pentium_timer_interrupt(int irq, struct pt_regs * regs)
  2211. +{
  2212. +    /* read Pentium cycle counter */
  2213. +    __asm__(".byte 0x0f,0x31"
  2214. +        :"=a" (((unsigned long *) &last_timer_cc)[0]),
  2215. +         "=d" (((unsigned long *) &last_timer_cc)[1]));
  2216. +    timer_interrupt(irq, regs);
  2217. +}
  2218. +
  2219. +/* Converts Gregorian date to seconds since 1970-01-01 00:00:00.
  2220. + * Assumes input in normal date format, i.e. 1980-12-31 23:59:59
  2221. + * => year=1980, mon=12, day=31, hour=23, min=59, sec=59.
  2222. + *
  2223. + * [For the Julian calendar (which was used in Russia before 1917,
  2224. + * Britain & colonies before 1752, anywhere else before 1582,
  2225. + * and is still in use by some communities) leave out the
  2226. + * -year/100+year/400 terms, and add 10.]
  2227. + *
  2228. + * This algorithm was first published by Gauss (I think).
  2229. + *
  2230. + * WARNING: this function will overflow on 2106-02-07 06:28:16 on
  2231. + * machines were long is 32-bit! (However, as time_t is signed, we
  2232. + * will already get problems at other places on 2038-01-19 03:14:08)
  2233. + */
  2234. +static inline unsigned long mktime(unsigned int year, unsigned int mon,
  2235. +    unsigned int day, unsigned int hour,
  2236. +    unsigned int min, unsigned int sec)
  2237. +{
  2238. +    if (0 >= (int) (mon -= 2)) {    /* 1..12 -> 11,12,1..10 */
  2239. +        mon += 12;    /* Puts Feb last since it has leap day */
  2240. +        year -= 1;
  2241. +    }
  2242. +    return (((
  2243. +        (unsigned long)(year/4 - year/100 + year/400 + 367*mon/12 + day) +
  2244. +          year*365 - 719499
  2245. +        )*24 + hour /* now have hours */
  2246. +       )*60 + min /* now have minutes */
  2247. +      )*60 + sec; /* finally seconds */
  2248. +}
  2249. +
  2250. +void time_init(void)
  2251. +{
  2252. +    void (*irq_handler)(int, struct pt_regs *);
  2253. +    unsigned int year, mon, day, hour, min, sec;
  2254. +    int i;
  2255. +
  2256. +    /* The Linux interpretation of the CMOS clock register contents:
  2257. +     * When the Update-In-Progress (UIP) flag goes from 1 to 0, the
  2258. +     * RTC registers show the second which has precisely just started.
  2259. +     * Let's hope other operating systems interpret the RTC the same way.
  2260. +     */
  2261. +    /* read RTC exactly on falling edge of update flag */
  2262. +    for (i = 0 ; i < 1000000 ; i++)    /* may take up to 1 second... */
  2263. +        if (CMOS_READ(RTC_FREQ_SELECT) & RTC_UIP)
  2264. +            break;
  2265. +    for (i = 0 ; i < 1000000 ; i++)    /* must try at least 2.228 ms */
  2266. +        if (!(CMOS_READ(RTC_FREQ_SELECT) & RTC_UIP))
  2267. +            break;
  2268. +    do { /* Isn't this overkill ? UIP above should guarantee consistency */
  2269. +        sec = CMOS_READ(RTC_SECONDS);
  2270. +        min = CMOS_READ(RTC_MINUTES);
  2271. +        hour = CMOS_READ(RTC_HOURS);
  2272. +        day = CMOS_READ(RTC_DAY_OF_MONTH);
  2273. +        mon = CMOS_READ(RTC_MONTH);
  2274. +        year = CMOS_READ(RTC_YEAR);
  2275. +    } while (sec != CMOS_READ(RTC_SECONDS));
  2276. +    if (!(CMOS_READ(RTC_CONTROL) & RTC_DM_BINARY) || RTC_ALWAYS_BCD)
  2277. +      {
  2278. +        BCD_TO_BIN(sec);
  2279. +        BCD_TO_BIN(min);
  2280. +        BCD_TO_BIN(hour);
  2281. +        BCD_TO_BIN(day);
  2282. +        BCD_TO_BIN(mon);
  2283. +        BCD_TO_BIN(year);
  2284. +      }
  2285. +    if ((year += 1900) < 1970)
  2286. +        year += 100;
  2287. +    xtime.tv_sec = mktime(year, mon, day, hour, min, sec);
  2288. +    xtime.tv_usec = 0;
  2289. +
  2290. +    /* If we have the CPU hardware time counters, use them */
  2291. +    irq_handler = timer_interrupt;    
  2292. +    if (x86_capability & 16) {
  2293. +        irq_handler = pentium_timer_interrupt;
  2294. +        do_gettimeoffset = do_fast_gettimeoffset;
  2295. +        /* read Pentium cycle counter */
  2296. +        __asm__(".byte 0x0f,0x31"
  2297. +            :"=a" (((unsigned long *) &init_timer_cc)[0]),
  2298. +             "=d" (((unsigned long *) &init_timer_cc)[1]));
  2299. +    }
  2300. +    if (request_irq(TIMER_IRQ, irq_handler, 0, "timer") != 0)
  2301. +        panic("Could not allocate timer IRQ!");
  2302.  }
  2303. diff -u --recursive --new-file v1.3.30/linux/arch/i386/kernel/trampoline.S linux/arch/i386/kernel/trampoline.S
  2304. --- v1.3.30/linux/arch/i386/kernel/trampoline.S    Thu Jan  1 02:00:00 1970
  2305. +++ linux/arch/i386/kernel/trampoline.S    Mon Oct  2 14:25:10 1995
  2306. @@ -0,0 +1,75 @@
  2307. +!
  2308. +!    Trampoline.S    Derived from Setup.S by Linus Torvalds
  2309. +!
  2310. +!    Entry: CS:IP point to the start of our code, we are 
  2311. +!    in real mode with no stack, but the rest of the 
  2312. +!    trampoline page to make our stack and everything else
  2313. +!    is a mystery.
  2314. +!
  2315. +!    In fact we don't actually need a stack so we don't
  2316. +!    set one up.
  2317. +!
  2318. +!    We jump into the boot/compressed/head.S code. So you'd
  2319. +!    better be running a compressed kernel image or you
  2320. +!    won't get very far.
  2321. +!
  2322. +#define __ASSEMBLY__
  2323. +#include <linux/config.h>
  2324. +#include <asm/segment.h>
  2325. +
  2326. +.text
  2327. +    extrn startup32
  2328. +
  2329. +entry start
  2330. +start:
  2331. +!    nop
  2332. +!    jmp start    !     Test
  2333. +    mov ax,cs    !    Code and data in the same place
  2334. +    mov ds,ax    !
  2335. +    mov cx,ax    !    Pass stack info to the 32bit boot
  2336. +    add cx,cx
  2337. +    add cx,cx
  2338. +    add cx,cx
  2339. +    add cx,cx    !    Segment -> Offset
  2340. +    add cx, #4096   !    End of page is wanted
  2341. +    mov     bx,#1    !    Flag an SMP trampoline
  2342. +    cli        !    We should be safe anyway
  2343. +
  2344. +    lidt    idt_48    !    load idt with 0,0
  2345. +    lgdt    gdt_48    !    load gdt with whatever is appropriate
  2346. +
  2347. +    xor    ax,ax    
  2348. +    inc    ax    !    protected mode (PE) bit
  2349. +    lmsw    ax    !    Into protected mode
  2350. +    jmp    flush_instr
  2351. +flush_instr:
  2352. +    jmpi    8192+startup32,KERNEL_CS    !    Jump to the 32bit trampoline code
  2353. +!    jmpi    0x100000,KERNEL_CS        !    Jump into the 32bit startup
  2354. +!    .byte   0x66,0x67            !    32bit
  2355. +!    .byte    0xea,0x00,0x00,0x10,0x00,0x10,0x00    !jmpi    .0x100000,KERNEL_CS
  2356. +
  2357. +gdt:
  2358. +    .word    0,0,0,0        ! dummy
  2359. +
  2360. +    .word    0,0,0,0        ! unused
  2361. +
  2362. +    .word    0x07FF        ! 8Mb - limit=2047 (2048*4096=8Mb)
  2363. +    .word    0x0000        ! base address=0
  2364. +    .word    0x9A00        ! code read/exec
  2365. +    .word    0x00C0        ! granularity=4096, 386
  2366. +
  2367. +    .word    0x07FF        ! 8Mb - limit=2047 (2048*4096=8Mb)
  2368. +    .word    0x0000        ! base address=0
  2369. +    .word    0x9200        ! data read/write
  2370. +    .word    0x00C0        ! granularity=4096, 386
  2371. +
  2372. +idt_48:
  2373. +    .word    0            ! idt limit=0
  2374. +    .word    0,0            ! idt base=0L
  2375. +
  2376. +gdt_48:
  2377. +    .word    0x800        ! gdt limit=2048, 256 GDT entries
  2378. +    .word    8192+gdt,0x0    ! gdt base = 8192+gdt (first SMP CPU)
  2379. +                ! we load the others with the first table
  2380. +                ! saves rewriting gdt_48 for each
  2381. +
  2382. diff -u --recursive --new-file v1.3.30/linux/arch/i386/kernel/trampoline32.S linux/arch/i386/kernel/trampoline32.S
  2383. --- v1.3.30/linux/arch/i386/kernel/trampoline32.S    Thu Jan  1 02:00:00 1970
  2384. +++ linux/arch/i386/kernel/trampoline32.S    Mon Oct  2 14:25:10 1995
  2385. @@ -0,0 +1,21 @@
  2386. +!
  2387. +!    32bit side of the trampoline code
  2388. +!
  2389. +#define __ASSEMBLY__
  2390. +#include <linux/config.h>
  2391. +#include <asm/segment.h>
  2392. +!
  2393. +!
  2394. +!    Anything but a relative address here will be wrong by 8K...
  2395. +!
  2396. +    .globl startup32
  2397. +.text
  2398. +startup32:
  2399. +!    Run the kernel
  2400. +    mov    eax,#KERNEL_DS
  2401. +    mov    ds,ax
  2402. +    mov    eax,#0xA5A5A5A5
  2403. +    mov    [8192],eax
  2404. +    jmpi    0x100000,KERNEL_CS
  2405. +l1:
  2406. +    .byte    0xEA,0x00,0x00,0x10,0x00,0x10,0x00
  2407. diff -u --recursive --new-file v1.3.30/linux/arch/i386/kernel/traps.c linux/arch/i386/kernel/traps.c
  2408. --- v1.3.30/linux/arch/i386/kernel/traps.c    Wed Aug  2 13:20:58 1995
  2409. +++ linux/arch/i386/kernel/traps.c    Mon Oct  2 14:25:10 1995
  2410. @@ -10,6 +10,7 @@
  2411.   * to mainly kill the offending process (probably by giving it a signal,
  2412.   * but possibly by killing it outright if necessary).
  2413.   */
  2414. +#include <linux/config.h>
  2415.  #include <linux/head.h>
  2416.  #include <linux/sched.h>
  2417.  #include <linux/kernel.h>
  2418. @@ -111,6 +112,7 @@
  2419.      }
  2420.      console_verbose();
  2421.      printk("%s: %04lx\n", str, err & 0xffff);
  2422. +    printk("CPU:    %d\n", smp_processor_id());
  2423.      printk("EIP:    %04x:%08lx\nEFLAGS: %08lx\n", 0xffff & regs->cs,regs->eip,regs->eflags);
  2424.      printk("eax: %08lx   ebx: %08lx   ecx: %08lx   edx: %08lx\n",
  2425.          regs->eax, regs->ebx, regs->ecx, regs->edx);
  2426. @@ -190,11 +192,15 @@
  2427.  
  2428.  asmlinkage void do_nmi(struct pt_regs * regs, long error_code)
  2429.  {
  2430. +#ifdef CONFIG_SMP_NMI_INVAL
  2431. +    smp_invalidate_rcv();
  2432. +#else
  2433.  #ifndef CONFIG_IGNORE_NMI
  2434.      printk("Uhhuh. NMI received. Dazed and confused, but trying to continue\n");
  2435.      printk("You probably have a hardware problem with your RAM chips or a\n");
  2436.      printk("power saving mode enabled.\n");
  2437.  #endif    
  2438. +#endif
  2439.  }
  2440.  
  2441.  asmlinkage void do_debug(struct pt_regs * regs, long error_code)
  2442. @@ -236,7 +242,19 @@
  2443.  void math_error(void)
  2444.  {
  2445.      struct i387_hard_struct * env;
  2446. -
  2447. +#ifdef CONFIG_SMP
  2448. +    env=¤t->tss.i387.hard;
  2449. +    send_sig(SIGFPE, current, 1);
  2450. +    /*
  2451. +     *    Save the info for the exception handler
  2452. +     */
  2453. +    __asm__ __volatile__("fnsave %0":"=m" (*env));
  2454. +    current->flags&=~PF_USEDFPU;
  2455. +    /*
  2456. +     *    Cause a trap if they use the FPU again.
  2457. +     */
  2458. +    stts();
  2459. +#else
  2460.      clts();
  2461.      if (!last_task_used_math) {
  2462.          __asm__("fnclex");
  2463. @@ -253,6 +271,7 @@
  2464.      env->fos = env->twd;
  2465.      env->swd &= 0xffff3800;
  2466.      env->twd = 0xffffffff;
  2467. +#endif    
  2468.  }
  2469.  
  2470.  asmlinkage void do_coprocessor_error(struct pt_regs * regs, long error_code)
  2471. @@ -270,6 +289,30 @@
  2472.   */
  2473.  asmlinkage void math_state_restore(void)
  2474.  {
  2475. +#ifdef CONFIG_SMP
  2476. +/*
  2477. + *    SMP is actually simpler than uniprocessor for once. Because
  2478. + *    we can't pull the delayed FPU switching trick Linus does
  2479. + *    we simply have to do the restore each context switch and
  2480. + *    set the flag. switch_to() will always save the state in
  2481. + *    case we swap processors. We also don't use the coprocessor
  2482. + *    timer - IRQ 13 mode isnt used with SMP machines (thank god).
  2483. + *
  2484. + *    If this actually works it will be a miracle however
  2485. + */
  2486. +    __asm__ __volatile__("clts");        /* Allow maths ops (or we recurse) */
  2487. +    if(current->used_math)
  2488. +        __asm__("frstor %0": :"m" (current->tss.i387));
  2489. +    else
  2490. +    {
  2491. +        /*
  2492. +         *    Our first FPU usage, clean the chip.
  2493. +         */
  2494. +        __asm__("fninit");
  2495. +        current->used_math = 1;
  2496. +    }
  2497. +    current->flags|=PF_USEDFPU;        /* So we fnsave on switch_to() */
  2498. +#else
  2499.      __asm__ __volatile__("clts");
  2500.      if (last_task_used_math == current)
  2501.          return;
  2502. @@ -287,6 +330,7 @@
  2503.          current->used_math=1;
  2504.      }
  2505.      timer_active &= ~(1<<COPRO_TIMER);
  2506. +#endif    
  2507.  }
  2508.  
  2509.  #ifndef CONFIG_MATH_EMULATION
  2510. @@ -305,7 +349,15 @@
  2511.  {
  2512.      int i;
  2513.      struct desc_struct * p;
  2514. -
  2515. +    static int smptrap=0;
  2516. +    
  2517. +    if(smptrap)
  2518. +    {
  2519. +        __asm__("pushfl ; andl $0xffffbfff,(%esp) ; popfl");
  2520. +        load_ldt(0);
  2521. +        return;
  2522. +    }
  2523. +    smptrap++;
  2524.      if (strncmp((char*)0x0FFFD9, "EISA", 4) == 0)
  2525.          EISA_bus = 1;
  2526.      set_call_gate(&default_ldt,lcall7);
  2527. diff -u --recursive --new-file v1.3.30/linux/arch/i386/mm/init.c linux/arch/i386/mm/init.c
  2528. --- v1.3.30/linux/arch/i386/mm/init.c    Mon Sep 25 12:26:21 1995
  2529. +++ linux/arch/i386/mm/init.c    Mon Oct  2 14:25:10 1995
  2530. @@ -15,6 +15,7 @@
  2531.  #include <linux/ptrace.h>
  2532.  #include <linux/mman.h>
  2533.  #include <linux/mm.h>
  2534. +#include <linux/smp.h>
  2535.  
  2536.  #include <asm/system.h>
  2537.  #include <asm/segment.h>
  2538. @@ -111,10 +112,27 @@
  2539.   * and SMM (for laptops with [34]86/SL chips) may need it.  It is read
  2540.   * and write protected to detect null pointer references in the
  2541.   * kernel.
  2542. + * It may also hold the MP configuration table when we are booting SMP.
  2543.   */
  2544.  #if 0
  2545.      memset((void *) 0, 0, PAGE_SIZE);
  2546.  #endif
  2547. +#ifdef CONFIG_SMP
  2548. +    smp_scan_config(0x0,0x400);    /* Scan the bottom 1K for a signature */
  2549. +    /*
  2550. +     *    FIXME: Linux assumes you have 640K of base ram.. this continues
  2551. +     *    the error...
  2552. +     */
  2553. +    smp_scan_config(639*0x400,0x400);    /* Scan the top 1K of base RAM */
  2554. +    smp_scan_config(0xF0000,0x10000);    /* Scan the 64K of bios */
  2555. +    /*
  2556. +     *    If it is an SMP machine we should know now, unless the configuration
  2557. +     *    is in an EISA/MCA bus machine with an extended bios data area. I don't
  2558. +     *    have such a machine so someone else can fill in the check of the EBDA
  2559. +     *    here.
  2560. +     */
  2561. +/*    smp_alloc_memory(8192); */
  2562. +#endif
  2563.  #ifdef CONFIG_TEST_VERIFY_AREA
  2564.      wp_works_ok = 0;
  2565.  #endif
  2566. @@ -123,6 +141,7 @@
  2567.      pg_dir = swapper_pg_dir;
  2568.      while (address < end_mem) {
  2569.  #ifdef CONFIG_PENTIUM_MM
  2570. +#ifndef CONFIG_SMP
  2571.          if (address <= end_mem + 4*1024*1024 &&
  2572.              (x86_capability & 8)) {
  2573.  #ifdef GAS_KNOWS_CR4
  2574. @@ -144,6 +163,7 @@
  2575.              continue;
  2576.          }
  2577.  #endif
  2578. +#endif
  2579.          /* map the memory at virtual addr 0xC0000000 */
  2580.          pg_table = (pte_t *) (PAGE_MASK & pgd_val(pg_dir[768]));
  2581.          if (!pg_table) {
  2582. @@ -184,6 +204,14 @@
  2583.  
  2584.      /* mark usable pages in the mem_map[] */
  2585.      start_low_mem = PAGE_ALIGN(start_low_mem);
  2586. +
  2587. +#ifdef CONFIG_SMP
  2588. +    /*
  2589. +     * But first pinch a few for the stack/trampoline stuff
  2590. +     */
  2591. +    start_low_mem += PAGE_SIZE;                /* 32bit startup code */
  2592. +    start_low_mem = smp_alloc_memory(start_low_mem);     /* AP processor stacks */
  2593. +#endif
  2594.      start_mem = PAGE_ALIGN(start_mem);
  2595.  
  2596.      /*
  2597. diff -u --recursive --new-file v1.3.30/linux/drivers/block/genhd.c linux/drivers/block/genhd.c
  2598. --- v1.3.30/linux/drivers/block/genhd.c    Mon Sep 25 12:26:21 1995
  2599. +++ linux/drivers/block/genhd.c    Fri Sep 29 09:27:39 1995
  2600. @@ -88,7 +88,7 @@
  2601.      this_sector = first_sector;
  2602.  
  2603.      while (1) {
  2604. -        if ((current_minor & mask) >= hd->max_p)
  2605. +        if ((current_minor & mask) == 0)
  2606.              return;
  2607.          if (!(bh = bread(dev,0,1024)))
  2608.              return;
  2609. @@ -134,7 +134,7 @@
  2610.  
  2611.              add_partition(hd, current_minor, this_sector+p->start_sect, p->nr_sects);
  2612.              current_minor++;
  2613. -            if ((current_minor & mask) >= hd->max_p)
  2614. +            if ((current_minor & mask) == 0)
  2615.                goto done;
  2616.          }
  2617.          /*
  2618. @@ -254,8 +254,6 @@
  2619.          if (!p->nr_sects)
  2620.              continue;
  2621.          add_partition(hd, minor, first_sector+p->start_sect, p->nr_sects);
  2622. -        if ((current_minor & 0x3f) >= 60)
  2623. -            continue;
  2624.          if (p->sys_ind == EXTENDED_PARTITION) {
  2625.              printk(" <");
  2626.              /*
  2627. @@ -280,7 +278,7 @@
  2628.          p = (struct partition *) (0x1be + data);
  2629.          for (i = 4 ; i < 16 ; i++, current_minor++) {
  2630.              p--;
  2631. -            if ((current_minor & mask) >= mask-2)
  2632. +            if ((current_minor & mask) == 0)
  2633.                  break;
  2634.              if (!(p->start_sect && p->nr_sects))
  2635.                  continue;
  2636. @@ -299,6 +297,7 @@
  2637.  static int osf_partition(struct gendisk *hd, unsigned int dev, unsigned long first_sector)
  2638.  {
  2639.      int i;
  2640. +    int mask = (1 << hd->minor_shift) - 1;
  2641.      struct buffer_head *bh;
  2642.      struct disklabel {
  2643.          u32 d_magic;
  2644. @@ -351,6 +350,8 @@
  2645.          return 0;
  2646.      }
  2647.      for (i = 0 ; i < label->d_npartitions; i++, partition++) {
  2648. +        if ((current_minor & mask) == 0)
  2649. +                break;
  2650.          if (partition->p_size)
  2651.              add_partition(hd, current_minor,
  2652.                  first_sector+partition->p_offset,
  2653. diff -u --recursive --new-file v1.3.30/linux/drivers/block/ide.c linux/drivers/block/ide.c
  2654. --- v1.3.30/linux/drivers/block/ide.c    Wed Sep 27 15:59:57 1995
  2655. +++ linux/drivers/block/ide.c    Fri Sep 29 09:27:28 1995
  2656. @@ -149,10 +149,9 @@
  2657.   *  Driver compile-time options are in ide.h
  2658.   *
  2659.   *  To do, in likely order of completion:
  2660. - *    - figure out why Mitsumi ATAPI cdroms are having trouble..
  2661.   *    - add ioctls to get/set interface timings on cmd640, ht6560b, triton
  2662.   *    - modify kernel to obtain BIOS geometry for drives on 2nd/3rd/4th i/f
  2663. - *    - improved CMD support:  probably handing this off to someone else
  2664. + *    - improved CMD support:  handed this off to someone else
  2665.   *    - find someone to work on IDE *tape drive* support
  2666.   */
  2667.  
  2668. diff -u --recursive --new-file v1.3.30/linux/drivers/block/triton.c linux/drivers/block/triton.c
  2669. --- v1.3.30/linux/drivers/block/triton.c    Mon Sep 18 14:53:51 1995
  2670. +++ linux/drivers/block/triton.c    Fri Sep 29 09:27:28 1995
  2671. @@ -44,8 +44,14 @@
  2672.   * Testing was done with an ASUS P55TP4XE/100 system and the following drives:
  2673.   *
  2674.   *   Quantum Fireball 1080A (1Gig w/83kB buffer), DMA mode2, PIO mode4.
  2675. - *    - DMA mode2 works fine (7.4MB/sec), despite the tiny on-drive buffer.
  2676. + *    - DMA mode2 works well (7.4MB/sec), despite the tiny on-drive buffer.
  2677.   *    - This drive also does PIO mode4, at about the same speed as DMA mode2.
  2678. + *      An awesome drive for the price!
  2679. + *
  2680. + *   Fujitsu M1606TA (1Gig w/256kB buffer), DMA mode2, PIO mode4.
  2681. + *    - DMA mode2 gives horrible performance (1.6MB/sec), despite the good
  2682. + *      size of the on-drive buffer and a boasted 10ms average access time.
  2683. + *    - PIO mode4 was better, but peaked at a mere 4.5MB/sec.
  2684.   *
  2685.   *   Micropolis MC2112A (1Gig w/508kB buffer), drive pre-dates EIDE and ATA2.
  2686.   *    - DMA works fine (2.2MB/sec), probably due to the large on-drive buffer.
  2687. diff -u --recursive --new-file v1.3.30/linux/drivers/char/keyboard.c linux/drivers/char/keyboard.c
  2688. --- v1.3.30/linux/drivers/char/keyboard.c    Wed Sep 27 15:59:57 1995
  2689. +++ linux/drivers/char/keyboard.c    Mon Oct  2 08:21:06 1995
  2690. @@ -1186,6 +1186,11 @@
  2691.      request_irq(KEYBOARD_IRQ, keyboard_interrupt, 0, "keyboard");
  2692.      request_region(0x60,16,"kbd");
  2693.  #ifdef __alpha__
  2694. +    /* if there is an input byte left, eat it up: */
  2695. +    if (inb(0x64) & 0x01) {
  2696. +        inb(0x60);
  2697. +    }
  2698. +
  2699.      /* enable keyboard interrupts, PC/AT mode */
  2700.      kb_wait();
  2701.      outb(0x60,0x64);    /* write PS/2 Mode Register */
  2702. diff -u --recursive --new-file v1.3.30/linux/drivers/char/mem.c linux/drivers/char/mem.c
  2703. --- v1.3.30/linux/drivers/char/mem.c    Wed Sep 27 15:59:57 1995
  2704. +++ linux/drivers/char/mem.c    Tue Oct  3 12:14:46 1995
  2705. @@ -26,7 +26,7 @@
  2706.  extern long soundcard_init(long mem_start);
  2707.  #endif
  2708.  
  2709. -static int read_ram(struct inode * inode, struct file * file,char * buf, int count)
  2710. +static int read_ram(struct inode * inode, struct file * file, char * buf, int count)
  2711.  {
  2712.      return -EIO;
  2713.  }
  2714. @@ -36,11 +36,12 @@
  2715.      return -EIO;
  2716.  }
  2717.  
  2718. -static int read_mem(struct inode * inode, struct file * file,char * buf, int count)
  2719. +static int read_mem(struct inode * inode, struct file * file, char * buf, int count)
  2720.  {
  2721.      unsigned long p = file->f_pos;
  2722.      int read;
  2723.  
  2724. +    p += PAGE_OFFSET;
  2725.      if (count < 0)
  2726.          return -EINVAL;
  2727.      if (MAP_NR(p) >= MAP_NR(high_memory))
  2728. @@ -48,24 +49,27 @@
  2729.      if (count > high_memory - p)
  2730.          count = high_memory - p;
  2731.      read = 0;
  2732. -    while (p < PAGE_SIZE && count > 0) {
  2733. +#if defined(__i386__)        /* we don't have page 0 mapped on x86.. */
  2734. +    while (p < PAGE_OFFSET + PAGE_SIZE && count > 0) {
  2735.          put_user(0,buf);
  2736.          buf++;
  2737.          p++;
  2738.          count--;
  2739.          read++;
  2740.      }
  2741. -    memcpy_tofs(buf,(void *) p,count);
  2742. +#endif
  2743. +    memcpy_tofs(buf, (void *) p, count);
  2744.      read += count;
  2745.      file->f_pos += read;
  2746.      return read;
  2747.  }
  2748.  
  2749. -static int write_mem(struct inode * inode, struct file * file,const char * buf, int count)
  2750. +static int write_mem(struct inode * inode, struct file * file, const char * buf, int count)
  2751.  {
  2752.      unsigned long p = file->f_pos;
  2753.      int written;
  2754.  
  2755. +    p += PAGE_OFFSET;
  2756.      if (count < 0)
  2757.          return -EINVAL;
  2758.      if (MAP_NR(p) >= MAP_NR(high_memory))
  2759. @@ -73,14 +77,16 @@
  2760.      if (count > high_memory - p)
  2761.          count = high_memory - p;
  2762.      written = 0;
  2763. -    while (p < PAGE_SIZE && count > 0) {
  2764. +#if defined(__i386__)        /* we don't have page 0 mapped on x86.. */
  2765. +    while (PAGE_OFFSET + p < PAGE_SIZE && count > 0) {
  2766.          /* Hmm. Do something? */
  2767.          buf++;
  2768.          p++;
  2769.          count--;
  2770.          written++;
  2771.      }
  2772. -    memcpy_fromfs((void *) p,buf,count);
  2773. +#endif
  2774. +    memcpy_fromfs((void *) p, buf, count);
  2775.      written += count;
  2776.      file->f_pos += written;
  2777.      return count;
  2778. @@ -121,7 +127,7 @@
  2779.      return read1 + read2;
  2780.  }
  2781.  
  2782. -static int read_port(struct inode * inode,struct file * file,char * buf, int count)
  2783. +static int read_port(struct inode * inode, struct file * file,char * buf, int count)
  2784.  {
  2785.      unsigned int i = file->f_pos;
  2786.      char * tmp = buf;
  2787. @@ -135,7 +141,7 @@
  2788.      return tmp-buf;
  2789.  }
  2790.  
  2791. -static int write_port(struct inode * inode,struct file * file,const char * buf, int count)
  2792. +static int write_port(struct inode * inode, struct file * file, const char * buf, int count)
  2793.  {
  2794.      unsigned int i = file->f_pos;
  2795.      const char * tmp = buf;
  2796. @@ -149,17 +155,17 @@
  2797.      return tmp-buf;
  2798.  }
  2799.  
  2800. -static int read_null(struct inode * node,struct file * file,char * buf,int count)
  2801. +static int read_null(struct inode * node, struct file * file, char * buf, int count)
  2802.  {
  2803.      return 0;
  2804.  }
  2805.  
  2806. -static int write_null(struct inode * inode,struct file * file, const char * buf, int count)
  2807. +static int write_null(struct inode * inode, struct file * file, const char * buf, int count)
  2808.  {
  2809.      return count;
  2810.  }
  2811.  
  2812. -static int read_zero(struct inode * node,struct file * file,char * buf,int count)
  2813. +static int read_zero(struct inode * node, struct file * file, char * buf, int count)
  2814.  {
  2815.      int left;
  2816.  
  2817. @@ -179,12 +185,12 @@
  2818.      return 0;
  2819.  }
  2820.  
  2821. -static int read_full(struct inode * node,struct file * file,char * buf,int count)
  2822. +static int read_full(struct inode * node, struct file * file, char * buf,int count)
  2823.  {
  2824.      return count;
  2825.  }
  2826.  
  2827. -static int write_full(struct inode * inode,struct file * file, const char * buf, int count)
  2828. +static int write_full(struct inode * inode, struct file * file, const char * buf, int count)
  2829.  {
  2830.      return -ENOSPC;
  2831.  }
  2832. @@ -199,7 +205,7 @@
  2833.      return file->f_pos=0;
  2834.  }
  2835.  /*
  2836. - * The memory devices use the full 32 bits of the offset, and so we cannot
  2837. + * The memory devices use the full 32/64 bits of the offset, and so we cannot
  2838.   * check against negative addresses: they are ok. The return value is weird,
  2839.   * though, in that case (0).
  2840.   *
  2841. diff -u --recursive --new-file v1.3.30/linux/drivers/char/msbusmouse.c linux/drivers/char/msbusmouse.c
  2842. --- v1.3.30/linux/drivers/char/msbusmouse.c    Fri Sep 15 11:13:01 1995
  2843. +++ linux/drivers/char/msbusmouse.c    Tue Oct  3 08:38:10 1995
  2844. @@ -39,6 +39,7 @@
  2845.  #endif
  2846.  
  2847.  #include <linux/kernel.h>
  2848. +#include <linux/ioport.h>
  2849.  #include <linux/sched.h>
  2850.  #include <linux/busmouse.h>
  2851.  #include <linux/signal.h>
  2852. @@ -188,6 +189,10 @@
  2853.      mouse.buttons = 0x80;
  2854.      mouse.dx = mouse.dy = 0;
  2855.      mouse.wait = NULL;
  2856. +
  2857. +    if (check_region(MS_MSE_CONTROL_PORT, 0x04))
  2858. +        return -ENODEV;
  2859. +
  2860.      if (inb_p(MS_MSE_SIGNATURE_PORT) == 0xde) {
  2861.  
  2862.          mse_byte = inb_p(MS_MSE_SIGNATURE_PORT);
  2863. @@ -210,6 +215,7 @@
  2864.  #endif
  2865.      }
  2866.      MS_MSE_INT_OFF();
  2867. +    request_region(MS_MSE_CONTROL_PORT, 0x04, "MS Busmouse");
  2868.      printk("Microsoft BusMouse detected and installed.\n");
  2869.      mouse_register(&ms_bus_mouse);
  2870.  #ifdef MODULE
  2871. @@ -224,7 +230,10 @@
  2872.  {
  2873.      if (MOD_IN_USE)
  2874.          printk("msbusmouse: in use, remove delayed\n");
  2875. -    mouse_deregister(&ms_bus_mouse);
  2876. +    else {
  2877. +        mouse_deregister(&ms_bus_mouse);
  2878. +        release_region(MS_MSE_CONTROL_PORT, 0x04);
  2879. +    }
  2880.  }
  2881.  #endif
  2882.  
  2883. diff -u --recursive --new-file v1.3.30/linux/drivers/char/psaux.c linux/drivers/char/psaux.c
  2884. --- v1.3.30/linux/drivers/char/psaux.c    Fri Sep 15 11:13:01 1995
  2885. +++ linux/drivers/char/psaux.c    Tue Oct  3 08:27:29 1995
  2886. @@ -499,7 +499,6 @@
  2887.          printk("PS/2 auxiliary pointing device detected -- driver installed.\n");
  2888.           aux_present = 1;
  2889.          kbd_read_mask = AUX_OBUF_FULL;
  2890. -        mouse_register(&psaux_mouse);
  2891.      } else {
  2892.  #ifdef MODULE
  2893.          return -EIO;
  2894. @@ -507,6 +506,7 @@
  2895.          return kmem_start;              /* No mouse at all */
  2896.  #endif
  2897.      }
  2898. +    mouse_register(&psaux_mouse);
  2899.      queue = (struct aux_queue *) kmem_start;
  2900.      kmem_start += sizeof (struct aux_queue);
  2901.      memset(queue, 0, sizeof(*queue));
  2902. diff -u --recursive --new-file v1.3.30/linux/drivers/char/random.c linux/drivers/char/random.c
  2903. --- v1.3.30/linux/drivers/char/random.c    Wed Sep 27 15:59:57 1995
  2904. +++ linux/drivers/char/random.c    Tue Oct  3 08:10:41 1995
  2905. @@ -426,16 +426,19 @@
  2906.  
  2907.  #if defined (__i386__)
  2908.      /*
  2909. -     * On a 386, read the high resolution timer.  We assume that
  2910. -     * this gives us 2 bits of randomness.  XXX This needs
  2911. +     * On a Pentium, read the cycle counter. We assume that
  2912. +     * this gives us 8 bits of randomness.  XXX This needs
  2913.       * investigation.
  2914. -     */ 
  2915. -    outb_p(0x00, 0x43);    /* latch the count ASAP */
  2916. -    add_entropy_byte(r, inb_p(0x40), 1);
  2917. -    add_entropy_byte(r, inb(0x40), 1);
  2918. -    r->entropy_count += 2;
  2919. -    if (r->entropy_count > r->bit_length)
  2920. -        r->entropy_count = r->bit_length;
  2921. +     */
  2922. +    if (x86_capability & 16) {
  2923. +        unsigned long low, high;
  2924. +        __asm__(".byte 0x0f,0x31"
  2925. +            :"=a" (low), "=d" (high));
  2926. +        add_entropy_byte(r, low, 1);
  2927. +        r->entropy_count += 8;
  2928. +        if (r->entropy_count > r->bit_length)
  2929. +            r->entropy_count = r->bit_length;
  2930. +    }
  2931.  #endif
  2932.  }
  2933.  
  2934. diff -u --recursive --new-file v1.3.30/linux/drivers/net/3c501.c linux/drivers/net/3c501.c
  2935. --- v1.3.30/linux/drivers/net/3c501.c    Sat Sep  9 15:26:52 1995
  2936. +++ linux/drivers/net/3c501.c    Wed Oct  4 08:15:11 1995
  2937. @@ -654,6 +654,7 @@
  2938.  }
  2939.  
  2940.  /* Set or clear the multicast filter for this adaptor.
  2941. +   num_addrs == -2    All multicast hosts
  2942.     num_addrs == -1    Promiscuous mode, receive all packets
  2943.     num_addrs == 0    Normal mode, clear multicast list
  2944.     num_addrs > 0    Multicast mode, receive normal and MC packets, and do
  2945. @@ -664,8 +665,8 @@
  2946.  {
  2947.      int ioaddr = dev->base_addr;
  2948.  
  2949. -    if (num_addrs > 0) {
  2950. -    outb(RX_MULT, RX_CMD);
  2951. +    if (num_addrs > 0 || num_addrs==-2) {
  2952. +    outb(RX_MULT, RX_CMD);    /* Multicast or all multicast is the same */
  2953.      inb(RX_STATUS);        /* Clear status. */
  2954.      } else if (num_addrs < 0) {
  2955.      outb(RX_PROM, RX_CMD);
  2956. diff -u --recursive --new-file v1.3.30/linux/drivers/net/3c503.c linux/drivers/net/3c503.c
  2957. --- v1.3.30/linux/drivers/net/3c503.c    Sun Sep  3 12:26:53 1995
  2958. +++ linux/drivers/net/3c503.c    Sun Oct  1 19:18:58 1995
  2959. @@ -71,8 +71,10 @@
  2960.  static void el2_init_card(struct device *dev);
  2961.  static void el2_block_output(struct device *dev, int count,
  2962.                   const unsigned char *buf, const start_page);
  2963. -static int el2_block_input(struct device *dev, int count, char *buf,
  2964. +static void el2_block_input(struct device *dev, int count, struct sk_buff *skb,
  2965.                 int ring_offset);
  2966. +static void el2_get_8390_hdr(struct device *dev, struct e8390_pkt_hdr *hdr,
  2967. +             int ring_page);
  2968.  
  2969.  
  2970.  /* This routine probes for a memory-mapped 3c503 board by looking for
  2971. @@ -148,6 +150,7 @@
  2972.  {
  2973.      int i, iobase_reg, membase_reg, saved_406;
  2974.      static unsigned version_printed = 0;
  2975. +    unsigned long vendor_id;
  2976.  
  2977.      /* Reset and/or avoid any lurking NE2000 */
  2978.      if (inb(ioaddr + 0x408) == 0xff) {
  2979. @@ -167,11 +170,11 @@
  2980.      saved_406 = inb_p(ioaddr + 0x406);
  2981.      outb_p(ECNTRL_RESET|ECNTRL_THIN, ioaddr + 0x406); /* Reset it... */
  2982.      outb_p(ECNTRL_THIN, ioaddr + 0x406);
  2983. -    /* Map the station addr PROM into the lower I/O ports. */
  2984. +    /* Map the station addr PROM into the lower I/O ports. We now check
  2985. +       for both the old and new 3Com prefix */
  2986.      outb(ECNTRL_SAPROM|ECNTRL_THIN, ioaddr + 0x406);
  2987. -    if (   inb(ioaddr + 0) != 0x02
  2988. -    || inb(ioaddr + 1) != 0x60
  2989. -    || inb(ioaddr + 2) != 0x8c) {
  2990. +    vendor_id = inb(ioaddr)*0x10000 + inb(ioaddr + 1)*0x100 + inb(ioaddr + 2);
  2991. +    if ((vendor_id != OLD_3COM_ID) && (vendor_id != NEW_3COM_ID)) {
  2992.      /* Restore the register we frobbed. */
  2993.      outb(saved_406, ioaddr + 0x406);
  2994.      return ENODEV;
  2995. @@ -250,6 +253,7 @@
  2996.      ei_status.rx_start_page = EL2SM_START_PG + TX_PAGES;
  2997.      ei_status.stop_page = EL2SM_STOP_PG;
  2998.      ei_status.reset_8390 = &el2_reset_8390;
  2999. +    ei_status.get_8390_hdr = &el2_get_8390_hdr;
  3000.      ei_status.block_input = &el2_block_input;
  3001.      ei_status.block_output = &el2_block_output;
  3002.  
  3003. @@ -268,7 +272,7 @@
  3004.      dev->stop = &el2_close;
  3005.  
  3006.      if (dev->mem_start)
  3007. -    printk("\n%s: %s with shared memory at %#6lx-%#6lx,\n",
  3008. +    printk("\n%s: %s with shared memory at %#6lx-%#6lx.\n",
  3009.             dev->name, ei_status.name, dev->mem_start, dev->mem_end-1);
  3010.      else
  3011.      printk("\n%s: %s using programmed I/O (REJUMPER for SHARED MEMORY).\n",
  3012. @@ -388,12 +392,9 @@
  3013.      outb(EGACFR_NORM, E33G_GACFR);    /* Enable RAM and interrupts. */
  3014.  
  3015.      if (dev->mem_start) {    /* Shared memory transfer */
  3016. -    void *dest_addr = (void *)(dev->mem_start +
  3017. -        ((start_page - ei_status.tx_start_page) << 8));
  3018. -    memcpy(dest_addr, buf, count);
  3019. -    if (ei_debug > 2  &&  memcmp(dest_addr, buf, count))
  3020. -        printk("%s: 3c503 send_packet() bad memory copy @ %#5x.\n",
  3021. -           dev->name, (int) dest_addr);
  3022. +    unsigned long dest_addr = dev->mem_start +
  3023. +        ((start_page - ei_status.tx_start_page) << 8);
  3024. +    memcpy_toio(dest_addr, buf, count);
  3025.      return;
  3026.      }
  3027.      /* No shared memory, put the packet out the slow way. */
  3028. @@ -420,9 +421,34 @@
  3029.      return;
  3030.  }
  3031.  
  3032. +/* Read the 4 byte, page aligned 8390 specific header. */
  3033. +static void
  3034. +el2_get_8390_hdr(struct device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
  3035. +{
  3036. +    unsigned int i;
  3037. +    unsigned long hdr_start = dev->mem_start + ((ring_page - EL2SM_START_PG)<<8);
  3038. +
  3039. +    if (dev->mem_start) {       /* Use the shared memory. */
  3040. +    memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
  3041. +    return;
  3042. +    }
  3043. +
  3044. +    /* No shared memory, use programmed I/O. Ugh. */
  3045. +    outb(0, E33G_DMAAL);
  3046. +    outb_p(ring_page & 0xff, E33G_DMAAH);
  3047. +    outb_p((ei_status.interface_num == 0 ? ECNTRL_THIN : ECNTRL_AUI) | ECNTRL_INPUT
  3048. +       | ECNTRL_START, E33G_CNTRL);
  3049. +
  3050. +    /* Header is less than 8 bytes, so we can ignore the FIFO. */
  3051. +    for(i = 0; i < sizeof(struct e8390_pkt_hdr); i++)
  3052. +    ((char *)(hdr))[i] = inb_p(E33G_FIFOH);
  3053. +
  3054. +    outb_p(ei_status.interface_num == 0 ? ECNTRL_THIN : ECNTRL_AUI, E33G_CNTRL);
  3055. +}
  3056. +
  3057.  /* Returns the new ring pointer. */
  3058. -static int
  3059. -el2_block_input(struct device *dev, int count, char *buf, int ring_offset)
  3060. +static void
  3061. +el2_block_input(struct device *dev, int count, struct sk_buff *skb, int ring_offset)
  3062.  {
  3063.      int boguscount = 0;
  3064.      int end_of_ring = dev->rmem_end;
  3065. @@ -434,13 +460,14 @@
  3066.      if (dev->mem_start + ring_offset + count > end_of_ring) {
  3067.          /* We must wrap the input move. */
  3068.          int semi_count = end_of_ring - (dev->mem_start + ring_offset);
  3069. -        memcpy(buf, (char *)dev->mem_start + ring_offset, semi_count);
  3070. +        memcpy_fromio(skb->data, dev->mem_start + ring_offset, semi_count);
  3071.          count -= semi_count;
  3072. -        memcpy(buf + semi_count, (char *)dev->rmem_start, count);
  3073. -        return dev->rmem_start + count;
  3074. +        memcpy_fromio(skb->data + semi_count, dev->rmem_start, count);
  3075. +    } else {
  3076. +        /* Packet is in one chunk -- we can copy + cksum. */
  3077. +        eth_io_copy_and_sum(skb, dev->mem_start + ring_offset, count, 0);
  3078.      }
  3079. -    memcpy(buf, (char *)dev->mem_start + ring_offset, count);
  3080. -    return ring_offset + count;
  3081. +    return;
  3082.      }
  3083.      /* No shared memory, use programmed I/O. */
  3084.      outb(ring_offset & 0xff, E33G_DMAAL);
  3085. @@ -459,10 +486,9 @@
  3086.              boguscount = 0;
  3087.              break;
  3088.          }
  3089. -    buf[i] = inb_p(E33G_FIFOH);
  3090. +    (skb->data)[i] = inb_p(E33G_FIFOH);
  3091.      }
  3092.      outb_p(ei_status.interface_num == 0 ? ECNTRL_THIN : ECNTRL_AUI, E33G_CNTRL);
  3093. -    return 0;
  3094.  }
  3095.  #ifdef MODULE
  3096.  char kernel_version[] = UTS_RELEASE;
  3097. diff -u --recursive --new-file v1.3.30/linux/drivers/net/3c503.h linux/drivers/net/3c503.h
  3098. --- v1.3.30/linux/drivers/net/3c503.h    Wed Dec  1 14:44:15 1993
  3099. +++ linux/drivers/net/3c503.h    Sun Oct  1 19:18:58 1995
  3100. @@ -6,6 +6,12 @@
  3101.  #define EL2H (dev->base_addr + 0x400)
  3102.  #define EL2L (dev->base_addr)
  3103.  
  3104. +/* Vendor unique hardware addr. prefix. 3Com has 2 because they ran
  3105. +   out of available addresses on the first one... */
  3106. +
  3107. +#define OLD_3COM_ID    0x02608c
  3108. +#define NEW_3COM_ID    0x0020af
  3109. +
  3110.  /* Shared memory management parameters */
  3111.  
  3112.  #define EL2SM_START_PG    (0x20)    /* First page of TX buffer */
  3113. diff -u --recursive --new-file v1.3.30/linux/drivers/net/3c509.c linux/drivers/net/3c509.c
  3114. --- v1.3.30/linux/drivers/net/3c509.c    Sat Sep  9 15:26:52 1995
  3115. +++ linux/drivers/net/3c509.c    Wed Oct  4 08:15:11 1995
  3116. @@ -262,7 +262,7 @@
  3117.      dev->stop = &el3_close;
  3118.      dev->get_stats = &el3_get_stats;
  3119.  #ifdef HAVE_MULTICAST
  3120. -        dev->set_multicast_list = &set_multicast_list;
  3121. +    dev->set_multicast_list = &set_multicast_list;
  3122.  #endif
  3123.  
  3124.      /* Fill in the generic fields of the device structure. */
  3125. @@ -652,7 +652,7 @@
  3126.              printk("%s: Setting Rx mode to %d addresses.\n", dev->name, num_addrs);
  3127.          }
  3128.      }
  3129. -    if (num_addrs > 0) {
  3130. +    if (num_addrs > 0 || num_addrs == -2) {
  3131.          outw(SetRxFilter|RxStation|RxMulticast|RxBroadcast, ioaddr + EL3_CMD);
  3132.      } else if (num_addrs < 0) {
  3133.          outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
  3134. diff -u --recursive --new-file v1.3.30/linux/drivers/net/8390.c linux/drivers/net/8390.c
  3135. --- v1.3.30/linux/drivers/net/8390.c    Sat Sep  9 15:26:52 1995
  3136. +++ linux/drivers/net/8390.c    Wed Oct  4 08:15:11 1995
  3137. @@ -19,6 +19,8 @@
  3138.    Changelog:
  3139.  
  3140.    Paul Gortmaker    : remove set_bit lock, other cleanups.
  3141. +  Paul Gortmaker    : add ei_get_8390_hdr() so we can pass skb's to 
  3142. +              ei_block_input() for eth_io_copy_and_sum().
  3143.  
  3144.    */
  3145.  
  3146. @@ -70,15 +72,18 @@
  3147.                        int start_page)
  3148.          Write the COUNT bytes of BUF to the packet buffer at START_PAGE.  The
  3149.          "page" value uses the 8390's 256-byte pages.
  3150. -    int block_input(struct device *dev, int count, char *buf, int ring_offset)
  3151. -        Read COUNT bytes from the packet buffer into BUF.  Start reading from
  3152. -        RING_OFFSET, the address as the 8390 sees it.  The first read will
  3153. -        always be the 4 byte, page aligned 8390 header.  *If* there is a
  3154. +    void get_8390_hdr(struct device *dev, struct e8390_hdr *hdr, int ring_page)
  3155. +        Read the 4 byte, page aligned 8390 header. *If* there is a
  3156.          subsequent read, it will be of the rest of the packet.
  3157. +    void block_input(struct device *dev, int count, struct sk_buff *skb, int ring_offset)
  3158. +        Read COUNT bytes from the packet buffer into the skb data area. Start 
  3159. +        reading from RING_OFFSET, the address as the 8390 sees it.  This will always
  3160. +        follow the read of the 8390 header. 
  3161.  */
  3162.  #define ei_reset_8390 (ei_local->reset_8390)
  3163.  #define ei_block_output (ei_local->block_output)
  3164.  #define ei_block_input (ei_local->block_input)
  3165. +#define ei_get_8390_hdr (ei_local->get_8390_hdr)
  3166.  
  3167.  /* use 0 for production, 1 for verification, >2 for debug */
  3168.  #ifdef EI_DEBUG
  3169. @@ -152,17 +157,16 @@
  3170.              printk("%s: xmit on stopped card\n", dev->name);
  3171.              return 1;
  3172.          }
  3173. -        printk(KERN_DEBUG "%s: transmit timed out, TX status %#2x, ISR %#2x.\n",
  3174. -               dev->name, txsr, isr);
  3175. -        /* Does the 8390 thinks it has posted an interrupt? */
  3176. -        if (isr)
  3177. -            printk(KERN_DEBUG "%s: Possible IRQ conflict on IRQ%d?\n", dev->name, dev->irq);
  3178. -        else {
  3179. -            /* The 8390 probably hasn't gotten on the cable yet. */
  3180. -            printk(KERN_DEBUG "%s: Possible network cable problem?\n", dev->name);
  3181. -            if(ei_local->stat.tx_packets==0)
  3182. -                ei_local->interface_num ^= 1;     /* Try a different xcvr.  */
  3183. +
  3184. +        printk(KERN_DEBUG "%s: Tx timed out, %s TSR=%#2x, ISR=%#2x, t=%d.\n",
  3185. +           dev->name, (txsr & ENTSR_ABT) ? "excess collisions." :
  3186. +           (isr) ? "lost interrupt?" : "cable problem?", txsr, isr, tickssofar);
  3187. +
  3188. +        if (!isr && !ei_local->stat.tx_packets) {
  3189. +           /* The 8390 probably hasn't gotten on the cable yet. */
  3190. +           ei_local->interface_num ^= 1;   /* Try a different xcvr.  */
  3191.          }
  3192. +
  3193.          /* Try to restart the card.  Perhaps the user has fixed something. */
  3194.          ei_reset_8390(dev);
  3195.          NS8390_init(dev, 1);
  3196. @@ -312,7 +316,7 @@
  3197.  
  3198.          /* Ignore any RDC interrupts that make it back to here. */
  3199.          if (interrupts & ENISR_RDC) {
  3200. -                outb_p(ENISR_RDC, e8390_base + EN0_ISR);
  3201. +            outb_p(ENISR_RDC, e8390_base + EN0_ISR);
  3202.          }
  3203.  
  3204.          outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, e8390_base + E8390_CMD);
  3205. @@ -431,10 +435,9 @@
  3206.              break;                /* Done for now */
  3207.          
  3208.          current_offset = this_frame << 8;
  3209. -        ei_block_input(dev, sizeof(rx_frame), (char *)&rx_frame,
  3210. -                       current_offset);
  3211. +        ei_get_8390_hdr(dev, &rx_frame, this_frame);
  3212.          
  3213. -        pkt_len = rx_frame.count - sizeof(rx_frame);
  3214. +        pkt_len = rx_frame.count - sizeof(struct e8390_pkt_hdr);
  3215.          
  3216.          next_frame = this_frame + 1 + ((pkt_len+4)>>8);
  3217.          
  3218. @@ -470,9 +473,8 @@
  3219.              } else {
  3220.                  skb_reserve(skb,2);    /* IP headers on 16 byte boundaries */
  3221.                  skb->dev = dev;
  3222. -                
  3223. -                ei_block_input(dev, pkt_len, skb_put(skb,pkt_len),
  3224. -                               current_offset + sizeof(rx_frame));
  3225. +                skb_put(skb, pkt_len);    /* Make room */
  3226. +                ei_block_input(dev, pkt_len, skb, current_offset + sizeof(rx_frame));
  3227.                  skb->protocol=eth_type_trans(skb,dev);
  3228.                  netif_rx(skb);
  3229.                  ei_local->stat.rx_packets++;
  3230. @@ -533,7 +535,7 @@
  3231.         easy way of timing something in that range, so we use 'jiffies' as
  3232.         a sanity check. */
  3233.      while ((inb_p(e8390_base+EN0_ISR) & ENISR_RESET) == 0)
  3234. -        if (jiffies - reset_start_time > 1) {
  3235. +        if (jiffies - reset_start_time > 2*HZ/100) {
  3236.              printk("%s: reset did not complete at ei_rx_overrun.\n",
  3237.                     dev->name);
  3238.              NS8390_init(dev, 1);
  3239. @@ -576,7 +578,7 @@
  3240.  {
  3241.      short ioaddr = dev->base_addr;
  3242.      
  3243. -    if (num_addrs > 0) {
  3244. +    if (num_addrs > 0 || num_addrs == -2) {
  3245.          /* The multicast-accept list is initialized to accept-all, and we
  3246.             rely on higher-level filtering for now. */
  3247.          outb_p(E8390_RXCONFIG | 0x08, ioaddr + EN0_RXCR);
  3248. diff -u --recursive --new-file v1.3.30/linux/drivers/net/8390.h linux/drivers/net/8390.h
  3249. --- v1.3.30/linux/drivers/net/8390.h    Wed Aug  2 13:21:02 1995
  3250. +++ linux/drivers/net/8390.h    Sun Oct  1 19:18:58 1995
  3251. @@ -9,6 +9,7 @@
  3252.  
  3253.  #include <linux/if_ether.h>
  3254.  #include <linux/ioport.h>
  3255. +#include <linux/skbuff.h>
  3256.  
  3257.  #define TX_2X_PAGES 12
  3258.  #define TX_1X_PAGES 6
  3259. @@ -16,6 +17,13 @@
  3260.  
  3261.  #define ETHER_ADDR_LEN 6
  3262.  
  3263. +/* The 8390 specific per-packet-header format. */
  3264. +struct e8390_pkt_hdr {
  3265. +  unsigned char status; /* status */
  3266. +  unsigned char next;   /* pointer to next packet. */
  3267. +  unsigned short count; /* header + packet length in bytes */
  3268. +};
  3269. +
  3270.  /* From 8390.c */
  3271.  extern int ei_debug;
  3272.  extern struct sigaction ei_sigaction;
  3273. @@ -39,8 +47,9 @@
  3274.  struct ei_device {
  3275.    const char *name;
  3276.    void (*reset_8390)(struct device *);
  3277. +  void (*get_8390_hdr)(struct device *, struct e8390_pkt_hdr *, int);
  3278.    void (*block_output)(struct device *, int, const unsigned char *, int);
  3279. -  int  (*block_input)(struct device *, int, char *, int);
  3280. +  void (*block_input)(struct device *, int, struct sk_buff *, int);
  3281.    unsigned open:1;
  3282.    unsigned word16:1;  /* We have the 16-bit (vs 8-bit) version of the card. */
  3283.    unsigned txing:1;        /* Transmit Active */
  3284. @@ -63,8 +72,8 @@
  3285.  /* The maximum number of 8390 interrupt service routines called per IRQ. */
  3286.  #define MAX_SERVICE 12
  3287.  
  3288. -/* The maximum number of jiffies waited before assuming a Tx failed. */
  3289. -#define TX_TIMEOUT 20 
  3290. +/* The maximum time waited (in jiffies) before assuming a Tx failed. (20ms) */
  3291. +#define TX_TIMEOUT (20*HZ/100)
  3292.  
  3293.  #define ei_status (*(struct ei_device *)(dev->priv))
  3294.  
  3295. @@ -155,10 +164,4 @@
  3296.  #define ENTSR_CDH 0x40    /* The collision detect "heartbeat" signal was lost. */
  3297.  #define ENTSR_OWC 0x80  /* There was an out-of-window collision. */
  3298.  
  3299. -/* The per-packet-header format. */
  3300. -struct e8390_pkt_hdr {
  3301. -  unsigned char status; /* status */
  3302. -  unsigned char next;   /* pointer to next packet. */
  3303. -  unsigned short count; /* header + packet length in bytes */
  3304. -};
  3305.  #endif /* _8390_h */
  3306. diff -u --recursive --new-file v1.3.30/linux/drivers/net/CONFIG linux/drivers/net/CONFIG
  3307. --- v1.3.30/linux/drivers/net/CONFIG    Wed Aug  9 14:55:39 1995
  3308. +++ linux/drivers/net/CONFIG    Sun Oct  1 19:18:58 1995
  3309. @@ -9,15 +9,14 @@
  3310.  #
  3311.  #  CONFIG_WD80x3    The Western Digital (SMC) WD80x3 driver
  3312.  #    WD_SHMEM=xxx    Forces the address of the shared memory
  3313. -#    WD_no_mapout    Don't map out the shared memory (faster, but
  3314. -#            your machine may not warm-boot).
  3315.  #  CONFIG_NE2000    The NE-[12]000 clone driver.
  3316.  #    PACKETBUF_MEMSIZE  Allows an extra-large packet buffer to be
  3317.  #            used.  Usually pointless under Linux.
  3318.  #    show_all_SAPROM  Show the entire address PROM, not just the
  3319.  #            ethernet address, during boot.
  3320.  #    CONFIG_NE_RW_BUGFIX  Patch an obscure bug with a version of the 8390.
  3321. -#    CONFIG_NE_SANITY ??
  3322. +#    CONFIG_NE_SANITY Double check the internal card xfer address
  3323. +#            against the driver's value. Useful for debugging.
  3324.  #  CONFIG_HPLAN        The HP-LAN driver (for 8390-based boards only).
  3325.  #    rw_bugfix    Fix the same obscure bug.
  3326.  #  CONFIG_EL2        The 3c503 EtherLink II driver
  3327. diff -u --recursive --new-file v1.3.30/linux/drivers/net/ac3200.c linux/drivers/net/ac3200.c
  3328. --- v1.3.30/linux/drivers/net/ac3200.c    Tue Aug 15 20:39:02 1995
  3329. +++ linux/drivers/net/ac3200.c    Sun Oct  1 19:18:58 1995
  3330. @@ -29,6 +29,7 @@
  3331.  #include <asm/io.h>
  3332.  
  3333.  #include <linux/netdevice.h>
  3334. +#include <linux/etherdevice.h>
  3335.  #include "8390.h"
  3336.  
  3337.  /* Offsets from the base address. */
  3338. @@ -72,10 +73,13 @@
  3339.  
  3340.  static int ac_open(struct device *dev);
  3341.  static void ac_reset_8390(struct device *dev);
  3342. -static int ac_block_input(struct device *dev, int count,
  3343. -                          char *buf, int ring_offset);
  3344. +static void ac_block_input(struct device *dev, int count,
  3345. +                    struct sk_buff *skb, int ring_offset);
  3346.  static void ac_block_output(struct device *dev, const int count,
  3347.                              const unsigned char *buf, const int start_page);
  3348. +static void ac_get_8390_hdr(struct device *dev, struct e8390_pkt_hdr *hdr,
  3349. +                    int ring_page);
  3350. +
  3351.  static int ac_close_card(struct device *dev);
  3352.  
  3353.  
  3354. @@ -195,6 +199,7 @@
  3355.      ei_status.reset_8390 = &ac_reset_8390;
  3356.      ei_status.block_input = &ac_block_input;
  3357.      ei_status.block_output = &ac_block_output;
  3358. +    ei_status.get_8390_hdr = &ac_get_8390_hdr;
  3359.  
  3360.      dev->open = &ac_open;
  3361.      dev->stop = &ac_close_card;
  3362. @@ -237,33 +242,43 @@
  3363.      return;
  3364.  }
  3365.  
  3366. +/* Grab the 8390 specific header. Similar to the block_input routine, but
  3367. +   we don't need to be concerned with ring wrap as the header will be at
  3368. +   the start of a page, so we optimize accordingly. */
  3369. +
  3370. +static void
  3371. +ac_get_8390_hdr(struct device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
  3372. +{
  3373. +    unsigned long hdr_start = dev->mem_start + ((ring_page - AC_START_PG)<<8);
  3374. +    memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
  3375. +}
  3376. +
  3377.  /*  Block input and output are easy on shared memory ethercards, the only
  3378.      complication is when the ring buffer wraps. */
  3379.  
  3380. -static int ac_block_input(struct device *dev, int count, char *buf,
  3381. +static void ac_block_input(struct device *dev, int count, struct sk_buff *skb,
  3382.                            int ring_offset)
  3383.  {
  3384. -    long xfer_start = dev->mem_start + ring_offset - (AC_START_PG<<8);
  3385. +    unsigned long xfer_start = dev->mem_start + ring_offset - (AC_START_PG<<8);
  3386.  
  3387.      if (xfer_start + count > dev->rmem_end) {
  3388.          /* We must wrap the input move. */
  3389.          int semi_count = dev->rmem_end - xfer_start;
  3390. -        memcpy(buf, (char*)xfer_start, semi_count);
  3391. +        memcpy_fromio(skb->data, xfer_start, semi_count);
  3392.          count -= semi_count;
  3393. -        memcpy(buf + semi_count, (char *)dev->rmem_start, count);
  3394. -        return dev->rmem_start + count;
  3395. +        memcpy_fromio(skb->data + semi_count, dev->rmem_start, count);
  3396. +    } else {
  3397. +        /* Packet is in one chunk -- we can copy + cksum. */
  3398. +        eth_io_copy_and_sum(skb, xfer_start, count, 0);
  3399.      }
  3400. -    memcpy(buf, (char*)xfer_start, count);
  3401. -
  3402. -    return ring_offset + count;
  3403.  }
  3404.  
  3405.  static void ac_block_output(struct device *dev, int count,
  3406.                              const unsigned char *buf, int start_page)
  3407.  {
  3408. -    long shmem = dev->mem_start + ((start_page - AC_START_PG)<<8);
  3409. +    unsigned long shmem = dev->mem_start + ((start_page - AC_START_PG)<<8);
  3410.  
  3411. -    memcpy((unsigned char *)shmem, buf, count);
  3412. +    memcpy_toio(shmem, buf, count);
  3413.  }
  3414.  
  3415.  static int ac_close_card(struct device *dev)
  3416. diff -u --recursive --new-file v1.3.30/linux/drivers/net/e2100.c linux/drivers/net/e2100.c
  3417. --- v1.3.30/linux/drivers/net/e2100.c    Tue Aug 15 20:39:03 1995
  3418. +++ linux/drivers/net/e2100.c    Sun Oct  1 19:18:58 1995
  3419. @@ -19,7 +19,7 @@
  3420.      station address region, and the low three bits of next outb() *address*
  3421.      is used    as the write value for that register.  Either someone wasn't
  3422.      too used to dem bit en bites, or they were trying to obfuscate the
  3423. -    programming    interface.
  3424. +    programming interface.
  3425.  
  3426.      There is an additional complication when setting the window on the packet
  3427.      buffer.  You must first do a read into the packet buffer region with the
  3428. @@ -48,6 +48,7 @@
  3429.  #include <linux/ioport.h>
  3430.  
  3431.  #include <linux/netdevice.h>
  3432. +#include <linux/etherdevice.h>
  3433.  #include "8390.h"
  3434.  
  3435.  static int e21_probe_list[] = {0x300, 0x280, 0x380, 0x220, 0};
  3436. @@ -99,10 +100,13 @@
  3437.  
  3438.  static int e21_open(struct device *dev);
  3439.  static void e21_reset_8390(struct device *dev);
  3440. -static int e21_block_input(struct device *dev, int count,
  3441. -                           char *buf, int ring_offset);
  3442. +static void e21_block_input(struct device *dev, int count,
  3443. +                           struct sk_buff *skb, int ring_offset);
  3444.  static void e21_block_output(struct device *dev, int count,
  3445.                               const unsigned char *buf, const start_page);
  3446. +static void e21_get_8390_hdr(struct device *dev, struct e8390_pkt_hdr *hdr,
  3447. +                            int ring_page);
  3448. +
  3449.  static int e21_close(struct device *dev);
  3450.  
  3451.  
  3452. @@ -189,7 +193,7 @@
  3453.      ei_status.tx_start_page = E21_TX_START_PG;
  3454.      ei_status.rx_start_page = E21_RX_START_PG;
  3455.      ei_status.stop_page = E21_RX_STOP_PG;
  3456. -    ei_status.saved_irq = dev->irq;
  3457. +    ei_status.saved_irq = dev->irq;
  3458.  
  3459.      /* Check the media port used.  The port can be passed in on the
  3460.         low mem_end bits. */
  3461. @@ -227,6 +231,7 @@
  3462.      ei_status.reset_8390 = &e21_reset_8390;
  3463.      ei_status.block_input = &e21_block_input;
  3464.      ei_status.block_output = &e21_block_output;
  3465. +    ei_status.get_8390_hdr = &e21_get_8390_hdr;
  3466.      dev->open = &e21_open;
  3467.      dev->stop = &e21_close;
  3468.      NS8390_init(dev, 0);
  3469. @@ -277,28 +282,40 @@
  3470.      return;
  3471.  }
  3472.  
  3473. +/* Grab the 8390 specific header. We put the 2k window so the header page
  3474. +   appears at the start of the shared memory. */
  3475. +
  3476. +static void
  3477. +e21_get_8390_hdr(struct device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
  3478. +{
  3479. +
  3480. +    short ioaddr = dev->base_addr;
  3481. +    char *shared_mem = (char *)dev->mem_start;
  3482. +
  3483. +    mem_on(ioaddr, shared_mem, ring_page);
  3484. +
  3485. +    memcpy_fromio(hdr, shared_mem, sizeof(struct e8390_pkt_hdr));
  3486. +
  3487. +    /* Turn off memory access: we would need to reprogram the window anyway. */
  3488. +    mem_off(ioaddr);
  3489. +
  3490. +}
  3491. +
  3492.  /*  Block input and output are easy on shared memory ethercards.
  3493.      The E21xx makes block_input() especially easy by wrapping the top
  3494.      ring buffer to the bottom automatically. */
  3495. -static int
  3496. -e21_block_input(struct device *dev, int count, char *buf, int ring_offset)
  3497. +static void
  3498. +e21_block_input(struct device *dev, int count, struct sk_buff *skb, int ring_offset)
  3499.  {
  3500.      short ioaddr = dev->base_addr;
  3501.      char *shared_mem = (char *)dev->mem_start;
  3502. -    int start_page = (ring_offset>>8);
  3503.  
  3504. -    mem_on(ioaddr, shared_mem, start_page);
  3505. +    mem_on(ioaddr, shared_mem, (ring_offset>>8));
  3506.  
  3507. -    /* We'll always get a 4 byte header read first. */
  3508. -    if (count == 4)
  3509. -        ((int*)buf)[0] = ((int*)shared_mem)[0];
  3510. -    else
  3511. -        memcpy(buf, shared_mem + (ring_offset & 0xff), count);
  3512. +    /* Packet is always in one chunk -- we can copy + cksum. */
  3513. +    eth_io_copy_and_sum(skb, dev->mem_start + (ring_offset & 0xff), count, 0);
  3514.  
  3515. -    /* Turn off memory access: we would need to reprogram the window anyway. */
  3516.      mem_off(ioaddr);
  3517. -
  3518. -    return 0;
  3519.  }
  3520.  
  3521.  static void
  3522. @@ -310,10 +327,10 @@
  3523.  
  3524.      /* Set the shared memory window start by doing a read, with the low address
  3525.         bits specifying the starting page. */
  3526. -    *(shared_mem + start_page);
  3527. +    readb(shared_mem + start_page);
  3528.      mem_on(ioaddr, shared_mem, start_page);
  3529.  
  3530. -    memcpy((char*)shared_mem, buf, count);
  3531. +    memcpy_toio(shared_mem, buf, count);
  3532.      mem_off(ioaddr);
  3533.  }
  3534.  
  3535. diff -u --recursive --new-file v1.3.30/linux/drivers/net/eql.c linux/drivers/net/eql.c
  3536. --- v1.3.30/linux/drivers/net/eql.c    Sat Sep  9 15:26:52 1995
  3537. +++ linux/drivers/net/eql.c    Mon Oct  2 14:25:10 1995
  3538. @@ -25,7 +25,7 @@
  3539.   * Inspirations:
  3540.   *   The Harried and Overworked Alan Cox
  3541.   * Conspiracies:
  3542. - *   The Alan Cox and Arisian plot to get someone else to do the code, which
  3543. + *   The Alan Cox and Mike McLagan plot to get someone else to do the code, which
  3544.   *   turned out to be me.
  3545.   */
  3546.  
  3547. diff -u --recursive --new-file v1.3.30/linux/drivers/net/hp-plus.c linux/drivers/net/hp-plus.c
  3548. --- v1.3.30/linux/drivers/net/hp-plus.c    Tue Aug 15 20:39:03 1995
  3549. +++ linux/drivers/net/hp-plus.c    Sun Oct  1 19:18:58 1995
  3550. @@ -101,14 +101,18 @@
  3551.  static void hpp_reset_8390(struct device *dev);
  3552.  static int hpp_open(struct device *dev);
  3553.  static int hpp_close(struct device *dev);
  3554. -static int hpp_mem_block_input(struct device *dev, int count,
  3555. -                          char *buf, int ring_offset);
  3556. +static void hpp_mem_block_input(struct device *dev, int count,
  3557. +                          struct sk_buff *skb, int ring_offset);
  3558.  static void hpp_mem_block_output(struct device *dev, int count,
  3559.                              const unsigned char *buf, const start_page);
  3560. -static int hpp_io_block_input(struct device *dev, int count,
  3561. -                          char *buf, int ring_offset);
  3562. +static void hpp_mem_get_8390_hdr(struct device *dev, struct e8390_pkt_hdr *hdr,
  3563. +                          int ring_page);
  3564. +static void hpp_io_block_input(struct device *dev, int count,
  3565. +                          struct sk_buff *skb, int ring_offset);
  3566.  static void hpp_io_block_output(struct device *dev, int count,
  3567.                              const unsigned char *buf, const start_page);
  3568. +static void hpp_io_get_8390_hdr(struct device *dev, struct e8390_pkt_hdr *hdr,
  3569. +                          int ring_page);
  3570.  
  3571.  
  3572.  /*    Probe a list of addresses for an HP LAN+ adaptor.
  3573. @@ -221,11 +225,13 @@
  3574.      ei_status.reset_8390 = &hpp_reset_8390;
  3575.      ei_status.block_input = &hpp_io_block_input;
  3576.      ei_status.block_output = &hpp_io_block_output;
  3577. +    ei_status.get_8390_hdr = &hpp_io_get_8390_hdr;
  3578.  
  3579.      /* Check if the memory_enable flag is set in the option register. */
  3580.      if (mem_start) {
  3581.          ei_status.block_input = &hpp_mem_block_input;
  3582.          ei_status.block_output = &hpp_mem_block_output;
  3583. +        ei_status.get_8390_hdr = &hpp_mem_get_8390_hdr;
  3584.          dev->mem_start = mem_start;
  3585.          dev->rmem_start = dev->mem_start + TX_2X_PAGES*256;
  3586.          dev->mem_end = dev->rmem_end
  3587. @@ -307,23 +313,49 @@
  3588.      return;
  3589.  }
  3590.  
  3591. -/* Block input and output, similar to the Crynwr packet driver.
  3592. +/* The programmed-I/O version of reading the 4 byte 8390 specific header.
  3593.     Note that transfer with the EtherTwist+ must be on word boundaries. */
  3594.  
  3595. -static int
  3596. -hpp_io_block_input(struct device *dev, int count, char *buf, int ring_offset)
  3597. +static void
  3598. +hpp_io_get_8390_hdr(struct device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
  3599. +{
  3600. +    int ioaddr = dev->base_addr - NIC_OFFSET;
  3601. +
  3602. +    outw((ring_page<<8), ioaddr + HPP_IN_ADDR);
  3603. +    insw(ioaddr + HP_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr)>>1);
  3604. +}
  3605. +
  3606. +/* Block input and output, similar to the Crynwr packet driver. */
  3607. +
  3608. +static void
  3609. +hpp_io_block_input(struct device *dev, int count, struct sk_buff *skb, int ring_offset)
  3610.  {
  3611.      int ioaddr = dev->base_addr - NIC_OFFSET;
  3612. +    char *buf = skb->data;
  3613.  
  3614.      outw(ring_offset, ioaddr + HPP_IN_ADDR);
  3615.      insw(ioaddr + HP_DATAPORT, buf, count>>1);
  3616.      if (count & 0x01)
  3617.          buf[count-1] = inw(ioaddr + HP_DATAPORT);
  3618. -    return ring_offset + count;
  3619.  }
  3620.  
  3621. -static int
  3622. -hpp_mem_block_input(struct device *dev, int count, char *buf, int ring_offset)
  3623. +/* The corresponding shared memory versions of the above 2 functions. */
  3624. +
  3625. +static void
  3626. +hpp_mem_get_8390_hdr(struct device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
  3627. +{
  3628. +    int ioaddr = dev->base_addr - NIC_OFFSET;
  3629. +    int option_reg = inw(ioaddr + HPP_OPTION);
  3630. +
  3631. +    outw((ring_page<<8), ioaddr + HPP_IN_ADDR);
  3632. +    outw(option_reg & ~(MemDisable + BootROMEnb), ioaddr + HPP_OPTION);
  3633. +    memcpy_fromio(hdr, dev->mem_start, sizeof(struct e8390_pkt_hdr));
  3634. +    outw(option_reg, ioaddr + HPP_OPTION);
  3635. +    hdr->count = (hdr->count + 3) & ~3;    /* Round up allocation. */
  3636. +}
  3637. +
  3638. +static void
  3639. +hpp_mem_block_input(struct device *dev, int count, struct sk_buff *skb, int ring_offset)
  3640.  {
  3641.      int ioaddr = dev->base_addr - NIC_OFFSET;
  3642.      int option_reg = inw(ioaddr + HPP_OPTION);
  3643. @@ -331,11 +363,13 @@
  3644.      outw(ring_offset, ioaddr + HPP_IN_ADDR);
  3645.  
  3646.      outw(option_reg & ~(MemDisable + BootROMEnb), ioaddr + HPP_OPTION);
  3647. -    /* Caution: this relies on 8390.c rounding up allocations! */
  3648. -    memcpy(buf, (char*)dev->mem_start,  (count + 3) & ~3);
  3649. -    outw(option_reg, ioaddr + HPP_OPTION);
  3650.  
  3651. -    return ring_offset + count;
  3652. +    /* Caution: this relies on get_8390_hdr() rounding up count!
  3653. +       Also note that we *can't* use eth_io_copy_and_sum() because
  3654. +       it will not always copy "count" bytes (e.g. padded IP).  */
  3655. +
  3656. +    memcpy_fromio(skb->data, dev->mem_start, count);
  3657. +    outw(option_reg, ioaddr + HPP_OPTION);
  3658.  }
  3659.  
  3660.  /* A special note: we *must* always transfer >=16 bit words.
  3661. @@ -359,7 +393,7 @@
  3662.  
  3663.      outw(start_page << 8, ioaddr + HPP_OUT_ADDR);
  3664.      outw(option_reg & ~(MemDisable + BootROMEnb), ioaddr + HPP_OPTION);
  3665. -    memcpy((char *)dev->mem_start, buf, (count + 3) & ~3);
  3666. +    memcpy_toio(dev->mem_start, buf, (count + 3) & ~3);
  3667.      outw(option_reg, ioaddr + HPP_OPTION);
  3668.  
  3669.      return;
  3670. diff -u --recursive --new-file v1.3.30/linux/drivers/net/hp.c linux/drivers/net/hp.c
  3671. --- v1.3.30/linux/drivers/net/hp.c    Tue Aug 15 20:39:03 1995
  3672. +++ linux/drivers/net/hp.c    Sun Oct  1 19:18:58 1995
  3673. @@ -60,10 +60,13 @@
  3674.  int hp_probe1(struct device *dev, int ioaddr);
  3675.  
  3676.  static void hp_reset_8390(struct device *dev);
  3677. -static int hp_block_input(struct device *dev, int count,
  3678. -                          char *buf, int ring_offset);
  3679. +static void hp_get_8390_hdr(struct device *dev, struct e8390_pkt_hdr *hdr,
  3680. +                    int ring_page);
  3681. +static void hp_block_input(struct device *dev, int count,
  3682. +                    struct sk_buff *skb , int ring_offset);
  3683.  static void hp_block_output(struct device *dev, int count,
  3684.                              const unsigned char *buf, const start_page);
  3685. +
  3686.  static void hp_init_card(struct device *dev);
  3687.  
  3688.  /* The map from IRQ number to HP_CONFIGURE register setting. */
  3689. @@ -184,6 +187,7 @@
  3690.      ei_status.stop_page = wordmode ? HP_16BSTOP_PG : HP_8BSTOP_PG;
  3691.  
  3692.      ei_status.reset_8390 = &hp_reset_8390;
  3693. +    ei_status.get_8390_hdr = &hp_get_8390_hdr;
  3694.      ei_status.block_input = &hp_block_input;
  3695.      ei_status.block_output = &hp_block_output;
  3696.      hp_init_card(dev);
  3697. @@ -214,17 +218,40 @@
  3698.      return;
  3699.  }
  3700.  
  3701. -/* Block input and output, similar to the Crynwr packet driver.     If you
  3702. +static void
  3703. +hp_get_8390_hdr(struct device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
  3704. +{
  3705. +    int nic_base = dev->base_addr;
  3706. +    int saved_config = inb_p(nic_base - NIC_OFFSET + HP_CONFIGURE);
  3707. +
  3708. +    outb_p(saved_config | HP_DATAON, nic_base - NIC_OFFSET + HP_CONFIGURE);
  3709. +    outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base);
  3710. +    outb_p(sizeof(struct e8390_pkt_hdr), nic_base + EN0_RCNTLO);
  3711. +    outb_p(0, nic_base + EN0_RCNTHI);
  3712. +    outb_p(0, nic_base + EN0_RSARLO);    /* On page boundary */
  3713. +    outb_p(ring_page, nic_base + EN0_RSARHI);
  3714. +    outb_p(E8390_RREAD+E8390_START, nic_base);
  3715. +
  3716. +    if (ei_status.word16) 
  3717. +      insw(nic_base - NIC_OFFSET + HP_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr)>>1);
  3718. +    else 
  3719. +      insb(nic_base - NIC_OFFSET + HP_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr));
  3720. +
  3721. +    outb_p(saved_config & (~HP_DATAON), nic_base - NIC_OFFSET + HP_CONFIGURE);
  3722. +}
  3723. +    
  3724. +/* Block input and output, similar to the Crynwr packet driver. If you are
  3725.     porting to a new ethercard look at the packet driver source for hints.
  3726.     The HP LAN doesn't use shared memory -- we put the packet
  3727.     out through the "remote DMA" dataport. */
  3728.  
  3729. -static int
  3730. -hp_block_input(struct device *dev, int count, char *buf, int ring_offset)
  3731. +static void
  3732. +hp_block_input(struct device *dev, int count, struct sk_buff *skb, int ring_offset)
  3733.  {
  3734.      int nic_base = dev->base_addr;
  3735.      int saved_config = inb_p(nic_base - NIC_OFFSET + HP_CONFIGURE);
  3736.      int xfer_count = count;
  3737. +    char *buf = skb->data;
  3738.  
  3739.      outb_p(saved_config | HP_DATAON, nic_base - NIC_OFFSET + HP_CONFIGURE);
  3740.      outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base);
  3741. @@ -251,7 +278,6 @@
  3742.                 dev->name, ring_offset + xfer_count, addr);
  3743.      }
  3744.      outb_p(saved_config & (~HP_DATAON), nic_base - NIC_OFFSET + HP_CONFIGURE);
  3745. -    return ring_offset + count;
  3746.  }
  3747.  
  3748.  static void
  3749. diff -u --recursive --new-file v1.3.30/linux/drivers/net/loopback.c linux/drivers/net/loopback.c
  3750. --- v1.3.30/linux/drivers/net/loopback.c    Sat Sep  9 15:26:52 1995
  3751. +++ linux/drivers/net/loopback.c    Wed Oct  4 08:15:11 1995
  3752. @@ -14,6 +14,7 @@
  3753.   *        Alan Cox    :    Fixed oddments for NET3.014
  3754.   *        Alan Cox    :    Rejig for NET3.029 snap #3
  3755.   *        Alan Cox    :     Fixed NET3.029 bugs and sped up
  3756. + *        Larry McVoy    :    Tiny tweak to double performance
  3757.   *
  3758.   *        This program is free software; you can redistribute it and/or
  3759.   *        modify it under the terms of the GNU General Public License
  3760. diff -u --recursive --new-file v1.3.30/linux/drivers/net/ne.c linux/drivers/net/ne.c
  3761. --- v1.3.30/linux/drivers/net/ne.c    Tue Aug 15 20:39:03 1995
  3762. +++ linux/drivers/net/ne.c    Sun Oct  1 19:18:58 1995
  3763. @@ -73,6 +73,7 @@
  3764.      {"NE1000","NE2000-invalid", {0x00, 0x00, 0xd8}}, /* Ancient real NE1000. */
  3765.      {"NN1000", "NN2000",  {0x08, 0x03, 0x08}}, /* Outlaw no-name clone. */
  3766.      {"4-DIM8","4-DIM16", {0x00,0x00,0x4d,}},  /* Outlaw 4-Dimension cards. */
  3767. +    {"Con-Intl_8", "Con-Intl_16", {0x00, 0x00, 0x24}}, /* Connect Int'nl */
  3768.      {0,}
  3769.  };
  3770.  #endif
  3771. @@ -92,8 +93,10 @@
  3772.  static int ne_probe1(struct device *dev, int ioaddr);
  3773.  
  3774.  static void ne_reset_8390(struct device *dev);
  3775. -static int ne_block_input(struct device *dev, int count,
  3776. -              char *buf, int ring_offset);
  3777. +static void ne_get_8390_hdr(struct device *dev, struct e8390_pkt_hdr *hdr,
  3778. +              int ring_page);
  3779. +static void ne_block_input(struct device *dev, int count,
  3780. +              struct sk_buff *skb, int ring_offset);
  3781.  static void ne_block_output(struct device *dev, const int count,
  3782.          const unsigned char *buf, const int start_page);
  3783.  
  3784. @@ -181,14 +184,12 @@
  3785.      /* DON'T change these to inb_p/outb_p or reset will fail on clones. */
  3786.      outb(inb(ioaddr + NE_RESET), ioaddr + NE_RESET);
  3787.  
  3788. -    /* wait 20 ms for the dust to settle. */
  3789. -    while (jiffies - reset_start_time < 2*HZ/100) 
  3790. -        barrier();
  3791. -
  3792. -    if ((inb_p(ioaddr+EN0_ISR) & ENISR_RESET) == 0) {
  3793. -        printk(" not found (no reset ack).\n");
  3794. -        return ENODEV;
  3795. -    }
  3796. +    while ((inb_p(ioaddr + EN0_ISR) & ENISR_RESET) == 0)
  3797. +        if (jiffies - reset_start_time > 2*HZ/100) {
  3798. +            printk(" not found (no reset ack).\n");
  3799. +            return ENODEV;
  3800. +        }
  3801. +
  3802.      outb_p(0xff, ioaddr + EN0_ISR);        /* Ack all intr. */
  3803.      }
  3804.  
  3805. @@ -338,6 +339,7 @@
  3806.      ei_status.reset_8390 = &ne_reset_8390;
  3807.      ei_status.block_input = &ne_block_input;
  3808.      ei_status.block_output = &ne_block_output;
  3809. +    ei_status.get_8390_hdr = &ne_get_8390_hdr;
  3810.      NS8390_init(dev, 0);
  3811.      return 0;
  3812.  }
  3813. @@ -366,27 +368,63 @@
  3814.      outb_p(ENISR_RESET, NE_BASE + EN0_ISR);    /* Ack intr. */
  3815.  }
  3816.  
  3817. +/* Grab the 8390 specific header. Similar to the block_input routine, but
  3818. +   we don't need to be concerned with ring wrap as the header will be at
  3819. +   the start of a page, so we optimize accordingly. */
  3820. +
  3821. +static void
  3822. +ne_get_8390_hdr(struct device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
  3823. +{
  3824. +
  3825. +    int nic_base = dev->base_addr;
  3826. +
  3827. +    /* This *shouldn't* happen. If it does, it's the last thing you'll see */
  3828. +    if (ei_status.dmaing) {
  3829. +    printk("%s: DMAing conflict in ne_get_8390_hdr "
  3830. +       "[DMAstat:%d][irqlock:%d][intr:%d].\n",
  3831. +       dev->name, ei_status.dmaing, ei_status.irqlock,
  3832. +       dev->interrupt);
  3833. +    return;
  3834. +    }
  3835. +
  3836. +    ei_status.dmaing |= 0x01;
  3837. +    outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
  3838. +    outb_p(sizeof(struct e8390_pkt_hdr), nic_base + EN0_RCNTLO);
  3839. +    outb_p(0, nic_base + EN0_RCNTHI);
  3840. +    outb_p(0, nic_base + EN0_RSARLO);        /* On page boundary */
  3841. +    outb_p(ring_page, nic_base + EN0_RSARHI);
  3842. +    outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD);
  3843. +
  3844. +    if (ei_status.word16)
  3845. +    insw(NE_BASE + NE_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr)>>1);
  3846. +    else
  3847. +    insb(NE_BASE + NE_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr));
  3848. +
  3849. +    outb_p(ENISR_RDC, nic_base + EN0_ISR);    /* Ack intr. */
  3850. +    ei_status.dmaing &= ~0x01;
  3851. +}
  3852. +
  3853.  /* Block input and output, similar to the Crynwr packet driver.  If you
  3854.     are porting to a new ethercard, look at the packet driver source for hints.
  3855. -   The NEx000 doesn't share it on-board packet memory -- you have to put
  3856. +   The NEx000 doesn't share the on-board packet memory -- you have to put
  3857.     the packet out through the "remote DMA" dataport using outb. */
  3858.  
  3859. -static int
  3860. -ne_block_input(struct device *dev, int count, char *buf, int ring_offset)
  3861. +static void
  3862. +ne_block_input(struct device *dev, int count, struct sk_buff *skb, int ring_offset)
  3863.  {
  3864. -    int nic_base = dev->base_addr;
  3865.  #ifdef CONFIG_NE_SANITY
  3866.      int xfer_count = count;
  3867.  #endif
  3868. +    int nic_base = dev->base_addr;
  3869. +    char *buf = skb->data;
  3870.  
  3871.      /* This *shouldn't* happen. If it does, it's the last thing you'll see */
  3872.      if (ei_status.dmaing) {
  3873. -    if (ei_debug > 0)
  3874. -        printk("%s: DMAing conflict in ne_block_input "
  3875. -           "[DMAstat:%d][irqlock:%d][intr:%d].\n",
  3876. -           dev->name, ei_status.dmaing, ei_status.irqlock,
  3877. -           dev->interrupt);
  3878. -    return 0;
  3879. +    printk("%s: DMAing conflict in ne_block_input "
  3880. +       "[DMAstat:%d][irqlock:%d][intr:%d].\n",
  3881. +       dev->name, ei_status.dmaing, ei_status.irqlock,
  3882. +       dev->interrupt);
  3883. +    return;
  3884.      }
  3885.      ei_status.dmaing |= 0x01;
  3886.      outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
  3887. @@ -431,7 +469,6 @@
  3888.  #endif
  3889.      outb_p(ENISR_RDC, nic_base + EN0_ISR);    /* Ack intr. */
  3890.      ei_status.dmaing &= ~0x01;
  3891. -    return ring_offset + count;
  3892.  }
  3893.  
  3894.  static void
  3895. @@ -452,11 +489,10 @@
  3896.  
  3897.      /* This *shouldn't* happen. If it does, it's the last thing you'll see */
  3898.      if (ei_status.dmaing) {
  3899. -    if (ei_debug > 0)
  3900. -        printk("%s: DMAing conflict in ne_block_output."
  3901. -           "[DMAstat:%d][irqlock:%d][intr:%d]\n",
  3902. -           dev->name, ei_status.dmaing, ei_status.irqlock,
  3903. -           dev->interrupt);
  3904. +    printk("%s: DMAing conflict in ne_block_output."
  3905. +       "[DMAstat:%d][irqlock:%d][intr:%d]\n",
  3906. +       dev->name, ei_status.dmaing, ei_status.irqlock,
  3907. +       dev->interrupt);
  3908.      return;
  3909.      }
  3910.      ei_status.dmaing |= 0x01;
  3911. diff -u --recursive --new-file v1.3.30/linux/drivers/net/plip.c linux/drivers/net/plip.c
  3912. --- v1.3.30/linux/drivers/net/plip.c    Mon Sep 18 14:53:54 1995
  3913. +++ linux/drivers/net/plip.c    Tue Oct  3 08:38:10 1995
  3914. @@ -1,4 +1,4 @@
  3915. -/* $Id: plip.c,v 1.14 1995/09/18 04:57:24 gniibe Exp $ */
  3916. +/* $Id: plip.c,v 1.15 1995/10/03 01:47:09 gniibe Exp $ */
  3917.  /* PLIP: A parallel port "network" driver for Linux. */
  3918.  /* This driver is for parallel port with 5-bit cable (LapLink (R) cable). */
  3919.  /*
  3920. @@ -24,6 +24,8 @@
  3921.   *        Niibe Yutaka
  3922.   *          - Module initialization.  You can specify I/O addr and IRQ:
  3923.   *            # insmod plip.o io=0x3bc irq=7
  3924. + *          - MTU fix.
  3925. + *          - Make sure other end is OK, before sending a packet.
  3926.   *
  3927.   *        This program is free software; you can redistribute it and/or
  3928.   *        modify it under the terms of the GNU General Public License
  3929. @@ -45,6 +47,10 @@
  3930.   *     So, this PLIP can't communicate the PLIP of Linux v1.0.
  3931.   */
  3932.  
  3933. +/*
  3934. + *     To use with DOS box, please do (Turn on ARP switch):
  3935. + *    # ifconfig plip[0-2] arp
  3936. + */
  3937.  static const char *version = "NET3 PLIP version 2.1 gniibe@mri.co.jp\n";
  3938.  
  3939.  /*
  3940. @@ -534,7 +540,8 @@
  3941.          if (plip_receive(nibble_timeout, status_addr,
  3942.                   &rcv->nibble, &rcv->length.b.msb))
  3943.              return TIMEOUT;
  3944. -        if (rcv->length.h > dev->mtu || rcv->length.h < 8) {
  3945. +        if (rcv->length.h > dev->mtu + dev->hard_header_len
  3946. +            || rcv->length.h < 8) {
  3947.              printk("%s: bogus packet size %d.\n", dev->name, rcv->length.h);
  3948.              return ERROR;
  3949.          }
  3950. @@ -672,6 +679,9 @@
  3951.  
  3952.      switch (snd->state) {
  3953.      case PLIP_PK_TRIGGER:
  3954. +        if ((inb(PAR_STATUS(dev)) & 0xf8) != 0x80)
  3955. +            return TIMEOUT;
  3956. +
  3957.          /* Trigger remote rx interrupt. */
  3958.          outb(0x08, data_addr);
  3959.          cx = nl->trigger;
  3960. @@ -894,7 +904,7 @@
  3961.          return 1;
  3962.      }
  3963.  
  3964. -    if (skb->len > dev->mtu) {
  3965. +    if (skb->len > dev->mtu + dev->hard_header_len) {
  3966.          printk("%s: packet too big, %d.\n", dev->name, (int)skb->len);
  3967.          dev->tbusy = 0;
  3968.          return 0;
  3969. diff -u --recursive --new-file v1.3.30/linux/drivers/net/ppp.c linux/drivers/net/ppp.c
  3970. --- v1.3.30/linux/drivers/net/ppp.c    Mon Sep 18 14:53:54 1995
  3971. +++ linux/drivers/net/ppp.c    Fri Sep 29 07:07:57 1995
  3972. @@ -746,7 +746,7 @@
  3973.      ppp->stats.sbytes += actual;
  3974.      if (actual == count) {
  3975.          ppp->xtail = 0;
  3976. -        tty->flags &= ~TTY_DO_WRITE_WAKEUP;
  3977. +        tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
  3978.  
  3979.          ppp_output_done(ppp);
  3980.      } else {
  3981. diff -u --recursive --new-file v1.3.30/linux/drivers/net/smc-ultra.c linux/drivers/net/smc-ultra.c
  3982. --- v1.3.30/linux/drivers/net/smc-ultra.c    Tue Aug 15 20:39:03 1995
  3983. +++ linux/drivers/net/smc-ultra.c    Sun Oct  1 19:18:58 1995
  3984. @@ -66,8 +66,10 @@
  3985.  
  3986.  static int ultra_open(struct device *dev);
  3987.  static void ultra_reset_8390(struct device *dev);
  3988. -static int ultra_block_input(struct device *dev, int count,
  3989. -                          char *buf, int ring_offset);
  3990. +static void ultra_get_8390_hdr(struct device *dev, struct e8390_pkt_hdr *hdr, 
  3991. +                        int ring_page);
  3992. +static void ultra_block_input(struct device *dev, int count,
  3993. +                          struct sk_buff *skb, int ring_offset);
  3994.  static void ultra_block_output(struct device *dev, int count,
  3995.                              const unsigned char *buf, const start_page);
  3996.  static int ultra_close_card(struct device *dev);
  3997. @@ -211,6 +213,7 @@
  3998.      ei_status.reset_8390 = &ultra_reset_8390;
  3999.      ei_status.block_input = &ultra_block_input;
  4000.      ei_status.block_output = &ultra_block_output;
  4001. +    ei_status.get_8390_hdr = &ultra_get_8390_hdr;
  4002.      dev->open = &ultra_open;
  4003.      dev->stop = &ultra_close_card;
  4004.      NS8390_init(dev, 0);
  4005. @@ -253,44 +256,56 @@
  4006.      return;
  4007.  }
  4008.  
  4009. +/* Grab the 8390 specific header. Similar to the block_input routine, but
  4010. +   we don't need to be concerned with ring wrap as the header will be at
  4011. +   the start of a page, so we optimize accordingly. */
  4012. +
  4013. +static void
  4014. +ultra_get_8390_hdr(struct device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
  4015. +{
  4016. +
  4017. +    unsigned long hdr_start = dev->mem_start + ((ring_page - START_PG)<<8);
  4018. +
  4019. +    outb(ULTRA_MEMENB, dev->base_addr - ULTRA_NIC_OFFSET);    /* shmem on */
  4020. +    memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
  4021. +    outb(0x00, dev->base_addr - ULTRA_NIC_OFFSET); /* shmem off */
  4022. +}
  4023. +
  4024.  /* Block input and output are easy on shared memory ethercards, the only
  4025.     complication is when the ring buffer wraps. */
  4026.  
  4027. -static int
  4028. -ultra_block_input(struct device *dev, int count, char *buf, int ring_offset)
  4029. +static void
  4030. +ultra_block_input(struct device *dev, int count, struct sk_buff *skb, int ring_offset)
  4031.  {
  4032. -    void *xfer_start = (void *)(dev->mem_start + ring_offset
  4033. -                                - (START_PG<<8));
  4034. +    unsigned long xfer_start = dev->mem_start + ring_offset - (START_PG<<8);
  4035.  
  4036.      /* Enable shared memory. */
  4037.      outb(ULTRA_MEMENB, dev->base_addr - ULTRA_NIC_OFFSET);
  4038.  
  4039. -    if (xfer_start + count > (void*) dev->rmem_end) {
  4040. +    if (xfer_start + count > dev->rmem_end) {
  4041.          /* We must wrap the input move. */
  4042. -        int semi_count = (void*)dev->rmem_end - xfer_start;
  4043. -        memcpy(buf, xfer_start, semi_count);
  4044. +        int semi_count = dev->rmem_end - xfer_start;
  4045. +        memcpy_fromio(skb->data, xfer_start, semi_count);
  4046.          count -= semi_count;
  4047. -        memcpy(buf + semi_count, (char *)dev->rmem_start, count);
  4048. -        outb(0x00, dev->base_addr - ULTRA_NIC_OFFSET); /* Disable memory. */
  4049. -        return dev->rmem_start + count;
  4050. +        memcpy_fromio(skb->data + semi_count, dev->rmem_start, count);
  4051. +    } else {
  4052. +        /* Packet is in one chunk -- we can copy + cksum. */
  4053. +        eth_io_copy_and_sum(skb, xfer_start, count, 0);
  4054.      }
  4055. -    memcpy(buf, xfer_start, count);
  4056.  
  4057. -    outb(0x00, dev->base_addr - ULTRA_NIC_OFFSET); /* Disable memory. */
  4058. -    return ring_offset + count;
  4059. +    outb(0x00, dev->base_addr - ULTRA_NIC_OFFSET);    /* Disable memory. */
  4060.  }
  4061.  
  4062.  static void
  4063.  ultra_block_output(struct device *dev, int count, const unsigned char *buf,
  4064.                  int start_page)
  4065.  {
  4066. -    unsigned char *shmem
  4067. -        = (unsigned char *)dev->mem_start + ((start_page - START_PG)<<8);
  4068. +    unsigned long shmem = dev->mem_start + ((start_page - START_PG)<<8);
  4069.  
  4070.      /* Enable shared memory. */
  4071.      outb(ULTRA_MEMENB, dev->base_addr - ULTRA_NIC_OFFSET);
  4072.  
  4073. -    memcpy(shmem, buf, count);
  4074. +    memcpy_toio(shmem, buf, count);
  4075.  
  4076.      outb(0x00, dev->base_addr - ULTRA_NIC_OFFSET); /* Disable memory. */
  4077.  }
  4078. diff -u --recursive --new-file v1.3.30/linux/drivers/net/tulip.c linux/drivers/net/tulip.c
  4079. --- v1.3.30/linux/drivers/net/tulip.c    Tue Aug 15 20:39:03 1995
  4080. +++ linux/drivers/net/tulip.c    Wed Oct  4 08:15:11 1995
  4081. @@ -696,7 +696,7 @@
  4082.      short ioaddr = dev->base_addr;
  4083.      int csr6 = inl(ioaddr + CSR6) & ~0x00D5;
  4084.  
  4085. -    if (num_addrs > 15) {
  4086. +    if (num_addrs > 15 || num_addrs == -2) {
  4087.          /* Too many to filter perfectly -- accept all multicasts. */
  4088.          outl(csr6 | 0x0080, ioaddr + CSR6);
  4089.      } else if (num_addrs < 0) {            /* Set promiscuous. */
  4090. diff -u --recursive --new-file v1.3.30/linux/drivers/net/wd.c linux/drivers/net/wd.c
  4091. --- v1.3.30/linux/drivers/net/wd.c    Tue Aug 15 20:39:03 1995
  4092. +++ linux/drivers/net/wd.c    Sun Oct  1 19:18:58 1995
  4093. @@ -45,8 +45,10 @@
  4094.  
  4095.  static int wd_open(struct device *dev);
  4096.  static void wd_reset_8390(struct device *dev);
  4097. -static int wd_block_input(struct device *dev, int count,
  4098. -                          char *buf, int ring_offset);
  4099. +static void wd_get_8390_hdr(struct device *dev, struct e8390_pkt_hdr *hdr,
  4100. +                        int ring_page);
  4101. +static void wd_block_input(struct device *dev, int count,
  4102. +                          struct sk_buff *skb, int ring_offset);
  4103.  static void wd_block_output(struct device *dev, int count,
  4104.                              const unsigned char *buf, const start_page);
  4105.  static int wd_close_card(struct device *dev);
  4106. @@ -261,6 +263,7 @@
  4107.      ei_status.reset_8390 = &wd_reset_8390;
  4108.      ei_status.block_input = &wd_block_input;
  4109.      ei_status.block_output = &wd_block_output;
  4110. +    ei_status.get_8390_hdr = &wd_get_8390_hdr;
  4111.      dev->open = &wd_open;
  4112.      dev->stop = &wd_close_card;
  4113.      NS8390_init(dev, 0);
  4114. @@ -316,40 +319,50 @@
  4115.      return;
  4116.  }
  4117.  
  4118. +/* Grab the 8390 specific header. Similar to the block_input routine, but
  4119. +   we don't need to be concerned with ring wrap as the header will be at
  4120. +   the start of a page, so we optimize accordingly. */
  4121. +
  4122. +static void
  4123. +wd_get_8390_hdr(struct device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
  4124. +{
  4125. +
  4126. +    int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
  4127. +    unsigned long hdr_start = dev->mem_start + ((ring_page - WD_START_PG)<<8);
  4128. +
  4129. +    /* We'll always get a 4 byte header read followed by a packet read, so
  4130. +       we enable 16 bit mode before the header, and disable after the body. */
  4131. +    if (ei_status.word16)
  4132. +        outb(ISA16 | ei_status.reg5, wd_cmdreg+WD_CMDREG5);
  4133. +
  4134. +    memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
  4135. +}
  4136. +
  4137.  /* Block input and output are easy on shared memory ethercards, and trivial
  4138.     on the Western digital card where there is no choice of how to do it.
  4139.     The only complications are that the ring buffer wraps, and need to map
  4140.     switch between 8- and 16-bit modes. */
  4141.  
  4142. -static int
  4143. -wd_block_input(struct device *dev, int count, char *buf, int ring_offset)
  4144. +static void
  4145. +wd_block_input(struct device *dev, int count, struct sk_buff *skb, int ring_offset)
  4146.  {
  4147.      int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
  4148. -    long xfer_start = dev->mem_start + ring_offset - (WD_START_PG<<8);
  4149. -
  4150. -    /* We'll always get a 4 byte header read followed by a packet read, so
  4151. -       we enable 16 bit mode before the header, and disable after the body. */
  4152. -    if (count == 4) {
  4153. -        if (ei_status.word16)
  4154. -            outb(ISA16 | ei_status.reg5, wd_cmdreg+WD_CMDREG5);
  4155. -        ((int*)buf)[0] = ((int*)xfer_start)[0];
  4156. -        return 0;
  4157. -    }
  4158. +    unsigned long xfer_start = dev->mem_start + ring_offset - (WD_START_PG<<8);
  4159.  
  4160.      if (xfer_start + count > dev->rmem_end) {
  4161.          /* We must wrap the input move. */
  4162.          int semi_count = dev->rmem_end - xfer_start;
  4163. -        memcpy(buf, (char *)xfer_start, semi_count);
  4164. +        memcpy_fromio(skb->data, xfer_start, semi_count);
  4165.          count -= semi_count;
  4166. -        memcpy(buf + semi_count, (char *)dev->rmem_start, count);
  4167. -    } else
  4168. -        memcpy(buf, (char *)xfer_start, count);
  4169. +        memcpy_fromio(skb->data + semi_count, dev->rmem_start, count);
  4170. +    } else {
  4171. +        /* Packet is in one chunk -- we can copy + cksum. */
  4172. +        eth_io_copy_and_sum(skb, xfer_start, count, 0);
  4173. +    }
  4174.  
  4175.      /* Turn off 16 bit access so that reboot works.     ISA brain-damage */
  4176.      if (ei_status.word16)
  4177.          outb(ei_status.reg5, wd_cmdreg+WD_CMDREG5);
  4178. -
  4179. -    return 0;
  4180.  }
  4181.  
  4182.  static void
  4183. @@ -363,10 +376,10 @@
  4184.      if (ei_status.word16) {
  4185.          /* Turn on and off 16 bit access so that reboot works. */
  4186.          outb(ISA16 | ei_status.reg5, wd_cmdreg+WD_CMDREG5);
  4187. -        memcpy((char *)shmem, buf, count);
  4188. +        memcpy_toio(shmem, buf, count);
  4189.          outb(ei_status.reg5, wd_cmdreg+WD_CMDREG5);
  4190.      } else
  4191. -        memcpy((char *)shmem, buf, count);
  4192. +        memcpy_toio(shmem, buf, count);
  4193.  }
  4194.  
  4195.  
  4196. diff -u --recursive --new-file v1.3.30/linux/drivers/scsi/53c7,8xx.c linux/drivers/scsi/53c7,8xx.c
  4197. --- v1.3.30/linux/drivers/scsi/53c7,8xx.c    Wed Sep 27 15:59:58 1995
  4198. +++ linux/drivers/scsi/53c7,8xx.c    Mon Oct  2 08:21:06 1995
  4199. @@ -1121,7 +1121,7 @@
  4200.       * hostdata structure rather than in the RELATIVE area of the 
  4201.       * SCRIPTS.
  4202.       */
  4203. -    
  4204. +
  4205.  
  4206.      patch_abs_rwri_data (hostdata->script, 0, dmode_memory_to_memory, tmp);
  4207.      patch_abs_rwri_data (hostdata->script, 0, dmode_memory_to_ncr, memory_to_ncr);
  4208. diff -u --recursive --new-file v1.3.30/linux/drivers/scsi/eata_dma.c linux/drivers/scsi/eata_dma.c
  4209. --- v1.3.30/linux/drivers/scsi/eata_dma.c    Mon Sep 25 12:26:22 1995
  4210. +++ linux/drivers/scsi/eata_dma.c    Fri Sep 29 09:27:28 1995
  4211. @@ -881,7 +881,7 @@
  4212.      }
  4213.      
  4214.      /* if gc->DMA_valid it must be an ISA HBA and we have to register it */
  4215. -    dma_channel = 0xff;
  4216. +    dma_channel = BUSMASTER;
  4217.      if (gc->DMA_valid) {
  4218.      if (request_dma(dma_channel = (8 - gc->DMA_channel) & 7, "eata_dma")) {
  4219.          printk("Unable to allocate DMA channel %d for ISA HBA at %#.4x.\n",
  4220. @@ -1025,8 +1025,9 @@
  4221.  
  4222.      hd->channel = gc->MAX_CHAN;        
  4223.      sh->max_channel = gc->MAX_CHAN; 
  4224. +    sh->unique_id = base;
  4225.      sh->base = (char *) base;
  4226. -    sh->io_port = (u16) base;
  4227. +    sh->io_port = base;
  4228.      sh->n_io_port = 9;
  4229.      sh->irq = gc->IRQ;
  4230.      sh->dma_channel = dma_channel;
  4231. @@ -1318,7 +1319,7 @@
  4232.             SD(HBA_ptr)->EATA_revision, (SD(HBA_ptr)->bustype == 'P')? 
  4233.             "PCI ":(SD(HBA_ptr)->bustype == 'E')?"EISA":"ISA ",
  4234.             (u32) HBA_ptr->base, HBA_ptr->irq);
  4235. -        if(HBA_ptr->dma_channel != 0xff)
  4236. +        if(HBA_ptr->dma_channel != BUSMASTER)
  4237.          printk("   %2x ", HBA_ptr->dma_channel);
  4238.          else
  4239.          printk("  %s", "BMST");
  4240. diff -u --recursive --new-file v1.3.30/linux/drivers/scsi/eata_dma_proc.c linux/drivers/scsi/eata_dma_proc.c
  4241. --- v1.3.30/linux/drivers/scsi/eata_dma_proc.c    Mon Sep 25 12:26:22 1995
  4242. +++ linux/drivers/scsi/eata_dma_proc.c    Fri Sep 29 09:27:28 1995
  4243. @@ -90,6 +90,7 @@
  4244.      int      size, len = 0;
  4245.      off_t begin = 0;
  4246.      off_t pos = 0;
  4247. +    scd = NULL;
  4248.  
  4249.      HBA_ptr = first_HBA;
  4250.      for (i = 1; i <= registered_HBAs; i++) {
  4251. @@ -135,8 +136,8 @@
  4252.      len += size; 
  4253.      pos = begin + len;
  4254.      
  4255. -    if(SD(HBA_ptr)->bustype == IS_EISA) {
  4256. -    if (HBA_ptr->dma_channel == 0xff)
  4257. +    if(SD(HBA_ptr)->broken_INQUIRY == TRUE) {
  4258. +    if (HBA_ptr->dma_channel == BUSMASTER)
  4259.          size = sprintf(buffer + len, "DMA: BUSMASTER\n");
  4260.      else
  4261.          size = sprintf(buffer + len, "DMA: %d\n", HBA_ptr->dma_channel);
  4262. @@ -146,6 +147,7 @@
  4263.      size = sprintf(buffer + len, "Base IO : %#.4x\n", (u32) HBA_ptr->base);
  4264.      len += size; 
  4265.      pos = begin + len;
  4266. +
  4267.      size = sprintf(buffer + len, "Host Bus: EISA\n"); 
  4268.      len += size; 
  4269.      pos = begin + len;
  4270. @@ -456,6 +458,7 @@
  4271.          goto stop_output;
  4272.      }
  4273.  
  4274. +#if 0
  4275.      scd = scsi_devices;
  4276.      
  4277.      size = sprintf(buffer+len,"Attached devices: %s\n", (scd)?"":"none");
  4278. @@ -477,6 +480,7 @@
  4279.      }
  4280.      scd = scd->next;
  4281.      }
  4282. +#endif
  4283.      
  4284.   stop_output:
  4285.      DBG(DBG_PROC, printk("2pos: %ld offset: %ld len: %d\n", pos, offset, len));
  4286. diff -u --recursive --new-file v1.3.30/linux/drivers/scsi/eata_generic.h linux/drivers/scsi/eata_generic.h
  4287. --- v1.3.30/linux/drivers/scsi/eata_generic.h    Tue Jul 18 16:28:58 1995
  4288. +++ linux/drivers/scsi/eata_generic.h    Fri Sep 29 09:27:28 1995
  4289. @@ -40,6 +40,9 @@
  4290.  
  4291.  #define BROKEN_INQUIRY    1
  4292.  
  4293. +#define BUSMASTER       0xff
  4294. +#define PIO             0xfe
  4295. +
  4296.  #define EATA_SIGNATURE    0x45415441     /* BIG ENDIAN coded "EATA" sig.     */
  4297.  #define EATA_CP_SIZE    44
  4298.  
  4299. diff -u --recursive --new-file v1.3.30/linux/drivers/scsi/eata_pio.c linux/drivers/scsi/eata_pio.c
  4300. --- v1.3.30/linux/drivers/scsi/eata_pio.c    Mon Sep 25 12:26:22 1995
  4301. +++ linux/drivers/scsi/eata_pio.c    Fri Sep 29 09:27:29 1995
  4302. @@ -783,11 +783,12 @@
  4303.      SD(sh)->hostid=gc->scsi_id[3];
  4304.      SD(sh)->devflags=1<<gc->scsi_id[3];
  4305.      SD(sh)->moresupport=gc->MORE_support;
  4306. +    sh->unique_id = base;
  4307.      sh->base = (char *) base;
  4308. -    sh->io_port = (ushort) base;
  4309. +    sh->io_port = base;
  4310.      sh->n_io_port = 8;
  4311.      sh->irq = gc->IRQ;
  4312. -    sh->dma_channel = 0xfe;  /* PIO */
  4313. +    sh->dma_channel = PIO;
  4314.      sh->this_id = gc->scsi_id[3];
  4315.      sh->can_queue = 1;
  4316.      sh->cmd_per_lun = 1;
  4317. diff -u --recursive --new-file v1.3.30/linux/drivers/scsi/scsi_proc.c linux/drivers/scsi/scsi_proc.c
  4318. --- v1.3.30/linux/drivers/scsi/scsi_proc.c    Mon Sep 18 14:54:02 1995
  4319. +++ linux/drivers/scsi/scsi_proc.c    Fri Sep 29 09:27:29 1995
  4320. @@ -265,8 +265,8 @@
  4321.      int x, y = *size;
  4322.      
  4323.      y = sprintf(buffer + len, 
  4324. -            "Channel: %02d Id: %02d Lun: %02d\n  Vendor: ",
  4325. -            scd->channel, scd->id, scd->lun);
  4326. +            "Host: scsi%d Channel: %02d Id: %02d Lun: %02d\n  Vendor: ",
  4327. +            scd->host->host_no, scd->channel, scd->id, scd->lun);
  4328.      for (x = 0; x < 8; x++) {
  4329.      if (scd->vendor[x] >= 0x20)
  4330.          y += sprintf(buffer + len + y, "%c", scd->vendor[x]);
  4331. diff -u --recursive --new-file v1.3.30/linux/drivers/scsi/sd.c linux/drivers/scsi/sd.c
  4332. --- v1.3.30/linux/drivers/scsi/sd.c    Mon Sep 18 14:54:03 1995
  4333. +++ linux/drivers/scsi/sd.c    Tue Oct  3 08:24:17 1995
  4334. @@ -1325,7 +1325,7 @@
  4335.           * Reset the blocksize for everything so that we can read
  4336.           * the partition table.
  4337.           */
  4338. -        blksize_size[MAJOR_NR][i] = 1024;
  4339. +        blksize_size[MAJOR_NR][minor] = 1024;
  4340.      };
  4341.      
  4342.  #ifdef MAYBE_REINIT
  4343. diff -u --recursive --new-file v1.3.30/linux/drivers/scsi/sr_ioctl.c linux/drivers/scsi/sr_ioctl.c
  4344. --- v1.3.30/linux/drivers/scsi/sr_ioctl.c    Mon Sep 18 14:54:03 1995
  4345. +++ linux/drivers/scsi/sr_ioctl.c    Sun Oct  1 19:51:44 1995
  4346. @@ -158,7 +158,31 @@
  4347.      result = do_ioctl(target, sr_cmd, NULL, 255);
  4348.      return result;
  4349.      }
  4350. +
  4351. +    case CDROMPLAYBLK:
  4352. +    {
  4353. +    struct cdrom_blk blk;
  4354. +
  4355. +        err = verify_area (VERIFY_READ, (void *) arg, sizeof (blk));
  4356. +        if (err) return err;
  4357. +
  4358. +    memcpy_fromfs(&blk, (void *) arg, sizeof(blk));
  4359.      
  4360. +    sr_cmd[0] = SCMD_PLAYAUDIO10;
  4361. +    sr_cmd[1] = scsi_CDs[target].device->lun << 5;
  4362. +    sr_cmd[2] = blk.from >> 24;
  4363. +    sr_cmd[3] = blk.from >> 16;
  4364. +    sr_cmd[4] = blk.from >> 8;
  4365. +    sr_cmd[5] = blk.from;
  4366. +    sr_cmd[6] = 0;
  4367. +    sr_cmd[7] = blk.len >> 8;
  4368. +    sr_cmd[8] = blk.len;
  4369. +    sr_cmd[9] = 0;
  4370. +    
  4371. +    result = do_ioctl(target, sr_cmd, NULL, 255);
  4372. +    return result;
  4373. +    }
  4374. +        
  4375.      case CDROMPLAYTRKIND:
  4376.      {
  4377.      struct cdrom_ti ti;
  4378. diff -u --recursive --new-file v1.3.30/linux/drivers/scsi/st.c linux/drivers/scsi/st.c
  4379. --- v1.3.30/linux/drivers/scsi/st.c    Wed Sep 27 15:59:59 1995
  4380. +++ linux/drivers/scsi/st.c    Wed Oct  4 08:15:24 1995
  4381. @@ -11,7 +11,7 @@
  4382.    Copyright 1992, 1993, 1994, 1995 Kai Makisara
  4383.           email Kai.Makisara@metla.fi
  4384.  
  4385. -  Last modified: Mon Sep 25 19:52:16 1995 by root@kai.makisara.fi
  4386. +  Last modified: Sat Sep 30 15:54:57 1995 by root@kai.makisara.fi
  4387.    Some small formal changes - aeb, 950809
  4388.  */
  4389.  #ifdef MODULE
  4390. @@ -684,6 +684,8 @@
  4391.      if (!SCpnt)
  4392.        return;
  4393.  
  4394. +    SCpnt->request.rq_status = RQ_INACTIVE;  /* Mark as not busy */
  4395. +
  4396.      if ((STp->buffer)->last_result_fatal != 0)
  4397.        printk("st%d: Error on write filemark.\n", dev);
  4398.      else {
  4399. @@ -693,7 +695,6 @@
  4400.        if (STp->two_fm)
  4401.          back_over_eof(STp);
  4402.      }
  4403. -    SCpnt->request.rq_status = RQ_INACTIVE;  /* Mark as not busy */
  4404.        }
  4405.  
  4406.  #if DEBUG
  4407. @@ -972,7 +973,7 @@
  4408.             (STp->buffer)->writing,
  4409.             st_sleep_done, ST_TIMEOUT, MAX_WRITE_RETRIES);
  4410.      }
  4411. -    else
  4412. +    else if (SCpnt != NULL)
  4413.        SCpnt->request.rq_status = RQ_INACTIVE;  /* Mark as not busy */
  4414.  
  4415.      STp->at_sm &= (total != 0);
  4416. @@ -1192,7 +1193,8 @@
  4417.        }
  4418.        else if (STp->eof != ST_NOEOF) {
  4419.      STp->eof_hit = 1;
  4420. -    SCpnt->request.rq_status = RQ_INACTIVE;  /* Mark as not busy */
  4421. +    if (SCpnt != NULL)
  4422. +      SCpnt->request.rq_status = RQ_INACTIVE;  /* Mark as not busy */
  4423.      if (total == 0 && STp->eof == ST_FM) {
  4424.        STp->eof = ST_NOEOF;
  4425.        STp->drv_block = 0;
  4426. @@ -1211,7 +1213,8 @@
  4427.  
  4428.      } /* for (total = 0; total < count; ) */
  4429.  
  4430. -    SCpnt->request.rq_status = RQ_INACTIVE;  /* Mark as not busy */
  4431. +    if (SCpnt != NULL)
  4432. +      SCpnt->request.rq_status = RQ_INACTIVE;  /* Mark as not busy */
  4433.  
  4434.      return total;
  4435.  }
  4436. @@ -1734,7 +1737,7 @@
  4437.  st_ioctl(struct inode * inode,struct file * file,
  4438.       unsigned int cmd_in, unsigned long arg)
  4439.  {
  4440. -   int i, cmd, result;
  4441. +   int i, cmd_nr, cmd_type, result;
  4442.     struct mtop mtc;
  4443.     struct mtpos mt_pos;
  4444.     unsigned char scmd[10];
  4445. @@ -1759,10 +1762,10 @@
  4446.         return scsi_ioctl(STp->device, cmd_in, (void *) arg);
  4447.       }
  4448.     
  4449. -   cmd = cmd_in & IOCCMD_MASK;
  4450. -   if (cmd == (MTIOCTOP & IOCCMD_MASK)) {
  4451. -
  4452. -     if (((cmd_in & IOCSIZE_MASK) >> IOCSIZE_SHIFT) != sizeof(mtc))
  4453. +   cmd_type = _IOC_TYPE(cmd_in);
  4454. +   cmd_nr   = _IOC_NR(cmd_in);
  4455. +   if (cmd_type == _IOC_TYPE(MTIOCTOP) && cmd_nr == _IOC_NR(MTIOCTOP)) {
  4456. +     if (_IOC_SIZE(cmd_in) != sizeof(mtc))
  4457.         return (-EINVAL);
  4458.  
  4459.       i = verify_area(VERIFY_READ, (void *)arg, sizeof(mtc));
  4460. @@ -1816,9 +1819,9 @@
  4461.       else
  4462.         return st_int_ioctl(inode, file, mtc.mt_op, mtc.mt_count);
  4463.     }
  4464. -   else if (cmd == (MTIOCGET & IOCCMD_MASK)) {
  4465. +   else if (cmd_type == _IOC_TYPE(MTIOCGET) && cmd_nr == _IOC_NR(MTIOCGET)) {
  4466.  
  4467. -     if (((cmd_in & IOCSIZE_MASK) >> IOCSIZE_SHIFT) != sizeof(struct mtget))
  4468. +     if (_IOC_SIZE(cmd_in) != sizeof(struct mtget))
  4469.         return (-EINVAL);
  4470.       i = verify_area(VERIFY_WRITE, (void *)arg, sizeof(struct mtget));
  4471.       if (i)
  4472. @@ -1869,14 +1872,14 @@
  4473.       (STp->mt_status)->mt_erreg = 0;  /* Clear after read */
  4474.       return 0;
  4475.     }
  4476. -   else if (cmd == (MTIOCPOS & IOCCMD_MASK)) {
  4477. +   else if (cmd_type == _IOC_TYPE(MTIOCPOS) && cmd_nr == _IOC_NR(MTIOCPOS)) {
  4478.       if (STp->ready != ST_READY)
  4479.         return (-EIO);
  4480.  #if DEBUG
  4481.       if (debugging)
  4482.         printk("st%d: get tape position.\n", dev);
  4483.  #endif
  4484. -     if (((cmd_in & IOCSIZE_MASK) >> IOCSIZE_SHIFT) != sizeof(struct mtpos))
  4485. +     if (_IOC_SIZE(cmd_in) != sizeof(struct mtpos))
  4486.         return (-EINVAL);
  4487.  
  4488.       i = flush_buffer(inode, file, 0);
  4489. diff -u --recursive --new-file v1.3.30/linux/drivers/sound/sound_switch.c linux/drivers/sound/sound_switch.c
  4490. --- v1.3.30/linux/drivers/sound/sound_switch.c    Mon Aug 28 14:52:21 1995
  4491. +++ linux/drivers/sound/sound_switch.c    Sun Oct  1 10:00:52 1995
  4492. @@ -58,9 +58,7 @@
  4493.  {
  4494.    int             l;
  4495.  
  4496. -  for (l = 0; l < 256, s[l]; l++);    /*
  4497. -                     * l=strlen(s);
  4498. -                     */
  4499. +  l = strnlen(s, 256);
  4500.  
  4501.    if (status_len + l >= 4000)
  4502.      return 0;
  4503. diff -u --recursive --new-file v1.3.30/linux/fs/binfmt_elf.c linux/fs/binfmt_elf.c
  4504. --- v1.3.30/linux/fs/binfmt_elf.c    Mon Sep 25 12:26:22 1995
  4505. +++ linux/fs/binfmt_elf.c    Wed Oct  4 08:11:50 1995
  4506. @@ -61,9 +61,9 @@
  4507.  
  4508.  struct linux_binfmt elf_format = {
  4509.  #ifndef MODULE
  4510. -    NULL, NULL, load_elf_binary, load_elf_library, aout_core_dump
  4511. +    NULL, NULL, load_elf_binary, load_elf_library, elf_core_dump
  4512.  #else
  4513. -    NULL, &mod_use_count_, load_elf_binary, load_elf_library, aout_core_dump
  4514. +    NULL, &mod_use_count_, load_elf_binary, load_elf_library, elf_core_dump
  4515.  #endif
  4516.  };
  4517.  
  4518. diff -u --recursive --new-file v1.3.30/linux/fs/ext2/super.c linux/fs/ext2/super.c
  4519. --- v1.3.30/linux/fs/ext2/super.c    Mon Sep 18 14:54:05 1995
  4520. +++ linux/fs/ext2/super.c    Mon Oct  2 14:32:53 1995
  4521. @@ -647,7 +647,7 @@
  4522.      /*
  4523.       * Allow the "check" option to be passed as a remount option.
  4524.       */
  4525. -    set_opt (sb->u.ext2_sb.s_mount_opt, CHECK_NORMAL);
  4526. +    set_opt (new_mount_opt, CHECK_NORMAL);
  4527.      if (!parse_options (data, &tmp, &resuid, &resgid,
  4528.                  &new_mount_opt))
  4529.          return -EINVAL;
  4530. diff -u --recursive --new-file v1.3.30/linux/fs/read_write.c linux/fs/read_write.c
  4531. --- v1.3.30/linux/fs/read_write.c    Tue Jun 27 14:11:44 1995
  4532. +++ linux/fs/read_write.c    Sat Sep 30 10:59:23 1995
  4533. @@ -10,6 +10,7 @@
  4534.  #include <linux/kernel.h>
  4535.  #include <linux/sched.h>
  4536.  #include <linux/mm.h>
  4537. +#include <linux/uio.h>
  4538.  
  4539.  #include <asm/segment.h>
  4540.  
  4541. @@ -148,4 +149,93 @@
  4542.          notify_change(inode, &newattrs);
  4543.      }
  4544.      return written;
  4545. +}
  4546. +
  4547. +/*
  4548. + * OSF/1 (and SunOS) readv/writev emulation.
  4549. + *
  4550. + * NOTE! This is not really the way it should be done,
  4551. + * but it should be good enough for TCP connections,
  4552. + * notably X11 ;-)
  4553. + */
  4554. +asmlinkage int sys_readv(unsigned long fd, const struct iovec * vector, long count)
  4555. +{
  4556. +    int retval;
  4557. +    struct file * file;
  4558. +    struct inode * inode;
  4559. +
  4560. +    if (fd >= NR_OPEN || !(file = current->files->fd[fd]) || !(inode = file->f_inode))
  4561. +        return -EBADF;
  4562. +    if (!(file->f_mode & 1))
  4563. +        return -EBADF;
  4564. +    if (!file->f_op || !file->f_op->read)
  4565. +        return -EINVAL;
  4566. +    if (!count)
  4567. +        return 0;
  4568. +    retval = verify_area(VERIFY_READ, vector, count*sizeof(*vector));
  4569. +    if (retval)
  4570. +        return retval;
  4571. +
  4572. +    while (count > 0) {
  4573. +        void * base;
  4574. +        int len, nr;
  4575. +
  4576. +        base = get_user(&vector->iov_base);
  4577. +        len = get_user(&vector->iov_len);
  4578. +        vector++;
  4579. +        count--;
  4580. +        nr = verify_area(VERIFY_WRITE, base, len);
  4581. +        if (!nr)
  4582. +            nr = file->f_op->read(inode, file, base, len);
  4583. +        if (nr < 0) {
  4584. +            if (retval)
  4585. +                return retval;
  4586. +            return nr;
  4587. +        }
  4588. +        retval += nr;
  4589. +        if (nr != len)
  4590. +            break;
  4591. +    }
  4592. +    return retval;
  4593. +}
  4594. +
  4595. +asmlinkage int sys_writev(unsigned long fd, const struct iovec * vector, long count)
  4596. +{
  4597. +    int retval;
  4598. +    struct file * file;
  4599. +    struct inode * inode;
  4600. +
  4601. +    if (fd >= NR_OPEN || !(file = current->files->fd[fd]) || !(inode = file->f_inode))
  4602. +        return -EBADF;
  4603. +    if (!(file->f_mode & 2))
  4604. +        return -EBADF;
  4605. +    if (!file->f_op || !file->f_op->write)
  4606. +        return -EINVAL;
  4607. +    if (!count)
  4608. +        return 0;
  4609. +    retval = verify_area(VERIFY_READ, vector, count*sizeof(*vector));
  4610. +    if (retval)
  4611. +        return retval;
  4612. +
  4613. +    while (count > 0) {
  4614. +        void * base;
  4615. +        int len, nr;
  4616. +
  4617. +        base = get_user(&vector->iov_base);
  4618. +        len = get_user(&vector->iov_len);
  4619. +        vector++;
  4620. +        count--;
  4621. +        nr = verify_area(VERIFY_READ, base, len);
  4622. +        if (!nr)
  4623. +            nr = file->f_op->write(inode, file, base, len);
  4624. +        if (nr < 0) {
  4625. +            if (retval)
  4626. +                return retval;
  4627. +            return nr;
  4628. +        }
  4629. +        retval += nr;
  4630. +        if (nr != len)
  4631. +            break;
  4632. +    }
  4633. +    return retval;
  4634.  }
  4635. diff -u --recursive --new-file v1.3.30/linux/include/asm-alpha/checksum.h linux/include/asm-alpha/checksum.h
  4636. --- v1.3.30/linux/include/asm-alpha/checksum.h    Wed Aug  2 13:21:16 1995
  4637. +++ linux/include/asm-alpha/checksum.h    Tue Oct  3 12:18:54 1995
  4638. @@ -55,4 +55,15 @@
  4639.  
  4640.  extern unsigned short ip_compute_csum(unsigned char * buff, int len);
  4641.  
  4642. +/*
  4643. + *    Fold a partial checksum without adding pseudo headers
  4644. + */
  4645. +
  4646. +static inline unsigned short csum_fold(unsigned int sum)
  4647. +{
  4648. +    sum = (sum & 0xffff) + (sum >> 16);
  4649. +    sum = (sum & 0xffff) + (sum >> 16);
  4650. +    return ~sum;
  4651. +}
  4652. +
  4653.  #endif
  4654. diff -u --recursive --new-file v1.3.30/linux/include/asm-alpha/io.h linux/include/asm-alpha/io.h
  4655. --- v1.3.30/linux/include/asm-alpha/io.h    Sun Sep  3 12:27:01 1995
  4656. +++ linux/include/asm-alpha/io.h    Sun Oct  1 19:18:58 1995
  4657. @@ -127,6 +127,14 @@
  4658.  #define memcpy_fromio(to,from,len)    (memcpy_fromio)((to),(unsigned long)(from),(len))
  4659.  #define memcpy_toio(to,from,len)    (memcpy_toio)((unsigned long)(to),(from),(len))
  4660.  
  4661. +/*
  4662. + * XXX - We don't have csum_partial_copy_fromio() yet, so we cheat here and 
  4663. + * just copy it. The net code will then do the checksum later. Presently 
  4664. + * only used by some shared memory 8390 ethernet cards anyway.
  4665. + */
  4666. +
  4667. +#define eth_io_copy_and_sum(skb,src,len,unused)    memcpy_fromio((skb)->data,(src),(len))
  4668. +
  4669.  #endif /* __KERNEL__ */
  4670.  
  4671.  #endif
  4672. diff -u --recursive --new-file v1.3.30/linux/include/asm-alpha/param.h linux/include/asm-alpha/param.h
  4673. --- v1.3.30/linux/include/asm-alpha/param.h    Fri Jun  2 13:51:17 1995
  4674. +++ linux/include/asm-alpha/param.h    Mon Oct  2 08:21:06 1995
  4675. @@ -1,8 +1,15 @@
  4676.  #ifndef _ASMAXP_PARAM_H
  4677.  #define _ASMAXP_PARAM_H
  4678.  
  4679. +#include <linux/config.h>
  4680. +
  4681.  #ifndef HZ
  4682. -#define HZ 1024
  4683. +# if defined(CONFIG_ALPHA_EB66) || defined(CONFIG_ALPHA_EB66P) || \
  4684. +     defined(CONFIG_ALPHA_EB64) || defined(CONFIG_ALPHA_EB64P)
  4685. +#  define HZ     977    /* Evaluation Boards seem to be a little odd */
  4686. +# else
  4687. +#  define HZ    1024    /* normal value for Alpha systems */
  4688. +# endif
  4689.  #endif
  4690.  
  4691.  #define EXEC_PAGESIZE    8192
  4692. diff -u --recursive --new-file v1.3.30/linux/include/asm-alpha/unistd.h linux/include/asm-alpha/unistd.h
  4693. --- v1.3.30/linux/include/asm-alpha/unistd.h    Wed Sep 13 12:45:32 1995
  4694. +++ linux/include/asm-alpha/unistd.h    Sat Sep 30 18:04:05 1995
  4695. @@ -77,6 +77,8 @@
  4696.  #define __NR_gettimeofday    116
  4697.  #define __NR_getrusage        117
  4698.  #define __NR_getsockopt        118
  4699. +#define __NR_readv        120
  4700. +#define __NR_writev        121
  4701.  #define __NR_settimeofday    122
  4702.  #define __NR_fchown        123
  4703.  #define __NR_fchmod        124
  4704. @@ -126,7 +128,7 @@
  4705.  #define __NR_syslog        310
  4706.  #define __NR_reboot        311
  4707.  #define __NR_clone        312
  4708. -
  4709. +#define __NR_uselib        313
  4710.  
  4711.  #ifdef __LIBRARY__
  4712.  
  4713. diff -u --recursive --new-file v1.3.30/linux/include/asm-i386/bitops.h linux/include/asm-i386/bitops.h
  4714. --- v1.3.30/linux/include/asm-i386/bitops.h    Mon Jul 31 15:59:02 1995
  4715. +++ linux/include/asm-i386/bitops.h    Tue Oct  3 12:22:10 1995
  4716. @@ -13,6 +13,14 @@
  4717.   * bit 0 is the LSB of addr; bit 32 is the LSB of (addr+1).
  4718.   */
  4719.  
  4720. +#include <linux/config.h>
  4721. +
  4722. +#ifdef CONFIG_SMP
  4723. +#define LOCK_PREFIX "lock ; "
  4724. +#else
  4725. +#define LOCK_PREFIX ""
  4726. +#endif
  4727. +
  4728.  /*
  4729.   * Some hacks to defeat gcc over-optimizations..
  4730.   */
  4731. @@ -23,7 +31,8 @@
  4732.  {
  4733.      int oldbit;
  4734.  
  4735. -    __asm__ __volatile__("btsl %2,%1\n\tsbbl %0,%0"
  4736. +    __asm__ __volatile__(LOCK_PREFIX
  4737. +        "btsl %2,%1\n\tsbbl %0,%0"
  4738.          :"=r" (oldbit),"=m" (ADDR)
  4739.          :"ir" (nr));
  4740.      return oldbit;
  4741. @@ -33,7 +42,8 @@
  4742.  {
  4743.      int oldbit;
  4744.  
  4745. -    __asm__ __volatile__("btrl %2,%1\n\tsbbl %0,%0"
  4746. +    __asm__ __volatile__(LOCK_PREFIX
  4747. +        "btrl %2,%1\n\tsbbl %0,%0"
  4748.          :"=r" (oldbit),"=m" (ADDR)
  4749.          :"ir" (nr));
  4750.      return oldbit;
  4751. @@ -43,7 +53,8 @@
  4752.  {
  4753.      int oldbit;
  4754.  
  4755. -    __asm__ __volatile__("btcl %2,%1\n\tsbbl %0,%0"
  4756. +    __asm__ __volatile__(LOCK_PREFIX
  4757. +        "btcl %2,%1\n\tsbbl %0,%0"
  4758.          :"=r" (oldbit),"=m" (ADDR)
  4759.          :"ir" (nr));
  4760.      return oldbit;
  4761. diff -u --recursive --new-file v1.3.30/linux/include/asm-i386/checksum.h linux/include/asm-i386/checksum.h
  4762. --- v1.3.30/linux/include/asm-i386/checksum.h    Wed Sep 13 12:45:32 1995
  4763. +++ linux/include/asm-i386/checksum.h    Tue Oct  3 11:45:59 1995
  4764. @@ -103,20 +103,17 @@
  4765.   *    Fold a partial checksum without adding pseudo headers
  4766.   */
  4767.  
  4768. -static inline unsigned short int csum_fold(unsigned int sum)
  4769. +static inline unsigned int csum_fold(unsigned int sum)
  4770.  {
  4771. -     __asm__("
  4772. -         movl %0, %1
  4773. -         shrl $16, %1
  4774. -         addw %w1, %w0
  4775. -         adcl $0, %0
  4776. -         notl %0
  4777. -         "
  4778. -         : "=&r" (sum)
  4779. -         : "0" (sum)
  4780. -     );
  4781. -     return sum;
  4782. - }
  4783. +    __asm__("
  4784. +        addl %1, %0
  4785. +        adcl $0xffff, %0
  4786. +        "
  4787. +        : "=r" (sum)
  4788. +        : "r" (sum << 16), "0" (sum & 0xffff0000)
  4789. +    );
  4790. +    return (~sum) >> 16;
  4791. +}
  4792.   
  4793.  /*
  4794.   * this routine is used for miscellaneous IP-like checksums, mainly
  4795. diff -u --recursive --new-file v1.3.30/linux/include/asm-i386/delay.h linux/include/asm-i386/delay.h
  4796. --- v1.3.30/linux/include/asm-i386/delay.h    Wed Dec 14 14:18:14 1994
  4797. +++ linux/include/asm-i386/delay.h    Mon Oct  2 14:25:10 1995
  4798. @@ -6,6 +6,10 @@
  4799.   *
  4800.   * Delay routines, using a pre-computed "loops_per_second" value.
  4801.   */
  4802. + 
  4803. +#ifdef CONFIG_SMP
  4804. +#include <asm/smp.h>
  4805. +#endif 
  4806.  
  4807.  extern __inline__ void __delay(int loops)
  4808.  {
  4809. @@ -27,8 +31,13 @@
  4810.      usecs *= 0x000010c6;        /* 2**32 / 1000000 */
  4811.      __asm__("mull %0"
  4812.          :"=d" (usecs)
  4813. +#ifdef CONFIG_SMP
  4814. +        :"a" (usecs),"0" (cpu_data[smp_processor_id()].udelay_val)
  4815. +#else
  4816.          :"a" (usecs),"0" (loops_per_sec)
  4817. +#endif
  4818.          :"ax");
  4819. +        
  4820.      __delay(usecs);
  4821.  }
  4822.  
  4823. diff -u --recursive --new-file v1.3.30/linux/include/asm-i386/io.h linux/include/asm-i386/io.h
  4824. --- v1.3.30/linux/include/asm-i386/io.h    Sun Sep  3 16:12:49 1995
  4825. +++ linux/include/asm-i386/io.h    Sun Oct  1 19:18:58 1995
  4826. @@ -78,6 +78,12 @@
  4827.  #define memcpy_toio(a,b,c)    memcpy((void *)(a),(b),(c))
  4828.  
  4829.  /*
  4830. + * Again, i386 does not require mem IO specific function.
  4831. + */
  4832. +
  4833. +#define eth_io_copy_and_sum(a,b,c,d)    eth_copy_and_sum((a),(void *)(b),(c),(d))
  4834. +
  4835. +/*
  4836.   * Talk about misusing macros..
  4837.   */
  4838.  
  4839. diff -u --recursive --new-file v1.3.30/linux/include/asm-i386/irq.h linux/include/asm-i386/irq.h
  4840. --- v1.3.30/linux/include/asm-i386/irq.h    Mon Sep 18 14:54:09 1995
  4841. +++ linux/include/asm-i386/irq.h    Mon Oct  2 14:25:11 1995
  4842. @@ -5,6 +5,8 @@
  4843.   *    linux/include/asm/irq.h
  4844.   *
  4845.   *    (C) 1992, 1993 Linus Torvalds
  4846. + *
  4847. + *    IRQ/IPI changes taken from work by Thomas Radke <tomsoft@informatik.tu-chemnitz.de>
  4848.   */
  4849.  
  4850.  #include <linux/linkage.h>
  4851. @@ -124,6 +126,174 @@
  4852.  #define IRQ_NAME(nr) IRQ_NAME2(IRQ##nr)
  4853.  #define FAST_IRQ_NAME(nr) IRQ_NAME2(fast_IRQ##nr)
  4854.  #define BAD_IRQ_NAME(nr) IRQ_NAME2(bad_IRQ##nr)
  4855. +
  4856. +#ifdef    CONFIG_SMP
  4857. +
  4858. +#define GET_PROCESSOR_ID \
  4859. +    "movl "SYMBOL_NAME_STR(apic_reg)", %edx\n\t" \
  4860. +    "movl 32(%edx), %eax\n\t" \
  4861. +    "shrl $24,%eax\n\t" \
  4862. +    "andb $0x0F,%al\n"
  4863. +    
  4864. +#define    ENTER_KERNEL \
  4865. +    "pushl %eax\n\t" \
  4866. +    "pushl %edx\n\t" \
  4867. +    "pushfl\n\t" \
  4868. +    "cli\n\t" \
  4869. +    GET_PROCESSOR_ID \
  4870. +    "1: " \
  4871. +    "lock\n\t" \
  4872. +    "btsl $0, "SYMBOL_NAME_STR(kernel_flag)"\n\t" \
  4873. +    "jnc 3f\n\t" \
  4874. +    "cmpb "SYMBOL_NAME_STR(active_kernel_processor)", %al\n\t" \
  4875. +    "je 4f\n\t" \
  4876. +    "2: " \
  4877. +    "incl "SYMBOL_NAME_STR(smp_spins)"\n\t" \
  4878. +    "btl %al, "SYMBOL_NAME_STR(smp_invalidate_needed)"\n\t" \
  4879. +    "jnc 5f\n\t" \
  4880. +    "lock\n\t" \
  4881. +    "btrl %al, "SYMBOL_NAME_STR(smp_invalidate_needed)"\n\t" \
  4882. +    "jnc 5f\n\t" \
  4883. +    "movl %cr3,%edx\n\t" \
  4884. +    "movl %edx,%cr3\n" \
  4885. +    "5: btl $0, "SYMBOL_NAME_STR(kernel_flag)"\n\t" \
  4886. +    "jc 2b\n\t" \
  4887. +    "jmp 1b\n\t" \
  4888. +    "3: " \
  4889. +    "movb %al, "SYMBOL_NAME_STR(active_kernel_processor)"\n\t" \
  4890. +    "4: " \
  4891. +    "incl "SYMBOL_NAME_STR(kernel_counter)"\n\t" \
  4892. +    "popfl\n\t" \
  4893. +    "popl %edx\n\t" \
  4894. +    "popl %eax\n\t"
  4895. +
  4896. +#define    LEAVE_KERNEL \
  4897. +    "pushfl\n\t" \
  4898. +    "cli\n\t" \
  4899. +    "decl "SYMBOL_NAME_STR(kernel_counter)"\n\t" \
  4900. +    "jnz 1f\n\t" \
  4901. +    "movb $" STR (NO_PROC_ID) ", "SYMBOL_NAME_STR(active_kernel_processor)"\n\t" \
  4902. +    "lock\n\t" \
  4903. +    "btrl $0, "SYMBOL_NAME_STR(kernel_flag)"\n\t" \
  4904. +    "1: " \
  4905. +    "popfl\n\t"
  4906. +    
  4907. +    
  4908. +/*
  4909. + *    the syscall count inc is a gross hack because ret_from_syscall is used by both irq and
  4910. + *    syscall return paths (urghh).
  4911. + */
  4912. + 
  4913. +#define BUILD_IRQ(chip,nr,mask) \
  4914. +asmlinkage void IRQ_NAME(nr); \
  4915. +asmlinkage void FAST_IRQ_NAME(nr); \
  4916. +asmlinkage void BAD_IRQ_NAME(nr); \
  4917. +__asm__( \
  4918. +"\n"__ALIGN_STR"\n" \
  4919. +SYMBOL_NAME_STR(IRQ) #nr "_interrupt:\n\t" \
  4920. +    "pushl $-"#nr"-2\n\t" \
  4921. +    SAVE_ALL \
  4922. +    ENTER_KERNEL \
  4923. +    ACK_##chip(mask) \
  4924. +    "incl "SYMBOL_NAME_STR(intr_count)"\n\t"\
  4925. +    "sti\n\t" \
  4926. +    "movl %esp,%ebx\n\t" \
  4927. +    "pushl %ebx\n\t" \
  4928. +    "pushl $" #nr "\n\t" \
  4929. +    "call "SYMBOL_NAME_STR(do_IRQ)"\n\t" \
  4930. +    "addl $8,%esp\n\t" \
  4931. +    "cli\n\t" \
  4932. +    UNBLK_##chip(mask) \
  4933. +    "decl "SYMBOL_NAME_STR(intr_count)"\n\t" \
  4934. +    "incl "SYMBOL_NAME_STR(syscall_count)"\n\t" \
  4935. +    "jmp ret_from_sys_call\n" \
  4936. +"\n"__ALIGN_STR"\n" \
  4937. +SYMBOL_NAME_STR(fast_IRQ) #nr "_interrupt:\n\t" \
  4938. +    SAVE_MOST \
  4939. +    ENTER_KERNEL \
  4940. +    ACK_##chip(mask) \
  4941. +    "incl "SYMBOL_NAME_STR(intr_count)"\n\t" \
  4942. +    "pushl $" #nr "\n\t" \
  4943. +    "call "SYMBOL_NAME_STR(do_fast_IRQ)"\n\t" \
  4944. +    "addl $4,%esp\n\t" \
  4945. +    "cli\n\t" \
  4946. +    UNBLK_##chip(mask) \
  4947. +    "decl "SYMBOL_NAME_STR(intr_count)"\n\t" \
  4948. +    LEAVE_KERNEL \
  4949. +    RESTORE_MOST \
  4950. +"\n"__ALIGN_STR"\n" \
  4951. +SYMBOL_NAME_STR(bad_IRQ) #nr "_interrupt:\n\t" \
  4952. +    SAVE_MOST \
  4953. +    ENTER_KERNEL \
  4954. +    ACK_##chip(mask) \
  4955. +    LEAVE_KERNEL \
  4956. +    RESTORE_MOST);
  4957. +    
  4958. +    
  4959. +/*
  4960. + *    Message pass must be a fast IRQ..
  4961. + */
  4962. +
  4963. +#define BUILD_MSGIRQ(chip,nr,mask) \
  4964. +asmlinkage void IRQ_NAME(nr); \
  4965. +asmlinkage void FAST_IRQ_NAME(nr); \
  4966. +asmlinkage void BAD_IRQ_NAME(nr); \
  4967. +__asm__( \
  4968. +"\n"__ALIGN_STR"\n" \
  4969. +SYMBOL_NAME_STR(IRQ) #nr "_interrupt:\n\t" \
  4970. +    "pushl $-"#nr"-2\n\t" \
  4971. +    SAVE_ALL \
  4972. +    ENTER_KERNEL \
  4973. +    ACK_##chip(mask) \
  4974. +    "incl "SYMBOL_NAME_STR(intr_count)"\n\t"\
  4975. +    "sti\n\t" \
  4976. +    "movl %esp,%ebx\n\t" \
  4977. +    "pushl %ebx\n\t" \
  4978. +    "pushl $" #nr "\n\t" \
  4979. +    "call "SYMBOL_NAME_STR(do_IRQ)"\n\t" \
  4980. +    "addl $8,%esp\n\t" \
  4981. +    "cli\n\t" \
  4982. +    UNBLK_##chip(mask) \
  4983. +    "decl "SYMBOL_NAME_STR(intr_count)"\n\t" \
  4984. +    "incl "SYMBOL_NAME_STR(syscall_count)"\n\t" \
  4985. +    "jmp ret_from_sys_call\n" \
  4986. +"\n"__ALIGN_STR"\n" \
  4987. +SYMBOL_NAME_STR(fast_IRQ) #nr "_interrupt:\n\t" \
  4988. +    SAVE_MOST \
  4989. +    ACK_##chip(mask) \
  4990. +    "incl "SYMBOL_NAME_STR(ipi_count)"\n\t" \
  4991. +    "pushl $" #nr "\n\t" \
  4992. +    "call "SYMBOL_NAME_STR(do_fast_IRQ)"\n\t" \
  4993. +    "addl $4,%esp\n\t" \
  4994. +    "cli\n\t" \
  4995. +    UNBLK_##chip(mask) \
  4996. +    RESTORE_MOST \
  4997. +"\n"__ALIGN_STR"\n" \
  4998. +SYMBOL_NAME_STR(bad_IRQ) #nr "_interrupt:\n\t" \
  4999. +    SAVE_MOST \
  5000. +    ACK_##chip(mask) \
  5001. +    RESTORE_MOST);
  5002. +
  5003. +#define BUILD_RESCHEDIRQ(nr) \
  5004. +asmlinkage void IRQ_NAME(nr); \
  5005. +__asm__( \
  5006. +"\n"__ALIGN_STR"\n" \
  5007. +SYMBOL_NAME_STR(IRQ) #nr "_interrupt:\n\t" \
  5008. +    "pushl $-"#nr"-2\n\t" \
  5009. +    SAVE_ALL \
  5010. +    ENTER_KERNEL \
  5011. +    "incl "SYMBOL_NAME_STR(intr_count)"\n\t"\
  5012. +    "sti\n\t" \
  5013. +    "movl %esp,%ebx\n\t" \
  5014. +    "pushl %ebx\n\t" \
  5015. +    "pushl $" #nr "\n\t" \
  5016. +    "call "SYMBOL_NAME_STR(smp_reschedule_irq)"\n\t" \
  5017. +    "addl $8,%esp\n\t" \
  5018. +    "cli\n\t" \
  5019. +    "decl "SYMBOL_NAME_STR(intr_count)"\n\t" \
  5020. +    "incl "SYMBOL_NAME_STR(syscall_count)"\n\t" \
  5021. +    "jmp ret_from_sys_call\n");
  5022. +#else
  5023.      
  5024.  #define BUILD_IRQ(chip,nr,mask) \
  5025.  asmlinkage void IRQ_NAME(nr); \
  5026. @@ -164,4 +334,5 @@
  5027.      ACK_##chip(mask) \
  5028.      RESTORE_MOST);
  5029.  
  5030. +#endif
  5031.  #endif
  5032. diff -u --recursive --new-file v1.3.30/linux/include/asm-i386/locks.h linux/include/asm-i386/locks.h
  5033. --- v1.3.30/linux/include/asm-i386/locks.h    Thu Jan  1 02:00:00 1970
  5034. +++ linux/include/asm-i386/locks.h    Mon Oct  2 14:25:11 1995
  5035. @@ -0,0 +1,133 @@
  5036. +/*
  5037. + *    SMP locks primitives for building ix86 locks
  5038. + *    (not yet used).
  5039. + *
  5040. + *        Alan Cox, alan@cymru.net, 1995
  5041. + */
  5042. + 
  5043. +/*
  5044. + *    This would be much easier but far less clear and easy
  5045. + *    to borrow for other processors if it was just assembler.
  5046. + */
  5047. +
  5048. +extern __inline__ void prim_spin_lock(struct spinlock *sp)
  5049. +{
  5050. +    int processor=smp_processor_id();
  5051. +    
  5052. +    /*
  5053. +     *    Grab the lock bit
  5054. +     */
  5055. +     
  5056. +    while(lock_set_bit(0,&sp->lock))
  5057. +    {
  5058. +        /*
  5059. +         *    Failed, but thats cos we own it!
  5060. +         */
  5061. +         
  5062. +        if(sp->cpu==processor)
  5063. +        {
  5064. +            sp->users++;
  5065. +            return 0;
  5066. +        }
  5067. +        /*
  5068. +         *    Spin in the cache S state if possible
  5069. +         */
  5070. +        while(sp->lock)
  5071. +        {
  5072. +            /*
  5073. +             *    Wait for any invalidates to go off
  5074. +             */
  5075. +             
  5076. +            if(smp_invalidate_needed&(1<<processor));
  5077. +                while(lock_clear_bit(processor,&smp_invalidate_needed))
  5078. +                    local_invalidate();
  5079. +            sp->spins++;
  5080. +        }
  5081. +        /*
  5082. +         *    Someone wrote the line, we go 'I' and get
  5083. +         *    the cache entry. Now try and regrab
  5084. +         */
  5085. +    }
  5086. +    sp->users++;sp->cpu=processor;
  5087. +    return 1;
  5088. +}
  5089. +
  5090. +/*
  5091. + *    Release a spin lock
  5092. + */
  5093. + 
  5094. +extern __inline__ int prim_spin_unlock(struct spinlock *sp)
  5095. +{
  5096. +    /* This is safe. The decrement is still guarded by the lock. A multilock would
  5097. +       not be safe this way */
  5098. +    if(!--sp->users)
  5099. +    {
  5100. +        lock_clear_bit(0,&sp->lock);sp->cpu= NO_PROC_ID;
  5101. +        return 1;
  5102. +    }
  5103. +    return 0;
  5104. +}
  5105. +
  5106. +
  5107. +/*
  5108. + *    Non blocking lock grab
  5109. + */
  5110. + 
  5111. +extern __inline__ int prim_spin_lock_nb(struct spinlock *sp)
  5112. +{
  5113. +    if(lock_set_bit(0,&sp->lock))
  5114. +        return 0;        /* Locked already */
  5115. +    sp->users++;
  5116. +    return 1;            /* We got the lock */
  5117. +}
  5118. +
  5119. +
  5120. +/*
  5121. + *    These wrap the locking primtives up for usage
  5122. + */
  5123. + 
  5124. +extern __inline__ void spinlock(struct spinlock *sp)
  5125. +{
  5126. +    if(sp->priority<current->lock_order)
  5127. +        panic("lock order violation: %s (%d)\n", sp->name, current->lock_order);
  5128. +    if(prim_spin_lock(sp))
  5129. +    {
  5130. +        /*
  5131. +         *    We got a new lock. Update the priority chain
  5132. +         */
  5133. +        sp->oldpri=current->lock_order;
  5134. +        current->lock_order=sp->priority;
  5135. +    }
  5136. +}
  5137. +
  5138. +extern __inline__ void spinunlock(struct spinlock *sp)
  5139. +{
  5140. +    if(current->lock_order!=sp->priority)
  5141. +        panic("lock release order violation %s (%d)\n", sp->name, current->lock_order);
  5142. +    if(prim_spin_unlock(sp))
  5143. +    {
  5144. +        /*
  5145. +         *    Update the debugging lock priority chain. We dumped
  5146. +         *    our last right to the lock.
  5147. +         */
  5148. +        current->lock_order=sp->oldpri;
  5149. +    }    
  5150. +}
  5151. +
  5152. +extern __inline__ void spintestlock(struct spinlock *sp)
  5153. +{
  5154. +    /*
  5155. +     *    We do no sanity checks, its legal to optimistically
  5156. +     *    get a lower lock.
  5157. +     */
  5158. +    prim_spin_lock_nb(sp);
  5159. +}
  5160. +
  5161. +extern __inline__ void spintestunlock(struct spinlock *sp)
  5162. +{
  5163. +    /*
  5164. +     *    A testlock doesnt update the lock chain so we
  5165. +     *    must not update it on free
  5166. +     */
  5167. +    prim_spin_unlock(sp);
  5168. +}
  5169. diff -u --recursive --new-file v1.3.30/linux/include/asm-i386/page.h linux/include/asm-i386/page.h
  5170. --- v1.3.30/linux/include/asm-i386/page.h    Mon Sep 25 12:26:23 1995
  5171. +++ linux/include/asm-i386/page.h    Mon Oct  2 14:25:11 1995
  5172. @@ -60,6 +60,8 @@
  5173.   *
  5174.   * ..but the i386 has somewhat limited invalidation capabilities.
  5175.   */
  5176. + 
  5177. +#ifndef CONFIG_SMP
  5178.  #define invalidate() \
  5179.  __asm__ __volatile__("movl %%cr3,%%eax\n\tmovl %%eax,%%cr3": : :"ax")
  5180.  
  5181. @@ -68,6 +70,14 @@
  5182.  do { if ((task)->mm == current->mm) invalidate(); } while (0)
  5183.  #define invalidate_page(task,addr) \
  5184.  do { if ((task)->mm == current->mm) invalidate(); } while (0)
  5185. +
  5186. +#else
  5187. +#include <asm/smp.h>
  5188. +#define local_invalidate() \
  5189. +__asm__ __volatile__("movl %%cr3,%%eax\n\tmovl %%eax,%%cr3": : :"ax")
  5190. +#define invalidate() \
  5191. +    smp_invalidate();
  5192. +#endif
  5193.  
  5194.  /* Certain architectures need to do special things when pte's
  5195.   * within a page table are directly modified.  Thus, the following
  5196. diff -u --recursive --new-file v1.3.30/linux/include/asm-i386/smp.h linux/include/asm-i386/smp.h
  5197. --- v1.3.30/linux/include/asm-i386/smp.h    Wed Sep 27 16:00:00 1995
  5198. +++ linux/include/asm-i386/smp.h    Mon Oct  2 14:25:11 1995
  5199. @@ -1,6 +1,7 @@
  5200.  #ifndef __ASM_SMP_H
  5201.  #define __ASM_SMP_H
  5202.  
  5203. +#ifdef CONFIG_SMP
  5204.  #ifndef ASSEMBLY
  5205.  
  5206.  #include <asm/i82489.h>
  5207. @@ -165,7 +166,7 @@
  5208.  };
  5209.  
  5210.  
  5211. -extern struct cpuinfo_x86 cpu_data[NR_PROCS];
  5212. +extern struct cpuinfo_x86 cpu_data[NR_CPUS];
  5213.  
  5214.  /*
  5215.   *    Private routines/data
  5216. @@ -174,7 +175,7 @@
  5217.  extern void smp_scan_config(unsigned long, unsigned long);
  5218.  extern unsigned long smp_alloc_memory(unsigned long mem_base);
  5219.  extern unsigned char *apic_reg;
  5220. -extern unsigned char *kernel_stacks[NR_PROCS];
  5221. +extern unsigned char *kernel_stacks[NR_CPUS];
  5222.  extern unsigned char boot_cpu_id;
  5223.  extern unsigned long cpu_present_map;
  5224.  extern void smp_invalidate(void);
  5225. @@ -227,5 +228,5 @@
  5226.  #endif /* !ASSEMBLY */
  5227.  
  5228.  #define NO_PROC_ID        0xFF        /* No processor magic marker */
  5229. -
  5230. +#endif
  5231.  #endif
  5232. diff -u --recursive --new-file v1.3.30/linux/include/asm-i386/system.h linux/include/asm-i386/system.h
  5233. --- v1.3.30/linux/include/asm-i386/system.h    Tue Jul 18 16:28:58 1995
  5234. +++ linux/include/asm-i386/system.h    Mon Oct  2 14:25:11 1995
  5235. @@ -47,9 +47,62 @@
  5236.   *
  5237.   * It also reloads the debug regs if necessary..
  5238.   */
  5239. +
  5240. + 
  5241. +#ifdef CONFIG_SMP
  5242. +    /*
  5243. +     *    Keep the lock depth straight. If we switch on an interrupt from
  5244. +     *    kernel->user task we need to lose a depth, and if we switch the
  5245. +     *    other way we need to gain a depth. Same layer switches come out
  5246. +     *    the same.
  5247. +     *
  5248. +     *    We spot a switch in user mode because the kernel counter is the
  5249. +     *    same as the interrupt counter depth. (We never switch during the
  5250. +     *    message/invalidate IPI).
  5251. +     *
  5252. +     *    We fsave/fwait so that an exception goes off at the right time
  5253. +     *    (as a call from the fsave or fwait in effect) rather than to
  5254. +     *    the wrong process.
  5255. +     */
  5256. +
  5257. +#define switch_to(tsk) do { \
  5258. +    cli();\
  5259. +    if(current->flags&PF_USEDFPU) \
  5260. +    { \
  5261. +        __asm__ __volatile__("fnsave %0":"=m" (current->tss.i387.hard)); \
  5262. +        __asm__ __volatile__("fwait"); \
  5263. +        current->flags&=~PF_USEDFPU;     \
  5264. +    } \
  5265. +    current->lock_depth=syscall_count; \
  5266. +    kernel_counter+=next->lock_depth-current->lock_depth; \
  5267. +    syscall_count=next->lock_depth; \
  5268. +__asm__("pushl %%edx\n\t" \
  5269. +    "movl "SYMBOL_NAME_STR(apic_reg)",%%edx\n\t" \
  5270. +    "movl 0x20(%%edx), %%edx\n\t" \
  5271. +    "shrl $22,%%edx\n\t" \
  5272. +    "and  $0x3C,%%edx\n\t" \
  5273. +    "xchgl %%ecx,"SYMBOL_NAME_STR(current_set)"(,%%edx)\n\t" \
  5274. +    "popl %%edx\n\t" \
  5275. +    "ljmp %0\n\t" \
  5276. +    "sti\n\t" \
  5277. +    : /* no output */ \
  5278. +    :"m" (*(((char *)&tsk->tss.tr)-4)), \
  5279. +     "c" (tsk) \
  5280. +    :"cx"); \
  5281. +    /* Now maybe reload the debug registers */ \
  5282. +    if(current->debugreg[7]){ \
  5283. +        loaddebug(0); \
  5284. +        loaddebug(1); \
  5285. +        loaddebug(2); \
  5286. +        loaddebug(3); \
  5287. +        loaddebug(6); \
  5288. +    } \
  5289. +} while (0)
  5290. +
  5291. +#else
  5292.  #define switch_to(tsk) do { \
  5293.  __asm__("cli\n\t" \
  5294. -    "xchgl %%ecx,"SYMBOL_NAME_STR(current)"\n\t" \
  5295. +    "xchgl %%ecx,"SYMBOL_NAME_STR(current_set)"\n\t" \
  5296.      "ljmp %0\n\t" \
  5297.      "sti\n\t" \
  5298.      "cmpl %%ecx,"SYMBOL_NAME_STR(last_task_used_math)"\n\t" \
  5299. @@ -69,6 +122,7 @@
  5300.          loaddebug(6); \
  5301.      } \
  5302.  } while (0)
  5303. +#endif
  5304.  
  5305.  #define _set_base(addr,base) \
  5306.  __asm__("movw %%dx,%0\n\t" \
  5307. diff -u --recursive --new-file v1.3.30/linux/include/asm-i386/unistd.h linux/include/asm-i386/unistd.h
  5308. --- v1.3.30/linux/include/asm-i386/unistd.h    Wed Sep 13 12:45:32 1995
  5309. +++ linux/include/asm-i386/unistd.h    Sat Sep 30 18:03:16 1995
  5310. @@ -150,6 +150,8 @@
  5311.  #define __NR__newselect        142
  5312.  #define __NR_flock        143
  5313.  #define __NR_msync        144
  5314. +#define __NR_readv        145
  5315. +#define __NR_writev        146
  5316.  
  5317.  /* XXX - _foo needs to be __foo, while __NR_bar could be _NR_bar. */
  5318.  #define _syscall0(type,name) \
  5319. diff -u --recursive --new-file v1.3.30/linux/include/linux/cdrom.h linux/include/linux/cdrom.h
  5320. --- v1.3.30/linux/include/linux/cdrom.h    Fri Sep 15 11:13:02 1995
  5321. +++ linux/include/linux/cdrom.h    Sun Oct  1 19:51:44 1995
  5322. @@ -65,6 +65,13 @@
  5323.   * CDROM IOCTL structures
  5324.   */
  5325.  
  5326. +struct cdrom_blk 
  5327. +{
  5328. +    unsigned from;
  5329. +    unsigned short len;
  5330. +};
  5331. +
  5332. +
  5333.  struct cdrom_msf 
  5334.  {
  5335.      u_char    cdmsf_min0;    /* start minute */
  5336. @@ -285,7 +292,10 @@
  5337.  #define CDROMREADCOOKED        0x5315    /* read data in cooked mode */
  5338.  #define CDROMSEEK        0x5316  /*seek msf address*/
  5339.    
  5340. -
  5341. +/*
  5342. + * for playing audio in logical block addressing mode
  5343. + */
  5344. +#define CDROMPLAYBLK        0x5317    /* (struct cdrom_blk) */
  5345.  
  5346.  /*
  5347.   * CD-ROM-specific SCSI command opcodes
  5348. diff -u --recursive --new-file v1.3.30/linux/include/linux/igmp.h linux/include/linux/igmp.h
  5349. --- v1.3.30/linux/include/linux/igmp.h    Wed Sep 13 12:45:32 1995
  5350. +++ linux/include/linux/igmp.h    Mon Oct  2 14:25:11 1995
  5351. @@ -42,6 +42,7 @@
  5352.  #define IGMP_MTRACE_RESP        0x1e
  5353.  #define IGMP_MTRACE            0x1f
  5354.  
  5355. +
  5356.  /*
  5357.   *    Use the BSD names for these for compatibility
  5358.   */
  5359. diff -u --recursive --new-file v1.3.30/linux/include/linux/mroute.h linux/include/linux/mroute.h
  5360. --- v1.3.30/linux/include/linux/mroute.h    Wed Sep 13 12:45:32 1995
  5361. +++ linux/include/linux/mroute.h    Mon Oct  2 14:25:11 1995
  5362. @@ -1,5 +1,6 @@
  5363.  #ifndef __LINUX_MROUTE_H
  5364.  #define __LINUX_MROUTE_H
  5365. +
  5366.  /*
  5367.   *    Based on the MROUTING 3.5 defines primarily to keep
  5368.   *    source compatibility with BSD.
  5369. @@ -117,19 +118,53 @@
  5370.  extern int ip_mroute_getsockopt(struct sock *, int, char *, int *);
  5371.  extern int ipmr_ioctl(struct sock *sk, int cmd, unsigned long arg);
  5372.  extern void mroute_close(struct sock *sk);
  5373. +extern void ipmr_forward(struct sk_buff *skb, int is_frag);
  5374.  
  5375.  
  5376.  struct vif_device
  5377.  {
  5378. -    struct device *dev;        /* Device we are using */
  5379. -    struct route *rt_cache;        /* Tunnel route cache */
  5380. -    unsigned long bytes_in,bytes_out;
  5381. -    unsigned long pkt_in,pkt_out;    /* Statistics */
  5382. -    unsigned long rate_limit;    /* Traffic shaping (NI) */
  5383. -    unsigned char threshold;    /* TTL threshold */
  5384. -    unsigned short flags;        /* Control flags */
  5385. -    unsigned long local,remote;    /* Addresses (remote for tunnels) */
  5386. +    struct device     *dev;            /* Device we are using */
  5387. +    struct route     *rt_cache;        /* Tunnel route cache */
  5388. +    unsigned long    bytes_in,bytes_out;
  5389. +    unsigned long    pkt_in,pkt_out;        /* Statistics             */
  5390. +    unsigned long    rate_limit;        /* Traffic shaping (NI)     */
  5391. +    unsigned char    threshold;        /* TTL threshold         */
  5392. +    unsigned short    flags;            /* Control flags         */
  5393. +    unsigned long    local,remote;        /* Addresses(remote for tunnels)*/
  5394.  };
  5395.  
  5396. +struct mfc_cache 
  5397. +{
  5398. +    struct mfc_cache *next;            /* Next entry on cache line     */
  5399. +    __u32 mfc_mcastgrp;            /* Group the entry belongs to     */
  5400. +    __u32 mfc_origin;            /* Source of packet         */
  5401. +    vifi_t mfc_parent;            /* Source interface        */
  5402. +    struct timer_list mfc_timer;        /* Expiry timer            */
  5403. +    int mfc_flags;                /* Flags on line        */
  5404. +    struct sk_buff_head mfc_unresolved;    /* Unresolved buffers        */
  5405. +    int mfc_queuelen;            /* Unresolved buffer counter    */
  5406. +    unsigned char mfc_ttls[MAXVIFS];    /* TTL thresholds        */
  5407. +};
  5408. +
  5409. +#define MFC_QUEUED        1
  5410. +#define MFC_RESOLVED        2
  5411. +
  5412. +
  5413. +#define MFC_LINES        64
  5414. +
  5415. +#ifdef __BIG_ENDIAN
  5416. +#define MFC_HASH(a,b)    ((((a)>>24)^((b)>>26))&(MFC_LINES-1))
  5417. +#else
  5418. +#define MFC_HASH(a,b)    (((a)^((b)>>2))&(MFC_LINES-1))
  5419. +#endif        
  5420. +
  5421.  #endif
  5422. +
  5423. +/*
  5424. + *    Pseudo messages used by mrouted
  5425. + */
  5426. +
  5427. +#define IGMPMSG_NOCACHE        1        /* Kernel cache fill request to mrouted */
  5428. +#define IGMPMSG_WRONGVIF    2        /* For PIM assert processing (unused) */
  5429. +
  5430.  #endif
  5431. diff -u --recursive --new-file v1.3.30/linux/include/linux/proc_fs.h linux/include/linux/proc_fs.h
  5432. --- v1.3.30/linux/include/linux/proc_fs.h    Mon Sep 25 12:26:23 1995
  5433. +++ linux/include/linux/proc_fs.h    Wed Oct  4 08:21:33 1995
  5434. @@ -67,6 +67,8 @@
  5435.      PROC_NET_SNMP,
  5436.      PROC_NET_RARP,
  5437.      PROC_NET_IGMP,
  5438. +    PROC_NET_IPMR_VIF,
  5439. +    PROC_NET_IPMR_MFC,
  5440.      PROC_NET_IPFWFWD,
  5441.      PROC_NET_IPFWBLK,
  5442.      PROC_NET_IPACCT,
  5443. diff -u --recursive --new-file v1.3.30/linux/include/linux/sched.h linux/include/linux/sched.h
  5444. --- v1.3.30/linux/include/linux/sched.h    Wed Sep 27 16:00:00 1995
  5445. +++ linux/include/linux/sched.h    Wed Oct  4 08:20:52 1995
  5446. @@ -1,6 +1,8 @@
  5447.  #ifndef _LINUX_SCHED_H
  5448.  #define _LINUX_SCHED_H
  5449.  
  5450. +#include <linux/config.h>
  5451. +
  5452.  /*
  5453.   * define DEBUG if you want the wait-queues to have some extra
  5454.   * debugging code. It's not normally used, but might catch some
  5455. @@ -21,6 +23,8 @@
  5456.  #include <asm/system.h>
  5457.  #include <asm/page.h>
  5458.  
  5459. +#include <linux/smp.h>
  5460. +
  5461.  /*
  5462.   * cloning flags:
  5463.   */
  5464. @@ -215,6 +219,10 @@
  5465.      struct mm_struct *mm;
  5466.  /* signal handlers */
  5467.      struct signal_struct *sig;
  5468. +#ifdef CONFIG_SMP
  5469. +    int processor;
  5470. +    int lock_depth;        /* Lock depth. We can context swithc in and out of holding a syscall kernel lock... */    
  5471. +#endif    
  5472.  };
  5473.  
  5474.  /*
  5475. @@ -228,6 +236,8 @@
  5476.  #define PF_STARTING    0x00000100    /* being created */
  5477.  #define PF_EXITING    0x00000200    /* getting shut down */
  5478.  
  5479. +#define PF_USEDFPU    0x00100000    /* Process used the FPU this quantum (SMP only) */
  5480. +
  5481.  /*
  5482.   * Limit the stack by to some sane default: root can always
  5483.   * increase this limit if needed..  8MB seems reasonable.
  5484. @@ -275,7 +285,12 @@
  5485.  extern struct task_struct init_task;
  5486.  extern struct task_struct *task[NR_TASKS];
  5487.  extern struct task_struct *last_task_used_math;
  5488. -extern struct task_struct *current;
  5489. +extern struct task_struct *current_set[NR_CPUS];
  5490. +/*
  5491. + *    On a single processor system this comes out as current_set[0] when cpp
  5492. + *    has finished with it, which gcc will optimise away.
  5493. + */
  5494. +#define current (current_set[smp_processor_id()])    /* Current on this processor */
  5495.  extern unsigned long volatile jiffies;
  5496.  extern unsigned long itimer_ticks;
  5497.  extern unsigned long itimer_next;
  5498. diff -u --recursive --new-file v1.3.30/linux/include/linux/smp.h linux/include/linux/smp.h
  5499. --- v1.3.30/linux/include/linux/smp.h    Wed Sep 13 12:45:33 1995
  5500. +++ linux/include/linux/smp.h    Mon Oct  2 14:25:11 1995
  5501. @@ -6,6 +6,7 @@
  5502.   *        Alan Cox. <alan@cymru.net>
  5503.   */
  5504.  
  5505. +#ifdef CONFIG_SMP
  5506.  #include <asm/smp.h>
  5507.  
  5508.   
  5509. @@ -28,4 +29,15 @@
  5510.  #define MSG_STOP_CPU        0x0002        /* Sent to shut down slave CPU's when rebooting */
  5511.  #define MSG_RESCHEDULE        0x0003        /* Reschedule request from master CPU */
  5512.  
  5513. +#else
  5514. +
  5515. +/*
  5516. + *    These macros fold the SMP functionality into a single CPU system
  5517. + */
  5518. + 
  5519. +#define smp_num_cpus            1
  5520. +#define smp_processor_id()        0
  5521. +#define smp_message_pass(t,m,d,w)    
  5522. +#define smp_threads_ready        1
  5523. +#endif
  5524.  #endif
  5525. diff -u --recursive --new-file v1.3.30/linux/include/linux/tasks.h linux/include/linux/tasks.h
  5526. --- v1.3.30/linux/include/linux/tasks.h    Wed Sep 13 12:45:33 1995
  5527. +++ linux/include/linux/tasks.h    Mon Oct  2 14:25:11 1995
  5528. @@ -5,7 +5,11 @@
  5529.   * This is the maximum nr of tasks - change it if you need to
  5530.   */
  5531.   
  5532. -#define NR_PROCS    32        /* Max processors that can be running */
  5533. +#ifdef CONFIG_SMP
  5534. +#define NR_CPUS    32        /* Max processors that can be running in SMP */
  5535. +#else
  5536. +#define NR_CPUS 1
  5537. +#endif
  5538.  
  5539.  #define NR_TASKS    512
  5540.  
  5541. diff -u --recursive --new-file v1.3.30/linux/include/net/netlink.h linux/include/net/netlink.h
  5542. --- v1.3.30/linux/include/net/netlink.h    Thu Jan  1 02:00:00 1970
  5543. +++ linux/include/net/netlink.h    Mon Oct  2 14:25:11 1995
  5544. @@ -0,0 +1,13 @@
  5545. +#define NET_MAJOR 18        /* Major 18 is reserved for networking         */
  5546. +#define MAX_LINKS 3        /* 18,0 for route updates, 18,1 for SKIP     */
  5547. +#define MAX_QBYTES 32768    /* Maximum bytes in the queue             */
  5548. +
  5549. +extern int netlink_attach(int unit, int (*function)(struct sk_buff *skb));
  5550. +extern void netlink_detach(int unit);
  5551. +extern int netlink_post(int unit, struct sk_buff *skb);
  5552. +extern void init_netlink(void);
  5553. +
  5554. +#define NETLINK_ROUTE        0    /* Routing/device hook                */
  5555. +#define NETLINK_SKIP        1    /* Reserved for ENskip              */
  5556. +#define NETLINK_USERSOCK    2    /* Reserved for user mode socket protocols     */
  5557. +
  5558. diff -u --recursive --new-file v1.3.30/linux/init/main.c linux/init/main.c
  5559. --- v1.3.30/linux/init/main.c    Wed Sep 27 16:00:00 1995
  5560. +++ linux/init/main.c    Mon Oct  2 14:25:11 1995
  5561. @@ -293,11 +293,14 @@
  5562.     better than 1% */
  5563.  #define LPS_PREC 8
  5564.  
  5565. -static void calibrate_delay(void)
  5566. +void calibrate_delay(void)
  5567.  {
  5568.      int ticks;
  5569.      int loopbit;
  5570.      int lps_precision = LPS_PREC;
  5571. +#ifdef CONFIG_SMP
  5572. +    loops_per_sec = (1<<12);
  5573. +#endif        
  5574.  
  5575.      printk("Calibrating delay loop.. ");
  5576.      while (loops_per_sec <<= 1) {
  5577. @@ -418,9 +421,76 @@
  5578.  
  5579.  static char init_stack[PAGE_SIZE];
  5580.  
  5581. +#ifdef CONFIG_SMP
  5582. +/*
  5583. + *    Activate a secondary processor.
  5584. + */
  5585. + 
  5586. +asmlinkage void start_secondary(void)
  5587. +{
  5588. +    trap_init();
  5589. +    init_IRQ();
  5590. +    smp_callin();
  5591. +    for(;;)
  5592. +        idle();
  5593. +}
  5594. +
  5595. +/*
  5596. + *    Called by CPU#0 to activate the rest.
  5597. + */
  5598. + 
  5599. +static void smp_init(void)
  5600. +{
  5601. +    int i=0;
  5602. +    smp_boot_cpus();
  5603. +    
  5604. +    /*
  5605. +     *    Create the slave init tasks. At this point
  5606. +     *    fork will create them all ask task 0
  5607. +     */
  5608. +
  5609. +    for(i=1;i<smp_num_cpus;i++)
  5610. +    {
  5611. +        fork();
  5612. +        /* We are forking multiple process 0's. This makes it harder
  5613. +           to tell them apart than we would like ;) */
  5614. +        if(current!=task[0])
  5615. +        {
  5616. +            for(;;)
  5617. +                idle();
  5618. +        }
  5619. +        /*
  5620. +         *    Assume linear processor numbering
  5621. +         */
  5622. +        current_set[i]=task[i];
  5623. +        current_set[i]->processor=i;
  5624. +    }
  5625. +    smp_threads_ready=1;
  5626. +    smp_commence();
  5627. +}        
  5628. +    
  5629. +#endif
  5630. +
  5631. +/*
  5632. + *    Activate the first processor.
  5633. + */
  5634. + 
  5635.  asmlinkage void start_kernel(void)
  5636.  {
  5637.      char * command_line;
  5638. +
  5639. +/*
  5640. + *    This little check will move.
  5641. + */
  5642. +
  5643. +#ifdef CONFIG_SMP    
  5644. +    static int first_cpu=1;
  5645. +    
  5646. +    if(!first_cpu)
  5647. +        start_secondary();
  5648. +    first_cpu=0;
  5649. +    
  5650. +#endif    
  5651.  /*
  5652.   * Interrupts are still disabled. Do necessary setups, then
  5653.   * enable them
  5654. @@ -477,7 +547,9 @@
  5655.      check_bugs();
  5656.  
  5657.      printk(linux_banner);
  5658. -
  5659. +#ifdef CONFIG_SMP    
  5660. +    smp_init();
  5661. +#endif
  5662.      /* we count on the clone going ok */
  5663.      if (!clone(CLONE_VM, init_stack+sizeof(init_stack)))
  5664.          init();
  5665. diff -u --recursive --new-file v1.3.30/linux/kernel/exit.c linux/kernel/exit.c
  5666. --- v1.3.30/linux/kernel/exit.c    Mon Sep 18 14:54:10 1995
  5667. +++ linux/kernel/exit.c    Mon Oct  2 14:25:11 1995
  5668. @@ -6,6 +6,7 @@
  5669.  
  5670.  #undef DEBUG_PROC_TREE
  5671.  
  5672. +#include <linux/config.h>
  5673.  #include <linux/wait.h>
  5674.  #include <linux/errno.h>
  5675.  #include <linux/signal.h>
  5676. @@ -72,7 +73,7 @@
  5677.  
  5678.  void notify_parent(struct task_struct * tsk)
  5679.  {
  5680. -    if (tsk->p_pptr == task[1])
  5681. +    if (tsk->p_pptr == task[smp_num_cpus])        /* Init */
  5682.          tsk->exit_signal = SIGCHLD;
  5683.      send_sig(tsk->exit_signal, tsk->p_pptr, 1);
  5684.      wake_up_interruptible(&tsk->p_pptr->wait_chldexit);
  5685. @@ -349,8 +350,8 @@
  5686.  
  5687.      for_each_task(p) {
  5688.          if (p->p_opptr == father)
  5689. -            if (task[1])
  5690. -                p->p_opptr = task[1];
  5691. +            if (task[smp_num_cpus])    /* init */
  5692. +                p->p_opptr = task[smp_num_cpus];
  5693.              else
  5694.                  p->p_opptr = task[0];
  5695.      }
  5696. @@ -457,8 +458,8 @@
  5697.          current->p_cptr = p->p_osptr;
  5698.          p->p_ysptr = NULL;
  5699.          p->flags &= ~(PF_PTRACED|PF_TRACESYS);
  5700. -        if (task[1] && task[1] != current)
  5701. -            p->p_pptr = task[1];
  5702. +        if (task[smp_num_cpus] && task[smp_num_cpus] != current) /* init */
  5703. +            p->p_pptr = task[smp_num_cpus];
  5704.          else
  5705.              p->p_pptr = task[0];
  5706.          p->p_osptr = p->p_pptr->p_cptr;
  5707. diff -u --recursive --new-file v1.3.30/linux/kernel/fork.c linux/kernel/fork.c
  5708. --- v1.3.30/linux/kernel/fork.c    Wed Sep 27 16:00:00 1995
  5709. +++ linux/kernel/fork.c    Tue Oct  3 12:47:42 1995
  5710. @@ -11,6 +11,7 @@
  5711.   * management can be a bitch. See 'mm/mm.c': 'copy_page_tables()'
  5712.   */
  5713.  
  5714. +#include <linux/config.h>
  5715.  #include <linux/errno.h>
  5716.  #include <linux/sched.h>
  5717.  #include <linux/kernel.h>
  5718. @@ -20,6 +21,7 @@
  5719.  #include <linux/ptrace.h>
  5720.  #include <linux/malloc.h>
  5721.  #include <linux/ldt.h>
  5722. +#include <linux/smp.h>
  5723.  
  5724.  #include <asm/segment.h>
  5725.  #include <asm/system.h>
  5726. @@ -40,15 +42,17 @@
  5727.              return -EAGAIN;
  5728.      }
  5729.  repeat:
  5730. -    if ((++last_pid) & 0xffff8000)
  5731. -        last_pid=1;
  5732. +    if(smp_threads_ready) {
  5733. +        if ((++last_pid) & 0xffff8000)
  5734. +            last_pid=1;
  5735. +    }
  5736.      this_user_tasks = 0;
  5737.      for_each_task (p) {
  5738.          if (p->uid == current->uid)
  5739.              this_user_tasks++;
  5740. -        if (p->pid == last_pid ||
  5741. +        if (smp_threads_ready && (p->pid == last_pid ||
  5742.              p->pgrp == last_pid ||
  5743. -            p->session == last_pid)
  5744. +            p->session == last_pid))
  5745.              goto repeat;
  5746.      }
  5747.      if (this_user_tasks > current->rlim[RLIMIT_NPROC].rlim_cur)
  5748. @@ -224,6 +228,10 @@
  5749.      p->tty_old_pgrp = 0;
  5750.      p->utime = p->stime = 0;
  5751.      p->cutime = p->cstime = 0;
  5752. +#ifdef CONFIG_SMP
  5753. +    p->processor = NO_PROC_ID;
  5754. +    p->lock_depth = 1;
  5755. +#endif
  5756.      p->start_time = jiffies;
  5757.      task[nr] = p;
  5758.      SET_LINKS(p);
  5759. diff -u --recursive --new-file v1.3.30/linux/kernel/ksyms.c linux/kernel/ksyms.c
  5760. --- v1.3.30/linux/kernel/ksyms.c    Wed Sep 27 16:00:00 1995
  5761. +++ linux/kernel/ksyms.c    Mon Oct  2 14:25:12 1995
  5762. @@ -273,7 +273,10 @@
  5763.      X(sleep_on),
  5764.      X(interruptible_sleep_on),
  5765.      X(schedule),
  5766. -    X(current),
  5767. +    X(current_set),
  5768. +#if defined(__i386__) && defined(CONFIG_SMP)
  5769. +    X(apic_reg),        /* Needed internally for the I386 inlines */
  5770. +#endif    
  5771.      X(jiffies),
  5772.      X(xtime),
  5773.      X(loops_per_sec),
  5774. diff -u --recursive --new-file v1.3.30/linux/kernel/sched.c linux/kernel/sched.c
  5775. --- v1.3.30/linux/kernel/sched.c    Wed Sep 27 16:00:00 1995
  5776. +++ linux/kernel/sched.c    Tue Oct  3 12:48:39 1995
  5777. @@ -26,6 +26,7 @@
  5778.  #include <linux/tqueue.h>
  5779.  #include <linux/resource.h>
  5780.  #include <linux/mm.h>
  5781. +#include <linux/smp.h>
  5782.  
  5783.  #include <asm/system.h>
  5784.  #include <asm/io.h>
  5785. @@ -88,7 +89,7 @@
  5786.  
  5787.  unsigned long volatile jiffies=0;
  5788.  
  5789. -struct task_struct *current = &init_task;
  5790. +struct task_struct *current_set[NR_CPUS];
  5791.  struct task_struct *last_task_used_math = NULL;
  5792.  
  5793.  struct task_struct * task[NR_TASKS] = {&init_task, };
  5794. @@ -181,6 +182,12 @@
  5795.      struct task_struct * p;
  5796.      struct task_struct * next;
  5797.      unsigned long timeout = 0;
  5798. +    
  5799. +#ifdef CONFIG_SMP_DEBUG
  5800. +    int proc=smp_processor_id();
  5801. +    if(active_kernel_processor!=proc)
  5802. +        panic("active kernel processor set wrongly! %d not %d\n", active_kernel_processor,proc);
  5803. +#endif
  5804.  
  5805.  /* check alarm, wake up any interruptible tasks that have got a signal */
  5806.  
  5807. @@ -210,6 +217,13 @@
  5808.      }
  5809.      p = init_task.next_run;
  5810.      sti();
  5811. +    
  5812. +#ifdef CONFIG_SMP
  5813. +    /*
  5814. +     *    This is safe as we do not permit re-entry of schedule()
  5815. +     */
  5816. +    current->processor = NO_PROC_ID;    
  5817. +#endif    
  5818.  
  5819.  /*
  5820.   * Note! there may appear new tasks on the run-queue during this, as
  5821. @@ -220,6 +234,13 @@
  5822.      c = -1000;
  5823.      next = &init_task;
  5824.      while (p != &init_task) {
  5825. +#ifdef CONFIG_SMP    
  5826. +        /* We are not permitted to run a task someone else is running */
  5827. +        if (p->processor != NO_PROC_ID) {
  5828. +            p = p->next_run;
  5829. +            continue;
  5830. +        }
  5831. +#endif        
  5832.          if (p->counter > c)
  5833.              c = p->counter, next = p;
  5834.          p = p->next_run;
  5835. @@ -230,6 +251,20 @@
  5836.          for_each_task(p)
  5837.              p->counter = (p->counter >> 1) + p->priority;
  5838.      }
  5839. +#ifdef CONFIG_SMP    
  5840. +    
  5841. +    /*
  5842. +     *    Context switching between two idle threads is pointless.
  5843. +     */
  5844. +    if(!current->pid && !next->pid)
  5845. +        next=current;
  5846. +    /*
  5847. +     *    Allocate process to CPU
  5848. +     */
  5849. +     
  5850. +     next->processor = smp_processor_id();
  5851. +     
  5852. +#endif     
  5853.      if (current != next) {
  5854.          struct timer_list timer;
  5855.  
  5856. @@ -446,6 +481,9 @@
  5857.                 (*p)->state == TASK_UNINTERRUPTIBLE ||
  5858.                 (*p)->state == TASK_SWAPPING))
  5859.              nr += FIXED_1;
  5860. +#ifdef CONFIG_SMP
  5861. +    nr-=(smp_num_cpus-1)*FIXED_1;
  5862. +#endif            
  5863.      return nr;
  5864.  }
  5865.  
  5866. @@ -651,8 +689,7 @@
  5867.      } else
  5868.          xtime.tv_usec += tick + time_adjust_step;
  5869.  
  5870. -    if (time_adjust)
  5871. -    {
  5872. +    if (time_adjust) {
  5873.          /* We are doing an adjtime thing. 
  5874.           *
  5875.           * Modify the value of the tick for next time.
  5876. @@ -685,7 +722,7 @@
  5877.      calc_load();
  5878.      if (user_mode(regs)) {
  5879.          current->utime++;
  5880. -        if (current != task[0]) {
  5881. +        if (current->pid) {
  5882.              if (current->priority < 15)
  5883.                  kstat.cpu_nice++;
  5884.              else
  5885. @@ -698,9 +735,9 @@
  5886.          }
  5887.      } else {
  5888.          current->stime++;
  5889. -        if(current != task[0])
  5890. +        if(current->pid)
  5891.              kstat.cpu_system++;
  5892. -        if (prof_buffer && current != task[0]) {
  5893. +        if (prof_buffer && current->pid) {
  5894.              extern int _stext;
  5895.              unsigned long ip = instruction_pointer(regs);
  5896.              ip -= (unsigned long) &_stext;
  5897. @@ -727,7 +764,7 @@
  5898.              send_sig(SIGXCPU, current, 1);
  5899.      }
  5900.  
  5901. -    if (current != task[0] && 0 > --current->counter) {
  5902. +    if (current->pid && 0 > --current->counter) {
  5903.          current->counter = 0;
  5904.          need_resched = 1;
  5905.      }
  5906. @@ -875,6 +912,15 @@
  5907.  
  5908.  void sched_init(void)
  5909.  {
  5910. +    /*
  5911. +     *    We have to do a little magic to get the first
  5912. +     *    process right in SMP mode.
  5913. +     */
  5914. +    int cpu=smp_processor_id();
  5915. +    current_set[cpu]=&init_task;
  5916. +#ifdef CONFIG_SMP    
  5917. +    init_task.processor=cpu;
  5918. +#endif
  5919.      bh_base[TIMER_BH].routine = timer_bh;
  5920.      bh_base[TQUEUE_BH].routine = tqueue_bh;
  5921.      bh_base[IMMEDIATE_BH].routine = immediate_bh;
  5922. diff -u --recursive --new-file v1.3.30/linux/kernel/sys.c linux/kernel/sys.c
  5923. --- v1.3.30/linux/kernel/sys.c    Mon Sep 18 14:54:10 1995
  5924. +++ linux/kernel/sys.c    Mon Oct  2 14:25:12 1995
  5925. @@ -173,7 +173,7 @@
  5926.      if (C_A_D)
  5927.          hard_reset_now();
  5928.      else
  5929. -        send_sig(SIGINT,task[1],1);
  5930. +        kill_proc(1, SIGINT, 1);
  5931.  }
  5932.      
  5933.  
  5934. diff -u --recursive --new-file v1.3.30/linux/kernel/time.c linux/kernel/time.c
  5935. --- v1.3.30/linux/kernel/time.c    Wed Sep 27 16:00:00 1995
  5936. +++ linux/kernel/time.c    Mon Oct  2 08:21:27 1995
  5937. @@ -26,6 +26,8 @@
  5938.  #include <linux/mm.h>
  5939.  #include <linux/timex.h>
  5940.  
  5941. +#include <asm/segment.h>
  5942. +
  5943.  /* 
  5944.   * The timezone where the local system is located.  Used as a default by some
  5945.   * programs who obtain this value by using gettimeofday.
  5946. diff -u --recursive --new-file v1.3.30/linux/net/Changes linux/net/Changes
  5947. --- v1.3.30/linux/net/Changes    Wed Sep 27 16:00:01 1995
  5948. +++ linux/net/Changes    Wed Oct  4 08:15:11 1995
  5949. @@ -230,6 +230,19 @@
  5950.  o    TCP cache zap bugs hopefully fixed        [IN]
  5951.  o    Length checks in udp/raw sending [Craig Metz]    [IN]
  5952.  
  5953. +-------->>>>> 1.3.31 <<<<<<-------
  5954. +
  5955. +o    IP_OPTIONS [A.N.Kuznetsov]            [IN]
  5956. +o    TCP cache zap more fixes            [IN]
  5957. +o    Most of the IP multicast routing cache added    [IN]
  5958. +o    Kernel/user communication module (not used yet) [IN]
  5959. +
  5960. +-------->>>>> 1.3.31 <<<<<<-------
  5961. +
  5962. +o    IFF_ALLMULTI support for 3c501,3c509,8390 and
  5963. +    tulip(SMC etherpower) boards            [IN]
  5964. +
  5965. +
  5966.  ---------- Things I thought Linus had for a while and not merged ----------------
  5967.  
  5968.  o    Paul Gortmakers 8390 Copy and checksum        [Pending]
  5969. @@ -240,19 +253,15 @@
  5970.  ---------- Things pending for me to merge --------------
  5971.  
  5972.  o    IPFW support for TOS changing (Al Longyear)
  5973. -o    /dev/skip /dev/ipah etc - Kernel/Usermode communications module (me)
  5974.  o    AF_UNIX garbage collect code
  5975.  o    Faster closedown option for heavy use sites (me)
  5976.  o    Tom May's insw_and_checksum()            
  5977.  
  5978. -
  5979. -
  5980. ---------------- Tbings That Need Doing Before 1.4 ------------------
  5981. +--------------- Things That Need Doing Before 1.4 ------------------
  5982.  
  5983.  o    inet_error for other layers
  5984.  o    Finish merging the bridge code
  5985.  o    SIOCSLEEPRT patch
  5986. -o    Options support in ip_build_xmit        [PENDING]
  5987.  o    Fast checksum/copy on outgoing TCP
  5988.  o    Fast dev_grab_next() transmit reload function
  5989.      and dev_push_failed() ??
  5990. @@ -261,10 +270,8 @@
  5991.  o    Forwarding queue control (+ fairness algorithms ??)
  5992.  o    IP forward flow control.
  5993.  o    Infinite PPP devices.
  5994. -o    AX.25 set protocol type
  5995.  o    Clean up RAW AX.25 sockets.
  5996.  o    Finish 802.2 Class I code to be compliant to the oddities of 802.2
  5997. -o    Full variable length AX.25 support        [JSN doing]
  5998.  o    Tidy BPQ support to use a bpqip tunnel device
  5999.  o    Strange eth0-eth3 bug 
  6000.  o    Finish IPIP bug fixes                [Done hopefully]
  6001. @@ -276,9 +283,7 @@
  6002.  
  6003.  0.2
  6004.  ---
  6005. -o    New icmp.c.                    [IN]
  6006.  o    Better TCP window handling [Pedro Roque]
  6007. -o    IP option support.
  6008.  o    Add tty support to sonix driver.
  6009.  o    PPP for Sonix ISDN.
  6010.  o    Loadable firewall extensions.
  6011. diff -u --recursive --new-file v1.3.30/linux/net/Makefile linux/net/Makefile
  6012. --- v1.3.30/linux/net/Makefile    Fri Aug 18 08:44:58 1995
  6013. +++ linux/net/Makefile    Mon Oct  2 14:25:12 1995
  6014. @@ -11,6 +11,6 @@
  6015.  ALL_SUB_DIRS := 802 ax25 core ethernet ipv4 ipx unix appletalk netrom
  6016.  SUB_DIRS     := $(ALL_SUB_DIRS)
  6017.  L_TARGET     := network.a
  6018. -L_OBJS         := socket.o protocols.o $(join $(SUB_DIRS),$(SUB_DIRS:%=/%.o))
  6019. +L_OBJS         := socket.o protocols.o netlink.o $(join $(SUB_DIRS),$(SUB_DIRS:%=/%.o))
  6020.  
  6021.  include $(TOPDIR)/Rules.make
  6022. diff -u --recursive --new-file v1.3.30/linux/net/ipv4/Makefile linux/net/ipv4/Makefile
  6023. --- v1.3.30/linux/net/ipv4/Makefile    Wed Sep 27 16:00:01 1995
  6024. +++ linux/net/ipv4/Makefile    Wed Oct  4 08:22:36 1995
  6025. @@ -17,8 +17,10 @@
  6026.  
  6027.  ifeq ($(CONFIG_INET_RARP),y)
  6028.  IPV4_OBJS += rarp.o
  6029. -elifeq ($(CONFIG_INET_RARP),m)
  6030. -M_OBJS += rarp.o
  6031. +else
  6032. +  ifeq ($(CONFIG_INET_RARP),m)
  6033. +  M_OBJS += rarp.o
  6034. +  endif
  6035.  endif
  6036.  
  6037.  ifeq ($(CONFIG_NET_IPIP),y)
  6038. diff -u --recursive --new-file v1.3.30/linux/net/ipv4/icmp.c linux/net/ipv4/icmp.c
  6039. --- v1.3.30/linux/net/ipv4/icmp.c    Wed Sep 27 16:00:01 1995
  6040. +++ linux/net/ipv4/icmp.c    Tue Oct  3 11:40:56 1995
  6041. @@ -196,31 +196,29 @@
  6042.   
  6043.  static void icmp_glue_bits(const void *p, __u32 saddr, char *to, unsigned int offset, unsigned int fraglen)
  6044.  {
  6045. -    struct icmp_bxm *icmp_param=(struct icmp_bxm *)p;
  6046. +    struct icmp_bxm *icmp_param = (struct icmp_bxm *)p;
  6047.      struct icmphdr *icmph;
  6048. -    if(offset)
  6049. +    unsigned long csum;
  6050. +
  6051. +    if (offset) {
  6052.          icmp_param->csum=csum_partial_copy(icmp_param->data_ptr+offset-sizeof(struct icmphdr), 
  6053.                  to, fraglen,icmp_param->csum);
  6054. -    else
  6055. -    {
  6056. -#ifdef CSUM_FOLD_WORKS
  6057. -        /*
  6058. -         *    Need this fixed to make multifragment ICMP's work again.
  6059. -         */
  6060. -        icmp_param->csum=csum_partial_copy((void *)&icmp_param->icmph, to, sizeof(struct icmphdr),
  6061. -            icmp_param->csum);
  6062. -        icmp_param->csum=csum_partial_copy(icmp_param->data_ptr, to+sizeof(struct icmphdr),
  6063. -                fraglen-sizeof(struct icmphdr), icmp_param->csum);
  6064. -        icmph=(struct icmphdr *)to;
  6065. -        icmph->checksum = csum_fold(icmp_param->csum);
  6066. -#else
  6067. -        memcpy(to, &icmp_param->icmph, sizeof(struct icmphdr));
  6068. -        memcpy(to+sizeof(struct icmphdr), icmp_param->data_ptr, fraglen-sizeof(struct icmphdr));
  6069. -        icmph=(struct icmphdr *)to;
  6070. -        icmph->checksum=ip_compute_csum(to, fraglen);
  6071. -#endif
  6072. -                
  6073. +        return;
  6074.      }
  6075. +
  6076. +    /*
  6077. +     *    First fragment includes header. Note that we've done
  6078. +     *    the other fragments first, so that we get the checksum
  6079. +     *    for the whole packet here.
  6080. +     */
  6081. +    csum = csum_partial_copy((void *)&icmp_param->icmph,
  6082. +        to, sizeof(struct icmphdr), 
  6083. +        icmp_param->csum);
  6084. +    csum = csum_partial_copy(icmp_param->data_ptr,
  6085. +        to+sizeof(struct icmphdr),
  6086. +        fraglen-sizeof(struct icmphdr), csum);
  6087. +    icmph=(struct icmphdr *)to;
  6088. +    icmph->checksum = csum_fold(csum);
  6089.  }
  6090.   
  6091.  /*
  6092. @@ -231,6 +229,7 @@
  6093.  {
  6094.      struct sock *sk=icmp_socket.data;
  6095.      icmp_param->icmph.checksum=0;
  6096. +    icmp_param->csum=0;
  6097.      icmp_out_count(icmp_param->icmph.type);
  6098.      ip_build_xmit(sk, icmp_glue_bits, icmp_param, 
  6099.          icmp_param->data_len+sizeof(struct icmphdr),
  6100. @@ -698,10 +697,12 @@
  6101.  void icmp_init(struct proto_ops *ops)
  6102.  {
  6103.      struct sock *sk;
  6104. +    int err;
  6105.      icmp_socket.type=SOCK_RAW;
  6106.      icmp_socket.ops=ops;
  6107. -    if(ops->create(&icmp_socket, IPPROTO_ICMP)<0)
  6108. -        panic("Failed to create the ICMP control socket.\n");
  6109. +    if((err=ops->create(&icmp_socket, IPPROTO_ICMP))<0)
  6110. +        panic("Failed to create the ICMP control socket (%d,%d,%p,%p).\n", -err,
  6111. +            current->euid, current, &init_task);
  6112.      sk=icmp_socket.data;
  6113.      sk->allocation=GFP_ATOMIC;
  6114.      sk->num = 256;            /* Don't receive any data */
  6115. diff -u --recursive --new-file v1.3.30/linux/net/ipv4/ip.c linux/net/ipv4/ip.c
  6116. --- v1.3.30/linux/net/ipv4/ip.c    Wed Sep 27 16:00:02 1995
  6117. +++ linux/net/ipv4/ip.c    Wed Oct  4 08:15:11 1995
  6118. @@ -93,6 +93,8 @@
  6119.   *    Werner Almesberger    :    Zero fragment bug
  6120.   *        Alan Cox    :    RAW IP frame length bug
  6121.   *        Alan Cox    :    Outgoing firewall on build_xmit
  6122. + *        A.N.Kuznetsov    :    IP_OPTIONS support throughout the kernel
  6123. + *        Alan Cox    :    Multicast routing hooks
  6124.   *
  6125.   *  
  6126.   *
  6127. @@ -1466,6 +1468,50 @@
  6128.  
  6129.  
  6130.  #ifdef CONFIG_IP_FORWARD
  6131. +#ifdef CONFIG_IP_MROUTE
  6132. +
  6133. +/*
  6134. + *     Encapsulate a packet by attaching a valid IPIP header to it.
  6135. + *    This avoids tunnel drivers and other mess and gives us the speed so
  6136. + *    important for multicast video.
  6137. + */
  6138. + 
  6139. +static void ip_encap(struct sk_buff *skb, int len, struct device *out, __u32 daddr)
  6140. +{
  6141. +    /*
  6142. +     *    There is space for the IPIP header and MAC left.
  6143. +     *
  6144. +     *    Firstly push down and install the IPIP header.
  6145. +     */
  6146. +    struct iphdr *iph=(struct iphdr *)skb_push(skb,sizeof(struct iphdr));
  6147. +    if(len>65515)
  6148. +        len=65515;
  6149. +    iph->version    =     4;
  6150. +    iph->tos    =    skb->ip_hdr->tos;
  6151. +    iph->ttl    =    skb->ip_hdr->ttl;
  6152. +    iph->frag_off    =    0;
  6153. +    iph->daddr    =    daddr;
  6154. +    iph->saddr    =    out->pa_addr;
  6155. +    iph->protocol    =    IPPROTO_IPIP;
  6156. +    iph->ihl    =    5;
  6157. +    iph->tot_len    =    htons(skb->len);
  6158. +    iph->id        =    htons(ip_id_count++);
  6159. +    ip_send_check(iph);
  6160. +
  6161. +    skb->dev = out;
  6162. +    skb->arp = 1;
  6163. +    skb->raddr=daddr;
  6164. +    /*
  6165. +     *    Now add the physical header (driver will push it down).
  6166. +     */
  6167. +    if (out->hard_header && out->hard_header(skb, out, ETH_P_IP, NULL, NULL, len)<0)
  6168. +            skb->arp=0;
  6169. +    /*
  6170. +     *    Read to queue for transmission.
  6171. +     */
  6172. +}
  6173. +
  6174. +#endif
  6175.  
  6176.  /*
  6177.   *    Forward an IP datagram to its next destination.
  6178. @@ -1485,7 +1531,8 @@
  6179.      int fw_res = 0;        /* Forwarding result */    
  6180.  #ifdef CONFIG_IP_MASQUERADE    
  6181.      struct sk_buff *skb_in = skb;    /* So we can remember if the masquerader did some swaps */
  6182. -#endif    
  6183. +#endif
  6184. +    int encap = 0;        /* Encap length */
  6185.      
  6186.      /* 
  6187.       *    See if we are allowed to forward this.
  6188. @@ -1542,83 +1589,86 @@
  6189.          return -1;
  6190.      }
  6191.  
  6192. -    /*
  6193. -     * OK, the packet is still valid.  Fetch its destination address,
  6194. -     * and give it to the IP sender for further processing.
  6195. -     */
  6196. -
  6197. -    rt = ip_rt_route(target_addr, NULL, NULL);
  6198. -    if (rt == NULL)
  6199. -    {
  6200. -        /*
  6201. -         *    Tell the sender its packet cannot be delivered. Again
  6202. -         *    ICMP is screened later.
  6203. -         */
  6204. -        icmp_send(skb, ICMP_DEST_UNREACH, ICMP_NET_UNREACH, 0, dev);
  6205. -        return -1;
  6206. -    }
  6207. -
  6208. -
  6209. -    /*
  6210. -     * Gosh.  Not only is the packet valid; we even know how to
  6211. -     * forward it onto its final destination.  Can we say this
  6212. -     * is being plain lucky?
  6213. -     * If the router told us that there is no GW, use the dest.
  6214. -     * IP address itself- we seem to be connected directly...
  6215. -     */
  6216. -
  6217. -    raddr = rt->rt_gateway;
  6218. -
  6219. -    if (raddr != 0)
  6220. +#ifdef CONFIG_IP_MROUTE
  6221. +    if(!(is_frag&8))
  6222.      {
  6223. +#endif    
  6224.          /*
  6225. -         *    Strict routing permits no gatewaying
  6226. +         * OK, the packet is still valid.  Fetch its destination address,
  6227. +         * and give it to the IP sender for further processing.
  6228.           */
  6229.  
  6230. -            if (opt->is_strictroute)
  6231. +        rt = ip_rt_route(target_addr, NULL, NULL);
  6232. +        if (rt == NULL)
  6233.          {
  6234. -            icmp_send(skb, ICMP_DEST_UNREACH, ICMP_SR_FAILED, 0, dev);
  6235. +            /*
  6236. +             *    Tell the sender its packet cannot be delivered. Again
  6237. +             *    ICMP is screened later.
  6238. +             */
  6239. +            icmp_send(skb, ICMP_DEST_UNREACH, ICMP_NET_UNREACH, 0, dev);
  6240.              return -1;
  6241.          }
  6242.      
  6243. +    
  6244.          /*
  6245. -         *    There is a gateway so find the correct route for it.
  6246. -         *    Gateways cannot in turn be gatewayed.
  6247. +         * Gosh.  Not only is the packet valid; we even know how to
  6248. +         * forward it onto its final destination.  Can we say this
  6249. +         * is being plain lucky?
  6250. +         * If the router told us that there is no GW, use the dest.
  6251. +         * IP address itself- we seem to be connected directly...
  6252.           */
  6253.  
  6254. -#if 0
  6255. -        rt = ip_rt_route(raddr, NULL, NULL);
  6256. -        if (rt == NULL)
  6257. +        raddr = rt->rt_gateway;
  6258. +    
  6259. +        if (raddr != 0)
  6260.          {
  6261.              /*
  6262. -             *    Tell the sender its packet cannot be delivered...
  6263. +             *    Strict routing permits no gatewaying
  6264. +             */
  6265. +    
  6266. +                if (opt->is_strictroute)
  6267. +            {
  6268. +                icmp_send(skb, ICMP_DEST_UNREACH, ICMP_SR_FAILED, 0, dev);
  6269. +                return -1;
  6270. +            }
  6271. +        
  6272. +            /*
  6273. +             *    There is a gateway so find the correct route for it.
  6274. +             *    Gateways cannot in turn be gatewayed.
  6275.               */
  6276. -            icmp_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_UNREACH, 0, dev);
  6277. -            return -1;
  6278.          }
  6279. -        if (rt->rt_gateway != 0)
  6280. -            raddr = rt->rt_gateway;
  6281. +        else
  6282. +            raddr = target_addr;
  6283. +
  6284. +        /*
  6285. +         *    Having picked a route we can now send the frame out.
  6286. +         */
  6287. +
  6288. +        dev2 = rt->rt_dev;
  6289. +        /*
  6290. +         *    In IP you never have to forward a frame on the interface that it 
  6291. +         *    arrived upon. We now generate an ICMP HOST REDIRECT giving the route
  6292. +         *    we calculated.
  6293. +         */
  6294. +#ifndef CONFIG_IP_NO_ICMP_REDIRECT
  6295. +        if (dev == dev2 && !((iph->saddr^iph->daddr)&dev->pa_mask) &&
  6296. +            (rt->rt_flags&RTF_MODIFIED) && !opt->srr)
  6297. +            icmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST, raddr, dev);
  6298.  #endif
  6299. +#ifdef CONFIG_IP_MROUTE
  6300.      }
  6301.      else
  6302. -        raddr = target_addr;
  6303. -
  6304. -    /*
  6305. -     *    Having picked a route we can now send the frame out.
  6306. -     */
  6307. -
  6308. -    dev2 = rt->rt_dev;
  6309. +    {
  6310. +        /*
  6311. +         *    Multicast route forward. Routing is already done
  6312. +         */
  6313. +        dev2=skb->dev;
  6314. +        raddr=skb->raddr;
  6315. +        if(is_frag&16)        /* VIFF_TUNNEL mode */
  6316. +            encap=20;
  6317. +    }
  6318. +#endif    
  6319.      
  6320. -    /*
  6321. -     *    In IP you never have to forward a frame on the interface that it 
  6322. -     *    arrived upon. We now generate an ICMP HOST REDIRECT giving the route
  6323. -     *    we calculated.
  6324. -     */
  6325. -#ifndef CONFIG_IP_NO_ICMP_REDIRECT
  6326. -    if (dev == dev2 && !((iph->saddr^iph->daddr)&dev->pa_mask) &&
  6327. -        (rt->rt_flags&RTF_MODIFIED) && !opt->srr)
  6328. -        icmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST, raddr, dev);
  6329. -#endif        
  6330.  
  6331.      /*
  6332.       * We now may allocate a new buffer, and copy the datagram into it.
  6333. @@ -1637,17 +1687,21 @@
  6334.  #endif
  6335.          IS_SKB(skb);
  6336.  
  6337. -        if (skb->len > dev2->mtu && (ntohs(iph->frag_off) & IP_DF)) {
  6338. +        if (skb->len+encap > dev2->mtu && (ntohs(iph->frag_off) & IP_DF)) {
  6339.            ip_statistics.IpFragFails++;
  6340.            icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED, dev2->mtu, dev);
  6341.            return -1;
  6342.          }
  6343.  
  6344. +#ifdef CONFIG_IP_MROUTE
  6345. +        if(skb_headroom(skb)-encap<dev2->hard_header_len)
  6346. +        {
  6347. +            skb2 = alloc_skb(dev2->hard_header_len + skb->len + encap + 15, GFP_ATOMIC);
  6348. +#else
  6349.          if(skb_headroom(skb)<dev2->hard_header_len)
  6350.          {
  6351.              skb2 = alloc_skb(dev2->hard_header_len + skb->len + 15, GFP_ATOMIC);
  6352. -            IS_SKB(skb2);
  6353. -        
  6354. +#endif        
  6355.              /*
  6356.               *    This is rare and since IP is tolerant of network failures
  6357.               *    quite harmless.
  6358. @@ -1659,11 +1713,19 @@
  6359.                  return -1;
  6360.              }
  6361.          
  6362. +            IS_SKB(skb2);
  6363.              /*
  6364.               *    Add the physical headers.
  6365.               */
  6366. -
  6367. -             ip_send(skb2,raddr,skb->len,dev2,dev2->pa_addr);
  6368. +#ifdef CONFIG_IP_MROUTE
  6369. +            if(is_frag&16)
  6370. +            {
  6371. +                skb_reserve(skb,(encap+dev->hard_header_len+15)&~15);    /* 16 byte aligned IP headers are good */
  6372. +                ip_encap(skb2,skb->len, dev2, raddr);
  6373. +            }
  6374. +            else
  6375. +#endif            
  6376. +                 ip_send(skb2,raddr,skb->len,dev2,dev2->pa_addr);
  6377.  
  6378.              /*
  6379.               *    We have to copy the bytes over as the new header wouldn't fit
  6380. @@ -1689,13 +1751,22 @@
  6381.  
  6382.              skb2 = skb;        
  6383.              skb2->dev=dev2;
  6384. -            skb->arp=1;
  6385. -            skb->raddr=raddr;
  6386. -            if(dev2->hard_header)
  6387. +#ifdef CONFIG_IP_MROUTE
  6388. +            if(is_frag&16)
  6389. +                ip_encap(skb,skb->len, dev2, raddr);
  6390. +            else
  6391.              {
  6392. -                if(dev2->hard_header(skb, dev2, ETH_P_IP, NULL, NULL, skb->len)<0)
  6393. -                    skb->arp=0;
  6394. -            }
  6395. +#endif
  6396. +                skb->arp=1;
  6397. +                skb->raddr=raddr;
  6398. +                if(dev2->hard_header)
  6399. +                {
  6400. +                    if(dev2->hard_header(skb, dev2, ETH_P_IP, NULL, NULL, skb->len)<0)
  6401. +                        skb->arp=0;
  6402. +                }
  6403. +#ifdef CONFIG_IP_MROUTE
  6404. +            }                
  6405. +#endif            
  6406.              ip_statistics.IpForwDatagrams++;
  6407.          }
  6408.  
  6409. @@ -1825,6 +1896,9 @@
  6410.  #ifdef CONFIG_IP_FIREWALL
  6411.      int err;
  6412.  #endif    
  6413. +#ifdef CONFIG_IP_MROUTE
  6414. +    int mroute_pkt=0;
  6415. +#endif    
  6416.  
  6417.  #ifdef CONFIG_NET_IPV6
  6418.      /* 
  6419. @@ -1944,9 +2018,11 @@
  6420.              for ( srrptr=optptr[2], srrspace = optptr[1];
  6421.                    srrptr <= srrspace;
  6422.                    srrptr += 4
  6423. -                 ) {
  6424. +                 ) 
  6425. +            {
  6426.                  int brd2;
  6427. -                if (srrptr + 3 > srrspace) {
  6428. +                if (srrptr + 3 > srrspace) 
  6429. +                {
  6430.                      icmp_send(skb, ICMP_PARAMETERPROB, 0, opt->srr+2,
  6431.                            skb->dev);
  6432.                      kfree_skb(skb, FREE_WRITE);
  6433. @@ -1954,21 +2030,26 @@
  6434.                  }
  6435.                  memcpy(&nexthop, &optptr[srrptr-1], 4);
  6436.                  if ((brd2 = ip_chk_addr(nexthop)) == 0)
  6437. -                  break;
  6438. -                if (brd2 != IS_MYADDR) {
  6439. -/* ANK: should we implement weak tunneling of multicasts?
  6440. - *    Are they obsolete? DVMRP specs (RFC-1075) is old enough...
  6441. - */
  6442. +                    break;
  6443. +                if (brd2 != IS_MYADDR) 
  6444. +                {
  6445. +
  6446. +                    /*
  6447. +                     *    ANK: should we implement weak tunneling of multicasts?
  6448. +                     *    Are they obsolete? DVMRP specs (RFC-1075) is old enough...
  6449. +                     *    [They are obsolete]
  6450. +                     */
  6451.                      kfree_skb(skb, FREE_WRITE);
  6452.                      return -EINVAL;
  6453.                  }
  6454.              }
  6455. -            if (srrptr <= srrspace) {
  6456. +            if (srrptr <= srrspace) 
  6457. +            {
  6458.                  opt->srr_is_hit = 1;
  6459.                  opt->is_changed = 1;
  6460.  #ifdef CONFIG_IP_FORWARD
  6461.                  if (ip_forward(skb, dev, is_frag, nexthop))
  6462. -                  kfree_skb(skb, FREE_WRITE);
  6463. +                    kfree_skb(skb, FREE_WRITE);
  6464.  #else
  6465.                  ip_statistics.IpInAddrErrors++;
  6466.                  kfree_skb(skb, FREE_WRITE);
  6467. @@ -2041,6 +2122,15 @@
  6468.          skb->ip_hdr = iph;
  6469.          skb->h.raw += iph->ihl*4;
  6470.  
  6471. +#ifdef CONFIG_IP_MROUTE        
  6472. +        /*
  6473. +         *    Check the state on multicast routing (multicast and not 224.0.0.z)
  6474. +         */
  6475. +         
  6476. +        if(brd==IS_MULTICAST && (iph->daddr&htonl(0xFFFFFF00))!=htonl(0xE0000000))
  6477. +            mroute_pkt=1;
  6478. +
  6479. +#endif
  6480.          /*
  6481.           *    Deliver to raw sockets. This is fun as to avoid copies we want to make no surplus copies.
  6482.           *
  6483. @@ -2102,7 +2192,11 @@
  6484.              *    raw delivery wait for that
  6485.              */
  6486.      
  6487. +#ifdef CONFIG_IP_MROUTE
  6488. +            if (ipprot->copy || raw_sk || mroute_pkt)
  6489. +#else    
  6490.              if (ipprot->copy || raw_sk)
  6491. +#endif            
  6492.              {
  6493.                  skb2 = skb_clone(skb, GFP_ATOMIC);
  6494.                  if(skb2==NULL)
  6495. @@ -2132,6 +2226,30 @@
  6496.           *    ICMP reply messages get queued up for transmission...)
  6497.           */
  6498.  
  6499. +#ifdef CONFIG_IP_MROUTE         
  6500. +        /*
  6501. +         *    Forward the last copy to the multicast router. If
  6502. +         *    there is a pending raw deliery however make a copy
  6503. +         *    and forward that.
  6504. +         */
  6505. +         
  6506. +        if(mroute_pkt)
  6507. +        {
  6508. +            flag=1;
  6509. +            if(raw_sk==NULL)
  6510. +                ipmr_forward(skb, is_frag);
  6511. +            else
  6512. +            {
  6513. +                struct sk_buff *skb2=skb_clone(skb, GFP_ATOMIC);
  6514. +                if(skb2)
  6515. +                {
  6516. +                    skb2->free=1;
  6517. +                    ipmr_forward(skb2, is_frag);
  6518. +                }
  6519. +            }
  6520. +        }
  6521. +#endif        
  6522. +
  6523.          if(raw_sk!=NULL)    /* Shift to last raw user */
  6524.              raw_rcv(raw_sk, skb, dev, iph->saddr, iph->daddr);
  6525.          else if (!flag)        /* Free and report errors */
  6526. @@ -2145,7 +2263,7 @@
  6527.      }
  6528.  
  6529.      /*
  6530. -     *    Do any IP forwarding required.
  6531. +     *    Do any unicast IP forwarding required.
  6532.       */
  6533.      
  6534.      /*
  6535. @@ -2266,14 +2384,7 @@
  6536.       *    header length problem
  6537.       */
  6538.  
  6539. -#if 0
  6540. -    ptr = skb->data;
  6541. -    ptr += dev->hard_header_len;
  6542. -    iph = (struct iphdr *)ptr;    
  6543. -    skb->ip_hdr = iph;
  6544. -#else
  6545.      iph = skb->ip_hdr;
  6546. -#endif
  6547.      iph->tot_len = ntohs(skb->len-(((unsigned char *)iph)-skb->data));
  6548.  
  6549.  #ifdef CONFIG_IP_FIREWALL
  6550. diff -u --recursive --new-file v1.3.30/linux/net/ipv4/ip_fw.c linux/net/ipv4/ip_fw.c
  6551. --- v1.3.30/linux/net/ipv4/ip_fw.c    Wed Sep 13 12:45:35 1995
  6552. +++ linux/net/ipv4/ip_fw.c    Wed Oct  4 08:15:11 1995
  6553. @@ -40,6 +40,7 @@
  6554.   *    Alan Cox        :    Fixed an error in the merge.
  6555.   *    Thomas Quinot        :    Fixed port spoofing.
  6556.   *    Alan Cox        :    Cleaned up retransmits in spoofing.
  6557. + *    Alan Cox        :    Cleaned up length setting.
  6558.   *
  6559.   *    All the real work was done by .....
  6560.   *
  6561. @@ -266,7 +267,7 @@
  6562.          case IPPROTO_TCP:
  6563.              dprintf1("TCP ");
  6564.              /* ports stay 0 if it is not the first fragment */
  6565. -            if (offset!=0) {
  6566. +            if (!offset) {
  6567.                  src_port=ntohs(tcp->source);
  6568.                  dst_port=ntohs(tcp->dest);
  6569.                  if(tcp->ack)
  6570. @@ -281,7 +282,7 @@
  6571.          case IPPROTO_UDP:
  6572.              dprintf1("UDP ");
  6573.              /* ports stay 0 if it is not the first fragment */
  6574. -            if (offset!=0) {
  6575. +            if (!offset) {
  6576.                  src_port=ntohs(udp->source);
  6577.                  dst_port=ntohs(udp->dest);
  6578.              }
  6579. @@ -700,6 +701,12 @@
  6580.  /*         skb2->h.raw = &skb2->data[skb->h.raw - skb->data];*/
  6581.          skb2->h.raw = skb2->data + (skb->h.raw - skb->data);
  6582.          iph=skb2->h.iph;
  6583. +        /*
  6584. +         *    Mend the IP header too
  6585. +         */
  6586. +        iph->tot_len = htons(diff+ntohs(iph->tot_len));
  6587. +        iph->check = 0;
  6588. +        iph->check = ip_fast_csum((unsigned char *)iph, iph->ihl);
  6589.   
  6590.           /*
  6591.            *    Copy the packet data into the new buffer.
  6592. diff -u --recursive --new-file v1.3.30/linux/net/ipv4/ipmr.c linux/net/ipv4/ipmr.c
  6593. --- v1.3.30/linux/net/ipv4/ipmr.c    Wed Sep 27 16:00:02 1995
  6594. +++ linux/net/ipv4/ipmr.c    Wed Oct  4 08:15:11 1995
  6595. @@ -12,10 +12,16 @@
  6596.   *
  6597.   *    Fixes:
  6598.   *    Michael Chastain    :    Incorrect size of copying.
  6599. - *
  6600. + *    Alan Cox        :    Added the cache manager code
  6601.   *
  6602.   *    Status:
  6603. - *        Tree building works. Cache manager to be added next.
  6604. + *        Cache manager under test. Forwarding in vague test mode
  6605. + *    Todo:
  6606. + *        Flow control
  6607. + *        Tunnels
  6608. + *        Wipe cache on mrouted exit
  6609. + *        Debug cache ttl handling properly
  6610. + *        Resolve IFF_ALLMULTI for most cards
  6611.   */
  6612.  
  6613.  #include <asm/system.h>
  6614. @@ -27,10 +33,12 @@
  6615.  #include <linux/mm.h>
  6616.  #include <linux/kernel.h>
  6617.  #include <linux/fcntl.h>
  6618. +#include <linux/stat.h>
  6619.  #include <linux/socket.h>
  6620.  #include <linux/in.h>
  6621.  #include <linux/inet.h>
  6622.  #include <linux/netdevice.h>
  6623. +#include <linux/proc_fs.h>
  6624.  #include <linux/mroute.h>
  6625.  #include <net/ip.h>
  6626.  #include <net/protocol.h>
  6627. @@ -47,9 +55,12 @@
  6628.   *    Multicast router conrol variables
  6629.   */
  6630.  
  6631. -static struct vif_device vif_table[MAXVIFS];
  6632. -static unsigned long vifc_map;
  6633. -int mroute_do_pim = 0;
  6634. +static struct vif_device vif_table[MAXVIFS];        /* Devices         */
  6635. +static unsigned long vifc_map;                /* Active device map    */
  6636. +int mroute_do_pim = 0;                    /* Set in PIM assert    */
  6637. +static struct mfc_cache *mfc_cache_array[MFC_LINES];    /* Forwarding cache    */
  6638. +static struct mfc_cache *cache_resolve_queue;        /* Unresolved cache    */
  6639. +int cache_resolve_queue_len = 0;            /* Size of unresolved    */
  6640.  
  6641.  /*
  6642.   *    Delete a VIF entry
  6643. @@ -64,6 +75,342 @@
  6644.      }
  6645.      v->dev=NULL;
  6646.  }
  6647. +
  6648. +/*
  6649. + *    Find a vif
  6650. + */
  6651. + 
  6652. +static int ipmr_vifi_find(struct device *dev)
  6653. +{
  6654. +    struct vif_device *v=&vif_table[0];
  6655. +    int ct;
  6656. +    for(ct=0;ct<MAXVIFS;ct++,v++)
  6657. +    {
  6658. +        if(v->dev==dev)
  6659. +            return ct;
  6660. +    }
  6661. +    return -1;
  6662. +}
  6663. +
  6664. +/*
  6665. + *    Delete a multicast route cache entry
  6666. + */
  6667. + 
  6668. +static void ipmr_cache_delete(struct mfc_cache *cache)
  6669. +{
  6670. +    struct sk_buff *skb;
  6671. +    int line;
  6672. +    struct mfc_cache **cp;
  6673. +    
  6674. +    /*
  6675. +     *    Find the right cache line
  6676. +     */
  6677. +
  6678. +    if(cache->mfc_flags&MFC_QUEUED)
  6679. +    {    
  6680. +        cp=&cache_resolve_queue;
  6681. +        del_timer(&cache->mfc_timer);
  6682. +    }    
  6683. +    else
  6684. +    {
  6685. +        line=MFC_HASH(cache->mfc_mcastgrp,cache->mfc_origin);
  6686. +        cp=&(mfc_cache_array[line]);
  6687. +    }
  6688. +    
  6689. +    /*
  6690. +     *    Unlink the buffer
  6691. +     */
  6692. +    
  6693. +    while(*cp!=NULL)
  6694. +    {
  6695. +        if(*cp==cache)
  6696. +        {
  6697. +            *cp=cache->next;
  6698. +            break;
  6699. +        }
  6700. +        cp=&((*cp)->next);
  6701. +    }
  6702. +    
  6703. +    /*
  6704. +     *    Free the buffer. If it is a pending resolution
  6705. +     *    clean up the other resources.
  6706. +     */
  6707. +
  6708. +    if(cache->mfc_flags&MFC_QUEUED)
  6709. +    {
  6710. +        cache_resolve_queue_len--;
  6711. +        while((skb=skb_dequeue(&cache->mfc_unresolved)))
  6712. +            kfree_skb(skb, FREE_WRITE);
  6713. +    }
  6714. +    kfree_s(cache,sizeof(cache));
  6715. +}
  6716. +
  6717. +/*
  6718. + *    Cache expiry timer
  6719. + */    
  6720. + 
  6721. +static void ipmr_cache_timer(unsigned long data)
  6722. +{
  6723. +    struct mfc_cache *cache=(struct mfc_cache *)data;
  6724. +    ipmr_cache_delete(cache);
  6725. +}
  6726. +
  6727. +/*
  6728. + *    Insert a multicast cache entry
  6729. + */
  6730. +
  6731. +static void ipmr_cache_insert(struct mfc_cache *c)
  6732. +{
  6733. +    int line=MFC_HASH(c->mfc_mcastgrp,c->mfc_origin);
  6734. +    c->next=mfc_cache_array[line];
  6735. +    mfc_cache_array[line]=c;
  6736. +}
  6737. + 
  6738. +/*
  6739. + *    Find a multicast cache entry
  6740. + */
  6741. + 
  6742. +struct mfc_cache *ipmr_cache_find(__u32 origin, __u32 mcastgrp)
  6743. +{
  6744. +    int line=MFC_HASH(mcastgrp,origin);
  6745. +    struct mfc_cache *cache;
  6746. +    cache=mfc_cache_array[line];
  6747. +    while(cache!=NULL)
  6748. +    {
  6749. +        if(cache->mfc_origin==origin && cache->mfc_mcastgrp==mcastgrp)
  6750. +            return cache;
  6751. +        cache=cache->next;
  6752. +    }
  6753. +    cache=cache_resolve_queue;
  6754. +    while(cache!=NULL)
  6755. +    {
  6756. +        if(cache->mfc_origin==origin && cache->mfc_mcastgrp==mcastgrp)
  6757. +            return cache;
  6758. +        cache=cache->next;
  6759. +    }
  6760. +    return NULL;
  6761. +}
  6762. +
  6763. +/*
  6764. + *    Allocate a multicast cache entry
  6765. + */
  6766. + 
  6767. +static struct mfc_cache *ipmr_cache_alloc(int priority)
  6768. +{
  6769. +    struct mfc_cache *c=(struct mfc_cache *)kmalloc(sizeof(struct mfc_cache), priority);
  6770. +    if(c==NULL)
  6771. +        return NULL;
  6772. +    c->mfc_queuelen=0;
  6773. +    skb_queue_head_init(&c->mfc_unresolved);
  6774. +    init_timer(&c->mfc_timer);
  6775. +    c->mfc_timer.data=(long)c;
  6776. +    c->mfc_timer.function=ipmr_cache_timer;
  6777. +    return c;
  6778. +}
  6779. + 
  6780. +/*
  6781. + *    A cache entry has gone into a resolved state from queued
  6782. + */
  6783. + 
  6784. +static void ipmr_cache_resolve(struct mfc_cache *cache)
  6785. +{
  6786. +    struct mfc_cache **p;
  6787. +    struct sk_buff *skb;
  6788. +    /*
  6789. +     *    Kill the queue entry timer.
  6790. +     */
  6791. +    del_timer(&cache->mfc_timer);
  6792. +    cache->mfc_flags&=~MFC_QUEUED;
  6793. +    /*
  6794. +     *    Remove from the resolve queue
  6795. +     */
  6796. +    p=&cache_resolve_queue;
  6797. +    while((*p)!=NULL)
  6798. +    {
  6799. +        if((*p)==cache)
  6800. +        {
  6801. +            *p=cache->next;
  6802. +            break;
  6803. +        }
  6804. +        p=&((*p)->next);
  6805. +    }
  6806. +    cache_resolve_queue_len--;
  6807. +    sti();
  6808. +    /*
  6809. +     *    Insert into the main cache
  6810. +     */
  6811. +    ipmr_cache_insert(cache);
  6812. +    /*
  6813. +     *    Play the pending entries through our router
  6814. +     */
  6815. +    while((skb=skb_dequeue(&cache->mfc_unresolved)))
  6816. +        ipmr_forward(skb, skb->protocol);
  6817. +}
  6818. +
  6819. +/*
  6820. + *    Bounce a cache query up to mrouted. We could use netlink for this but mrouted
  6821. + *    expects the following bizarre scheme..
  6822. + */
  6823. + 
  6824. +static void ipmr_cache_report(struct sk_buff *pkt)
  6825. +{
  6826. +    struct sk_buff *skb=alloc_skb(128, GFP_ATOMIC);
  6827. +    int ihl=pkt->ip_hdr->ihl<<2;
  6828. +    struct igmphdr *igmp;
  6829. +    if(!skb)
  6830. +        return;
  6831. +        
  6832. +    skb->free=1;
  6833. +    
  6834. +    /*
  6835. +     *    Copy the IP header
  6836. +     */
  6837. +
  6838. +    skb->ip_hdr=(struct iphdr *)skb_put(skb,ihl);
  6839. +    skb->h.iph=skb->ip_hdr;
  6840. +    memcpy(skb->data,pkt->data,ihl);
  6841. +    skb->ip_hdr->protocol = 0;            /* Flag to the kernel this is a route add */
  6842. +    
  6843. +    /*
  6844. +     *    Add our header
  6845. +     */
  6846. +    
  6847. +    igmp=(struct igmphdr *)skb_put(skb,sizeof(struct igmphdr));
  6848. +    igmp->type    =    IGMPMSG_NOCACHE;        /* non IGMP dummy message */
  6849. +    igmp->code     =    0;
  6850. +    skb->ip_hdr->tot_len=htons(skb->len);            /* Fix the length */
  6851. +    
  6852. +    /*
  6853. +     *    Deliver to mrouted
  6854. +     */
  6855. +    if(sock_queue_rcv_skb(mroute_socket,skb)<0)
  6856. +    {
  6857. +        skb->sk=NULL;
  6858. +        kfree_skb(skb, FREE_READ);
  6859. +    }
  6860. +}
  6861. +        
  6862. + 
  6863. +/*
  6864. + *    Queue a packet for resolution
  6865. + */
  6866. + 
  6867. +static void ipmr_cache_unresolved(struct mfc_cache *cache, vifi_t vifi, struct sk_buff *skb, int is_frag)
  6868. +{
  6869. +    if(cache==NULL)
  6870. +    {    
  6871. +        /*
  6872. +         *    Create a new entry if allowable
  6873. +         */
  6874. +        if(cache_resolve_queue_len>=10 || (cache=ipmr_cache_alloc(GFP_ATOMIC))==NULL)
  6875. +        {
  6876. +            kfree_skb(skb, FREE_WRITE);
  6877. +            return;
  6878. +        }
  6879. +        /*
  6880. +         *    Fill in the new cache entry
  6881. +         */
  6882. +        cache->mfc_parent=vifi;
  6883. +        cache->mfc_origin=skb->ip_hdr->saddr;
  6884. +        cache->mfc_mcastgrp=skb->ip_hdr->daddr;
  6885. +        cache->mfc_flags=MFC_QUEUED;
  6886. +        /*
  6887. +         *    Link to the unresolved list
  6888. +         */
  6889. +        cache->next=cache_resolve_queue;
  6890. +        cache_resolve_queue=cache;
  6891. +        cache_resolve_queue_len++;
  6892. +        /*
  6893. +         *    Fire off the expiry timer
  6894. +         */
  6895. +        cache->mfc_timer.expires=jiffies+10*HZ;
  6896. +        add_timer(&cache->mfc_timer);
  6897. +        /*
  6898. +         *    Reflect first query at mrouted.
  6899. +         */
  6900. +        if(mroute_socket)
  6901. +            ipmr_cache_report(skb);
  6902. +    }
  6903. +    /*
  6904. +     *    See if we can append the packet
  6905. +     */
  6906. +    if(cache->mfc_queuelen>3)
  6907. +    {
  6908. +        kfree_skb(skb, FREE_WRITE);
  6909. +        return;
  6910. +    }
  6911. +    /*
  6912. +     *    Add to our 'pending' list. Cache the is_frag data
  6913. +     *    in skb->protocol now it is spare.
  6914. +     */
  6915. +    cache->mfc_queuelen++;
  6916. +    skb->protocol=is_frag;
  6917. +    skb_queue_tail(&cache->mfc_unresolved,skb);
  6918. +}
  6919. +
  6920. +/*
  6921. + *    MFC cache manipulation by user space mroute daemon
  6922. + */
  6923. + 
  6924. +int ipmr_mfc_modify(int action, struct mfcctl *mfc)
  6925. +{
  6926. +    struct mfc_cache *cache;
  6927. +    if(!MULTICAST(mfc->mfcc_mcastgrp.s_addr))
  6928. +        return -EINVAL;
  6929. +    /*
  6930. +     *    Find the cache line
  6931. +     */
  6932. +    
  6933. +    cli();
  6934. +    cache=ipmr_cache_find(mfc->mfcc_origin.s_addr,mfc->mfcc_mcastgrp.s_addr);
  6935. +    
  6936. +    /*
  6937. +     *    Delete an entry
  6938. +     */
  6939. +    if(action==MRT_DEL_MFC)
  6940. +    {
  6941. +        if(cache)
  6942. +        {
  6943. +            ipmr_cache_delete(cache);
  6944. +            sti();
  6945. +            return 0;
  6946. +        }
  6947. +        return -ENOENT;
  6948. +    }
  6949. +    if(cache)
  6950. +    {
  6951. +        /*
  6952. +         *    Update the cache, see if it frees a pending queue
  6953. +         */
  6954. +
  6955. +        cache->mfc_flags|=MFC_RESOLVED;
  6956. +        memcpy(cache->mfc_ttls, mfc->mfcc_ttls,sizeof(cache->mfc_ttls));
  6957. +         
  6958. +        /*
  6959. +         *    Check to see if we resolved a queued list. If so we
  6960. +         *    need to send on the frames and tidy up.
  6961. +         */
  6962. +         
  6963. +        if(cache->mfc_flags&MFC_QUEUED)
  6964. +            ipmr_cache_resolve(cache);    /* Unhook & send the frames */
  6965. +        sti();
  6966. +        return 0;
  6967. +    }
  6968. +    /*
  6969. +     *    Unsolicited update - thats ok add anyway.
  6970. +     */
  6971. +    sti();
  6972. +    cache=ipmr_cache_alloc(GFP_KERNEL);
  6973. +    if(cache==NULL)
  6974. +        return -ENOMEM;
  6975. +    cache->mfc_flags=MFC_RESOLVED;
  6976. +    cache->mfc_origin=mfc->mfcc_origin.s_addr;
  6977. +    cache->mfc_mcastgrp=mfc->mfcc_mcastgrp.s_addr;
  6978. +    cache->mfc_parent=mfc->mfcc_parent;
  6979. +    memcpy(cache->mfc_ttls, mfc->mfcc_ttls,sizeof(cache->mfc_ttls));
  6980. +    ipmr_cache_insert(cache);
  6981. +    return 0;
  6982. +}
  6983.   
  6984.  /*
  6985.   *    Socket options and virtual interface manipulation. The whole
  6986. @@ -76,6 +423,7 @@
  6987.  {
  6988.      int err;
  6989.      struct vifctl vif;
  6990. +    struct mfcctl mfc;
  6991.      
  6992.      if(optname!=MRT_INIT)
  6993.      {
  6994. @@ -184,7 +532,11 @@
  6995.           */
  6996.          case MRT_ADD_MFC:
  6997.          case MRT_DEL_MFC:
  6998. -            return -EOPNOTSUPP;
  6999. +            err=verify_area(VERIFY_READ, optval, sizeof(mfc));
  7000. +            if(err)
  7001. +                return err;
  7002. +            memcpy_fromfs(&mfc,optval, sizeof(mfc));
  7003. +            return ipmr_mfc_modify(optname, &mfc);
  7004.          /*
  7005.           *    Control PIM assert.
  7006.           */
  7007. @@ -301,6 +653,15 @@
  7008.          v++;
  7009.      }        
  7010.      vifc_map=0;    
  7011. +    /*
  7012. +     *    Wipe the cache
  7013. +     */
  7014. +    for(i=0;i<MFC_LINES;i++)
  7015. +    {
  7016. +        while(mfc_cache_array[i]!=NULL)
  7017. +            ipmr_cache_delete(mfc_cache_array[i]);
  7018. +    }    
  7019. +    /* The timer will clear any 'pending' stuff */
  7020.  }
  7021.  
  7022.  static int ipmr_device_event(unsigned long event, void *ptr)
  7023. @@ -328,12 +689,226 @@
  7024.      NULL,
  7025.      0
  7026.  };
  7027. +
  7028. +/*
  7029. + *    Processing handlers for ipmr_forward
  7030. + */
  7031. +
  7032. +static void ipmr_queue_xmit(struct sk_buff *skb, struct vif_device *vif, struct device *in_dev, int frag)
  7033. +{
  7034. +    int tunnel=0;
  7035. +    __u32 raddr=skb->raddr;
  7036. +    if(vif->flags&VIFF_TUNNEL)
  7037. +    {
  7038. +        tunnel=16;
  7039. +        raddr=vif->remote;
  7040. +    }
  7041. +    vif->pkt_out++;
  7042. +    vif->bytes_out+=skb->len;
  7043. +    skb->dev=vif->dev;
  7044. +    skb->raddr=skb->h.iph->daddr;
  7045. +    if(ip_forward(skb, in_dev, frag|8|tunnel, raddr)==-1)
  7046. +        kfree_skb(skb, FREE_WRITE);
  7047. +}
  7048. +
  7049. +/*
  7050. + *    Multicast packets for forwarding arrive here
  7051. + */
  7052. +
  7053. +void ipmr_forward(struct sk_buff *skb, int is_frag)
  7054. +{
  7055. +    struct mfc_cache *cache;
  7056. +    struct sk_buff *skb2;
  7057. +    int psend = -1;
  7058. +    int vif=ipmr_vifi_find(skb->dev);
  7059. +    if(vif==-1)
  7060. +    {
  7061. +        kfree_skb(skb, FREE_WRITE);
  7062. +        return;
  7063. +    }
  7064. +    
  7065. +    vif_table[vif].pkt_in++;
  7066. +    vif_table[vif].bytes_in+=skb->len;
  7067.      
  7068. +    cache=ipmr_cache_find(skb->ip_hdr->saddr,skb->ip_hdr->daddr);
  7069. +    
  7070. +    /*
  7071. +     *    No usable cache entry
  7072. +     */
  7073. +     
  7074. +    if(cache==NULL || (cache->mfc_flags&MFC_QUEUED))
  7075. +        ipmr_cache_unresolved(cache,vif,skb, is_frag);
  7076. +    else
  7077. +    {
  7078. +        /*
  7079. +         *    Forward the frame
  7080. +         */
  7081. +         int ct=0;
  7082. +         while(ct<MAXVIFS)
  7083. +         {
  7084. +             /*
  7085. +              *    0 means don't do it. Silly idea, 255 as don't do it would be cleaner!
  7086. +              */
  7087. +             if(skb->ip_hdr->ttl > cache->mfc_ttls[ct] && cache->mfc_ttls[ct]>0)
  7088. +             {
  7089. +                 if(psend!=-1)
  7090. +                 {
  7091. +                     skb2=skb_clone(skb, GFP_ATOMIC);
  7092. +                     if(skb2)
  7093. +                     {
  7094. +                         skb2->free=1;
  7095. +                         ipmr_queue_xmit(skb2, &vif_table[psend], skb->dev, is_frag);
  7096. +                     }
  7097. +                }
  7098. +                psend=ct;
  7099. +            }
  7100. +            ct++;
  7101. +        }
  7102. +        if(psend==-1)
  7103. +            kfree_skb(skb, FREE_WRITE);
  7104. +        else
  7105. +        {
  7106. +            ipmr_queue_xmit(skb, &vif_table[psend], skb->dev, is_frag);
  7107. +        }
  7108. +        /*
  7109. +         *    Adjust the stats
  7110. +         */
  7111. +    }
  7112. +}
  7113.  
  7114. +/*
  7115. + *    The /proc interfaces to multicast routing /proc/ip_mr_cache /proc/ip_mr_vif
  7116. + */
  7117. + 
  7118. +int ipmr_vif_info(char *buffer, char **start, off_t offset, int length, int dummy)
  7119. +{
  7120. +    struct vif_device *vif;
  7121. +    int len=0;
  7122. +    off_t pos=0;
  7123. +    off_t begin=0;
  7124. +    int size;
  7125. +    int ct;
  7126. +
  7127. +    len += sprintf(buffer,
  7128. +         "Interface  Bytes In  Pkts In  Bytes Out  Pkts Out  Flags Local    Remote\n");
  7129. +    pos=len;
  7130. +  
  7131. +    for (ct=0;ct<MAXVIFS;ct++) 
  7132. +    {
  7133. +        vif=&vif_table[ct];
  7134. +        if(!(vifc_map&(1<<ct)))
  7135. +            continue;
  7136. +        if(vif->dev==NULL)
  7137. +            continue;
  7138. +            size = sprintf(buffer+len, "%-10s %8ld  %7ld  %8ld   %7ld   %05X %08lX %08lX\n",
  7139. +                vif->dev->name,vif->bytes_in, vif->pkt_in, vif->bytes_out,vif->pkt_out,
  7140. +                vif->flags, vif->local, vif->remote);
  7141. +        len+=size;
  7142. +        pos+=size;
  7143. +        if(pos<offset)
  7144. +        {
  7145. +            len=0;
  7146. +            begin=pos;
  7147. +        }
  7148. +        if(pos>offset+length)
  7149. +            break;
  7150. +      }
  7151. +      
  7152. +      *start=buffer+(offset-begin);
  7153. +      len-=(offset-begin);
  7154. +      if(len>length)
  7155. +          len=length;
  7156. +      return len;
  7157. +}
  7158. +
  7159. +int ipmr_mfc_info(char *buffer, char **start, off_t offset, int length, int dummy)
  7160. +{
  7161. +    struct mfc_cache *mfc;
  7162. +    int len=0;
  7163. +    off_t pos=0;
  7164. +    off_t begin=0;
  7165. +    int size;
  7166. +    int ct;
  7167. +
  7168. +    len += sprintf(buffer,
  7169. +         "Group    Origin   SrcIface \n");
  7170. +    pos=len;
  7171. +  
  7172. +    for (ct=0;ct<MFC_LINES;ct++) 
  7173. +    {
  7174. +        cli();
  7175. +        mfc=mfc_cache_array[ct];
  7176. +        while(mfc!=NULL)
  7177. +        {
  7178. +            char *name="none";
  7179. +            char vifmap[MAXVIFS+1];
  7180. +            int n;
  7181. +            /*
  7182. +             *    Device name
  7183. +             */
  7184. +            if(vifc_map&(1<<mfc->mfc_parent))
  7185. +                name=vif_table[mfc->mfc_parent].dev->name;
  7186. +            /*
  7187. +             *    Interface forwarding map
  7188. +             */
  7189. +            for(n=0;n<MAXVIFS;n++)
  7190. +                if(vifc_map&(1<<n) && mfc->mfc_ttls[ct])
  7191. +                    vifmap[n]='X';
  7192. +                else
  7193. +                    vifmap[n]='-';
  7194. +            vifmap[n]=0;
  7195. +            /*
  7196. +             *    Now print it out
  7197. +             */
  7198. +            size = sprintf(buffer+len, "%08lX %08lX %-8s %s\n",
  7199. +                (unsigned long)mfc->mfc_mcastgrp,
  7200. +                (unsigned long)mfc->mfc_origin,
  7201. +                name,
  7202. +                vifmap);
  7203. +            len+=size;
  7204. +            pos+=size;
  7205. +            if(pos<offset)
  7206. +            {
  7207. +                len=0;
  7208. +                begin=pos;
  7209. +            }
  7210. +            if(pos>offset+length)
  7211. +            {
  7212. +                sti();
  7213. +                goto done;
  7214. +            }
  7215. +            mfc=mfc->next;
  7216. +          }
  7217. +          sti();
  7218. +      }
  7219. +done:
  7220. +      *start=buffer+(offset-begin);
  7221. +      len-=(offset-begin);
  7222. +      if(len>length)
  7223. +          len=length;
  7224. +      return len;
  7225. +}
  7226. +
  7227. +/*
  7228. + *    Setup for IP multicast routing
  7229. + */
  7230. + 
  7231.  void ip_mr_init(void)
  7232.  {
  7233. -    printk("Linux IP multicast router 0.00pre-working 8)\n");
  7234. +    printk("Linux IP multicast router 0.02pre-working 8)\n");
  7235.      register_netdevice_notifier(&ip_mr_notifier);
  7236. +    proc_net_register(&(struct proc_dir_entry) {
  7237. +        PROC_NET_IPMR_VIF, 9 ,"ip_mr_vif",
  7238. +        S_IFREG | S_IRUGO, 1, 0, 0,
  7239. +        0, &proc_net_inode_operations,
  7240. +        ipmr_vif_info
  7241. +    });
  7242. +    proc_net_register(&(struct proc_dir_entry) {
  7243. +        PROC_NET_IPMR_MFC, 11 ,"ip_mr_cache",
  7244. +        S_IFREG | S_IRUGO, 1, 0, 0,
  7245. +        0, &proc_net_inode_operations,
  7246. +        ipmr_mfc_info
  7247. +    });
  7248.  }
  7249.  
  7250.  #endif
  7251. diff -u --recursive --new-file v1.3.30/linux/net/ipv4/tcp.c linux/net/ipv4/tcp.c
  7252. --- v1.3.30/linux/net/ipv4/tcp.c    Wed Sep 27 16:00:02 1995
  7253. +++ linux/net/ipv4/tcp.c    Mon Oct  2 14:25:13 1995
  7254. @@ -509,6 +509,8 @@
  7255.      sk->state=state;
  7256.      if(state==TCP_ESTABLISHED)
  7257.          tcp_statistics.TcpCurrEstab++;
  7258. +    if(sk->state==TCP_CLOSE)
  7259. +        tcp_cache_zap();
  7260.  }
  7261.  
  7262.  /*
  7263. diff -u --recursive --new-file v1.3.30/linux/net/netlink.c linux/net/netlink.c
  7264. --- v1.3.30/linux/net/netlink.c    Thu Jan  1 02:00:00 1970
  7265. +++ linux/net/netlink.c    Mon Oct  2 14:25:13 1995
  7266. @@ -0,0 +1,250 @@
  7267. +/*
  7268. + * SKIPLINK    An implementation of a loadable kernel mode driver providing
  7269. + *        multiple kernel/user space bidirectional communications links.
  7270. + *
  7271. + *         Author:     Alan Cox <alan@cymru.net>
  7272. + *
  7273. + *        This program is free software; you can redistribute it and/or
  7274. + *        modify it under the terms of the GNU General Public License
  7275. + *        as published by the Free Software Foundation; either version
  7276. + *        2 of the License, or (at your option) any later version.
  7277. + * 
  7278. + */
  7279. +
  7280. +#include <linux/config.h>
  7281. +
  7282. +#if defined(CONFIG_NETLINK) || defined(MODULE)
  7283. +#ifdef MODULE
  7284. +#include <linux/module.h>
  7285. +#include <linux/version.h>
  7286. +#else
  7287. +#define MOD_INC_USE_COUNT
  7288. +#define MOD_DEC_USE_COUNT
  7289. +#endif
  7290. +
  7291. +#include <linux/errno.h>
  7292. +#include <linux/kernel.h>
  7293. +#include <linux/major.h>
  7294. +#include <linux/sched.h>
  7295. +#include <linux/lp.h>
  7296. +#include <linux/malloc.h>
  7297. +#include <linux/ioport.h>
  7298. +#include <linux/fcntl.h>
  7299. +#include <linux/delay.h>
  7300. +#include <linux/skbuff.h>
  7301. +
  7302. +#include <net/netlink.h>
  7303. +
  7304. +#include <asm/io.h>
  7305. +#include <asm/segment.h>
  7306. +#include <asm/system.h>
  7307. +
  7308. +static int (*netlink_handler[MAX_LINKS])(struct sk_buff *skb);
  7309. +static struct sk_buff_head skb_queue_rd[MAX_LINKS]; 
  7310. +static int rdq_size[MAX_LINKS];
  7311. +static struct wait_queue *read_space_wait[MAX_LINKS];
  7312. +
  7313. +static int active_map = 0;
  7314. +static int open_map = 0;
  7315. +
  7316. +/*
  7317. + *    Device operations
  7318. + */
  7319. + 
  7320. +/*
  7321. + *    Default write handler.
  7322. + */
  7323. + 
  7324. +static int netlink_err(struct sk_buff *skb)
  7325. +{
  7326. +    kfree_skb(skb, FREE_READ);
  7327. +    return -EUNATCH;
  7328. +}
  7329. + 
  7330. +/*
  7331. + *    Write a message to the kernel side of a communication link
  7332. + */
  7333. + 
  7334. +static int netlink_write(struct inode * inode, struct file * file, const char * buf, int count)
  7335. +{
  7336. +    unsigned int minor = MINOR(inode->i_rdev);
  7337. +    struct sk_buff *skb;
  7338. +    skb=alloc_skb(count, GFP_KERNEL);
  7339. +    memcpy_fromfs(skb_put(skb,count),buf, count);
  7340. +    return (netlink_handler[minor])(skb);
  7341. +}
  7342. +
  7343. +/*
  7344. + *    Read a message from the kernel side of the communication link
  7345. + */
  7346. +
  7347. +static int netlink_read(struct inode * inode, struct file * file, char * buf, int count)
  7348. +{
  7349. +    unsigned int minor = MINOR(inode->i_rdev);
  7350. +    struct sk_buff *skb;
  7351. +    cli();
  7352. +    while((skb=skb_dequeue(&skb_queue_rd[minor]))==NULL)
  7353. +    {
  7354. +        if(file->f_flags&O_NONBLOCK)
  7355. +        {
  7356. +            sti();
  7357. +            return -EWOULDBLOCK;
  7358. +        }
  7359. +        interruptible_sleep_on(&read_space_wait[minor]);
  7360. +        if(current->signal & ~current->blocked)
  7361. +        {
  7362. +            sti();
  7363. +            return -ERESTARTSYS;
  7364. +        }
  7365. +    }
  7366. +    rdq_size[minor]-=skb->len;
  7367. +    sti();
  7368. +    if(skb->len<count)
  7369. +        count=skb->len;
  7370. +    memcpy_tofs(buf,skb->data,count);
  7371. +    kfree_skb(skb, FREE_READ);
  7372. +    return count;
  7373. +}
  7374. +
  7375. +static int netlink_lseek(struct inode * inode, struct file * file,
  7376. +            off_t offset, int origin)
  7377. +{
  7378. +    return -ESPIPE;
  7379. +}
  7380. +
  7381. +static int netlink_open(struct inode * inode, struct file * file)
  7382. +{
  7383. +    unsigned int minor = MINOR(inode->i_rdev);
  7384. +    
  7385. +    if(minor>=MAX_LINKS)
  7386. +        return -ENODEV;
  7387. +    if(open_map&(1<<minor))
  7388. +        return -EBUSY;
  7389. +    if(active_map&(1<<minor))
  7390. +    {
  7391. +        open_map|=(1<<minor);
  7392. +        return 0;
  7393. +    }
  7394. +    return -EUNATCH;
  7395. +}
  7396. +
  7397. +static void netlink_release(struct inode * inode, struct file * file)
  7398. +{
  7399. +    unsigned int minor = MINOR(inode->i_rdev);
  7400. +    open_map&=~(1<<minor);    
  7401. +    MOD_DEC_USE_COUNT;
  7402. +}
  7403. +
  7404. +
  7405. +static int netlink_ioctl(struct inode *inode, struct file *file,
  7406. +            unsigned int cmd, unsigned long arg)
  7407. +{
  7408. +    unsigned int minor = MINOR(inode->i_rdev);
  7409. +    int retval = 0;
  7410. +
  7411. +    if (minor >= MAX_LINKS)
  7412. +        return -ENODEV;
  7413. +    switch ( cmd ) {
  7414. +        default:
  7415. +            retval = -EINVAL;
  7416. +    }
  7417. +    return retval;
  7418. +}
  7419. +
  7420. +
  7421. +static struct file_operations netlink_fops = {
  7422. +    netlink_lseek,
  7423. +    netlink_read,
  7424. +    netlink_write,
  7425. +    NULL,        /* netlink_readdir */
  7426. +    NULL,        /* netlink_select */
  7427. +    netlink_ioctl,
  7428. +    NULL,        /* netlink_mmap */
  7429. +    netlink_open,
  7430. +    netlink_release
  7431. +};
  7432. +
  7433. +/*
  7434. + *    We export these functions to other modules. They provide a 
  7435. + *    complete set of kernel non-blocking support for message
  7436. + *    queueing.
  7437. + */
  7438. + 
  7439. +int netlink_attach(int unit, int (*function)(struct sk_buff *skb))
  7440. +{
  7441. +    if(unit>=MAX_LINKS)
  7442. +        return -ENODEV;
  7443. +    if(active_map&(1<<unit))
  7444. +        return -EBUSY;
  7445. +    active_map|=(1<<unit);
  7446. +    netlink_handler[unit]=function;
  7447. +    return 0;
  7448. +}
  7449. +
  7450. +void netlink_detach(int unit)
  7451. +{
  7452. +    active_map&=~(1<<unit);
  7453. +    netlink_handler[unit]=netlink_err;
  7454. +}
  7455. +
  7456. +int netlink_post(int unit, struct sk_buff *skb)
  7457. +{
  7458. +    unsigned long flags;
  7459. +    int ret;
  7460. +    save_flags(flags);
  7461. +    cli();
  7462. +    if(rdq_size[unit]+skb->len>MAX_QBYTES)
  7463. +        ret=-EWOULDBLOCK;
  7464. +    else
  7465. +    {
  7466. +        skb_queue_tail(&skb_queue_rd[unit], skb);
  7467. +        rdq_size[unit]+=skb->len;
  7468. +        ret=0;
  7469. +        wake_up_interruptible(&read_space_wait[MAX_LINKS]);
  7470. +    }
  7471. +    restore_flags(flags);
  7472. +    return ret;
  7473. +}
  7474. +
  7475. +
  7476. +#ifdef MODULE
  7477. +char kernel_version[]=UTS_RELEASE;
  7478. +
  7479. +int init_module(void)
  7480. +{
  7481. +    int ct;
  7482. +    printk("Network Kernel/User communications module 0.01 ALPHA\n");
  7483. +    if (register_chrdev(NET_MAJOR,"netlink",&netlink_fops)) {
  7484. +        printk("netlink: unable to get major %d\n", NET_MAJOR);
  7485. +        return -EIO;
  7486. +    }
  7487. +    for(ct=0;ct<MAX_LINKS;ct++)
  7488. +    {
  7489. +        skb_queue_head_init(&skb_queue_rd[ct]);
  7490. +        netlink_handler[ct]=netlink_err;
  7491. +    }
  7492. +    return 0;
  7493. +}
  7494. +
  7495. +void cleanup_module(void)
  7496. +{
  7497. +    unregister_chrdev(NET_MAJOR,"netlink");
  7498. +}
  7499. +
  7500. +#else
  7501. +
  7502. +void init_netlink(void)
  7503. +{
  7504. +    int ct;
  7505. +    /* Keep quiet on booting, we don't want too many messages */
  7506. +    if(register_chrdev(NET_MAJOR,"netlink", &netlink_fops))
  7507. +        printk("netlink: unable to get major %d\n", NET_MAJOR);
  7508. +    for(ct=0;ct<MAX_LINKS;ct++)
  7509. +    {
  7510. +        skb_queue_head_init(&skb_queue_rd[ct]);
  7511. +        netlink_handler[ct]=netlink_err;
  7512. +    }
  7513. +}
  7514. +
  7515. +#endif
  7516. +#endif
  7517. diff -u --recursive --new-file v1.3.30/linux/net/socket.c linux/net/socket.c
  7518. --- v1.3.30/linux/net/socket.c    Wed Sep 13 12:45:36 1995
  7519. +++ linux/net/socket.c    Mon Oct  2 14:25:13 1995
  7520. @@ -64,6 +64,8 @@
  7521.  #include <linux/netdevice.h>
  7522.  #include <linux/proc_fs.h>
  7523.  
  7524. +#include <net/netlink.h>
  7525. +
  7526.  #include <asm/system.h>
  7527.  #include <asm/segment.h>
  7528.  
  7529. @@ -1285,13 +1287,21 @@
  7530.  {
  7531.      int i;
  7532.  
  7533. -    printk("Swansea University Computer Society NET3.031 Snap #1 for Linux 1.3.25\n");
  7534. +    printk("Swansea University Computer Society NET3.031 Snap #3 for Linux 1.3.30\n");
  7535.  
  7536.      /*
  7537.       *    Initialize all address (protocol) families. 
  7538.       */
  7539.       
  7540.      for (i = 0; i < NPROTO; ++i) pops[i] = NULL;
  7541. +    
  7542. +    /*
  7543. +     *    The netlink device handler may be needed early.
  7544. +     */
  7545. +
  7546. +#ifdef CONFIG_NETLINK
  7547. +    init_netlink();
  7548. +#endif         
  7549.  
  7550.      /*
  7551.       *    Initialize the protocols module. 
  7552.