Return to kern_malloc.c CVS log

Up to [Apple Darwin 0.x] / kernel / bsd / kern

Annotation of kernel/bsd/kern/kern_malloc.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
        !             3:  *
        !             4:  * @APPLE_LICENSE_HEADER_START@
        !             5:  * 
        !             6:  * Portions Copyright (c) 1999 Apple Computer, Inc.  All Rights
        !             7:  * Reserved.  This file contains Original Code and/or Modifications of
        !             8:  * Original Code as defined in and that are subject to the Apple Public
        !             9:  * Source License Version 1.1 (the "License").  You may not use this file
        !            10:  * except in compliance with the License.  Please obtain a copy of the
        !            11:  * License at http://www.apple.com/publicsource and read it before using
        !            12:  * this file.
        !            13:  * 
        !            14:  * The Original Code and all software distributed under the License are
        !            15:  * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
        !            16:  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
        !            17:  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
        !            18:  * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
        !            19:  * License for the specific language governing rights and limitations
        !            20:  * under the License.
        !            21:  * 
        !            22:  * @APPLE_LICENSE_HEADER_END@
        !            23:  */
        !            24: 
        !            25: /* Copyright (c) 1995, 1997 Apple Computer, Inc. All Rights Reserved */
        !            26: /*
        !            27:  * Copyright (c) 1987, 1991, 1993
        !            28:  *     The Regents of the University of California.  All rights reserved.
        !            29:  *
        !            30:  * Redistribution and use in source and binary forms, with or without
        !            31:  * modification, are permitted provided that the following conditions
        !            32:  * are met:
        !            33:  * 1. Redistributions of source code must retain the above copyright
        !            34:  *    notice, this list of conditions and the following disclaimer.
        !            35:  * 2. Redistributions in binary form must reproduce the above copyright
        !            36:  *    notice, this list of conditions and the following disclaimer in the
        !            37:  *    documentation and/or other materials provided with the distribution.
        !            38:  * 3. All advertising materials mentioning features or use of this software
        !            39:  *    must display the following acknowledgement:
        !            40:  *     This product includes software developed by the University of
        !            41:  *     California, Berkeley and its contributors.
        !            42:  * 4. Neither the name of the University nor the names of its contributors
        !            43:  *    may be used to endorse or promote products derived from this software
        !            44:  *    without specific prior written permission.
        !            45:  *
        !            46:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
        !            47:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
        !            48:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
        !            49:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
        !            50:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
        !            51:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
        !            52:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
        !            53:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
        !            54:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
        !            55:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
        !            56:  * SUCH DAMAGE.
        !            57:  *
        !            58:  *     @(#)kern_malloc.c       8.4 (Berkeley) 5/20/95
        !            59:  */
        !            60: 
        !            61: #include <sys/param.h>
        !            62: #include <sys/malloc.h>
        !            63: 
        !            64: #include <sys/socket.h>
        !            65: #include <sys/socketvar.h>
        !            66: 
        !            67: #include <net/route.h>
        !            68: 
        !            69: #include <netinet/in.h>
        !            70: #include <netinet/in_systm.h>
        !            71: #include <netinet/ip.h>
        !            72: #include <netinet/in_pcb.h>
        !            73: 
        !            74: #include <sys/proc.h>
        !            75: #include <sys/mount.h>
        !            76: #include <sys/vnode.h>
        !            77: #include <sys/namei.h>
        !            78: #include <sys/file.h>
        !            79: #include <sys/filedesc.h>
        !            80: #include <sys/tty.h>
        !            81: 
        !            82: #include <ufs/ufs/quota.h>
        !            83: #include <ufs/ufs/inode.h>
        !            84: 
        !            85: #include <nfs/rpcv2.h>
        !            86: #include <nfs/nfsproto.h>
        !            87: #include <nfs/nfsnode.h>
        !            88: #include <nfs/nfsmount.h>
        !            89: #include <nfs/nqnfs.h>
        !            90: 
        !            91: #include <mach/mach_types.h>
        !            92: 
        !            93: #include <kern/zalloc.h>
        !            94: #include <kern/kalloc.h>
        !            95: 
        !            96: struct kmemstats kmemstats[M_LAST];
        !            97: char *memname[] = INITKMEMNAMES;
        !            98: 
        !            99: struct kmzones {
        !           100:        size_t          kz_elemsize;
        !           101:        void            *kz_zalloczone;
        !           102: #define        KMZ_CREATEZONE          ((void *)-2)
        !           103: #define KMZ_LOOKUPZONE         ((void *)-1)
        !           104: #define KMZ_MALLOC             ((void *)0)
        !           105: #define        KMZ_SHAREZONE           ((void *)1)
        !           106: } kmzones[] = {
        !           107: #define        SOS(sname)      sizeof (struct sname)
        !           108: #define SOX(sname)     -1
        !           109:        -1,             0,                      /* 0 M_FREE */
        !           110:        MSIZE,          KMZ_CREATEZONE,         /* 1 M_MBUF */
        !           111:        0,              KMZ_MALLOC,             /* 2 M_DEVBUF */
        !           112:        SOS(socket),    KMZ_CREATEZONE,         /* 3 M_SOCKET */
        !           113:        SOS(inpcb),     KMZ_LOOKUPZONE,         /* 4 M_PCB */
        !           114:        M_MBUF,         KMZ_SHAREZONE,          /* 5 M_RTABLE */
        !           115:        M_MBUF,         KMZ_SHAREZONE,          /* 6 M_HTABLE */
        !           116:        M_MBUF,         KMZ_SHAREZONE,          /* 7 M_FTABLE */
        !           117:        SOS(rusage),    KMZ_CREATEZONE,         /* 8 M_ZOMBIE */
        !           118:        0,              KMZ_MALLOC,             /* 9 M_IFADDR */
        !           119:        M_MBUF,         KMZ_SHAREZONE,          /* 10 M_SOOPTS */
        !           120:        0,              KMZ_MALLOC,             /* 11 M_SONAME */
        !           121:        MAXPATHLEN,     KMZ_CREATEZONE,         /* 12 M_NAMEI */
        !           122:        0,              KMZ_MALLOC,             /* 13 M_GPROF */
        !           123:        0,              KMZ_MALLOC,             /* 14 M_IOCTLOPS */
        !           124:        0,              KMZ_MALLOC,             /* 15 M_MAPMEM */
        !           125:        SOS(ucred),     KMZ_CREATEZONE,         /* 16 M_CRED */
        !           126:        SOS(pgrp),      KMZ_CREATEZONE,         /* 17 M_PGRP */
        !           127:        SOS(session),   KMZ_CREATEZONE,         /* 18 M_SESSION */
        !           128:        SOS(iovec),     KMZ_LOOKUPZONE,         /* 19 M_IOV */
        !           129:        SOS(mount),     KMZ_CREATEZONE,         /* 20 M_MOUNT */
        !           130:        0,              KMZ_MALLOC,             /* 21 M_FHANDLE */
        !           131:        SOS(nfsreq),    KMZ_CREATEZONE,         /* 22 M_NFSREQ */
        !           132:        SOS(nfsmount),  KMZ_CREATEZONE,         /* 23 M_NFSMNT */
        !           133:        SOS(nfsnode),   KMZ_CREATEZONE,         /* 24 M_NFSNODE */
        !           134:        SOS(vnode),     KMZ_CREATEZONE,         /* 25 M_VNODE */
        !           135:        SOS(namecache), KMZ_CREATEZONE,         /* 26 M_CACHE */
        !           136:        SOX(dquot),     KMZ_LOOKUPZONE,         /* 27 M_DQUOT */
        !           137:        SOX(ufsmount),  KMZ_LOOKUPZONE,         /* 28 M_UFSMNT */
        !           138:        0,              KMZ_MALLOC,             /* 29 M_CGSUM */
        !           139:        0,              KMZ_MALLOC,             /* 30 M_VMMAP */
        !           140:        0,              KMZ_MALLOC,             /* 31 M_VMMAPENT */
        !           141:        0,              KMZ_MALLOC,             /* 32 M_VMOBJ */
        !           142:        0,              KMZ_MALLOC,             /* 33 M_VMOBJHASH */
        !           143:        0,              KMZ_MALLOC,             /* 34 M_VMPMAP */
        !           144:        0,              KMZ_MALLOC,             /* 35 M_VMPVENT */
        !           145:        0,              KMZ_MALLOC,             /* 36 M_VMPAGER */
        !           146:        0,              KMZ_MALLOC,             /* 37 M_VMPGDATA */
        !           147:        SOS(file),      KMZ_CREATEZONE,         /* 38 M_FILE */
        !           148:        SOS(filedesc),  KMZ_CREATEZONE,         /* 39 M_FILEDESC */
        !           149:        SOX(lockf),     KMZ_CREATEZONE,         /* 40 M_LOCKF */
        !           150:        SOS(proc),      KMZ_CREATEZONE,         /* 41 M_PROC */
        !           151:        SOS(pcred),     KMZ_CREATEZONE,         /* 42 M_SUBPROC */
        !           152:        0,              KMZ_MALLOC,             /* 43 M_SEGMENT */
        !           153:        M_FFSNODE,      KMZ_SHAREZONE,          /* 44 M_LFSNODE */
        !           154:        SOS(inode),     KMZ_CREATEZONE,         /* 45 M_FFSNODE */
        !           155:        M_FFSNODE,      KMZ_SHAREZONE,          /* 46 M_MFSNODE */
        !           156:        SOS(nqlease),   KMZ_CREATEZONE,         /* 47 M_NQLEASE */
        !           157:        SOS(nqm),       KMZ_CREATEZONE,         /* 48 M_NQMHOST */
        !           158:        0,              KMZ_MALLOC,             /* 49 M_NETADDR */
        !           159:        SOX(nfssvc_sock),
        !           160:                        KMZ_CREATEZONE,         /* 50 M_NFSSVC */
        !           161:        SOS(nfsuid),    KMZ_CREATEZONE,         /* 51 M_NFSUID */
        !           162:        SOX(nfsrvcache),
        !           163:                        KMZ_CREATEZONE,         /* 52 M_NFSD */
        !           164:        SOX(ip_moptions),
        !           165:                        KMZ_LOOKUPZONE,         /* 53 M_IPMOPTS */
        !           166:        SOX(in_multi),  KMZ_LOOKUPZONE,         /* 54 M_IPMADDR */
        !           167:        SOX(ether_multi),
        !           168:                        KMZ_LOOKUPZONE,         /* 55 M_IFMADDR */
        !           169:        SOX(mrt),       KMZ_CREATEZONE,         /* 56 M_MRTABLE */
        !           170:        0,              0,                      /* 57 M_ISOFSMNT */
        !           171:        0,              0,                      /* 58 M_ISOFSNODE */
        !           172:        SOS(nfsrv_descript),
        !           173:                        KMZ_CREATEZONE,         /* 59 M_NFSRVDESC */
        !           174:        SOS(nfsdmap),   KMZ_CREATEZONE,         /* 60 M_NFSDIROFF */
        !           175:        SOS(fhandle),   KMZ_LOOKUPZONE,         /* 61 M_NFSBIGFH */
        !           176:        0,              KMZ_MALLOC,             /* 62 M_MSDOSFSMNT */
        !           177:        0,              KMZ_MALLOC,             /* 63 M_MSDOSFSFAT */
        !           178:        0,              KMZ_MALLOC,             /* 64 M_MSDOSFSNODE */
        !           179:        SOS(tty),       KMZ_CREATEZONE,         /* 65 M_TTYS */
        !           180:        0,              KMZ_MALLOC,             /* 66 M_EXEC */
        !           181:        0,              KMZ_MALLOC,             /* 67 M_MISCFSMNT */
        !           182:        0,              KMZ_MALLOC,             /* 68 M_MISCFSNODE */
        !           183:        0,              KMZ_MALLOC,             /* 69 M_ADOSFSMNT */
        !           184:        0,              KMZ_MALLOC,             /* 70 M_ADOSFSNODE */
        !           185:        0,              KMZ_MALLOC,             /* 71 M_ANODE */
        !           186:        SOX(buf),       KMZ_CREATEZONE,         /* 72 M_BUFHDR */
        !           187:        (NDFILE * OFILESIZE),
        !           188:                        KMZ_CREATEZONE,         /* 73 M_OFILETABL */
        !           189:        MCLBYTES,       KMZ_CREATEZONE,         /* 74 M_MCLUST */
        !           190:        0,              KMZ_MALLOC,             /* 75 M_TEMP */
        !           191: #undef SOS
        !           192: #undef SOX
        !           193: };
        !           194: 
        !           195: 
        !           196: /*
        !           197:  * Initialize the kernel memory allocator
        !           198:  */
        !           199: void
        !           200: kmeminit(void)
        !           201: {
        !           202:        struct kmzones  *kmz;
        !           203: 
        !           204:        kmz = kmzones;
        !           205:        while (kmz < &kmzones[M_LAST]) {
        !           206: /* XXX */
        !           207:                if (kmz->kz_elemsize == -1)
        !           208:                        ;
        !           209:                else
        !           210: /* XXX */
        !           211:                if (kmz->kz_zalloczone == KMZ_CREATEZONE) {
        !           212:                        kmz->kz_zalloczone = zinit(kmz->kz_elemsize,
        !           213:                                                1024 * 1024, PAGE_SIZE, FALSE,
        !           214:                                                memname[kmz - kmzones]);
        !           215:                }
        !           216:                else if (kmz->kz_zalloczone == KMZ_LOOKUPZONE)
        !           217:                        kmz->kz_zalloczone = kalloc_zone(kmz->kz_elemsize);
        !           218: 
        !           219:                kmz++;
        !           220:        }
        !           221: 
        !           222:        kmz = kmzones;
        !           223:        while (kmz < &kmzones[M_LAST]) {
        !           224: /* XXX */
        !           225:                if (kmz->kz_elemsize == -1)
        !           226:                        ;
        !           227:                else
        !           228: /* XXX */
        !           229:                if (kmz->kz_zalloczone == KMZ_SHAREZONE) {
        !           230:                        kmz->kz_zalloczone =
        !           231:                                kmzones[kmz->kz_elemsize].kz_zalloczone;
        !           232:                        kmz->kz_elemsize =
        !           233:                                kmzones[kmz->kz_elemsize].kz_elemsize;
        !           234:                }
        !           235: 
        !           236:                kmz++;
        !           237:        }
        !           238: }
        !           239: 
        !           240: #define        MDECL(reqlen)                                   \
        !           241: union {                                                        \
        !           242:        struct  _mhead hdr;                             \
        !           243:        char    _m[(reqlen) + sizeof (struct _mhead)];  \
        !           244: }
        !           245: 
        !           246: struct _mhead {
        !           247:        size_t  mlen;
        !           248:        char    dat[0];
        !           249: };
        !           250: 
        !           251: void *_MALLOC(
        !           252:        size_t          size,
        !           253:        int             type,
        !           254:        int             flags)
        !           255: {
        !           256:        MDECL(size)     *mem;
        !           257:        size_t          memsize = sizeof (*mem);
        !           258: 
        !           259:        if (type >= M_LAST)
        !           260:                panic("_malloc TYPE");
        !           261: 
        !           262:        if (size == 0)
        !           263:                return (0);
        !           264: 
        !           265:        if (flags & M_NOWAIT) {
        !           266:                mem = (void *)kalloc_noblock(memsize);
        !           267:        } else {
        !           268:                mem = (void *)kalloc(memsize);
        !           269:        }
        !           270:        if (!mem)
        !           271:                return (0);
        !           272: 
        !           273:        mem->hdr.mlen = memsize;
        !           274: 
        !           275:        return  (mem->hdr.dat);
        !           276: }
        !           277: 
        !           278: void _FREE(
        !           279:        void            *addr,
        !           280:        int             type)
        !           281: {
        !           282:        struct _mhead   *hdr;
        !           283: 
        !           284:        if (type >= M_LAST)
        !           285:                panic("_free TYPE");
        !           286: 
        !           287:        if (!addr)
        !           288:                return;
        !           289: 
        !           290:        hdr = addr; hdr--;
        !           291:        kfree((vm_offset_t)hdr, hdr->mlen);
        !           292: }
        !           293: 
        !           294: void *_MALLOC_ZONE(
        !           295:        size_t          size,
        !           296:        int             type,
        !           297:        int             flags)
        !           298: {
        !           299:        struct kmzones  *kmz;
        !           300:        void            *elem;
        !           301: 
        !           302:        if (type >= M_LAST)
        !           303:                panic("_malloc_zone TYPE");
        !           304: 
        !           305:        kmz = &kmzones[type];
        !           306:        if (kmz->kz_zalloczone == KMZ_MALLOC)
        !           307:                panic("_malloc_zone ZONE");
        !           308: 
        !           309: /* XXX */
        !           310:        if (kmz->kz_elemsize == -1)
        !           311:                panic("_malloc_zone XXX");
        !           312: /* XXX */
        !           313:        if (size == kmz->kz_elemsize)
        !           314:                if (flags & M_NOWAIT) {
        !           315:                        elem = (void *)zalloc_noblock(kmz->kz_zalloczone);
        !           316:                } else {
        !           317:                        elem = (void *)zalloc(kmz->kz_zalloczone);
        !           318:                }
        !           319:        else
        !           320:                if (flags & M_NOWAIT) {
        !           321:                        elem = (void *)kalloc_noblock(size);
        !           322:                } else {
        !           323:                        elem = (void *)kalloc(size);
        !           324:                }
        !           325: 
        !           326:        return (elem);
        !           327: }
        !           328: 
        !           329: void _FREE_ZONE(
        !           330:        void            *elem,
        !           331:        size_t          size,
        !           332:        int             type)
        !           333: {
        !           334:        struct kmzones  *kmz;
        !           335: 
        !           336:        if (type >= M_LAST)
        !           337:                panic("FREE_SIZE");
        !           338: 
        !           339:        kmz = &kmzones[type];
        !           340:        if (kmz->kz_zalloczone == KMZ_MALLOC)
        !           341:                panic("free_zone ZONE");
        !           342: 
        !           343: /* XXX */
        !           344:        if (kmz->kz_elemsize == -1)
        !           345:                panic("FREE_SIZE XXX");
        !           346: /* XXX */
        !           347:        if (size == kmz->kz_elemsize)
        !           348:                zfree(kmz->kz_zalloczone, (vm_offset_t)elem);
        !           349:        else
        !           350:                kfree((vm_offset_t)elem, size);
        !           351: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.