source: trunk/minix/commands/elle/sbm.c@ 9

/* SB - Copyright 1982 by Ken Harrenstien, SRI International
 *      This software is quasi-public; it may be used freely with
 *      like software, but may NOT be sold or made part of licensed
 *      products without permission of the author.  In all cases
 *      the source code and any modifications thereto must remain
 *      available to any user.
 *
 *      This is part of the SB library package.
 *      Any software using the SB library must likewise be made
 *      quasi-public, with freely available sources.
 */

#if 0
        This file contains the low-level memory allocation
subroutines which are used by the SBLK routines.  The code here
is quite machine-dependent, and the definitions in "sb.h" should be
carefully checked to verify that they are correct for the target
machine.

        The ultimate low-level routine is "sbrk()" which must be
provided by the system''s C library.  SBM expects that successive calls
to sbrk() will return contiguous areas of memory with progressively
higher addresses.  Also, the very first call to sbrk() is assumed to
return a word-aligned address.
#endif /*COMMENT*/

#include "sb.h"

#define FUDGE (sizeof(struct smblk))    /* Allow this much fudge in
                                allocation, to prevent undue fragmentation */

char *(*sbm_debug)();           /* Debug switch - user-furnished routine */

struct smblk *sbm_nfl;          /* Pointer to node freelist */
struct smblk *sbm_nxtra;        /* Reserved extra free node */
struct smblk *sbm_list;         /* Pointer to smblk memory alloc list.
                                 * ALL smblks are strung onto this list
                                 * except for the freelist!
                                 */
SBMA sbm_lowaddr;               /* Lowest word-aligned address we know about.*/

/* If compiling with debug switch set, use special routine in place of
 * sbrk so we can pretend we have a very limited area of free memory.
 */
#ifdef DBG_SIZE
#define SBM_SBRK sbm_brk
char *sbm_brk();
#else
#define SBM_SBRK sbrk
#endif /*DBG_SIZE*/

/* Forward routine declarations */
char *sbrk();
struct smblk *sbm_nmak(), *sbm_nget(), *sbm_mget(), *sbm_split();
struct smblk *sbm_lmak(), *sbm_err();


/* SBM_INIT - Initialize storage management.
 *      If args are zero, normal initialization is done.  Otherwise,
 *      args are understood to be pointers to an area of memory allocated
 *      on the stack (eg by an "int mem[2000]" declaration in MAIN) and
 *      initialization will include this area in addition to the
 *      unused space between "_end" and the start of the stack segment.
 *      This is mostly of use for PDP11s which would otherwise waste a lot
 *      of address space.
 *      Maybe should have a SBM_RESET() function?
 */

struct smblk *
sbm_init(xaddr,xlen)
SBMA xaddr;             /* Address of allocated stack area if any */
SBMO xlen;              /* Size of this area */
{       register struct smblk *sm, *sml;
        register char *cp;

        /* Get initial chunk of memory from standard system rtn */
        if((cp = SBM_SBRK(SMNODES*sizeof(struct smblk))) == 0
          || (int) cp == -1)
                return(sbm_err(0,"Can't sbrk"));
        sm = (struct smblk *)cp;                /* Better be word-aligned! */
        sbm_lmak(sm,(SBMO)sizeof(struct smblk),SMNODES);      /* Make list */
        sbm_nfl = sm;                           /* Point freelist at it */
        sbm_lowaddr = (SBMA)sm;                 /* Remember lowest addr seen */

        /* Set up 1st node pointing to all memory from here on up.
         * We don't know exactly how much will be available at this point,
         * so we just pretend we have the maximum possible.
         */
        sbm_list = sml = sbm_nget();
        sml->smforw = sml->smback = 0;
        sml->smflags = SM_USE|SM_NID;           /* Initial flags */
        sml->smaddr = (SBMA) sml;
        sml->smlen = MAXSBMO;                   /* Pretend we have lots */
        sml->smuse = (SMNODES * sizeof(struct smblk));

        /* Now split off everything above initial allocation as NXM. */
        sm = sbm_split(sml, sm->smuse);
        sml->smflags |= SM_MNODS;       /* Mark 1st node as having SM nodes */
        sm->smflags  |= SM_NXM;         /* Mark 2nd node as NXM */

        /* Now possibly set up extra nodes, if stack mem is being allocated
         * (From our viewpoint it looks as if a chunk in the middle of
         * the initial NXM section has been declared usable)
         */
        if(xlen)
          {     /* Allow for "extra" static stack memory */
                /* Will lose if xaddr <= 1st NXM! */
                sml = sbm_split(sm, (SBMO)(xaddr - sm->smaddr));
                sbm_split(sml, xlen);           /* Split off following NXM */
                sml->smflags &= ~(SM_USE|SM_NXM); /* This node is free mem! */
          }

        /* Now set up a small additional node which points to the NXM
         * that we cannot get from SBRK.  At this stage, this is just
         * a place-holder, to reserve the node so we don't have to
         * worry about running out of nodes at the same time sbrk stops
         * returning memory.
         * SM points to the NXM that we expect SBRK to dig into.
         */
        sbm_split(sm, sm->smlen - WDSIZE); /* Chop off teensy bit */
        sm->smflags &= ~SM_USE;         /* Now mark NXM "free"!! */

        /* Finally, reserve an "extra" SM node for use by sbm_nget
         * when it is allocating more freelist node chunks.
         */
        sbm_nxtra = sbm_nget();

        return(sbm_list);
}


