generalize uba code to handle Q bus more gracefully

[unix-history] / usr / src / sys / kern / subr_xxx.c

/*
* Copyright (c) 1982, 1986 Regents of the University of California.
* All rights reserved.  The Berkeley software License Agreement
* specifies the terms and conditions for redistribution.
*
*      @(#)subr_xxx.c  7.1 (Berkeley) %G%
*/

#include "../machine/pte.h"

#include "param.h"
#include "systm.h"
#include "conf.h"
#include "inode.h"
#include "dir.h"
#include "user.h"
#include "buf.h"
#include "proc.h"
#include "fs.h"
#include "vm.h"
#include "cmap.h"
#include "uio.h"

/*
* Routine placed in illegal entries in the bdevsw and cdevsw tables.
*/
nodev()
{

       return (ENODEV);
}

/*
* Null routine; placed in insignificant entries
* in the bdevsw and cdevsw tables.
*/
nulldev()
{

       return (0);
}

#ifdef notdef
imin(a, b)
{

       return (a < b ? a : b);
}

imax(a, b)
{

       return (a > b ? a : b);
}

unsigned
min(a, b)
       u_int a, b;
{

       return (a < b ? a : b);
}

unsigned
max(a, b)
       u_int a, b;
{

       return (a > b ? a : b);
}
#endif notdef

extern  cabase, calimit;
extern  struct pte camap[];

caddr_t cacur = (caddr_t)&cabase;
caddr_t camax = (caddr_t)&cabase;
int     cax = 0;
/*
* This is a kernel-mode storage allocator.
* It is very primitive, currently, in that
* there is no way to give space back.
* It serves, for the time being, the needs of
* auto-configuration code and the like which
* need to allocate some stuff at boot time.
*/
caddr_t
calloc(size)
       int size;
{
       register caddr_t res;
       register int i;

       if (cacur+size >= (caddr_t)&calimit)
               panic("calloc");
       while (cacur+size > camax) {
               (void) vmemall(&camap[cax], CLSIZE, &proc[0], CSYS);
               vmaccess(&camap[cax], camax, CLSIZE);
               for (i = 0; i < CLSIZE; i++)
                       clearseg(camap[cax++].pg_pfnum);
               camax += NBPG * CLSIZE;
       }
       res = cacur;
       cacur += size;
       return (res);
}

#ifdef GPROF
/*
* Stub routine in case it is ever possible to free space.
*/
cfreemem(cp, size)
       caddr_t cp;
       int size;
{
       printf("freeing %x, size %d\n", cp, size);
}
#endif

#ifndef vax
ffs(mask)
       register long mask;
{
       register int i;

       for(i = 1; i < NSIG; i++) {
               if (mask & 1)
                       return (i);
               mask >>= 1;
       }
       return (0);
}

bcmp(s1, s2, len)
       register char *s1, *s2;
       register int len;
{

       while (len--)
               if (*s1++ != *s2++)
                       return (1);
       return (0);
}

strlen(s1)
       register char *s1;
{
       register int len;

       for (len = 0; *s1++ != '\0'; len++)
               /* void */;
       return (len);
}
#endif