Return to kern_malloc.c CVS log

Up to [Apple XNU] / XNU / bsd / kern

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

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

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