/* SBM_NGET() - Get a free SM node.
 *      Note the hair to provide a spare SM node when
 *      we are allocating memory for more SM nodes.  This is necessary
 *      because sbm_mget and sbm_nget call each other recursively and
 *      sbm_mget cannot create any new memory without a SM node to point
 *      at the allocated chunk.
 */
struct smblk *
sbm_nget()
{       register struct smblk *sm, *sml;

        if(!(sm = sbm_nfl))             /* Get a node from freelist */
          {     /* Freelist is empty, try to allocate more nodes. */

                /* Put our "spare" smblk on freelist temporarily so that
                 * sbm_mget has a chance of winning.
                 * Infinite recursion is avoided by a test
                 * in sbm_mget which checks sbm_nfl and sbm_nxtra.
                 */
                if(!(sm = sbm_nxtra))
                        return(sbm_err(0,"Zero sbm_nxtra!"));
                sm->smforw = 0;
                sbm_nfl = sm;
                sbm_nxtra = 0;

                /* Try to allocate another chunk of SM nodes. */
                sml = sbm_nmak(sizeof(struct smblk),SM_MNODS);

                /* Put the new free nodes (if any) on freelist.
                 * Done this way because freelist may have had one or two
                 * nodes added to it by sbm_mget, so can't just stick
                 * a new pointer in sbm_nfl.
                 */
                while(sm = sml)
                  {     sml = sm->smforw;
                        sbm_nfre(sm);
                  }

                /* Now reserve an extra node again.
                 * It is an error if there is nothing on freelist here,
                 * because even if sbm_mget failed the "extra node" should
                 * still be on freelist.  The check for a zero sbm_nxtra
                 * above will catch such an error.
                 */
                sbm_nxtra = sbm_nget();

                /* Now see if anything to return */
                if(!(sm = sbm_nfl))             /* If freelist empty again, */
                        return(0);              /* give up. */
          }
        sbm_nfl = sm->smforw;   /* If win, take it off freelist */
        return(sm);             /* Return ptr or 0 if none */
}

/* SBM_NFRE(sm) - Return a SM node to the SM freelist.
 */
sbm_nfre(smp)
struct smblk *smp;
{       register struct smblk *sm;
        (sm = smp)->smflags = 0;
        sm->smforw = sbm_nfl;
        sbm_nfl = sm;
}

/* SBM_NMAK(elsize, flag) - Make (allocate & build) a typeless node freelist.
 */
struct smblk *
sbm_nmak(elsize, flag)
SBMO elsize;
unsigned flag;
{       register struct smblk *sm, *smp;
        register int cnt;

        if((sm = sbm_mget(SMNODES*elsize,SMNODES*elsize)) == 0)
                return(0);

        sm->smflags |= flag;            /* Indicate type of nodes */
        cnt = sm->smlen/elsize;         /* Find # nodes that will fit */
        sm->smuse = cnt * elsize;       /* Actual size used */
        smp = (struct smblk *)(sm->smaddr);     /* Ptr to 1st loc of mem */
        sbm_lmak(smp, (SBMO)elsize, cnt);       /* Build freelist */
        return(smp);            /* Return 1st free node. Caller is */
                                /* responsible for setting freelist ptr. */
}

/* SBM_LMAK - Build freelist of typeless nodes.
 *      Note this does not allocate memory, it just converts an already
 *      allocated memory area.
 */
struct smblk *
sbm_lmak(addr, elsize, num)
SBMA addr;
SBMO elsize;
int num;
{       register struct smblk *sm, *smp;
        register int cnt;

        smp = (struct smblk *) addr;
        if((cnt = num) <= 0)
                return(0);
        do {    sm = smp;       /* Save ptr */
                sm->smforw = (smp = (struct smblk *) ((SBMA)smp + elsize));
                sm->smflags = 0;
          } while(--cnt);
        sm->smforw = 0;         /* Last node points to nothing */
        return(sm);             /* Return ptr to last node */
}

