Linux-2.6.12-rc2v2.6.12-rc2

Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.

Let it rip!

1 files changed, 251 insertions, 0 deletions

diff --git a/net/ipv4/ipvs/ip_vs_sched.c b/net/ipv4/ipvs/ip_vs_sched.c
new file mode 100644
index 000000000000..0f7c56a225bd
--- /dev/null
+++ b/net/ipv4/ipvs/ip_vs_sched.c
@@ -0,0 +1,251 @@
+/*
+ * IPVS         An implementation of the IP virtual server support for the
+ *              LINUX operating system.  IPVS is now implemented as a module
+ *              over the Netfilter framework. IPVS can be used to build a
+ *              high-performance and highly available server based on a
+ *              cluster of servers.
+ *
+ * Version:     $Id: ip_vs_sched.c,v 1.13 2003/05/10 03:05:23 wensong Exp $
+ *
+ * Authors:     Wensong Zhang <wensong@linuxvirtualserver.org>
+ *              Peter Kese <peter.kese@ijs.si>
+ *
+ *              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.
+ *
+ * Changes:
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/sched.h>
+#include <linux/spinlock.h>
+#include <asm/string.h>
+#include <linux/kmod.h>
+
+#include <net/ip_vs.h>
+
+/*
+ *  IPVS scheduler list
+ */
+static LIST_HEAD(ip_vs_schedulers);
+
+/* lock for service table */
+static DEFINE_RWLOCK(__ip_vs_sched_lock);
+
+
+/*
+ *  Bind a service with a scheduler
+ */
+int ip_vs_bind_scheduler(struct ip_vs_service *svc,
+                         struct ip_vs_scheduler *scheduler)
+{
+        int ret;
+
+        if (svc == NULL) {
+                IP_VS_ERR("ip_vs_bind_scheduler(): svc arg NULL\n");
+                return -EINVAL;
+        }
+        if (scheduler == NULL) {
+                IP_VS_ERR("ip_vs_bind_scheduler(): scheduler arg NULL\n");
+                return -EINVAL;
+        }
+
+        svc->scheduler = scheduler;
+
+        if (scheduler->init_service) {
+                ret = scheduler->init_service(svc);
+                if (ret) {
+                        IP_VS_ERR("ip_vs_bind_scheduler(): init error\n");
+                        return ret;
+                }
+        }
+
+        return 0;
+}
+
+
+/*
+ *  Unbind a service with its scheduler
+ */
+int ip_vs_unbind_scheduler(struct ip_vs_service *svc)
+{
+        struct ip_vs_scheduler *sched;
+
+        if (svc == NULL) {
+                IP_VS_ERR("ip_vs_unbind_scheduler(): svc arg NULL\n");
+                return -EINVAL;
+        }
+
+        sched = svc->scheduler;
+        if (sched == NULL) {
+                IP_VS_ERR("ip_vs_unbind_scheduler(): svc isn't bound\n");
+                return -EINVAL;
+        }
+
+        if (sched->done_service) {
+                if (sched->done_service(svc) != 0) {
+                        IP_VS_ERR("ip_vs_unbind_scheduler(): done error\n");
+                        return -EINVAL;
+                }
+        }
+
+        svc->scheduler = NULL;
+        return 0;
+}
+
+
+/*
+ *  Get scheduler in the scheduler list by name
+ */
+static struct ip_vs_scheduler *ip_vs_sched_getbyname(const char *sched_name)
+{
+        struct ip_vs_scheduler *sched;
+
+        IP_VS_DBG(2, "ip_vs_sched_getbyname(): sched_name \"%s\"\n",
+                  sched_name);
+
+        read_lock_bh(&__ip_vs_sched_lock);
+
+        list_for_each_entry(sched, &ip_vs_schedulers, n_list) {
+                /*
+                 * Test and get the modules atomically
+                 */
+                if (sched->module && !try_module_get(sched->module)) {
+                        /*
+                         * This scheduler is just deleted
+                         */
+                        continue;
+                }
+                if (strcmp(sched_name, sched->name)==0) {
+                        /* HIT */
+                        read_unlock_bh(&__ip_vs_sched_lock);
+                        return sched;
+                }
+                if (sched->module)
+                        module_put(sched->module);
+        }
+
+        read_unlock_bh(&__ip_vs_sched_lock);
+        return NULL;
+}
+
+
+/*
+ *  Lookup scheduler and try to load it if it doesn't exist
+ */
+struct ip_vs_scheduler *ip_vs_scheduler_get(const char *sched_name)
+{
+        struct ip_vs_scheduler *sched;
+
+        /*
+         *  Search for the scheduler by sched_name
+         */
+        sched = ip_vs_sched_getbyname(sched_name);
+
+        /*
+         *  If scheduler not found, load the module and search again
+         */
+        if (sched == NULL) {
+                request_module("ip_vs_%s", sched_name);
+                sched = ip_vs_sched_getbyname(sched_name);
+        }
+
+        return sched;
+}
+
+void ip_vs_scheduler_put(struct ip_vs_scheduler *scheduler)
+{
+        if (scheduler->module)
+                module_put(scheduler->module);
+}
+
+
+/*
+ *  Register a scheduler in the scheduler list
+ */
+int register_ip_vs_scheduler(struct ip_vs_scheduler *scheduler)
+{
+        struct ip_vs_scheduler *sched;
+
+        if (!scheduler) {
+                IP_VS_ERR("register_ip_vs_scheduler(): NULL arg\n");
+                return -EINVAL;
+        }
+
+        if (!scheduler->name) {
+                IP_VS_ERR("register_ip_vs_scheduler(): NULL scheduler_name\n");
+                return -EINVAL;
+        }
+
+        /* increase the module use count */
+        ip_vs_use_count_inc();
+
+        /*
+         *  Make sure that the scheduler with this name doesn't exist
+         *  in the scheduler list.
+         */
+        sched = ip_vs_sched_getbyname(scheduler->name);
+        if (sched) {
+                ip_vs_scheduler_put(sched);
+                ip_vs_use_count_dec();
+                IP_VS_ERR("register_ip_vs_scheduler(): [%s] scheduler "
+                          "already existed in the system\n", scheduler->name);
+                return -EINVAL;
+        }
+
+        write_lock_bh(&__ip_vs_sched_lock);
+
+        if (scheduler->n_list.next != &scheduler->n_list) {
+                write_unlock_bh(&__ip_vs_sched_lock);
+                ip_vs_use_count_dec();
+                IP_VS_ERR("register_ip_vs_scheduler(): [%s] scheduler "
+                          "already linked\n", scheduler->name);
+                return -EINVAL;
+        }
+
+        /*
+         *      Add it into the d-linked scheduler list
+         */
+        list_add(&scheduler->n_list, &ip_vs_schedulers);
+        write_unlock_bh(&__ip_vs_sched_lock);
+
+        IP_VS_INFO("[%s] scheduler registered.\n", scheduler->name);
+
+        return 0;
+}
+
+
+/*
+ *  Unregister a scheduler from the scheduler list
+ */
+int unregister_ip_vs_scheduler(struct ip_vs_scheduler *scheduler)
+{
+        if (!scheduler) {
+                IP_VS_ERR( "unregister_ip_vs_scheduler(): NULL arg\n");
+                return -EINVAL;
+        }
+
+        write_lock_bh(&__ip_vs_sched_lock);
+        if (scheduler->n_list.next == &scheduler->n_list) {
+                write_unlock_bh(&__ip_vs_sched_lock);
+                IP_VS_ERR("unregister_ip_vs_scheduler(): [%s] scheduler "
+                          "is not in the list. failed\n", scheduler->name);
+                return -EINVAL;
+        }
+
+        /*
+         *      Remove it from the d-linked scheduler list
+         */
+        list_del(&scheduler->n_list);
+        write_unlock_bh(&__ip_vs_sched_lock);
+
+        /* decrease the module use count */
+        ip_vs_use_count_dec();
+
+        IP_VS_INFO("[%s] scheduler unregistered.\n", scheduler->name);
+
+        return 0;
+}