litmus-rt.git - The LITMUS^RT kernel.

	Commit message (Collapse)	Author	Age
*	bzip2/lzma: library support for gzip, bzip2 and lzma decompression	Alain Knaff	2009-01-04
	Impact: Replaces inflate.c with a wrapper around zlib_inflate; new library code This is the first part of the bzip2/lzma patch The bzip patch is based on an idea by Christian Ludwig, includes support for compressing the kernel with bzip2 or lzma rather than gzip. Both compressors give smaller sizes than gzip. Lzma's decompresses faster than bzip2. It also supports ramdisks and initramfs' compressed using these two compressors. The functionality has been successfully used for a couple of years by the udpcast project This version applies to "tip" kernel 2.6.28 This part contains: - changed inflate.c to accomodate rest of patch - implementation of bzip2 compression (not used at this stage yet) - implementation of lzma compression (not used at this stage yet) - Makefile routines to support bzip2 and lzma kernel compression Signed-off-by: Alain Knaff <alain@knaff.lu> Signed-off-by: H. Peter Anvin <hpa@zytor.com>

/* * Copyright(c) 2007 - 2009 Intel Corporation. All rights reserved. * * 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. * * The full GNU General Public License is included in this distribution in the * file called COPYING. */ /* * This driver supports an interface for DCA clients and providers to meet. */ #include <linux/kernel.h> #include <linux/notifier.h> #include <linux/device.h> #include <linux/dca.h> #include <linux/slab.h> #define DCA_VERSION "1.12.1" MODULE_VERSION(DCA_VERSION); MODULE_LICENSE("GPL"); MODULE_AUTHOR("Intel Corporation"); static DEFINE_SPINLOCK(dca_lock); static LIST_HEAD(dca_domains); static struct pci_bus *dca_pci_rc_from_dev(struct device *dev) { struct pci_dev *pdev = to_pci_dev(dev); struct pci_bus *bus = pdev->bus; while (bus->parent) bus = bus->parent; return bus; } static struct dca_domain *dca_allocate_domain(struct pci_bus *rc) { struct dca_domain *domain; domain = kzalloc(sizeof(*domain), GFP_NOWAIT); if (!domain) return NULL; INIT_LIST_HEAD(&domain->dca_providers); domain->pci_rc = rc; return domain; } static void dca_free_domain(struct dca_domain *domain) { list_del(&domain->node); kfree(domain); } static struct dca_domain *dca_find_domain(struct pci_bus *rc) { struct dca_domain *domain; list_for_each_entry(domain, &dca_domains, node) if (domain->pci_rc == rc) return domain; return NULL; } static struct dca_domain *dca_get_domain(struct device *dev) { struct pci_bus *rc; struct dca_domain *domain; rc = dca_pci_rc_from_dev(dev); domain = dca_find_domain(rc); if (!domain) { domain = dca_allocate_domain(rc); if (domain) list_add(&domain->node, &dca_domains); } return domain; } static struct dca_provider *dca_find_provider_by_dev(struct device *dev) { struct dca_provider *dca; struct pci_bus *rc; struct dca_domain *domain; if (dev) { rc = dca_pci_rc_from_dev(dev); domain = dca_find_domain(rc); if (!domain) return NULL; } else { if (!list_empty(&dca_domains)) domain = list_first_entry(&dca_domains, struct dca_domain, node); else return NULL; } list_for_each_entry(dca, &domain->dca_providers, node) if ((!dev) || (dca->ops->dev_managed(dca, dev))) return dca; return NULL; } /** * dca_add_requester - add a dca client to the list * @dev - the device that wants dca service */ int dca_add_requester(struct device *dev) { struct dca_provider *dca; int err, slot = -ENODEV; unsigned long flags; struct pci_bus *pci_rc; struct dca_domain *domain; if (!dev) return -EFAULT; spin_lock_irqsave(&dca_lock, flags); /* check if the requester has not been added already */ dca = dca_find_provider_by_dev(dev); if (dca) { spin_unlock_irqrestore(&dca_lock, flags); return -EEXIST; } pci_rc = dca_pci_rc_from_dev(dev); domain = dca_find_domain(pci_rc); if (!domain) { spin_unlock_irqrestore(&dca_lock, flags); return -ENODEV; } list_for_each_entry(dca, &domain->dca_providers, node) { slot = dca->ops->add_requester(dca, dev); if (slot >= 0) break; } spin_unlock_irqrestore(&dca_lock, flags); if (slot < 0) return slot; err = dca_sysfs_add_req(dca, dev, slot); if (err) { spin_lock_irqsave(&dca_lock, flags); if (dca == dca_find_provider_by_dev(dev)) dca->ops->remove_requester(dca, dev); spin_unlock_irqrestore(&dca_lock, flags); return err; } return 0; } EXPORT_SYMBOL_GPL(dca_add_requester); /** * dca_remove_requester - remove a dca client from the list * @dev - the device that wants dca service */ int dca_remove_requester(struct device *dev) { struct dca_provider *dca; int slot; unsigned long flags; if (!dev) return -EFAULT; spin_lock_irqsave(&dca_lock, flags); dca = dca_find_provider_by_dev(dev); if (!dca) { spin_unlock_irqrestore(&dca_lock, flags); return -ENODEV; } slot = dca->ops->remove_requester(dca, dev); spin_unlock_irqrestore(&dca_lock, flags); if (slot < 0) return slot; dca_sysfs_remove_req(dca, slot); return 0; } EXPORT_SYMBOL_GPL(dca_remove_requester); /** * dca_common_get_tag - return the dca tag (serves both new and old api) * @dev - the device that wants dca service * @cpu - the cpuid as returned by get_cpu() */ u8 dca_common_get_tag(struct device *dev, int cpu) { struct dca_provider *dca; u8 tag; unsigned long flags; spin_lock_irqsave(&dca_lock, flags); dca = dca_find_provider_by_dev(dev); if (!dca) { spin_unlock_irqrestore(&dca_lock, flags); return -ENODEV; } tag = dca->ops->get_tag(dca, dev, cpu); spin_unlock_irqrestore(&dca_lock, flags); return tag; } /** * dca3_get_tag - return the dca tag to the requester device * for the given cpu (new api) * @dev - the device that wants dca service * @cpu - the cpuid as returned by get_cpu() */ u8 dca3_get_tag(struct device *dev, int cpu) { if (!dev) return -EFAULT; return dca_common_get_tag(dev, cpu); } EXPORT_SYMBOL_GPL(dca3_get_tag); /** * dca_get_tag - return the dca tag for the given cpu (old api) * @cpu - the cpuid as returned by get_cpu() */ u8 dca_get_tag(int cpu) { struct device *dev = NULL; return dca_common_get_tag(dev, cpu); } EXPORT_SYMBOL_GPL(dca_get_tag); /** * alloc_dca_provider - get data struct for describing a dca provider * @ops - pointer to struct of dca operation function pointers * @priv_size - size of extra mem to be added for provider's needs */ struct dca_provider *alloc_dca_provider(struct dca_ops *ops, int priv_size) { struct dca_provider *dca; int alloc_size; alloc_size = (sizeof(*dca) + priv_size); dca = kzalloc(alloc_size, GFP_KERNEL); if (!dca) return NULL; dca->ops = ops; return dca; } EXPORT_SYMBOL_GPL(alloc_dca_provider); /** * free_dca_provider - release the dca provider data struct * @ops - pointer to struct of dca operation function pointers * @priv_size - size of extra mem to be added for provider's needs */ void free_dca_provider(struct dca_provider *dca) { kfree(dca); } EXPORT_SYMBOL_GPL(free_dca_provider); static BLOCKING_NOTIFIER_HEAD(dca_provider_chain); /** * register_dca_provider - register a dca provider * @dca - struct created by alloc_dca_provider() * @dev - device providing dca services */ int register_dca_provider(struct dca_provider *dca, struct device *dev) { int err; unsigned long flags; struct dca_domain *domain; err = dca_sysfs_add_provider(dca, dev); if (err) return err; spin_lock_irqsave(&dca_lock, flags); domain = dca_get_domain(dev); if (!domain) { spin_unlock_irqrestore(&dca_lock, flags); return -ENODEV; } list_add(&dca->node, &domain->dca_providers); spin_unlock_irqrestore(&dca_lock, flags); blocking_notifier_call_chain(&dca_provider_chain, DCA_PROVIDER_ADD, NULL); return 0; } EXPORT_SYMBOL_GPL(register_dca_provider); /** * unregister_dca_provider - remove a dca provider * @dca - struct created by alloc_dca_provider() */ void unregister_dca_provider(struct dca_provider *dca, struct device *dev) { unsigned long flags; struct pci_bus *pci_rc; struct dca_domain *domain; blocking_notifier_call_chain(&dca_provider_chain, DCA_PROVIDER_REMOVE, NULL); spin_lock_irqsave(&dca_lock, flags); list_del(&dca->node); pci_rc = dca_pci_rc_from_dev(dev); domain = dca_find_domain(pci_rc); if (list_empty(&domain->dca_providers)) dca_free_domain(domain); spin_unlock_irqrestore(&dca_lock, flags); dca_sysfs_remove_provider(dca); } EXPORT_SYMBOL_GPL(unregister_dca_provider); /** * dca_register_notify - register a client's notifier callback */ void dca_register_notify(struct notifier_block *nb) { blocking_notifier_chain_register(&dca_provider_chain, nb); } EXPORT_SYMBOL_GPL(dca_register_notify); /** * dca_unregister_notify - remove a client's notifier callback */ void dca_unregister_notify(struct notifier_block *nb) { blocking_notifier_chain_unregister(&dca_provider_chain, nb); } EXPORT_SYMBOL_GPL(dca_unregister_notify); static int __init dca_init(void) { pr_info("dca service started, version %s\n", DCA_VERSION); return dca_sysfs_init(); } static void __exit dca_exit(void) { dca_sysfs_exit(); } arch_initcall(dca_init); module_exit(dca_exit);