mirror/freebsd-ports
1
0
Fork 0
mirror of https://git.FreeBSD.org/ports.git synced 2024-11-14 23:46:10 +00:00
Code Issues Releases Activity
9802c96856
freebsd-ports/x11-fm/tkdesk/files/patch-aa

1417 lines
32 KiB
Plaintext
Raw Normal View History

Upgrade, 1.0b2 -> 1.0b3. Submitted by: Juergen Lock <nox@jelal.hb.north.de> (Note that the maintainer has been changed to: Juergen Lock <nox@jelal.hb.north.de>)
1996-11-12 04:54:14 +00:00
Index: Makefile
--- Makefile.orig Thu Sep 26 10:37:58 1996
+++ Makefile Sun Nov 10 20:40:01 1996
@@ -21,9 +21,14 @@
# --------------------------------
#
+# Installation prefix:
+
+PREFIX?=/usr/local
+
+#
# Where the executables will be installed:
-BINDIR = /usr/local/bin
+BINDIR = ${PREFIX}/bin
#BINDIR = $(HOME)/bin
# Where TkDesk will look for the tkdesk script when started (this is
@@ -34,7 +39,7 @@
#
# TkDesk's library will be installed here:
-LIBDIR = /usr/local/lib/TkDesk
+LIBDIR = ${PREFIX}/lib/TkDesk
#LIBDIR = $(HOME)/lib/TkDesk
# Where TkDesk will look for its library files when started (this is
@@ -50,48 +55,50 @@
#
# Location of the Tcl include files:
-TCLINCDIR = /usr/include/tcl # Linux with Slackware 3.0
-#TCLINCDIR = /usr/local/include
+#TCLINCDIR = /usr/include/tcl # Linux with Slackware 3.0
+TCLINCDIR = /usr/local/include
#TCLINCDIR = /usr/local/include/tcl7.5
#TCLINCDIR = $(HOME)/include
# Location of the Tcl library:
# (Ignore the "-L" bit - the linker needs it.)
-TCLLIBDIR =
-#TCLLIBDIR = -L/usr/local/lib
+#TCLLIBDIR =
+TCLLIBDIR = -L/usr/local/lib
#TCLLIBDIR = -L$(HOME)/lib
#
# Flag for linking the Tcl library to TkDesk:
-TCLLIB = -ltcl
+#TCLLIB = -ltcl
#TCLLIB = -ltcl7.4
#TCLLIB = -ltcl7.5
#TCLLIB = -ltcl7_4
+TCLLIB = -ltcl75
#
# Location of the Tk include files:
-TKINCDIR = /usr/include/tcl # Linux with Slackware 3.0
-#TKINCDIR = /usr/local/include
+#TKINCDIR = /usr/include/tcl # Linux with Slackware 3.0
+TKINCDIR = /usr/local/include
#TKINCDIR = /usr/local/include/tcl7.5
#TKINCDIR = $(HOME)/include
# Location of the Tk library:
# (Ignore the "-L" bit - the linker needs it.)
-TKLIBDIR =
-#TKLIBDIR = -L/usr/local/lib
+#TKLIBDIR =
+TKLIBDIR = -L/usr/local/lib
#TKLIBDIR = -L$(HOME)/lib
#
# Flag for linking the Tk library to TkDesk:
-TKLIB = -ltk
+#TKLIB = -ltk
#TKLIB = -ltk4.0
#TKLIB = -ltk4.1
#TKLIB = -ltk4_0
+TKLIB = -ltk41
# --------------------------------
# X11 Paths:
@@ -119,12 +126,12 @@
# to add the appropriate library which allows for dynamic loading on
# your system, such as -ldl for Linux and SGI or -ldld for HP-UX.)
-OTHERLIBS = -lieee # e.g. Linux with Tcl 7.4
+#OTHERLIBS = -lieee # e.g. Linux with Tcl 7.4
#OTHERLIBS = -ldl -lieee # e.g. Linux with Tcl 7.5 and dynamic loading
#OTHERLIBS = -ldl -lnsl -lsocket # e.g. for Solaris
#OTHERLIBS = -ldl -lsocket # e.g. for SGI with os5.3 and Tcl 7.5
#OTHERLIBS = -ldld # e.g. for HP-UX 9.05 and Tcl 7.5
-#OTHERLIBS =
+OTHERLIBS =
# --------------------------------
# Compiler and Linker Settings:
@@ -170,8 +177,8 @@
@echo "out the fifth line in the file tkdesk and then executing:"
@echo "./tkdesksh tkdesk -configdir ./tcldesk/configs"
-shell: makelibs tkAppInit.o
- $(CC) $(LDFLAGS) tkAppInit.o -o tkdesksh libdesk/libdesk.a \
+shell: makelibs tkAppInit.o malloc.o
+ $(CC) $(LDFLAGS) tkAppInit.o malloc.o -o tkdesksh libdesk/libdesk.a \
netscape-remote/libnetscape.a \
blt/src/libBLT.a $(TKLIBDIRFLAG) $(TKLIB) \
$(XLIBDIRFLAG) -lX11 itcl/src/libitcl.a \
@@ -240,10 +247,11 @@
find $(LIBDIR) -type f -exec chmod a+r {} \;
find $(LIBDIR) -type d -exec chmod a+rx {} \;
@echo "=== Installing the executables..."
- @rm -f $(BINDIR)/tkdesksh $(BINDIR)/tkdesk $(BINDIR)/pauseme $(BINDIR)/ed-tkdesk $(BINDIR)/cd-tkdesk $(BINDIR)/od-tkdesk
+ @rm -f $(BINDIR)/tkdesksh $(BINDIR)/tkdesk $(BINDIR)/pauseme $(BINDIR)/ed-tkdesk $(BINDIR)/cd-tkdesk $(BINDIR)/od-tkdesk $(BINDIR)/gdbcore $(BINDIR)/dddcore
cp tkdesksh $(BINDIR)
- cp tkdesk tools/pauseme tools/ed-tkdesk tools/cd-tkdesk tools/od-tkdesk $(BINDIR)
- chmod 755 $(BINDIR)/*tkdesk* $(BINDIR)/pauseme
+ cp tkdesk tools/pauseme tools/gdbcore tools/ed-tkdesk tools/cd-tkdesk tools/od-tkdesk $(BINDIR)
+ chmod 755 $(BINDIR)/*tkdesk* $(BINDIR)/pauseme $(BINDIR)/gdbcore
+ ln -s gdbcore $(BINDIR)/dddcore
@echo "=== Installation complete."
uninstall:
Index: libdesk/dsk_ls.c
@@ -382,7 +382,7 @@
void write_element (fe)
FILE_ENTRY *fe;
{
- char buf[256], *np;
+ char buf[2560], *np;
np = (par_only_directories) ? fe->path : fe->name;
Index: libdesk/misc.c
@@ -68,7 +68,7 @@
{
int keep = 0, i;
char tc;
- char instr[TCL_RESULT_SIZE], outstr[TCL_RESULT_SIZE];
+ char instr[2560], outstr[2560];
if (argc < 2 || argc > 3) {
sprintf (interp->result, "usage: dsk_striptc ?-keep? string");
@@ -87,7 +87,7 @@
}
if (instr[0] == 0) {
- *interp->result = 0;
+ Tcl_ResetResult(interp);
return (TCL_OK);
}
@@ -117,7 +117,7 @@
}
}
- strcpy (interp->result, outstr);
+ Tcl_SetResult(interp, outstr, TCL_VOLATILE);
return (TCL_OK);
} /* dsk_striptc_Cmd */
Index: tcldesk/appbar.tcl
@@ -1002,7 +1002,7 @@
_appbar_get_load]
return
}
- set li [lsearch $uptime "average:"]
+ set li [lsearch $uptime "averages:"]
set load1 [string trimright [lindex $uptime [incr li]] ,]
set load2 [string trimright [lindex $uptime [incr li]] ,]
set load3 [string trimright [lindex $uptime [incr li]] ,]
Index: tools/gdbcore
@@ -0,0 +1,28 @@
+#! /bin/sh
+# {gdb,ddd}core executable corefile - gdb/ddd a core file
+
+# Try to load shared symbols by `run'ning upto main first, then
+# loading the core-file (BSD's gdb sees only static symbols otherwise)
+case `basename $0` in
+ddd*)
+ x=ddd
+ ;;
+*)
+ x=gdb
+ ;;
+esac
+if [ -z "$1" ]; then
+ f=`basename $2|sed s/.core\$//`
+else
+ f=$1
+fi
+if [ ! -f "$f" ]; then
+ f=`dirname $2`/`basename $f`
+fi
+if nm -g "$f" |grep -q "^[0-9a-f]* T _main$"; then
+ (echo b main; echo r; echo del 1; echo core-file $2) >/tmp/gdbcore-x-$$
+ (rm /tmp/gdbcore-x-$$; exec $x -x /dev/fd/6 $f) 6</tmp/gdbcore-x-$$
+else
+ # no `main' symbol...
+ exec $x $f $2
+fi
Index: malloc.c
@@ -0,0 +1,1206 @@
+/*
+ * ----------------------------------------------------------------------------
+ * "THE BEER-WARE LICENSE" (Revision 42):
+ * <phk@FreeBSD.ORG> wrote this file. As long as you retain this notice you
+ * can do whatever you want with this stuff. If we meet some day, and you think
+ * this stuff is worth it, you can buy me a beer in return. Poul-Henning Kamp
+ * ----------------------------------------------------------------------------
+ *
+ * $Id: malloc.c,v 1.12 1996/09/17 19:50:23 phk Exp $
+ *
+ */
+
+/*
+ * Defining EXTRA_SANITY will enable some checks which are related
+ * to internal conditions and consistency in malloc.c
+ */
+#undef EXTRA_SANITY
+
+/*
+ * Defining MALLOC_STATS will enable you to call malloc_dump() and set
+ * the [dD] options in the MALLOC_OPTIONS environment variable.
+ * It has no run-time performance hit.
+ */
+#define MALLOC_STATS
+
+#if defined(EXTRA_SANITY) && !defined(MALLOC_STATS)
+# define MALLOC_STATS /* required for EXTRA_SANITY */
+#endif
+
+/*
+ * What to use for Junk
+ */
+#define SOME_JUNK 0xd0 /* as in "Duh" :-) */
+
+/*
+ * If these weren't defined here, they would be calculated on the fly,
+ * at a considerable cost in performance.
+ */
+#if defined(__i386__) && defined(__FreeBSD__)
+# define malloc_pagesize 4096U
+# define malloc_pageshift 12U
+# define malloc_minsize 16U
+# define malloc_maxsize ((malloc_pagesize)>>1)
+#endif /* __i386__ && __FreeBSD__ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <memory.h>
+#include <errno.h>
+#include <err.h>
+#include <sys/types.h>
+#include <sys/mman.h>
+#ifdef _THREAD_SAFE
+#include <pthread.h>
+#include "pthread_private.h"
+#endif
+
+/*
+ * This structure describes a page worth of chunks.
+ */
+
+struct pginfo {
+ struct pginfo *next; /* next on the free list */
+ void *page; /* Pointer to the page */
+ u_short size; /* size of this page's chunks */
+ u_short shift; /* How far to shift for this size chunks */
+ u_short free; /* How many free chunks */
+ u_short total; /* How many chunk */
+ u_long bits[1]; /* Which chunks are free */
+};
+
+/*
+ * This structure describes a number of free pages.
+ */
+
+struct pgfree {
+ struct pgfree *next; /* next run of free pages */
+ struct pgfree *prev; /* prev run of free pages */
+ void *page; /* pointer to free pages */
+ void *end; /* pointer to end of free pages */
+ u_long size; /* number of bytes free */
+};
+
+/*
+ * How many bits per u_long in the bitmap.
+ * Change only if not 8 bits/byte
+ */
+#define MALLOC_BITS (8*sizeof(u_long))
+
+/*
+ * Magic values to put in the page_directory
+ */
+#define MALLOC_NOT_MINE ((struct pginfo*) 0)
+#define MALLOC_FREE ((struct pginfo*) 1)
+#define MALLOC_FIRST ((struct pginfo*) 2)
+#define MALLOC_FOLLOW ((struct pginfo*) 3)
+#define MALLOC_MAGIC ((struct pginfo*) 4)
+
+/*
+ * The i386 architecture has some very convenient instructions.
+ * We might as well use them. There are C-language backups, but
+ * they are considerably slower.
+ */
+#ifdef __i386__
+#define ffs _ffs
+static __inline int
+_ffs(unsigned input)
+{
+ int result;
+ asm("bsfl %1,%0" : "=r" (result) : "r" (input));
+ return result+1;
+}
+
+#define fls _fls
+static __inline int
+_fls(unsigned input)
+{
+ int result;
+ asm("bsrl %1,%0" : "=r" (result) : "r" (input));
+ return result+1;
+}
+
+#define set_bit _set_bit
+static __inline void
+_set_bit(struct pginfo *pi, int bit)
+{
+ asm("btsl %0,(%1)" :
+ : "r" (bit & (MALLOC_BITS-1)), "r" (pi->bits+(bit/MALLOC_BITS)));
+}
+
+#define clr_bit _clr_bit
+static __inline void
+_clr_bit(struct pginfo *pi, int bit)
+{
+ asm("btcl %0,(%1)" :
+ : "r" (bit & (MALLOC_BITS-1)), "r" (pi->bits+(bit/MALLOC_BITS)));
+}
+
+#endif /* __i386__ */
+
+/*
+ * Set to one when malloc_init has been called
+ */
+static unsigned initialized;
+
+/*
+ * The size of a page.
+ * Must be a integral multiplum of the granularity of mmap(2).
+ * Your toes will curl if it isn't a power of two
+ */
+#ifndef malloc_pagesize
+static unsigned malloc_pagesize;
+#endif /* malloc_pagesize */
+
+/*
+ * A mask for the offset inside a page.
+ */
+#define malloc_pagemask ((malloc_pagesize)-1)
+
+#define pageround(foo) (((foo) + (malloc_pagemask))&(~(malloc_pagemask)))
+#define ptr2index(foo) (((u_long)(foo) >> malloc_pageshift)-malloc_origo)
+
+/*
+ * malloc_pagesize == 1 << malloc_pageshift
+ */
+#ifndef malloc_pageshift
+static unsigned malloc_pageshift;
+#endif /* malloc_pageshift */
+
+/*
+ * The smallest allocation we bother about.
+ * Must be power of two
+ */
+#ifndef malloc_minsize
+static unsigned malloc_minsize;
+#endif /* malloc_minsize */
+
+/*
+ * The largest chunk we care about.
+ * Must be smaller than pagesize
+ * Must be power of two
+ */
+#ifndef malloc_maxsize
+static unsigned malloc_maxsize;
+#endif /* malloc_maxsize */
+
+/*
+ * The minimum size (in bytes) of the free page cache.
+ */
+#ifndef malloc_cache
+static unsigned malloc_cache;
+#endif /* malloc_cache */
+
+/*
+ * The offset from pagenumber to index into the page directory
+ */
+static u_long malloc_origo;
+
+/*
+ * The last index in the page directory we care about
+ */
+static u_long last_index;
+
+/*
+ * Pointer to page directory.
+ * Allocated "as if with" malloc
+ */
+static struct pginfo **page_dir;
+
+/*
+ * How many slots in the page directory
+ */
+static unsigned malloc_ninfo;
+
+/*
+ * Free pages line up here
+ */
+static struct pgfree free_list;
+
+/*
+ * Abort() if we fail to get VM ?
+ */
+static int malloc_abort;
+
+/*
+ * Are we trying to die ?
+ */
+static int suicide;
+
+#ifdef MALLOC_STATS
+/*
+ * dump statistics
+ */
+static int malloc_stats;
+#endif /* MALLOC_STATS */
+
+/*
+ * always realloc ?
+ */
+static int malloc_realloc;
+
+/*
+ * zero fill ?
+ */
+static int malloc_zero;
+
+/*
+ * junk fill ?
+ */
+static int malloc_junk;
+
+/*
+ * my last break.
+ */
+static void *malloc_brk;
+
+/*
+ * one location cache for free-list holders
+ */
+static struct pgfree *px;
+
+/*
+ * Necessary function declarations
+ */
+static int extend_pgdir(u_long index);
+
+#ifdef MALLOC_STATS
+void
+malloc_dump(FILE *fd)
+{
+ struct pginfo **pd;
+ struct pgfree *pf;
+ int j;
+
+ pd = page_dir;
+
+ /* print out all the pages */
+ for(j=0;j<=last_index;j++) {
+ fprintf(fd,"%08lx %5d ",(j+malloc_origo) << malloc_pageshift,j);
+ if (pd[j] == MALLOC_NOT_MINE) {
+ for(j++;j<=last_index && pd[j] == MALLOC_NOT_MINE;j++)
+ ;
+ j--;
+ fprintf(fd,".. %5d not mine\n", j);
+ } else if (pd[j] == MALLOC_FREE) {
+ for(j++;j<=last_index && pd[j] == MALLOC_FREE;j++)
+ ;
+ j--;
+ fprintf(fd,".. %5d free\n", j);
+ } else if (pd[j] == MALLOC_FIRST) {
+ for(j++;j<=last_index && pd[j] == MALLOC_FOLLOW;j++)
+ ;
+ j--;
+ fprintf(fd,".. %5d in use\n", j);
+ } else if (pd[j] < MALLOC_MAGIC) {
+ fprintf(fd,"(%p)\n", pd[j]);
+ } else {
+ fprintf(fd,"%p %d (of %d) x %d @ %p --> %p\n",
+ pd[j],pd[j]->free, pd[j]->total,
+ pd[j]->size, pd[j]->page, pd[j]->next);
+ }
+ }
+
+ for(pf=free_list.next; pf; pf=pf->next) {
+ fprintf(fd,"Free: @%p [%p...%p[ %ld ->%p <-%p\n",
+ pf,pf->page,pf->end,pf->size,pf->prev,pf->next);
+ if (pf == pf->next) {
+ fprintf(fd,"Free_list loops.\n");
+ break;
+ }
+ }
+
+ /* print out various info */
+ fprintf(fd,"Minsize\t%d\n",malloc_minsize);
+ fprintf(fd,"Maxsize\t%d\n",malloc_maxsize);
+ fprintf(fd,"Pagesize\t%d\n",malloc_pagesize);
+ fprintf(fd,"Pageshift\t%d\n",malloc_pageshift);
+ fprintf(fd,"FirstPage\t%ld\n",malloc_origo);
+ fprintf(fd,"LastPage\t%ld %lx\n",last_index+malloc_pageshift,
+ (last_index + malloc_pageshift) << malloc_pageshift);
+ fprintf(fd,"Break\t%ld\n",(u_long)sbrk(0) >> malloc_pageshift);
+}
+#endif /* MALLOC_STATS */
+
+static void
+wrterror(char *p)
+{
+ char *q = "Malloc error: ";
+ suicide = 1;
+ write(2,q,strlen(q));
+ write(2,p,strlen(p));
+#ifdef MALLOC_STATS
+ if (malloc_stats)
+ malloc_dump(stderr);
+#endif /* MALLOC_STATS */
+ abort();
+}
+
+static void
+wrtwarning(char *p)
+{
+ char *q = "Malloc warning: ";
+ if (malloc_abort)
+ wrterror(p);
+ write(2,q,strlen(q));
+ write(2,p,strlen(p));
+}
+
+#ifdef EXTRA_SANITY
+static void
+malloc_exit()
+{
+ FILE *fd = fopen("malloc.out","a");
+ char *q = "malloc() warning: Couldn't dump stats.\n";
+ if (fd) {
+ malloc_dump(fd);
+ fclose(fd);
+ } else
+ write(2,q,strlen(q));
+}
+#endif /* EXTRA_SANITY */
+
+
+/*
+ * Allocate a number of pages from the OS
+ */
+static caddr_t
+map_pages(int pages)
+{
+ caddr_t result,tail;
+
+ result = (caddr_t)pageround((u_long)sbrk(0));
+ tail = result + (pages << malloc_pageshift);
+
+ if (brk(tail)) {
+#ifdef EXTRA_SANITY
+ wrterror("(internal): map_pages fails\n");
+#endif /* EXTRA_SANITY */
+ return 0;
+ }
+
+ last_index = ptr2index(tail) - 1;
+ malloc_brk = tail;
+
+ if ((last_index+1) >= malloc_ninfo && !extend_pgdir(last_index))
+ return 0;;
+
+ return result;
+}
+
+/*
+ * Set a bit in the bitmap
+ */
+#ifndef set_bit
+static __inline void
+set_bit(struct pginfo *pi, int bit)
+{
+ pi->bits[bit/MALLOC_BITS] |= 1<<(bit%MALLOC_BITS);
+}
+#endif /* set_bit */
+
+/*
+ * Clear a bit in the bitmap
+ */
+#ifndef clr_bit
+static __inline void
+clr_bit(struct pginfo *pi, int bit)
+{
+ pi->bits[bit/MALLOC_BITS] &= ~(1<<(bit%MALLOC_BITS));
+}
+#endif /* clr_bit */
+
+#ifndef tst_bit
+/*
+ * Test a bit in the bitmap
+ */
+static __inline int
+tst_bit(struct pginfo *pi, int bit)
+{
+ return pi->bits[bit/MALLOC_BITS] & (1<<(bit%MALLOC_BITS));
+}
+#endif /* tst_bit */
+
+/*
+ * Find last bit
+ */
+#ifndef fls
+static __inline int
+fls(int size)
+{
+ int i = 1;
+ while (size >>= 1)
+ i++;
+ return i;
+}
+#endif /* fls */
+
+/*
+ * Extend page directory
+ */
+static int
+extend_pgdir(u_long index)
+{
+ struct pginfo **new,**old;
+ int i, oldlen;
+
+ /* Make it this many pages */
+ i = index * sizeof *page_dir;
+ i /= malloc_pagesize;
+ i += 2;
+
+ /* remember the old mapping size */
+ oldlen = malloc_ninfo * sizeof *page_dir;
+
+ /*
+ * NOTE: we allocate new pages and copy the directory rather than tempt
+ * fate by trying to "grow" the region.. There is nothing to prevent
+ * us from accidently re-mapping space that's been allocated by our caller
+ * via dlopen() or other mmap().
+ *
+ * The copy problem is not too bad, as there is 4K of page index per
+ * 4MB of malloc arena.
+ *
+ * We can totally avoid the copy if we open a file descriptor to associate
+ * the anon mappings with. Then, when we remap the pages at the new
+ * address, the old pages will be "magically" remapped.. But this means
+ * keeping open a "secret" file descriptor.....
+ */
+
+ /* Get new pages */
+ new = (struct pginfo**) mmap(0, i * malloc_pagesize, PROT_READ|PROT_WRITE,
+ MAP_ANON|MAP_PRIVATE, -1, 0);
+ if (new == (struct pginfo **)-1)
+ return 0;
+
+ /* Copy the old stuff */
+ memcpy(new, page_dir,
+ malloc_ninfo * sizeof *page_dir);
+
+ /* register the new size */
+ malloc_ninfo = i * malloc_pagesize / sizeof *page_dir;
+
+ /* swap the pointers */
+ old = page_dir;
+ page_dir = new;
+
+ /* Now free the old stuff */
+ munmap((caddr_t)old, oldlen);
+ return 1;
+}
+
+/*
+ * Initialize the world
+ */
+static void
+malloc_init ()
+{
+ char *p;
+
+#ifdef EXTRA_SANITY
+ malloc_junk = 1;
+#endif /* EXTRA_SANITY */
+
+ for (p=getenv("MALLOC_OPTIONS"); p && *p; p++) {
+ switch (*p) {
+ case 'a': malloc_abort = 0; break;
+ case 'A': malloc_abort = 1; break;
+#ifdef MALLOC_STATS
+ case 'd': malloc_stats = 0; break;
+ case 'D': malloc_stats = 1; break;
+#endif /* MALLOC_STATS */
+ case 'r': malloc_realloc = 0; break;
+ case 'R': malloc_realloc = 1; break;
+ case 'j': malloc_junk = 0; break;
+ case 'J': malloc_junk = 1; break;
+ case 'z': malloc_zero = 0; break;
+ case 'Z': malloc_zero = 1; break;
+ default:
+ wrtwarning("(Init): Unknown char in MALLOC_OPTIONS\n");
+ p = 0;
+ break;
+ }
+ }
+
+ /*
+ * We want junk in the entire allocation, and zero only in the part
+ * the user asked for.
+ */
+ if (malloc_zero)
+ malloc_junk=1;
+
+#ifdef EXTRA_SANITY
+ if (malloc_stats)
+ atexit(malloc_exit);
+#endif /* EXTRA_SANITY */
+
+#ifndef malloc_pagesize
+ /* determine our pagesize */
+ malloc_pagesize = getpagesize();
+#endif /* malloc_pagesize */
+
+#ifndef malloc_maxsize
+ malloc_maxsize = malloc_pagesize >> 1;
+#endif /* malloc_maxsize */
+
+#ifndef malloc_pageshift
+ {
+ int i;
+ /* determine how much we shift by to get there */
+ for (i = malloc_pagesize; i > 1; i >>= 1)
+ malloc_pageshift++;
+ }
+#endif /* malloc_pageshift */
+
+#ifndef malloc_cache
+ malloc_cache = 100 << malloc_pageshift;
+#endif /* malloc_cache */
+
+#ifndef malloc_minsize
+ {
+ int i;
+ /*
+ * find the smallest size allocation we will bother about.
+ * this is determined as the smallest allocation that can hold
+ * it's own pginfo;
+ */
+ i = 2;
+ for(;;) {
+ int j;
+
+ /* Figure out the size of the bits */
+ j = malloc_pagesize/i;
+ j /= 8;
+ if (j < sizeof(u_long))
+ j = sizeof (u_long);
+ if (sizeof(struct pginfo) + j - sizeof (u_long) <= i)
+ break;
+ i += i;
+ }
+ malloc_minsize = i;
+ }
+#endif /* malloc_minsize */
+
+ /* Allocate one page for the page directory */
+ page_dir = (struct pginfo **) mmap(0, malloc_pagesize, PROT_READ|PROT_WRITE,
+ MAP_ANON|MAP_PRIVATE, -1, 0);
+ if (page_dir == (struct pginfo **) -1)
+ wrterror("(Init) my first mmap failed. (check limits ?)\n");
+
+ /*
+ * We need a maximum of malloc_pageshift buckets, steal these from the
+ * front of the page_directory;
+ */
+ malloc_origo = ((u_long)pageround((u_long)sbrk(0))) >> malloc_pageshift;
+ malloc_origo -= malloc_pageshift;
+
+ malloc_ninfo = malloc_pagesize / sizeof *page_dir;
+
+ /* Been here, done that */
+ initialized++;
+
+ /*
+ * This is a nice hack from Kaleb Keithly (kaleb@x.org).
+ * We can sbrk(2) further back when we keep this on a low address.
+ */
+ px = (struct pgfree *) malloc (sizeof *px);
+}
+
+/*
+ * Allocate a number of complete pages
+ */
+void *
+malloc_pages(size_t size)
+{
+ void *p,*delay_free = 0;
+ int i;
+ struct pgfree *pf;
+ u_long index;
+
+ size = pageround(size);
+
+ p = 0;
+ /* Look for free pages before asking for more */
+ for(pf = free_list.next; pf; pf = pf->next) {
+
+#ifdef EXTRA_SANITY
+ if (pf->size & malloc_pagemask)
+ wrterror("(ES): junk length entry on free_list\n");
+ if (!pf->size)
+ wrterror("(ES): zero length entry on free_list\n");
+ if (pf->page == pf->end)
+ wrterror("(ES): zero entry on free_list\n");
+ if (pf->page > pf->end)
+ wrterror("(ES): sick entry on free_list\n");
+ if ((void*)pf->page >= (void*)sbrk(0))
+ wrterror("(ES): entry on free_list past brk\n");
+ if (page_dir[ptr2index(pf->page)] != MALLOC_FREE)
+ wrterror("(ES): non-free first page on free-list\n");
+ if (page_dir[ptr2index(pf->end)-1] != MALLOC_FREE)
+ wrterror("(ES): non-free last page on free-list\n");
+#endif /* EXTRA_SANITY */
+
+ if (pf->size < size)
+ continue;
+
+ if (pf->size == size) {
+ p = pf->page;
+ if (pf->next)
+ pf->next->prev = pf->prev;
+ pf->prev->next = pf->next;
+ delay_free = pf;
+ break;
+ }
+
+ p = pf->page;
+ pf->page += size;
+ pf->size -= size;
+ break;
+ }
+
+#ifdef EXTRA_SANITY
+ if (p && page_dir[ptr2index(p)] != MALLOC_FREE)
+ wrterror("(ES): allocated non-free page on free-list\n");
+#endif /* EXTRA_SANITY */
+
+ size >>= malloc_pageshift;
+
+ /* Map new pages */
+ if (!p)
+ p = map_pages(size);
+
+ if (p) {
+
+ index = ptr2index(p);
+ page_dir[index] = MALLOC_FIRST;
+ for (i=1;i<size;i++)
+ page_dir[index+i] = MALLOC_FOLLOW;
+
+ if (malloc_junk)
+ memset(p, SOME_JUNK,size << malloc_pageshift);
+ }
+
+ if (delay_free) {
+ if (!px)
+ px = delay_free;
+ else
+ free(delay_free);
+ }
+
+ return p;
+}
+
+/*
+ * Allocate a page of fragments
+ */
+
+static __inline int
+malloc_make_chunks(int bits)
+{
+ struct pginfo *bp;
+ void *pp;
+ int i,k,l;
+
+ /* Allocate a new bucket */
+ pp = malloc_pages(malloc_pagesize);
+ if (!pp)
+ return 0;
+
+ /* Find length of admin structure */
+ l = sizeof *bp - sizeof(u_long);
+ l += sizeof(u_long) *
+ (((malloc_pagesize >> bits)+MALLOC_BITS-1) / MALLOC_BITS);
+
+ /* Don't waste more than two chunks on this */
+ if ((1<<(bits)) <= l+l) {
+ bp = (struct pginfo *)pp;
+ } else {
+ bp = (struct pginfo *)malloc(l);
+ if (!bp)
+ return 0;
+ }
+
+ bp->size = (1<<bits);
+ bp->shift = bits;
+ bp->total = bp->free = malloc_pagesize >> bits;
+ bp->page = pp;
+
+ page_dir[ptr2index(pp)] = bp;
+
+ bp->next = page_dir[bits];
+ page_dir[bits] = bp;
+
+ /* set all valid bits in the bits */
+ k = bp->total;
+ i = 0;
+
+ /* Do a bunch at a time */
+ for(;k-i >= MALLOC_BITS; i += MALLOC_BITS)
+ bp->bits[i / MALLOC_BITS] = ~0;
+
+ for(; i < k; i++)
+ set_bit(bp,i);
+
+ if (bp == bp->page) {
+ /* Mark the ones we stole for ourselves */
+ for(i=0;l > 0;i++) {
+ clr_bit(bp,i);
+ bp->free--;
+ bp->total--;
+ l -= (1 << bits);
+ }
+ }
+
+ return 1;
+}
+
+/*
+ * Allocate a fragment
+ */
+static void *
+malloc_bytes(size_t size)
+{
+ int j;
+ struct pginfo *bp;
+ int k;
+ u_long *lp;
+
+ /* Don't bother with anything less than this */
+ if (size < malloc_minsize)
+ size = malloc_minsize;
+
+ /* Find the right bucket */
+ j = fls((size)-1);
+
+ /* If it's empty, make a page more of that size chunks */
+ if (!page_dir[j] && !malloc_make_chunks(j))
+ return 0;
+
+ bp = page_dir[j];
+
+ /* Find first word of bitmap which isn't empty */
+ for (lp = bp->bits; !*lp; lp++)
+ ;
+
+ /* Find that bit, and tweak it */
+ k = ffs(*lp) - 1;
+ *lp ^= 1<<k;
+
+ /* If there are no more free, remove from free-list */
+ if (!--bp->free) {
+ page_dir[j] = bp->next;
+ bp->next = 0;
+ }
+
+ /* Adjust to the real offset of that chunk */
+ k += (lp-bp->bits)*MALLOC_BITS;
+ k <<= bp->shift;
+
+ if (malloc_junk)
+ memset(bp->page + k, SOME_JUNK, bp->size);
+
+ return bp->page + k;
+}
+
+/*
+ * Allocate a piece of memory
+ */
+static __inline void *
+imalloc(size_t size)
+{
+ void *result;
+
+ if (!initialized)
+ malloc_init();
+
+ if (suicide)
+ abort();
+
+ if (size <= malloc_maxsize)
+ result = malloc_bytes(size);
+ else
+ result = malloc_pages(size);
+
+ if (malloc_abort && !result)
+ wrterror("malloc(): returns NULL\n");
+
+ if (malloc_zero)
+ memset(result,0,size);
+
+ return result;
+}
+
+/*
+ * Change the size of an allocation.
+ */
+static __inline void *
+irealloc(void *ptr, size_t size)
+{
+ void *p;
+ u_long osize,index;
+ struct pginfo **mp;
+ int i;
+
+ if (suicide)
+ return 0;
+
+ if (!ptr) /* Bounce to malloc() */
+ return malloc(size);
+
+ if (!initialized) {
+ wrtwarning("realloc(): malloc() never got called.\n");
+ return 0;
+ }
+
+ if (ptr && !size) { /* Bounce to free() */
+ free(ptr);
+ return 0;
+ }
+
+ index = ptr2index(ptr);
+
+ if (index < malloc_pageshift) {
+ wrtwarning("realloc(): junk pointer (too low)\n");
+ return 0;
+ }
+
+ if (index > last_index) {
+ wrtwarning("realloc(): junk pointer (too high)\n");
+ return 0;
+ }
+
+ mp = &page_dir[index];
+
+ if (*mp == MALLOC_FIRST) { /* Page allocation */
+
+ /* Check the pointer */
+ if ((u_long)ptr & malloc_pagemask) {
+ wrtwarning("realloc(): modified page pointer.\n");
+ return 0;
+ }
+
+ /* Find the size in bytes */
+ for (osize = malloc_pagesize; *++mp == MALLOC_FOLLOW;)
+ osize += malloc_pagesize;
+
+ if (!malloc_realloc && /* unless we have to, */
+ size <= osize && /* .. or are too small, */
+ size > (osize - malloc_pagesize)) { /* .. or can free a page, */
+ return ptr; /* don't do anything. */
+ }
+
+ } else if (*mp >= MALLOC_MAGIC) { /* Chunk allocation */
+
+ /* Check the pointer for sane values */
+ if (((u_long)ptr & ((*mp)->size-1))) {
+ wrtwarning("realloc(): modified chunk pointer.\n");
+ return 0;
+ }
+
+ /* Find the chunk index in the page */
+ i = ((u_long)ptr & malloc_pagemask) >> (*mp)->shift;
+
+ /* Verify that it isn't a free chunk already */
+ if (tst_bit(*mp,i)) {
+ wrtwarning("realloc(): already free chunk.\n");
+ return 0;
+ }
+
+ osize = (*mp)->size;
+
+ if (!malloc_realloc && /* Unless we have to, */
+ size < osize && /* ..or are too small, */
+ (size > osize/2 || /* ..or could use a smaller size, */
+ osize == malloc_minsize)) { /* ..(if there is one) */
+ return ptr; /* ..Don't do anything */
+ }
+
+ } else {
+ wrtwarning("realloc(): wrong page pointer.\n");
+ return 0;
+ }
+
+ p = malloc(size);
+
+ if (p) {
+ /* copy the lesser of the two sizes, and free the old one */
+ if (osize < size)
+ memcpy(p,ptr,osize);
+ else
+ memcpy(p,ptr,size);
+ free(ptr);
+ }
+ return p;
+}
+
+/*
+ * Free a sequence of pages
+ */
+
+static __inline void
+free_pages(void *ptr, int index, struct pginfo *info)
+{
+ int i;
+ struct pgfree *pf,*pt=0;
+ u_long l;
+ void *tail;
+
+ if (info == MALLOC_FREE) {
+ wrtwarning("free(): already free page.\n");
+ return;
+ }
+
+ if (info != MALLOC_FIRST) {
+ wrtwarning("free(): freeing wrong page.\n");
+ return;
+ }
+
+ if ((u_long)ptr & malloc_pagemask) {
+ wrtwarning("free(): modified page pointer.\n");
+ return;
+ }
+
+ /* Count how many pages and mark them free at the same time */
+ page_dir[index] = MALLOC_FREE;
+ for (i = 1; page_dir[index+i] == MALLOC_FOLLOW; i++)
+ page_dir[index + i] = MALLOC_FREE;
+
+ l = i << malloc_pageshift;
+
+ tail = ptr+l;
+
+ /* add to free-list */
+ if (!px)
+ px = malloc(sizeof *pt); /* This cannot fail... */
+ px->page = ptr;
+ px->end = tail;
+ px->size = l;
+ if (!free_list.next) {
+
+ /* Nothing on free list, put this at head */
+ px->next = free_list.next;
+ px->prev = &free_list;
+ free_list.next = px;
+ pf = px;
+ px = 0;
+
+ } else {
+
+ /* Find the right spot, leave pf pointing to the modified entry. */
+ tail = ptr+l;
+
+ for(pf = free_list.next; pf->end < ptr && pf->next; pf = pf->next)
+ ; /* Race ahead here */
+
+ if (pf->page > tail) {
+ /* Insert before entry */
+ px->next = pf;
+ px->prev = pf->prev;
+ pf->prev = px;
+ px->prev->next = px;
+ pf = px;
+ px = 0;
+ } else if (pf->end == ptr ) {
+ /* Append to the previous entry */
+ pf->end += l;
+ pf->size += l;
+ if (pf->next && pf->end == pf->next->page ) {
+ /* And collapse the next too. */
+ pt = pf->next;
+ pf->end = pt->end;
+ pf->size += pt->size;
+ pf->next = pt->next;
+ if (pf->next)
+ pf->next->prev = pf;
+ }
+ } else if (pf->page == tail) {
+ /* Prepend to entry */
+ pf->size += l;
+ pf->page = ptr;
+ } else if (!pf->next) {
+ /* Append at tail of chain */
+ px->next = 0;
+ px->prev = pf;
+ pf->next = px;
+ pf = px;
+ px = 0;
+ } else {
+ wrterror("messed up free list");
+ }
+ }
+
+ /* Return something to OS ? */
+ if (!pf->next && /* If we're the last one, */
+ pf->size > malloc_cache && /* ..and the cache is full, */
+ pf->end == malloc_brk && /* ..and none behind us, */
+ malloc_brk == sbrk(0)) { /* ..and it's OK to do... */
+
+ /*
+ * Keep the cache intact. Notice that the '>' above guarantees that
+ * the pf will always have at least one page afterwards.
+ */
+ pf->end = pf->page + malloc_cache;
+ pf->size = malloc_cache;
+
+ brk(pf->end);
+ malloc_brk = pf->end;
+
+ index = ptr2index(pf->end);
+ last_index = index - 1;
+
+ for(i=index;i <= last_index;)
+ page_dir[i++] = MALLOC_NOT_MINE;
+
+ /* XXX: We could realloc/shrink the pagedir here I guess. */
+ }
+ if (pt)
+ free(pt);
+}
+
+/*
+ * Free a chunk, and possibly the page it's on, if the page becomes empty.
+ */
+
+static __inline void
+free_bytes(void *ptr, int index, struct pginfo *info)
+{
+ int i;
+ struct pginfo **mp;
+ void *vp;
+
+ /* Find the chunk number on the page */
+ i = ((u_long)ptr & malloc_pagemask) >> info->shift;
+
+ if (((u_long)ptr & (info->size-1))) {
+ wrtwarning("free(): modified pointer.\n");
+ return;
+ }
+
+ if (tst_bit(info,i)) {
+ wrtwarning("free(): already free chunk.\n");
+ return;
+ }
+
+ set_bit(info,i);
+ info->free++;
+
+ mp = page_dir + info->shift;
+
+ if (info->free == 1) {
+
+ /* Page became non-full */
+
+ mp = page_dir + info->shift;
+ /* Insert in address order */
+ while (*mp && (*mp)->next && (*mp)->next->page < info->page)
+ mp = &(*mp)->next;
+ info->next = *mp;
+ *mp = info;
+ return;
+ }
+
+ if (info->free != info->total)
+ return;
+
+ /* Find & remove this page in the queue */
+ while (*mp != info) {
+ mp = &((*mp)->next);
+#ifdef EXTRA_SANITY
+ if (!*mp)
+ wrterror("(ES): Not on queue\n");
+#endif /* EXTRA_SANITY */
+ }
+ *mp = info->next;
+
+ /* Free the page & the info structure if need be */
+ page_dir[ptr2index(info->page)] = MALLOC_FIRST;
+ vp = info->page; /* Order is important ! */
+ if(vp != (void*)info)
+ free(info);
+ free(vp);
+}
+
+static __inline void
+ifree(void *ptr)
+{
+ struct pginfo *info;
+ int index;
+
+ /* This is legal */
+ if (!ptr)
+ return;
+
+ if (!initialized) {
+ wrtwarning("free(): malloc() never got called.\n");
+ return;
+ }
+
+ /* If we're already sinking, don't make matters any worse. */
+ if (suicide)
+ return;
+
+ index = ptr2index(ptr);
+
+ if (index < malloc_pageshift) {
+ wrtwarning("free(): junk pointer (too low)\n");
+ return;
+ }
+
+ if (index > last_index) {
+ wrtwarning("free(): junk pointer (too high)\n");
+ return;
+ }
+
+ info = page_dir[index];
+
+ if (info < MALLOC_MAGIC)
+ free_pages(ptr,index,info);
+ else
+ free_bytes(ptr,index,info);
+ return;
+}
+
+void *
+malloc(size_t size)
+{
+#ifdef _THREAD_SAFE
+ int status;
+ register void *r;
+ _thread_kern_sig_block(&status);
+ r = imalloc(size);
+ _thread_kern_sig_unblock(status);
+ return r;
+#else
+ return imalloc(size);
+#endif
+}
+
+void
+free(void *ptr)
+{
+#ifdef _THREAD_SAFE
+ int status;
+ _thread_kern_sig_block(&status);
+ ifree(ptr);
+ _thread_kern_sig_unblock(status);
+#else
+ ifree(ptr);
+#endif
+ return;
+}
+
+void *
+realloc(void *ptr, size_t size)
+{
+#ifdef _THREAD_SAFE
+ int status;
+ register void *r;
+ _thread_kern_sig_block(&status);
+ r = irealloc(ptr, size);
+ _thread_kern_sig_unblock(status);
+ return r;
+#else
+ return irealloc(ptr, size);
+#endif
+}
Reference in New Issue Copy Permalink