/* SBM_NMOV(sm1, sm2, begp, elsize) - Move a typeless node.
 *      Copy sm1 to sm2, adjust ptrs, leave sm1 free.
 */
sbm_nmov(smp1,smp2,begp,elsize)
struct smblk *smp1, *smp2, **begp;
int elsize;
{       register struct smblk *sm;

        bcopy((SBMA)smp1,(SBMA)(sm = smp2), elsize);     /* Copy the stuff */
        if(sm->smforw) sm->smforw->smback = sm; /* Fix up links */
        if(sm->smback) sm->smback->smforw = sm;
        else *begp = sm;
}


/* SBM_MGET(min,max) - Get a SMBLK with specified amount of memory.
 *      Returns 0 if none available.
 *      Memory is guaranteed to start on word boundary, but may not
 *              end on one.  Note that sbm_mfree is responsible for
 *              ensuring that free mem starts word-aligned.
 *      A subtle but major concern of this code is the number of freelist
 * nodes gobbled by a single call.  If the freelist happens to not have
 * enough nodes, then a recursive call to sbm_mget is made (via sbm_nget)
 * in order to allocate a new batch of freelist nodes!  sbm_nget will
 * always provide a single "spare" node during such an allocation, but
 * there is only one and it is essential that sbm_mget gobble only ONE
 * (if any) during such a call, which is indicated by sbm_nxtra==0.
 *      The maximum # of freelist nodes that sbm_mget can gobble is
 * 2, when (1) NXM memory is obtained, and a SM is needed to point at
 * the new free mem, plus (2) the resulting SM is too big, and has to
 * be split up, which requires another SM for the remainder.
 *      The "used-NXM" smblk is set up at init time precisely in order to
 * avoid the necessity of creating it here when sbrk stops winning, since
 * that would require yet another freelist node and make it possible for
 * sbm_mget to gobble 3 during one call -- too many.
 *      Further note: the sbm_nfl checks are necessary in order
 * to ensure that a SM node is available for use by sbm_split.  Otherwise
 * the calls to sbm_split might create a new SM freelist by gobbling the
 * very memory which we are hoping to return!
 */
SBMO sbm_chksiz = SMCHUNKSIZ;   /* Current chunk size to feed sbrk */

