/* * Copyright (C) 2000 Takashi Iwai * * Generic memory management routines for soundcard memory allocation * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include #include #include #include #include #include MODULE_AUTHOR("Takashi Iwai"); MODULE_DESCRIPTION("Generic memory management routines for soundcard memory allocation"); MODULE_LICENSE("GPL"); #define get_memblk(p) list_entry(p, struct snd_util_memblk, list) /* * create a new memory manager */ struct snd_util_memhdr * snd_util_memhdr_new(int memsize) { struct snd_util_memhdr *hdr; hdr = kzalloc(sizeof(*hdr), GFP_KERNEL); if (hdr == NULL) return NULL; hdr->size = memsize; mutex_init(&hdr->block_mutex); INIT_LIST_HEAD(&hdr->block); return hdr; } /* * free a memory manager */ void snd_util_memhdr_free(struct snd_util_memhdr *hdr) { struct list_head *p; if (!hdr) return; /* release all blocks */ while ((p = hdr->block.next) != &hdr->block) { list_del(p); kfree(get_memblk(p)); } kfree(hdr); } /* * allocate a memory block (without mutex) */ struct snd_util_memblk * __snd_util_mem_alloc(struct snd_util_memhdr *hdr, int size) { struct snd_util_memblk *blk; unsigned int units, prev_offset; struct list_head *p; if (snd_BUG_ON(!hdr || size <= 0)) return NULL; /* word alignment */ units = size; if (units & 1) units++; if (units > hdr->size) return NULL; /* look for empty block */ prev_offset = 0; list_for_each(p, &hdr->block) { blk = get_memblk(p); if (blk->offset - prev_offset >= units) goto __found; prev_offset = blk->offset + blk->size; } if (hdr->size - prev_offset < units) return NULL; __found: return __snd_util_memblk_new(hdr, units, p->prev); } /* * create a new memory block with the given size * the block is linked next to prev */ struct snd_util_memblk * __snd_util_memblk_new(struct snd_util_memhdr *hdr, unsigned int units, struct list_head *prev) { struct snd_util_memblk *blk; blk = kmalloc(sizeof(struct snd_util_memblk) + hdr->block_extra_size, GFP_KERNEL); if (blk == NULL) return NULL; if (prev == &hdr->block) blk->offset = 0; else { struct snd_util_memblk *p = get_memblk(prev); blk->offset = p->offset + p->size; } blk->size = units; list_add(&blk->list, prev); hdr->nblocks++; hdr->used += units; return blk; } /* * allocate a memory block (with mutex) */ struct snd_util_memblk * snd_util_mem_alloc(struct snd_util_memhdr *hdr, int size) { struct snd_util_memblk *blk; mutex_lock(&hdr->block_mutex); blk = __snd_util_mem_alloc(hdr, size); mutex_unlock(&hdr->block_mutex); return blk; } /* * remove the block from linked-list and free resource * (without mutex) */ void __snd_util_mem_free(struct snd_util_memhdr *hdr, struct snd_util_memblk *blk) { list_del(&blk->list); hdr->nblocks--; hdr->used -= blk->size; kfree(blk); } /* * free a memory block (with mutex) */ int snd_util_mem_free(struct snd_util_memhdr *hdr, struct snd_util_memblk *blk) { if (snd_BUG_ON(!hdr || !blk)) return -EINVAL; mutex_lock(&hdr->block_mutex); __snd_util_mem_free(hdr, blk); mutex_unlock(&hdr->block_mutex); return 0; } /* * return available memory size */ int snd_util_mem_avail(struct snd_util_memhdr *hdr) { unsigned int size; mutex_lock(&hdr->block_mutex); size = hdr->size - hdr->used; mutex_unlock(&hdr->block_mutex); return size; } EXPORT_SYMBOL(snd_util_memhdr_new); EXPORT_SYMBOL(snd_util_memhdr_free); EXPORT_SYMBOL(snd_util_mem_alloc); EXPORT_SYMBOL(snd_util_mem_free); EXPORT_SYMBOL(snd_util_mem_avail); EXPORT_SYMBOL(__snd_util_mem_alloc); EXPORT_SYMBOL(__snd_util_mem_free); EXPORT_SYMBOL(__snd_util_memblk_new); /* * INIT part */ static int __init alsa_util_mem_init(void) { return 0; } static void __exit alsa_util_mem_exit(void) { } module_init(alsa_util_mem_init) module_exit(alsa_util_mem_exit) mode:
authorLinus Torvalds <torvalds@linux-foundation.org>2016-12-25 14:05:56 -0800
committerLinus Torvalds <torvalds@linux-foundation.org>2016-12-25 14:05:56 -0800
commitb272f732f888d4cf43c943a40c9aaa836f9b7431 (patch)
treeda9cac6b9d12b83592c16d3503c0e3f2f00f146f /include/trace/events/sunrpc.h
parent10bbe7599e2755d3f3e100103967788b8b5a4bce (diff)
parent008b69e4d52f2cbee3ed0d0502edd78155000b1a (diff)
Merge branch 'smp-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip
Pull SMP hotplug notifier removal from Thomas Gleixner: "This is the final cleanup of the hotplug notifier infrastructure. The series has been reintgrated in the last two days because there came a new driver using the old infrastructure via the SCSI tree. Summary: - convert the last leftover drivers utilizing notifiers - fixup for a completely broken hotplug user - prevent setup of already used states - removal of the notifiers - treewide cleanup of hotplug state names - consolidation of state space There is a sphinx based documentation pending, but that needs review from the documentation folks" * 'smp-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: irqchip/armada-xp: Consolidate hotplug state space irqchip/gic: Consolidate hotplug state space coresight/etm3/4x: Consolidate hotplug state space cpu/hotplug: Cleanup state names cpu/hotplug: Remove obsolete cpu hotplug register/unregister functions staging/lustre/libcfs: Convert to hotplug state machine scsi/bnx2i: Convert to hotplug state machine scsi/bnx2fc: Convert to hotplug state machine cpu/hotplug: Prevent overwriting of callbacks x86/msr: Remove bogus cleanup from the error path bus: arm-ccn: Prevent hotplug callback leak perf/x86/intel/cstate: Prevent hotplug callback leak ARM/imx/mmcd: Fix broken cpu hotplug handling scsi: qedi: Convert to hotplug state machine
Diffstat (limited to 'include/trace/events/sunrpc.h')