[11/many] acrypto: crypto_main.c

[Evgeniy Polyakov <johnpol@2ka.mipt.ru>]

--- /tmp/empty/crypto_main.c	1970-01-01 03:00:00.000000000 +0300
+++ ./acrypto/crypto_main.c	2005-03-07 20:35:36.000000000 +0300
@@ -0,0 +1,374 @@
+/*
+ * 	crypto_main.c
+ *
+ * Copyright (c) 2004 Evgeniy Polyakov <johnpol@2ka.mipt.ru>
+ * 
+ *
+ * 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 <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/types.h>
+#include <linux/list.h>
+#include <linux/slab.h>
+#include <linux/interrupt.h>
+#include <linux/spinlock.h>
+
+#include "acrypto.h"
+#include "crypto_lb.h"
+#include "crypto_conn.h"
+#include "crypto_route.h"
+#include "crypto_user_ioctl.h"
+
+int force_lb_remove;
+module_param(force_lb_remove, int, 0);
+
+struct crypto_device main_crypto_device;
+
+extern struct bus_type crypto_bus_type;
+extern struct device_driver crypto_driver;
+extern struct class crypto_class;
+extern struct device crypto_dev;
+
+extern struct class_device_attribute class_device_attr_devices;
+extern struct class_device_attribute class_device_attr_lbs;
+
+static void dump_ci(struct crypto_session_initializer *ci)
+{
+	dprintk("%llu [%llu] op=%04u, type=%04x, mode=%04x, priority=%04x",
+		ci->id, ci->dev_id,
+		ci->operation, ci->type, ci->mode, ci->priority);
+}
+
+void __crypto_session_insert(struct crypto_device *dev, struct crypto_session *s)
+{
+	struct crypto_session *__s;
+
+	if (unlikely(list_empty(&dev->session_list))) {
+		list_add(&s->dev_queue_entry, &dev->session_list);
+	} else {
+		int inserted = 0;
+
+		list_for_each_entry(__s, &dev->session_list, dev_queue_entry) {
+			if (__s->ci.priority < s->ci.priority) {
+				list_add_tail(&s->dev_queue_entry, &__s->dev_queue_entry);
+				inserted = 1;
+				break;
+			}
+		}
+
+		if (!inserted)
+			list_add_tail(&s->dev_queue_entry, &dev->session_list);
+	}
+
+	dump_ci(&s->ci);
+	dprintk(" added to crypto device %s [%d].\n", dev->name, atomic_read(&dev->refcnt));
+}
+
+void crypto_session_insert_main(struct crypto_device *dev, struct crypto_session *s)
+{
+	struct crypto_session *__s;
+
+	spin_lock_irq(&dev->session_lock);
+
+	crypto_device_get(dev);
+	if (unlikely(list_empty(&dev->session_list))) {
+		list_add(&s->main_queue_entry, &dev->session_list);
+	} else {
+		int inserted = 0;
+
+		list_for_each_entry(__s, &dev->session_list, main_queue_entry) {
+			if (__s->ci.priority < s->ci.priority) {
+				list_add_tail(&s->main_queue_entry,
+					      &__s->main_queue_entry);
+				inserted = 1;
+				break;
+			}
+		}
+
+		if (!inserted)
+			list_add_tail(&s->main_queue_entry, &dev->session_list);
+	}
+
+	spin_unlock_irq(&dev->session_lock);
+}
+
+void crypto_session_insert(struct crypto_device *dev, struct crypto_session *s)
+{
+	spin_lock_irq(&dev->session_lock);
+	__crypto_session_insert(dev, s);
+	spin_unlock_irq(&dev->session_lock);
+}
+
+void crypto_session_destroy(struct crypto_session *s)
+{
+	if (s->data.priv_size && s->data.priv)
+		kfree(s->data.priv);
+
+	if (session_from_cache(s))
+		kmem_cache_free(s->pool_dev->session_cache, s);
+	else
+		mempool_free(s, s->pool_dev->session_pool);
+}
+
+struct crypto_session *crypto_session_create(struct crypto_session_initializer *ci, struct crypto_data *d)
+{
+	struct crypto_device *dev = &main_crypto_device;
+	struct crypto_device *ldev;
+	struct crypto_session *s;
+	int err;
+
+	if (d->priv_size > CRYPTO_MAX_PRIV_SIZE) {
+		dprintk("priv_size %u is too big, maximum allowed %u.\n",
+			d->priv_size, CRYPTO_MAX_PRIV_SIZE);
+		return NULL;
+	}
+	
+	ldev = crypto_lb_find_device(ci, d);
+	if (!ldev) {
+		dprintk("Cannot find suitable device for [%02x.%02x.%02x.%02x].\n",
+				ci->operation, ci->mode, ci->type, ci->priority);
+		return NULL;
+	}
+	
+	s = mempool_alloc(ldev->session_pool, GFP_ATOMIC);
+	if (!s) {
+		ldev->stat.pool_failed++;
+
+		s = kmem_cache_alloc(ldev->session_cache, GFP_ATOMIC);
+		if (!s) {
+			ldev->stat.kmem_failed++;
+			goto err_out_device_put;
+		}
+
+		mark_session_from_cache(s);
+	}
+	
+	s->pool_dev = ldev;
+
+	crypto_route_head_init(&s->route_list);
+	INIT_LIST_HEAD(&s->dev_queue_entry);
+	INIT_LIST_HEAD(&s->main_queue_entry);
+
+	spin_lock_init(&s->lock);
+
+	memcpy(&s->ci, ci, sizeof(s->ci));
+	memcpy(&s->data, d, sizeof(s->data));
+
+	s->data.priv = NULL;
+	if (d->priv_size) {
+		s->data.priv = kmalloc(d->priv_size, GFP_ATOMIC);
+		if (!s->data.priv)
+			goto err_out_session_free;
+
+		if (d->priv)
+			memcpy(s->data.priv, d->priv, d->priv_size);
+	}
+	else
+		s->data.priv = d->priv;
+
+	s->ci.id = dev->sid++;
+	s->ci.dev_id = ldev->sid++;
+	s->ci.flags = 0;
+
+	err = crypto_route_add_direct(ldev, s, ci);
+	if (err) {
+		dprintk("Can not add route to device %s.\n", ldev->name);
+		goto err_out_session_free;
+	}
+
+	return s;
+
+err_out_session_free:
+	crypto_session_destroy(s);
+err_out_device_put:
+	crypto_device_put(ldev);
+
+	return NULL;
+}
+
+void crypto_session_add(struct crypto_session *s)
+{
+	struct crypto_device *ldev;
+	struct crypto_device *dev = &main_crypto_device;
+
+	ldev = crypto_route_get_current_device(s);
+	BUG_ON(!ldev);		/* This can not happen. */
+
+	spin_lock_irq(&s->lock);
+	crypto_session_insert(ldev, s);
+	crypto_device_put(ldev);
+	crypto_session_insert_main(dev, s);
+	spin_unlock_irq(&s->lock);
+
+	if (ldev->data_ready)
+		ldev->data_ready(ldev);
+}
+
+struct crypto_session *crypto_session_alloc(struct crypto_session_initializer *ci, struct crypto_data *d)
+{
+	struct crypto_session *s;
+
+	s = crypto_session_create(ci, d);
+	if (!s)
+		return NULL;
+
+	crypto_session_add(s);
+
+	return s;
+}
+
+void crypto_session_dequeue_route(struct crypto_session *s)
+{
+	struct crypto_route *rt;
+	struct crypto_device *dev;
+
+	BUG_ON(crypto_route_queue_len(s) > 1);
+
+	while ((rt = crypto_route_dequeue(s))) {
+		dev = rt->dev;
+
+		dprintk(KERN_INFO "Removing route entry for device %s.\n", dev->name);
+
+		spin_lock_irq(&dev->session_lock);
+		list_del_init(&s->dev_queue_entry);
+		spin_unlock_irq(&dev->session_lock);
+
+		crypto_route_free(rt);
+	}
+}
+
+void __crypto_session_dequeue_main(struct crypto_session *s)
+{
+	struct crypto_device *dev = &main_crypto_device;
+
+	list_del(&s->main_queue_entry);
+	crypto_device_put(dev);
+}
+
+void crypto_session_dequeue_main(struct crypto_session *s)
+{
+	struct crypto_device *dev = &main_crypto_device;
+
+	spin_lock_irq(&dev->session_lock);
+
+	__crypto_session_dequeue_main(s);
+
+	spin_unlock_irq(&dev->session_lock);
+}
+
+int __devinit cmain_init(void)
+{
+	struct crypto_device *dev = &main_crypto_device;
+	int err;
+
+	snprintf(dev->name, sizeof(dev->name), "crypto_sessions");
+
+	err = bus_register(&crypto_bus_type);
+	if (err) {
+		dprintk(KERN_ERR "Failed to register crypto bus: err=%d.\n",
+			err);
+		return err;
+	}
+
+	err = driver_register(&crypto_driver);
+	if (err) {
+		dprintk(KERN_ERR "Failed to register crypto driver: err=%d.\n",
+			err);
+		goto err_out_bus_unregister;
+	}
+
+	err = class_register(&crypto_class);
+	if (err) {
+		dprintk(KERN_ERR "Failed to register crypto class: err=%d.\n",
+			err);
+		goto err_out_driver_unregister;
+	}
+
+	err = crypto_lb_init();
+	if (err)
+		goto err_out_class_unregister;
+
+	err = crypto_conn_init();
+	if (err)
+		goto err_out_crypto_lb_fini;
+
+	err = __crypto_device_add(dev);
+	if (err)
+		goto err_out_crypto_conn_fini;
+
+	err = class_device_create_file(&dev->class_device, &class_device_attr_devices);
+	if (err)
+		dprintk("Failed to create \"devices\" attribute: err=%d.\n", err);
+
+	err = class_device_create_file(&dev->class_device, &class_device_attr_lbs);
+	if (err)
+		dprintk("Failed to create \"lbs\" attribute: err=%d.\n", err);
+
+	err = crypto_user_ioctl_init();
+	if (err)
+		goto err_out_remove_files;
+
+	return 0;
+
+err_out_remove_files:
+	class_device_remove_file(&dev->class_device, &class_device_attr_devices);
+	class_device_remove_file(&dev->class_device, &class_device_attr_lbs);
+	__crypto_device_remove(dev);
+err_out_crypto_conn_fini:
+	crypto_conn_fini();
+err_out_crypto_lb_fini:
+	crypto_lb_fini();
+err_out_class_unregister:
+	class_unregister(&crypto_class);
+err_out_driver_unregister:
+	driver_unregister(&crypto_driver);
+err_out_bus_unregister:
+	bus_unregister(&crypto_bus_type);
+
+	return err;
+}
+
+void __devexit cmain_fini(void)
+{
+	struct crypto_device *dev = &main_crypto_device;
+
+	crypto_user_ioctl_fini();
+	
+	class_device_remove_file(&dev->class_device, &class_device_attr_devices);
+	class_device_remove_file(&dev->class_device, &class_device_attr_lbs);
+	__crypto_device_remove(dev);
+
+	crypto_conn_fini();
+	crypto_lb_fini();
+
+	class_unregister(&crypto_class);
+	driver_unregister(&crypto_driver);
+	bus_unregister(&crypto_bus_type);
+}
+
+module_init(cmain_init);
+module_exit(cmain_fini);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Evgeniy Polyakov <johnpol@2ka.mipt.ru>");
+MODULE_DESCRIPTION("Asynchronous crypto layer.");
+
+EXPORT_SYMBOL(crypto_session_alloc);
+EXPORT_SYMBOL_GPL(crypto_session_create);
+EXPORT_SYMBOL_GPL(crypto_session_add);
+EXPORT_SYMBOL_GPL(crypto_session_dequeue_route);