struct smblk *
sbm_mget(cmin,cmax)
SBMO cmin,cmax;
{       register struct smblk *sm, *sml;
        register SBMO csiz;
        register SBMA addr, xaddr;

        if((sm = sbm_list) == 0         /* If never done, */
          && (sm = sbm_init((SBMA)0,(SBMO)0)) == 0)     /* initialize mem alloc stuff. */
                return(0);              /* Can't init??? */

        /* Round up sizes to word boundary */
        if(rndrem(cmin)) cmin = rndup(cmin);
        if(rndrem(cmax)) cmax = rndup(cmax);

        /* Search for a free block having enough memory.
         * If run into a free-NXM block, always "win", since there may be
         * a combination of preceding free-mem and new mem which will satisfy
         * the request.  If it turns out this didn't work, we'll just fail
         * a little farther on.
         */
retry:  csiz = cmin;                    /* Set size that will satisfy us */
        do {
                if(  ((sm->smflags&SM_USE) == 0)
                  && ((sm->smlen >= csiz) || (sm->smflags&SM_NXM)) )
                        break;
          } while(sm = sm->smforw);
        if(sm == 0)
                return(0);      /* Found none that minimum would fit */

        if(sm->smflags&SM_NXM)
          {     /* Found free area, but it's marked NXM and the system
                 * must be persuaded (via sbrk) to let us use that portion
                 * of our address space.  Grab a good-sized chunk.
                 */
                if(sbm_nfl == 0)        /* Verify a spare SM node is avail */
                        goto getnod;    /* Nope, must get one. */

                /* Decide amount of mem to ask system for, via sbrk.
                 * The fine point here is the check of sbm_nxtra to make sure
                 * that, when building more freelist nodes, we don't have
                 * to use more than one SM node in the process.  If we
                 * asked for too much mem, we'd have to use a SM node
                 * to hold the excess after splitting.
                 */
                csiz = cmax;
                if(sbm_nxtra            /* If normal then try for big chunk */
                  && csiz < sbm_chksiz) csiz = sbm_chksiz;      /* Max */
                if (csiz > sm->smlen)  csiz = sm->smlen;        /* Min */

                /* Get the NXM mem */
                if((addr = (SBMA)SBM_SBRK(csiz)) != sm->smaddr)
                  {     /* Unexpected value returned from SBRK! */

                        if((int)addr != 0 && (int)addr != -1)
                          {     return(sbm_err(0,"SBRK %o != %o", addr,
                                                sm->smaddr));
#if 0
                        /* If value indicates couldn't get the stuff, then
                         * we have probably hit our limit and the rest of
                         * NXM should be declared "used" to prevent further
                         * hopeless sbrk calls.  We split off the portion
                         * of NXM that is known for sure to be unavailable,
                         * and mark it "used".  If a "used NXM" area already
                         * exists following this one, the two are merged.
                         * The chunk size is then reduced by half, so
                         * only log2(SMCHUNKSIZ) attempts will be made, and
                         * we try again.
                         */
                                /* If returned some mem which starts outside
                                 * the NXM then something is screwed up. */
                                if(addr < sm->smaddr
                                  || (addr >= sm->smaddr+sm->smlen))
                                        return(sbm_err(0,"SBRK %o != %o",
                                                addr, sm->smaddr));
                                /* Got some mem, falls within NXM.
                                 * Presumably someone else has called sbrk
                                 * since last time, so we need to fence off
                                 * the intervening area. */
                                sm = sbm_split((sml=sm),(addr - sm->smaddr));
                                sml->smflags |= SM_USE|SM_EXT;
                                return(sbm_mget(cmin,cmax));
#endif /*COMMENT*/
                          }

                        /* Handle case of SBRK claiming no more memory.
                         * Gobble as much as we can, and then turn this NXM
                         * block into a free-mem block, and leave the
                         * remainder in the used-NXM block (which should
                         * immediately follow this free-NXM block!)
                         */
                        if(!(sml = sm->smforw)  /* Ensure have used-NXM blk */
                          || (sml->smflags&(SM_USE|SM_NXM))
                                        != (SM_USE|SM_NXM))
                                return(sbm_err(0,"No uNXM node!"));
                        xaddr = sm->smaddr;     /* Use this for checking */
                        sm->smuse = 0;          /* Use this for sum */
                        for(csiz = sm->smlen; csiz > 0;)
                          {     addr = SBM_SBRK(csiz);
                                if((int)addr == 0 || (int)addr == -1)
                                  {     csiz >>= 1;
                                        continue;
                                  }
                                if(addr != xaddr)
                                        return(sbm_err(0,"SBRK %o != %o", addr,
                                                xaddr));
                                sm->smuse += csiz;
                                xaddr += csiz;
                          }

                        /* Have gobbled as much from SBRK as we could.
                         * Turn the free-NXM block into a free-mem block,
                         * unless we got nothing, in which case just merge
                         * it into the used-NXM block and continue
                         * searching from this point.
                         */
                        if(!(csiz = sm->smuse)) /* Get total added */
                          {     sm->smflags = sml->smflags;     /* Ugh. */
                                sbm_mmrg(sm);
                                goto retry;             /* Keep looking */
                          }
                        else
                          {     sml->smaddr = sm->smaddr + csiz;
                                sml->smlen += sm->smlen - csiz;
                                sm->smlen = csiz;
                                sm->smflags &= ~SM_NXM; /* No longer NXM */
                          }
                  }

                /* Here when we've acquired CSIZ more memory from sbrk.
                 * If preceding mem area is not in use, merge new mem
                 * into it.
                 */
                if((sml = sm->smback) && 
                  (sml->smflags&(SM_USE|SM_NXM))==0)    /* Previous free? */
                  {     sml->smlen += csiz;             /* Yes, simple! */
                        sm->smaddr += csiz;             /* Fix up */
                        if((sm->smlen -= csiz) == 0)    /* If no NXM left,*/
                                sbm_mmrg(sml);  /* Merge NXM node w/prev */
                        sm = sml;               /* Prev is now winning node */
                  }
                else
                  {     /* Prev node isn't a free area.  Split up the NXM
                         * node to account for acquired mem, unless we
                         * gobbled all the mem available.
                         */
                        if(sm->smlen > csiz     /* Split unless all used */
                          && !sbm_split(sm,csiz)) /* Call shd always win */
                                return(sbm_err(0,"getsplit err: %o",sm));
                        sm->smflags &= ~SM_NXM; /* Node is now real mem */
                  }

                /* Now make a final check that we have enough memory.
                 * This can fail because SBRK may not have been able
                 * to gobble enough memory, either because (1) not
                 * as much NXM was available as we thought,
                 * or (2) we noticed the free-NXM area and immediately
                 * gambled on trying it without checking any lengths.
                 * In any case, we try again starting from the current SM
                 * because there may be more free mem higher up (eg on
                 * stack).
                 */
                if(sm->smlen < cmin)
                        goto retry;
          }

        /* Check to see if node has too much mem.  This is especially true
         * for memory just acquired via sbrk, which gobbles a huge chunk each
         * time.  If there's too much, we split up the area.
         */
        if(sm->smlen > cmax+FUDGE)      /* Got too much?  (Allow some fudge)*/
                /* Yes, split up so don't gobble too much. */
                if(sbm_nfl)                     /* If success guaranteed, */
                        sbm_split(sm,cmax);     /* split it, all's well. */
                else goto getnod;

        sm->smuse = 0;
        sm->smflags |= SM_USE;  /* Finally seize it by marking "in-use". */
        return(sm);

        /* Come here when we will need to get another SM node but the
         * SM freelist is empty.  We have to forget about using the area
         * we just found, because sbm_nget may gobble it for the
         * freelist.  So, we first force a refill of the freelist, and then
         * invoke ourselves again on what's left.
         */
getnod:
        if(sml = sbm_nget())            /* Try to build freelist */
          {     sbm_nfre(sml);          /* Won, give node back, */
                sm = sbm_list;          /* and retry, starting over! */
                goto retry;     
          }
        /* Failed.  Not enough memory for both this request
         * and one more block of SM nodes.  Since such a SM_MNODS
         * block isn't very big, we are so close to the limits that it
         * isn't worth trying to do something fancy here to satisfy the
         * original request.  So we just fail.
         */
        return(0);
}

