home *** CD-ROM | disk | FTP | other *** search
/ Il CD di internet / CD.iso / SOURCE / KERNEL-S / V1.0 / PATCH3.GZ / patch3
Encoding:
Text File  |  1994-03-21  |  25.5 KB  |  827 lines
  1. diff -u --recursive --new-file v1.0.2/linux/CREDITS linux/CREDITS
  2. --- v1.0.2/linux/CREDITS    Fri Mar 18 10:21:32 1994
  3. +++ linux/CREDITS    Sat Mar 19 20:01:34 1994
  4. @@ -403,6 +403,15 @@
  5.  S: FIN-00330 Helsingfors
  6.  S: Finland
  7.  
  8. +N: Kai Petzke
  9. +E: wpp@marie.physik.tu-berlin.de
  10. +D: Driver for Laser Magnetic Storage CD-ROM
  11. +D: Some kernel bug fixes, new swapping routine
  12. +D: Port of the database Postgres
  13. +S: Stresemannstr. 62
  14. +S: 10963 Berlin
  15. +S: Germany
  16. +
  17.  N: Stefan Probst
  18.  E: snprobst@immd4.informatik.uni-erlangen.de
  19.  D: The Linux Support Team Erlangen
  20. diff -u --recursive --new-file v1.0.2/linux/Makefile linux/Makefile
  21. --- v1.0.2/linux/Makefile    Mon Mar 21 16:36:20 1994
  22. +++ linux/Makefile    Mon Mar 21 17:05:21 1994
  23. @@ -1,6 +1,6 @@
  24.  VERSION = 1
  25.  PATCHLEVEL = 0
  26. -SUBLEVEL = 2
  27. +SUBLEVEL = 3
  28.  
  29.  all:    Version zImage
  30.  
  31. diff -u --recursive --new-file v1.0.2/linux/drivers/char/lp.c linux/drivers/char/lp.c
  32. --- v1.0.2/linux/drivers/char/lp.c    Fri Mar 18 10:21:33 1994
  33. +++ linux/drivers/char/lp.c    Mon Mar 21 16:26:07 1994
  34. @@ -445,10 +445,10 @@
  35.          for (testvalue = 0 ; testvalue < LP_DELAY ; testvalue++)
  36.              ;
  37.          testvalue = inb_p(LP_B(offset));
  38. -        if (testvalue != 255) {
  39. +        if (testvalue == LP_DUMMY) {
  40.              LP_F(offset) |= LP_EXIST;
  41.              lp_reset(offset);
  42. -            printk("lp_init: lp%d exists (%d), ", offset, testvalue);
  43. +            printk("lp_init: lp%d exists, ", offset);
  44.              if (LP_IRQ(offset))
  45.                  printk("using IRQ%d\n", LP_IRQ(offset));
  46.              else
  47. diff -u --recursive --new-file v1.0.2/linux/drivers/net/slip.c linux/drivers/net/slip.c
  48. --- v1.0.2/linux/drivers/net/slip.c    Mon Mar 14 11:30:53 1994
  49. +++ linux/drivers/net/slip.c    Mon Mar 21 16:16:10 1994
  50. @@ -1102,9 +1102,9 @@
  51.    DPRINTF((DBG_SLIP, "SLIP: ioctl(%d, 0x%X, 0x%X)\n", tty->line, cmd, arg));
  52.    switch(cmd) {
  53.      case SIOCGIFNAME:
  54. -        err=verify_area(VERIFY_WRITE, arg, 16);
  55. +        err=verify_area(VERIFY_WRITE, arg, strlen(sl->dev->name) + 1);
  56.          if(err)
  57. -            return -err;
  58. +            return err;
  59.          memcpy_tofs(arg, sl->dev->name, strlen(sl->dev->name) + 1);
  60.          return(0);
  61.      case SIOCGIFENCAP:
  62. diff -u --recursive --new-file v1.0.2/linux/drivers/scsi/sg.c linux/drivers/scsi/sg.c
  63. --- v1.0.2/linux/drivers/scsi/sg.c    Mon Mar 21 16:36:21 1994
  64. +++ linux/drivers/scsi/sg.c    Sat Mar 19 19:29:14 1994
  65. @@ -56,7 +56,7 @@
  66.   {
  67.    int dev = MINOR(inode->i_rdev);
  68.    if ((dev<0) || (dev>=NR_SG))
  69. -   return -ENXIO
  70. +   return -ENXIO;
  71.    switch(cmd_in)
  72.     {
  73.      case SG_SET_TIMEOUT:
  74. diff -u --recursive --new-file v1.0.2/linux/drivers/scsi/sr_ioctl.c linux/drivers/scsi/sr_ioctl.c
  75. --- v1.0.2/linux/drivers/scsi/sr_ioctl.c    Mon Mar 21 16:36:21 1994
  76. +++ linux/drivers/scsi/sr_ioctl.c    Mon Mar 21 16:13:13 1994
  77. @@ -95,7 +95,7 @@
  78.          u_char     sr_cmd[10];
  79.  
  80.      int dev = inode->i_rdev;
  81. -    int result, target;
  82. +    int result, target, err;
  83.  
  84.      target = MINOR(dev);
  85.      if (target >= NR_SR) return -ENXIO;
  86. @@ -192,7 +192,9 @@
  87.  
  88.              scsi_free(buffer, 512);
  89.  
  90. -            verify_area (VERIFY_WRITE, (void *) arg, sizeof (struct cdrom_tochdr));
  91. +            err = verify_area (VERIFY_WRITE, (void *) arg, sizeof (struct cdrom_tochdr));
  92. +            if (err)
  93. +                return err;
  94.              memcpy_tofs ((void *) arg, &tochdr, sizeof (struct cdrom_tochdr));
  95.              
  96.              return result;
  97. @@ -230,7 +232,9 @@
  98.  
  99.              scsi_free(buffer, 512);
  100.  
  101. -            verify_area (VERIFY_WRITE, (void *) arg, sizeof (struct cdrom_tocentry));
  102. +            err = verify_area (VERIFY_WRITE, (void *) arg, sizeof (struct cdrom_tocentry));
  103. +            if (err)
  104. +                return err;
  105.              memcpy_tofs ((void *) arg, &tocentry, sizeof (struct cdrom_tocentry));
  106.  
  107.              return result;
  108. @@ -369,7 +373,9 @@
  109.  
  110.                scsi_free(buffer, 512);
  111.  
  112. -              verify_area (VERIFY_WRITE, (void *) arg, sizeof (struct cdrom_subchnl));
  113. +              err = verify_area (VERIFY_WRITE, (void *) arg, sizeof (struct cdrom_subchnl));
  114. +              if (err)
  115. +                  return err;
  116.                memcpy_tofs ((void *) arg, &subchnl, sizeof (struct cdrom_subchnl));
  117.                return result;
  118.              }
  119. diff -u --recursive --new-file v1.0.2/linux/fs/ext2/ioctl.c linux/fs/ext2/ioctl.c
  120. --- v1.0.2/linux/fs/ext2/ioctl.c    Fri Dec 31 11:59:49 1993
  121. +++ linux/fs/ext2/ioctl.c    Mon Mar 21 16:13:13 1994
  122. @@ -17,11 +17,14 @@
  123.  int ext2_ioctl (struct inode * inode, struct file * filp, unsigned int cmd,
  124.          unsigned long arg)
  125.  {
  126. +    int err;
  127.  
  128.      ext2_debug ("cmd = %u, arg = %lu\n", cmd, arg);
  129.  
  130.      switch (cmd) {
  131.      case EXT2_IOC_GETFLAGS:
  132. +        if ((err = verify_area (VERIFY_WRITE, (long *) arg, sizeof(long))))
  133. +            return err;
  134.          put_fs_long (inode->u.ext2_i.i_flags, (long *) arg);
  135.          return 0;
  136.      case EXT2_IOC_SETFLAGS:
  137. @@ -34,6 +37,8 @@
  138.          inode->i_dirt = 1;
  139.          return 0;
  140.      case EXT2_IOC_GETVERSION:
  141. +        if ((err = verify_area (VERIFY_WRITE, (long *) arg, sizeof(long))))
  142. +            return err;
  143.          put_fs_long (inode->u.ext2_i.i_version, (long *) arg);
  144.          return 0;
  145.      case EXT2_IOC_SETVERSION:
  146. diff -u --recursive --new-file v1.0.2/linux/include/linux/mm.h linux/include/linux/mm.h
  147. --- v1.0.2/linux/include/linux/mm.h    Mon Feb 14 21:27:12 1994
  148. +++ linux/include/linux/mm.h    Sun Mar 20 22:13:06 1994
  149. @@ -73,6 +73,25 @@
  150.  #define BAD_PAGE __bad_page()
  151.  #define ZERO_PAGE __zero_page()
  152.  
  153. +/* planning stage.. */
  154. +#define P_DIRTY        0x0001
  155. +#define P_LOCKED    0x0002
  156. +#define P_UPTODATE    0x0004
  157. +#define P_RESERVED    0x8000
  158. +
  159. +struct page_info {
  160. +    unsigned short flags;
  161. +    unsigned short count;
  162. +    struct inode * inode;
  163. +    unsigned long offset;
  164. +    struct page_info * next_same_inode;
  165. +    struct page_info * prev_same_inode;
  166. +    struct page_info * next_hash;
  167. +    struct page_info * prev_hash;
  168. +    struct wait_queue *wait;
  169. +};
  170. +/* end of planning stage */
  171. +
  172.  extern volatile short free_page_ptr; /* used by malloc and tcp/ip. */
  173.  
  174.  extern int nr_swap_pages;
  175. @@ -189,7 +208,7 @@
  176.  
  177.  
  178.  /* vm_ops not present page codes */
  179. -#define SHM_SWP_TYPE 0x41        
  180. +#define SHM_SWP_TYPE 0x41
  181.  extern void shm_no_page (ulong *);
  182.  
  183.  #endif
  184. diff -u --recursive --new-file v1.0.2/linux/ipc/sem.c linux/ipc/sem.c
  185. --- v1.0.2/linux/ipc/sem.c    Mon Dec 27 16:22:39 1993
  186. +++ linux/ipc/sem.c    Mon Mar 21 16:16:11 1994
  187. @@ -235,7 +235,7 @@
  188.          case GETALL:
  189.              if (!arg || ! (array = (ushort *) get_fs_long((int *) arg)))
  190.                  return -EFAULT;
  191. -            i = verify_area (VERIFY_WRITE, array, nsems* sizeof(short));
  192. +            i = verify_area (VERIFY_WRITE, array, nsems*sizeof(short));
  193.              if (i)
  194.                  return i;
  195.          }
  196. @@ -266,7 +266,7 @@
  197.      case IPC_STAT:
  198.          if (!arg || !(buf = (struct semid_ds *) get_fs_long((int *) arg))) 
  199.              return -EFAULT;
  200. -        if ((i = verify_area (VERIFY_WRITE, arg, sizeof tbuf)))
  201. +        if ((i = verify_area (VERIFY_WRITE, buf, sizeof(*sma))))
  202.              return i;
  203.          break;
  204.      case IPC_SET:
  205. diff -u --recursive --new-file v1.0.2/linux/kernel/sched.c linux/kernel/sched.c
  206. --- v1.0.2/linux/kernel/sched.c    Mon Mar 21 16:36:22 1994
  207. +++ linux/kernel/sched.c    Fri Mar 18 11:18:45 1994
  208. @@ -772,7 +772,7 @@
  209.  
  210.  static void show_task(int nr,struct task_struct * p)
  211.  {
  212. -    int free;
  213. +    unsigned long free;
  214.      static char * stat_nam[] = { "R", "S", "D", "Z", "T", "W" };
  215.  
  216.      printk("%-8s %3d ", p->comm, (p == current) ? -nr : nr);
  217. diff -u --recursive --new-file v1.0.2/linux/kernel/sys.c linux/kernel/sys.c
  218. --- v1.0.2/linux/kernel/sys.c    Fri Mar  4 17:10:58 1994
  219. +++ linux/kernel/sys.c    Mon Mar 21 16:13:14 1994
  220. @@ -166,9 +166,14 @@
  221.  {
  222.      struct vm86_struct info;
  223.      struct pt_regs * pt_regs = (struct pt_regs *) &v86;
  224. +    int error;
  225.  
  226.      if (current->saved_kernel_stack)
  227.          return -EPERM;
  228. +    /* v86 must be readable (now) and writable (for save_v86_state) */
  229. +    error = verify_area(VERIFY_WRITE,v86,sizeof(*v86));
  230. +    if (error)
  231. +        return error;
  232.      memcpy_fromfs(&info,v86,sizeof(info));
  233.  /*
  234.   * make sure the vm86() system call doesn't try to do anything silly
  235. diff -u --recursive --new-file v1.0.2/linux/lib/malloc.c linux/lib/malloc.c
  236. --- v1.0.2/linux/lib/malloc.c    Wed Dec  1 14:44:15 1993
  237. +++ linux/lib/malloc.c
  238. @@ -1,540 +0,0 @@
  239. -/*
  240. - * malloc.c --- a general purpose kernel memory allocator for Linux.
  241. - *
  242. - * Written by Theodore Ts'o (tytso@mit.edu), 11/29/91
  243. - *
  244. - * This routine is written to be as fast as possible, so that it
  245. - * can be called from the interrupt level.
  246. - *
  247. - * Limitations: maximum size of memory we can allocate using this routine
  248. - *    is 4k, the size of a page in Linux.
  249. - *
  250. - * The general game plan is that each page (called a bucket) will only hold
  251. - * objects of a given size.  When all of the object on a page are released,
  252. - * the page can be returned to the general free pool.  When kmalloc() is
  253. - * called, it looks for the smallest bucket size which will fulfill its
  254. - * request, and allocate a piece of memory from that bucket pool.
  255. - *
  256. - * Each bucket has as its control block a bucket descriptor which keeps
  257. - * track of how many objects are in use on that page, and the free list
  258. - * for that page.  Like the buckets themselves, bucket descriptors are
  259. - * stored on pages requested from get_free_page().  However, unlike buckets,
  260. - * pages devoted to bucket descriptor pages are never released back to the
  261. - * system.  Fortunately, a system should probably only need 1 or 2 bucket
  262. - * descriptor pages, since a page can hold 256 bucket descriptors (which
  263. - * corresponds to 1 megabyte worth of bucket pages.)  If the kernel is using
  264. - * that much allocated memory, it's probably doing something wrong.  :-)
  265. - *
  266. - * Note: kmalloc() and kfree() both call get_free_page() and free_page()
  267. - *    in sections of code where interrupts are turned off, to allow
  268. - *    kmalloc() and kfree() to be safely called from an interrupt routine.
  269. - *    (We will probably need this functionality when networking code,
  270. - *    particularily things like NFS, is added to Linux.)  However, this
  271. - *    presumes that get_free_page() and free_page() are interrupt-level
  272. - *    safe, which they may not be once paging is added.  If this is the
  273. - *    case, we will need to modify kmalloc() to keep a few unused pages
  274. - *    "pre-allocated" so that it can safely draw upon those pages if
  275. - *     it is called from an interrupt routine.
  276. - *
  277. - *     Another concern is that get_free_page() should not sleep; if it
  278. - *    does, the code is carefully ordered so as to avoid any race
  279. - *    conditions.  The catch is that if kmalloc() is called re-entrantly,
  280. - *    there is a chance that unecessary pages will be grabbed from the
  281. - *    system.  Except for the pages for the bucket descriptor page, the
  282. - *    extra pages will eventually get released back to the system, though,
  283. - *    so it isn't all that bad.
  284. - */
  285. -
  286. -/* I'm going to modify it to keep some free pages around.  Get free page
  287. -   can sleep, and tcp/ip needs to call kmalloc at interrupt time  (Or keep
  288. -   big buffers around for itself.)  I guess I'll have return from
  289. -   syscall fill up the free page descriptors. -RAB */
  290. -
  291. -/* since the advent of GFP_ATOMIC, I've changed the kmalloc code to
  292. -   use it and return NULL if it can't get a page. -RAB  */
  293. -/* (mostly just undid the previous changes -RAB) */
  294. -
  295. -/* I've added the priority argument to kmalloc so routines can
  296. -   sleep on memory if they want. - RAB */
  297. -
  298. -/* I've also got to make sure that kmalloc is reentrant now. */
  299. -
  300. -/* Debugging support: add file/line info, add beginning+end markers. -M.U- */
  301. -
  302. -#include <linux/kernel.h>
  303. -#include <linux/mm.h>
  304. -#include <linux/string.h>
  305. -#include <linux/malloc.h>
  306. -
  307. -#include <asm/system.h>
  308. -
  309. -struct bucket_desc {    /* 16 bytes */
  310. -    void            *page;
  311. -    struct bucket_desc    *next;
  312. -    void            *freeptr;
  313. -    unsigned short        refcnt;
  314. -    unsigned short        bucket_size;
  315. -};
  316. -
  317. -struct _bucket_dir {    /* 8 bytes */
  318. -    unsigned int        size;
  319. -    struct bucket_desc    *chain;
  320. -};
  321. -
  322. -#ifdef CONFIG_DEBUG_MALLOC
  323. -
  324. -struct hdr_start {
  325. -    const char *file;
  326. -    const char *ok_file;
  327. -    unsigned short line;
  328. -    unsigned short ok_line;
  329. -    unsigned short size;
  330. -    int magic;
  331. -};
  332. -struct hdr_end {
  333. -    int magic;
  334. -};
  335. -
  336. -#define DEB_MAGIC_FREE  0x13579BDF /* free block */
  337. -#define DEB_MAGIC_ALLOC 0x2468ACE0 /* allocated block */
  338. -#define DEB_MAGIC_USED  0x147AD036 /* allocated but bad */
  339. -#define DEB_MAGIC_FREED 0x258BE169 /* free but abused */
  340. -
  341. -#define DEB_MAGIC_END   0x369CF258 /* end marker */
  342. -
  343. -#endif
  344. -/*
  345. - * The following is the where we store a pointer to the first bucket
  346. - * descriptor for a given size.
  347. - *
  348. - * If it turns out that the Linux kernel allocates a lot of objects of a
  349. - * specific size, then we may want to add that specific size to this list,
  350. - * since that will allow the memory to be allocated more efficiently.
  351. - * However, since an entire page must be dedicated to each specific size
  352. - * on this list, some amount of temperance must be exercised here.
  353. - *
  354. - * Note that this list *must* be kept in order.
  355. - */
  356. -struct _bucket_dir bucket_dir[] = {
  357. -#ifndef CONFIG_DEBUG_MALLOC /* Debug headers have too much overhead */
  358. -    { 16,    (struct bucket_desc *) 0},
  359. -#endif
  360. -    { 32,    (struct bucket_desc *) 0},
  361. -    { 64,    (struct bucket_desc *) 0},
  362. -    { 128,    (struct bucket_desc *) 0},
  363. -    { 256,    (struct bucket_desc *) 0},
  364. -    { 512,    (struct bucket_desc *) 0},
  365. -    { 1024,    (struct bucket_desc *) 0},
  366. -    { 2048, (struct bucket_desc *) 0},
  367. -    { 4096, (struct bucket_desc *) 0},
  368. -    { 0,    (struct bucket_desc *) 0}};   /* End of list marker */
  369. -
  370. -/*
  371. - * This contains a linked list of free bucket descriptor blocks
  372. - */
  373. -static struct bucket_desc *free_bucket_desc = (struct bucket_desc *) 0;
  374. -
  375. -/*
  376. - * This routine initializes a bucket description page.
  377. - */
  378. -
  379. -/* It assumes it is called with interrupts on. and will
  380. -   return that way.  It also can sleep if priority != GFP_ATOMIC. */
  381. - 
  382. -static inline void init_bucket_desc(unsigned long page)
  383. -{
  384. -    struct bucket_desc *bdesc;
  385. -    int i;
  386. -
  387. -    bdesc = (struct bucket_desc *) page;
  388. -    for (i = PAGE_SIZE/sizeof(struct bucket_desc); --i > 0; bdesc++ )
  389. -        bdesc->next = bdesc+1;
  390. -    /*
  391. -     * This is done last, to avoid race conditions in case
  392. -     * get_free_page() sleeps and this routine gets called again....
  393. -     */
  394. -    cli();
  395. -    bdesc->next = free_bucket_desc;
  396. -    free_bucket_desc = (struct bucket_desc *) page;
  397. -}
  398. -
  399. -/*
  400. - * Re-organized some code to give cleaner assembly output for easier
  401. - * verification.. LBT
  402. - */
  403. -#ifdef CONFIG_DEBUG_MALLOC
  404. -void *
  405. -deb_kmalloc(const char *deb_file, unsigned short deb_line,
  406. -    unsigned int len, int priority)
  407. -#else
  408. -void *
  409. -kmalloc(unsigned int len, int priority)
  410. -#endif
  411. -{
  412. -    int i;
  413. -    unsigned long        flags;
  414. -    unsigned long        page;
  415. -    struct _bucket_dir    *bdir;
  416. -    struct bucket_desc    *bdesc;
  417. -    void            *retval;
  418. -
  419. -#ifdef CONFIG_DEBUG_MALLOC
  420. -    len += sizeof(struct hdr_start)+sizeof(struct hdr_end);
  421. -#endif
  422. -    /*
  423. -     * First we search the bucket_dir to find the right bucket change
  424. -     * for this request.
  425. -     */
  426. -
  427. -    /* The sizes are static so there is no reentry problem here. */
  428. -    bdir = bucket_dir;
  429. -    for (bdir = bucket_dir ; bdir->size < len ; bdir++) {
  430. -        if (!bdir->size)
  431. -            goto too_large;
  432. -    }
  433. -
  434. -    /*
  435. -     * Now we search for a bucket descriptor which has free space
  436. -     */
  437. -    save_flags(flags);
  438. -    cli();            /* Avoid race conditions */
  439. -    for (bdesc = bdir->chain; bdesc != NULL; bdesc = bdesc->next)
  440. -        if (bdesc->freeptr)
  441. -            goto found_bdesc;
  442. -    /*
  443. -     * If we didn't find a bucket with free space, then we'll
  444. -     * allocate a new one.
  445. -     */
  446. -    
  447. -    /*
  448. -     * Note that init_bucket_descriptor() does its
  449. -     * own cli() before returning, and guarantees that
  450. -     * there is a bucket desc in the page.
  451. -     */
  452. -    if (!free_bucket_desc) {
  453. -        restore_flags(flags);
  454. -        if(!(page=__get_free_page(priority)))
  455. -            return NULL;
  456. -        init_bucket_desc(page);
  457. -    }
  458. -    
  459. -    bdesc = free_bucket_desc;
  460. -    free_bucket_desc = bdesc->next;
  461. -    restore_flags(flags);
  462. -
  463. -    if(!(page=__get_free_page(priority))) {
  464. -    /*
  465. -     * Out of memory? Put the bucket descriptor back on the free list
  466. -     */
  467. -        cli();
  468. -        bdesc->next = free_bucket_desc;
  469. -        free_bucket_desc = bdesc;
  470. -        restore_flags(flags);
  471. -        return NULL;
  472. -    }
  473. -        
  474. -    bdesc->refcnt = 0;
  475. -    bdesc->bucket_size = bdir->size;
  476. -    bdesc->page = bdesc->freeptr = (void *) page;
  477. -    
  478. -    /* Set up the chain of free objects */
  479. -    for (i=PAGE_SIZE/bdir->size; i > 0 ; i--) {
  480. -#ifdef CONFIG_DEBUG_MALLOC
  481. -        struct hdr_start *hd;
  482. -        struct hdr_end *he;
  483. -        hd = (struct hdr_start *) page;
  484. -        he = (struct hdr_end *)(page+(bdir->size-sizeof(struct hdr_end)));
  485. -        hd->magic = DEB_MAGIC_FREE;
  486. -        hd->file = hd->ok_file = "(expand)"; 
  487. -        hd->line = hd->ok_line = 0;
  488. -        hd->size = bdir->size-sizeof(struct hdr_start)-sizeof(struct hdr_end);
  489. -        he->magic = DEB_MAGIC_END;
  490. -
  491. -        memset(hd+1,0xF8,hd->size);
  492. -
  493. -        *((void **) (hd+1)) = (i==1) ? NULL : (void *)(page + bdir->size);
  494. -#else
  495. -        *((void **) page) = (i==1) ? NULL : (void *)(page + bdir->size);
  496. -#endif
  497. -        page += bdir->size;
  498. -    }
  499. -    
  500. -    /* turn interrupts back off for putting the
  501. -       thing onto the chain. */
  502. -    cli();
  503. -    /* remember bdir is not changed. */
  504. -    bdesc->next = bdir->chain; /* OK, link it in! */
  505. -    bdir->chain = bdesc;
  506. -
  507. -found_bdesc:
  508. -    retval = (void *) bdesc->freeptr;
  509. -#ifdef CONFIG_DEBUG_MALLOC
  510. -    bdesc->freeptr = *((void **) (((char *)retval)+sizeof(struct hdr_start)));
  511. -#else
  512. -    bdesc->freeptr = *((void **) retval);
  513. -#endif
  514. -    bdesc->refcnt++;
  515. -    restore_flags(flags);    /* OK, we're safe again */
  516. -#ifdef CONFIG_DEBUG_MALLOC
  517. -    {
  518. -        struct hdr_start *hd;
  519. -        struct hdr_end *he;
  520. -
  521. -        hd = (struct hdr_start *) retval;
  522. -        retval = hd+1;
  523. -        len -= sizeof(struct hdr_start)+sizeof(struct hdr_end);
  524. -        if(hd->magic != DEB_MAGIC_FREE && hd->magic != DEB_MAGIC_FREED) {
  525. -            printk("DEB_MALLOC allocating %s block 0x%x (head 0x%x) from %s:%d, magic %x\n",
  526. -                (hd->magic == DEB_MAGIC_ALLOC) ? "nonfree" : "trashed", 
  527. -                retval,hd,deb_file,deb_line,hd->magic);
  528. -            return NULL;
  529. -        }
  530. -        if(len > hd->size || len > bdir->size-sizeof(struct hdr_start)-sizeof(struct hdr_end)) {
  531. -            printk("DEB_MALLOC got %x:%x-byte block, wanted %x, from %s:%d, last %s:%d\n",
  532. -                hd->size,bdir->size,len,hd->file,hd->line,deb_file,deb_line);
  533. -            return NULL;
  534. -        }
  535. -        {
  536. -            unsigned char *x = (unsigned char *) retval;
  537. -            unsigned short pos = 4;
  538. -            x += pos;
  539. -            while(pos < hd->size) {
  540. -                if(*x++ != 0xF8) {
  541. -                    printk("DEB_MALLOC used 0x%x:%x(%x) while free, from %s:%d\n",
  542. -                        retval,pos,hd->size,hd->file,hd->line);
  543. -                    return NULL;
  544. -                }
  545. -                pos++;
  546. -            }
  547. -        }
  548. -        he = (struct hdr_end *)(((char *)retval)+hd->size);
  549. -        if(he->magic != DEB_MAGIC_END) {
  550. -            printk("DEB_MALLOC overran 0x%x:%d while free, from %s:%d\n",retval,hd->size,hd->file,hd->line);
  551. -        }
  552. -        memset(retval, 0xf0, len);
  553. -        he = (struct hdr_end *)(((char *)retval)+len);
  554. -        hd->file = hd->ok_file = deb_file;
  555. -        hd->line = hd->ok_line = deb_line;
  556. -        hd->size = len;
  557. -        hd->magic = DEB_MAGIC_ALLOC;
  558. -        he->magic = DEB_MAGIC_END;
  559. -    }
  560. -#endif
  561. -    return retval;
  562. -
  563. -too_large:
  564. -       /* This should be changed for sizes > 1 page. */
  565. -    printk("kmalloc called with impossibly large argument (%d)\n", len);
  566. -    return NULL;
  567. -}
  568. -
  569. -#ifdef CONFIG_DEBUG_MALLOC
  570. -void deb_kcheck_s(const char *deb_file, unsigned short deb_line,
  571. -    void *obj, int size)
  572. -{
  573. -    struct hdr_start *hd;
  574. -    struct hdr_end *he;
  575. -
  576. -    if (!obj)
  577. -        return;
  578. -    hd = (struct hdr_start *) obj;
  579. -    hd--;
  580. -
  581. -    if(hd->magic != DEB_MAGIC_ALLOC) {
  582. -        if(hd->magic == DEB_MAGIC_FREE) {
  583. -            printk("DEB_MALLOC Using free block of 0x%x at %s:%d, by %s:%d, wasOK %s:%d\n",
  584. -                obj,deb_file,deb_line,hd->file,hd->line,hd->ok_file,hd->ok_line);
  585. -            /* For any other condition it is either superfluous or dangerous to print something. */
  586. -            hd->magic = DEB_MAGIC_FREED;
  587. -        }
  588. -        return;
  589. -    }
  590. -    if(hd->size != size) {
  591. -        if(size != 0) {
  592. -            printk("DEB_MALLOC size for 0x%x given as %d, stored %d, at %s:%d, wasOK %s:%d\n",
  593. -                obj,size,hd->size,deb_file,deb_line,hd->ok_file,hd->ok_line);
  594. -        }
  595. -        size = hd->size;
  596. -    }
  597. -    he = (struct hdr_end *)(((char *)obj)+size);
  598. -    if(he->magic != DEB_MAGIC_END) {
  599. -        printk("DEB_MALLOC overran block 0x%x:%d, at %s:%d, wasOK %s:%d\n",
  600. -            obj,hd->size,deb_file,deb_line,hd->ok_file,hd->ok_line);
  601. -        hd->magic = DEB_MAGIC_USED;
  602. -        return;
  603. -    }
  604. -    hd->ok_file = deb_file;
  605. -    hd->ok_line = deb_line;
  606. -}
  607. -#endif
  608. -
  609. -/*
  610. - * Here is the kfree routine.  If you know the size of the object that you
  611. - * are freeing, then kfree_s() will use that information to speed up the
  612. - * search for the bucket descriptor.
  613. - *
  614. - * We will #define a macro so that "kfree(x)" is becomes "kfree_s(x, 0)"
  615. - */
  616. -#ifdef CONFIG_DEBUG_MALLOC
  617. -void deb_kfree_s(const char *deb_file, unsigned short deb_line,
  618. -    void *obj, int size)
  619. -#else
  620. -void kfree_s(void *obj, int size)
  621. -#endif
  622. -{
  623. -    unsigned long        flags;
  624. -    void            *page;
  625. -    struct _bucket_dir    *bdir;
  626. -    struct bucket_desc    *bdesc, *prev;
  627. -
  628. -    if (!obj)
  629. -        return;
  630. -#ifdef CONFIG_DEBUG_MALLOC
  631. -    {
  632. -        struct hdr_start *hd;
  633. -        struct hdr_end *he;
  634. -        hd = (struct hdr_start *) obj;
  635. -        hd--;
  636. -
  637. -        if(hd->magic == DEB_MAGIC_FREE) {
  638. -            printk("DEB_MALLOC dup free of 0x%x at %s:%d by %s:%d, wasOK %s:%d\n",
  639. -                    obj,deb_file,deb_line,hd->file,hd->line,hd->ok_file,hd->ok_line);
  640. -            return;
  641. -        }
  642. -        if(hd->size != size) {
  643. -            if(size != 0) {
  644. -                if(hd->magic != DEB_MAGIC_USED)
  645. -                    printk("DEB_MALLOC size for 0x%x given as %d, stored %d, at %s:%d, wasOK %s:%d\n",
  646. -                        obj,size,hd->size,deb_file,deb_line,hd->ok_file,hd->ok_line);
  647. -            }
  648. -            size = hd->size;
  649. -        }
  650. -        he = (struct hdr_end *)(((char *)obj)+size);
  651. -        if(he->magic != DEB_MAGIC_END) {
  652. -            if(hd->magic != DEB_MAGIC_USED)
  653. -                printk("DEB_MALLOC overran block 0x%x:%d, at %s:%d, from %s:%d, wasOK %s:%d\n",
  654. -                    obj,hd->size,deb_file,deb_line,hd->file,hd->line,hd->ok_file,hd->ok_line);
  655. -        }
  656. -        size += sizeof(struct hdr_start)+sizeof(struct hdr_end);
  657. -    }
  658. -#endif
  659. -    save_flags(flags);
  660. -    /* Calculate what page this object lives in */
  661. -    page = (void *)  ((unsigned long) obj & PAGE_MASK);
  662. -
  663. -    /* Now search the buckets looking for that page */
  664. -    for (bdir = bucket_dir; bdir->size; bdir++) {
  665. -        prev = 0;
  666. -        /* If size is zero then this conditional is always true */
  667. -        if (bdir->size >= size) {
  668. -        /* We have to turn off interrupts here because
  669. -           we are descending the chain.  If something
  670. -           changes it in the middle we could suddenly
  671. -           find ourselves descending the free list.
  672. -           I think this would only cause a memory
  673. -           leak, but better safe than sorry. */
  674. -        cli(); /* To avoid race conditions */
  675. -        for (bdesc = bdir->chain; bdesc; bdesc = bdesc->next) {
  676. -            if (bdesc->page == page)
  677. -            goto found;
  678. -            prev = bdesc;
  679. -        }
  680. -        }
  681. -    }
  682. -
  683. -    restore_flags(flags);
  684. -    printk("Bad address passed to kernel kfree_s(%p, %d)\n",obj, size);
  685. -#ifdef CONFIG_DEBUG_MALLOC
  686. -    printk("Offending code: %s:%d\n",deb_file,deb_line);
  687. -#else
  688. -    printk("Offending eip: %08x\n",((unsigned long *) &obj)[-1]);
  689. -#endif
  690. -    return;
  691. -
  692. -found:
  693. -    /* interrupts are off here. */
  694. -#ifdef CONFIG_DEBUG_MALLOC
  695. -
  696. -    {
  697. -        struct hdr_start *hd;
  698. -        struct hdr_end *he;
  699. -        hd = (struct hdr_start *) obj;
  700. -        hd--;
  701. -        
  702. -        hd->file = deb_file;
  703. -        hd->line = deb_line;
  704. -        hd->magic = DEB_MAGIC_FREE;
  705. -        hd->size = bdir->size-sizeof(struct hdr_start)-sizeof(struct hdr_end);
  706. -        he = (struct hdr_end *)(((char *)obj)+hd->size);
  707. -        memset(obj, 0xf8, hd->size);
  708. -        he->magic = DEB_MAGIC_END;
  709. -        *((void **)obj) = bdesc->freeptr;
  710. -        obj = hd;
  711. -    }
  712. -#else
  713. -    *((void **)obj) = bdesc->freeptr;
  714. -#endif
  715. -
  716. -    bdesc->freeptr = obj;
  717. -    bdesc->refcnt--;
  718. -    if (bdesc->refcnt == 0) {
  719. -        /*
  720. -         * We need to make sure that prev is still accurate.  It
  721. -         * may not be, if someone rudely interrupted us....
  722. -         */
  723. -        if ((prev && (prev->next != bdesc)) ||
  724. -            (!prev && (bdir->chain != bdesc)))
  725. -            for (prev = bdir->chain; prev; prev = prev->next)
  726. -                if (prev->next == bdesc)
  727. -                    break;
  728. -        if (prev)
  729. -            prev->next = bdesc->next;
  730. -        else {
  731. -            if (bdir->chain != bdesc)
  732. -                panic("kmalloc bucket chains corrupted");
  733. -            bdir->chain = bdesc->next;
  734. -        }
  735. -        bdesc->next = free_bucket_desc;
  736. -        free_bucket_desc = bdesc;
  737. -        free_page((unsigned long) bdesc->page);
  738. -    }
  739. -    restore_flags(flags);
  740. -    return;
  741. -}
  742. -
  743. -#ifdef CONFIG_DEBUG_MALLOC
  744. -int get_malloc(char *buffer)
  745. -{
  746. -    int len = 0;
  747. -    int i;
  748. -    unsigned long        flags;
  749. -    void            *page;
  750. -    struct _bucket_dir    *bdir;
  751. -    struct bucket_desc    *bdesc;
  752. -
  753. -    save_flags(flags);
  754. -    cli(); /* To avoid race conditions */
  755. -    for (bdir = bucket_dir; bdir->size; bdir++) {
  756. -        for (bdesc = bdir->chain; bdesc; bdesc = bdesc->next) {
  757. -            page = bdesc->page;
  758. -            for (i=PAGE_SIZE/bdir->size; i > 0 ; i--) {
  759. -                struct hdr_start *hd;
  760. -                hd = (struct hdr_start *)page;
  761. -                if(hd->magic == DEB_MAGIC_ALLOC) {
  762. -                    if(len > PAGE_SIZE-80) {
  763. -                        restore_flags(flags);
  764. -                        len += sprintf(buffer+len,"...\n");
  765. -                        return len;
  766. -                    }
  767. -                    len += sprintf(buffer+len,"%08x:%03x %s:%d %s:%d\n",
  768. -                        (long)(page+sizeof(struct hdr_start)),hd->size,hd->file,hd->line,hd->ok_file,hd->ok_line);
  769. -                }
  770. -                page += bdir->size;
  771. -            }
  772. -        }
  773. -    }
  774. -
  775. -    restore_flags(flags);
  776. -    return len;
  777. -}
  778. -#endif
  779. diff -u --recursive --new-file v1.0.2/linux/net/inet/dev.c linux/net/inet/dev.c
  780. --- v1.0.2/linux/net/inet/dev.c    Fri Mar 18 10:21:34 1994
  781. +++ linux/net/inet/dev.c    Mon Mar 21 16:13:14 1994
  782. @@ -745,6 +745,9 @@
  783.    memcpy_fromfs(&ifc, arg, sizeof(struct ifconf));
  784.    len = ifc.ifc_len;
  785.    pos = ifc.ifc_buf;
  786. +  err=verify_area(VERIFY_WRITE, pos, len);
  787. +  if(err)
  788. +    return err;
  789.  
  790.    /* Loop over the interfaces, and write an info block for each. */
  791.    for (dev = dev_base; dev != NULL; dev = dev->next) {
  792. diff -u --recursive --new-file v1.0.2/linux/net/inet/ip.c linux/net/inet/ip.c
  793. --- v1.0.2/linux/net/inet/ip.c    Fri Mar 18 10:21:34 1994
  794. +++ linux/net/inet/ip.c    Mon Mar 21 14:50:37 1994
  795. @@ -1000,7 +1000,9 @@
  796.         DPRINTF((DBG_IP, "    DEV=%s, MTU=%d, LEN=%d SRC=%s",
  797.           dev->name, dev->mtu, left, in_ntoa(iph->saddr)));
  798.         DPRINTF((DBG_IP, " DST=%s\n", in_ntoa(iph->daddr)));
  799. - 
  800. +
  801. +    if (mtu < 8)
  802. +        return;
  803.         /* Check for any "DF" flag. */
  804.         if (ntohs(iph->frag_off) & IP_DF) 
  805.         {
  806. diff -u --recursive --new-file v1.0.2/linux/net/inet/sock.c linux/net/inet/sock.c
  807. --- v1.0.2/linux/net/inet/sock.c    Mon Mar 21 16:36:23 1994
  808. +++ linux/net/inet/sock.c    Mon Mar 21 14:56:03 1994
  809. @@ -428,7 +428,7 @@
  810.     * structure, otherwise we need to keep it around until
  811.     * everything is gone.
  812.     */
  813. -      if (sk->rmem_alloc == 0 && sk->wmem_alloc == 0) 
  814. +      if (sk->dead && sk->rmem_alloc == 0 && sk->wmem_alloc == 0) 
  815.        {
  816.          kfree_s((void *)sk,sizeof(*sk));
  817.        } 
  818. @@ -1197,7 +1197,7 @@
  819.    if (newsock->data) {
  820.        struct sock * sk = (struct sock *) newsock->data;
  821.        newsock->data = NULL;
  822. -      kfree_s(sk, sizeof(struct sock));
  823. +      destroy_sock(sk);
  824.    }
  825.  
  826.    if (sk1->prot->accept == NULL) return(-EOPNOTSUPP);
  827.