#ifdef DBG_SIZE
/* Code for debugging stuff by imposing an artificial limitation on size
 * of available memory.
 */
SBMO sbm_dlim = MAXSBMO;        /* Amount of mem to allow (default is max) */

char *
sbm_brk(size)
unsigned size;
{       register char *addr;

        if(size > sbm_dlim) return(0);
        addr = sbrk(size);
        if((int)addr == 0 || (int)addr == -1)
                return(0);
        sbm_dlim -= size;
        return(addr);
}
#endif /*DBG_SIZE*/


/* SBM_MFREE(sm) - Free up an allocated memory area.
 */
sbm_mfree(sm)
register struct smblk *sm;
{       register struct smblk *smx;
        register SBMO crem;

        sm->smflags &= ~SM_USE;                 /* Say mem is free */
        if((smx = sm->smback)                   /* Check preceding mem */
          && (smx->smflags&(SM_USE|SM_NXM))==0) /*   If it's free, */
                sbm_mmrg(sm = smx);             /*   then merge 'em. */
        if((smx = sm->smforw)                   /* Check following mem */
          && (smx->smflags&(SM_USE|SM_NXM))==0) /*   Again, if free,  */
                sbm_mmrg(sm);                   /*   merge them.   */

        if(sm->smlen == 0)              /* Just in case, chk for null blk */
          {     if(smx = sm->smback)            /* If pred exists, */
                        sbm_mmrg(smx);          /* merge quietly. */
                else {
                        sbm_list = sm->smforw;  /* 1st node on list, so */
                        sbm_nfre(sm);           /* simply flush it. */
                  }
                return;
          }

        /* This code is slightly over-general for some machines.
         * The pointer subtraction is done in order to get a valid integer
         * offset value regardless of the internal representation of a pointer.
         * We cannot reliably force alignment via casts; some C implementations
         * treat that as a no-op.
         */
        if(crem = rndrem(sm->smaddr - sbm_lowaddr))     /* On word bndry? */
          {     /* No -- must adjust.  All free mem blks MUST, by fiat,
                 * start on word boundary.  Here we fix things by
                 * making the leftover bytes belong to the previous blk,
                 * no matter what it is used for.  Prev blk is guaranteed to
                 * (1) Exist (this cannot be 1st blk since 1st is known to
                 * start on wd boundary) and to be (2) Non-free (else it would
                 * have been merged).
                 */
                if((smx = sm->smback) == 0)     /* Get ptr to prev blk */
                  {     sbm_err(0,"Align err"); /* Catch screws */
                        return;
                  }
                crem = WDSIZE - crem;   /* Find # bytes to flush */
                if(crem >= sm->smlen)   /* Make sure node has that many */
                  {     sbm_mmrg(smx);  /* Flush node to avoid zero length */
                        return;
                  }
                smx->smlen += crem;     /* Make stray bytes part of prev */
                sm->smaddr += crem;     /* And flush from current. */
                sm->smlen -= crem;
          }
}


/* SBM_EXP - Expand (or shrink) size of an allocated memory chunk.
 *      "nsize" is desired new size; may be larger or smaller than current
 *      size.
 */
struct smblk *
sbm_exp(sm,size)
register struct smblk *sm;
register SBMO size;
{       register struct smblk *smf;
        register SBMO mexp, pred, succ;

        if(sm->smlen >= size)           /* Do we want truncation? */
                goto realo2;            /* Yup, go split block */

        /* Block is expanding. */
        mexp = size - sm->smlen;                /* Get # bytes to expand by */
        pred = succ = 0;
        if((smf = sm->smforw)                   /* See if free mem follows */
         && (smf->smflags&(SM_USE|SM_NXM)) == 0)
                if((succ = smf->smlen) >= mexp)
                        goto realo1;            /* Quick stuff if succ OK */

        if((smf = sm->smback)                   /* See if free mem precedes */
         && (smf->smflags&(SM_USE|SM_NXM)) == 0)
                pred = smf->smlen;

        /* If not enough free space combined on both sides of this chunk,
         * we have to look for a completely new block.
         */
        if(pred+succ < mexp)
          {     if((smf = sbm_mget(size,size)) == 0)
                        return(0);              /* Couldn't find one */
                else pred = 0;                  /* Won, indicate new block */
          }

        /* OK, must copy either into new block or down into predecessor
         * (overlap is OK as long as bcopy moves 1st byte first)
         */
        bcopy(sm->smaddr, smf->smaddr, sm->smlen);
        smf->smflags = sm->smflags;     /* Copy extra attribs */
        smf->smuse = sm->smuse;
        if(!pred)                       /* If invoked sbm_mget */
          {     sbm_mfree(sm);          /* then must free up old area */
                return(smf);            /* and can return immediately. */
          }
        sbm_mmrg(smf);                  /* Merge current into pred blk */
        sm = smf;                       /* Now pred is current blk. */

        if(succ)
realo1:         sbm_mmrg(sm);           /* Merge succ into current blk */
realo2: if(sm->smlen > size             /* If now have too much, */
          && sbm_split(sm, size))       /* split up and possibly */
                sbm_mfree(sm->smforw);  /* free up unused space. */
        return(sm);

        /* Note that sbm_split can fail if it can't get a free node,
         * which is only possible if we are reducing the size of an area.
         * If it fails, we just return anyway without truncating the area.
         */
}


/* SBM_MMRG(sm) - Merge a memory area with the area following it.
 *      The node (and memory area) following the SM pointed to are
 *      merged in and the successor node freed up.  The flags
 *      and smuse of the current SM (which is not moved or anything)
 *      remain the same.
 */
sbm_mmrg(smp)
struct smblk *smp;
{       register struct smblk *sm, *sm2;

        sm = smp;
        sm->smlen += (sm2 = sm->smforw)->smlen; /* Add succ's len */
        if(sm->smforw = sm2->smforw)            /* and fix linkages */
                sm->smforw->smback = sm;
        sbm_nfre(sm2);                          /* now can flush succ node */
}

/* SBM_SPLIT - Split up an area (gets a new smblk to point to split-off
 *      portion.)
 * Note returned value is ptr to 2nd smblk, since this is a new one.
 * Ptr to 1st remains valid since original smblk stays where it is.
 * NOTE: Beware of splitting up free mem (SM_USE == 0) since sbm_nget may
 * steal it out from under unless precautions are taken!  See comments
 * at sbm_mget related to this.
 */
struct smblk *
sbm_split(smp,coff)
struct smblk *smp;
SBMO coff;
{       register struct smblk *sm, *smx;
        register SBMO csiz;

        if((sm = smp)->smlen <= (csiz = coff))
                return(0);
        if((smx = sbm_nget()) == 0)
                return(0);
        smx->smlen = sm->smlen - csiz;          /* Set 2nd size */
        smx->smaddr = sm->smaddr + csiz;        /* Set 2nd addr */
        sm->smlen = csiz;                       /* Take from 1st size */
        smx->smflags = sm->smflags;             /* Copy flags */
        if(smx->smforw = sm->smforw)            /* Splice 2nd after 1 */
                smx->smforw->smback = smx;
        smx->smback = sm;
        sm->smforw = smx;                       /* Put 2nd into chain */
        return(smx);                            /* Return ptr to 2nd smblk */
}

#if 0   /* Replaced by "bcopy" for system-dep efficiency */
/* SBM_SCPY - Copy string of bytes.  Somewhat machine-dependent;
 *      Tries to be clever about using word moves instead of byte moves.
 */
sbm_scpy(from, to, count)       /* Copy count bytes from -> to */
char *from, *to;
unsigned count;
{       register char *s1, *s2;
        register unsigned cnt;
        int tmp;

        if((cnt = count) == 0)
                return;
        s1 = from;
        s2 = to;
        while(rndrem((int)s1))          /* Get 1st ptr aligned */
          {     *s2++ = *s1++;
                if(--cnt == 0) return;
          }
        if(rndrem((int)s2) == 0)        /* Do wd move if ptr 2 now aligned */
          {
#ifdef DUMBPCC /* Code for dumber (Portable C type) compiler */
                register WORD *ap, *bp;
                tmp = cnt;
                ap = (WORD *) s1;
                bp = (WORD *) s2;
                if(cnt = rnddiv(cnt))
                        do { *bp++ = *ap++; }
                        while(--cnt);
                if ((cnt = rndrem(tmp)) ==0)
                        return;
                s1 = (char *) ap;
                s2 = (char *) bp;
#else
        /* Tight loop for efficient copying on 11s */
                tmp = cnt;
                if(cnt = rnddiv(cnt))
                        do { *((WORD *)s2)++ = *((WORD *)s1)++; }
                        while(--cnt);
                if((cnt = rndrem(tmp)) == 0)
                        return;
#endif /*-DUMBPCC*/
          }                             
        do { *s2++ = *s1++; }   /* Finish up with byte loop */
        while(--cnt);
}
#endif /*COMMENT*/

struct smblk *          /* If it returns at all, this is most common type */
sbm_err(val,str,a0,a1,a2,a3)
char *str;
struct smblk *val;
{       int *sptr;

        sptr = (int *) &sptr;   /* Point to self on stack */
        sptr += 5;              /* Point to return addr */
        if((int)sbm_debug==1)
                abort();
        if(sbm_debug)
                (*sbm_debug)(0,*sptr,str,a0,a1,a2,a3);
        return(val);
}


/* These routines correspond to the V7 LIBC routines as described
 * in the V7 UPM (3).  They should provide satisfactory emulation
 * if the documentation is correct.  Replacement is necessary since
 * the SBM routines are jealous and cannot tolerate competition for
 * calls of SBRK; i.e. the memory being managed must be contiguous.
 */

/* Guaranteed to return word-aligned pointer to area of AT LEAST
 * requested size.  Area size is rounded up to word boundary.
 */

char *
malloc(size)
unsigned size;
{       register struct smblk *sm, **sma;
        register SBMO siz;

        siz = rndup(size + sizeof (struct smblk *));   /* Make room for ptr */
        if((sm = sbm_mget(siz,siz)) == 0)
                return(0);
        *(sma = (struct smblk **)sm->smaddr) = sm; /* Store ptr in addr-1 */
        return((char *)++sma);
}

char *
alloc(size)     /* For V6 programs - note different failure value! */
unsigned size;
{       register char *addr;
        return((addr = malloc(size)) ? addr : (char *) -1);
}

free(ptr)
char *ptr;
{       register struct smblk *sm, **smp;

        smp = &((struct smblk **)ptr)[-1];      /* Point to addr-1 */
        sm = *smp;                              /* Pluck SM ptr therefrom */
        if(((sm->smflags&0377) != SM_NID) || sm->smaddr != (SBMA)smp)
                return((int)sbm_err(0,"free: bad arg %o", ptr));
        sbm_mfree(sm);
        return(1);
}

char *
realloc(ptr,size)
char *ptr;
unsigned size;
{       register struct smblk *sm, **smp;

        smp = &((struct smblk **)ptr)[-1];      /* Point to addr-1 */
        sm = *smp;                              /* Pluck SM ptr therefrom */
        if(((sm->smflags&0377) != SM_NID) || (sm->smaddr != (SBMA)smp))
                return((char *)sbm_err(0,"realloc: bad arg %o",ptr));
        if((sm = sbm_exp(sm, rndup(size+(sizeof(struct smblk *))))) == 0)
                return(0);
        *(smp = (struct smblk **)sm->smaddr) = sm;      /* Save smblk ptr */
        return((char *)++smp);
}

char *
calloc(nelem,elsize)
unsigned nelem, elsize;
{       register SBMO cmin;
        register WORD *ip;                     /* Clear in units of words */
        register char *addr;

        if((cmin = nelem*elsize) == 0           /* Find # bytes to get */
          || (addr = malloc(cmin)) == 0)        /* Get it */
                return(0);
        ip = (WORD *) addr;                     /* Set up ptr to area */
        cmin = rnddiv(cmin+WDSIZE-1);           /* Find # words to clear */
        do { *ip++ = 0; } while (--cmin);       /* Zap the area */
        return(addr);
}


/* SBM_NGC() - Specific routine for GC'ing SMBLK nodes.
 *
 * SBM_XNGC(begp, elsize, type) - Compact nodes of specified type.
 *      Scans allocated mem from low to high to find chunks with nodes of
 *      the specified type.
 *      Flushes current freelist and rebuilds it as scan progresses,
 *      such that 1st thing on list is lowest-addr node.  When a node is
 *      seen that can be moved, new node is acquired from freelist if
 *      it exists, otherwise no move is made.  If a chunk has been scanned
 *      and no active nodes remain, it is flushed and freelist updated.
 *      NOTE: This has not yet been verified to work with nodes of any
 *              type other than SMBLK.
 */

sbm_ngc()
{       register struct smblk *sm;
        if(!(sm = sbm_nxtra))
                return((int)sbm_err(0,"Zero sbm_nxtra"));
        sm->smflags |= SM_USE;          /* Ensure this one isn't GC'd */
        sbm_xngc(&sbm_nfl, sizeof(struct smblk), SM_MNODS);
        sm->smflags = 0;                /* Flush temporary crock */
}
sbm_xngc(begp, elsize, flag)
struct smblk **begp;
unsigned elsize, flag;
{       register struct smblk *sm, *chk, *smf;
        struct smblk *ftail, *savtail;
        int cnt, inuse;

        *begp = ftail = 0;              /* Flush node freelist */
        for(chk = sbm_list; chk; chk = chk->smforw)
          if(chk->smflags&flag)
            {   sm = (struct smblk *) chk->smaddr;
                cnt = (chk->smuse)/elsize;
                savtail = ftail;
                inuse = 0;
                smf = *begp;
                                         /* Set up ptr to 1st freelist node */
                while(--cnt >= 0)
                  {     /* Here decide if movable */
                        if(sm->smflags && smf   /* Live and have copy place */
                          && (
                                (sm->smflags&SM_USE) == 0       /* Free mem? */
                            ||  (sm->smflags&(SM_MNODS|SM_DNODS))
                             )
                          && sm->smback)        /* has backptr (see ncpy) */
                          {                             /* Move the node */
                                *begp = smf->smforw;    /* Get free node */
                                if(smf == ftail)
                                        ftail = 0;
                                if(smf == savtail)
                                        savtail = 0;
                                /* Move node.  Already checked for back ptr
                                 * of 0 since no obvious way to tell where
                                 * the ptr to list is kept.  Sigh.
                                 */
                                sbm_nmov(sm,smf,(struct smblk **)0,elsize);
                                /* Get ptr to new freelist node.  Note
                                 * check to ensure that it is not in this
                                 * same chunk (if it is, no point in moving
                                 * any nodes!)
                                 */
                                if((smf = *begp) >= chk)
                                        smf = 0;        /* Zero if same chk */
                                sm->smflags = 0;        /* Make node free */
                          }
                        /* At this point, not movable */
                        if(sm->smflags == 0)            /* Free node? */
                          {     if(ftail)               /* Add to freelist */
                                        ftail->smforw = sm;
                                ftail = sm;
                                if(*begp == 0)
                                        *begp = sm;
                                sm->smforw = 0;
                          }
                        else inuse++;
                        sm = (struct smblk *)((SBMA)sm + elsize);
                  }
                if(inuse == 0                           /* All free? */
                  && (sm = chk->smback))                /* & not 1st? */
                  {     if(savtail)                     /* Edit freelist */
                                (ftail = savtail)->smforw = 0;
                        else *begp = ftail = 0;
                        sbm_mfree(chk);
                        chk = sm;
                  }
            }
}

/*
 *      Note that proc must return a zero value, or loop aborts and
 *      returns that selfsame value.
 */
sbm_nfor(flag,nodsiz,proc,arg)
int flag;
int (*proc)();
int nodsiz;
struct sbfile *arg;
{       register struct smblk *sm, *np;
        register int cnt;
        int res;

        for(sm = sbm_list; sm; sm = sm->smforw)
          if(sm->smflags&flag)
            {   np = (struct smblk *) sm->smaddr;
                cnt = sm->smuse/nodsiz;
                do {
                        if(np->smflags)
                                if(res = (*proc)(np,arg))
                                        return(res);
                        np = (struct smblk *)((SBMA)np + nodsiz);
                  } while(--cnt);
            }
        return(0);
}